diff --git a/README.md b/README.md
index ca99d59bb8..cd0560e624 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@ to find and inspect the patch diffs.
  * LLVM, LLD, Clang 19.1.0
  * zlib 1.3.1
  * zstd 1.5.2
- * zig 0.14.0-dev.1876+41dbd0d0d
+ * zig 0.14.0-dev.2246+bfcf18c5a
 
 For other versions, check the git tags of this repository.
 
@@ -96,16 +96,16 @@ is more portable across Linux distributions.
 |----------------------------|----------------|
 | `aarch64-linux-gnu`        | OK             |
 | `aarch64-linux-musl`       | OK             |
-| `aarch64-macos-none`       | [#194](https://github.com/ziglang/zig-bootstrap/issues/194) |
+| `aarch64-macos-none`       | OK             |
 | `aarch64-windows-gnu`      | OK             |
 | `aarch64_be-linux-gnu`     | OK             |
 | `aarch64_be-linux-musl`    | OK             |
-| `arm-linux-gnueabi`        | [#101](https://github.com/ziglang/zig-bootstrap/issues/101) |
-| `arm-linux-gnueabihf`      | [#102](https://github.com/ziglang/zig-bootstrap/issues/102) |
+| `arm-linux-gnueabi`        | OK             |
+| `arm-linux-gnueabihf`      | OK             |
 | `arm-linux-musleabi`       | OK             |
 | `arm-linux-musleabihf`     | OK             |
-| `armeb-linux-gnueabi`      | [#96](https://github.com/ziglang/zig-bootstrap/issues/96) |
-| `armeb-linux-gnueabihf`    | [#97](https://github.com/ziglang/zig-bootstrap/issues/97) |
+| `armeb-linux-gnueabi`      | OK             |
+| `armeb-linux-gnueabihf`    | OK             |
 | `armeb-linux-musleabi`     | OK             |
 | `armeb-linux-musleabihf`   | OK             |
 | `loongarch64-linux-gnu`    | OK             |
@@ -158,7 +158,6 @@ is more portable across Linux distributions.
 
 #### Other Notable Targets Known to Work
 
- * `aarch64-macos-none` with mcpu value of `apple_a14`.
  * `arm-linux-musleabi` with mcpu value of `generic+v6kz`. This produces a
    build of Zig that runs on the RPi 1 and RPi Zero.
    - If you want to produce a build for this CPU exactly, use `arm1176jzf_s`.
diff --git a/build b/build
index b1c233233a..4923b5c740 100755
--- a/build
+++ b/build
@@ -7,7 +7,7 @@ TARGET="$1" # Example: riscv64-linux-gnu
 MCPU="$2" # Examples: `baseline`, `native`, `generic+v7a`, or `arm1176jzf_s`
 
 ROOTDIR="$(pwd)"
-ZIG_VERSION="0.14.0-dev.1876+41dbd0d0d"
+ZIG_VERSION="0.14.0-dev.2246+bfcf18c5a"
 
 TARGET_OS_AND_ABI=${TARGET#*-} # Example: linux-gnu
 
diff --git a/build.bat b/build.bat
index 331bd1d043..28daafd711 100644
--- a/build.bat
+++ b/build.bat
@@ -35,7 +35,7 @@ if "%VSCMD_ARG_HOST_ARCH%"=="x86" set OUTDIR=out-win-x86
 
 set ROOTDIR=%~dp0
 set "ROOTDIR_CMAKE=%ROOTDIR:\=/%"
-set ZIG_VERSION="0.14.0-dev.1876+41dbd0d0d"
+set ZIG_VERSION="0.14.0-dev.2246+bfcf18c5a"
 set JOBS_ARG=
 
 pushd %ROOTDIR%
diff --git a/zig/CMakeLists.txt b/zig/CMakeLists.txt
index e71f799b54..ca20a702bc 100644
--- a/zig/CMakeLists.txt
+++ b/zig/CMakeLists.txt
@@ -376,7 +376,7 @@ set(ZIG_STAGE2_SOURCES
     lib/std/Target.zig
     lib/std/Target/Query.zig
     lib/std/Target/aarch64.zig
-    lib/std/Target/amdgpu.zig
+    lib/std/Target/amdgcn.zig
     lib/std/Target/arm.zig
     lib/std/Target/avr.zig
     lib/std/Target/bpf.zig
@@ -522,6 +522,7 @@ set(ZIG_STAGE2_SOURCES
     src/Sema.zig
     src/Sema/bitcast.zig
     src/Sema/comptime_ptr_access.zig
+    src/ThreadSafeQueue.zig
     src/Type.zig
     src/Value.zig
     src/Zcu.zig
@@ -591,30 +592,25 @@ set(ZIG_STAGE2_SOURCES
     src/link.zig
     src/link/C.zig
     src/link/Coff.zig
-    src/link/Coff/Atom.zig
-    src/link/Coff/ImportTable.zig
-    src/link/Coff/Object.zig
-    src/link/Coff/Relocation.zig
-    src/link/Coff/lld.zig
     src/link/Dwarf.zig
     src/link/Elf.zig
     src/link/Elf/Archive.zig
     src/link/Elf/Atom.zig
     src/link/Elf/AtomList.zig
-    src/link/Elf/LdScript.zig
     src/link/Elf/LinkerDefined.zig
+    src/link/Elf/Merge.zig
     src/link/Elf/Object.zig
     src/link/Elf/SharedObject.zig
     src/link/Elf/Symbol.zig
+    src/link/Elf/Thunk.zig
     src/link/Elf/ZigObject.zig
     src/link/Elf/eh_frame.zig
     src/link/Elf/file.zig
     src/link/Elf/gc.zig
-    src/link/Elf/merge_section.zig
     src/link/Elf/relocatable.zig
     src/link/Elf/relocation.zig
     src/link/Elf/synthetic_sections.zig
-    src/link/Elf/Thunk.zig
+    src/link/LdScript.zig
     src/link/MachO.zig
     src/link/MachO/Archive.zig
     src/link/MachO/Atom.zig
@@ -652,12 +648,9 @@ set(ZIG_STAGE2_SOURCES
     src/link/StringTable.zig
     src/link/Wasm.zig
     src/link/Wasm/Archive.zig
-    src/link/Wasm/Atom.zig
     src/link/Wasm/Object.zig
     src/link/Wasm/Symbol.zig
     src/link/Wasm/ZigObject.zig
-    src/link/Wasm/file.zig
-    src/link/Wasm/types.zig
     src/link/aarch64.zig
     src/link/riscv.zig
     src/link/table_section.zig
@@ -834,11 +827,6 @@ else()
   endif()
 endif()
 
-option(ZIG2_NO_RTLIB "Build zig2 without linking to a compiler runtime library (for `zig cc` only)" OFF)
-if(ZIG2_NO_RTLIB)
-  set(ZIG2_LINK_FLAGS "${ZIG2_LINK_FLAGS} -rtlib=none")
-endif()
-
 set(ZIG1_WASM_MODULE "${PROJECT_SOURCE_DIR}/stage1/zig1.wasm")
 set(ZIG1_C_SOURCE "${PROJECT_BINARY_DIR}/zig1.c")
 set(ZIG2_C_SOURCE "${PROJECT_BINARY_DIR}/zig2.c")
diff --git a/zig/bootstrap.c b/zig/bootstrap.c
index f341740a0e..cbbc65cf9b 100644
--- a/zig/bootstrap.c
+++ b/zig/bootstrap.c
@@ -123,7 +123,7 @@ int main(int argc, char **argv) {
         if (f == NULL)
             panic("unable to open config.zig for writing");
 
-        const char *zig_version = "0.14.0-dev.1876+41dbd0d0d";
+        const char *zig_version = "0.14.0-dev.2246+bfcf18c5a";
 
         int written = fprintf(f,
             "pub const have_llvm = false;\n"
diff --git a/zig/build.zig b/zig/build.zig
index a5f4cd5675..633d11419f 100644
--- a/zig/build.zig
+++ b/zig/build.zig
@@ -32,20 +32,17 @@ pub fn build(b: *std.Build) !void {
     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;
-    const enable_tidy = b.option(bool, "enable-tidy", "Check langref output HTML validity") orelse false;
+    const enable_superhtml = b.option(bool, "enable-superhtml", "Check langref output HTML validity") orelse false;
 
     const langref_file = generateLangRef(b);
     const install_langref = b.addInstallFileWithDir(langref_file, .prefix, "doc/langref.html");
-    const check_langref = tidyCheck(b, langref_file);
-    if (enable_tidy) install_langref.step.dependOn(check_langref);
-    // Checking autodocs is disabled because tidy gives a false positive:
-    // line 304 column 9 - Warning: moved <style> tag to <head>! fix-style-tags: no to avoid.
-    // I noticed that `--show-warnings no` still incorrectly causes exit code 1.
-    // I was unable to find an alternative to tidy.
-    //const check_autodocs = tidyCheck(b, b.path("lib/docs/index.html"));
-    if (enable_tidy) {
+    const check_langref = superHtmlCheck(b, langref_file);
+    if (enable_superhtml) install_langref.step.dependOn(check_langref);
+
+    const check_autodocs = superHtmlCheck(b, b.path("lib/docs/index.html"));
+    if (enable_superhtml) {
         test_step.dependOn(check_langref);
-        //test_step.dependOn(check_autodocs);
+        test_step.dependOn(check_autodocs);
     }
     if (!skip_install_langref) {
         b.getInstallStep().dependOn(&install_langref.step);
@@ -647,7 +644,7 @@ fn addCompilerStep(b: *std.Build, options: AddCompilerStepOptions) *std.Build.St
         .root_source_file = b.path("src/main.zig"),
         .target = options.target,
         .optimize = options.optimize,
-        .max_rss = 7_500_000_000,
+        .max_rss = 7_800_000_000,
         .strip = options.strip,
         .sanitize_thread = options.sanitize_thread,
         .single_threaded = options.single_threaded,
@@ -1358,11 +1355,11 @@ fn generateLangRef(b: *std.Build) std.Build.LazyPath {
     return docgen_cmd.addOutputFileArg("langref.html");
 }
 
-fn tidyCheck(b: *std.Build, html_file: std.Build.LazyPath) *std.Build.Step {
-    const run_tidy = b.addSystemCommand(&.{
-        "tidy", "--drop-empty-elements", "no", "-qe",
+fn superHtmlCheck(b: *std.Build, html_file: std.Build.LazyPath) *std.Build.Step {
+    const run_superhtml = b.addSystemCommand(&.{
+        "superhtml", "check",
     });
-    run_tidy.addFileArg(html_file);
-    run_tidy.expectExitCode(0);
-    return &run_tidy.step;
+    run_superhtml.addFileArg(html_file);
+    run_superhtml.expectExitCode(0);
+    return &run_superhtml.step;
 }
diff --git a/zig/doc/langref.html.in b/zig/doc/langref.html.in
index 54b923d0d9..3ed8d9d3ae 100644
--- a/zig/doc/langref.html.in
+++ b/zig/doc/langref.html.in
@@ -2190,6 +2190,7 @@ or
         <li>An {#link|enum#} field uses exactly the bit width of its integer tag type.</li>
         <li>A {#link|packed union#} field uses exactly the bit width of the union field with
         the largest bit width.</li>
+        <li>Packed structs support equality operators.</li>
       </ul>
       <p>
       This means that a {#syntax#}packed struct{#endsyntax#} can participate
@@ -2240,6 +2241,12 @@ or
       </p>
       {#code|test_aligned_struct_fields.zig#}
 
+      <p>
+      Equating packed structs results in a comparison of the backing integer, 
+      and only works for the `==` and `!=` operators.
+      </p>
+      {#code|test_packed_struct_equality.zig#}
+
       <p>
       Using packed structs with {#link|volatile#} is problematic, and may be a compile error in the future.
       For details on this subscribe to
@@ -4616,7 +4623,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
       {#header_close#}
 
       {#header_open|@compileLog#}
-      <pre>{#syntax#}@compileLog(args: ...) void{#endsyntax#}</pre>
+      <pre>{#syntax#}@compileLog(...) void{#endsyntax#}</pre>
       <p>
       This function prints the arguments passed to it at compile-time.
       </p>
@@ -4872,6 +4879,13 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
       </p>
       {#header_close#}
 
+      {#header_open|@FieldType#}
+      <pre>{#syntax#}@FieldType(comptime Type: type, comptime field_name: []const u8) type{#endsyntax#}</pre>
+      <p>
+      Given a type and the name of one of its fields, returns the type of that field.
+      </p>
+      {#header_close#}
+
       {#header_open|@floatCast#}
       <pre>{#syntax#}@floatCast(value: anytype) anytype{#endsyntax#}</pre>
       <p>
@@ -5054,12 +5068,12 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
       {#header_close#}
 
       {#header_open|@max#}
-      <pre>{#syntax#}@max(a: T, b: T) T{#endsyntax#}</pre>
+      <pre>{#syntax#}@max(...) T{#endsyntax#}</pre>
       <p>
-      Returns the maximum value of {#syntax#}a{#endsyntax#} and {#syntax#}b{#endsyntax#}. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
+      Takes two or more arguments and returns the biggest value included (the maximum). This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
       </p>
       <p>
-      NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
+      NaNs are handled as follows: return the biggest non-NaN value included. If all operands are NaN, return NaN.
       </p>
       {#see_also|@min|Vectors#}
       {#header_close#}
@@ -5093,12 +5107,12 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
       {#header_close#}
 
       {#header_open|@min#}
-      <pre>{#syntax#}@min(a: T, b: T) T{#endsyntax#}</pre>
+      <pre>{#syntax#}@min(...) T{#endsyntax#}</pre>
       <p>
-      Returns the minimum value of {#syntax#}a{#endsyntax#} and {#syntax#}b{#endsyntax#}. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
+      Takes two or more arguments and returns the smallest value included (the minimum). This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
       </p>
       <p>
-      NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
+      NaNs are handled as follows: return the smallest non-NaN value included. If all operands are NaN, return NaN.
       </p>
       {#see_also|@max|Vectors#}
       {#header_close#}
@@ -5281,13 +5295,6 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
       {#see_also|Vectors#}
       {#header_close#}
 
-      {#header_open|@setAlignStack#}
-      <pre>{#syntax#}@setAlignStack(comptime alignment: u29) void{#endsyntax#}</pre>
-      <p>
-      Ensures that a function will have a stack alignment of at least {#syntax#}alignment{#endsyntax#} bytes.
-      </p>
-      {#header_close#}
-
       {#header_open|@setEvalBranchQuota#}
       <pre>{#syntax#}@setEvalBranchQuota(comptime new_quota: u32) void{#endsyntax#}</pre>
       <p>
@@ -5781,7 +5788,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
       {#header_open|@TypeOf#}
       <pre>{#syntax#}@TypeOf(...) type{#endsyntax#}</pre>
       <p>
-      {#syntax#}@TypeOf{#endsyntax#} is a special builtin function that takes any (nonzero) number of expressions
+      {#syntax#}@TypeOf{#endsyntax#} is a special builtin function that takes any (non-zero) number of expressions
       as parameters and returns the type of the result, using {#link|Peer Type Resolution#}.
       </p>
       <p>
diff --git a/zig/doc/langref/builtin.CallModifier struct.zig b/zig/doc/langref/builtin.CallModifier struct.zig
index 52c4c5d117..60fc4f2ac4 100644
--- a/zig/doc/langref/builtin.CallModifier struct.zig	
+++ b/zig/doc/langref/builtin.CallModifier struct.zig	
@@ -23,7 +23,7 @@ pub const CallModifier = enum {
     /// If this is not possible, a compile error is emitted instead.
     always_tail,
 
-    /// Guarantees that the call will inlined at the callsite.
+    /// Guarantees that the call will be inlined at the callsite.
     /// If this is not possible, a compile error is emitted instead.
     always_inline,
 
diff --git a/zig/doc/langref/enum_export_error.zig b/zig/doc/langref/enum_export_error.zig
index 1056fb182a..a550c561b9 100644
--- a/zig/doc/langref/enum_export_error.zig
+++ b/zig/doc/langref/enum_export_error.zig
@@ -3,4 +3,5 @@ export fn entry(foo: Foo) void {
     _ = foo;
 }
 
-// obj=parameter of type 'enum_export_error.Foo' not allowed in function with calling convention 'C'
+// obj=parameter of type 'enum_export_error.Foo' not allowed in function with calling convention 'x86_64_sysv'
+// target=x86_64-linux
diff --git a/zig/doc/langref/test_packed_struct_equality.zig b/zig/doc/langref/test_packed_struct_equality.zig
new file mode 100644
index 0000000000..d1c755af19
--- /dev/null
+++ b/zig/doc/langref/test_packed_struct_equality.zig
@@ -0,0 +1,14 @@
+const std = @import("std");
+const expect = std.testing.expect;
+
+test "packed struct equality" {
+    const S = packed struct {
+        a: u4,
+        b: u4,
+    };
+    const x: S = .{ .a = 1, .b = 2 };
+    const y: S = .{ .b = 2, .a = 1 };
+    try expect(x == y);
+}
+
+// test
diff --git a/zig/doc/langref/test_structs.zig b/zig/doc/langref/test_structs.zig
index 936d280586..b62fd3578d 100644
--- a/zig/doc/langref/test_structs.zig
+++ b/zig/doc/langref/test_structs.zig
@@ -6,28 +6,13 @@ const Point = struct {
     y: f32,
 };
 
-// Maybe we want to pass it to OpenGL so we want to be particular about
-// how the bytes are arranged.
-const Point2 = packed struct {
-    x: f32,
-    y: f32,
-};
-
 // Declare an instance of a struct.
-const p = Point{
+const p: Point = .{
     .x = 0.12,
     .y = 0.34,
 };
 
-// Maybe we're not ready to fill out some of the fields.
-var p2 = Point{
-    .x = 0.12,
-    .y = undefined,
-};
-
-// Structs can have methods
-// Struct methods are not special, they are only namespaced
-// functions that you can call with dot syntax.
+// Functions in the struct's namespace can be called with dot syntax.
 const Vec3 = struct {
     x: f32,
     y: f32,
@@ -46,7 +31,6 @@ const Vec3 = struct {
     }
 };
 
-const expect = @import("std").testing.expect;
 test "dot product" {
     const v1 = Vec3.init(1.0, 0.0, 0.0);
     const v2 = Vec3.init(0.0, 1.0, 0.0);
@@ -67,14 +51,14 @@ test "struct namespaced variable" {
     try expect(Empty.PI == 3.14);
     try expect(@sizeOf(Empty) == 0);
 
-    // you can still instantiate an empty struct
-    const does_nothing = Empty{};
+    // Empty structs can be instantiated the same as usual.
+    const does_nothing: Empty = .{};
 
     _ = does_nothing;
 }
 
-// struct field order is determined by the compiler for optimal performance.
-// however, you can still calculate a struct base pointer given a field pointer:
+// Struct field order is determined by the compiler, however, a base pointer
+// can be computed from a field pointer:
 fn setYBasedOnX(x: *f32, y: f32) void {
     const point: *Point = @fieldParentPtr("x", x);
     point.y = y;
@@ -88,8 +72,7 @@ test "field parent pointer" {
     try expect(point.y == 0.9);
 }
 
-// You can return a struct from a function. This is how we do generics
-// in Zig:
+// Structs can be returned from functions.
 fn LinkedList(comptime T: type) type {
     return struct {
         pub const Node = struct {
@@ -105,8 +88,7 @@ fn LinkedList(comptime T: type) type {
 }
 
 test "linked list" {
-    // Functions called at compile-time are memoized. This means you can
-    // do this:
+    // Functions called at compile-time are memoized.
     try expect(LinkedList(i32) == LinkedList(i32));
 
     const list = LinkedList(i32){
@@ -139,4 +121,6 @@ test "linked list" {
     // instead of try expect(list2.first.?.*.data == 1234);
 }
 
+const expect = @import("std").testing.expect;
+
 // test
diff --git a/zig/lib/c.zig b/zig/lib/c.zig
index d742258607..734940ff05 100644
--- a/zig/lib/c.zig
+++ b/zig/lib/c.zig
@@ -11,16 +11,14 @@ const native_os = builtin.os.tag;
 const native_arch = builtin.cpu.arch;
 const native_abi = builtin.abi;
 
+const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .internal else .strong;
+
 const is_wasm = switch (native_arch) {
     .wasm32, .wasm64 => true,
     else => false,
 };
-const is_msvc = switch (native_abi) {
-    .msvc => true,
-    else => false,
-};
 const is_freestanding = switch (native_os) {
-    .freestanding => true,
+    .freestanding, .other => true,
     else => false,
 };
 
@@ -30,16 +28,14 @@ comptime {
     }
 
     if (builtin.link_libc) {
-        @export(&strcmp, .{ .name = "strcmp", .linkage = .strong });
-        @export(&strncmp, .{ .name = "strncmp", .linkage = .strong });
-        @export(&strerror, .{ .name = "strerror", .linkage = .strong });
-        @export(&strlen, .{ .name = "strlen", .linkage = .strong });
-        @export(&strcpy, .{ .name = "strcpy", .linkage = .strong });
-        @export(&strncpy, .{ .name = "strncpy", .linkage = .strong });
-        @export(&strcat, .{ .name = "strcat", .linkage = .strong });
-        @export(&strncat, .{ .name = "strncat", .linkage = .strong });
-    } else if (is_msvc) {
-        @export(&_fltused, .{ .name = "_fltused", .linkage = .strong });
+        @export(&strcmp, .{ .name = "strcmp", .linkage = linkage });
+        @export(&strncmp, .{ .name = "strncmp", .linkage = linkage });
+        @export(&strerror, .{ .name = "strerror", .linkage = linkage });
+        @export(&strlen, .{ .name = "strlen", .linkage = linkage });
+        @export(&strcpy, .{ .name = "strcpy", .linkage = linkage });
+        @export(&strncpy, .{ .name = "strncpy", .linkage = linkage });
+        @export(&strcat, .{ .name = "strcat", .linkage = linkage });
+        @export(&strncat, .{ .name = "strncat", .linkage = linkage });
     }
 }
 
@@ -62,8 +58,6 @@ fn wasm_start() callconv(.C) void {
     _ = main(0, undefined);
 }
 
-var _fltused: c_int = 1;
-
 fn strcpy(dest: [*:0]u8, src: [*:0]const u8) callconv(.C) [*:0]u8 {
     var i: usize = 0;
     while (src[i] != 0) : (i += 1) {
diff --git a/zig/lib/compiler/aro/aro/Builtins.zig b/zig/lib/compiler/aro/aro/Builtins.zig
index fa92de328a..6443a6b6d4 100644
--- a/zig/lib/compiler/aro/aro/Builtins.zig
+++ b/zig/lib/compiler/aro/aro/Builtins.zig
@@ -157,7 +157,7 @@ fn createType(desc: TypeDescription, it: *TypeDescription.TypeIterator, comp: *c
                 .len = element_count,
                 .elem = child_ty,
             };
-            const vector_ty = .{ .specifier = .vector, .data = .{ .array = arr_ty } };
+            const vector_ty: Type = .{ .specifier = .vector, .data = .{ .array = arr_ty } };
             builder.specifier = Type.Builder.fromType(vector_ty);
         },
         .q => {
diff --git a/zig/lib/compiler/aro/aro/Parser.zig b/zig/lib/compiler/aro/aro/Parser.zig
index 00857c65e1..85053b7e48 100644
--- a/zig/lib/compiler/aro/aro/Parser.zig
+++ b/zig/lib/compiler/aro/aro/Parser.zig
@@ -8095,7 +8095,7 @@ fn primaryExpr(p: *Parser) Error!Result {
 
 fn makePredefinedIdentifier(p: *Parser, strings_top: usize) !Result {
     const end: u32 = @intCast(p.strings.items.len);
-    const elem_ty = .{ .specifier = .char, .qual = .{ .@"const" = true } };
+    const elem_ty: Type = .{ .specifier = .char, .qual = .{ .@"const" = true } };
     const arr_ty = try p.arena.create(Type.Array);
     arr_ty.* = .{ .elem = elem_ty, .len = end - strings_top };
     const ty: Type = .{ .specifier = .array, .data = .{ .array = arr_ty } };
diff --git a/zig/lib/compiler/aro/aro/Preprocessor.zig b/zig/lib/compiler/aro/aro/Preprocessor.zig
index 5a03cc0dff..709b6f164f 100644
--- a/zig/lib/compiler/aro/aro/Preprocessor.zig
+++ b/zig/lib/compiler/aro/aro/Preprocessor.zig
@@ -389,7 +389,7 @@ fn preprocessExtra(pp: *Preprocessor, source: Source) MacroError!TokenWithExpans
     try pp.ensureTotalTokenCapacity(pp.tokens.len + estimated_token_count);
 
     var if_level: u8 = 0;
-    var if_kind = std.PackedIntArray(u2, 256).init([1]u2{0} ** 256);
+    var if_kind: [64]u8 = .{0} ** 64;
     const until_else = 0;
     const until_endif = 1;
     const until_endif_seen_else = 2;
@@ -430,12 +430,12 @@ fn preprocessExtra(pp: *Preprocessor, source: Source) MacroError!TokenWithExpans
                         if_level = sum;
 
                         if (try pp.expr(&tokenizer)) {
-                            if_kind.set(if_level, until_endif);
+                            std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_endif);
                             if (pp.verbose) {
                                 pp.verboseLog(directive, "entering then branch of #if", .{});
                             }
                         } else {
-                            if_kind.set(if_level, until_else);
+                            std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_else);
                             try pp.skip(&tokenizer, .until_else);
                             if (pp.verbose) {
                                 pp.verboseLog(directive, "entering else branch of #if", .{});
@@ -451,12 +451,12 @@ fn preprocessExtra(pp: *Preprocessor, source: Source) MacroError!TokenWithExpans
                         const macro_name = (try pp.expectMacroName(&tokenizer)) orelse continue;
                         try pp.expectNl(&tokenizer);
                         if (pp.defines.get(macro_name) != null) {
-                            if_kind.set(if_level, until_endif);
+                            std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_endif);
                             if (pp.verbose) {
                                 pp.verboseLog(directive, "entering then branch of #ifdef", .{});
                             }
                         } else {
-                            if_kind.set(if_level, until_else);
+                            std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_else);
                             try pp.skip(&tokenizer, .until_else);
                             if (pp.verbose) {
                                 pp.verboseLog(directive, "entering else branch of #ifdef", .{});
@@ -472,9 +472,9 @@ fn preprocessExtra(pp: *Preprocessor, source: Source) MacroError!TokenWithExpans
                         const macro_name = (try pp.expectMacroName(&tokenizer)) orelse continue;
                         try pp.expectNl(&tokenizer);
                         if (pp.defines.get(macro_name) == null) {
-                            if_kind.set(if_level, until_endif);
+                            std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_endif);
                         } else {
-                            if_kind.set(if_level, until_else);
+                            std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_else);
                             try pp.skip(&tokenizer, .until_else);
                         }
                     },
@@ -482,13 +482,13 @@ fn preprocessExtra(pp: *Preprocessor, source: Source) MacroError!TokenWithExpans
                         if (if_level == 0) {
                             try pp.err(directive, .elif_without_if);
                             if_level += 1;
-                            if_kind.set(if_level, until_else);
+                            std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_else);
                         } else if (if_level == 1) {
                             guard_name = null;
                         }
-                        switch (if_kind.get(if_level)) {
+                        switch (std.mem.readPackedIntNative(u2, &if_kind, if_level * 2)) {
                             until_else => if (try pp.expr(&tokenizer)) {
-                                if_kind.set(if_level, until_endif);
+                                std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_endif);
                                 if (pp.verbose) {
                                     pp.verboseLog(directive, "entering then branch of #elif", .{});
                                 }
@@ -510,15 +510,15 @@ fn preprocessExtra(pp: *Preprocessor, source: Source) MacroError!TokenWithExpans
                         if (if_level == 0) {
                             try pp.err(directive, .elifdef_without_if);
                             if_level += 1;
-                            if_kind.set(if_level, until_else);
+                            std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_else);
                         } else if (if_level == 1) {
                             guard_name = null;
                         }
-                        switch (if_kind.get(if_level)) {
+                        switch (std.mem.readPackedIntNative(u2, &if_kind, if_level * 2)) {
                             until_else => {
                                 const macro_name = try pp.expectMacroName(&tokenizer);
                                 if (macro_name == null) {
-                                    if_kind.set(if_level, until_else);
+                                    std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_else);
                                     try pp.skip(&tokenizer, .until_else);
                                     if (pp.verbose) {
                                         pp.verboseLog(directive, "entering else branch of #elifdef", .{});
@@ -526,12 +526,12 @@ fn preprocessExtra(pp: *Preprocessor, source: Source) MacroError!TokenWithExpans
                                 } else {
                                     try pp.expectNl(&tokenizer);
                                     if (pp.defines.get(macro_name.?) != null) {
-                                        if_kind.set(if_level, until_endif);
+                                        std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_endif);
                                         if (pp.verbose) {
                                             pp.verboseLog(directive, "entering then branch of #elifdef", .{});
                                         }
                                     } else {
-                                        if_kind.set(if_level, until_else);
+                                        std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_else);
                                         try pp.skip(&tokenizer, .until_else);
                                         if (pp.verbose) {
                                             pp.verboseLog(directive, "entering else branch of #elifdef", .{});
@@ -551,15 +551,15 @@ fn preprocessExtra(pp: *Preprocessor, source: Source) MacroError!TokenWithExpans
                         if (if_level == 0) {
                             try pp.err(directive, .elifdef_without_if);
                             if_level += 1;
-                            if_kind.set(if_level, until_else);
+                            std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_else);
                         } else if (if_level == 1) {
                             guard_name = null;
                         }
-                        switch (if_kind.get(if_level)) {
+                        switch (std.mem.readPackedIntNative(u2, &if_kind, if_level * 2)) {
                             until_else => {
                                 const macro_name = try pp.expectMacroName(&tokenizer);
                                 if (macro_name == null) {
-                                    if_kind.set(if_level, until_else);
+                                    std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_else);
                                     try pp.skip(&tokenizer, .until_else);
                                     if (pp.verbose) {
                                         pp.verboseLog(directive, "entering else branch of #elifndef", .{});
@@ -567,12 +567,12 @@ fn preprocessExtra(pp: *Preprocessor, source: Source) MacroError!TokenWithExpans
                                 } else {
                                     try pp.expectNl(&tokenizer);
                                     if (pp.defines.get(macro_name.?) == null) {
-                                        if_kind.set(if_level, until_endif);
+                                        std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_endif);
                                         if (pp.verbose) {
                                             pp.verboseLog(directive, "entering then branch of #elifndef", .{});
                                         }
                                     } else {
-                                        if_kind.set(if_level, until_else);
+                                        std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_else);
                                         try pp.skip(&tokenizer, .until_else);
                                         if (pp.verbose) {
                                             pp.verboseLog(directive, "entering else branch of #elifndef", .{});
@@ -596,9 +596,9 @@ fn preprocessExtra(pp: *Preprocessor, source: Source) MacroError!TokenWithExpans
                         } else if (if_level == 1) {
                             guard_name = null;
                         }
-                        switch (if_kind.get(if_level)) {
+                        switch (std.mem.readPackedIntNative(u2, &if_kind, if_level * 2)) {
                             until_else => {
-                                if_kind.set(if_level, until_endif_seen_else);
+                                std.mem.writePackedIntNative(u2, &if_kind, if_level * 2, until_endif_seen_else);
                                 if (pp.verbose) {
                                     pp.verboseLog(directive, "#else branch here", .{});
                                 }
diff --git a/zig/lib/compiler/aro/aro/target.zig b/zig/lib/compiler/aro/aro/target.zig
index c07935a420..56bc4dd46a 100644
--- a/zig/lib/compiler/aro/aro/target.zig
+++ b/zig/lib/compiler/aro/aro/target.zig
@@ -437,9 +437,18 @@ pub fn ldEmulationOption(target: std.Target, arm_endianness: ?std.builtin.Endian
         .loongarch64 => "elf64loongarch",
         .mips => "elf32btsmip",
         .mipsel => "elf32ltsmip",
-        .mips64 => if (target.abi == .gnuabin32) "elf32btsmipn32" else "elf64btsmip",
-        .mips64el => if (target.abi == .gnuabin32) "elf32ltsmipn32" else "elf64ltsmip",
-        .x86_64 => if (target.abi == .gnux32 or target.abi == .muslx32) "elf32_x86_64" else "elf_x86_64",
+        .mips64 => switch (target.abi) {
+            .gnuabin32, .muslabin32 => "elf32btsmipn32",
+            else => "elf64btsmip",
+        },
+        .mips64el => switch (target.abi) {
+            .gnuabin32, .muslabin32 => "elf32ltsmipn32",
+            else => "elf64ltsmip",
+        },
+        .x86_64 => switch (target.abi) {
+            .gnux32, .muslx32 => "elf32_x86_64",
+            else => "elf_x86_64",
+        },
         .ve => "elf64ve",
         .csky => "cskyelf_linux",
         else => null,
@@ -684,13 +693,15 @@ pub fn toLLVMTriple(target: std.Target, buf: []u8) []const u8 {
         .gnuf32 => "gnuf32",
         .gnusf => "gnusf",
         .gnux32 => "gnux32",
-        .gnuilp32 => "gnuilp32",
+        .gnuilp32 => "gnu_ilp32",
         .code16 => "code16",
         .eabi => "eabi",
         .eabihf => "eabihf",
         .android => "android",
         .androideabi => "androideabi",
         .musl => "musl",
+        .muslabin32 => "muslabin32",
+        .muslabi64 => "muslabi64",
         .musleabi => "musleabi",
         .musleabihf => "musleabihf",
         .muslx32 => "muslx32",
@@ -709,8 +720,8 @@ pub fn toLLVMTriple(target: std.Target, buf: []u8) []const u8 {
 test "alignment functions - smoke test" {
     var target: std.Target = undefined;
     const x86 = std.Target.Cpu.Arch.x86_64;
-    target.cpu = std.Target.Cpu.baseline(x86);
     target.os = std.Target.Os.Tag.defaultVersionRange(.linux, x86);
+    target.cpu = std.Target.Cpu.baseline(x86, target.os);
     target.abi = std.Target.Abi.default(x86, target.os);
 
     try std.testing.expect(isTlsSupported(target));
@@ -722,8 +733,8 @@ test "alignment functions - smoke test" {
     try std.testing.expect(systemCompiler(target) == .gcc);
 
     const arm = std.Target.Cpu.Arch.arm;
-    target.cpu = std.Target.Cpu.baseline(arm);
     target.os = std.Target.Os.Tag.defaultVersionRange(.ios, arm);
+    target.cpu = std.Target.Cpu.baseline(arm, target.os);
     target.abi = std.Target.Abi.default(arm, target.os);
 
     try std.testing.expect(!isTlsSupported(target));
diff --git a/zig/lib/compiler/aro/aro/text_literal.zig b/zig/lib/compiler/aro/aro/text_literal.zig
index d9f6b2a88b..7bc8fd95cb 100644
--- a/zig/lib/compiler/aro/aro/text_literal.zig
+++ b/zig/lib/compiler/aro/aro/text_literal.zig
@@ -188,7 +188,7 @@ pub const Parser = struct {
     pub fn err(self: *Parser, tag: Diagnostics.Tag, extra: Diagnostics.Message.Extra) void {
         if (self.errored) return;
         self.errored = true;
-        const diagnostic = .{ .tag = tag, .extra = extra };
+        const diagnostic: CharDiagnostic = .{ .tag = tag, .extra = extra };
         if (self.errors_len == self.errors_buffer.len) {
             self.errors_buffer[self.errors_buffer.len - 1] = diagnostic;
         } else {
diff --git a/zig/lib/compiler/aro/aro/toolchains/Linux.zig b/zig/lib/compiler/aro/aro/toolchains/Linux.zig
index 9666c8e3b0..763222cc98 100644
--- a/zig/lib/compiler/aro/aro/toolchains/Linux.zig
+++ b/zig/lib/compiler/aro/aro/toolchains/Linux.zig
@@ -40,7 +40,7 @@ fn buildExtraOpts(self: *Linux, tc: *const Toolchain) !void {
         self.extra_opts.appendAssumeCapacity("relro");
     }
 
-    if (target.cpu.arch.isARM() or target.cpu.arch.isAARCH64() or is_android) {
+    if ((target.cpu.arch.isArm() and !target.cpu.arch.isThumb()) or target.cpu.arch.isAARCH64() or is_android) {
         try self.extra_opts.ensureUnusedCapacity(gpa, 2);
         self.extra_opts.appendAssumeCapacity("-z");
         self.extra_opts.appendAssumeCapacity("max-page-size=4096");
diff --git a/zig/lib/compiler/aro_translate_c.zig b/zig/lib/compiler/aro_translate_c.zig
index 910d12d32b..6be33a196f 100644
--- a/zig/lib/compiler/aro_translate_c.zig
+++ b/zig/lib/compiler/aro_translate_c.zig
@@ -749,7 +749,7 @@ fn transType(c: *Context, scope: *Scope, raw_ty: Type, qual_handling: Type.QualH
             const is_const = is_fn_proto or child_type.isConst();
             const is_volatile = child_type.qual.@"volatile";
             const elem_type = try transType(c, scope, child_type, qual_handling, source_loc);
-            const ptr_info = .{
+            const ptr_info: @FieldType(ast.Payload.Pointer, "data") = .{
                 .is_const = is_const,
                 .is_volatile = is_volatile,
                 .elem_type = elem_type,
diff --git a/zig/lib/compiler/aro_translate_c/ast.zig b/zig/lib/compiler/aro_translate_c/ast.zig
index 8cd331d294..b92db7862f 100644
--- a/zig/lib/compiler/aro_translate_c/ast.zig
+++ b/zig/lib/compiler/aro_translate_c/ast.zig
@@ -550,12 +550,26 @@ pub const Payload = struct {
             is_var_args: bool,
             name: ?[]const u8,
             linksection_string: ?[]const u8,
-            explicit_callconv: ?std.builtin.CallingConvention,
+            explicit_callconv: ?CallingConvention,
             params: []Param,
             return_type: Node,
             body: ?Node,
             alignment: ?c_uint,
         },
+
+        pub const CallingConvention = enum {
+            c,
+            x86_64_sysv,
+            x86_64_win,
+            x86_stdcall,
+            x86_fastcall,
+            x86_thiscall,
+            x86_vectorcall,
+            aarch64_vfabi,
+            arm_aapcs,
+            arm_aapcs_vfp,
+            m68k_rtd,
+        };
     };
 
     pub const Param = struct {
@@ -2812,14 +2826,52 @@ fn renderFunc(c: *Context, node: Node) !NodeIndex {
     const callconv_expr = if (payload.explicit_callconv) |some| blk: {
         _ = try c.addToken(.keyword_callconv, "callconv");
         _ = try c.addToken(.l_paren, "(");
-        _ = try c.addToken(.period, ".");
-        const res = try c.addNode(.{
-            .tag = .enum_literal,
-            .main_token = try c.addTokenFmt(.identifier, "{s}", .{@tagName(some)}),
-            .data = undefined,
-        });
+        const cc_node = switch (some) {
+            .c => cc_node: {
+                _ = try c.addToken(.period, ".");
+                break :cc_node try c.addNode(.{
+                    .tag = .enum_literal,
+                    .main_token = try c.addToken(.identifier, "c"),
+                    .data = undefined,
+                });
+            },
+            .x86_64_sysv,
+            .x86_64_win,
+            .x86_stdcall,
+            .x86_fastcall,
+            .x86_thiscall,
+            .x86_vectorcall,
+            .aarch64_vfabi,
+            .arm_aapcs,
+            .arm_aapcs_vfp,
+            .m68k_rtd,
+            => cc_node: {
+                // .{ .foo = .{} }
+                _ = try c.addToken(.period, ".");
+                const outer_lbrace = try c.addToken(.l_brace, "{");
+                _ = try c.addToken(.period, ".");
+                _ = try c.addToken(.identifier, @tagName(some));
+                _ = try c.addToken(.equal, "=");
+                _ = try c.addToken(.period, ".");
+                const inner_lbrace = try c.addToken(.l_brace, "{");
+                _ = try c.addToken(.r_brace, "}");
+                _ = try c.addToken(.r_brace, "}");
+                break :cc_node try c.addNode(.{
+                    .tag = .struct_init_dot_two,
+                    .main_token = outer_lbrace,
+                    .data = .{
+                        .lhs = try c.addNode(.{
+                            .tag = .struct_init_dot_two,
+                            .main_token = inner_lbrace,
+                            .data = .{ .lhs = 0, .rhs = 0 },
+                        }),
+                        .rhs = 0,
+                    },
+                });
+            },
+        };
         _ = try c.addToken(.r_paren, ")");
-        break :blk res;
+        break :blk cc_node;
     } else 0;
 
     const return_type_expr = try renderNode(c, payload.return_type);
diff --git a/zig/lib/compiler/build_runner.zig b/zig/lib/compiler/build_runner.zig
index 4d643222d7..421d2e72f1 100644
--- a/zig/lib/compiler/build_runner.zig
+++ b/zig/lib/compiler/build_runner.zig
@@ -280,6 +280,10 @@ pub fn main() !void {
                 builder.enable_darling = true;
             } else if (mem.eql(u8, arg, "-fno-darling")) {
                 builder.enable_darling = false;
+            } else if (mem.eql(u8, arg, "-fallow-so-scripts")) {
+                graph.allow_so_scripts = true;
+            } else if (mem.eql(u8, arg, "-fno-allow-so-scripts")) {
+                graph.allow_so_scripts = false;
             } else if (mem.eql(u8, arg, "-freference-trace")) {
                 builder.reference_trace = 256;
             } else if (mem.startsWith(u8, arg, "-freference-trace=")) {
@@ -443,10 +447,7 @@ pub fn main() !void {
 
         if (!watch) return cleanExit();
 
-        switch (builtin.os.tag) {
-            .linux, .windows => {},
-            else => fatal("--watch not yet implemented for {s}", .{@tagName(builtin.os.tag)}),
-        }
+        if (!Watch.have_impl) fatal("--watch not yet implemented for {s}", .{@tagName(builtin.os.tag)});
 
         try w.update(gpa, run.step_stack.keys());
 
@@ -1341,6 +1342,8 @@ fn usage(b: *std.Build, out_stream: anytype) !void {
         \\Advanced Options:
         \\  -freference-trace[=num]      How many lines of reference trace should be shown per compile error
         \\  -fno-reference-trace         Disable reference trace
+        \\  -fallow-so-scripts           Allows .so files to be GNU ld scripts
+        \\  -fno-allow-so-scripts        (default) .so files must be ELF files
         \\  --build-file [file]          Override path to build.zig
         \\  --cache-dir [path]           Override path to local Zig cache directory
         \\  --global-cache-dir [path]    Override path to global Zig cache directory
diff --git a/zig/lib/compiler/objcopy.zig b/zig/lib/compiler/objcopy.zig
index 9794671e6f..bf031bb391 100644
--- a/zig/lib/compiler/objcopy.zig
+++ b/zig/lib/compiler/objcopy.zig
@@ -832,7 +832,6 @@ fn ElfFile(comptime is_64: bool) type {
     const Elf_Shdr = if (is_64) elf.Elf64_Shdr else elf.Elf32_Shdr;
     const Elf_Chdr = if (is_64) elf.Elf64_Chdr else elf.Elf32_Chdr;
     const Elf_Sym = if (is_64) elf.Elf64_Sym else elf.Elf32_Sym;
-    const Elf_Verdef = if (is_64) elf.Elf64_Verdef else elf.Elf32_Verdef;
     const Elf_OffSize = if (is_64) elf.Elf64_Off else elf.Elf32_Off;
 
     return struct {
@@ -1179,11 +1178,11 @@ fn ElfFile(comptime is_64: bool) type {
                                     const data = try allocator.alignedAlloc(u8, section_memory_align, src_data.len);
                                     @memcpy(data, src_data);
 
-                                    const defs = @as([*]Elf_Verdef, @ptrCast(data))[0 .. @as(usize, @intCast(src.sh_size)) / @sizeOf(Elf_Verdef)];
-                                    for (defs) |*def| {
-                                        if (def.vd_ndx != elf.SHN_UNDEF)
-                                            def.vd_ndx = sections_update[src.sh_info].remap_idx;
-                                    }
+                                    const defs = @as([*]elf.Verdef, @ptrCast(data))[0 .. @as(usize, @intCast(src.sh_size)) / @sizeOf(elf.Verdef)];
+                                    for (defs) |*def| switch (def.ndx) {
+                                        .LOCAL, .GLOBAL => {},
+                                        else => def.ndx = @enumFromInt(sections_update[src.sh_info].remap_idx),
+                                    };
 
                                     break :dst_data data;
                                 },
diff --git a/zig/lib/compiler/test_runner.zig b/zig/lib/compiler/test_runner.zig
index f88354623d..15ae84510a 100644
--- a/zig/lib/compiler/test_runner.zig
+++ b/zig/lib/compiler/test_runner.zig
@@ -6,7 +6,7 @@ const io = std.io;
 const testing = std.testing;
 const assert = std.debug.assert;
 
-pub const std_options = .{
+pub const std_options: std.Options = .{
     .logFn = log,
 };
 
@@ -136,7 +136,7 @@ fn mainServer() !void {
                         .leak = leak,
                         .fuzz = is_fuzz_test,
                         .log_err_count = std.math.lossyCast(
-                            @TypeOf(@as(std.zig.Server.Message.TestResults.Flags, undefined).log_err_count),
+                            @FieldType(std.zig.Server.Message.TestResults.Flags, "log_err_count"),
                             log_err_count,
                         ),
                     },
diff --git a/zig/lib/compiler_rt.zig b/zig/lib/compiler_rt.zig
index 9628ea4f3b..02d3f75c5b 100644
--- a/zig/lib/compiler_rt.zig
+++ b/zig/lib/compiler_rt.zig
@@ -1,6 +1,7 @@
 const builtin = @import("builtin");
+const common = @import("compiler_rt/common.zig");
 
-pub const panic = @import("compiler_rt/common.zig").panic;
+pub const panic = common.panic;
 
 comptime {
     // Integer routines
@@ -236,4 +237,10 @@ comptime {
         _ = @import("compiler_rt/bcmp.zig");
         _ = @import("compiler_rt/ssp.zig");
     }
+
+    if (!builtin.link_libc and builtin.abi == .msvc) {
+        @export(&_fltused, .{ .name = "_fltused", .linkage = common.linkage, .visibility = common.visibility });
+    }
 }
+
+var _fltused: c_int = 1;
diff --git a/zig/lib/compiler_rt/arm.zig b/zig/lib/compiler_rt/arm.zig
index e42694b2bf..5a95e9da49 100644
--- a/zig/lib/compiler_rt/arm.zig
+++ b/zig/lib/compiler_rt/arm.zig
@@ -10,7 +10,7 @@ pub const panic = common.panic;
 
 comptime {
     if (!builtin.is_test) {
-        if (arch.isArmOrThumb()) {
+        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 });
@@ -206,7 +206,7 @@ fn __aeabi_drsub(a: f64, b: f64) callconv(.AAPCS) f64 {
 }
 
 test "__aeabi_frsub" {
-    if (!builtin.cpu.arch.isARM()) return error.SkipZigTest;
+    if (!builtin.cpu.arch.isArm() or builtin.cpu.arch.isThumb()) return error.SkipZigTest;
     const inf32 = std.math.inf(f32);
     const maxf32 = std.math.floatMax(f32);
     const frsub_data = [_][3]f32{
@@ -226,14 +226,13 @@ test "__aeabi_frsub" {
         [_]f32{ maxf32, -maxf32, -inf32 },
         [_]f32{ -maxf32, maxf32, inf32 },
     };
-    if (!builtin.cpu.arch.isARM()) return error.SkipZigTest;
     for (frsub_data) |data| {
         try std.testing.expectApproxEqAbs(data[2], __aeabi_frsub(data[0], data[1]), 0.001);
     }
 }
 
 test "__aeabi_drsub" {
-    if (!builtin.cpu.arch.isARM()) return error.SkipZigTest;
+    if (!builtin.cpu.arch.isArm() or builtin.cpu.arch.isThumb()) return error.SkipZigTest;
     const inf64 = std.math.inf(f64);
     const maxf64 = std.math.floatMax(f64);
     const frsub_data = [_][3]f64{
@@ -253,7 +252,6 @@ test "__aeabi_drsub" {
         [_]f64{ maxf64, -maxf64, -inf64 },
         [_]f64{ -maxf64, maxf64, inf64 },
     };
-    if (!builtin.cpu.arch.isARM()) return error.SkipZigTest;
     for (frsub_data) |data| {
         try std.testing.expectApproxEqAbs(data[2], __aeabi_drsub(data[0], data[1]), 0.000001);
     }
diff --git a/zig/lib/compiler_rt/atomics.zig b/zig/lib/compiler_rt/atomics.zig
index db1e9b4b70..2cec398732 100644
--- a/zig/lib/compiler_rt/atomics.zig
+++ b/zig/lib/compiler_rt/atomics.zig
@@ -42,7 +42,7 @@ const largest_atomic_size = switch (arch) {
 // Objects smaller than this threshold are implemented in terms of compare-exchange
 // of a larger value.
 const smallest_atomic_fetch_exch_size = switch (arch) {
-    // On AMDGPU, there are no instructions for atomic operations other than load and store
+    // On AMDGCN, there are no instructions for atomic operations other than load and store
     // (as of LLVM 15), and so these need to be implemented in terms of atomic CAS.
     .amdgcn => @sizeOf(u32),
     else => @sizeOf(u8),
diff --git a/zig/lib/compiler_rt/clear_cache.zig b/zig/lib/compiler_rt/clear_cache.zig
index 0c7847388c..c05a38f846 100644
--- a/zig/lib/compiler_rt/clear_cache.zig
+++ b/zig/lib/compiler_rt/clear_cache.zig
@@ -28,8 +28,10 @@ fn clear_cache(start: usize, end: usize) callconv(.C) void {
         .aarch64, .aarch64_be => true,
         else => false,
     };
-    const loongarch64 = switch (arch) {
-        .loongarch64 => true,
+    const loongarch = switch (arch) {
+        .loongarch32,
+        .loongarch64,
+        => true,
         else => false,
     };
     const mips = switch (arch) {
@@ -163,7 +165,7 @@ fn clear_cache(start: usize, end: usize) callconv(.C) void {
         // On Darwin, sys_icache_invalidate() provides this functionality
         sys_icache_invalidate(start, end - start);
         exportIt();
-    } else if (os == .linux and loongarch64) {
+    } else if (os == .linux and loongarch) {
         // See: https://github.com/llvm/llvm-project/blob/cf54cae26b65fc3201eff7200ffb9b0c9e8f9a13/compiler-rt/lib/builtins/clear_cache.c#L94-L95
         asm volatile (
             \\ ibar 0
diff --git a/zig/lib/compiler_rt/clzsi2_test.zig b/zig/lib/compiler_rt/clzsi2_test.zig
index 4fd85edca5..188290e90b 100644
--- a/zig/lib/compiler_rt/clzsi2_test.zig
+++ b/zig/lib/compiler_rt/clzsi2_test.zig
@@ -268,7 +268,7 @@ test "clzsi2" {
     try test__clzsi2(0xFE000000, 0);
     try test__clzsi2(0xFF000000, 0);
     // arm and thumb1 assume input a != 0
-    if (!builtin.cpu.arch.isArmOrThumb())
+    if (!builtin.cpu.arch.isArm())
         try test__clzsi2(0x00000000, 32);
     try test__clzsi2(0x00000001, 31);
     try test__clzsi2(0x00000002, 30);
diff --git a/zig/lib/compiler_rt/common.zig b/zig/lib/compiler_rt/common.zig
index 786dc7303a..afc3a2e6d9 100644
--- a/zig/lib/compiler_rt/common.zig
+++ b/zig/lib/compiler_rt/common.zig
@@ -29,7 +29,7 @@ pub const want_aeabi = switch (builtin.abi) {
     },
     else => false,
 };
-pub const want_mingw_arm_abi = builtin.cpu.arch.isArmOrThumb() and builtin.target.isMinGW();
+pub const want_mingw_arm_abi = builtin.cpu.arch.isArm() and builtin.target.isMinGW();
 
 pub const want_ppc_abi = builtin.cpu.arch.isPowerPC();
 
@@ -103,7 +103,7 @@ pub fn F16T(comptime OtherType: type) type {
         else
             u16,
         .aarch64, .aarch64_be => f16,
-        .riscv64 => if (builtin.zig_backend == .stage1) u16 else f16,
+        .riscv32, .riscv64 => f16,
         .x86, .x86_64 => if (builtin.target.isDarwin()) switch (OtherType) {
             // Starting with LLVM 16, Darwin uses different abi for f16
             // depending on the type of the other return/argument..???
diff --git a/zig/lib/compiler_rt/int.zig b/zig/lib/compiler_rt/int.zig
index 49891ac5e3..e71a0c0990 100644
--- a/zig/lib/compiler_rt/int.zig
+++ b/zig/lib/compiler_rt/int.zig
@@ -10,7 +10,6 @@ const is_test = builtin.is_test;
 const common = @import("common.zig");
 const udivmod = @import("udivmod.zig").udivmod;
 const __divti3 = @import("divti3.zig").__divti3;
-const arm = @import("arm.zig");
 
 pub const panic = common.panic;
 
@@ -102,25 +101,6 @@ test "test_divmoddi4" {
     }
 }
 
-fn test_one_aeabi_ldivmod(a: i64, b: i64, expected_q: i64, expected_r: i64) !void {
-    const LdivmodRes = extern struct {
-        q: i64, // r1:r0
-        r: i64, // r3:r2
-    };
-    const actualIdivmod = @as(*const fn (a: i64, b: i64) callconv(.AAPCS) LdivmodRes, @ptrCast(&arm.__aeabi_ldivmod));
-    const arm_res = actualIdivmod(a, b);
-    try testing.expectEqual(expected_q, arm_res.q);
-    try testing.expectEqual(expected_r, arm_res.r);
-}
-
-test "arm.__aeabi_ldivmod" {
-    if (!builtin.cpu.arch.isARM()) return error.SkipZigTest;
-
-    for (cases__divmodsi4) |case| {
-        try test_one_aeabi_ldivmod(case[0], case[1], case[2], case[3]);
-    }
-}
-
 pub fn __udivmoddi4(a: u64, b: u64, maybe_rem: ?*u64) callconv(.C) u64 {
     return udivmod(u64, a, b, maybe_rem);
 }
@@ -261,25 +241,6 @@ test "test_divmodsi4" {
     }
 }
 
-fn test_one_aeabi_idivmod(a: i32, b: i32, expected_q: i32, expected_r: i32) !void {
-    const IdivmodRes = extern struct {
-        q: i32, // r0
-        r: i32, // r1
-    };
-    const actualIdivmod = @as(*const fn (a: i32, b: i32) callconv(.AAPCS) IdivmodRes, @ptrCast(&arm.__aeabi_idivmod));
-    const arm_res = actualIdivmod(a, b);
-    try testing.expectEqual(expected_q, arm_res.q);
-    try testing.expectEqual(expected_r, arm_res.r);
-}
-
-test "arm.__aeabi_idivmod" {
-    if (!builtin.cpu.arch.isARM()) return error.SkipZigTest;
-
-    for (cases__divmodsi4) |case| {
-        try test_one_aeabi_idivmod(case[0], case[1], case[2], case[3]);
-    }
-}
-
 pub fn __udivmodsi4(a: u32, b: u32, rem: *u32) callconv(.C) u32 {
     const d = __udivsi3(a, b);
     rem.* = @bitCast(@as(i32, @bitCast(a)) -% (@as(i32, @bitCast(d)) * @as(i32, @bitCast(b))));
diff --git a/zig/lib/compiler_rt/udivmoddi4_test.zig b/zig/lib/compiler_rt/udivmoddi4_test.zig
index 3c51ed9426..2458824a79 100644
--- a/zig/lib/compiler_rt/udivmoddi4_test.zig
+++ b/zig/lib/compiler_rt/udivmoddi4_test.zig
@@ -3,7 +3,6 @@
 const testing = @import("std").testing;
 const builtin = @import("builtin");
 const __udivmoddi4 = @import("int.zig").__udivmoddi4;
-const __aeabi_uldivmod = @import("arm.zig").__aeabi_uldivmod;
 
 fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) !void {
     var r: u64 = undefined;
@@ -18,26 +17,6 @@ test "udivmoddi4" {
     }
 }
 
-const ARMRes = extern struct {
-    q: u64, // r1:r0
-    r: u64, // r3:r2
-};
-
-fn test__aeabi_uldivmod(a: u64, b: u64, expected_q: u64, expected_r: u64) !void {
-    const actualUldivmod = @as(*const fn (a: u64, b: u64) callconv(.AAPCS) ARMRes, @ptrCast(&__aeabi_uldivmod));
-    const arm_res = actualUldivmod(a, b);
-    try testing.expectEqual(expected_q, arm_res.q);
-    try testing.expectEqual(expected_r, arm_res.r);
-}
-
-test "arm.__aeabi_uldivmod" {
-    if (!builtin.cpu.arch.isARM()) return error.SkipZigTest;
-
-    for (cases) |case| {
-        try test__aeabi_uldivmod(case[0], case[1], case[2], case[3]);
-    }
-}
-
 const cases = [_][4]u64{
     [_]u64{0x0000000000000000, 0x0000000000000001, 0x0000000000000000, 0x0000000000000000},
     [_]u64{0x0000000000000000, 0x0000000000000002, 0x0000000000000000, 0x0000000000000000},
diff --git a/zig/lib/compiler_rt/udivmodsi4_test.zig b/zig/lib/compiler_rt/udivmodsi4_test.zig
index bd3633423b..5b76877135 100644
--- a/zig/lib/compiler_rt/udivmodsi4_test.zig
+++ b/zig/lib/compiler_rt/udivmodsi4_test.zig
@@ -2,27 +2,18 @@
 // zig fmt: off
 const testing = @import("std").testing;
 const builtin = @import("builtin");
-const __aeabi_uidivmod = @import("arm.zig").__aeabi_uidivmod;
+const __udivmodsi4 = @import("int.zig").__udivmodsi4;
 
-const ARMRes = extern struct {
-    q: u32, // r0
-    r: u32, // r1
-};
-
-fn test__aeabi_uidivmod(a: u32, b: u32, expected_q: u32, expected_r: u32) !void {
-    const actualUidivmod = @as(*const fn (a: u32, b: u32) callconv(.AAPCS) ARMRes, @ptrCast(&__aeabi_uidivmod));
-    const arm_res = actualUidivmod(a, b);
-    try testing.expectEqual(expected_q, arm_res.q);
-    try testing.expectEqual(expected_r, arm_res.r);
+fn test__udivmodsi4(a: u32, b: u32, expected_q: u32, expected_r: u32) !void {
+    var r: u32 = undefined;
+    const q = __udivmodsi4(a, b, &r);
+    try testing.expectEqual(expected_q, q);
+    try testing.expectEqual(expected_r, r);
 }
 
-test "arm.__aeabi_uidivmod" {
-    if (!builtin.cpu.arch.isARM()) return error.SkipZigTest;
-
-    var i: i32 = 0;
+test "udivmodsi4" {
     for (cases) |case| {
-        try test__aeabi_uidivmod(case[0], case[1], case[2], case[3]);
-        i+=1;
+        try test__udivmodsi4(case[0], case[1], case[2], case[3]);
     }
 }
 
diff --git a/zig/lib/fuzzer.zig b/zig/lib/fuzzer.zig
index d8f405dccb..3c00ec7b48 100644
--- a/zig/lib/fuzzer.zig
+++ b/zig/lib/fuzzer.zig
@@ -5,7 +5,7 @@ const assert = std.debug.assert;
 const fatal = std.process.fatal;
 const SeenPcsHeader = std.Build.Fuzz.abi.SeenPcsHeader;
 
-pub const std_options = .{
+pub const std_options = std.Options{
     .logFn = logOverride,
 };
 
diff --git a/zig/lib/libc/glibc/sysdeps/x86_64/x32/sysdep.h b/zig/lib/libc/glibc/sysdeps/x86_64/x32/sysdep.h
index 02036edd7d..39cb08b3cf 100644
--- a/zig/lib/libc/glibc/sysdeps/x86_64/x32/sysdep.h
+++ b/zig/lib/libc/glibc/sysdeps/x86_64/x32/sysdep.h
@@ -17,6 +17,7 @@
    <https://www.gnu.org/licenses/>.  */
 
 #include <sysdeps/x86_64/sysdep.h>
+#undef LP_SIZE
 #ifdef __ASSEMBLER__
 # define LP_SIZE 4
 #else
diff --git a/zig/lib/libc/include/aarch64-linux-musl/bits/stdint.h b/zig/lib/libc/include/aarch64-linux-musl/bits/stdint.h
new file mode 100644
index 0000000000..02714d7398
--- /dev/null
+++ b/zig/lib/libc/include/aarch64-linux-musl/bits/stdint.h
@@ -0,0 +1,20 @@
+typedef int32_t int_fast16_t;
+typedef int32_t int_fast32_t;
+typedef uint32_t uint_fast16_t;
+typedef uint32_t uint_fast32_t;
+
+#define INT_FAST16_MIN  INT32_MIN
+#define INT_FAST32_MIN  INT32_MIN
+
+#define INT_FAST16_MAX  INT32_MAX
+#define INT_FAST32_MAX  INT32_MAX
+
+#define UINT_FAST16_MAX UINT32_MAX
+#define UINT_FAST32_MAX UINT32_MAX
+
+#define INTPTR_MIN      INT64_MIN
+#define INTPTR_MAX      INT64_MAX
+#define UINTPTR_MAX     UINT64_MAX
+#define PTRDIFF_MIN     INT64_MIN
+#define PTRDIFF_MAX     INT64_MAX
+#define SIZE_MAX        UINT64_MAX
\ No newline at end of file
diff --git a/zig/lib/libc/include/generic-musl/bits/alltypes.h b/zig/lib/libc/include/generic-musl/bits/alltypes.h
new file mode 100644
index 0000000000..46b309d668
--- /dev/null
+++ b/zig/lib/libc/include/generic-musl/bits/alltypes.h
@@ -0,0 +1,408 @@
+#define _REDIR_TIME64 1
+#define _Addr int
+#define _Int64 long long
+#define _Reg int
+
+#if _MIPSEL || __MIPSEL || __MIPSEL__
+#define __BYTE_ORDER 1234
+#else
+#define __BYTE_ORDER 4321
+#endif
+
+#define __LONG_MAX 0x7fffffffL
+
+#ifndef __cplusplus
+#if defined(__NEED_wchar_t) && !defined(__DEFINED_wchar_t)
+typedef int wchar_t;
+#define __DEFINED_wchar_t
+#endif
+
+#endif
+
+#if defined(__NEED_float_t) && !defined(__DEFINED_float_t)
+typedef float float_t;
+#define __DEFINED_float_t
+#endif
+
+#if defined(__NEED_double_t) && !defined(__DEFINED_double_t)
+typedef double double_t;
+#define __DEFINED_double_t
+#endif
+
+
+#if defined(__NEED_max_align_t) && !defined(__DEFINED_max_align_t)
+typedef struct { long long __ll; long double __ld; } max_align_t;
+#define __DEFINED_max_align_t
+#endif
+
+#define __LITTLE_ENDIAN 1234
+#define __BIG_ENDIAN 4321
+#define __USE_TIME_BITS64 1
+
+#if defined(__NEED_size_t) && !defined(__DEFINED_size_t)
+typedef unsigned _Addr size_t;
+#define __DEFINED_size_t
+#endif
+
+#if defined(__NEED_uintptr_t) && !defined(__DEFINED_uintptr_t)
+typedef unsigned _Addr uintptr_t;
+#define __DEFINED_uintptr_t
+#endif
+
+#if defined(__NEED_ptrdiff_t) && !defined(__DEFINED_ptrdiff_t)
+typedef _Addr ptrdiff_t;
+#define __DEFINED_ptrdiff_t
+#endif
+
+#if defined(__NEED_ssize_t) && !defined(__DEFINED_ssize_t)
+typedef _Addr ssize_t;
+#define __DEFINED_ssize_t
+#endif
+
+#if defined(__NEED_intptr_t) && !defined(__DEFINED_intptr_t)
+typedef _Addr intptr_t;
+#define __DEFINED_intptr_t
+#endif
+
+#if defined(__NEED_regoff_t) && !defined(__DEFINED_regoff_t)
+typedef _Addr regoff_t;
+#define __DEFINED_regoff_t
+#endif
+
+#if defined(__NEED_register_t) && !defined(__DEFINED_register_t)
+typedef _Reg register_t;
+#define __DEFINED_register_t
+#endif
+
+#if defined(__NEED_time_t) && !defined(__DEFINED_time_t)
+typedef _Int64 time_t;
+#define __DEFINED_time_t
+#endif
+
+#if defined(__NEED_suseconds_t) && !defined(__DEFINED_suseconds_t)
+typedef _Int64 suseconds_t;
+#define __DEFINED_suseconds_t
+#endif
+
+
+#if defined(__NEED_int8_t) && !defined(__DEFINED_int8_t)
+typedef signed char     int8_t;
+#define __DEFINED_int8_t
+#endif
+
+#if defined(__NEED_int16_t) && !defined(__DEFINED_int16_t)
+typedef signed short    int16_t;
+#define __DEFINED_int16_t
+#endif
+
+#if defined(__NEED_int32_t) && !defined(__DEFINED_int32_t)
+typedef signed int      int32_t;
+#define __DEFINED_int32_t
+#endif
+
+#if defined(__NEED_int64_t) && !defined(__DEFINED_int64_t)
+typedef signed _Int64   int64_t;
+#define __DEFINED_int64_t
+#endif
+
+#if defined(__NEED_intmax_t) && !defined(__DEFINED_intmax_t)
+typedef signed _Int64   intmax_t;
+#define __DEFINED_intmax_t
+#endif
+
+#if defined(__NEED_uint8_t) && !defined(__DEFINED_uint8_t)
+typedef unsigned char   uint8_t;
+#define __DEFINED_uint8_t
+#endif
+
+#if defined(__NEED_uint16_t) && !defined(__DEFINED_uint16_t)
+typedef unsigned short  uint16_t;
+#define __DEFINED_uint16_t
+#endif
+
+#if defined(__NEED_uint32_t) && !defined(__DEFINED_uint32_t)
+typedef unsigned int    uint32_t;
+#define __DEFINED_uint32_t
+#endif
+
+#if defined(__NEED_uint64_t) && !defined(__DEFINED_uint64_t)
+typedef unsigned _Int64 uint64_t;
+#define __DEFINED_uint64_t
+#endif
+
+#if defined(__NEED_u_int64_t) && !defined(__DEFINED_u_int64_t)
+typedef unsigned _Int64 u_int64_t;
+#define __DEFINED_u_int64_t
+#endif
+
+#if defined(__NEED_uintmax_t) && !defined(__DEFINED_uintmax_t)
+typedef unsigned _Int64 uintmax_t;
+#define __DEFINED_uintmax_t
+#endif
+
+
+#if defined(__NEED_mode_t) && !defined(__DEFINED_mode_t)
+typedef unsigned mode_t;
+#define __DEFINED_mode_t
+#endif
+
+#if defined(__NEED_nlink_t) && !defined(__DEFINED_nlink_t)
+typedef unsigned _Reg nlink_t;
+#define __DEFINED_nlink_t
+#endif
+
+#if defined(__NEED_off_t) && !defined(__DEFINED_off_t)
+typedef _Int64 off_t;
+#define __DEFINED_off_t
+#endif
+
+#if defined(__NEED_ino_t) && !defined(__DEFINED_ino_t)
+typedef unsigned _Int64 ino_t;
+#define __DEFINED_ino_t
+#endif
+
+#if defined(__NEED_dev_t) && !defined(__DEFINED_dev_t)
+typedef unsigned _Int64 dev_t;
+#define __DEFINED_dev_t
+#endif
+
+#if defined(__NEED_blksize_t) && !defined(__DEFINED_blksize_t)
+typedef long blksize_t;
+#define __DEFINED_blksize_t
+#endif
+
+#if defined(__NEED_blkcnt_t) && !defined(__DEFINED_blkcnt_t)
+typedef _Int64 blkcnt_t;
+#define __DEFINED_blkcnt_t
+#endif
+
+#if defined(__NEED_fsblkcnt_t) && !defined(__DEFINED_fsblkcnt_t)
+typedef unsigned _Int64 fsblkcnt_t;
+#define __DEFINED_fsblkcnt_t
+#endif
+
+#if defined(__NEED_fsfilcnt_t) && !defined(__DEFINED_fsfilcnt_t)
+typedef unsigned _Int64 fsfilcnt_t;
+#define __DEFINED_fsfilcnt_t
+#endif
+
+
+#if defined(__NEED_wint_t) && !defined(__DEFINED_wint_t)
+typedef unsigned wint_t;
+#define __DEFINED_wint_t
+#endif
+
+#if defined(__NEED_wctype_t) && !defined(__DEFINED_wctype_t)
+typedef unsigned long wctype_t;
+#define __DEFINED_wctype_t
+#endif
+
+
+#if defined(__NEED_timer_t) && !defined(__DEFINED_timer_t)
+typedef void * timer_t;
+#define __DEFINED_timer_t
+#endif
+
+#if defined(__NEED_clockid_t) && !defined(__DEFINED_clockid_t)
+typedef int clockid_t;
+#define __DEFINED_clockid_t
+#endif
+
+#if defined(__NEED_clock_t) && !defined(__DEFINED_clock_t)
+typedef long clock_t;
+#define __DEFINED_clock_t
+#endif
+
+#if defined(__NEED_struct_timeval) && !defined(__DEFINED_struct_timeval)
+struct timeval { time_t tv_sec; suseconds_t tv_usec; };
+#define __DEFINED_struct_timeval
+#endif
+
+#if defined(__NEED_struct_timespec) && !defined(__DEFINED_struct_timespec)
+struct timespec { time_t tv_sec; int :8*(sizeof(time_t)-sizeof(long))*(__BYTE_ORDER==4321); long tv_nsec; int :8*(sizeof(time_t)-sizeof(long))*(__BYTE_ORDER!=4321); };
+#define __DEFINED_struct_timespec
+#endif
+
+
+#if defined(__NEED_pid_t) && !defined(__DEFINED_pid_t)
+typedef int pid_t;
+#define __DEFINED_pid_t
+#endif
+
+#if defined(__NEED_id_t) && !defined(__DEFINED_id_t)
+typedef unsigned id_t;
+#define __DEFINED_id_t
+#endif
+
+#if defined(__NEED_uid_t) && !defined(__DEFINED_uid_t)
+typedef unsigned uid_t;
+#define __DEFINED_uid_t
+#endif
+
+#if defined(__NEED_gid_t) && !defined(__DEFINED_gid_t)
+typedef unsigned gid_t;
+#define __DEFINED_gid_t
+#endif
+
+#if defined(__NEED_key_t) && !defined(__DEFINED_key_t)
+typedef int key_t;
+#define __DEFINED_key_t
+#endif
+
+#if defined(__NEED_useconds_t) && !defined(__DEFINED_useconds_t)
+typedef unsigned useconds_t;
+#define __DEFINED_useconds_t
+#endif
+
+
+#ifdef __cplusplus
+#if defined(__NEED_pthread_t) && !defined(__DEFINED_pthread_t)
+typedef unsigned long pthread_t;
+#define __DEFINED_pthread_t
+#endif
+
+#else
+#if defined(__NEED_pthread_t) && !defined(__DEFINED_pthread_t)
+typedef struct __pthread * pthread_t;
+#define __DEFINED_pthread_t
+#endif
+
+#endif
+#if defined(__NEED_pthread_once_t) && !defined(__DEFINED_pthread_once_t)
+typedef int pthread_once_t;
+#define __DEFINED_pthread_once_t
+#endif
+
+#if defined(__NEED_pthread_key_t) && !defined(__DEFINED_pthread_key_t)
+typedef unsigned pthread_key_t;
+#define __DEFINED_pthread_key_t
+#endif
+
+#if defined(__NEED_pthread_spinlock_t) && !defined(__DEFINED_pthread_spinlock_t)
+typedef int pthread_spinlock_t;
+#define __DEFINED_pthread_spinlock_t
+#endif
+
+#if defined(__NEED_pthread_mutexattr_t) && !defined(__DEFINED_pthread_mutexattr_t)
+typedef struct { unsigned __attr; } pthread_mutexattr_t;
+#define __DEFINED_pthread_mutexattr_t
+#endif
+
+#if defined(__NEED_pthread_condattr_t) && !defined(__DEFINED_pthread_condattr_t)
+typedef struct { unsigned __attr; } pthread_condattr_t;
+#define __DEFINED_pthread_condattr_t
+#endif
+
+#if defined(__NEED_pthread_barrierattr_t) && !defined(__DEFINED_pthread_barrierattr_t)
+typedef struct { unsigned __attr; } pthread_barrierattr_t;
+#define __DEFINED_pthread_barrierattr_t
+#endif
+
+#if defined(__NEED_pthread_rwlockattr_t) && !defined(__DEFINED_pthread_rwlockattr_t)
+typedef struct { unsigned __attr[2]; } pthread_rwlockattr_t;
+#define __DEFINED_pthread_rwlockattr_t
+#endif
+
+
+#if defined(__NEED_struct__IO_FILE) && !defined(__DEFINED_struct__IO_FILE)
+struct _IO_FILE { char __x; };
+#define __DEFINED_struct__IO_FILE
+#endif
+
+#if defined(__NEED_FILE) && !defined(__DEFINED_FILE)
+typedef struct _IO_FILE FILE;
+#define __DEFINED_FILE
+#endif
+
+
+#if defined(__NEED_va_list) && !defined(__DEFINED_va_list)
+typedef __builtin_va_list va_list;
+#define __DEFINED_va_list
+#endif
+
+#if defined(__NEED___isoc_va_list) && !defined(__DEFINED___isoc_va_list)
+typedef __builtin_va_list __isoc_va_list;
+#define __DEFINED___isoc_va_list
+#endif
+
+
+#if defined(__NEED_mbstate_t) && !defined(__DEFINED_mbstate_t)
+typedef struct __mbstate_t { unsigned __opaque1, __opaque2; } mbstate_t;
+#define __DEFINED_mbstate_t
+#endif
+
+
+#if defined(__NEED_locale_t) && !defined(__DEFINED_locale_t)
+typedef struct __locale_struct * locale_t;
+#define __DEFINED_locale_t
+#endif
+
+
+#if defined(__NEED_sigset_t) && !defined(__DEFINED_sigset_t)
+typedef struct __sigset_t { unsigned long __bits[128/sizeof(long)]; } sigset_t;
+#define __DEFINED_sigset_t
+#endif
+
+
+#if defined(__NEED_struct_iovec) && !defined(__DEFINED_struct_iovec)
+struct iovec { void *iov_base; size_t iov_len; };
+#define __DEFINED_struct_iovec
+#endif
+
+
+#if defined(__NEED_struct_winsize) && !defined(__DEFINED_struct_winsize)
+struct winsize { unsigned short ws_row, ws_col, ws_xpixel, ws_ypixel; };
+#define __DEFINED_struct_winsize
+#endif
+
+
+#if defined(__NEED_socklen_t) && !defined(__DEFINED_socklen_t)
+typedef unsigned socklen_t;
+#define __DEFINED_socklen_t
+#endif
+
+#if defined(__NEED_sa_family_t) && !defined(__DEFINED_sa_family_t)
+typedef unsigned short sa_family_t;
+#define __DEFINED_sa_family_t
+#endif
+
+
+#if defined(__NEED_pthread_attr_t) && !defined(__DEFINED_pthread_attr_t)
+typedef struct { union { int __i[sizeof(long)==8?14:9]; volatile int __vi[sizeof(long)==8?14:9]; unsigned long __s[sizeof(long)==8?7:9]; } __u; } pthread_attr_t;
+#define __DEFINED_pthread_attr_t
+#endif
+
+#if defined(__NEED_pthread_mutex_t) && !defined(__DEFINED_pthread_mutex_t)
+typedef struct { union { int __i[sizeof(long)==8?10:6]; volatile int __vi[sizeof(long)==8?10:6]; volatile void *volatile __p[sizeof(long)==8?5:6]; } __u; } pthread_mutex_t;
+#define __DEFINED_pthread_mutex_t
+#endif
+
+#if defined(__NEED_mtx_t) && !defined(__DEFINED_mtx_t)
+typedef struct { union { int __i[sizeof(long)==8?10:6]; volatile int __vi[sizeof(long)==8?10:6]; volatile void *volatile __p[sizeof(long)==8?5:6]; } __u; } mtx_t;
+#define __DEFINED_mtx_t
+#endif
+
+#if defined(__NEED_pthread_cond_t) && !defined(__DEFINED_pthread_cond_t)
+typedef struct { union { int __i[12]; volatile int __vi[12]; void *__p[12*sizeof(int)/sizeof(void*)]; } __u; } pthread_cond_t;
+#define __DEFINED_pthread_cond_t
+#endif
+
+#if defined(__NEED_cnd_t) && !defined(__DEFINED_cnd_t)
+typedef struct { union { int __i[12]; volatile int __vi[12]; void *__p[12*sizeof(int)/sizeof(void*)]; } __u; } cnd_t;
+#define __DEFINED_cnd_t
+#endif
+
+#if defined(__NEED_pthread_rwlock_t) && !defined(__DEFINED_pthread_rwlock_t)
+typedef struct { union { int __i[sizeof(long)==8?14:8]; volatile int __vi[sizeof(long)==8?14:8]; void *__p[sizeof(long)==8?7:8]; } __u; } pthread_rwlock_t;
+#define __DEFINED_pthread_rwlock_t
+#endif
+
+#if defined(__NEED_pthread_barrier_t) && !defined(__DEFINED_pthread_barrier_t)
+typedef struct { union { int __i[sizeof(long)==8?8:5]; volatile int __vi[sizeof(long)==8?8:5]; void *__p[sizeof(long)==8?4:5]; } __u; } pthread_barrier_t;
+#define __DEFINED_pthread_barrier_t
+#endif
+
+
+#undef _Addr
+#undef _Int64
+#undef _Reg
\ No newline at end of file
diff --git a/zig/lib/libc/include/generic-musl/bits/fenv.h b/zig/lib/libc/include/generic-musl/bits/fenv.h
index b260c6f63b..1347e5f2fe 100644
--- a/zig/lib/libc/include/generic-musl/bits/fenv.h
+++ b/zig/lib/libc/include/generic-musl/bits/fenv.h
@@ -1,17 +1,34 @@
-#define FE_INVALID      16
-#define FE_DIVBYZERO    8
-#define FE_OVERFLOW     4
-#define FE_UNDERFLOW    2
-#define FE_INEXACT      1
+#define FE_INVALID    1
+#define __FE_DENORM   2
+#define FE_DIVBYZERO  4
+#define FE_OVERFLOW   8
+#define FE_UNDERFLOW  16
+#define FE_INEXACT    32
 
-#define FE_ALL_EXCEPT   31
+#define FE_ALL_EXCEPT 63
 
-#define FE_TONEAREST    0
-#define FE_DOWNWARD     2
-#define FE_UPWARD       3
-#define FE_TOWARDZERO   1
+#define FE_TONEAREST  0
+#define FE_DOWNWARD   0x400
+#define FE_UPWARD     0x800
+#define FE_TOWARDZERO 0xc00
 
-typedef unsigned int fexcept_t;
-typedef unsigned int fenv_t;
+typedef unsigned short fexcept_t;
+
+typedef struct {
+	unsigned short __control_word;
+	unsigned short __unused1;
+	unsigned short __status_word;
+	unsigned short __unused2;
+	unsigned short __tags;
+	unsigned short __unused3;
+	unsigned int __eip;
+	unsigned short __cs_selector;
+	unsigned int __opcode:11;
+	unsigned int __unused4:5;
+	unsigned int __data_offset;
+	unsigned short __data_selector;
+	unsigned short __unused5;
+	unsigned int __mxcsr;
+} fenv_t;
 
 #define FE_DFL_ENV      ((const fenv_t *) -1)
\ No newline at end of file
diff --git a/zig/lib/libc/include/generic-musl/bits/setjmp.h b/zig/lib/libc/include/generic-musl/bits/setjmp.h
new file mode 100644
index 0000000000..a7cb9dbc8b
--- /dev/null
+++ b/zig/lib/libc/include/generic-musl/bits/setjmp.h
@@ -0,0 +1 @@
+typedef unsigned long long __jmp_buf[23];
\ No newline at end of file
diff --git a/zig/lib/libc/include/generic-musl/bits/signal.h b/zig/lib/libc/include/generic-musl/bits/signal.h
new file mode 100644
index 0000000000..475aae6d68
--- /dev/null
+++ b/zig/lib/libc/include/generic-musl/bits/signal.h
@@ -0,0 +1,142 @@
+#if defined(_POSIX_SOURCE) || defined(_POSIX_C_SOURCE) \
+ || defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+
+#if defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+#define MINSIGSTKSZ 2048
+#define SIGSTKSZ 8192
+#endif
+
+#if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+typedef unsigned long long greg_t, gregset_t[32];
+
+typedef struct {
+	union {
+		double fp_dregs[32];
+		struct {
+			float _fp_fregs;
+			unsigned _fp_pad;
+		} fp_fregs[32];
+	} fp_r;
+} fpregset_t;
+
+struct sigcontext {
+	unsigned long long sc_regs[32];
+	unsigned long long sc_fpregs[32];
+	unsigned long long sc_mdhi;
+	unsigned long long sc_hi1;
+	unsigned long long sc_hi2;
+	unsigned long long sc_hi3;
+	unsigned long long sc_mdlo;
+	unsigned long long sc_lo1;
+	unsigned long long sc_lo2;
+	unsigned long long sc_lo3;
+	unsigned long long sc_pc;
+	unsigned int sc_fpc_csr;
+	unsigned int sc_used_math;
+	unsigned int sc_dsp;
+	unsigned int sc_reserved;
+};
+
+typedef struct {
+	gregset_t gregs;
+	fpregset_t fpregs;
+	greg_t mdhi;
+	greg_t hi1;
+	greg_t hi2;
+	greg_t hi3;
+	greg_t mdlo;
+	greg_t lo1;
+	greg_t lo2;
+	greg_t lo3;
+	greg_t pc;
+	unsigned int fpc_csr;
+	unsigned int used_math;
+	unsigned int dsp;
+	unsigned int reserved;
+} mcontext_t;
+
+#else
+typedef struct {
+	unsigned long long __mc1[32];
+	double __mc2[32];
+	unsigned long long __mc3[9];
+	unsigned __mc4[4];
+} mcontext_t;
+#endif
+
+struct sigaltstack {
+	void *ss_sp;
+	size_t ss_size;
+	int ss_flags;
+};
+
+typedef struct __ucontext {
+	unsigned long uc_flags;
+	struct __ucontext *uc_link;
+	stack_t uc_stack;
+	mcontext_t uc_mcontext;
+	sigset_t uc_sigmask;
+} ucontext_t;
+
+#define SA_NOCLDSTOP  1
+#define SA_NOCLDWAIT  0x10000
+#define SA_SIGINFO    8
+#define SA_ONSTACK    0x08000000
+#define SA_RESTART    0x10000000
+#define SA_NODEFER    0x40000000
+#define SA_RESETHAND  0x80000000
+
+#undef SIG_BLOCK
+#undef SIG_UNBLOCK
+#undef SIG_SETMASK
+#define SIG_BLOCK     1
+#define SIG_UNBLOCK   2
+#define SIG_SETMASK   3
+
+#undef SI_ASYNCIO
+#undef SI_MESGQ
+#undef SI_TIMER
+#define SI_ASYNCIO (-2)
+#define SI_MESGQ (-4)
+#define SI_TIMER (-3)
+
+#define __SI_SWAP_ERRNO_CODE
+
+#endif
+
+#define SIGHUP    1
+#define SIGINT    2
+#define SIGQUIT   3
+#define SIGILL    4
+#define SIGTRAP   5
+#define SIGABRT   6
+#define SIGIOT    SIGABRT
+#define SIGEMT    7
+#define SIGFPE    8
+#define SIGKILL   9
+#define SIGBUS    10
+#define SIGSEGV   11
+#define SIGSYS    12
+#define SIGPIPE   13
+#define SIGALRM   14
+#define SIGTERM   15
+#define SIGUSR1   16
+#define SIGUSR2   17
+#define SIGCHLD   18
+#define SIGPWR    19
+#define SIGWINCH  20
+#define SIGURG    21
+#define SIGIO     22
+#define SIGPOLL   SIGIO
+#define SIGSTOP   23
+#define SIGTSTP   24
+#define SIGCONT   25
+#define SIGTTIN   26
+#define SIGTTOU   27
+#define SIGVTALRM 28
+#define SIGPROF   29
+#define SIGXCPU   30
+#define SIGXFSZ   31
+#define SIGUNUSED SIGSYS
+
+#define _NSIG 128
\ No newline at end of file
diff --git a/zig/lib/libc/include/generic-musl/bits/stdint.h b/zig/lib/libc/include/generic-musl/bits/stdint.h
index 02714d7398..b70a87dc9d 100644
--- a/zig/lib/libc/include/generic-musl/bits/stdint.h
+++ b/zig/lib/libc/include/generic-musl/bits/stdint.h
@@ -12,9 +12,9 @@ typedef uint32_t uint_fast32_t;
 #define UINT_FAST16_MAX UINT32_MAX
 #define UINT_FAST32_MAX UINT32_MAX
 
-#define INTPTR_MIN      INT64_MIN
-#define INTPTR_MAX      INT64_MAX
-#define UINTPTR_MAX     UINT64_MAX
-#define PTRDIFF_MIN     INT64_MIN
-#define PTRDIFF_MAX     INT64_MAX
-#define SIZE_MAX        UINT64_MAX
\ No newline at end of file
+#define INTPTR_MIN      INT32_MIN
+#define INTPTR_MAX      INT32_MAX
+#define UINTPTR_MAX     UINT32_MAX
+#define PTRDIFF_MIN     INT32_MIN
+#define PTRDIFF_MAX     INT32_MAX
+#define SIZE_MAX        UINT32_MAX
\ No newline at end of file
diff --git a/zig/lib/libc/include/loongarch64-linux-musl/bits/stdint.h b/zig/lib/libc/include/loongarch64-linux-musl/bits/stdint.h
new file mode 100644
index 0000000000..02714d7398
--- /dev/null
+++ b/zig/lib/libc/include/loongarch64-linux-musl/bits/stdint.h
@@ -0,0 +1,20 @@
+typedef int32_t int_fast16_t;
+typedef int32_t int_fast32_t;
+typedef uint32_t uint_fast16_t;
+typedef uint32_t uint_fast32_t;
+
+#define INT_FAST16_MIN  INT32_MIN
+#define INT_FAST32_MIN  INT32_MIN
+
+#define INT_FAST16_MAX  INT32_MAX
+#define INT_FAST32_MAX  INT32_MAX
+
+#define UINT_FAST16_MAX UINT32_MAX
+#define UINT_FAST32_MAX UINT32_MAX
+
+#define INTPTR_MIN      INT64_MIN
+#define INTPTR_MAX      INT64_MAX
+#define UINTPTR_MAX     UINT64_MAX
+#define PTRDIFF_MIN     INT64_MIN
+#define PTRDIFF_MAX     INT64_MAX
+#define SIZE_MAX        UINT64_MAX
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-musl/bits/stdint.h b/zig/lib/libc/include/mips64-linux-musl/bits/stdint.h
new file mode 100644
index 0000000000..02714d7398
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-musl/bits/stdint.h
@@ -0,0 +1,20 @@
+typedef int32_t int_fast16_t;
+typedef int32_t int_fast32_t;
+typedef uint32_t uint_fast16_t;
+typedef uint32_t uint_fast32_t;
+
+#define INT_FAST16_MIN  INT32_MIN
+#define INT_FAST32_MIN  INT32_MIN
+
+#define INT_FAST16_MAX  INT32_MAX
+#define INT_FAST32_MAX  INT32_MAX
+
+#define UINT_FAST16_MAX UINT32_MAX
+#define UINT_FAST32_MAX UINT32_MAX
+
+#define INTPTR_MIN      INT64_MIN
+#define INTPTR_MAX      INT64_MAX
+#define UINTPTR_MAX     UINT64_MAX
+#define PTRDIFF_MIN     INT64_MIN
+#define PTRDIFF_MAX     INT64_MAX
+#define SIZE_MAX        UINT64_MAX
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/errno.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/errno.h
new file mode 100644
index 0000000000..54adcccfee
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/errno.h
@@ -0,0 +1,134 @@
+#define EPERM            1
+#define ENOENT           2
+#define ESRCH            3
+#define EINTR            4
+#define EIO              5
+#define ENXIO            6
+#define E2BIG            7
+#define ENOEXEC          8
+#define EBADF            9
+#define ECHILD          10
+#define EAGAIN          11
+#define ENOMEM          12
+#define EACCES          13
+#define EFAULT          14
+#define ENOTBLK         15
+#define EBUSY           16
+#define EEXIST          17
+#define EXDEV           18
+#define ENODEV          19
+#define ENOTDIR         20
+#define EISDIR          21
+#define EINVAL          22
+#define ENFILE          23
+#define EMFILE          24
+#define ENOTTY          25
+#define ETXTBSY         26
+#define EFBIG           27
+#define ENOSPC          28
+#define ESPIPE          29
+#define EROFS           30
+#define EMLINK          31
+#define EPIPE           32
+#define EDOM            33
+#define ERANGE          34
+#define ENOMSG          35
+#define EIDRM           36
+#define ECHRNG          37
+#define EL2NSYNC        38
+#define EL3HLT          39
+#define EL3RST          40
+#define ELNRNG          41
+#define EUNATCH         42
+#define ENOCSI          43
+#define EL2HLT          44
+#define EDEADLK         45
+#define ENOLCK          46
+#define EBADE           50
+#define EBADR           51
+#define EXFULL          52
+#define ENOANO          53
+#define EBADRQC         54
+#define EBADSLT         55
+#define EDEADLOCK       56
+#define EBFONT          59
+#define ENOSTR          60
+#define ENODATA         61
+#define ETIME           62
+#define ENOSR           63
+#define ENONET          64
+#define ENOPKG          65
+#define EREMOTE         66
+#define ENOLINK         67
+#define EADV            68
+#define ESRMNT          69
+#define ECOMM           70
+#define EPROTO          71
+#define EDOTDOT         73
+#define EMULTIHOP       74
+#define EBADMSG         77
+#define ENAMETOOLONG    78
+#define EOVERFLOW       79
+#define ENOTUNIQ        80
+#define EBADFD          81
+#define EREMCHG         82
+#define ELIBACC         83
+#define ELIBBAD         84
+#define ELIBSCN         85
+#define ELIBMAX         86
+#define ELIBEXEC        87
+#define EILSEQ          88
+#define ENOSYS          89
+#define ELOOP           90
+#define ERESTART        91
+#define ESTRPIPE        92
+#define ENOTEMPTY       93
+#define EUSERS          94
+#define ENOTSOCK        95
+#define EDESTADDRREQ    96
+#define EMSGSIZE        97
+#define EPROTOTYPE      98
+#define ENOPROTOOPT     99
+#define EPROTONOSUPPORT 120
+#define ESOCKTNOSUPPORT 121
+#define EOPNOTSUPP      122
+#define ENOTSUP         EOPNOTSUPP
+#define EPFNOSUPPORT    123
+#define EAFNOSUPPORT    124
+#define EADDRINUSE      125
+#define EADDRNOTAVAIL   126
+#define ENETDOWN        127
+#define ENETUNREACH     128
+#define ENETRESET       129
+#define ECONNABORTED    130
+#define ECONNRESET      131
+#define ENOBUFS         132
+#define EISCONN         133
+#define ENOTCONN        134
+#define EUCLEAN         135
+#define ENOTNAM         137
+#define ENAVAIL         138
+#define EISNAM          139
+#define EREMOTEIO       140
+#define ESHUTDOWN       143
+#define ETOOMANYREFS    144
+#define ETIMEDOUT       145
+#define ECONNREFUSED    146
+#define EHOSTDOWN       147
+#define EHOSTUNREACH    148
+#define EWOULDBLOCK     EAGAIN
+#define EALREADY        149
+#define EINPROGRESS     150
+#define ESTALE          151
+#define ECANCELED       158
+#define ENOMEDIUM       159
+#define EMEDIUMTYPE     160
+#define ENOKEY          161
+#define EKEYEXPIRED     162
+#define EKEYREVOKED     163
+#define EKEYREJECTED    164
+#define EOWNERDEAD      165
+#define ENOTRECOVERABLE 166
+#define ERFKILL         167
+#define EHWPOISON       168
+#define EDQUOT          1133
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/fcntl.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/fcntl.h
new file mode 100644
index 0000000000..911a8adc48
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/fcntl.h
@@ -0,0 +1,40 @@
+#define O_CREAT        0400
+#define O_EXCL        02000
+#define O_NOCTTY      04000
+#define O_TRUNC       01000
+#define O_APPEND       0010
+#define O_NONBLOCK     0200
+#define O_DSYNC        0020
+#define O_SYNC       040020
+#define O_RSYNC      040020
+#define O_DIRECTORY 0200000
+#define O_NOFOLLOW  0400000
+#define O_CLOEXEC  02000000
+
+#define O_ASYNC      010000
+#define O_DIRECT    0100000
+#define O_LARGEFILE  020000
+#define O_NOATIME  01000000
+#define O_PATH    010000000
+#define O_TMPFILE 020200000
+#define O_NDELAY O_NONBLOCK
+
+#define F_DUPFD  0
+#define F_GETFD  1
+#define F_SETFD  2
+#define F_GETFL  3
+#define F_SETFL  4
+
+#define F_SETOWN 24
+#define F_GETOWN 23
+#define F_SETSIG 10
+#define F_GETSIG 11
+
+#define F_GETLK 33
+#define F_SETLK 34
+#define F_SETLKW 35
+
+#define F_SETOWN_EX 15
+#define F_GETOWN_EX 16
+
+#define F_GETOWNER_UIDS 17
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/fenv.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/fenv.h
new file mode 100644
index 0000000000..dbf9b368f1
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/fenv.h
@@ -0,0 +1,25 @@
+#ifdef __mips_soft_float
+#define FE_ALL_EXCEPT 0
+#define FE_TONEAREST  0
+#else
+#define FE_INEXACT    4
+#define FE_UNDERFLOW  8
+#define FE_OVERFLOW   16
+#define FE_DIVBYZERO  32
+#define FE_INVALID    64
+
+#define FE_ALL_EXCEPT 124
+
+#define FE_TONEAREST  0
+#define FE_TOWARDZERO 1
+#define FE_UPWARD     2
+#define FE_DOWNWARD   3
+#endif
+
+typedef unsigned short fexcept_t;
+
+typedef struct {
+	unsigned __cw;
+} fenv_t;
+
+#define FE_DFL_ENV      ((const fenv_t *) -1)
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/hwcap.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/hwcap.h
new file mode 100644
index 0000000000..0cc1faa9f7
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/hwcap.h
@@ -0,0 +1,3 @@
+#define HWCAP_MIPS_R6		(1 << 0)
+#define HWCAP_MIPS_MSA		(1 << 1)
+#define HWCAP_MIPS_CRC32	(1 << 2)
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/ioctl.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/ioctl.h
new file mode 100644
index 0000000000..c4fbd0d8df
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/ioctl.h
@@ -0,0 +1,114 @@
+#define _IOC(a,b,c,d) ( ((a)<<29) | ((b)<<8) | (c) | ((d)<<16) )
+#define _IOC_NONE  1U
+#define _IOC_READ  2U
+#define _IOC_WRITE 4U
+
+#define _IO(a,b) _IOC(_IOC_NONE,(a),(b),0)
+#define _IOW(a,b,c) _IOC(_IOC_WRITE,(a),(b),sizeof(c))
+#define _IOR(a,b,c) _IOC(_IOC_READ,(a),(b),sizeof(c))
+#define _IOWR(a,b,c) _IOC(_IOC_READ|_IOC_WRITE,(a),(b),sizeof(c))
+
+#define TCGETA		0x5401
+#define TCSETA		0x5402
+#define TCSETAW		0x5403
+#define TCSETAF		0x5404
+#define TCSBRK		0x5405
+#define TCXONC		0x5406
+#define TCFLSH		0x5407
+#define TCGETS		0x540D
+#define TCSETS		0x540E
+#define TCSETSW		0x540F
+#define TCSETSF		0x5410
+
+#define TIOCEXCL	0x740D
+#define TIOCNXCL	0x740E
+#define TIOCOUTQ	0x7472
+#define TIOCSTI		0x5472
+#define TIOCMGET	0x741D
+#define TIOCMBIS	0x741B
+#define TIOCMBIC	0x741C
+#define TIOCMSET	0x741A
+
+#define TIOCPKT		0x5470
+#define TIOCSWINSZ	_IOW('t', 103, struct winsize)
+#define TIOCGWINSZ	_IOR('t', 104, struct winsize)
+#define TIOCNOTTY	0x5471
+#define TIOCSETD	0x7401
+#define TIOCGETD	0x7400
+
+#define FIOCLEX		0x6601
+#define FIONCLEX	0x6602
+#define FIOASYNC	0x667D
+#define FIONBIO		0x667E
+#define FIOQSIZE	0x667F
+
+#define TIOCGLTC        0x7474
+#define TIOCSLTC        0x7475
+#define TIOCSPGRP	_IOW('t', 118, int)
+#define TIOCGPGRP	_IOR('t', 119, int)
+#define TIOCCONS	_IOW('t', 120, int)
+
+#define FIONREAD	0x467F
+#define TIOCINQ		FIONREAD
+
+#define TIOCGETP        0x7408
+#define TIOCSETP        0x7409
+#define TIOCSETN        0x740A
+
+#define TIOCSBRK	0x5427
+#define TIOCCBRK	0x5428
+#define TIOCGSID	0x7416
+#define TIOCGRS485	_IOR('T', 0x2E, char[32])
+#define TIOCSRS485	_IOWR('T', 0x2F, char[32])
+#define TIOCGPTN	_IOR('T', 0x30, unsigned int)
+#define TIOCSPTLCK	_IOW('T', 0x31, int)
+#define TIOCGDEV	_IOR('T', 0x32, unsigned int)
+#define TIOCSIG		_IOW('T', 0x36, int)
+#define TIOCVHANGUP	0x5437
+#define TIOCGPKT	_IOR('T', 0x38, int)
+#define TIOCGPTLCK	_IOR('T', 0x39, int)
+#define TIOCGEXCL	_IOR('T', 0x40, int)
+#define TIOCGPTPEER	_IO('T', 0x41)
+
+#define TIOCSCTTY	0x5480
+#define TIOCGSOFTCAR	0x5481
+#define TIOCSSOFTCAR	0x5482
+#define TIOCLINUX	0x5483
+#define TIOCGSERIAL	0x5484
+#define TIOCSSERIAL	0x5485
+#define TCSBRKP		0x5486
+
+#define TIOCSERCONFIG	0x5488
+#define TIOCSERGWILD	0x5489
+#define TIOCSERSWILD	0x548A
+#define TIOCGLCKTRMIOS	0x548B
+#define TIOCSLCKTRMIOS	0x548C
+#define TIOCSERGSTRUCT	0x548D
+#define TIOCSERGETLSR   0x548E
+#define TIOCSERGETMULTI 0x548F
+#define TIOCSERSETMULTI 0x5490
+#define TIOCMIWAIT	0x5491
+#define TIOCGICOUNT	0x5492
+
+#define TIOCM_LE	0x001
+#define TIOCM_DTR	0x002
+#define TIOCM_RTS	0x004
+#define TIOCM_ST	0x010
+#define TIOCM_SR	0x020
+#define TIOCM_CTS	0x040
+#define TIOCM_CAR	0x100
+#define TIOCM_CD	TIOCM_CAR
+#define TIOCM_RNG	0x200
+#define TIOCM_RI	TIOCM_RNG
+#define TIOCM_DSR	0x400
+#define TIOCM_OUT1	0x2000
+#define TIOCM_OUT2	0x4000
+#define TIOCM_LOOP	0x8000
+
+#define FIOGETOWN       _IOR('f', 123, int)
+#define FIOSETOWN       _IOW('f', 124, int)
+#define SIOCATMARK      _IOR('s', 7, int)
+#define SIOCSPGRP       _IOW('s', 8, pid_t)
+#define SIOCGPGRP       _IOR('s', 9, pid_t)
+#define SIOCGSTAMP      _IOR(0x89, 6, char[16])
+#define SIOCGSTAMPNS    _IOR(0x89, 7, char[16])
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/ipcstat.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/ipcstat.h
new file mode 100644
index 0000000000..d055f3e837
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/ipcstat.h
@@ -0,0 +1 @@
+#define IPC_STAT 0x102
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/mman.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/mman.h
new file mode 100644
index 0000000000..54231d15a7
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/mman.h
@@ -0,0 +1,25 @@
+#undef MAP_ANON
+#define MAP_ANON       0x800
+#undef MAP_NORESERVE
+#define MAP_NORESERVE  0x0400
+#undef MAP_GROWSDOWN
+#define MAP_GROWSDOWN  0x1000
+#undef MAP_DENYWRITE
+#define MAP_DENYWRITE  0x2000
+#undef MAP_EXECUTABLE
+#define MAP_EXECUTABLE 0x4000
+#undef MAP_LOCKED
+#define MAP_LOCKED     0x8000
+#undef MAP_POPULATE
+#define MAP_POPULATE   0x10000
+#undef MAP_NONBLOCK
+#define MAP_NONBLOCK   0x20000
+#undef MAP_STACK
+#define MAP_STACK      0x40000
+#undef MAP_HUGETLB
+#define MAP_HUGETLB    0x80000
+#undef MAP_SYNC
+
+#if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+#undef MADV_SOFT_OFFLINE
+#endif
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/msg.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/msg.h
new file mode 100644
index 0000000000..9e428cabd5
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/msg.h
@@ -0,0 +1,27 @@
+struct msqid_ds {
+	struct ipc_perm msg_perm;
+#if _MIPSEL || __MIPSEL || __MIPSEL__
+	unsigned long __msg_stime_lo;
+	unsigned long __msg_stime_hi;
+	unsigned long __msg_rtime_lo;
+	unsigned long __msg_rtime_hi;
+	unsigned long __msg_ctime_lo;
+	unsigned long __msg_ctime_hi;
+#else
+	unsigned long __msg_stime_hi;
+	unsigned long __msg_stime_lo;
+	unsigned long __msg_rtime_hi;
+	unsigned long __msg_rtime_lo;
+	unsigned long __msg_ctime_hi;
+	unsigned long __msg_ctime_lo;
+#endif
+	unsigned long msg_cbytes;
+	msgqnum_t msg_qnum;
+	msglen_t msg_qbytes;
+	pid_t msg_lspid;
+	pid_t msg_lrpid;
+	unsigned long __unused[2];
+	time_t msg_stime;
+	time_t msg_rtime;
+	time_t msg_ctime;
+};
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/poll.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/poll.h
new file mode 100644
index 0000000000..cefdd9be80
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/poll.h
@@ -0,0 +1,2 @@
+#define POLLWRNORM POLLOUT
+#define POLLWRBAND 0x100
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/ptrace.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/ptrace.h
new file mode 100644
index 0000000000..275462def0
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/ptrace.h
@@ -0,0 +1,9 @@
+#define PTRACE_GET_THREAD_AREA	25
+#define PTRACE_SET_THREAD_AREA	26
+#define PTRACE_PEEKTEXT_3264	0xc0
+#define PTRACE_PEEKDATA_3264	0xc1
+#define PTRACE_POKETEXT_3264	0xc2
+#define PTRACE_POKEDATA_3264	0xc3
+#define PTRACE_GET_THREAD_AREA_3264	0xc4
+#define PTRACE_GET_WATCH_REGS	0xd0
+#define PTRACE_SET_WATCH_REGS	0xd1
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/reg.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/reg.h
new file mode 100644
index 0000000000..e40c44d384
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/reg.h
@@ -0,0 +1,47 @@
+#undef __WORDSIZE
+#define __WORDSIZE 64
+
+#define EF_R0 0
+#define EF_R1 1
+#define EF_R2 2
+#define EF_R3 3
+#define EF_R4 4
+#define EF_R5 5
+#define EF_R6 6
+#define EF_R7 7
+#define EF_R8 8
+#define EF_R9 9
+#define EF_R10 10
+#define EF_R11 11
+#define EF_R12 12
+#define EF_R13 13
+#define EF_R14 14
+#define EF_R15 15
+#define EF_R16 16
+#define EF_R17 17
+#define EF_R18 18
+#define EF_R19 19
+#define EF_R20 20
+#define EF_R21 21
+#define EF_R22 22
+#define EF_R23 23
+#define EF_R24 24
+#define EF_R25 25
+
+#define EF_R26 26
+#define EF_R27 27
+#define EF_R28 28
+#define EF_R29 29
+#define EF_R30 30
+#define EF_R31 31
+
+#define EF_LO 32
+#define EF_HI 33
+
+#define EF_CP0_EPC 34
+#define EF_CP0_BADVADDR 35
+#define EF_CP0_STATUS 36
+#define EF_CP0_CAUSE 37
+#define EF_UNUSED0 38
+
+#define EF_SIZE 304
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/resource.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/resource.h
new file mode 100644
index 0000000000..ef7ada7cb1
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/resource.h
@@ -0,0 +1,5 @@
+#define RLIMIT_NOFILE  5
+#define RLIMIT_AS      6
+#define RLIMIT_RSS     7
+#define RLIMIT_NPROC   8
+#define RLIMIT_MEMLOCK 9
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/sem.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/sem.h
new file mode 100644
index 0000000000..87b05d488d
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/sem.h
@@ -0,0 +1,16 @@
+struct semid_ds {
+	struct ipc_perm sem_perm;
+	unsigned long __sem_otime_lo;
+	unsigned long __sem_ctime_lo;
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+	unsigned short sem_nsems;
+	char __sem_nsems_pad[sizeof(long)-sizeof(short)];
+#else
+	char __sem_nsems_pad[sizeof(long)-sizeof(short)];
+	unsigned short sem_nsems;
+#endif
+	unsigned long __sem_otime_hi;
+	unsigned long __sem_ctime_hi;
+	time_t sem_otime;
+	time_t sem_ctime;
+};
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/shm.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/shm.h
new file mode 100644
index 0000000000..4e5357d24f
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/shm.h
@@ -0,0 +1,29 @@
+#define SHMLBA 4096
+
+struct shmid_ds {
+	struct ipc_perm shm_perm;
+	size_t shm_segsz;
+	unsigned long __shm_atime_lo;
+	unsigned long __shm_dtime_lo;
+	unsigned long __shm_ctime_lo;
+	pid_t shm_cpid;
+	pid_t shm_lpid;
+	unsigned long shm_nattch;
+	unsigned short __shm_atime_hi;
+	unsigned short __shm_dtime_hi;
+	unsigned short __shm_ctime_hi;
+	unsigned short __pad1;
+	time_t shm_atime;
+	time_t shm_dtime;
+	time_t shm_ctime;
+};
+
+struct shminfo {
+	unsigned long shmmax, shmmin, shmmni, shmseg, shmall, __unused[4];
+};
+
+struct shm_info {
+	int __used_ids;
+	unsigned long shm_tot, shm_rss, shm_swp;
+	unsigned long __swap_attempts, __swap_successes;
+};
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/socket.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/socket.h
new file mode 100644
index 0000000000..751f71fc47
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/socket.h
@@ -0,0 +1,35 @@
+#define SOCK_STREAM    2
+#define SOCK_DGRAM     1
+
+#define SOL_SOCKET     65535
+
+#define SO_DEBUG        1
+
+#define SO_REUSEADDR    0x0004
+#define SO_KEEPALIVE    0x0008
+#define SO_DONTROUTE    0x0010
+#define SO_BROADCAST    0x0020
+#define SO_LINGER       0x0080
+#define SO_OOBINLINE    0x0100
+#define SO_REUSEPORT    0x0200
+#define SO_SNDBUF       0x1001
+#define SO_RCVBUF       0x1002
+#define SO_SNDLOWAT     0x1003
+#define SO_RCVLOWAT     0x1004
+#define SO_ERROR        0x1007
+#define SO_TYPE         0x1008
+#define SO_ACCEPTCONN   0x1009
+#define SO_PROTOCOL     0x1028
+#define SO_DOMAIN       0x1029
+
+#define SO_NO_CHECK     11
+#define SO_PRIORITY     12
+#define SO_BSDCOMPAT    14
+#define SO_PASSCRED     17
+#define SO_PEERCRED     18
+#define SO_PEERSEC      30
+#define SO_SNDBUFFORCE  31
+#define SO_RCVBUFFORCE  33
+
+#define SOCK_NONBLOCK     0200
+#define SOCK_CLOEXEC  02000000
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/stat.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/stat.h
new file mode 100644
index 0000000000..31dcbd46cb
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/stat.h
@@ -0,0 +1,23 @@
+struct stat {
+	dev_t st_dev;
+	long __pad1[2];
+	ino_t st_ino;
+	mode_t st_mode;
+	nlink_t st_nlink;
+	uid_t st_uid;
+	gid_t st_gid;
+	dev_t st_rdev;
+	long __pad2[2];
+	off_t st_size;
+	struct {
+		long tv_sec;
+		long tv_nsec;
+	} __st_atim32, __st_mtim32, __st_ctim32;
+	blksize_t st_blksize;
+	long __pad3;
+	blkcnt_t st_blocks;
+	struct timespec st_atim;
+	struct timespec st_mtim;
+	struct timespec st_ctim;
+	long __pad4[2];
+};
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/statfs.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/statfs.h
new file mode 100644
index 0000000000..8fdd34ef66
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/statfs.h
@@ -0,0 +1,8 @@
+struct statfs {
+	unsigned long f_type, f_bsize, f_frsize;
+	fsblkcnt_t f_blocks, f_bfree;
+	fsfilcnt_t f_files, f_ffree;
+	fsblkcnt_t f_bavail;
+	fsid_t f_fsid;
+	unsigned long f_namelen, f_flags, f_spare[5];
+};
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/syscall.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/syscall.h
new file mode 100644
index 0000000000..2fa9aa090f
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/syscall.h
@@ -0,0 +1,759 @@
+#define __NR_read			6000
+#define __NR_write			6001
+#define __NR_open			6002
+#define __NR_close			6003
+#define __NR_stat			6004
+#define __NR_fstat			6005
+#define __NR_lstat			6006
+#define __NR_poll			6007
+#define __NR_lseek			6008
+#define __NR_mmap			6009
+#define __NR_mprotect			6010
+#define __NR_munmap			6011
+#define __NR_brk			6012
+#define __NR_rt_sigaction		6013
+#define __NR_rt_sigprocmask		6014
+#define __NR_ioctl			6015
+#define __NR_pread64			6016
+#define __NR_pwrite64			6017
+#define __NR_readv			6018
+#define __NR_writev			6019
+#define __NR_access			6020
+#define __NR_pipe			6021
+#define __NR__newselect			6022
+#define __NR_sched_yield		6023
+#define __NR_mremap			6024
+#define __NR_msync			6025
+#define __NR_mincore			6026
+#define __NR_madvise			6027
+#define __NR_shmget			6028
+#define __NR_shmat			6029
+#define __NR_shmctl			6030
+#define __NR_dup			6031
+#define __NR_dup2			6032
+#define __NR_pause			6033
+#define __NR_nanosleep			6034
+#define __NR_getitimer			6035
+#define __NR_setitimer			6036
+#define __NR_alarm			6037
+#define __NR_getpid			6038
+#define __NR_sendfile			6039
+#define __NR_socket			6040
+#define __NR_connect			6041
+#define __NR_accept			6042
+#define __NR_sendto			6043
+#define __NR_recvfrom			6044
+#define __NR_sendmsg			6045
+#define __NR_recvmsg			6046
+#define __NR_shutdown			6047
+#define __NR_bind			6048
+#define __NR_listen			6049
+#define __NR_getsockname		6050
+#define __NR_getpeername		6051
+#define __NR_socketpair			6052
+#define __NR_setsockopt			6053
+#define __NR_getsockopt			6054
+#define __NR_clone			6055
+#define __NR_fork			6056
+#define __NR_execve			6057
+#define __NR_exit			6058
+#define __NR_wait4			6059
+#define __NR_kill			6060
+#define __NR_uname			6061
+#define __NR_semget			6062
+#define __NR_semop			6063
+#define __NR_semctl			6064
+#define __NR_shmdt			6065
+#define __NR_msgget			6066
+#define __NR_msgsnd			6067
+#define __NR_msgrcv			6068
+#define __NR_msgctl			6069
+#define __NR_fcntl			6070
+#define __NR_flock			6071
+#define __NR_fsync			6072
+#define __NR_fdatasync			6073
+#define __NR_truncate			6074
+#define __NR_ftruncate			6075
+#define __NR_getdents			6076
+#define __NR_getcwd			6077
+#define __NR_chdir			6078
+#define __NR_fchdir			6079
+#define __NR_rename			6080
+#define __NR_mkdir			6081
+#define __NR_rmdir			6082
+#define __NR_creat			6083
+#define __NR_link			6084
+#define __NR_unlink			6085
+#define __NR_symlink			6086
+#define __NR_readlink			6087
+#define __NR_chmod			6088
+#define __NR_fchmod			6089
+#define __NR_chown			6090
+#define __NR_fchown			6091
+#define __NR_lchown			6092
+#define __NR_umask			6093
+#define __NR_gettimeofday_time32		6094
+#define __NR_getrlimit			6095
+#define __NR_getrusage			6096
+#define __NR_sysinfo			6097
+#define __NR_times			6098
+#define __NR_ptrace			6099
+#define __NR_getuid			6100
+#define __NR_syslog			6101
+#define __NR_getgid			6102
+#define __NR_setuid			6103
+#define __NR_setgid			6104
+#define __NR_geteuid			6105
+#define __NR_getegid			6106
+#define __NR_setpgid			6107
+#define __NR_getppid			6108
+#define __NR_getpgrp			6109
+#define __NR_setsid			6110
+#define __NR_setreuid			6111
+#define __NR_setregid			6112
+#define __NR_getgroups			6113
+#define __NR_setgroups			6114
+#define __NR_setresuid			6115
+#define __NR_getresuid			6116
+#define __NR_setresgid			6117
+#define __NR_getresgid			6118
+#define __NR_getpgid			6119
+#define __NR_setfsuid			6120
+#define __NR_setfsgid			6121
+#define __NR_getsid			6122
+#define __NR_capget			6123
+#define __NR_capset			6124
+#define __NR_rt_sigpending		6125
+#define __NR_rt_sigtimedwait		6126
+#define __NR_rt_sigqueueinfo		6127
+#define __NR_rt_sigsuspend		6128
+#define __NR_sigaltstack		6129
+#define __NR_utime			6130
+#define __NR_mknod			6131
+#define __NR_personality		6132
+#define __NR_ustat			6133
+#define __NR_statfs			6134
+#define __NR_fstatfs			6135
+#define __NR_sysfs			6136
+#define __NR_getpriority		6137
+#define __NR_setpriority		6138
+#define __NR_sched_setparam		6139
+#define __NR_sched_getparam		6140
+#define __NR_sched_setscheduler		6141
+#define __NR_sched_getscheduler		6142
+#define __NR_sched_get_priority_max	6143
+#define __NR_sched_get_priority_min	6144
+#define __NR_sched_rr_get_interval	6145
+#define __NR_mlock			6146
+#define __NR_munlock			6147
+#define __NR_mlockall			6148
+#define __NR_munlockall			6149
+#define __NR_vhangup			6150
+#define __NR_pivot_root			6151
+#define __NR__sysctl			6152
+#define __NR_prctl			6153
+#define __NR_adjtimex			6154
+#define __NR_setrlimit			6155
+#define __NR_chroot			6156
+#define __NR_sync			6157
+#define __NR_acct			6158
+#define __NR_settimeofday_time32		6159
+#define __NR_mount			6160
+#define __NR_umount2			6161
+#define __NR_swapon			6162
+#define __NR_swapoff			6163
+#define __NR_reboot			6164
+#define __NR_sethostname		6165
+#define __NR_setdomainname		6166
+#define __NR_create_module		6167
+#define __NR_init_module		6168
+#define __NR_delete_module		6169
+#define __NR_get_kernel_syms		6170
+#define __NR_query_module		6171
+#define __NR_quotactl			6172
+#define __NR_nfsservctl			6173
+#define __NR_getpmsg			6174
+#define __NR_putpmsg			6175
+#define __NR_afs_syscall		6176
+#define __NR_reserved177		6177
+#define __NR_gettid			6178
+#define __NR_readahead			6179
+#define __NR_setxattr			6180
+#define __NR_lsetxattr			6181
+#define __NR_fsetxattr			6182
+#define __NR_getxattr			6183
+#define __NR_lgetxattr			6184
+#define __NR_fgetxattr			6185
+#define __NR_listxattr			6186
+#define __NR_llistxattr			6187
+#define __NR_flistxattr			6188
+#define __NR_removexattr		6189
+#define __NR_lremovexattr		6190
+#define __NR_fremovexattr		6191
+#define __NR_tkill			6192
+#define __NR_reserved193		6193
+#define __NR_futex			6194
+#define __NR_sched_setaffinity		6195
+#define __NR_sched_getaffinity		6196
+#define __NR_cacheflush			6197
+#define __NR_cachectl			6198
+#define __NR_sysmips			6199
+#define __NR_io_setup			6200
+#define __NR_io_destroy			6201
+#define __NR_io_getevents		6202
+#define __NR_io_submit			6203
+#define __NR_io_cancel			6204
+#define __NR_exit_group			6205
+#define __NR_lookup_dcookie		6206
+#define __NR_epoll_create		6207
+#define __NR_epoll_ctl			6208
+#define __NR_epoll_wait			6209
+#define __NR_remap_file_pages		6210
+#define __NR_rt_sigreturn		6211
+#define __NR_fcntl64			6212
+#define __NR_set_tid_address		6213
+#define __NR_restart_syscall		6214
+#define __NR_semtimedop			6215
+#define __NR_fadvise64			6216
+#define __NR_statfs64			6217
+#define __NR_fstatfs64			6218
+#define __NR_sendfile64			6219
+#define __NR_timer_create		6220
+#define __NR_timer_settime32		6221
+#define __NR_timer_gettime32		6222
+#define __NR_timer_getoverrun		6223
+#define __NR_timer_delete		6224
+#define __NR_clock_settime32		6225
+#define __NR_clock_gettime32		6226
+#define __NR_clock_getres_time32		6227
+#define __NR_clock_nanosleep_time32		6228
+#define __NR_tgkill			6229
+#define __NR_utimes			6230
+#define __NR_mbind			6231
+#define __NR_get_mempolicy		6232
+#define __NR_set_mempolicy		6233
+#define __NR_mq_open			6234
+#define __NR_mq_unlink			6235
+#define __NR_mq_timedsend		6236
+#define __NR_mq_timedreceive		6237
+#define __NR_mq_notify			6238
+#define __NR_mq_getsetattr		6239
+#define __NR_vserver			6240
+#define __NR_waitid			6241
+#define __NR_add_key			6243
+#define __NR_request_key		6244
+#define __NR_keyctl			6245
+#define __NR_set_thread_area		6246
+#define __NR_inotify_init		6247
+#define __NR_inotify_add_watch		6248
+#define __NR_inotify_rm_watch		6249
+#define __NR_migrate_pages		6250
+#define __NR_openat			6251
+#define __NR_mkdirat			6252
+#define __NR_mknodat			6253
+#define __NR_fchownat			6254
+#define __NR_futimesat			6255
+#define __NR_newfstatat			6256
+#define __NR_unlinkat			6257
+#define __NR_renameat			6258
+#define __NR_linkat			6259
+#define __NR_symlinkat			6260
+#define __NR_readlinkat			6261
+#define __NR_fchmodat			6262
+#define __NR_faccessat			6263
+#define __NR_pselect6			6264
+#define __NR_ppoll			6265
+#define __NR_unshare			6266
+#define __NR_splice			6267
+#define __NR_sync_file_range		6268
+#define __NR_tee			6269
+#define __NR_vmsplice			6270
+#define __NR_move_pages			6271
+#define __NR_set_robust_list		6272
+#define __NR_get_robust_list		6273
+#define __NR_kexec_load			6274
+#define __NR_getcpu			6275
+#define __NR_epoll_pwait		6276
+#define __NR_ioprio_set			6277
+#define __NR_ioprio_get			6278
+#define __NR_utimensat			6279
+#define __NR_signalfd			6280
+#define __NR_timerfd			6281
+#define __NR_eventfd			6282
+#define __NR_fallocate			6283
+#define __NR_timerfd_create		6284
+#define __NR_timerfd_gettime32		6285
+#define __NR_timerfd_settime32		6286
+#define __NR_signalfd4			6287
+#define __NR_eventfd2			6288
+#define __NR_epoll_create1		6289
+#define __NR_dup3			6290
+#define __NR_pipe2			6291
+#define __NR_inotify_init1		6292
+#define __NR_preadv			6293
+#define __NR_pwritev			6294
+#define __NR_rt_tgsigqueueinfo		6295
+#define __NR_perf_event_open		6296
+#define __NR_accept4			6297
+#define __NR_recvmmsg			6298
+#define __NR_getdents64			6299
+#define __NR_fanotify_init		6300
+#define __NR_fanotify_mark		6301
+#define __NR_prlimit64			6302
+#define __NR_name_to_handle_at		6303
+#define __NR_open_by_handle_at		6304
+#define __NR_clock_adjtime		6305
+#define __NR_syncfs			6306
+#define __NR_sendmmsg			6307
+#define __NR_setns			6308
+#define __NR_process_vm_readv		6309
+#define __NR_process_vm_writev		6310
+#define __NR_kcmp			6311
+#define __NR_finit_module		6312
+#define __NR_sched_setattr		6313
+#define __NR_sched_getattr		6314
+#define __NR_renameat2			6315
+#define __NR_seccomp			6316
+#define __NR_getrandom			6317
+#define __NR_memfd_create		6318
+#define __NR_bpf			6319
+#define __NR_execveat			6320
+#define __NR_userfaultfd		6321
+#define __NR_membarrier			6322
+#define __NR_mlock2			6323
+#define __NR_copy_file_range		6324
+#define __NR_preadv2			6325
+#define __NR_pwritev2			6326
+#define __NR_pkey_mprotect		6327
+#define __NR_pkey_alloc			6328
+#define __NR_pkey_free			6329
+#define __NR_statx			6330
+#define __NR_rseq			6331
+#define __NR_io_pgetevents		6332
+#define __NR_clock_gettime64		6403
+#define __NR_clock_settime64		6404
+#define __NR_clock_adjtime64		6405
+#define __NR_clock_getres_time64	6406
+#define __NR_clock_nanosleep_time64	6407
+#define __NR_timer_gettime64		6408
+#define __NR_timer_settime64		6409
+#define __NR_timerfd_gettime64		6410
+#define __NR_timerfd_settime64		6411
+#define __NR_utimensat_time64		6412
+#define __NR_pselect6_time64		6413
+#define __NR_ppoll_time64		6414
+#define __NR_io_pgetevents_time64	6416
+#define __NR_recvmmsg_time64		6417
+#define __NR_mq_timedsend_time64	6418
+#define __NR_mq_timedreceive_time64	6419
+#define __NR_semtimedop_time64		6420
+#define __NR_rt_sigtimedwait_time64	6421
+#define __NR_futex_time64		6422
+#define __NR_sched_rr_get_interval_time64 6423
+#define __NR_pidfd_send_signal		6424
+#define __NR_io_uring_setup		6425
+#define __NR_io_uring_enter		6426
+#define __NR_io_uring_register		6427
+#define __NR_open_tree		6428
+#define __NR_move_mount		6429
+#define __NR_fsopen		6430
+#define __NR_fsconfig		6431
+#define __NR_fsmount		6432
+#define __NR_fspick		6433
+#define __NR_pidfd_open		6434
+#define __NR_clone3		6435
+#define __NR_close_range	6436
+#define __NR_openat2		6437
+#define __NR_pidfd_getfd	6438
+#define __NR_faccessat2		6439
+#define __NR_process_madvise	6440
+#define __NR_epoll_pwait2	6441
+#define __NR_mount_setattr	6442
+#define __NR_landlock_create_ruleset	6444
+#define __NR_landlock_add_rule	6445
+#define __NR_landlock_restrict_self	6446
+#define __NR_process_mrelease	6448
+#define __NR_futex_waitv	6449
+#define __NR_set_mempolicy_home_node	6450
+#define __NR_cachestat		6451
+#define __NR_fchmodat2		6452
+
+#define SYS_read			6000
+#define SYS_write			6001
+#define SYS_open			6002
+#define SYS_close			6003
+#define SYS_stat			6004
+#define SYS_fstat			6005
+#define SYS_lstat			6006
+#define SYS_poll			6007
+#define SYS_lseek			6008
+#define SYS_mmap			6009
+#define SYS_mprotect			6010
+#define SYS_munmap			6011
+#define SYS_brk			6012
+#define SYS_rt_sigaction		6013
+#define SYS_rt_sigprocmask		6014
+#define SYS_ioctl			6015
+#define SYS_pread64			6016
+#define SYS_pwrite64			6017
+#define SYS_readv			6018
+#define SYS_writev			6019
+#define SYS_access			6020
+#define SYS_pipe			6021
+#define SYS__newselect			6022
+#define SYS_sched_yield		6023
+#define SYS_mremap			6024
+#define SYS_msync			6025
+#define SYS_mincore			6026
+#define SYS_madvise			6027
+#define SYS_shmget			6028
+#define SYS_shmat			6029
+#define SYS_shmctl			6030
+#define SYS_dup			6031
+#define SYS_dup2			6032
+#define SYS_pause			6033
+#define SYS_nanosleep			6034
+#define SYS_getitimer			6035
+#define SYS_setitimer			6036
+#define SYS_alarm			6037
+#define SYS_getpid			6038
+#define SYS_sendfile			6039
+#define SYS_socket			6040
+#define SYS_connect			6041
+#define SYS_accept			6042
+#define SYS_sendto			6043
+#define SYS_recvfrom			6044
+#define SYS_sendmsg			6045
+#define SYS_recvmsg			6046
+#define SYS_shutdown			6047
+#define SYS_bind			6048
+#define SYS_listen			6049
+#define SYS_getsockname		6050
+#define SYS_getpeername		6051
+#define SYS_socketpair			6052
+#define SYS_setsockopt			6053
+#define SYS_getsockopt			6054
+#define SYS_clone			6055
+#define SYS_fork			6056
+#define SYS_execve			6057
+#define SYS_exit			6058
+#define SYS_wait4			6059
+#define SYS_kill			6060
+#define SYS_uname			6061
+#define SYS_semget			6062
+#define SYS_semop			6063
+#define SYS_semctl			6064
+#define SYS_shmdt			6065
+#define SYS_msgget			6066
+#define SYS_msgsnd			6067
+#define SYS_msgrcv			6068
+#define SYS_msgctl			6069
+#define SYS_fcntl			6070
+#define SYS_flock			6071
+#define SYS_fsync			6072
+#define SYS_fdatasync			6073
+#define SYS_truncate			6074
+#define SYS_ftruncate			6075
+#define SYS_getdents			6076
+#define SYS_getcwd			6077
+#define SYS_chdir			6078
+#define SYS_fchdir			6079
+#define SYS_rename			6080
+#define SYS_mkdir			6081
+#define SYS_rmdir			6082
+#define SYS_creat			6083
+#define SYS_link			6084
+#define SYS_unlink			6085
+#define SYS_symlink			6086
+#define SYS_readlink			6087
+#define SYS_chmod			6088
+#define SYS_fchmod			6089
+#define SYS_chown			6090
+#define SYS_fchown			6091
+#define SYS_lchown			6092
+#define SYS_umask			6093
+#define SYS_gettimeofday_time32		6094
+#define SYS_getrlimit			6095
+#define SYS_getrusage			6096
+#define SYS_sysinfo			6097
+#define SYS_times			6098
+#define SYS_ptrace			6099
+#define SYS_getuid			6100
+#define SYS_syslog			6101
+#define SYS_getgid			6102
+#define SYS_setuid			6103
+#define SYS_setgid			6104
+#define SYS_geteuid			6105
+#define SYS_getegid			6106
+#define SYS_setpgid			6107
+#define SYS_getppid			6108
+#define SYS_getpgrp			6109
+#define SYS_setsid			6110
+#define SYS_setreuid			6111
+#define SYS_setregid			6112
+#define SYS_getgroups			6113
+#define SYS_setgroups			6114
+#define SYS_setresuid			6115
+#define SYS_getresuid			6116
+#define SYS_setresgid			6117
+#define SYS_getresgid			6118
+#define SYS_getpgid			6119
+#define SYS_setfsuid			6120
+#define SYS_setfsgid			6121
+#define SYS_getsid			6122
+#define SYS_capget			6123
+#define SYS_capset			6124
+#define SYS_rt_sigpending		6125
+#define SYS_rt_sigtimedwait		6126
+#define SYS_rt_sigqueueinfo		6127
+#define SYS_rt_sigsuspend		6128
+#define SYS_sigaltstack		6129
+#define SYS_utime			6130
+#define SYS_mknod			6131
+#define SYS_personality		6132
+#define SYS_ustat			6133
+#define SYS_statfs			6134
+#define SYS_fstatfs			6135
+#define SYS_sysfs			6136
+#define SYS_getpriority		6137
+#define SYS_setpriority		6138
+#define SYS_sched_setparam		6139
+#define SYS_sched_getparam		6140
+#define SYS_sched_setscheduler		6141
+#define SYS_sched_getscheduler		6142
+#define SYS_sched_get_priority_max	6143
+#define SYS_sched_get_priority_min	6144
+#define SYS_sched_rr_get_interval	6145
+#define SYS_mlock			6146
+#define SYS_munlock			6147
+#define SYS_mlockall			6148
+#define SYS_munlockall			6149
+#define SYS_vhangup			6150
+#define SYS_pivot_root			6151
+#define SYS__sysctl			6152
+#define SYS_prctl			6153
+#define SYS_adjtimex			6154
+#define SYS_setrlimit			6155
+#define SYS_chroot			6156
+#define SYS_sync			6157
+#define SYS_acct			6158
+#define SYS_settimeofday_time32		6159
+#define SYS_mount			6160
+#define SYS_umount2			6161
+#define SYS_swapon			6162
+#define SYS_swapoff			6163
+#define SYS_reboot			6164
+#define SYS_sethostname		6165
+#define SYS_setdomainname		6166
+#define SYS_create_module		6167
+#define SYS_init_module		6168
+#define SYS_delete_module		6169
+#define SYS_get_kernel_syms		6170
+#define SYS_query_module		6171
+#define SYS_quotactl			6172
+#define SYS_nfsservctl			6173
+#define SYS_getpmsg			6174
+#define SYS_putpmsg			6175
+#define SYS_afs_syscall		6176
+#define SYS_reserved177		6177
+#define SYS_gettid			6178
+#define SYS_readahead			6179
+#define SYS_setxattr			6180
+#define SYS_lsetxattr			6181
+#define SYS_fsetxattr			6182
+#define SYS_getxattr			6183
+#define SYS_lgetxattr			6184
+#define SYS_fgetxattr			6185
+#define SYS_listxattr			6186
+#define SYS_llistxattr			6187
+#define SYS_flistxattr			6188
+#define SYS_removexattr		6189
+#define SYS_lremovexattr		6190
+#define SYS_fremovexattr		6191
+#define SYS_tkill			6192
+#define SYS_reserved193		6193
+#define SYS_futex			6194
+#define SYS_sched_setaffinity		6195
+#define SYS_sched_getaffinity		6196
+#define SYS_cacheflush			6197
+#define SYS_cachectl			6198
+#define SYS_sysmips			6199
+#define SYS_io_setup			6200
+#define SYS_io_destroy			6201
+#define SYS_io_getevents		6202
+#define SYS_io_submit			6203
+#define SYS_io_cancel			6204
+#define SYS_exit_group			6205
+#define SYS_lookup_dcookie		6206
+#define SYS_epoll_create		6207
+#define SYS_epoll_ctl			6208
+#define SYS_epoll_wait			6209
+#define SYS_remap_file_pages		6210
+#define SYS_rt_sigreturn		6211
+#define SYS_fcntl64			6212
+#define SYS_set_tid_address		6213
+#define SYS_restart_syscall		6214
+#define SYS_semtimedop			6215
+#define SYS_fadvise64			6216
+#define SYS_statfs64			6217
+#define SYS_fstatfs64			6218
+#define SYS_sendfile64			6219
+#define SYS_timer_create		6220
+#define SYS_timer_settime32		6221
+#define SYS_timer_gettime32		6222
+#define SYS_timer_getoverrun		6223
+#define SYS_timer_delete		6224
+#define SYS_clock_settime32		6225
+#define SYS_clock_gettime32		6226
+#define SYS_clock_getres_time32		6227
+#define SYS_clock_nanosleep_time32		6228
+#define SYS_tgkill			6229
+#define SYS_utimes			6230
+#define SYS_mbind			6231
+#define SYS_get_mempolicy		6232
+#define SYS_set_mempolicy		6233
+#define SYS_mq_open			6234
+#define SYS_mq_unlink			6235
+#define SYS_mq_timedsend		6236
+#define SYS_mq_timedreceive		6237
+#define SYS_mq_notify			6238
+#define SYS_mq_getsetattr		6239
+#define SYS_vserver			6240
+#define SYS_waitid			6241
+#define SYS_add_key			6243
+#define SYS_request_key		6244
+#define SYS_keyctl			6245
+#define SYS_set_thread_area		6246
+#define SYS_inotify_init		6247
+#define SYS_inotify_add_watch		6248
+#define SYS_inotify_rm_watch		6249
+#define SYS_migrate_pages		6250
+#define SYS_openat			6251
+#define SYS_mkdirat			6252
+#define SYS_mknodat			6253
+#define SYS_fchownat			6254
+#define SYS_futimesat			6255
+#define SYS_newfstatat			6256
+#define SYS_unlinkat			6257
+#define SYS_renameat			6258
+#define SYS_linkat			6259
+#define SYS_symlinkat			6260
+#define SYS_readlinkat			6261
+#define SYS_fchmodat			6262
+#define SYS_faccessat			6263
+#define SYS_pselect6			6264
+#define SYS_ppoll			6265
+#define SYS_unshare			6266
+#define SYS_splice			6267
+#define SYS_sync_file_range		6268
+#define SYS_tee			6269
+#define SYS_vmsplice			6270
+#define SYS_move_pages			6271
+#define SYS_set_robust_list		6272
+#define SYS_get_robust_list		6273
+#define SYS_kexec_load			6274
+#define SYS_getcpu			6275
+#define SYS_epoll_pwait		6276
+#define SYS_ioprio_set			6277
+#define SYS_ioprio_get			6278
+#define SYS_utimensat			6279
+#define SYS_signalfd			6280
+#define SYS_timerfd			6281
+#define SYS_eventfd			6282
+#define SYS_fallocate			6283
+#define SYS_timerfd_create		6284
+#define SYS_timerfd_gettime32		6285
+#define SYS_timerfd_settime32		6286
+#define SYS_signalfd4			6287
+#define SYS_eventfd2			6288
+#define SYS_epoll_create1		6289
+#define SYS_dup3			6290
+#define SYS_pipe2			6291
+#define SYS_inotify_init1		6292
+#define SYS_preadv			6293
+#define SYS_pwritev			6294
+#define SYS_rt_tgsigqueueinfo		6295
+#define SYS_perf_event_open		6296
+#define SYS_accept4			6297
+#define SYS_recvmmsg			6298
+#define SYS_getdents64			6299
+#define SYS_fanotify_init		6300
+#define SYS_fanotify_mark		6301
+#define SYS_prlimit64			6302
+#define SYS_name_to_handle_at		6303
+#define SYS_open_by_handle_at		6304
+#define SYS_clock_adjtime		6305
+#define SYS_syncfs			6306
+#define SYS_sendmmsg			6307
+#define SYS_setns			6308
+#define SYS_process_vm_readv		6309
+#define SYS_process_vm_writev		6310
+#define SYS_kcmp			6311
+#define SYS_finit_module		6312
+#define SYS_sched_setattr		6313
+#define SYS_sched_getattr		6314
+#define SYS_renameat2			6315
+#define SYS_seccomp			6316
+#define SYS_getrandom			6317
+#define SYS_memfd_create		6318
+#define SYS_bpf			6319
+#define SYS_execveat			6320
+#define SYS_userfaultfd		6321
+#define SYS_membarrier			6322
+#define SYS_mlock2			6323
+#define SYS_copy_file_range		6324
+#define SYS_preadv2			6325
+#define SYS_pwritev2			6326
+#define SYS_pkey_mprotect		6327
+#define SYS_pkey_alloc			6328
+#define SYS_pkey_free			6329
+#define SYS_statx			6330
+#define SYS_rseq			6331
+#define SYS_io_pgetevents		6332
+#define SYS_clock_gettime64		6403
+#define SYS_clock_settime64		6404
+#define SYS_clock_adjtime64		6405
+#define SYS_clock_getres_time64	6406
+#define SYS_clock_nanosleep_time64	6407
+#define SYS_timer_gettime64		6408
+#define SYS_timer_settime64		6409
+#define SYS_timerfd_gettime64		6410
+#define SYS_timerfd_settime64		6411
+#define SYS_utimensat_time64		6412
+#define SYS_pselect6_time64		6413
+#define SYS_ppoll_time64		6414
+#define SYS_io_pgetevents_time64	6416
+#define SYS_recvmmsg_time64		6417
+#define SYS_mq_timedsend_time64	6418
+#define SYS_mq_timedreceive_time64	6419
+#define SYS_semtimedop_time64		6420
+#define SYS_rt_sigtimedwait_time64	6421
+#define SYS_futex_time64		6422
+#define SYS_sched_rr_get_interval_time64 6423
+#define SYS_pidfd_send_signal		6424
+#define SYS_io_uring_setup		6425
+#define SYS_io_uring_enter		6426
+#define SYS_io_uring_register		6427
+#define SYS_open_tree		6428
+#define SYS_move_mount		6429
+#define SYS_fsopen		6430
+#define SYS_fsconfig		6431
+#define SYS_fsmount		6432
+#define SYS_fspick		6433
+#define SYS_pidfd_open		6434
+#define SYS_clone3		6435
+#define SYS_close_range	6436
+#define SYS_openat2		6437
+#define SYS_pidfd_getfd	6438
+#define SYS_faccessat2		6439
+#define SYS_process_madvise	6440
+#define SYS_epoll_pwait2	6441
+#define SYS_mount_setattr	6442
+#define SYS_landlock_create_ruleset	6444
+#define SYS_landlock_add_rule	6445
+#define SYS_landlock_restrict_self	6446
+#define SYS_process_mrelease	6448
+#define SYS_futex_waitv	6449
+#define SYS_set_mempolicy_home_node	6450
+#define SYS_cachestat		6451
+#define SYS_fchmodat2		6452
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/termios.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/termios.h
new file mode 100644
index 0000000000..0940ce20fb
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/termios.h
@@ -0,0 +1,169 @@
+struct termios {
+	tcflag_t c_iflag;
+	tcflag_t c_oflag;
+	tcflag_t c_cflag;
+	tcflag_t c_lflag;
+	cc_t c_line;
+	cc_t c_cc[NCCS];
+	speed_t __c_ispeed;
+	speed_t __c_ospeed;
+};
+
+#define VINTR     0
+#define VQUIT     1
+#define VERASE    2
+#define VKILL     3
+#define VMIN      4
+#define VTIME     5
+#define VEOL2     6
+#define VSWTC     7
+#define VSWTCH    7
+#define VSTART    8
+#define VSTOP     9
+#define VSUSP    10
+#define VREPRINT 12
+#define VDISCARD 13
+#define VWERASE  14
+#define VLNEXT   15
+#define VEOF     16
+#define VEOL     17
+
+#define IGNBRK  0000001
+#define BRKINT  0000002
+#define IGNPAR  0000004
+#define PARMRK  0000010
+#define INPCK   0000020
+#define ISTRIP  0000040
+#define INLCR   0000100
+#define IGNCR   0000200
+#define ICRNL   0000400
+#define IUCLC   0001000
+#define IXON    0002000
+#define IXANY   0004000
+#define IXOFF   0010000
+#define IMAXBEL 0020000
+#define IUTF8   0040000
+
+#define OPOST  0000001
+#define OLCUC  0000002
+#define ONLCR  0000004
+#define OCRNL  0000010
+#define ONOCR  0000020
+#define ONLRET 0000040
+#define OFILL  0000100
+#define OFDEL  0000200
+#if defined(_GNU_SOURCE) || defined(_BSD_SOURCE) || defined(_XOPEN_SOURCE)
+#define NLDLY  0000400
+#define NL0    0000000
+#define NL1    0000400
+#define CRDLY  0003000
+#define CR0    0000000
+#define CR1    0001000
+#define CR2    0002000
+#define CR3    0003000
+#define TABDLY 0014000
+#define TAB0   0000000
+#define TAB1   0004000
+#define TAB2   0010000
+#define TAB3   0014000
+#define BSDLY  0020000
+#define BS0    0000000
+#define BS1    0020000
+#define FFDLY  0100000
+#define FF0    0000000
+#define FF1    0100000
+#endif
+
+#define VTDLY  0040000
+#define VT0    0000000
+#define VT1    0040000
+
+#define B0       0000000
+#define B50      0000001
+#define B75      0000002
+#define B110     0000003
+#define B134     0000004
+#define B150     0000005
+#define B200     0000006
+#define B300     0000007
+#define B600     0000010
+#define B1200    0000011
+#define B1800    0000012
+#define B2400    0000013
+#define B4800    0000014
+#define B9600    0000015
+#define B19200   0000016
+#define B38400   0000017
+
+#define B57600   0010001
+#define B115200  0010002
+#define B230400  0010003
+#define B460800  0010004
+#define B500000  0010005
+#define B576000  0010006
+#define B921600  0010007
+#define B1000000 0010010
+#define B1152000 0010011
+#define B1500000 0010012
+#define B2000000 0010013
+#define B2500000 0010014
+#define B3000000 0010015
+#define B3500000 0010016
+#define B4000000 0010017
+
+#define CSIZE  0000060
+#define CS5    0000000
+#define CS6    0000020
+#define CS7    0000040
+#define CS8    0000060
+#define CSTOPB 0000100
+#define CREAD  0000200
+#define PARENB 0000400
+#define PARODD 0001000
+#define HUPCL  0002000
+#define CLOCAL 0004000
+
+#define ISIG   0000001
+#define ICANON 0000002
+#define ECHO   0000010
+#define ECHOE  0000020
+#define ECHOK  0000040
+#define ECHONL 0000100
+#define NOFLSH 0000200
+#define IEXTEN 0000400
+#define TOSTOP 0100000
+#define ITOSTOP 0100000
+
+#define TCOOFF 0
+#define TCOON  1
+#define TCIOFF 2
+#define TCION  3
+
+#define TCIFLUSH  0
+#define TCOFLUSH  1
+#define TCIOFLUSH 2
+
+#define TCSANOW   0
+#define TCSADRAIN 1
+#define TCSAFLUSH 2
+
+#if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+#define EXTA    0000016
+#define EXTB    0000017
+#define CBAUD   0010017
+#define CBAUDEX 0010000
+#define CIBAUD  002003600000
+#define CMSPAR  010000000000
+#define CRTSCTS 020000000000
+
+#define XCASE   0000004
+#define ECHOCTL 0001000
+#define ECHOPRT 0002000
+#define ECHOKE  0004000
+#define FLUSHO  0020000
+#define PENDIN  0040000
+#define EXTPROC 0200000
+
+#define XTABS  0014000
+#define TIOCSER_TEMT 1
+#endif
\ No newline at end of file
diff --git a/zig/lib/libc/include/mips64-linux-muslabin32/bits/user.h b/zig/lib/libc/include/mips64-linux-muslabin32/bits/user.h
new file mode 100644
index 0000000000..0c2b245fee
--- /dev/null
+++ b/zig/lib/libc/include/mips64-linux-muslabin32/bits/user.h
@@ -0,0 +1,15 @@
+struct user {
+	unsigned long regs[102];
+	unsigned long u_tsize, u_dsize, u_ssize;
+	unsigned long long start_code, start_data, start_stack;
+	long long signal;
+	unsigned long long *u_ar0;
+	unsigned long long magic;
+	char u_comm[32];
+};
+
+#define ELF_NGREG 45
+#define ELF_NFPREG 33
+
+typedef unsigned long elf_greg_t, elf_gregset_t[ELF_NGREG];
+typedef double elf_fpreg_t, elf_fpregset_t[ELF_NFPREG];
\ No newline at end of file
diff --git a/zig/lib/libc/include/powerpc64-linux-musl/bits/stdint.h b/zig/lib/libc/include/powerpc64-linux-musl/bits/stdint.h
new file mode 100644
index 0000000000..02714d7398
--- /dev/null
+++ b/zig/lib/libc/include/powerpc64-linux-musl/bits/stdint.h
@@ -0,0 +1,20 @@
+typedef int32_t int_fast16_t;
+typedef int32_t int_fast32_t;
+typedef uint32_t uint_fast16_t;
+typedef uint32_t uint_fast32_t;
+
+#define INT_FAST16_MIN  INT32_MIN
+#define INT_FAST32_MIN  INT32_MIN
+
+#define INT_FAST16_MAX  INT32_MAX
+#define INT_FAST32_MAX  INT32_MAX
+
+#define UINT_FAST16_MAX UINT32_MAX
+#define UINT_FAST32_MAX UINT32_MAX
+
+#define INTPTR_MIN      INT64_MIN
+#define INTPTR_MAX      INT64_MAX
+#define UINTPTR_MAX     UINT64_MAX
+#define PTRDIFF_MIN     INT64_MIN
+#define PTRDIFF_MAX     INT64_MAX
+#define SIZE_MAX        UINT64_MAX
\ No newline at end of file
diff --git a/zig/lib/libc/include/riscv32-linux-musl/bits/fenv.h b/zig/lib/libc/include/riscv32-linux-musl/bits/fenv.h
new file mode 100644
index 0000000000..b260c6f63b
--- /dev/null
+++ b/zig/lib/libc/include/riscv32-linux-musl/bits/fenv.h
@@ -0,0 +1,17 @@
+#define FE_INVALID      16
+#define FE_DIVBYZERO    8
+#define FE_OVERFLOW     4
+#define FE_UNDERFLOW    2
+#define FE_INEXACT      1
+
+#define FE_ALL_EXCEPT   31
+
+#define FE_TONEAREST    0
+#define FE_DOWNWARD     2
+#define FE_UPWARD       3
+#define FE_TOWARDZERO   1
+
+typedef unsigned int fexcept_t;
+typedef unsigned int fenv_t;
+
+#define FE_DFL_ENV      ((const fenv_t *) -1)
\ No newline at end of file
diff --git a/zig/lib/libc/include/riscv64-linux-musl/bits/fenv.h b/zig/lib/libc/include/riscv64-linux-musl/bits/fenv.h
new file mode 100644
index 0000000000..b260c6f63b
--- /dev/null
+++ b/zig/lib/libc/include/riscv64-linux-musl/bits/fenv.h
@@ -0,0 +1,17 @@
+#define FE_INVALID      16
+#define FE_DIVBYZERO    8
+#define FE_OVERFLOW     4
+#define FE_UNDERFLOW    2
+#define FE_INEXACT      1
+
+#define FE_ALL_EXCEPT   31
+
+#define FE_TONEAREST    0
+#define FE_DOWNWARD     2
+#define FE_UPWARD       3
+#define FE_TOWARDZERO   1
+
+typedef unsigned int fexcept_t;
+typedef unsigned int fenv_t;
+
+#define FE_DFL_ENV      ((const fenv_t *) -1)
\ No newline at end of file
diff --git a/zig/lib/libc/include/riscv64-linux-musl/bits/stdint.h b/zig/lib/libc/include/riscv64-linux-musl/bits/stdint.h
new file mode 100644
index 0000000000..02714d7398
--- /dev/null
+++ b/zig/lib/libc/include/riscv64-linux-musl/bits/stdint.h
@@ -0,0 +1,20 @@
+typedef int32_t int_fast16_t;
+typedef int32_t int_fast32_t;
+typedef uint32_t uint_fast16_t;
+typedef uint32_t uint_fast32_t;
+
+#define INT_FAST16_MIN  INT32_MIN
+#define INT_FAST32_MIN  INT32_MIN
+
+#define INT_FAST16_MAX  INT32_MAX
+#define INT_FAST32_MAX  INT32_MAX
+
+#define UINT_FAST16_MAX UINT32_MAX
+#define UINT_FAST32_MAX UINT32_MAX
+
+#define INTPTR_MIN      INT64_MIN
+#define INTPTR_MAX      INT64_MAX
+#define UINTPTR_MAX     UINT64_MAX
+#define PTRDIFF_MIN     INT64_MIN
+#define PTRDIFF_MAX     INT64_MAX
+#define SIZE_MAX        UINT64_MAX
\ No newline at end of file
diff --git a/zig/lib/libc/include/s390x-linux-musl/bits/stdint.h b/zig/lib/libc/include/s390x-linux-musl/bits/stdint.h
new file mode 100644
index 0000000000..02714d7398
--- /dev/null
+++ b/zig/lib/libc/include/s390x-linux-musl/bits/stdint.h
@@ -0,0 +1,20 @@
+typedef int32_t int_fast16_t;
+typedef int32_t int_fast32_t;
+typedef uint32_t uint_fast16_t;
+typedef uint32_t uint_fast32_t;
+
+#define INT_FAST16_MIN  INT32_MIN
+#define INT_FAST32_MIN  INT32_MIN
+
+#define INT_FAST16_MAX  INT32_MAX
+#define INT_FAST32_MAX  INT32_MAX
+
+#define UINT_FAST16_MAX UINT32_MAX
+#define UINT_FAST32_MAX UINT32_MAX
+
+#define INTPTR_MIN      INT64_MIN
+#define INTPTR_MAX      INT64_MAX
+#define UINTPTR_MAX     UINT64_MAX
+#define PTRDIFF_MIN     INT64_MIN
+#define PTRDIFF_MAX     INT64_MAX
+#define SIZE_MAX        UINT64_MAX
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-musl/bits/stdint.h b/zig/lib/libc/include/x86_64-linux-musl/bits/stdint.h
new file mode 100644
index 0000000000..02714d7398
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-musl/bits/stdint.h
@@ -0,0 +1,20 @@
+typedef int32_t int_fast16_t;
+typedef int32_t int_fast32_t;
+typedef uint32_t uint_fast16_t;
+typedef uint32_t uint_fast32_t;
+
+#define INT_FAST16_MIN  INT32_MIN
+#define INT_FAST32_MIN  INT32_MIN
+
+#define INT_FAST16_MAX  INT32_MAX
+#define INT_FAST32_MAX  INT32_MAX
+
+#define UINT_FAST16_MAX UINT32_MAX
+#define UINT_FAST32_MAX UINT32_MAX
+
+#define INTPTR_MIN      INT64_MIN
+#define INTPTR_MAX      INT64_MAX
+#define UINTPTR_MAX     UINT64_MAX
+#define PTRDIFF_MIN     INT64_MIN
+#define PTRDIFF_MAX     INT64_MAX
+#define SIZE_MAX        UINT64_MAX
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/alltypes.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/alltypes.h
new file mode 100644
index 0000000000..8dfc0bcf9d
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/alltypes.h
@@ -0,0 +1,423 @@
+#define _Addr int
+#define _Int64 long long
+#define _Reg long long
+
+#define __BYTE_ORDER 1234
+#define __LONG_MAX 0x7fffffffL
+
+#ifndef __cplusplus
+#ifdef __WCHAR_TYPE__
+#if defined(__NEED_wchar_t) && !defined(__DEFINED_wchar_t)
+typedef __WCHAR_TYPE__ wchar_t;
+#define __DEFINED_wchar_t
+#endif
+
+#else
+#if defined(__NEED_wchar_t) && !defined(__DEFINED_wchar_t)
+typedef long wchar_t;
+#define __DEFINED_wchar_t
+#endif
+
+#endif
+#endif
+
+#if defined(__FLT_EVAL_METHOD__) && __FLT_EVAL_METHOD__ == 2
+#if defined(__NEED_float_t) && !defined(__DEFINED_float_t)
+typedef long double float_t;
+#define __DEFINED_float_t
+#endif
+
+#if defined(__NEED_double_t) && !defined(__DEFINED_double_t)
+typedef long double double_t;
+#define __DEFINED_double_t
+#endif
+
+#else
+#if defined(__NEED_float_t) && !defined(__DEFINED_float_t)
+typedef float float_t;
+#define __DEFINED_float_t
+#endif
+
+#if defined(__NEED_double_t) && !defined(__DEFINED_double_t)
+typedef double double_t;
+#define __DEFINED_double_t
+#endif
+
+#endif
+
+#if defined(__NEED_max_align_t) && !defined(__DEFINED_max_align_t)
+typedef struct { long long __ll; long double __ld; } max_align_t;
+#define __DEFINED_max_align_t
+#endif
+
+#define __LITTLE_ENDIAN 1234
+#define __BIG_ENDIAN 4321
+#define __USE_TIME_BITS64 1
+
+#if defined(__NEED_size_t) && !defined(__DEFINED_size_t)
+typedef unsigned _Addr size_t;
+#define __DEFINED_size_t
+#endif
+
+#if defined(__NEED_uintptr_t) && !defined(__DEFINED_uintptr_t)
+typedef unsigned _Addr uintptr_t;
+#define __DEFINED_uintptr_t
+#endif
+
+#if defined(__NEED_ptrdiff_t) && !defined(__DEFINED_ptrdiff_t)
+typedef _Addr ptrdiff_t;
+#define __DEFINED_ptrdiff_t
+#endif
+
+#if defined(__NEED_ssize_t) && !defined(__DEFINED_ssize_t)
+typedef _Addr ssize_t;
+#define __DEFINED_ssize_t
+#endif
+
+#if defined(__NEED_intptr_t) && !defined(__DEFINED_intptr_t)
+typedef _Addr intptr_t;
+#define __DEFINED_intptr_t
+#endif
+
+#if defined(__NEED_regoff_t) && !defined(__DEFINED_regoff_t)
+typedef _Addr regoff_t;
+#define __DEFINED_regoff_t
+#endif
+
+#if defined(__NEED_register_t) && !defined(__DEFINED_register_t)
+typedef _Reg register_t;
+#define __DEFINED_register_t
+#endif
+
+#if defined(__NEED_time_t) && !defined(__DEFINED_time_t)
+typedef _Int64 time_t;
+#define __DEFINED_time_t
+#endif
+
+#if defined(__NEED_suseconds_t) && !defined(__DEFINED_suseconds_t)
+typedef _Int64 suseconds_t;
+#define __DEFINED_suseconds_t
+#endif
+
+
+#if defined(__NEED_int8_t) && !defined(__DEFINED_int8_t)
+typedef signed char     int8_t;
+#define __DEFINED_int8_t
+#endif
+
+#if defined(__NEED_int16_t) && !defined(__DEFINED_int16_t)
+typedef signed short    int16_t;
+#define __DEFINED_int16_t
+#endif
+
+#if defined(__NEED_int32_t) && !defined(__DEFINED_int32_t)
+typedef signed int      int32_t;
+#define __DEFINED_int32_t
+#endif
+
+#if defined(__NEED_int64_t) && !defined(__DEFINED_int64_t)
+typedef signed _Int64   int64_t;
+#define __DEFINED_int64_t
+#endif
+
+#if defined(__NEED_intmax_t) && !defined(__DEFINED_intmax_t)
+typedef signed _Int64   intmax_t;
+#define __DEFINED_intmax_t
+#endif
+
+#if defined(__NEED_uint8_t) && !defined(__DEFINED_uint8_t)
+typedef unsigned char   uint8_t;
+#define __DEFINED_uint8_t
+#endif
+
+#if defined(__NEED_uint16_t) && !defined(__DEFINED_uint16_t)
+typedef unsigned short  uint16_t;
+#define __DEFINED_uint16_t
+#endif
+
+#if defined(__NEED_uint32_t) && !defined(__DEFINED_uint32_t)
+typedef unsigned int    uint32_t;
+#define __DEFINED_uint32_t
+#endif
+
+#if defined(__NEED_uint64_t) && !defined(__DEFINED_uint64_t)
+typedef unsigned _Int64 uint64_t;
+#define __DEFINED_uint64_t
+#endif
+
+#if defined(__NEED_u_int64_t) && !defined(__DEFINED_u_int64_t)
+typedef unsigned _Int64 u_int64_t;
+#define __DEFINED_u_int64_t
+#endif
+
+#if defined(__NEED_uintmax_t) && !defined(__DEFINED_uintmax_t)
+typedef unsigned _Int64 uintmax_t;
+#define __DEFINED_uintmax_t
+#endif
+
+
+#if defined(__NEED_mode_t) && !defined(__DEFINED_mode_t)
+typedef unsigned mode_t;
+#define __DEFINED_mode_t
+#endif
+
+#if defined(__NEED_nlink_t) && !defined(__DEFINED_nlink_t)
+typedef unsigned _Reg nlink_t;
+#define __DEFINED_nlink_t
+#endif
+
+#if defined(__NEED_off_t) && !defined(__DEFINED_off_t)
+typedef _Int64 off_t;
+#define __DEFINED_off_t
+#endif
+
+#if defined(__NEED_ino_t) && !defined(__DEFINED_ino_t)
+typedef unsigned _Int64 ino_t;
+#define __DEFINED_ino_t
+#endif
+
+#if defined(__NEED_dev_t) && !defined(__DEFINED_dev_t)
+typedef unsigned _Int64 dev_t;
+#define __DEFINED_dev_t
+#endif
+
+#if defined(__NEED_blksize_t) && !defined(__DEFINED_blksize_t)
+typedef long blksize_t;
+#define __DEFINED_blksize_t
+#endif
+
+#if defined(__NEED_blkcnt_t) && !defined(__DEFINED_blkcnt_t)
+typedef _Int64 blkcnt_t;
+#define __DEFINED_blkcnt_t
+#endif
+
+#if defined(__NEED_fsblkcnt_t) && !defined(__DEFINED_fsblkcnt_t)
+typedef unsigned _Int64 fsblkcnt_t;
+#define __DEFINED_fsblkcnt_t
+#endif
+
+#if defined(__NEED_fsfilcnt_t) && !defined(__DEFINED_fsfilcnt_t)
+typedef unsigned _Int64 fsfilcnt_t;
+#define __DEFINED_fsfilcnt_t
+#endif
+
+
+#if defined(__NEED_wint_t) && !defined(__DEFINED_wint_t)
+typedef unsigned wint_t;
+#define __DEFINED_wint_t
+#endif
+
+#if defined(__NEED_wctype_t) && !defined(__DEFINED_wctype_t)
+typedef unsigned long wctype_t;
+#define __DEFINED_wctype_t
+#endif
+
+
+#if defined(__NEED_timer_t) && !defined(__DEFINED_timer_t)
+typedef void * timer_t;
+#define __DEFINED_timer_t
+#endif
+
+#if defined(__NEED_clockid_t) && !defined(__DEFINED_clockid_t)
+typedef int clockid_t;
+#define __DEFINED_clockid_t
+#endif
+
+#if defined(__NEED_clock_t) && !defined(__DEFINED_clock_t)
+typedef long clock_t;
+#define __DEFINED_clock_t
+#endif
+
+#if defined(__NEED_struct_timeval) && !defined(__DEFINED_struct_timeval)
+struct timeval { time_t tv_sec; suseconds_t tv_usec; };
+#define __DEFINED_struct_timeval
+#endif
+
+#if defined(__NEED_struct_timespec) && !defined(__DEFINED_struct_timespec)
+struct timespec { time_t tv_sec; int :8*(sizeof(time_t)-sizeof(long))*(__BYTE_ORDER==4321); long tv_nsec; int :8*(sizeof(time_t)-sizeof(long))*(__BYTE_ORDER!=4321); };
+#define __DEFINED_struct_timespec
+#endif
+
+
+#if defined(__NEED_pid_t) && !defined(__DEFINED_pid_t)
+typedef int pid_t;
+#define __DEFINED_pid_t
+#endif
+
+#if defined(__NEED_id_t) && !defined(__DEFINED_id_t)
+typedef unsigned id_t;
+#define __DEFINED_id_t
+#endif
+
+#if defined(__NEED_uid_t) && !defined(__DEFINED_uid_t)
+typedef unsigned uid_t;
+#define __DEFINED_uid_t
+#endif
+
+#if defined(__NEED_gid_t) && !defined(__DEFINED_gid_t)
+typedef unsigned gid_t;
+#define __DEFINED_gid_t
+#endif
+
+#if defined(__NEED_key_t) && !defined(__DEFINED_key_t)
+typedef int key_t;
+#define __DEFINED_key_t
+#endif
+
+#if defined(__NEED_useconds_t) && !defined(__DEFINED_useconds_t)
+typedef unsigned useconds_t;
+#define __DEFINED_useconds_t
+#endif
+
+
+#ifdef __cplusplus
+#if defined(__NEED_pthread_t) && !defined(__DEFINED_pthread_t)
+typedef unsigned long pthread_t;
+#define __DEFINED_pthread_t
+#endif
+
+#else
+#if defined(__NEED_pthread_t) && !defined(__DEFINED_pthread_t)
+typedef struct __pthread * pthread_t;
+#define __DEFINED_pthread_t
+#endif
+
+#endif
+#if defined(__NEED_pthread_once_t) && !defined(__DEFINED_pthread_once_t)
+typedef int pthread_once_t;
+#define __DEFINED_pthread_once_t
+#endif
+
+#if defined(__NEED_pthread_key_t) && !defined(__DEFINED_pthread_key_t)
+typedef unsigned pthread_key_t;
+#define __DEFINED_pthread_key_t
+#endif
+
+#if defined(__NEED_pthread_spinlock_t) && !defined(__DEFINED_pthread_spinlock_t)
+typedef int pthread_spinlock_t;
+#define __DEFINED_pthread_spinlock_t
+#endif
+
+#if defined(__NEED_pthread_mutexattr_t) && !defined(__DEFINED_pthread_mutexattr_t)
+typedef struct { unsigned __attr; } pthread_mutexattr_t;
+#define __DEFINED_pthread_mutexattr_t
+#endif
+
+#if defined(__NEED_pthread_condattr_t) && !defined(__DEFINED_pthread_condattr_t)
+typedef struct { unsigned __attr; } pthread_condattr_t;
+#define __DEFINED_pthread_condattr_t
+#endif
+
+#if defined(__NEED_pthread_barrierattr_t) && !defined(__DEFINED_pthread_barrierattr_t)
+typedef struct { unsigned __attr; } pthread_barrierattr_t;
+#define __DEFINED_pthread_barrierattr_t
+#endif
+
+#if defined(__NEED_pthread_rwlockattr_t) && !defined(__DEFINED_pthread_rwlockattr_t)
+typedef struct { unsigned __attr[2]; } pthread_rwlockattr_t;
+#define __DEFINED_pthread_rwlockattr_t
+#endif
+
+
+#if defined(__NEED_struct__IO_FILE) && !defined(__DEFINED_struct__IO_FILE)
+struct _IO_FILE { char __x; };
+#define __DEFINED_struct__IO_FILE
+#endif
+
+#if defined(__NEED_FILE) && !defined(__DEFINED_FILE)
+typedef struct _IO_FILE FILE;
+#define __DEFINED_FILE
+#endif
+
+
+#if defined(__NEED_va_list) && !defined(__DEFINED_va_list)
+typedef __builtin_va_list va_list;
+#define __DEFINED_va_list
+#endif
+
+#if defined(__NEED___isoc_va_list) && !defined(__DEFINED___isoc_va_list)
+typedef __builtin_va_list __isoc_va_list;
+#define __DEFINED___isoc_va_list
+#endif
+
+
+#if defined(__NEED_mbstate_t) && !defined(__DEFINED_mbstate_t)
+typedef struct __mbstate_t { unsigned __opaque1, __opaque2; } mbstate_t;
+#define __DEFINED_mbstate_t
+#endif
+
+
+#if defined(__NEED_locale_t) && !defined(__DEFINED_locale_t)
+typedef struct __locale_struct * locale_t;
+#define __DEFINED_locale_t
+#endif
+
+
+#if defined(__NEED_sigset_t) && !defined(__DEFINED_sigset_t)
+typedef struct __sigset_t { unsigned long __bits[128/sizeof(long)]; } sigset_t;
+#define __DEFINED_sigset_t
+#endif
+
+
+#if defined(__NEED_struct_iovec) && !defined(__DEFINED_struct_iovec)
+struct iovec { void *iov_base; size_t iov_len; };
+#define __DEFINED_struct_iovec
+#endif
+
+
+#if defined(__NEED_struct_winsize) && !defined(__DEFINED_struct_winsize)
+struct winsize { unsigned short ws_row, ws_col, ws_xpixel, ws_ypixel; };
+#define __DEFINED_struct_winsize
+#endif
+
+
+#if defined(__NEED_socklen_t) && !defined(__DEFINED_socklen_t)
+typedef unsigned socklen_t;
+#define __DEFINED_socklen_t
+#endif
+
+#if defined(__NEED_sa_family_t) && !defined(__DEFINED_sa_family_t)
+typedef unsigned short sa_family_t;
+#define __DEFINED_sa_family_t
+#endif
+
+
+#if defined(__NEED_pthread_attr_t) && !defined(__DEFINED_pthread_attr_t)
+typedef struct { union { int __i[sizeof(long)==8?14:9]; volatile int __vi[sizeof(long)==8?14:9]; unsigned long __s[sizeof(long)==8?7:9]; } __u; } pthread_attr_t;
+#define __DEFINED_pthread_attr_t
+#endif
+
+#if defined(__NEED_pthread_mutex_t) && !defined(__DEFINED_pthread_mutex_t)
+typedef struct { union { int __i[sizeof(long)==8?10:6]; volatile int __vi[sizeof(long)==8?10:6]; volatile void *volatile __p[sizeof(long)==8?5:6]; } __u; } pthread_mutex_t;
+#define __DEFINED_pthread_mutex_t
+#endif
+
+#if defined(__NEED_mtx_t) && !defined(__DEFINED_mtx_t)
+typedef struct { union { int __i[sizeof(long)==8?10:6]; volatile int __vi[sizeof(long)==8?10:6]; volatile void *volatile __p[sizeof(long)==8?5:6]; } __u; } mtx_t;
+#define __DEFINED_mtx_t
+#endif
+
+#if defined(__NEED_pthread_cond_t) && !defined(__DEFINED_pthread_cond_t)
+typedef struct { union { int __i[12]; volatile int __vi[12]; void *__p[12*sizeof(int)/sizeof(void*)]; } __u; } pthread_cond_t;
+#define __DEFINED_pthread_cond_t
+#endif
+
+#if defined(__NEED_cnd_t) && !defined(__DEFINED_cnd_t)
+typedef struct { union { int __i[12]; volatile int __vi[12]; void *__p[12*sizeof(int)/sizeof(void*)]; } __u; } cnd_t;
+#define __DEFINED_cnd_t
+#endif
+
+#if defined(__NEED_pthread_rwlock_t) && !defined(__DEFINED_pthread_rwlock_t)
+typedef struct { union { int __i[sizeof(long)==8?14:8]; volatile int __vi[sizeof(long)==8?14:8]; void *__p[sizeof(long)==8?7:8]; } __u; } pthread_rwlock_t;
+#define __DEFINED_pthread_rwlock_t
+#endif
+
+#if defined(__NEED_pthread_barrier_t) && !defined(__DEFINED_pthread_barrier_t)
+typedef struct { union { int __i[sizeof(long)==8?8:5]; volatile int __vi[sizeof(long)==8?8:5]; void *__p[sizeof(long)==8?4:5]; } __u; } pthread_barrier_t;
+#define __DEFINED_pthread_barrier_t
+#endif
+
+
+#undef _Addr
+#undef _Int64
+#undef _Reg
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/fcntl.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/fcntl.h
new file mode 100644
index 0000000000..283a2d14a6
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/fcntl.h
@@ -0,0 +1,40 @@
+#define O_CREAT        0100
+#define O_EXCL         0200
+#define O_NOCTTY       0400
+#define O_TRUNC       01000
+#define O_APPEND      02000
+#define O_NONBLOCK    04000
+#define O_DSYNC      010000
+#define O_SYNC     04010000
+#define O_RSYNC    04010000
+#define O_DIRECTORY 0200000
+#define O_NOFOLLOW  0400000
+#define O_CLOEXEC  02000000
+
+#define O_ASYNC      020000
+#define O_DIRECT     040000
+#define O_LARGEFILE 0100000
+#define O_NOATIME  01000000
+#define O_PATH    010000000
+#define O_TMPFILE 020200000
+#define O_NDELAY O_NONBLOCK
+
+#define F_DUPFD  0
+#define F_GETFD  1
+#define F_SETFD  2
+#define F_GETFL  3
+#define F_SETFL  4
+
+#define F_SETOWN 8
+#define F_GETOWN 9
+#define F_SETSIG 10
+#define F_GETSIG 11
+
+#define F_GETLK 5
+#define F_SETLK 6
+#define F_SETLKW 7
+
+#define F_SETOWN_EX 15
+#define F_GETOWN_EX 16
+
+#define F_GETOWNER_UIDS 17
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/float.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/float.h
new file mode 100644
index 0000000000..7d0d173bbb
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/float.h
@@ -0,0 +1,20 @@
+#ifdef __FLT_EVAL_METHOD__
+#define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
+#else
+#define FLT_EVAL_METHOD 0
+#endif
+
+#define LDBL_TRUE_MIN 3.6451995318824746025e-4951L
+#define LDBL_MIN     3.3621031431120935063e-4932L
+#define LDBL_MAX     1.1897314953572317650e+4932L
+#define LDBL_EPSILON 1.0842021724855044340e-19L
+
+#define LDBL_MANT_DIG 64
+#define LDBL_MIN_EXP (-16381)
+#define LDBL_MAX_EXP 16384
+
+#define LDBL_DIG 18
+#define LDBL_MIN_10_EXP (-4931)
+#define LDBL_MAX_10_EXP 4932
+
+#define DECIMAL_DIG 21
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/io.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/io.h
new file mode 100644
index 0000000000..be42152adb
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/io.h
@@ -0,0 +1,77 @@
+static __inline void outb(unsigned char __val, unsigned short __port)
+{
+	__asm__ volatile ("outb %0,%1" : : "a" (__val), "dN" (__port));
+}
+
+static __inline void outw(unsigned short __val, unsigned short __port)
+{
+	__asm__ volatile ("outw %0,%1" : : "a" (__val), "dN" (__port));
+}
+
+static __inline void outl(unsigned int __val, unsigned short __port)
+{
+	__asm__ volatile ("outl %0,%1" : : "a" (__val), "dN" (__port));
+}
+
+static __inline unsigned char inb(unsigned short __port)
+{
+	unsigned char __val;
+	__asm__ volatile ("inb %1,%0" : "=a" (__val) : "dN" (__port));
+	return __val;
+}
+
+static __inline unsigned short inw(unsigned short __port)
+{
+	unsigned short __val;
+	__asm__ volatile ("inw %1,%0" : "=a" (__val) : "dN" (__port));
+	return __val;
+}
+
+static __inline unsigned int inl(unsigned short __port)
+{
+	unsigned int __val;
+	__asm__ volatile ("inl %1,%0" : "=a" (__val) : "dN" (__port));
+	return __val;
+}
+
+static __inline void outsb(unsigned short __port, const void *__buf, unsigned long __n)
+{
+	__asm__ volatile ("cld; rep; outsb"
+		      : "+S" (__buf), "+c" (__n)
+		      : "d" (__port));
+}
+
+static __inline void outsw(unsigned short __port, const void *__buf, unsigned long __n)
+{
+	__asm__ volatile ("cld; rep; outsw"
+		      : "+S" (__buf), "+c" (__n)
+		      : "d" (__port));
+}
+
+static __inline void outsl(unsigned short __port, const void *__buf, unsigned long __n)
+{
+	__asm__ volatile ("cld; rep; outsl"
+		      : "+S" (__buf), "+c"(__n)
+		      : "d" (__port));
+}
+
+static __inline void insb(unsigned short __port, void *__buf, unsigned long __n)
+{
+	__asm__ volatile ("cld; rep; insb"
+		      : "+D" (__buf), "+c" (__n)
+		      : "d" (__port));
+}
+
+static __inline void insw(unsigned short __port, void *__buf, unsigned long __n)
+{
+	__asm__ volatile ("cld; rep; insw"
+		      : "+D" (__buf), "+c" (__n)
+		      : "d" (__port));
+}
+
+static __inline void insl(unsigned short __port, void *__buf, unsigned long __n)
+{
+	__asm__ volatile ("cld; rep; insl"
+		      : "+D" (__buf), "+c" (__n)
+		      : "d" (__port));
+}
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/ioctl_fix.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/ioctl_fix.h
new file mode 100644
index 0000000000..b9825e1502
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/ioctl_fix.h
@@ -0,0 +1,4 @@
+#undef SIOCGSTAMP
+#undef SIOCGSTAMPNS
+#define SIOCGSTAMP      0x8906
+#define SIOCGSTAMPNS    0x8907
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/ipc.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/ipc.h
new file mode 100644
index 0000000000..d966c77610
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/ipc.h
@@ -0,0 +1,11 @@
+struct ipc_perm {
+	key_t __ipc_perm_key;
+	uid_t uid;
+	gid_t gid;
+	uid_t cuid;
+	gid_t cgid;
+	mode_t mode;
+	int __ipc_perm_seq;
+	long long __pad1;
+	long long __pad2;
+};
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/limits.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/limits.h
new file mode 100644
index 0000000000..fc11433d98
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/limits.h
@@ -0,0 +1 @@
+#define PAGESIZE 4096
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/mman.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/mman.h
new file mode 100644
index 0000000000..7d968b07ba
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/mman.h
@@ -0,0 +1 @@
+#define MAP_32BIT      0x40
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/msg.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/msg.h
new file mode 100644
index 0000000000..4bb57fb0cf
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/msg.h
@@ -0,0 +1,15 @@
+struct msqid_ds {
+	struct ipc_perm msg_perm;
+	time_t msg_stime;
+	time_t msg_rtime;
+	time_t msg_ctime;
+	unsigned long msg_cbytes;
+	long __unused1;
+	msgqnum_t msg_qnum;
+	long __unused2;
+	msglen_t msg_qbytes;
+	long __unused3;
+	pid_t msg_lspid;
+	pid_t msg_lrpid;
+	unsigned long long __unused[2];
+};
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/ptrace.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/ptrace.h
new file mode 100644
index 0000000000..4686ac24d1
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/ptrace.h
@@ -0,0 +1,13 @@
+#define PTRACE_GET_THREAD_AREA		25
+#define PTRACE_SET_THREAD_AREA		26
+#define PTRACE_ARCH_PRCTL		30
+#define PTRACE_SYSEMU			31
+#define PTRACE_SYSEMU_SINGLESTEP	32
+#define PTRACE_SINGLEBLOCK		33
+
+#define PT_GET_THREAD_AREA PTRACE_GET_THREAD_AREA
+#define PT_SET_THREAD_AREA PTRACE_SET_THREAD_AREA
+#define PT_ARCH_PRCTL PTRACE_ARCH_PRCTL
+#define PT_SYSEMU PTRACE_SYSEMU
+#define PT_SYSEMU_SINGLESTEP PTRACE_SYSEMU_SINGLESTEP
+#define PT_STEPBLOCK PTRACE_SINGLEBLOCK
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/reg.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/reg.h
new file mode 100644
index 0000000000..17d6f80728
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/reg.h
@@ -0,0 +1,29 @@
+#undef __WORDSIZE
+#define __WORDSIZE 32
+#define R15    0
+#define R14    1
+#define R13    2
+#define R12    3
+#define RBP    4
+#define RBX    5
+#define R11    6
+#define R10    7
+#define R9     8
+#define R8     9
+#define RAX    10
+#define RCX    11
+#define RDX    12
+#define RSI    13
+#define RDI    14
+#define ORIG_RAX 15
+#define RIP    16
+#define CS     17
+#define EFLAGS 18
+#define RSP    19
+#define SS     20
+#define FS_BASE 21
+#define GS_BASE 22
+#define DS     23
+#define ES     24
+#define FS     25
+#define GS     26
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/sem.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/sem.h
new file mode 100644
index 0000000000..2ece33de64
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/sem.h
@@ -0,0 +1,11 @@
+struct semid_ds {
+	struct ipc_perm sem_perm;
+	time_t sem_otime;
+	long long __unused1;
+	time_t sem_ctime;
+	long long __unused2;
+	unsigned short sem_nsems;
+	char __sem_nsems_pad[sizeof(long long)-sizeof(short)];
+	long long __unused3;
+	long long __unused4;
+};
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/setjmp.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/setjmp.h
new file mode 100644
index 0000000000..6cb43541a3
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/setjmp.h
@@ -0,0 +1 @@
+typedef unsigned long long __jmp_buf[8];
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/shm.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/shm.h
new file mode 100644
index 0000000000..f0685c1347
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/shm.h
@@ -0,0 +1,32 @@
+#define SHMLBA 4096
+
+struct shmid_ds {
+	struct ipc_perm shm_perm;
+	size_t shm_segsz;
+	time_t shm_atime;
+	time_t shm_dtime;
+	time_t shm_ctime;
+	pid_t shm_cpid;
+	pid_t shm_lpid;
+	unsigned long shm_nattch;
+	unsigned long __pad0;
+	unsigned long long __pad1;
+	unsigned long long __pad2;
+};
+
+struct shminfo {
+	unsigned long shmmax, __pad0, shmmin, __pad1, shmmni, __pad2,
+	              shmseg, __pad3, shmall, __pad4;
+	unsigned long long __unused[4];
+};
+
+struct shm_info {
+	int __used_ids;
+	int __pad_ids;
+	unsigned long shm_tot, __pad0, shm_rss, __pad1, shm_swp, __pad2;
+	unsigned long __swap_attempts, __pad3, __swap_successes, __pad4;
+}
+#ifdef __GNUC__
+__attribute__((__aligned__(8)))
+#endif
+;
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/signal.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/signal.h
new file mode 100644
index 0000000000..bd12c1b3fe
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/signal.h
@@ -0,0 +1,152 @@
+#if defined(_POSIX_SOURCE) || defined(_POSIX_C_SOURCE) \
+ || defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+
+#if defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+#define MINSIGSTKSZ 2048
+#define SIGSTKSZ 8192
+#endif
+
+#ifdef _GNU_SOURCE
+enum { REG_R8 = 0 };
+#define REG_R8 REG_R8
+enum { REG_R9 = 1 };
+#define REG_R9 REG_R9
+enum { REG_R10 = 2 };
+#define REG_R10 REG_R10
+enum { REG_R11 = 3 };
+#define REG_R11 REG_R11
+enum { REG_R12 = 4 };
+#define REG_R12 REG_R12
+enum { REG_R13 = 5 };
+#define REG_R13 REG_R13
+enum { REG_R14 = 6 };
+#define REG_R14 REG_R14
+enum { REG_R15 = 7 };
+#define REG_R15 REG_R15
+enum { REG_RDI = 8 };
+#define REG_RDI REG_RDI
+enum { REG_RSI = 9 };
+#define REG_RSI REG_RSI
+enum { REG_RBP = 10 };
+#define REG_RBP REG_RBP
+enum { REG_RBX = 11 };
+#define REG_RBX REG_RBX
+enum { REG_RDX = 12 };
+#define REG_RDX REG_RDX
+enum { REG_RAX = 13 };
+#define REG_RAX REG_RAX
+enum { REG_RCX = 14 };
+#define REG_RCX REG_RCX
+enum { REG_RSP = 15 };
+#define REG_RSP REG_RSP
+enum { REG_RIP = 16 };
+#define REG_RIP REG_RIP
+enum { REG_EFL = 17 };
+#define REG_EFL REG_EFL
+enum { REG_CSGSFS = 18 };
+#define REG_CSGSFS REG_CSGSFS
+enum { REG_ERR = 19 };
+#define REG_ERR REG_ERR
+enum { REG_TRAPNO = 20 };
+#define REG_TRAPNO REG_TRAPNO
+enum { REG_OLDMASK = 21 };
+#define REG_OLDMASK REG_OLDMASK
+enum { REG_CR2 = 22 };
+#define REG_CR2 REG_CR2
+#endif
+
+#if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+typedef long long greg_t, gregset_t[23];
+typedef struct _fpstate {
+	unsigned short cwd, swd, ftw, fop;
+	unsigned long long rip, rdp;
+	unsigned mxcsr, mxcr_mask;
+	struct {
+		unsigned short significand[4], exponent, padding[3];
+	} _st[8];
+	struct {
+		unsigned element[4];
+	} _xmm[16];
+	unsigned padding[24];
+} *fpregset_t;
+struct sigcontext {
+	unsigned long long r8, r9, r10, r11, r12, r13, r14, r15;
+	unsigned long long rdi, rsi, rbp, rbx, rdx, rax, rcx, rsp, rip, eflags;
+	unsigned short cs, gs, fs, __pad0;
+	unsigned long long err, trapno, oldmask, cr2;
+	struct _fpstate *fpstate;
+	unsigned long long __reserved1[8];
+};
+typedef struct {
+	gregset_t gregs;
+	fpregset_t fpregs;
+	unsigned long long __reserved1[8];
+} mcontext_t;
+#else
+typedef struct {
+	unsigned long long __space[32];
+} mcontext_t;
+#endif
+
+struct sigaltstack {
+	void *ss_sp;
+	int ss_flags;
+	size_t ss_size;
+};
+
+typedef struct __ucontext {
+	unsigned long uc_flags;
+	struct __ucontext *uc_link;
+	stack_t uc_stack;
+	mcontext_t uc_mcontext;
+	sigset_t uc_sigmask;
+	unsigned long long __fpregs_mem[64];
+} ucontext_t;
+
+#define SA_NOCLDSTOP  1
+#define SA_NOCLDWAIT  2
+#define SA_SIGINFO    4
+#define SA_ONSTACK    0x08000000
+#define SA_RESTART    0x10000000
+#define SA_NODEFER    0x40000000
+#define SA_RESETHAND  0x80000000
+#define SA_RESTORER   0x04000000
+
+#endif
+
+#define SIGHUP    1
+#define SIGINT    2
+#define SIGQUIT   3
+#define SIGILL    4
+#define SIGTRAP   5
+#define SIGABRT   6
+#define SIGIOT    SIGABRT
+#define SIGBUS    7
+#define SIGFPE    8
+#define SIGKILL   9
+#define SIGUSR1   10
+#define SIGSEGV   11
+#define SIGUSR2   12
+#define SIGPIPE   13
+#define SIGALRM   14
+#define SIGTERM   15
+#define SIGSTKFLT 16
+#define SIGCHLD   17
+#define SIGCONT   18
+#define SIGSTOP   19
+#define SIGTSTP   20
+#define SIGTTIN   21
+#define SIGTTOU   22
+#define SIGURG    23
+#define SIGXCPU   24
+#define SIGXFSZ   25
+#define SIGVTALRM 26
+#define SIGPROF   27
+#define SIGWINCH  28
+#define SIGIO     29
+#define SIGPOLL   29
+#define SIGPWR    30
+#define SIGSYS    31
+#define SIGUNUSED SIGSYS
+
+#define _NSIG 65
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/socket.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/socket.h
new file mode 100644
index 0000000000..fbb01c8cc9
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/socket.h
@@ -0,0 +1,5 @@
+#define SO_RCVTIMEO     20
+#define SO_SNDTIMEO     21
+#define SO_TIMESTAMP    29
+#define SO_TIMESTAMPNS  35
+#define SO_TIMESTAMPING 37
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/stat.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/stat.h
new file mode 100644
index 0000000000..5950d70452
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/stat.h
@@ -0,0 +1,22 @@
+/* copied from kernel definition, but with padding replaced
+ * by the corresponding correctly-sized userspace types. */
+
+struct stat {
+	dev_t st_dev;
+	ino_t st_ino;
+	nlink_t st_nlink;
+
+	mode_t st_mode;
+	uid_t st_uid;
+	gid_t st_gid;
+	unsigned int    __pad0;
+	dev_t st_rdev;
+	off_t st_size;
+	blksize_t st_blksize;
+	blkcnt_t st_blocks;
+
+	struct timespec st_atim;
+	struct timespec st_mtim;
+	struct timespec st_ctim;
+	long long __unused[3];
+};
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/statfs.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/statfs.h
new file mode 100644
index 0000000000..ed33fede67
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/statfs.h
@@ -0,0 +1,9 @@
+struct statfs {
+	unsigned long f_type, __pad0, f_bsize, __pad1;
+	fsblkcnt_t f_blocks, f_bfree, f_bavail;
+	fsfilcnt_t f_files, f_ffree;
+	fsid_t f_fsid;
+	unsigned long f_namelen, __pad2, f_frsize, __pad3;
+	unsigned long f_flags, __pad4;
+	unsigned long long f_spare[4];
+};
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/syscall.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/syscall.h
new file mode 100644
index 0000000000..076f1d5234
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/syscall.h
@@ -0,0 +1,707 @@
+#define __NR_read (0x40000000 + 0)
+#define __NR_write (0x40000000 + 1)
+#define __NR_open (0x40000000 + 2)
+#define __NR_close (0x40000000 + 3)
+#define __NR_stat (0x40000000 + 4)
+#define __NR_fstat (0x40000000 + 5)
+#define __NR_lstat (0x40000000 + 6)
+#define __NR_poll (0x40000000 + 7)
+#define __NR_lseek (0x40000000 + 8)
+#define __NR_mmap (0x40000000 + 9)
+#define __NR_mprotect (0x40000000 + 10)
+#define __NR_munmap (0x40000000 + 11)
+#define __NR_brk (0x40000000 + 12)
+#define __NR_rt_sigprocmask (0x40000000 + 14)
+#define __NR_pread64 (0x40000000 + 17)
+#define __NR_pwrite64 (0x40000000 + 18)
+#define __NR_access (0x40000000 + 21)
+#define __NR_pipe (0x40000000 + 22)
+#define __NR_select (0x40000000 + 23)
+#define __NR_sched_yield (0x40000000 + 24)
+#define __NR_mremap (0x40000000 + 25)
+#define __NR_msync (0x40000000 + 26)
+#define __NR_mincore (0x40000000 + 27)
+#define __NR_madvise (0x40000000 + 28)
+#define __NR_shmget (0x40000000 + 29)
+#define __NR_shmat (0x40000000 + 30)
+#define __NR_shmctl (0x40000000 + 31)
+#define __NR_dup (0x40000000 + 32)
+#define __NR_dup2 (0x40000000 + 33)
+#define __NR_pause (0x40000000 + 34)
+#define __NR_nanosleep (0x40000000 + 35)
+#define __NR_getitimer (0x40000000 + 36)
+#define __NR_alarm (0x40000000 + 37)
+#define __NR_setitimer (0x40000000 + 38)
+#define __NR_getpid (0x40000000 + 39)
+#define __NR_sendfile (0x40000000 + 40)
+#define __NR_socket (0x40000000 + 41)
+#define __NR_connect (0x40000000 + 42)
+#define __NR_accept (0x40000000 + 43)
+#define __NR_sendto (0x40000000 + 44)
+#define __NR_shutdown (0x40000000 + 48)
+#define __NR_bind (0x40000000 + 49)
+#define __NR_listen (0x40000000 + 50)
+#define __NR_getsockname (0x40000000 + 51)
+#define __NR_getpeername (0x40000000 + 52)
+#define __NR_socketpair (0x40000000 + 53)
+#define __NR_clone (0x40000000 + 56)
+#define __NR_fork (0x40000000 + 57)
+#define __NR_vfork (0x40000000 + 58)
+#define __NR_exit (0x40000000 + 60)
+#define __NR_wait4 (0x40000000 + 61)
+#define __NR_kill (0x40000000 + 62)
+#define __NR_uname (0x40000000 + 63)
+#define __NR_semget (0x40000000 + 64)
+#define __NR_semop (0x40000000 + 65)
+#define __NR_semctl (0x40000000 + 66)
+#define __NR_shmdt (0x40000000 + 67)
+#define __NR_msgget (0x40000000 + 68)
+#define __NR_msgsnd (0x40000000 + 69)
+#define __NR_msgrcv (0x40000000 + 70)
+#define __NR_msgctl (0x40000000 + 71)
+#define __NR_fcntl (0x40000000 + 72)
+#define __NR_flock (0x40000000 + 73)
+#define __NR_fsync (0x40000000 + 74)
+#define __NR_fdatasync (0x40000000 + 75)
+#define __NR_truncate (0x40000000 + 76)
+#define __NR_ftruncate (0x40000000 + 77)
+#define __NR_getdents (0x40000000 + 78)
+#define __NR_getcwd (0x40000000 + 79)
+#define __NR_chdir (0x40000000 + 80)
+#define __NR_fchdir (0x40000000 + 81)
+#define __NR_rename (0x40000000 + 82)
+#define __NR_mkdir (0x40000000 + 83)
+#define __NR_rmdir (0x40000000 + 84)
+#define __NR_creat (0x40000000 + 85)
+#define __NR_link (0x40000000 + 86)
+#define __NR_unlink (0x40000000 + 87)
+#define __NR_symlink (0x40000000 + 88)
+#define __NR_readlink (0x40000000 + 89)
+#define __NR_chmod (0x40000000 + 90)
+#define __NR_fchmod (0x40000000 + 91)
+#define __NR_chown (0x40000000 + 92)
+#define __NR_fchown (0x40000000 + 93)
+#define __NR_lchown (0x40000000 + 94)
+#define __NR_umask (0x40000000 + 95)
+#define __NR_gettimeofday (0x40000000 + 96)
+#define __NR_getrlimit (0x40000000 + 97)
+#define __NR_getrusage (0x40000000 + 98)
+#define __NR_sysinfo (0x40000000 + 99)
+#define __NR_times (0x40000000 + 100)
+#define __NR_getuid (0x40000000 + 102)
+#define __NR_syslog (0x40000000 + 103)
+#define __NR_getgid (0x40000000 + 104)
+#define __NR_setuid (0x40000000 + 105)
+#define __NR_setgid (0x40000000 + 106)
+#define __NR_geteuid (0x40000000 + 107)
+#define __NR_getegid (0x40000000 + 108)
+#define __NR_setpgid (0x40000000 + 109)
+#define __NR_getppid (0x40000000 + 110)
+#define __NR_getpgrp (0x40000000 + 111)
+#define __NR_setsid (0x40000000 + 112)
+#define __NR_setreuid (0x40000000 + 113)
+#define __NR_setregid (0x40000000 + 114)
+#define __NR_getgroups (0x40000000 + 115)
+#define __NR_setgroups (0x40000000 + 116)
+#define __NR_setresuid (0x40000000 + 117)
+#define __NR_getresuid (0x40000000 + 118)
+#define __NR_setresgid (0x40000000 + 119)
+#define __NR_getresgid (0x40000000 + 120)
+#define __NR_getpgid (0x40000000 + 121)
+#define __NR_setfsuid (0x40000000 + 122)
+#define __NR_setfsgid (0x40000000 + 123)
+#define __NR_getsid (0x40000000 + 124)
+#define __NR_capget (0x40000000 + 125)
+#define __NR_capset (0x40000000 + 126)
+#define __NR_rt_sigsuspend (0x40000000 + 130)
+#define __NR_utime (0x40000000 + 132)
+#define __NR_mknod (0x40000000 + 133)
+#define __NR_personality (0x40000000 + 135)
+#define __NR_ustat (0x40000000 + 136)
+#define __NR_statfs (0x40000000 + 137)
+#define __NR_fstatfs (0x40000000 + 138)
+#define __NR_sysfs (0x40000000 + 139)
+#define __NR_getpriority (0x40000000 + 140)
+#define __NR_setpriority (0x40000000 + 141)
+#define __NR_sched_setparam (0x40000000 + 142)
+#define __NR_sched_getparam (0x40000000 + 143)
+#define __NR_sched_setscheduler (0x40000000 + 144)
+#define __NR_sched_getscheduler (0x40000000 + 145)
+#define __NR_sched_get_priority_max (0x40000000 + 146)
+#define __NR_sched_get_priority_min (0x40000000 + 147)
+#define __NR_sched_rr_get_interval (0x40000000 + 148)
+#define __NR_mlock (0x40000000 + 149)
+#define __NR_munlock (0x40000000 + 150)
+#define __NR_mlockall (0x40000000 + 151)
+#define __NR_munlockall (0x40000000 + 152)
+#define __NR_vhangup (0x40000000 + 153)
+#define __NR_modify_ldt (0x40000000 + 154)
+#define __NR_pivot_root (0x40000000 + 155)
+#define __NR_prctl (0x40000000 + 157)
+#define __NR_arch_prctl (0x40000000 + 158)
+#define __NR_adjtimex (0x40000000 + 159)
+#define __NR_setrlimit (0x40000000 + 160)
+#define __NR_chroot (0x40000000 + 161)
+#define __NR_sync (0x40000000 + 162)
+#define __NR_acct (0x40000000 + 163)
+#define __NR_settimeofday (0x40000000 + 164)
+#define __NR_mount (0x40000000 + 165)
+#define __NR_umount2 (0x40000000 + 166)
+#define __NR_swapon (0x40000000 + 167)
+#define __NR_swapoff (0x40000000 + 168)
+#define __NR_reboot (0x40000000 + 169)
+#define __NR_sethostname (0x40000000 + 170)
+#define __NR_setdomainname (0x40000000 + 171)
+#define __NR_iopl (0x40000000 + 172)
+#define __NR_ioperm (0x40000000 + 173)
+#define __NR_init_module (0x40000000 + 175)
+#define __NR_delete_module (0x40000000 + 176)
+#define __NR_quotactl (0x40000000 + 179)
+#define __NR_getpmsg (0x40000000 + 181)
+#define __NR_putpmsg (0x40000000 + 182)
+#define __NR_afs_syscall (0x40000000 + 183)
+#define __NR_tuxcall (0x40000000 + 184)
+#define __NR_security (0x40000000 + 185)
+#define __NR_gettid (0x40000000 + 186)
+#define __NR_readahead (0x40000000 + 187)
+#define __NR_setxattr (0x40000000 + 188)
+#define __NR_lsetxattr (0x40000000 + 189)
+#define __NR_fsetxattr (0x40000000 + 190)
+#define __NR_getxattr (0x40000000 + 191)
+#define __NR_lgetxattr (0x40000000 + 192)
+#define __NR_fgetxattr (0x40000000 + 193)
+#define __NR_listxattr (0x40000000 + 194)
+#define __NR_llistxattr (0x40000000 + 195)
+#define __NR_flistxattr (0x40000000 + 196)
+#define __NR_removexattr (0x40000000 + 197)
+#define __NR_lremovexattr (0x40000000 + 198)
+#define __NR_fremovexattr (0x40000000 + 199)
+#define __NR_tkill (0x40000000 + 200)
+#define __NR_time (0x40000000 + 201)
+#define __NR_futex (0x40000000 + 202)
+#define __NR_sched_setaffinity (0x40000000 + 203)
+#define __NR_sched_getaffinity (0x40000000 + 204)
+#define __NR_io_destroy (0x40000000 + 207)
+#define __NR_io_getevents (0x40000000 + 208)
+#define __NR_io_cancel (0x40000000 + 210)
+#define __NR_lookup_dcookie (0x40000000 + 212)
+#define __NR_epoll_create (0x40000000 + 213)
+#define __NR_remap_file_pages (0x40000000 + 216)
+#define __NR_getdents64 (0x40000000 + 217)
+#define __NR_set_tid_address (0x40000000 + 218)
+#define __NR_restart_syscall (0x40000000 + 219)
+#define __NR_semtimedop (0x40000000 + 220)
+#define __NR_fadvise64 (0x40000000 + 221)
+#define __NR_timer_settime (0x40000000 + 223)
+#define __NR_timer_gettime (0x40000000 + 224)
+#define __NR_timer_getoverrun (0x40000000 + 225)
+#define __NR_timer_delete (0x40000000 + 226)
+#define __NR_clock_settime (0x40000000 + 227)
+#define __NR_clock_gettime (0x40000000 + 228)
+#define __NR_clock_getres (0x40000000 + 229)
+#define __NR_clock_nanosleep (0x40000000 + 230)
+#define __NR_exit_group (0x40000000 + 231)
+#define __NR_epoll_wait (0x40000000 + 232)
+#define __NR_epoll_ctl (0x40000000 + 233)
+#define __NR_tgkill (0x40000000 + 234)
+#define __NR_utimes (0x40000000 + 235)
+#define __NR_mbind (0x40000000 + 237)
+#define __NR_set_mempolicy (0x40000000 + 238)
+#define __NR_get_mempolicy (0x40000000 + 239)
+#define __NR_mq_open (0x40000000 + 240)
+#define __NR_mq_unlink (0x40000000 + 241)
+#define __NR_mq_timedsend (0x40000000 + 242)
+#define __NR_mq_timedreceive (0x40000000 + 243)
+#define __NR_mq_getsetattr (0x40000000 + 245)
+#define __NR_add_key (0x40000000 + 248)
+#define __NR_request_key (0x40000000 + 249)
+#define __NR_keyctl (0x40000000 + 250)
+#define __NR_ioprio_set (0x40000000 + 251)
+#define __NR_ioprio_get (0x40000000 + 252)
+#define __NR_inotify_init (0x40000000 + 253)
+#define __NR_inotify_add_watch (0x40000000 + 254)
+#define __NR_inotify_rm_watch (0x40000000 + 255)
+#define __NR_migrate_pages (0x40000000 + 256)
+#define __NR_openat (0x40000000 + 257)
+#define __NR_mkdirat (0x40000000 + 258)
+#define __NR_mknodat (0x40000000 + 259)
+#define __NR_fchownat (0x40000000 + 260)
+#define __NR_futimesat (0x40000000 + 261)
+#define __NR_newfstatat (0x40000000 + 262)
+#define __NR_unlinkat (0x40000000 + 263)
+#define __NR_renameat (0x40000000 + 264)
+#define __NR_linkat (0x40000000 + 265)
+#define __NR_symlinkat (0x40000000 + 266)
+#define __NR_readlinkat (0x40000000 + 267)
+#define __NR_fchmodat (0x40000000 + 268)
+#define __NR_faccessat (0x40000000 + 269)
+#define __NR_pselect6 (0x40000000 + 270)
+#define __NR_ppoll (0x40000000 + 271)
+#define __NR_unshare (0x40000000 + 272)
+#define __NR_splice (0x40000000 + 275)
+#define __NR_tee (0x40000000 + 276)
+#define __NR_sync_file_range (0x40000000 + 277)
+#define __NR_utimensat (0x40000000 + 280)
+#define __NR_epoll_pwait (0x40000000 + 281)
+#define __NR_signalfd (0x40000000 + 282)
+#define __NR_timerfd_create (0x40000000 + 283)
+#define __NR_eventfd (0x40000000 + 284)
+#define __NR_fallocate (0x40000000 + 285)
+#define __NR_timerfd_settime (0x40000000 + 286)
+#define __NR_timerfd_gettime (0x40000000 + 287)
+#define __NR_accept4 (0x40000000 + 288)
+#define __NR_signalfd4 (0x40000000 + 289)
+#define __NR_eventfd2 (0x40000000 + 290)
+#define __NR_epoll_create1 (0x40000000 + 291)
+#define __NR_dup3 (0x40000000 + 292)
+#define __NR_pipe2 (0x40000000 + 293)
+#define __NR_inotify_init1 (0x40000000 + 294)
+#define __NR_perf_event_open (0x40000000 + 298)
+#define __NR_fanotify_init (0x40000000 + 300)
+#define __NR_fanotify_mark (0x40000000 + 301)
+#define __NR_prlimit64 (0x40000000 + 302)
+#define __NR_name_to_handle_at (0x40000000 + 303)
+#define __NR_open_by_handle_at (0x40000000 + 304)
+#define __NR_clock_adjtime (0x40000000 + 305)
+#define __NR_syncfs (0x40000000 + 306)
+#define __NR_setns (0x40000000 + 308)
+#define __NR_getcpu (0x40000000 + 309)
+#define __NR_kcmp (0x40000000 + 312)
+#define __NR_finit_module (0x40000000 + 313)
+#define __NR_sched_setattr (0x40000000 + 314)
+#define __NR_sched_getattr (0x40000000 + 315)
+#define __NR_renameat2 (0x40000000 + 316)
+#define __NR_seccomp (0x40000000 + 317)
+#define __NR_getrandom (0x40000000 + 318)
+#define __NR_memfd_create (0x40000000 + 319)
+#define __NR_kexec_file_load (0x40000000 + 320)
+#define __NR_bpf (0x40000000 + 321)
+#define __NR_userfaultfd (0x40000000 + 323)
+#define __NR_membarrier (0x40000000 + 324)
+#define __NR_mlock2 (0x40000000 + 325)
+#define __NR_copy_file_range (0x40000000 + 326)
+#define __NR_pkey_mprotect (0x40000000 + 329)
+#define __NR_pkey_alloc (0x40000000 + 330)
+#define __NR_pkey_free (0x40000000 + 331)
+#define __NR_statx (0x40000000 + 332)
+#define __NR_io_pgetevents (0x40000000 + 333)
+#define __NR_rseq (0x40000000 + 334)
+#define __NR_pidfd_send_signal (0x40000000 + 424)
+#define __NR_io_uring_setup (0x40000000 + 425)
+#define __NR_io_uring_enter (0x40000000 + 426)
+#define __NR_io_uring_register (0x40000000 + 427)
+#define __NR_open_tree		(0x40000000 + 428)
+#define __NR_move_mount		(0x40000000 + 429)
+#define __NR_fsopen		(0x40000000 + 430)
+#define __NR_fsconfig		(0x40000000 + 431)
+#define __NR_fsmount		(0x40000000 + 432)
+#define __NR_fspick		(0x40000000 + 433)
+#define __NR_pidfd_open		(0x40000000 + 434)
+#define __NR_clone3		(0x40000000 + 435)
+#define __NR_close_range	(0x40000000 + 436)
+#define __NR_openat2		(0x40000000 + 437)
+#define __NR_pidfd_getfd	(0x40000000 + 438)
+#define __NR_faccessat2		(0x40000000 + 439)
+#define __NR_process_madvise	(0x40000000 + 440)
+#define __NR_epoll_pwait2	(0x40000000 + 441)
+#define __NR_mount_setattr	(0x40000000 + 442)
+#define __NR_landlock_create_ruleset	(0x40000000 + 444)
+#define __NR_landlock_add_rule	(0x40000000 + 445)
+#define __NR_landlock_restrict_self	(0x40000000 + 446)
+#define __NR_memfd_secret	(0x40000000 + 447)
+#define __NR_process_mrelease	(0x40000000 + 448)
+#define __NR_futex_waitv	(0x40000000 + 449)
+#define __NR_set_mempolicy_home_node	(0x40000000 + 450)
+#define __NR_cachestat		(0x40000000 + 451)
+#define __NR_fchmodat2		(0x40000000 + 452)
+
+
+#define __NR_rt_sigaction (0x40000000 + 512)
+#define __NR_rt_sigreturn (0x40000000 + 513)
+#define __NR_ioctl (0x40000000 + 514)
+#define __NR_readv (0x40000000 + 515)
+#define __NR_writev (0x40000000 + 516)
+#define __NR_recvfrom (0x40000000 + 517)
+#define __NR_sendmsg (0x40000000 + 518)
+#define __NR_recvmsg (0x40000000 + 519)
+#define __NR_execve (0x40000000 + 520)
+#define __NR_ptrace (0x40000000 + 521)
+#define __NR_rt_sigpending (0x40000000 + 522)
+#define __NR_rt_sigtimedwait (0x40000000 + 523)
+#define __NR_rt_sigqueueinfo (0x40000000 + 524)
+#define __NR_sigaltstack (0x40000000 + 525)
+#define __NR_timer_create (0x40000000 + 526)
+#define __NR_mq_notify (0x40000000 + 527)
+#define __NR_kexec_load (0x40000000 + 528)
+#define __NR_waitid (0x40000000 + 529)
+#define __NR_set_robust_list (0x40000000 + 530)
+#define __NR_get_robust_list (0x40000000 + 531)
+#define __NR_vmsplice (0x40000000 + 532)
+#define __NR_move_pages (0x40000000 + 533)
+#define __NR_preadv (0x40000000 + 534)
+#define __NR_pwritev (0x40000000 + 535)
+#define __NR_rt_tgsigqueueinfo (0x40000000 + 536)
+#define __NR_recvmmsg (0x40000000 + 537)
+#define __NR_sendmmsg (0x40000000 + 538)
+#define __NR_process_vm_readv (0x40000000 + 539)
+#define __NR_process_vm_writev (0x40000000 + 540)
+#define __NR_setsockopt (0x40000000 + 541)
+#define __NR_getsockopt (0x40000000 + 542)
+#define __NR_io_setup (0x40000000 + 543)
+#define __NR_io_submit (0x40000000 + 544)
+#define __NR_execveat (0x40000000 + 545)
+#define __NR_preadv2 (0x40000000 + 546)
+#define __NR_pwritev2 (0x40000000 + 547)
+
+#define SYS_read (0x40000000 + 0)
+#define SYS_write (0x40000000 + 1)
+#define SYS_open (0x40000000 + 2)
+#define SYS_close (0x40000000 + 3)
+#define SYS_stat (0x40000000 + 4)
+#define SYS_fstat (0x40000000 + 5)
+#define SYS_lstat (0x40000000 + 6)
+#define SYS_poll (0x40000000 + 7)
+#define SYS_lseek (0x40000000 + 8)
+#define SYS_mmap (0x40000000 + 9)
+#define SYS_mprotect (0x40000000 + 10)
+#define SYS_munmap (0x40000000 + 11)
+#define SYS_brk (0x40000000 + 12)
+#define SYS_rt_sigprocmask (0x40000000 + 14)
+#define SYS_pread64 (0x40000000 + 17)
+#define SYS_pwrite64 (0x40000000 + 18)
+#define SYS_access (0x40000000 + 21)
+#define SYS_pipe (0x40000000 + 22)
+#define SYS_select (0x40000000 + 23)
+#define SYS_sched_yield (0x40000000 + 24)
+#define SYS_mremap (0x40000000 + 25)
+#define SYS_msync (0x40000000 + 26)
+#define SYS_mincore (0x40000000 + 27)
+#define SYS_madvise (0x40000000 + 28)
+#define SYS_shmget (0x40000000 + 29)
+#define SYS_shmat (0x40000000 + 30)
+#define SYS_shmctl (0x40000000 + 31)
+#define SYS_dup (0x40000000 + 32)
+#define SYS_dup2 (0x40000000 + 33)
+#define SYS_pause (0x40000000 + 34)
+#define SYS_nanosleep (0x40000000 + 35)
+#define SYS_getitimer (0x40000000 + 36)
+#define SYS_alarm (0x40000000 + 37)
+#define SYS_setitimer (0x40000000 + 38)
+#define SYS_getpid (0x40000000 + 39)
+#define SYS_sendfile (0x40000000 + 40)
+#define SYS_socket (0x40000000 + 41)
+#define SYS_connect (0x40000000 + 42)
+#define SYS_accept (0x40000000 + 43)
+#define SYS_sendto (0x40000000 + 44)
+#define SYS_shutdown (0x40000000 + 48)
+#define SYS_bind (0x40000000 + 49)
+#define SYS_listen (0x40000000 + 50)
+#define SYS_getsockname (0x40000000 + 51)
+#define SYS_getpeername (0x40000000 + 52)
+#define SYS_socketpair (0x40000000 + 53)
+#define SYS_clone (0x40000000 + 56)
+#define SYS_fork (0x40000000 + 57)
+#define SYS_vfork (0x40000000 + 58)
+#define SYS_exit (0x40000000 + 60)
+#define SYS_wait4 (0x40000000 + 61)
+#define SYS_kill (0x40000000 + 62)
+#define SYS_uname (0x40000000 + 63)
+#define SYS_semget (0x40000000 + 64)
+#define SYS_semop (0x40000000 + 65)
+#define SYS_semctl (0x40000000 + 66)
+#define SYS_shmdt (0x40000000 + 67)
+#define SYS_msgget (0x40000000 + 68)
+#define SYS_msgsnd (0x40000000 + 69)
+#define SYS_msgrcv (0x40000000 + 70)
+#define SYS_msgctl (0x40000000 + 71)
+#define SYS_fcntl (0x40000000 + 72)
+#define SYS_flock (0x40000000 + 73)
+#define SYS_fsync (0x40000000 + 74)
+#define SYS_fdatasync (0x40000000 + 75)
+#define SYS_truncate (0x40000000 + 76)
+#define SYS_ftruncate (0x40000000 + 77)
+#define SYS_getdents (0x40000000 + 78)
+#define SYS_getcwd (0x40000000 + 79)
+#define SYS_chdir (0x40000000 + 80)
+#define SYS_fchdir (0x40000000 + 81)
+#define SYS_rename (0x40000000 + 82)
+#define SYS_mkdir (0x40000000 + 83)
+#define SYS_rmdir (0x40000000 + 84)
+#define SYS_creat (0x40000000 + 85)
+#define SYS_link (0x40000000 + 86)
+#define SYS_unlink (0x40000000 + 87)
+#define SYS_symlink (0x40000000 + 88)
+#define SYS_readlink (0x40000000 + 89)
+#define SYS_chmod (0x40000000 + 90)
+#define SYS_fchmod (0x40000000 + 91)
+#define SYS_chown (0x40000000 + 92)
+#define SYS_fchown (0x40000000 + 93)
+#define SYS_lchown (0x40000000 + 94)
+#define SYS_umask (0x40000000 + 95)
+#define SYS_gettimeofday (0x40000000 + 96)
+#define SYS_getrlimit (0x40000000 + 97)
+#define SYS_getrusage (0x40000000 + 98)
+#define SYS_sysinfo (0x40000000 + 99)
+#define SYS_times (0x40000000 + 100)
+#define SYS_getuid (0x40000000 + 102)
+#define SYS_syslog (0x40000000 + 103)
+#define SYS_getgid (0x40000000 + 104)
+#define SYS_setuid (0x40000000 + 105)
+#define SYS_setgid (0x40000000 + 106)
+#define SYS_geteuid (0x40000000 + 107)
+#define SYS_getegid (0x40000000 + 108)
+#define SYS_setpgid (0x40000000 + 109)
+#define SYS_getppid (0x40000000 + 110)
+#define SYS_getpgrp (0x40000000 + 111)
+#define SYS_setsid (0x40000000 + 112)
+#define SYS_setreuid (0x40000000 + 113)
+#define SYS_setregid (0x40000000 + 114)
+#define SYS_getgroups (0x40000000 + 115)
+#define SYS_setgroups (0x40000000 + 116)
+#define SYS_setresuid (0x40000000 + 117)
+#define SYS_getresuid (0x40000000 + 118)
+#define SYS_setresgid (0x40000000 + 119)
+#define SYS_getresgid (0x40000000 + 120)
+#define SYS_getpgid (0x40000000 + 121)
+#define SYS_setfsuid (0x40000000 + 122)
+#define SYS_setfsgid (0x40000000 + 123)
+#define SYS_getsid (0x40000000 + 124)
+#define SYS_capget (0x40000000 + 125)
+#define SYS_capset (0x40000000 + 126)
+#define SYS_rt_sigsuspend (0x40000000 + 130)
+#define SYS_utime (0x40000000 + 132)
+#define SYS_mknod (0x40000000 + 133)
+#define SYS_personality (0x40000000 + 135)
+#define SYS_ustat (0x40000000 + 136)
+#define SYS_statfs (0x40000000 + 137)
+#define SYS_fstatfs (0x40000000 + 138)
+#define SYS_sysfs (0x40000000 + 139)
+#define SYS_getpriority (0x40000000 + 140)
+#define SYS_setpriority (0x40000000 + 141)
+#define SYS_sched_setparam (0x40000000 + 142)
+#define SYS_sched_getparam (0x40000000 + 143)
+#define SYS_sched_setscheduler (0x40000000 + 144)
+#define SYS_sched_getscheduler (0x40000000 + 145)
+#define SYS_sched_get_priority_max (0x40000000 + 146)
+#define SYS_sched_get_priority_min (0x40000000 + 147)
+#define SYS_sched_rr_get_interval (0x40000000 + 148)
+#define SYS_mlock (0x40000000 + 149)
+#define SYS_munlock (0x40000000 + 150)
+#define SYS_mlockall (0x40000000 + 151)
+#define SYS_munlockall (0x40000000 + 152)
+#define SYS_vhangup (0x40000000 + 153)
+#define SYS_modify_ldt (0x40000000 + 154)
+#define SYS_pivot_root (0x40000000 + 155)
+#define SYS_prctl (0x40000000 + 157)
+#define SYS_arch_prctl (0x40000000 + 158)
+#define SYS_adjtimex (0x40000000 + 159)
+#define SYS_setrlimit (0x40000000 + 160)
+#define SYS_chroot (0x40000000 + 161)
+#define SYS_sync (0x40000000 + 162)
+#define SYS_acct (0x40000000 + 163)
+#define SYS_settimeofday (0x40000000 + 164)
+#define SYS_mount (0x40000000 + 165)
+#define SYS_umount2 (0x40000000 + 166)
+#define SYS_swapon (0x40000000 + 167)
+#define SYS_swapoff (0x40000000 + 168)
+#define SYS_reboot (0x40000000 + 169)
+#define SYS_sethostname (0x40000000 + 170)
+#define SYS_setdomainname (0x40000000 + 171)
+#define SYS_iopl (0x40000000 + 172)
+#define SYS_ioperm (0x40000000 + 173)
+#define SYS_init_module (0x40000000 + 175)
+#define SYS_delete_module (0x40000000 + 176)
+#define SYS_quotactl (0x40000000 + 179)
+#define SYS_getpmsg (0x40000000 + 181)
+#define SYS_putpmsg (0x40000000 + 182)
+#define SYS_afs_syscall (0x40000000 + 183)
+#define SYS_tuxcall (0x40000000 + 184)
+#define SYS_security (0x40000000 + 185)
+#define SYS_gettid (0x40000000 + 186)
+#define SYS_readahead (0x40000000 + 187)
+#define SYS_setxattr (0x40000000 + 188)
+#define SYS_lsetxattr (0x40000000 + 189)
+#define SYS_fsetxattr (0x40000000 + 190)
+#define SYS_getxattr (0x40000000 + 191)
+#define SYS_lgetxattr (0x40000000 + 192)
+#define SYS_fgetxattr (0x40000000 + 193)
+#define SYS_listxattr (0x40000000 + 194)
+#define SYS_llistxattr (0x40000000 + 195)
+#define SYS_flistxattr (0x40000000 + 196)
+#define SYS_removexattr (0x40000000 + 197)
+#define SYS_lremovexattr (0x40000000 + 198)
+#define SYS_fremovexattr (0x40000000 + 199)
+#define SYS_tkill (0x40000000 + 200)
+#define SYS_time (0x40000000 + 201)
+#define SYS_futex (0x40000000 + 202)
+#define SYS_sched_setaffinity (0x40000000 + 203)
+#define SYS_sched_getaffinity (0x40000000 + 204)
+#define SYS_io_destroy (0x40000000 + 207)
+#define SYS_io_getevents (0x40000000 + 208)
+#define SYS_io_cancel (0x40000000 + 210)
+#define SYS_lookup_dcookie (0x40000000 + 212)
+#define SYS_epoll_create (0x40000000 + 213)
+#define SYS_remap_file_pages (0x40000000 + 216)
+#define SYS_getdents64 (0x40000000 + 217)
+#define SYS_set_tid_address (0x40000000 + 218)
+#define SYS_restart_syscall (0x40000000 + 219)
+#define SYS_semtimedop (0x40000000 + 220)
+#define SYS_fadvise64 (0x40000000 + 221)
+#define SYS_timer_settime (0x40000000 + 223)
+#define SYS_timer_gettime (0x40000000 + 224)
+#define SYS_timer_getoverrun (0x40000000 + 225)
+#define SYS_timer_delete (0x40000000 + 226)
+#define SYS_clock_settime (0x40000000 + 227)
+#define SYS_clock_gettime (0x40000000 + 228)
+#define SYS_clock_getres (0x40000000 + 229)
+#define SYS_clock_nanosleep (0x40000000 + 230)
+#define SYS_exit_group (0x40000000 + 231)
+#define SYS_epoll_wait (0x40000000 + 232)
+#define SYS_epoll_ctl (0x40000000 + 233)
+#define SYS_tgkill (0x40000000 + 234)
+#define SYS_utimes (0x40000000 + 235)
+#define SYS_mbind (0x40000000 + 237)
+#define SYS_set_mempolicy (0x40000000 + 238)
+#define SYS_get_mempolicy (0x40000000 + 239)
+#define SYS_mq_open (0x40000000 + 240)
+#define SYS_mq_unlink (0x40000000 + 241)
+#define SYS_mq_timedsend (0x40000000 + 242)
+#define SYS_mq_timedreceive (0x40000000 + 243)
+#define SYS_mq_getsetattr (0x40000000 + 245)
+#define SYS_add_key (0x40000000 + 248)
+#define SYS_request_key (0x40000000 + 249)
+#define SYS_keyctl (0x40000000 + 250)
+#define SYS_ioprio_set (0x40000000 + 251)
+#define SYS_ioprio_get (0x40000000 + 252)
+#define SYS_inotify_init (0x40000000 + 253)
+#define SYS_inotify_add_watch (0x40000000 + 254)
+#define SYS_inotify_rm_watch (0x40000000 + 255)
+#define SYS_migrate_pages (0x40000000 + 256)
+#define SYS_openat (0x40000000 + 257)
+#define SYS_mkdirat (0x40000000 + 258)
+#define SYS_mknodat (0x40000000 + 259)
+#define SYS_fchownat (0x40000000 + 260)
+#define SYS_futimesat (0x40000000 + 261)
+#define SYS_newfstatat (0x40000000 + 262)
+#define SYS_unlinkat (0x40000000 + 263)
+#define SYS_renameat (0x40000000 + 264)
+#define SYS_linkat (0x40000000 + 265)
+#define SYS_symlinkat (0x40000000 + 266)
+#define SYS_readlinkat (0x40000000 + 267)
+#define SYS_fchmodat (0x40000000 + 268)
+#define SYS_faccessat (0x40000000 + 269)
+#define SYS_pselect6 (0x40000000 + 270)
+#define SYS_ppoll (0x40000000 + 271)
+#define SYS_unshare (0x40000000 + 272)
+#define SYS_splice (0x40000000 + 275)
+#define SYS_tee (0x40000000 + 276)
+#define SYS_sync_file_range (0x40000000 + 277)
+#define SYS_utimensat (0x40000000 + 280)
+#define SYS_epoll_pwait (0x40000000 + 281)
+#define SYS_signalfd (0x40000000 + 282)
+#define SYS_timerfd_create (0x40000000 + 283)
+#define SYS_eventfd (0x40000000 + 284)
+#define SYS_fallocate (0x40000000 + 285)
+#define SYS_timerfd_settime (0x40000000 + 286)
+#define SYS_timerfd_gettime (0x40000000 + 287)
+#define SYS_accept4 (0x40000000 + 288)
+#define SYS_signalfd4 (0x40000000 + 289)
+#define SYS_eventfd2 (0x40000000 + 290)
+#define SYS_epoll_create1 (0x40000000 + 291)
+#define SYS_dup3 (0x40000000 + 292)
+#define SYS_pipe2 (0x40000000 + 293)
+#define SYS_inotify_init1 (0x40000000 + 294)
+#define SYS_perf_event_open (0x40000000 + 298)
+#define SYS_fanotify_init (0x40000000 + 300)
+#define SYS_fanotify_mark (0x40000000 + 301)
+#define SYS_prlimit64 (0x40000000 + 302)
+#define SYS_name_to_handle_at (0x40000000 + 303)
+#define SYS_open_by_handle_at (0x40000000 + 304)
+#define SYS_clock_adjtime (0x40000000 + 305)
+#define SYS_syncfs (0x40000000 + 306)
+#define SYS_setns (0x40000000 + 308)
+#define SYS_getcpu (0x40000000 + 309)
+#define SYS_kcmp (0x40000000 + 312)
+#define SYS_finit_module (0x40000000 + 313)
+#define SYS_sched_setattr (0x40000000 + 314)
+#define SYS_sched_getattr (0x40000000 + 315)
+#define SYS_renameat2 (0x40000000 + 316)
+#define SYS_seccomp (0x40000000 + 317)
+#define SYS_getrandom (0x40000000 + 318)
+#define SYS_memfd_create (0x40000000 + 319)
+#define SYS_kexec_file_load (0x40000000 + 320)
+#define SYS_bpf (0x40000000 + 321)
+#define SYS_userfaultfd (0x40000000 + 323)
+#define SYS_membarrier (0x40000000 + 324)
+#define SYS_mlock2 (0x40000000 + 325)
+#define SYS_copy_file_range (0x40000000 + 326)
+#define SYS_pkey_mprotect (0x40000000 + 329)
+#define SYS_pkey_alloc (0x40000000 + 330)
+#define SYS_pkey_free (0x40000000 + 331)
+#define SYS_statx (0x40000000 + 332)
+#define SYS_io_pgetevents (0x40000000 + 333)
+#define SYS_rseq (0x40000000 + 334)
+#define SYS_pidfd_send_signal (0x40000000 + 424)
+#define SYS_io_uring_setup (0x40000000 + 425)
+#define SYS_io_uring_enter (0x40000000 + 426)
+#define SYS_io_uring_register (0x40000000 + 427)
+#define SYS_open_tree		(0x40000000 + 428)
+#define SYS_move_mount		(0x40000000 + 429)
+#define SYS_fsopen		(0x40000000 + 430)
+#define SYS_fsconfig		(0x40000000 + 431)
+#define SYS_fsmount		(0x40000000 + 432)
+#define SYS_fspick		(0x40000000 + 433)
+#define SYS_pidfd_open		(0x40000000 + 434)
+#define SYS_clone3		(0x40000000 + 435)
+#define SYS_close_range	(0x40000000 + 436)
+#define SYS_openat2		(0x40000000 + 437)
+#define SYS_pidfd_getfd	(0x40000000 + 438)
+#define SYS_faccessat2		(0x40000000 + 439)
+#define SYS_process_madvise	(0x40000000 + 440)
+#define SYS_epoll_pwait2	(0x40000000 + 441)
+#define SYS_mount_setattr	(0x40000000 + 442)
+#define SYS_landlock_create_ruleset	(0x40000000 + 444)
+#define SYS_landlock_add_rule	(0x40000000 + 445)
+#define SYS_landlock_restrict_self	(0x40000000 + 446)
+#define SYS_memfd_secret	(0x40000000 + 447)
+#define SYS_process_mrelease	(0x40000000 + 448)
+#define SYS_futex_waitv	(0x40000000 + 449)
+#define SYS_set_mempolicy_home_node	(0x40000000 + 450)
+#define SYS_cachestat		(0x40000000 + 451)
+#define SYS_fchmodat2		(0x40000000 + 452)
+#define SYS_rt_sigaction (0x40000000 + 512)
+#define SYS_rt_sigreturn (0x40000000 + 513)
+#define SYS_ioctl (0x40000000 + 514)
+#define SYS_readv (0x40000000 + 515)
+#define SYS_writev (0x40000000 + 516)
+#define SYS_recvfrom (0x40000000 + 517)
+#define SYS_sendmsg (0x40000000 + 518)
+#define SYS_recvmsg (0x40000000 + 519)
+#define SYS_execve (0x40000000 + 520)
+#define SYS_ptrace (0x40000000 + 521)
+#define SYS_rt_sigpending (0x40000000 + 522)
+#define SYS_rt_sigtimedwait (0x40000000 + 523)
+#define SYS_rt_sigqueueinfo (0x40000000 + 524)
+#define SYS_sigaltstack (0x40000000 + 525)
+#define SYS_timer_create (0x40000000 + 526)
+#define SYS_mq_notify (0x40000000 + 527)
+#define SYS_kexec_load (0x40000000 + 528)
+#define SYS_waitid (0x40000000 + 529)
+#define SYS_set_robust_list (0x40000000 + 530)
+#define SYS_get_robust_list (0x40000000 + 531)
+#define SYS_vmsplice (0x40000000 + 532)
+#define SYS_move_pages (0x40000000 + 533)
+#define SYS_preadv (0x40000000 + 534)
+#define SYS_pwritev (0x40000000 + 535)
+#define SYS_rt_tgsigqueueinfo (0x40000000 + 536)
+#define SYS_recvmmsg (0x40000000 + 537)
+#define SYS_sendmmsg (0x40000000 + 538)
+#define SYS_process_vm_readv (0x40000000 + 539)
+#define SYS_process_vm_writev (0x40000000 + 540)
+#define SYS_setsockopt (0x40000000 + 541)
+#define SYS_getsockopt (0x40000000 + 542)
+#define SYS_io_setup (0x40000000 + 543)
+#define SYS_io_submit (0x40000000 + 544)
+#define SYS_execveat (0x40000000 + 545)
+#define SYS_preadv2 (0x40000000 + 546)
+#define SYS_pwritev2 (0x40000000 + 547)
\ No newline at end of file
diff --git a/zig/lib/libc/include/x86_64-linux-muslx32/bits/user.h b/zig/lib/libc/include/x86_64-linux-muslx32/bits/user.h
new file mode 100644
index 0000000000..df72f2a5de
--- /dev/null
+++ b/zig/lib/libc/include/x86_64-linux-muslx32/bits/user.h
@@ -0,0 +1,41 @@
+#undef __WORDSIZE
+#define __WORDSIZE 32
+
+typedef struct user_fpregs_struct {
+	uint16_t cwd, swd, ftw, fop;
+	uint64_t rip, rdp;
+	uint32_t mxcsr, mxcr_mask;
+	uint32_t st_space[32], xmm_space[64], padding[24];
+} elf_fpregset_t;
+
+struct user_regs_struct {
+	unsigned long r15, r14, r13, r12, rbp, rbx, r11, r10, r9, r8;
+	unsigned long rax, rcx, rdx, rsi, rdi, orig_rax, rip;
+	unsigned long cs, eflags, rsp, ss, fs_base, gs_base, ds, es, fs, gs;
+};
+#define ELF_NGREG 27
+typedef unsigned long long elf_greg_t, elf_gregset_t[ELF_NGREG];
+
+struct user {
+	struct user_regs_struct		regs;
+	int				u_fpvalid;
+	struct user_fpregs_struct	i387;
+	unsigned long			u_tsize;
+	unsigned long			u_dsize;
+	unsigned long			u_ssize;
+	unsigned long			start_code;
+	unsigned long			start_stack;
+	long				signal;
+	int				reserved;
+	struct user_regs_struct		*u_ar0;
+	struct user_fpregs_struct	*u_fpstate;
+	unsigned long			magic;
+	char				u_comm[32];
+	unsigned long			u_debugreg[8];
+};
+
+#define PAGE_MASK		(~(PAGESIZE-1))
+#define NBPG			PAGESIZE
+#define UPAGES			1
+#define HOST_TEXT_START_ADDR	(u.start_code)
+#define HOST_STACK_END_ADDR	(u.start_stack + u.u_ssize * NBPG)
\ No newline at end of file
diff --git a/zig/lib/libc/musl/arch/aarch64/bits/alltypes.h.in b/zig/lib/libc/musl/arch/aarch64/bits/alltypes.h.in
deleted file mode 100644
index c547ca0b72..0000000000
--- a/zig/lib/libc/musl/arch/aarch64/bits/alltypes.h.in
+++ /dev/null
@@ -1,24 +0,0 @@
-#define _Addr long
-#define _Int64 long
-#define _Reg long
-
-#if __AARCH64EB__
-#define __BYTE_ORDER 4321
-#else
-#define __BYTE_ORDER 1234
-#endif
-
-#define __LONG_MAX 0x7fffffffffffffffL
-
-#ifndef __cplusplus
-TYPEDEF unsigned wchar_t;
-#endif
-TYPEDEF unsigned wint_t;
-
-TYPEDEF int blksize_t;
-TYPEDEF unsigned int nlink_t;
-
-TYPEDEF float float_t;
-TYPEDEF double double_t;
-
-TYPEDEF struct { long long __ll; long double __ld; } max_align_t;
diff --git a/zig/lib/libc/musl/arch/aarch64/bits/syscall.h.in b/zig/lib/libc/musl/arch/aarch64/bits/syscall.h.in
deleted file mode 100644
index ea5a152a20..0000000000
--- a/zig/lib/libc/musl/arch/aarch64/bits/syscall.h.in
+++ /dev/null
@@ -1,307 +0,0 @@
-#define __NR_io_setup 0
-#define __NR_io_destroy 1
-#define __NR_io_submit 2
-#define __NR_io_cancel 3
-#define __NR_io_getevents 4
-#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_fcntl 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_renameat 38
-#define __NR_umount2 39
-#define __NR_mount 40
-#define __NR_pivot_root 41
-#define __NR_nfsservctl 42
-#define __NR_statfs 43
-#define __NR_fstatfs 44
-#define __NR_truncate 45
-#define __NR_ftruncate 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_lseek 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_sendfile 71
-#define __NR_pselect6 72
-#define __NR_ppoll 73
-#define __NR_signalfd4 74
-#define __NR_vmsplice 75
-#define __NR_splice 76
-#define __NR_tee 77
-#define __NR_readlinkat 78
-#define __NR_newfstatat 79
-#define __NR_fstat 80
-#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_timerfd_settime 86
-#define __NR_timerfd_gettime 87
-#define __NR_utimensat 88
-#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_futex 98
-#define __NR_set_robust_list 99
-#define __NR_get_robust_list 100
-#define __NR_nanosleep 101
-#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_gettime 108
-#define __NR_timer_getoverrun 109
-#define __NR_timer_settime 110
-#define __NR_timer_delete 111
-#define __NR_clock_settime 112
-#define __NR_clock_gettime 113
-#define __NR_clock_getres 114
-#define __NR_clock_nanosleep 115
-#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_sched_rr_get_interval 127
-#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_sigtimedwait 137
-#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_getrlimit 163
-#define __NR_setrlimit 164
-#define __NR_getrusage 165
-#define __NR_umask 166
-#define __NR_prctl 167
-#define __NR_getcpu 168
-#define __NR_gettimeofday 169
-#define __NR_settimeofday 170
-#define __NR_adjtimex 171
-#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_timedsend 182
-#define __NR_mq_timedreceive 183
-#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_semtimedop 192
-#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_mmap 222
-#define __NR_fadvise64 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_recvmmsg 243
-#define __NR_wait4 260
-#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_clock_adjtime 266
-#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_io_pgetevents 292
-#define __NR_rseq 293
-#define __NR_kexec_file_load 294
-#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_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
-
diff --git a/zig/lib/libc/musl/arch/arm/bits/alltypes.h.in b/zig/lib/libc/musl/arch/arm/bits/alltypes.h.in
deleted file mode 100644
index d62bd7bde6..0000000000
--- a/zig/lib/libc/musl/arch/arm/bits/alltypes.h.in
+++ /dev/null
@@ -1,21 +0,0 @@
-#define _REDIR_TIME64 1
-#define _Addr int
-#define _Int64 long long
-#define _Reg int
-
-#if __ARMEB__
-#define __BYTE_ORDER 4321
-#else
-#define __BYTE_ORDER 1234
-#endif
-
-#define __LONG_MAX 0x7fffffffL
-
-#ifndef __cplusplus
-TYPEDEF unsigned wchar_t;
-#endif
-
-TYPEDEF float float_t;
-TYPEDEF double double_t;
-
-TYPEDEF struct { long long __ll; long double __ld; } max_align_t;
diff --git a/zig/lib/libc/musl/arch/arm/bits/syscall.h.in b/zig/lib/libc/musl/arch/arm/bits/syscall.h.in
deleted file mode 100644
index 157b304d54..0000000000
--- a/zig/lib/libc/musl/arch/arm/bits/syscall.h.in
+++ /dev/null
@@ -1,414 +0,0 @@
-#define __NR_restart_syscall	0
-#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_creat	8
-#define __NR_link	9
-#define __NR_unlink	10
-#define __NR_execve	11
-#define __NR_chdir	12
-#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_setuid	23
-#define __NR_getuid	24
-#define __NR_ptrace	26
-#define __NR_pause	29
-#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_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_getrusage	77
-#define __NR_gettimeofday_time32	78
-#define __NR_settimeofday_time32	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_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_syslog	103
-#define __NR_setitimer	104
-#define __NR_getitimer	105
-#define __NR_stat	106
-#define __NR_lstat	107
-#define __NR_fstat	108
-#define __NR_vhangup	111
-#define __NR_wait4	114
-#define __NR_swapoff	115
-#define __NR_sysinfo	116
-#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_init_module	128
-#define __NR_delete_module	129
-#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_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_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_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_getdents64	217
-#define __NR_pivot_root	218
-#define __NR_mincore	219
-#define __NR_madvise	220
-#define __NR_fcntl64	221
-#define __NR_gettid	224
-#define __NR_readahead	225
-#define __NR_setxattr	226
-#define __NR_lsetxattr	227
-#define __NR_fsetxattr	228
-#define __NR_getxattr	229
-#define __NR_lgetxattr	230
-#define __NR_fgetxattr	231
-#define __NR_listxattr	232
-#define __NR_llistxattr	233
-#define __NR_flistxattr	234
-#define __NR_removexattr	235
-#define __NR_lremovexattr	236
-#define __NR_fremovexattr	237
-#define __NR_tkill	238
-#define __NR_sendfile64	239
-#define __NR_futex	240
-#define __NR_sched_setaffinity	241
-#define __NR_sched_getaffinity	242
-#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_lookup_dcookie	249
-#define __NR_epoll_create	250
-#define __NR_epoll_ctl	251
-#define __NR_epoll_wait	252
-#define __NR_remap_file_pages	253
-#define __NR_set_tid_address	256
-#define __NR_timer_create	257
-#define __NR_timer_settime32	258
-#define __NR_timer_gettime32	259
-#define __NR_timer_getoverrun	260
-#define __NR_timer_delete	261
-#define __NR_clock_settime32	262
-#define __NR_clock_gettime32	263
-#define __NR_clock_getres_time32	264
-#define __NR_clock_nanosleep_time32	265
-#define __NR_statfs64	266
-#define __NR_fstatfs64	267
-#define __NR_tgkill	268
-#define __NR_utimes	269
-#define __NR_fadvise64_64	270
-#define __NR_arm_fadvise64_64	270
-#define __NR_pciconfig_iobase	271
-#define __NR_pciconfig_read	272
-#define __NR_pciconfig_write	273
-#define __NR_mq_open	274
-#define __NR_mq_unlink	275
-#define __NR_mq_timedsend	276
-#define __NR_mq_timedreceive	277
-#define __NR_mq_notify	278
-#define __NR_mq_getsetattr	279
-#define __NR_waitid	280
-#define __NR_socket	281
-#define __NR_bind	282
-#define __NR_connect	283
-#define __NR_listen	284
-#define __NR_accept	285
-#define __NR_getsockname	286
-#define __NR_getpeername	287
-#define __NR_socketpair	288
-#define __NR_send	289
-#define __NR_sendto	290
-#define __NR_recv	291
-#define __NR_recvfrom	292
-#define __NR_shutdown	293
-#define __NR_setsockopt	294
-#define __NR_getsockopt	295
-#define __NR_sendmsg	296
-#define __NR_recvmsg	297
-#define __NR_semop	298
-#define __NR_semget	299
-#define __NR_semctl	300
-#define __NR_msgsnd	301
-#define __NR_msgrcv	302
-#define __NR_msgget	303
-#define __NR_msgctl	304
-#define __NR_shmat	305
-#define __NR_shmdt	306
-#define __NR_shmget	307
-#define __NR_shmctl	308
-#define __NR_add_key	309
-#define __NR_request_key	310
-#define __NR_keyctl	311
-#define __NR_semtimedop	312
-#define __NR_vserver	313
-#define __NR_ioprio_set	314
-#define __NR_ioprio_get	315
-#define __NR_inotify_init	316
-#define __NR_inotify_add_watch	317
-#define __NR_inotify_rm_watch	318
-#define __NR_mbind	319
-#define __NR_get_mempolicy	320
-#define __NR_set_mempolicy	321
-#define __NR_openat	322
-#define __NR_mkdirat	323
-#define __NR_mknodat	324
-#define __NR_fchownat	325
-#define __NR_futimesat	326
-#define __NR_fstatat64	327
-#define __NR_unlinkat	328
-#define __NR_renameat	329
-#define __NR_linkat	330
-#define __NR_symlinkat	331
-#define __NR_readlinkat	332
-#define __NR_fchmodat	333
-#define __NR_faccessat	334
-#define __NR_pselect6	335
-#define __NR_ppoll	336
-#define __NR_unshare	337
-#define __NR_set_robust_list	338
-#define __NR_get_robust_list	339
-#define __NR_splice	340
-#define __NR_sync_file_range2	341
-#define __NR_arm_sync_file_range	341
-#define __NR_tee	342
-#define __NR_vmsplice	343
-#define __NR_move_pages	344
-#define __NR_getcpu	345
-#define __NR_epoll_pwait	346
-#define __NR_kexec_load	347
-#define __NR_utimensat	348
-#define __NR_signalfd	349
-#define __NR_timerfd_create	350
-#define __NR_eventfd	351
-#define __NR_fallocate	352
-#define __NR_timerfd_settime32	353
-#define __NR_timerfd_gettime32	354
-#define __NR_signalfd4	355
-#define __NR_eventfd2	356
-#define __NR_epoll_create1	357
-#define __NR_dup3	358
-#define __NR_pipe2	359
-#define __NR_inotify_init1	360
-#define __NR_preadv	361
-#define __NR_pwritev	362
-#define __NR_rt_tgsigqueueinfo	363
-#define __NR_perf_event_open	364
-#define __NR_recvmmsg	365
-#define __NR_accept4	366
-#define __NR_fanotify_init	367
-#define __NR_fanotify_mark	368
-#define __NR_prlimit64	369
-#define __NR_name_to_handle_at	370
-#define __NR_open_by_handle_at	371
-#define __NR_clock_adjtime	372
-#define __NR_syncfs	373
-#define __NR_sendmmsg	374
-#define __NR_setns	375
-#define __NR_process_vm_readv	376
-#define __NR_process_vm_writev	377
-#define __NR_kcmp		378
-#define __NR_finit_module	379
-#define __NR_sched_setattr	380
-#define __NR_sched_getattr	381
-#define __NR_renameat2	382
-#define __NR_seccomp	383
-#define __NR_getrandom	384
-#define __NR_memfd_create	385
-#define __NR_bpf	386
-#define __NR_execveat	387
-#define __NR_userfaultfd	388
-#define __NR_membarrier		389
-#define __NR_mlock2		390
-#define __NR_copy_file_range	391
-#define __NR_preadv2	392
-#define __NR_pwritev2	393
-#define __NR_pkey_mprotect	394
-#define __NR_pkey_alloc	395
-#define __NR_pkey_free	396
-#define __NR_statx	397
-#define __NR_rseq	398
-#define __NR_io_pgetevents	399
-#define __NR_migrate_pages	400
-#define __NR_kexec_file_load	401
-#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_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 __ARM_NR_breakpoint	0x0f0001
-#define __ARM_NR_cacheflush	0x0f0002
-#define __ARM_NR_usr26		0x0f0003
-#define __ARM_NR_usr32		0x0f0004
-#define __ARM_NR_set_tls	0x0f0005
-#define __ARM_NR_get_tls	0x0f0006
-
diff --git a/zig/lib/libc/musl/arch/i386/bits/alltypes.h.in b/zig/lib/libc/musl/arch/i386/bits/alltypes.h.in
deleted file mode 100644
index 6feb03a6c3..0000000000
--- a/zig/lib/libc/musl/arch/i386/bits/alltypes.h.in
+++ /dev/null
@@ -1,31 +0,0 @@
-#define _REDIR_TIME64 1
-#define _Addr int
-#define _Int64 long long
-#define _Reg int
-
-#define __BYTE_ORDER 1234
-#define __LONG_MAX 0x7fffffffL
-
-#ifndef __cplusplus
-#ifdef __WCHAR_TYPE__
-TYPEDEF __WCHAR_TYPE__ wchar_t;
-#else
-TYPEDEF long wchar_t;
-#endif
-#endif
-
-#if defined(__FLT_EVAL_METHOD__) && __FLT_EVAL_METHOD__ == 0
-TYPEDEF float float_t;
-TYPEDEF double double_t;
-#else
-TYPEDEF long double float_t;
-TYPEDEF long double double_t;
-#endif
-
-#if !defined(__cplusplus)
-TYPEDEF struct { _Alignas(8) long long __ll; long double __ld; } max_align_t;
-#elif defined(__GNUC__)
-TYPEDEF struct { __attribute__((__aligned__(8))) long long __ll; long double __ld; } max_align_t;
-#else
-TYPEDEF struct { alignas(8) long long __ll; long double __ld; } max_align_t;
-#endif
diff --git a/zig/lib/libc/musl/arch/i386/bits/syscall.h.in b/zig/lib/libc/musl/arch/i386/bits/syscall.h.in
deleted file mode 100644
index 55e91cc43b..0000000000
--- a/zig/lib/libc/musl/arch/i386/bits/syscall.h.in
+++ /dev/null
@@ -1,445 +0,0 @@
-#define __NR_restart_syscall      0
-#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_waitpid		  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_break		 17
-#define __NR_oldstat		 18
-#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_oldfstat		 28
-#define __NR_pause		 29
-#define __NR_utime		 30
-#define __NR_stty		 31
-#define __NR_gtty		 32
-#define __NR_access		 33
-#define __NR_nice		 34
-#define __NR_ftime		 35
-#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_prof		 44
-#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_lock		 53
-#define __NR_ioctl		 54
-#define __NR_fcntl		 55
-#define __NR_mpx		 56
-#define __NR_setpgid		 57
-#define __NR_ulimit		 58
-#define __NR_oldolduname	 59
-#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_sgetmask		 68
-#define __NR_ssetmask		 69
-#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   /* Back compatible 2Gig limited rlimit */
-#define __NR_getrusage		 77
-#define __NR_gettimeofday_time32	 78
-#define __NR_settimeofday_time32	 79
-#define __NR_getgroups		 80
-#define __NR_setgroups		 81
-#define __NR_select		 82
-#define __NR_symlink		 83
-#define __NR_oldlstat		 84
-#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_profil		 98
-#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_olduname		109
-#define __NR_iopl		110
-#define __NR_vhangup		111
-#define __NR_idle		112
-#define __NR_vm86old		113
-#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_modify_ldt		123
-#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_vm86		166
-#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
-/* 223 is unused */
-#define __NR_gettid		224
-#define __NR_readahead		225
-#define __NR_setxattr		226
-#define __NR_lsetxattr		227
-#define __NR_fsetxattr		228
-#define __NR_getxattr		229
-#define __NR_lgetxattr		230
-#define __NR_fgetxattr		231
-#define __NR_listxattr		232
-#define __NR_llistxattr		233
-#define __NR_flistxattr		234
-#define __NR_removexattr	235
-#define __NR_lremovexattr	236
-#define __NR_fremovexattr	237
-#define __NR_tkill		238
-#define __NR_sendfile64		239
-#define __NR_futex		240
-#define __NR_sched_setaffinity	241
-#define __NR_sched_getaffinity	242
-#define __NR_set_thread_area	243
-#define __NR_get_thread_area	244
-#define __NR_io_setup		245
-#define __NR_io_destroy		246
-#define __NR_io_getevents	247
-#define __NR_io_submit		248
-#define __NR_io_cancel		249
-#define __NR_fadvise64		250
-/* 251 is available for reuse (was briefly sys_set_zone_reclaim) */
-#define __NR_exit_group		252
-#define __NR_lookup_dcookie	253
-#define __NR_epoll_create	254
-#define __NR_epoll_ctl		255
-#define __NR_epoll_wait		256
-#define __NR_remap_file_pages	257
-#define __NR_set_tid_address	258
-#define __NR_timer_create	259
-#define __NR_timer_settime32	(__NR_timer_create+1)
-#define __NR_timer_gettime32	(__NR_timer_create+2)
-#define __NR_timer_getoverrun	(__NR_timer_create+3)
-#define __NR_timer_delete	(__NR_timer_create+4)
-#define __NR_clock_settime32	(__NR_timer_create+5)
-#define __NR_clock_gettime32	(__NR_timer_create+6)
-#define __NR_clock_getres_time32	(__NR_timer_create+7)
-#define __NR_clock_nanosleep_time32	(__NR_timer_create+8)
-#define __NR_statfs64		268
-#define __NR_fstatfs64		269
-#define __NR_tgkill		270
-#define __NR_utimes		271
-#define __NR_fadvise64_64	272
-#define __NR_vserver		273
-#define __NR_mbind		274
-#define __NR_get_mempolicy	275
-#define __NR_set_mempolicy	276
-#define __NR_mq_open 		277
-#define __NR_mq_unlink		(__NR_mq_open+1)
-#define __NR_mq_timedsend	(__NR_mq_open+2)
-#define __NR_mq_timedreceive	(__NR_mq_open+3)
-#define __NR_mq_notify		(__NR_mq_open+4)
-#define __NR_mq_getsetattr	(__NR_mq_open+5)
-#define __NR_kexec_load		283
-#define __NR_waitid		284
-/* #define __NR_sys_setaltroot	285 */
-#define __NR_add_key		286
-#define __NR_request_key	287
-#define __NR_keyctl		288
-#define __NR_ioprio_set		289
-#define __NR_ioprio_get		290
-#define __NR_inotify_init	291
-#define __NR_inotify_add_watch	292
-#define __NR_inotify_rm_watch	293
-#define __NR_migrate_pages	294
-#define __NR_openat		295
-#define __NR_mkdirat		296
-#define __NR_mknodat		297
-#define __NR_fchownat		298
-#define __NR_futimesat		299
-#define __NR_fstatat64		300
-#define __NR_unlinkat		301
-#define __NR_renameat		302
-#define __NR_linkat		303
-#define __NR_symlinkat		304
-#define __NR_readlinkat		305
-#define __NR_fchmodat		306
-#define __NR_faccessat		307
-#define __NR_pselect6		308
-#define __NR_ppoll		309
-#define __NR_unshare		310
-#define __NR_set_robust_list	311
-#define __NR_get_robust_list	312
-#define __NR_splice		313
-#define __NR_sync_file_range	314
-#define __NR_tee		315
-#define __NR_vmsplice		316
-#define __NR_move_pages		317
-#define __NR_getcpu		318
-#define __NR_epoll_pwait	319
-#define __NR_utimensat		320
-#define __NR_signalfd		321
-#define __NR_timerfd_create	322
-#define __NR_eventfd		323
-#define __NR_fallocate		324
-#define __NR_timerfd_settime32	325
-#define __NR_timerfd_gettime32	326
-#define __NR_signalfd4		327
-#define __NR_eventfd2		328
-#define __NR_epoll_create1	329
-#define __NR_dup3		330
-#define __NR_pipe2		331
-#define __NR_inotify_init1	332
-#define __NR_preadv		333
-#define __NR_pwritev		334
-#define __NR_rt_tgsigqueueinfo	335
-#define __NR_perf_event_open	336
-#define __NR_recvmmsg		337
-#define __NR_fanotify_init	338
-#define __NR_fanotify_mark	339
-#define __NR_prlimit64		340
-#define __NR_name_to_handle_at	341
-#define __NR_open_by_handle_at	342
-#define __NR_clock_adjtime	343
-#define __NR_syncfs		344
-#define __NR_sendmmsg		345
-#define __NR_setns		346
-#define __NR_process_vm_readv	347
-#define __NR_process_vm_writev	348
-#define __NR_kcmp		349
-#define __NR_finit_module	350
-#define __NR_sched_setattr	351
-#define __NR_sched_getattr	352
-#define __NR_renameat2		353
-#define __NR_seccomp		354
-#define __NR_getrandom		355
-#define __NR_memfd_create	356
-#define __NR_bpf		357
-#define __NR_execveat		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_userfaultfd	374
-#define __NR_membarrier		375
-#define __NR_mlock2		376
-#define __NR_copy_file_range	377
-#define __NR_preadv2		378
-#define __NR_pwritev2		379
-#define __NR_pkey_mprotect	380
-#define __NR_pkey_alloc		381
-#define __NR_pkey_free		382
-#define __NR_statx		383
-#define __NR_arch_prctl		384
-#define __NR_io_pgetevents	385
-#define __NR_rseq		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_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
-
diff --git a/zig/lib/libc/musl/arch/loongarch64/bits/alltypes.h.in b/zig/lib/libc/musl/arch/loongarch64/bits/alltypes.h.in
deleted file mode 100644
index d1807aca6c..0000000000
--- a/zig/lib/libc/musl/arch/loongarch64/bits/alltypes.h.in
+++ /dev/null
@@ -1,18 +0,0 @@
-#define _Addr long
-#define _Int64 long
-#define _Reg long
-
-#define __BYTE_ORDER 1234
-#define __LONG_MAX 0x7fffffffffffffffL
-
-#ifndef __cplusplus
-TYPEDEF int wchar_t;
-#endif
-
-TYPEDEF float float_t;
-TYPEDEF double double_t;
-
-TYPEDEF struct { long long __ll; long double __ld; } max_align_t;
-
-TYPEDEF unsigned nlink_t;
-TYPEDEF int blksize_t;
diff --git a/zig/lib/libc/musl/arch/loongarch64/bits/syscall.h.in b/zig/lib/libc/musl/arch/loongarch64/bits/syscall.h.in
deleted file mode 100644
index 2afb4ea16d..0000000000
--- a/zig/lib/libc/musl/arch/loongarch64/bits/syscall.h.in
+++ /dev/null
@@ -1,316 +0,0 @@
-#define __NR_io_setup                   0
-#define __NR_io_destroy                 1
-#define __NR_io_submit                  2
-#define __NR_io_cancel                  3
-#define __NR_io_getevents               4
-#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 __NR3264_fcntl                  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 __NR3264_statfs                 43
-#define __NR3264_fstatfs                44
-#define __NR3264_truncate               45
-#define __NR3264_ftruncate              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 __NR3264_lseek                  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 __NR3264_sendfile               71
-#define __NR_pselect6                   72
-#define __NR_ppoll                      73
-#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_timerfd_settime            86
-#define __NR_timerfd_gettime            87
-#define __NR_utimensat                  88
-#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_futex                      98
-#define __NR_set_robust_list            99
-#define __NR_get_robust_list            100
-#define __NR_nanosleep                  101
-#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_gettime              108
-#define __NR_timer_getoverrun           109
-#define __NR_timer_settime              110
-#define __NR_timer_delete               111
-#define __NR_clock_settime              112
-#define __NR_clock_gettime              113
-#define __NR_clock_getres               114
-#define __NR_clock_nanosleep            115
-#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_sched_rr_get_interval      127
-#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_sigtimedwait            137
-#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_gettimeofday               169
-#define __NR_settimeofday               170
-#define __NR_adjtimex                   171
-#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_timedsend               182
-#define __NR_mq_timedreceive            183
-#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_semtimedop                 192
-#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 __NR3264_mmap                   222
-#define __NR3264_fadvise64              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_recvmmsg                   243
-#define __NR_arch_specific_syscall      244
-#define __NR_wait4                      260
-#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_clock_adjtime              266
-#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_io_pgetevents              292
-#define __NR_rseq                       293
-#define __NR_kexec_file_load            294
-#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_fcntl                      __NR3264_fcntl
-#define __NR_statfs                     __NR3264_statfs
-#define __NR_fstatfs                    __NR3264_fstatfs
-#define __NR_truncate                   __NR3264_truncate
-#define __NR_ftruncate                  __NR3264_ftruncate
-#define __NR_lseek                      __NR3264_lseek
-#define __NR_sendfile                   __NR3264_sendfile
-#define __NR_mmap                       __NR3264_mmap
-#define __NR_fadvise64                  __NR3264_fadvise64
diff --git a/zig/lib/libc/musl/arch/m68k/bits/alltypes.h.in b/zig/lib/libc/musl/arch/m68k/bits/alltypes.h.in
deleted file mode 100644
index f564690983..0000000000
--- a/zig/lib/libc/musl/arch/m68k/bits/alltypes.h.in
+++ /dev/null
@@ -1,25 +0,0 @@
-#define _REDIR_TIME64 1
-#define _Addr int
-#define _Int64 long long
-#define _Reg int
-
-#define __BYTE_ORDER 4321
-#define __LONG_MAX 0x7fffffffL
-
-#ifndef __cplusplus
-#ifdef __WCHAR_TYPE__
-TYPEDEF __WCHAR_TYPE__ wchar_t;
-#else
-TYPEDEF long wchar_t;
-#endif
-#endif
-
-#if __mcffpu__
-TYPEDEF float float_t;
-TYPEDEF double double_t;
-#else
-TYPEDEF long double float_t;
-TYPEDEF long double double_t;
-#endif
-
-TYPEDEF struct { long long __ll; long double __ld; } max_align_t;
diff --git a/zig/lib/libc/musl/arch/m68k/bits/syscall.h.in b/zig/lib/libc/musl/arch/m68k/bits/syscall.h.in
deleted file mode 100644
index 5cd84602ad..0000000000
--- a/zig/lib/libc/musl/arch/m68k/bits/syscall.h.in
+++ /dev/null
@@ -1,423 +0,0 @@
-#define __NR_restart_syscall	  0
-#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_waitpid		  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_chown		 16
-#define __NR_oldstat		 18
-#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_oldfstat		 28
-#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_sgetmask		 68
-#define __NR_ssetmask		 69
-#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_time32	 78
-#define __NR_settimeofday_time32	 79
-#define __NR_getgroups		 80
-#define __NR_setgroups		 81
-#define __NR_select		 82
-#define __NR_symlink		 83
-#define __NR_oldlstat		 84
-#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_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_vhangup		111
-#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_cacheflush		123
-#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_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_getpagesize	166
-#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_lchown		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_chown32		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_lchown32		212
-#define __NR_setuid32		213
-#define __NR_setgid32		214
-#define __NR_setfsuid32		215
-#define __NR_setfsgid32		216
-#define __NR_pivot_root		217
-#define __NR_getdents64		220
-#define __NR_gettid		221
-#define __NR_tkill		222
-#define __NR_setxattr		223
-#define __NR_lsetxattr		224
-#define __NR_fsetxattr		225
-#define __NR_getxattr		226
-#define __NR_lgetxattr		227
-#define __NR_fgetxattr		228
-#define __NR_listxattr		229
-#define __NR_llistxattr		230
-#define __NR_flistxattr		231
-#define __NR_removexattr	232
-#define __NR_lremovexattr	233
-#define __NR_fremovexattr	234
-#define __NR_futex		235
-#define __NR_sendfile64		236
-#define __NR_mincore		237
-#define __NR_madvise		238
-#define __NR_fcntl64		239
-#define __NR_readahead		240
-#define __NR_io_setup		241
-#define __NR_io_destroy		242
-#define __NR_io_getevents	243
-#define __NR_io_submit		244
-#define __NR_io_cancel		245
-#define __NR_fadvise64		246
-#define __NR_exit_group		247
-#define __NR_lookup_dcookie	248
-#define __NR_epoll_create	249
-#define __NR_epoll_ctl		250
-#define __NR_epoll_wait		251
-#define __NR_remap_file_pages	252
-#define __NR_set_tid_address	253
-#define __NR_timer_create	254
-#define __NR_timer_settime32	255
-#define __NR_timer_gettime32	256
-#define __NR_timer_getoverrun	257
-#define __NR_timer_delete	258
-#define __NR_clock_settime32	259
-#define __NR_clock_gettime32	260
-#define __NR_clock_getres_time32	261
-#define __NR_clock_nanosleep_time32	262
-#define __NR_statfs64		263
-#define __NR_fstatfs64		264
-#define __NR_tgkill		265
-#define __NR_utimes		266
-#define __NR_fadvise64_64	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_waitid		277
-#define __NR_add_key		279
-#define __NR_request_key	280
-#define __NR_keyctl		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_sched_setaffinity	311
-#define __NR_sched_getaffinity	312
-#define __NR_kexec_load		313
-#define __NR_getcpu		314
-#define __NR_epoll_pwait	315
-#define __NR_utimensat		316
-#define __NR_signalfd		317
-#define __NR_timerfd_create	318
-#define __NR_eventfd		319
-#define __NR_fallocate		320
-#define __NR_timerfd_settime32	321
-#define __NR_timerfd_gettime32	322
-#define __NR_signalfd4		323
-#define __NR_eventfd2		324
-#define __NR_epoll_create1	325
-#define __NR_dup3		326
-#define __NR_pipe2		327
-#define __NR_inotify_init1	328
-#define __NR_preadv		329
-#define __NR_pwritev		330
-#define __NR_rt_tgsigqueueinfo	331
-#define __NR_perf_event_open	332
-#define __NR_get_thread_area	333
-#define __NR_set_thread_area	334
-#define __NR_atomic_cmpxchg_32	335
-#define __NR_atomic_barrier	336
-#define __NR_fanotify_init	337
-#define __NR_fanotify_mark	338
-#define __NR_prlimit64		339
-#define __NR_name_to_handle_at	340
-#define __NR_open_by_handle_at	341
-#define __NR_clock_adjtime	342
-#define __NR_syncfs		343
-#define __NR_setns		344
-#define __NR_process_vm_readv	345
-#define __NR_process_vm_writev	346
-#define __NR_kcmp		347
-#define __NR_finit_module	348
-#define __NR_sched_setattr	349
-#define __NR_sched_getattr	350
-#define __NR_renameat2		351
-#define __NR_getrandom		352
-#define __NR_memfd_create	353
-#define __NR_bpf		354
-#define __NR_execveat		355
-#define __NR_socket		356
-#define __NR_socketpair		357
-#define __NR_bind		358
-#define __NR_connect		359
-#define __NR_listen		360
-#define __NR_accept4		361
-#define __NR_getsockopt		362
-#define __NR_setsockopt		363
-#define __NR_getsockname	364
-#define __NR_getpeername	365
-#define __NR_sendto		366
-#define __NR_sendmsg		367
-#define __NR_recvfrom		368
-#define __NR_recvmsg		369
-#define __NR_shutdown		370
-#define __NR_recvmmsg		371
-#define __NR_sendmmsg		372
-#define __NR_userfaultfd	373
-#define __NR_membarrier		374
-#define __NR_mlock2		375
-#define __NR_copy_file_range	376
-#define __NR_preadv2		377
-#define __NR_pwritev2		378
-#define __NR_statx		379
-#define __NR_seccomp		380
-#define __NR_pkey_mprotect	381
-#define __NR_pkey_alloc		382
-#define __NR_pkey_free		383
-#define __NR_rseq		384
-#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_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
diff --git a/zig/lib/libc/musl/arch/mips/bits/alltypes.h.in b/zig/lib/libc/musl/arch/mips/bits/alltypes.h.in
deleted file mode 100644
index ff934a4c42..0000000000
--- a/zig/lib/libc/musl/arch/mips/bits/alltypes.h.in
+++ /dev/null
@@ -1,21 +0,0 @@
-#define _REDIR_TIME64 1
-#define _Addr int
-#define _Int64 long long
-#define _Reg int
-
-#if _MIPSEL || __MIPSEL || __MIPSEL__
-#define __BYTE_ORDER 1234
-#else
-#define __BYTE_ORDER 4321
-#endif
-
-#define __LONG_MAX 0x7fffffffL
-
-#ifndef __cplusplus
-TYPEDEF int wchar_t;
-#endif
-
-TYPEDEF float float_t;
-TYPEDEF double double_t;
-
-TYPEDEF struct { long long __ll; long double __ld; } max_align_t;
diff --git a/zig/lib/libc/musl/arch/mips/bits/syscall.h.in b/zig/lib/libc/musl/arch/mips/bits/syscall.h.in
deleted file mode 100644
index 55e35742aa..0000000000
--- a/zig/lib/libc/musl/arch/mips/bits/syscall.h.in
+++ /dev/null
@@ -1,426 +0,0 @@
-#define __NR_syscall                 4000
-#define __NR_exit                    4001
-#define __NR_fork                    4002
-#define __NR_read                    4003
-#define __NR_write                   4004
-#define __NR_open                    4005
-#define __NR_close                   4006
-#define __NR_waitpid                 4007
-#define __NR_creat                   4008
-#define __NR_link                    4009
-#define __NR_unlink                  4010
-#define __NR_execve                  4011
-#define __NR_chdir                   4012
-#define __NR_time                    4013
-#define __NR_mknod                   4014
-#define __NR_chmod                   4015
-#define __NR_lchown                  4016
-#define __NR_break                   4017
-#define __NR_unused18                4018
-#define __NR_lseek                   4019
-#define __NR_getpid                  4020
-#define __NR_mount                   4021
-#define __NR_umount                  4022
-#define __NR_setuid                  4023
-#define __NR_getuid                  4024
-#define __NR_stime                   4025
-#define __NR_ptrace                  4026
-#define __NR_alarm                   4027
-#define __NR_unused28                4028
-#define __NR_pause                   4029
-#define __NR_utime                   4030
-#define __NR_stty                    4031
-#define __NR_gtty                    4032
-#define __NR_access                  4033
-#define __NR_nice                    4034
-#define __NR_ftime                   4035
-#define __NR_sync                    4036
-#define __NR_kill                    4037
-#define __NR_rename                  4038
-#define __NR_mkdir                   4039
-#define __NR_rmdir                   4040
-#define __NR_dup                     4041
-#define __NR_pipe                    4042
-#define __NR_times                   4043
-#define __NR_prof                    4044
-#define __NR_brk                     4045
-#define __NR_setgid                  4046
-#define __NR_getgid                  4047
-#define __NR_signal                  4048
-#define __NR_geteuid                 4049
-#define __NR_getegid                 4050
-#define __NR_acct                    4051
-#define __NR_umount2                 4052
-#define __NR_lock                    4053
-#define __NR_ioctl                   4054
-#define __NR_fcntl                   4055
-#define __NR_mpx                     4056
-#define __NR_setpgid                 4057
-#define __NR_ulimit                  4058
-#define __NR_unused59                4059
-#define __NR_umask                   4060
-#define __NR_chroot                  4061
-#define __NR_ustat                   4062
-#define __NR_dup2                    4063
-#define __NR_getppid                 4064
-#define __NR_getpgrp                 4065
-#define __NR_setsid                  4066
-#define __NR_sigaction               4067
-#define __NR_sgetmask                4068
-#define __NR_ssetmask                4069
-#define __NR_setreuid                4070
-#define __NR_setregid                4071
-#define __NR_sigsuspend              4072
-#define __NR_sigpending              4073
-#define __NR_sethostname             4074
-#define __NR_setrlimit               4075
-#define __NR_getrlimit               4076
-#define __NR_getrusage               4077
-#define __NR_gettimeofday_time32            4078
-#define __NR_settimeofday_time32            4079
-#define __NR_getgroups               4080
-#define __NR_setgroups               4081
-#define __NR_reserved82              4082
-#define __NR_symlink                 4083
-#define __NR_unused84                4084
-#define __NR_readlink                4085
-#define __NR_uselib                  4086
-#define __NR_swapon                  4087
-#define __NR_reboot                  4088
-#define __NR_readdir                 4089
-#define __NR_mmap                    4090
-#define __NR_munmap                  4091
-#define __NR_truncate                4092
-#define __NR_ftruncate               4093
-#define __NR_fchmod                  4094
-#define __NR_fchown                  4095
-#define __NR_getpriority             4096
-#define __NR_setpriority             4097
-#define __NR_profil                  4098
-#define __NR_statfs                  4099
-#define __NR_fstatfs                 4100
-#define __NR_ioperm                  4101
-#define __NR_socketcall              4102
-#define __NR_syslog                  4103
-#define __NR_setitimer               4104
-#define __NR_getitimer               4105
-#define __NR_stat                    4106
-#define __NR_lstat                   4107
-#define __NR_fstat                   4108
-#define __NR_unused109               4109
-#define __NR_iopl                    4110
-#define __NR_vhangup                 4111
-#define __NR_idle                    4112
-#define __NR_vm86                    4113
-#define __NR_wait4                   4114
-#define __NR_swapoff                 4115
-#define __NR_sysinfo                 4116
-#define __NR_ipc                     4117
-#define __NR_fsync                   4118
-#define __NR_sigreturn               4119
-#define __NR_clone                   4120
-#define __NR_setdomainname           4121
-#define __NR_uname                   4122
-#define __NR_modify_ldt              4123
-#define __NR_adjtimex                4124
-#define __NR_mprotect                4125
-#define __NR_sigprocmask             4126
-#define __NR_create_module           4127
-#define __NR_init_module             4128
-#define __NR_delete_module           4129
-#define __NR_get_kernel_syms         4130
-#define __NR_quotactl                4131
-#define __NR_getpgid                 4132
-#define __NR_fchdir                  4133
-#define __NR_bdflush                 4134
-#define __NR_sysfs                   4135
-#define __NR_personality             4136
-#define __NR_afs_syscall             4137
-#define __NR_setfsuid                4138
-#define __NR_setfsgid                4139
-#define __NR__llseek                 4140
-#define __NR_getdents                4141
-#define __NR__newselect              4142
-#define __NR_flock                   4143
-#define __NR_msync                   4144
-#define __NR_readv                   4145
-#define __NR_writev                  4146
-#define __NR_cacheflush              4147
-#define __NR_cachectl                4148
-#define __NR_sysmips                 4149
-#define __NR_unused150               4150
-#define __NR_getsid                  4151
-#define __NR_fdatasync               4152
-#define __NR__sysctl                 4153
-#define __NR_mlock                   4154
-#define __NR_munlock                 4155
-#define __NR_mlockall                4156
-#define __NR_munlockall              4157
-#define __NR_sched_setparam          4158
-#define __NR_sched_getparam          4159
-#define __NR_sched_setscheduler      4160
-#define __NR_sched_getscheduler      4161
-#define __NR_sched_yield             4162
-#define __NR_sched_get_priority_max  4163
-#define __NR_sched_get_priority_min  4164
-#define __NR_sched_rr_get_interval   4165
-#define __NR_nanosleep               4166
-#define __NR_mremap                  4167
-#define __NR_accept                  4168
-#define __NR_bind                    4169
-#define __NR_connect                 4170
-#define __NR_getpeername             4171
-#define __NR_getsockname             4172
-#define __NR_getsockopt              4173
-#define __NR_listen                  4174
-#define __NR_recv                    4175
-#define __NR_recvfrom                4176
-#define __NR_recvmsg                 4177
-#define __NR_send                    4178
-#define __NR_sendmsg                 4179
-#define __NR_sendto                  4180
-#define __NR_setsockopt              4181
-#define __NR_shutdown                4182
-#define __NR_socket                  4183
-#define __NR_socketpair              4184
-#define __NR_setresuid               4185
-#define __NR_getresuid               4186
-#define __NR_query_module            4187
-#define __NR_poll                    4188
-#define __NR_nfsservctl              4189
-#define __NR_setresgid               4190
-#define __NR_getresgid               4191
-#define __NR_prctl                   4192
-#define __NR_rt_sigreturn            4193
-#define __NR_rt_sigaction            4194
-#define __NR_rt_sigprocmask          4195
-#define __NR_rt_sigpending           4196
-#define __NR_rt_sigtimedwait         4197
-#define __NR_rt_sigqueueinfo         4198
-#define __NR_rt_sigsuspend           4199
-#define __NR_pread64                 4200
-#define __NR_pwrite64                4201
-#define __NR_chown                   4202
-#define __NR_getcwd                  4203
-#define __NR_capget                  4204
-#define __NR_capset                  4205
-#define __NR_sigaltstack             4206
-#define __NR_sendfile                4207
-#define __NR_getpmsg                 4208
-#define __NR_putpmsg                 4209
-#define __NR_mmap2                   4210
-#define __NR_truncate64              4211
-#define __NR_ftruncate64             4212
-#define __NR_stat64                  4213
-#define __NR_lstat64                 4214
-#define __NR_fstat64                 4215
-#define __NR_pivot_root              4216
-#define __NR_mincore                 4217
-#define __NR_madvise                 4218
-#define __NR_getdents64              4219
-#define __NR_fcntl64                 4220
-#define __NR_reserved221             4221
-#define __NR_gettid                  4222
-#define __NR_readahead               4223
-#define __NR_setxattr                4224
-#define __NR_lsetxattr               4225
-#define __NR_fsetxattr               4226
-#define __NR_getxattr                4227
-#define __NR_lgetxattr               4228
-#define __NR_fgetxattr               4229
-#define __NR_listxattr               4230
-#define __NR_llistxattr              4231
-#define __NR_flistxattr              4232
-#define __NR_removexattr             4233
-#define __NR_lremovexattr            4234
-#define __NR_fremovexattr            4235
-#define __NR_tkill                   4236
-#define __NR_sendfile64              4237
-#define __NR_futex                   4238
-#define __NR_sched_setaffinity       4239
-#define __NR_sched_getaffinity       4240
-#define __NR_io_setup                4241
-#define __NR_io_destroy              4242
-#define __NR_io_getevents            4243
-#define __NR_io_submit               4244
-#define __NR_io_cancel               4245
-#define __NR_exit_group              4246
-#define __NR_lookup_dcookie          4247
-#define __NR_epoll_create            4248
-#define __NR_epoll_ctl               4249
-#define __NR_epoll_wait              4250
-#define __NR_remap_file_pages        4251
-#define __NR_set_tid_address         4252
-#define __NR_restart_syscall         4253
-#define __NR_fadvise64               4254
-#define __NR_statfs64                4255
-#define __NR_fstatfs64               4256
-#define __NR_timer_create            4257
-#define __NR_timer_settime32           4258
-#define __NR_timer_gettime32           4259
-#define __NR_timer_getoverrun        4260
-#define __NR_timer_delete            4261
-#define __NR_clock_settime32           4262
-#define __NR_clock_gettime32           4263
-#define __NR_clock_getres_time32            4264
-#define __NR_clock_nanosleep_time32         4265
-#define __NR_tgkill                  4266
-#define __NR_utimes                  4267
-#define __NR_mbind                   4268
-#define __NR_get_mempolicy           4269
-#define __NR_set_mempolicy           4270
-#define __NR_mq_open                 4271
-#define __NR_mq_unlink               4272
-#define __NR_mq_timedsend            4273
-#define __NR_mq_timedreceive         4274
-#define __NR_mq_notify               4275
-#define __NR_mq_getsetattr           4276
-#define __NR_vserver                 4277
-#define __NR_waitid                  4278
-#define __NR_add_key                 4280
-#define __NR_request_key             4281
-#define __NR_keyctl                  4282
-#define __NR_set_thread_area         4283
-#define __NR_inotify_init            4284
-#define __NR_inotify_add_watch       4285
-#define __NR_inotify_rm_watch        4286
-#define __NR_migrate_pages           4287
-#define __NR_openat                  4288
-#define __NR_mkdirat                 4289
-#define __NR_mknodat                 4290
-#define __NR_fchownat                4291
-#define __NR_futimesat               4292
-#define __NR_fstatat64               4293
-#define __NR_unlinkat                4294
-#define __NR_renameat                4295
-#define __NR_linkat                  4296
-#define __NR_symlinkat               4297
-#define __NR_readlinkat              4298
-#define __NR_fchmodat                4299
-#define __NR_faccessat               4300
-#define __NR_pselect6                4301
-#define __NR_ppoll                   4302
-#define __NR_unshare                 4303
-#define __NR_splice                  4304
-#define __NR_sync_file_range         4305
-#define __NR_tee                     4306
-#define __NR_vmsplice                4307
-#define __NR_move_pages              4308
-#define __NR_set_robust_list         4309
-#define __NR_get_robust_list         4310
-#define __NR_kexec_load              4311
-#define __NR_getcpu                  4312
-#define __NR_epoll_pwait             4313
-#define __NR_ioprio_set              4314
-#define __NR_ioprio_get              4315
-#define __NR_utimensat               4316
-#define __NR_signalfd                4317
-#define __NR_timerfd                 4318
-#define __NR_eventfd                 4319
-#define __NR_fallocate               4320
-#define __NR_timerfd_create          4321
-#define __NR_timerfd_gettime32         4322
-#define __NR_timerfd_settime32         4323
-#define __NR_signalfd4               4324
-#define __NR_eventfd2                4325
-#define __NR_epoll_create1           4326
-#define __NR_dup3                    4327
-#define __NR_pipe2                   4328
-#define __NR_inotify_init1           4329
-#define __NR_preadv                  4330
-#define __NR_pwritev                 4331
-#define __NR_rt_tgsigqueueinfo       4332
-#define __NR_perf_event_open         4333
-#define __NR_accept4                 4334
-#define __NR_recvmmsg                4335
-#define __NR_fanotify_init           4336
-#define __NR_fanotify_mark           4337
-#define __NR_prlimit64               4338
-#define __NR_name_to_handle_at       4339
-#define __NR_open_by_handle_at       4340
-#define __NR_clock_adjtime           4341
-#define __NR_syncfs                  4342
-#define __NR_sendmmsg                4343
-#define __NR_setns                   4344
-#define __NR_process_vm_readv        4345
-#define __NR_process_vm_writev       4346
-#define __NR_kcmp                    4347
-#define __NR_finit_module            4348
-#define __NR_sched_setattr           4349
-#define __NR_sched_getattr           4350
-#define __NR_renameat2               4351
-#define __NR_seccomp                 4352
-#define __NR_getrandom               4353
-#define __NR_memfd_create            4354
-#define __NR_bpf                     4355
-#define __NR_execveat                4356
-#define __NR_userfaultfd             4357
-#define __NR_membarrier              4358
-#define __NR_mlock2                  4359
-#define __NR_copy_file_range         4360
-#define __NR_preadv2                 4361
-#define __NR_pwritev2                4362
-#define __NR_pkey_mprotect           4363
-#define __NR_pkey_alloc              4364
-#define __NR_pkey_free               4365
-#define __NR_statx                   4366
-#define __NR_rseq                    4367
-#define __NR_io_pgetevents           4368
-#define __NR_semget                  4393
-#define __NR_semctl                  4394
-#define __NR_shmget                  4395
-#define __NR_shmctl                  4396
-#define __NR_shmat                   4397
-#define __NR_shmdt                   4398
-#define __NR_msgget                  4399
-#define __NR_msgsnd                  4400
-#define __NR_msgrcv                  4401
-#define __NR_msgctl                  4402
-#define __NR_clock_gettime64         4403
-#define __NR_clock_settime64         4404
-#define __NR_clock_adjtime64         4405
-#define __NR_clock_getres_time64     4406
-#define __NR_clock_nanosleep_time64  4407
-#define __NR_timer_gettime64         4408
-#define __NR_timer_settime64         4409
-#define __NR_timerfd_gettime64       4410
-#define __NR_timerfd_settime64       4411
-#define __NR_utimensat_time64        4412
-#define __NR_pselect6_time64         4413
-#define __NR_ppoll_time64            4414
-#define __NR_io_pgetevents_time64    4416
-#define __NR_recvmmsg_time64         4417
-#define __NR_mq_timedsend_time64     4418
-#define __NR_mq_timedreceive_time64  4419
-#define __NR_semtimedop_time64       4420
-#define __NR_rt_sigtimedwait_time64  4421
-#define __NR_futex_time64            4422
-#define __NR_sched_rr_get_interval_time64 4423
-#define __NR_pidfd_send_signal       4424
-#define __NR_io_uring_setup          4425
-#define __NR_io_uring_enter          4426
-#define __NR_io_uring_register       4427
-#define __NR_open_tree		4428
-#define __NR_move_mount		4429
-#define __NR_fsopen		4430
-#define __NR_fsconfig		4431
-#define __NR_fsmount		4432
-#define __NR_fspick		4433
-#define __NR_pidfd_open		4434
-#define __NR_clone3		4435
-#define __NR_close_range	4436
-#define __NR_openat2		4437
-#define __NR_pidfd_getfd	4438
-#define __NR_faccessat2		4439
-#define __NR_process_madvise	4440
-#define __NR_epoll_pwait2	4441
-#define __NR_mount_setattr	4442
-#define __NR_landlock_create_ruleset	4444
-#define __NR_landlock_add_rule	4445
-#define __NR_landlock_restrict_self	4446
-#define __NR_process_mrelease	4448
-#define __NR_futex_waitv	4449
-#define __NR_set_mempolicy_home_node	4450
-#define __NR_cachestat		4451
-#define __NR_fchmodat2		4452
-
diff --git a/zig/lib/libc/musl/arch/mips64/bits/alltypes.h.in b/zig/lib/libc/musl/arch/mips64/bits/alltypes.h.in
deleted file mode 100644
index fcd61ee853..0000000000
--- a/zig/lib/libc/musl/arch/mips64/bits/alltypes.h.in
+++ /dev/null
@@ -1,22 +0,0 @@
-#define _Addr long
-#define _Int64 long
-#define _Reg long
-
-#if _MIPSEL || __MIPSEL || __MIPSEL__
-#define __BYTE_ORDER 1234
-#else
-#define __BYTE_ORDER 4321
-#endif
-
-#define __LONG_MAX 0x7fffffffffffffffL
-
-#ifndef __cplusplus
-TYPEDEF int wchar_t;
-#endif
-
-TYPEDEF float float_t;
-TYPEDEF double double_t;
-
-TYPEDEF struct { long long __ll; long double __ld; } max_align_t;
-
-TYPEDEF unsigned nlink_t;
diff --git a/zig/lib/libc/musl/arch/mips64/bits/syscall.h.in b/zig/lib/libc/musl/arch/mips64/bits/syscall.h.in
deleted file mode 100644
index 50cec45a46..0000000000
--- a/zig/lib/libc/musl/arch/mips64/bits/syscall.h.in
+++ /dev/null
@@ -1,356 +0,0 @@
-#define __NR_read			5000
-#define __NR_write			5001
-#define __NR_open			5002
-#define __NR_close			5003
-#define __NR_stat			5004
-#define __NR_fstat			5005
-#define __NR_lstat			5006
-#define __NR_poll			5007
-#define __NR_lseek			5008
-#define __NR_mmap			5009
-#define __NR_mprotect			5010
-#define __NR_munmap			5011
-#define __NR_brk			5012
-#define __NR_rt_sigaction		5013
-#define __NR_rt_sigprocmask		5014
-#define __NR_ioctl			5015
-#define __NR_pread64			5016
-#define __NR_pwrite64			5017
-#define __NR_readv			5018
-#define __NR_writev			5019
-#define __NR_access			5020
-#define __NR_pipe			5021
-#define __NR__newselect			5022
-#define __NR_sched_yield		5023
-#define __NR_mremap			5024
-#define __NR_msync			5025
-#define __NR_mincore			5026
-#define __NR_madvise			5027
-#define __NR_shmget			5028
-#define __NR_shmat			5029
-#define __NR_shmctl			5030
-#define __NR_dup			5031
-#define __NR_dup2			5032
-#define __NR_pause			5033
-#define __NR_nanosleep			5034
-#define __NR_getitimer			5035
-#define __NR_setitimer			5036
-#define __NR_alarm			5037
-#define __NR_getpid			5038
-#define __NR_sendfile			5039
-#define __NR_socket			5040
-#define __NR_connect			5041
-#define __NR_accept			5042
-#define __NR_sendto			5043
-#define __NR_recvfrom			5044
-#define __NR_sendmsg			5045
-#define __NR_recvmsg			5046
-#define __NR_shutdown			5047
-#define __NR_bind			5048
-#define __NR_listen			5049
-#define __NR_getsockname		5050
-#define __NR_getpeername		5051
-#define __NR_socketpair			5052
-#define __NR_setsockopt			5053
-#define __NR_getsockopt			5054
-#define __NR_clone			5055
-#define __NR_fork			5056
-#define __NR_execve			5057
-#define __NR_exit			5058
-#define __NR_wait4			5059
-#define __NR_kill			5060
-#define __NR_uname			5061
-#define __NR_semget			5062
-#define __NR_semop			5063
-#define __NR_semctl			5064
-#define __NR_shmdt			5065
-#define __NR_msgget			5066
-#define __NR_msgsnd			5067
-#define __NR_msgrcv			5068
-#define __NR_msgctl			5069
-#define __NR_fcntl			5070
-#define __NR_flock			5071
-#define __NR_fsync			5072
-#define __NR_fdatasync			5073
-#define __NR_truncate			5074
-#define __NR_ftruncate			5075
-#define __NR_getdents			5076
-#define __NR_getcwd			5077
-#define __NR_chdir			5078
-#define __NR_fchdir			5079
-#define __NR_rename			5080
-#define __NR_mkdir			5081
-#define __NR_rmdir			5082
-#define __NR_creat			5083
-#define __NR_link			5084
-#define __NR_unlink			5085
-#define __NR_symlink			5086
-#define __NR_readlink			5087
-#define __NR_chmod			5088
-#define __NR_fchmod			5089
-#define __NR_chown			5090
-#define __NR_fchown			5091
-#define __NR_lchown			5092
-#define __NR_umask			5093
-#define __NR_gettimeofday		5094
-#define __NR_getrlimit			5095
-#define __NR_getrusage			5096
-#define __NR_sysinfo			5097
-#define __NR_times			5098
-#define __NR_ptrace			5099
-#define __NR_getuid			5100
-#define __NR_syslog			5101
-#define __NR_getgid			5102
-#define __NR_setuid			5103
-#define __NR_setgid			5104
-#define __NR_geteuid			5105
-#define __NR_getegid			5106
-#define __NR_setpgid			5107
-#define __NR_getppid			5108
-#define __NR_getpgrp			5109
-#define __NR_setsid			5110
-#define __NR_setreuid			5111
-#define __NR_setregid			5112
-#define __NR_getgroups			5113
-#define __NR_setgroups			5114
-#define __NR_setresuid			5115
-#define __NR_getresuid			5116
-#define __NR_setresgid			5117
-#define __NR_getresgid			5118
-#define __NR_getpgid			5119
-#define __NR_setfsuid			5120
-#define __NR_setfsgid			5121
-#define __NR_getsid			5122
-#define __NR_capget			5123
-#define __NR_capset			5124
-#define __NR_rt_sigpending		5125
-#define __NR_rt_sigtimedwait		5126
-#define __NR_rt_sigqueueinfo		5127
-#define __NR_rt_sigsuspend		5128
-#define __NR_sigaltstack		5129
-#define __NR_utime			5130
-#define __NR_mknod			5131
-#define __NR_personality		5132
-#define __NR_ustat			5133
-#define __NR_statfs			5134
-#define __NR_fstatfs			5135
-#define __NR_sysfs			5136
-#define __NR_getpriority		5137
-#define __NR_setpriority		5138
-#define __NR_sched_setparam		5139
-#define __NR_sched_getparam		5140
-#define __NR_sched_setscheduler		5141
-#define __NR_sched_getscheduler		5142
-#define __NR_sched_get_priority_max	5143
-#define __NR_sched_get_priority_min	5144
-#define __NR_sched_rr_get_interval	5145
-#define __NR_mlock			5146
-#define __NR_munlock			5147
-#define __NR_mlockall			5148
-#define __NR_munlockall			5149
-#define __NR_vhangup			5150
-#define __NR_pivot_root			5151
-#define __NR__sysctl			5152
-#define __NR_prctl			5153
-#define __NR_adjtimex			5154
-#define __NR_setrlimit			5155
-#define __NR_chroot			5156
-#define __NR_sync			5157
-#define __NR_acct			5158
-#define __NR_settimeofday		5159
-#define __NR_mount			5160
-#define __NR_umount2			5161
-#define __NR_swapon			5162
-#define __NR_swapoff			5163
-#define __NR_reboot			5164
-#define __NR_sethostname		5165
-#define __NR_setdomainname		5166
-#define __NR_create_module		5167
-#define __NR_init_module		5168
-#define __NR_delete_module		5169
-#define __NR_get_kernel_syms		5170
-#define __NR_query_module		5171
-#define __NR_quotactl			5172
-#define __NR_nfsservctl			5173
-#define __NR_getpmsg			5174
-#define __NR_putpmsg			5175
-#define __NR_afs_syscall		5176
-#define __NR_reserved177		5177
-#define __NR_gettid			5178
-#define __NR_readahead			5179
-#define __NR_setxattr			5180
-#define __NR_lsetxattr			5181
-#define __NR_fsetxattr			5182
-#define __NR_getxattr			5183
-#define __NR_lgetxattr			5184
-#define __NR_fgetxattr			5185
-#define __NR_listxattr			5186
-#define __NR_llistxattr			5187
-#define __NR_flistxattr			5188
-#define __NR_removexattr		5189
-#define __NR_lremovexattr		5190
-#define __NR_fremovexattr		5191
-#define __NR_tkill			5192
-#define __NR_reserved193		5193
-#define __NR_futex			5194
-#define __NR_sched_setaffinity		5195
-#define __NR_sched_getaffinity		5196
-#define __NR_cacheflush			5197
-#define __NR_cachectl			5198
-#define __NR_sysmips			5199
-#define __NR_io_setup			5200
-#define __NR_io_destroy			5201
-#define __NR_io_getevents		5202
-#define __NR_io_submit			5203
-#define __NR_io_cancel			5204
-#define __NR_exit_group			5205
-#define __NR_lookup_dcookie		5206
-#define __NR_epoll_create		5207
-#define __NR_epoll_ctl			5208
-#define __NR_epoll_wait			5209
-#define __NR_remap_file_pages		5210
-#define __NR_rt_sigreturn		5211
-#define __NR_set_tid_address		5212
-#define __NR_restart_syscall		5213
-#define __NR_semtimedop			5214
-#define __NR_fadvise64			5215
-#define __NR_timer_create		5216
-#define __NR_timer_settime		5217
-#define __NR_timer_gettime		5218
-#define __NR_timer_getoverrun		5219
-#define __NR_timer_delete		5220
-#define __NR_clock_settime		5221
-#define __NR_clock_gettime		5222
-#define __NR_clock_getres		5223
-#define __NR_clock_nanosleep		5224
-#define __NR_tgkill			5225
-#define __NR_utimes			5226
-#define __NR_mbind			5227
-#define __NR_get_mempolicy		5228
-#define __NR_set_mempolicy		5229
-#define __NR_mq_open			5230
-#define __NR_mq_unlink			5231
-#define __NR_mq_timedsend		5232
-#define __NR_mq_timedreceive		5233
-#define __NR_mq_notify			5234
-#define __NR_mq_getsetattr		5235
-#define __NR_vserver			5236
-#define __NR_waitid			5237
-#define __NR_add_key			5239
-#define __NR_request_key		5240
-#define __NR_keyctl			5241
-#define __NR_set_thread_area		5242
-#define __NR_inotify_init		5243
-#define __NR_inotify_add_watch		5244
-#define __NR_inotify_rm_watch		5245
-#define __NR_migrate_pages		5246
-#define __NR_openat			5247
-#define __NR_mkdirat			5248
-#define __NR_mknodat			5249
-#define __NR_fchownat			5250
-#define __NR_futimesat			5251
-#define __NR_newfstatat			5252
-#define __NR_unlinkat			5253
-#define __NR_renameat			5254
-#define __NR_linkat			5255
-#define __NR_symlinkat			5256
-#define __NR_readlinkat			5257
-#define __NR_fchmodat			5258
-#define __NR_faccessat			5259
-#define __NR_pselect6			5260
-#define __NR_ppoll			5261
-#define __NR_unshare			5262
-#define __NR_splice			5263
-#define __NR_sync_file_range		5264
-#define __NR_tee			5265
-#define __NR_vmsplice			5266
-#define __NR_move_pages			5267
-#define __NR_set_robust_list		5268
-#define __NR_get_robust_list		5269
-#define __NR_kexec_load			5270
-#define __NR_getcpu			5271
-#define __NR_epoll_pwait		5272
-#define __NR_ioprio_set			5273
-#define __NR_ioprio_get			5274
-#define __NR_utimensat			5275
-#define __NR_signalfd			5276
-#define __NR_timerfd			5277
-#define __NR_eventfd			5278
-#define __NR_fallocate			5279
-#define __NR_timerfd_create		5280
-#define __NR_timerfd_gettime		5281
-#define __NR_timerfd_settime		5282
-#define __NR_signalfd4			5283
-#define __NR_eventfd2			5284
-#define __NR_epoll_create1		5285
-#define __NR_dup3			5286
-#define __NR_pipe2			5287
-#define __NR_inotify_init1		5288
-#define __NR_preadv			5289
-#define __NR_pwritev			5290
-#define __NR_rt_tgsigqueueinfo		5291
-#define __NR_perf_event_open		5292
-#define __NR_accept4			5293
-#define __NR_recvmmsg			5294
-#define __NR_fanotify_init		5295
-#define __NR_fanotify_mark		5296
-#define __NR_prlimit64			5297
-#define __NR_name_to_handle_at		5298
-#define __NR_open_by_handle_at		5299
-#define __NR_clock_adjtime		5300
-#define __NR_syncfs			5301
-#define __NR_sendmmsg			5302
-#define __NR_setns			5303
-#define __NR_process_vm_readv		5304
-#define __NR_process_vm_writev		5305
-#define __NR_kcmp			5306
-#define __NR_finit_module		5307
-#define __NR_getdents64			5308
-#define __NR_sched_setattr		5309
-#define __NR_sched_getattr		5310
-#define __NR_renameat2			5311
-#define __NR_seccomp			5312
-#define __NR_getrandom			5313
-#define __NR_memfd_create		5314
-#define __NR_bpf			5315
-#define __NR_execveat			5316
-#define __NR_userfaultfd		5317
-#define __NR_membarrier			5318
-#define __NR_mlock2			5319
-#define __NR_copy_file_range		5320
-#define __NR_preadv2			5321
-#define __NR_pwritev2			5322
-#define __NR_pkey_mprotect		5323
-#define __NR_pkey_alloc			5324
-#define __NR_pkey_free			5325
-#define __NR_statx			5326
-#define __NR_rseq			5327
-#define __NR_io_pgetevents		5328
-#define __NR_pidfd_send_signal		5424
-#define __NR_io_uring_setup		5425
-#define __NR_io_uring_enter		5426
-#define __NR_io_uring_register		5427
-#define __NR_open_tree		5428
-#define __NR_move_mount		5429
-#define __NR_fsopen		5430
-#define __NR_fsconfig		5431
-#define __NR_fsmount		5432
-#define __NR_fspick		5433
-#define __NR_pidfd_open		5434
-#define __NR_clone3		5435
-#define __NR_close_range	5436
-#define __NR_openat2		5437
-#define __NR_pidfd_getfd	5438
-#define __NR_faccessat2		5439
-#define __NR_process_madvise	5440
-#define __NR_epoll_pwait2	5441
-#define __NR_mount_setattr	5442
-#define __NR_landlock_create_ruleset	5444
-#define __NR_landlock_add_rule	5445
-#define __NR_landlock_restrict_self	5446
-#define __NR_process_mrelease	5448
-#define __NR_futex_waitv	5449
-#define __NR_set_mempolicy_home_node	5450
-#define __NR_cachestat		5451
-#define __NR_fchmodat2		5452
-
diff --git a/zig/lib/libc/musl/arch/mipsn32/atomic_arch.h b/zig/lib/libc/musl/arch/mipsn32/atomic_arch.h
new file mode 100644
index 0000000000..ccc3878cc5
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/atomic_arch.h
@@ -0,0 +1,52 @@
+#if __mips_isa_rev < 6
+#define LLSC_M "m"
+#else
+#define LLSC_M "ZC"
+#endif
+
+#define a_ll a_ll
+static inline int a_ll(volatile int *p)
+{
+	int v;
+#if __mips < 2
+	__asm__ __volatile__ (
+		".set push ; .set mips2\n\t"
+		"ll %0, %1"
+		"\n\t.set pop"
+		: "=r"(v) : "m"(*p));
+#else
+	__asm__ __volatile__ (
+		"ll %0, %1"
+		: "=r"(v) : LLSC_M(*p));
+#endif
+	return v;
+}
+
+#define a_sc a_sc
+static inline int a_sc(volatile int *p, int v)
+{
+	int r;
+#if __mips < 2
+	__asm__ __volatile__ (
+		".set push ; .set mips2\n\t"
+		"sc %0, %1"
+		"\n\t.set pop"
+		: "=r"(r), "=m"(*p) : "0"(v) : "memory");
+#else
+	__asm__ __volatile__ (
+		"sc %0, %1"
+		: "=r"(r), "="LLSC_M(*p) : "0"(v) : "memory");
+#endif
+	return r;
+}
+
+#define a_barrier a_barrier
+static inline void a_barrier()
+{
+	__asm__ __volatile__ ("sync" : : : "memory");
+}
+
+#define a_pre_llsc a_barrier
+#define a_post_llsc a_barrier
+
+#undef LLSC_M
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/errno.h b/zig/lib/libc/musl/arch/mipsn32/bits/errno.h
new file mode 100644
index 0000000000..1bb91e3d77
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/errno.h
@@ -0,0 +1,134 @@
+#define EPERM            1
+#define ENOENT           2
+#define ESRCH            3
+#define EINTR            4
+#define EIO              5
+#define ENXIO            6
+#define E2BIG            7
+#define ENOEXEC          8
+#define EBADF            9
+#define ECHILD          10
+#define EAGAIN          11
+#define ENOMEM          12
+#define EACCES          13
+#define EFAULT          14
+#define ENOTBLK         15
+#define EBUSY           16
+#define EEXIST          17
+#define EXDEV           18
+#define ENODEV          19
+#define ENOTDIR         20
+#define EISDIR          21
+#define EINVAL          22
+#define ENFILE          23
+#define EMFILE          24
+#define ENOTTY          25
+#define ETXTBSY         26
+#define EFBIG           27
+#define ENOSPC          28
+#define ESPIPE          29
+#define EROFS           30
+#define EMLINK          31
+#define EPIPE           32
+#define EDOM            33
+#define ERANGE          34
+#define ENOMSG          35
+#define EIDRM           36
+#define ECHRNG          37
+#define EL2NSYNC        38
+#define EL3HLT          39
+#define EL3RST          40
+#define ELNRNG          41
+#define EUNATCH         42
+#define ENOCSI          43
+#define EL2HLT          44
+#define EDEADLK         45
+#define ENOLCK          46
+#define EBADE           50
+#define EBADR           51
+#define EXFULL          52
+#define ENOANO          53
+#define EBADRQC         54
+#define EBADSLT         55
+#define EDEADLOCK       56
+#define EBFONT          59
+#define ENOSTR          60
+#define ENODATA         61
+#define ETIME           62
+#define ENOSR           63
+#define ENONET          64
+#define ENOPKG          65
+#define EREMOTE         66
+#define ENOLINK         67
+#define EADV            68
+#define ESRMNT          69
+#define ECOMM           70
+#define EPROTO          71
+#define EDOTDOT         73
+#define EMULTIHOP       74
+#define EBADMSG         77
+#define ENAMETOOLONG    78
+#define EOVERFLOW       79
+#define ENOTUNIQ        80
+#define EBADFD          81
+#define EREMCHG         82
+#define ELIBACC         83
+#define ELIBBAD         84
+#define ELIBSCN         85
+#define ELIBMAX         86
+#define ELIBEXEC        87
+#define EILSEQ          88
+#define ENOSYS          89
+#define ELOOP           90
+#define ERESTART        91
+#define ESTRPIPE        92
+#define ENOTEMPTY       93
+#define EUSERS          94
+#define ENOTSOCK        95
+#define EDESTADDRREQ    96
+#define EMSGSIZE        97
+#define EPROTOTYPE      98
+#define ENOPROTOOPT     99
+#define EPROTONOSUPPORT 120
+#define ESOCKTNOSUPPORT 121
+#define EOPNOTSUPP      122
+#define ENOTSUP         EOPNOTSUPP
+#define EPFNOSUPPORT    123
+#define EAFNOSUPPORT    124
+#define EADDRINUSE      125
+#define EADDRNOTAVAIL   126
+#define ENETDOWN        127
+#define ENETUNREACH     128
+#define ENETRESET       129
+#define ECONNABORTED    130
+#define ECONNRESET      131
+#define ENOBUFS         132
+#define EISCONN         133
+#define ENOTCONN        134
+#define EUCLEAN         135
+#define ENOTNAM         137
+#define ENAVAIL         138
+#define EISNAM          139
+#define EREMOTEIO       140
+#define ESHUTDOWN       143
+#define ETOOMANYREFS    144
+#define ETIMEDOUT       145
+#define ECONNREFUSED    146
+#define EHOSTDOWN       147
+#define EHOSTUNREACH    148
+#define EWOULDBLOCK     EAGAIN
+#define EALREADY        149
+#define EINPROGRESS     150
+#define ESTALE          151
+#define ECANCELED       158
+#define ENOMEDIUM       159
+#define EMEDIUMTYPE     160
+#define ENOKEY          161
+#define EKEYEXPIRED     162
+#define EKEYREVOKED     163
+#define EKEYREJECTED    164
+#define EOWNERDEAD      165
+#define ENOTRECOVERABLE 166
+#define ERFKILL         167
+#define EHWPOISON       168
+#define EDQUOT          1133
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/fcntl.h b/zig/lib/libc/musl/arch/mipsn32/bits/fcntl.h
new file mode 100644
index 0000000000..9fd8c23e27
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/fcntl.h
@@ -0,0 +1,40 @@
+#define O_CREAT        0400
+#define O_EXCL        02000
+#define O_NOCTTY      04000
+#define O_TRUNC       01000
+#define O_APPEND       0010
+#define O_NONBLOCK     0200
+#define O_DSYNC        0020
+#define O_SYNC       040020
+#define O_RSYNC      040020
+#define O_DIRECTORY 0200000
+#define O_NOFOLLOW  0400000
+#define O_CLOEXEC  02000000
+
+#define O_ASYNC      010000
+#define O_DIRECT    0100000
+#define O_LARGEFILE  020000
+#define O_NOATIME  01000000
+#define O_PATH    010000000
+#define O_TMPFILE 020200000
+#define O_NDELAY O_NONBLOCK
+
+#define F_DUPFD  0
+#define F_GETFD  1
+#define F_SETFD  2
+#define F_GETFL  3
+#define F_SETFL  4
+
+#define F_SETOWN 24
+#define F_GETOWN 23
+#define F_SETSIG 10
+#define F_GETSIG 11
+
+#define F_GETLK 33
+#define F_SETLK 34
+#define F_SETLKW 35
+
+#define F_SETOWN_EX 15
+#define F_GETOWN_EX 16
+
+#define F_GETOWNER_UIDS 17
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/fenv.h b/zig/lib/libc/musl/arch/mipsn32/bits/fenv.h
new file mode 100644
index 0000000000..589e71c1bf
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/fenv.h
@@ -0,0 +1,25 @@
+#ifdef __mips_soft_float
+#define FE_ALL_EXCEPT 0
+#define FE_TONEAREST  0
+#else
+#define FE_INEXACT    4
+#define FE_UNDERFLOW  8
+#define FE_OVERFLOW   16
+#define FE_DIVBYZERO  32
+#define FE_INVALID    64
+
+#define FE_ALL_EXCEPT 124
+
+#define FE_TONEAREST  0
+#define FE_TOWARDZERO 1
+#define FE_UPWARD     2
+#define FE_DOWNWARD   3
+#endif
+
+typedef unsigned short fexcept_t;
+
+typedef struct {
+	unsigned __cw;
+} fenv_t;
+
+#define FE_DFL_ENV      ((const fenv_t *) -1)
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/float.h b/zig/lib/libc/musl/arch/mipsn32/bits/float.h
new file mode 100644
index 0000000000..719c79085a
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/float.h
@@ -0,0 +1,16 @@
+#define FLT_EVAL_METHOD 0
+
+#define LDBL_TRUE_MIN 6.47517511943802511092443895822764655e-4966L
+#define LDBL_MIN 3.36210314311209350626267781732175260e-4932L
+#define LDBL_MAX 1.18973149535723176508575932662800702e+4932L
+#define LDBL_EPSILON 1.92592994438723585305597794258492732e-34L
+
+#define LDBL_MANT_DIG 113
+#define LDBL_MIN_EXP (-16381)
+#define LDBL_MAX_EXP 16384
+
+#define LDBL_DIG 33
+#define LDBL_MIN_10_EXP (-4931)
+#define LDBL_MAX_10_EXP 4932
+
+#define DECIMAL_DIG 36
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/hwcap.h b/zig/lib/libc/musl/arch/mipsn32/bits/hwcap.h
new file mode 100644
index 0000000000..13e86fe702
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/hwcap.h
@@ -0,0 +1,3 @@
+#define HWCAP_MIPS_R6		(1 << 0)
+#define HWCAP_MIPS_MSA		(1 << 1)
+#define HWCAP_MIPS_CRC32	(1 << 2)
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/ioctl.h b/zig/lib/libc/musl/arch/mipsn32/bits/ioctl.h
new file mode 100644
index 0000000000..e20bf19eaa
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/ioctl.h
@@ -0,0 +1,114 @@
+#define _IOC(a,b,c,d) ( ((a)<<29) | ((b)<<8) | (c) | ((d)<<16) )
+#define _IOC_NONE  1U
+#define _IOC_READ  2U
+#define _IOC_WRITE 4U
+
+#define _IO(a,b) _IOC(_IOC_NONE,(a),(b),0)
+#define _IOW(a,b,c) _IOC(_IOC_WRITE,(a),(b),sizeof(c))
+#define _IOR(a,b,c) _IOC(_IOC_READ,(a),(b),sizeof(c))
+#define _IOWR(a,b,c) _IOC(_IOC_READ|_IOC_WRITE,(a),(b),sizeof(c))
+
+#define TCGETA		0x5401
+#define TCSETA		0x5402
+#define TCSETAW		0x5403
+#define TCSETAF		0x5404
+#define TCSBRK		0x5405
+#define TCXONC		0x5406
+#define TCFLSH		0x5407
+#define TCGETS		0x540D
+#define TCSETS		0x540E
+#define TCSETSW		0x540F
+#define TCSETSF		0x5410
+
+#define TIOCEXCL	0x740D
+#define TIOCNXCL	0x740E
+#define TIOCOUTQ	0x7472
+#define TIOCSTI		0x5472
+#define TIOCMGET	0x741D
+#define TIOCMBIS	0x741B
+#define TIOCMBIC	0x741C
+#define TIOCMSET	0x741A
+
+#define TIOCPKT		0x5470
+#define TIOCSWINSZ	_IOW('t', 103, struct winsize)
+#define TIOCGWINSZ	_IOR('t', 104, struct winsize)
+#define TIOCNOTTY	0x5471
+#define TIOCSETD	0x7401
+#define TIOCGETD	0x7400
+
+#define FIOCLEX		0x6601
+#define FIONCLEX	0x6602
+#define FIOASYNC	0x667D
+#define FIONBIO		0x667E
+#define FIOQSIZE	0x667F
+
+#define TIOCGLTC        0x7474
+#define TIOCSLTC        0x7475
+#define TIOCSPGRP	_IOW('t', 118, int)
+#define TIOCGPGRP	_IOR('t', 119, int)
+#define TIOCCONS	_IOW('t', 120, int)
+
+#define FIONREAD	0x467F
+#define TIOCINQ		FIONREAD
+
+#define TIOCGETP        0x7408
+#define TIOCSETP        0x7409
+#define TIOCSETN        0x740A
+
+#define TIOCSBRK	0x5427
+#define TIOCCBRK	0x5428
+#define TIOCGSID	0x7416
+#define TIOCGRS485	_IOR('T', 0x2E, char[32])
+#define TIOCSRS485	_IOWR('T', 0x2F, char[32])
+#define TIOCGPTN	_IOR('T', 0x30, unsigned int)
+#define TIOCSPTLCK	_IOW('T', 0x31, int)
+#define TIOCGDEV	_IOR('T', 0x32, unsigned int)
+#define TIOCSIG		_IOW('T', 0x36, int)
+#define TIOCVHANGUP	0x5437
+#define TIOCGPKT	_IOR('T', 0x38, int)
+#define TIOCGPTLCK	_IOR('T', 0x39, int)
+#define TIOCGEXCL	_IOR('T', 0x40, int)
+#define TIOCGPTPEER	_IO('T', 0x41)
+
+#define TIOCSCTTY	0x5480
+#define TIOCGSOFTCAR	0x5481
+#define TIOCSSOFTCAR	0x5482
+#define TIOCLINUX	0x5483
+#define TIOCGSERIAL	0x5484
+#define TIOCSSERIAL	0x5485
+#define TCSBRKP		0x5486
+
+#define TIOCSERCONFIG	0x5488
+#define TIOCSERGWILD	0x5489
+#define TIOCSERSWILD	0x548A
+#define TIOCGLCKTRMIOS	0x548B
+#define TIOCSLCKTRMIOS	0x548C
+#define TIOCSERGSTRUCT	0x548D
+#define TIOCSERGETLSR   0x548E
+#define TIOCSERGETMULTI 0x548F
+#define TIOCSERSETMULTI 0x5490
+#define TIOCMIWAIT	0x5491
+#define TIOCGICOUNT	0x5492
+
+#define TIOCM_LE	0x001
+#define TIOCM_DTR	0x002
+#define TIOCM_RTS	0x004
+#define TIOCM_ST	0x010
+#define TIOCM_SR	0x020
+#define TIOCM_CTS	0x040
+#define TIOCM_CAR	0x100
+#define TIOCM_CD	TIOCM_CAR
+#define TIOCM_RNG	0x200
+#define TIOCM_RI	TIOCM_RNG
+#define TIOCM_DSR	0x400
+#define TIOCM_OUT1	0x2000
+#define TIOCM_OUT2	0x4000
+#define TIOCM_LOOP	0x8000
+
+#define FIOGETOWN       _IOR('f', 123, int)
+#define FIOSETOWN       _IOW('f', 124, int)
+#define SIOCATMARK      _IOR('s', 7, int)
+#define SIOCSPGRP       _IOW('s', 8, pid_t)
+#define SIOCGPGRP       _IOR('s', 9, pid_t)
+#define SIOCGSTAMP      _IOR(0x89, 6, char[16])
+#define SIOCGSTAMPNS    _IOR(0x89, 7, char[16])
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/ipcstat.h b/zig/lib/libc/musl/arch/mipsn32/bits/ipcstat.h
new file mode 100644
index 0000000000..4f4fcb0c5b
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/ipcstat.h
@@ -0,0 +1 @@
+#define IPC_STAT 0x102
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/mman.h b/zig/lib/libc/musl/arch/mipsn32/bits/mman.h
new file mode 100644
index 0000000000..9027bb6376
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/mman.h
@@ -0,0 +1,25 @@
+#undef MAP_ANON
+#define MAP_ANON       0x800
+#undef MAP_NORESERVE
+#define MAP_NORESERVE  0x0400
+#undef MAP_GROWSDOWN
+#define MAP_GROWSDOWN  0x1000
+#undef MAP_DENYWRITE
+#define MAP_DENYWRITE  0x2000
+#undef MAP_EXECUTABLE
+#define MAP_EXECUTABLE 0x4000
+#undef MAP_LOCKED
+#define MAP_LOCKED     0x8000
+#undef MAP_POPULATE
+#define MAP_POPULATE   0x10000
+#undef MAP_NONBLOCK
+#define MAP_NONBLOCK   0x20000
+#undef MAP_STACK
+#define MAP_STACK      0x40000
+#undef MAP_HUGETLB
+#define MAP_HUGETLB    0x80000
+#undef MAP_SYNC
+
+#if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+#undef MADV_SOFT_OFFLINE
+#endif
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/msg.h b/zig/lib/libc/musl/arch/mipsn32/bits/msg.h
new file mode 100644
index 0000000000..c734dbb570
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/msg.h
@@ -0,0 +1,27 @@
+struct msqid_ds {
+	struct ipc_perm msg_perm;
+#if _MIPSEL || __MIPSEL || __MIPSEL__
+	unsigned long __msg_stime_lo;
+	unsigned long __msg_stime_hi;
+	unsigned long __msg_rtime_lo;
+	unsigned long __msg_rtime_hi;
+	unsigned long __msg_ctime_lo;
+	unsigned long __msg_ctime_hi;
+#else
+	unsigned long __msg_stime_hi;
+	unsigned long __msg_stime_lo;
+	unsigned long __msg_rtime_hi;
+	unsigned long __msg_rtime_lo;
+	unsigned long __msg_ctime_hi;
+	unsigned long __msg_ctime_lo;
+#endif
+	unsigned long msg_cbytes;
+	msgqnum_t msg_qnum;
+	msglen_t msg_qbytes;
+	pid_t msg_lspid;
+	pid_t msg_lrpid;
+	unsigned long __unused[2];
+	time_t msg_stime;
+	time_t msg_rtime;
+	time_t msg_ctime;
+};
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/poll.h b/zig/lib/libc/musl/arch/mipsn32/bits/poll.h
new file mode 100644
index 0000000000..b0b1ed621e
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/poll.h
@@ -0,0 +1,2 @@
+#define POLLWRNORM POLLOUT
+#define POLLWRBAND 0x100
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/posix.h b/zig/lib/libc/musl/arch/mipsn32/bits/posix.h
new file mode 100644
index 0000000000..30a38714f3
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/posix.h
@@ -0,0 +1,2 @@
+#define _POSIX_V6_ILP32_OFFBIG  1
+#define _POSIX_V7_ILP32_OFFBIG  1
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/ptrace.h b/zig/lib/libc/musl/arch/mipsn32/bits/ptrace.h
new file mode 100644
index 0000000000..77a01c064e
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/ptrace.h
@@ -0,0 +1,9 @@
+#define PTRACE_GET_THREAD_AREA	25
+#define PTRACE_SET_THREAD_AREA	26
+#define PTRACE_PEEKTEXT_3264	0xc0
+#define PTRACE_PEEKDATA_3264	0xc1
+#define PTRACE_POKETEXT_3264	0xc2
+#define PTRACE_POKEDATA_3264	0xc3
+#define PTRACE_GET_THREAD_AREA_3264	0xc4
+#define PTRACE_GET_WATCH_REGS	0xd0
+#define PTRACE_SET_WATCH_REGS	0xd1
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/reg.h b/zig/lib/libc/musl/arch/mipsn32/bits/reg.h
new file mode 100644
index 0000000000..a3f63accf7
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/reg.h
@@ -0,0 +1,47 @@
+#undef __WORDSIZE
+#define __WORDSIZE 64
+
+#define EF_R0 0
+#define EF_R1 1
+#define EF_R2 2
+#define EF_R3 3
+#define EF_R4 4
+#define EF_R5 5
+#define EF_R6 6
+#define EF_R7 7
+#define EF_R8 8
+#define EF_R9 9
+#define EF_R10 10
+#define EF_R11 11
+#define EF_R12 12
+#define EF_R13 13
+#define EF_R14 14
+#define EF_R15 15
+#define EF_R16 16
+#define EF_R17 17
+#define EF_R18 18
+#define EF_R19 19
+#define EF_R20 20
+#define EF_R21 21
+#define EF_R22 22
+#define EF_R23 23
+#define EF_R24 24
+#define EF_R25 25
+
+#define EF_R26 26
+#define EF_R27 27
+#define EF_R28 28
+#define EF_R29 29
+#define EF_R30 30
+#define EF_R31 31
+
+#define EF_LO 32
+#define EF_HI 33
+
+#define EF_CP0_EPC 34
+#define EF_CP0_BADVADDR 35
+#define EF_CP0_STATUS 36
+#define EF_CP0_CAUSE 37
+#define EF_UNUSED0 38
+
+#define EF_SIZE 304
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/resource.h b/zig/lib/libc/musl/arch/mipsn32/bits/resource.h
new file mode 100644
index 0000000000..414a405417
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/resource.h
@@ -0,0 +1,5 @@
+#define RLIMIT_NOFILE  5
+#define RLIMIT_AS      6
+#define RLIMIT_RSS     7
+#define RLIMIT_NPROC   8
+#define RLIMIT_MEMLOCK 9
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/sem.h b/zig/lib/libc/musl/arch/mipsn32/bits/sem.h
new file mode 100644
index 0000000000..fe6f094858
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/sem.h
@@ -0,0 +1,16 @@
+struct semid_ds {
+	struct ipc_perm sem_perm;
+	unsigned long __sem_otime_lo;
+	unsigned long __sem_ctime_lo;
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+	unsigned short sem_nsems;
+	char __sem_nsems_pad[sizeof(long)-sizeof(short)];
+#else
+	char __sem_nsems_pad[sizeof(long)-sizeof(short)];
+	unsigned short sem_nsems;
+#endif
+	unsigned long __sem_otime_hi;
+	unsigned long __sem_ctime_hi;
+	time_t sem_otime;
+	time_t sem_ctime;
+};
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/setjmp.h b/zig/lib/libc/musl/arch/mipsn32/bits/setjmp.h
new file mode 100644
index 0000000000..4d93267e61
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/setjmp.h
@@ -0,0 +1 @@
+typedef unsigned long long __jmp_buf[23];
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/shm.h b/zig/lib/libc/musl/arch/mipsn32/bits/shm.h
new file mode 100644
index 0000000000..ab8c642d82
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/shm.h
@@ -0,0 +1,29 @@
+#define SHMLBA 4096
+
+struct shmid_ds {
+	struct ipc_perm shm_perm;
+	size_t shm_segsz;
+	unsigned long __shm_atime_lo;
+	unsigned long __shm_dtime_lo;
+	unsigned long __shm_ctime_lo;
+	pid_t shm_cpid;
+	pid_t shm_lpid;
+	unsigned long shm_nattch;
+	unsigned short __shm_atime_hi;
+	unsigned short __shm_dtime_hi;
+	unsigned short __shm_ctime_hi;
+	unsigned short __pad1;
+	time_t shm_atime;
+	time_t shm_dtime;
+	time_t shm_ctime;
+};
+
+struct shminfo {
+	unsigned long shmmax, shmmin, shmmni, shmseg, shmall, __unused[4];
+};
+
+struct shm_info {
+	int __used_ids;
+	unsigned long shm_tot, shm_rss, shm_swp;
+	unsigned long __swap_attempts, __swap_successes;
+};
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/signal.h b/zig/lib/libc/musl/arch/mipsn32/bits/signal.h
new file mode 100644
index 0000000000..ffec7fd014
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/signal.h
@@ -0,0 +1,142 @@
+#if defined(_POSIX_SOURCE) || defined(_POSIX_C_SOURCE) \
+ || defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+
+#if defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+#define MINSIGSTKSZ 2048
+#define SIGSTKSZ 8192
+#endif
+
+#if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+typedef unsigned long long greg_t, gregset_t[32];
+
+typedef struct {
+	union {
+		double fp_dregs[32];
+		struct {
+			float _fp_fregs;
+			unsigned _fp_pad;
+		} fp_fregs[32];
+	} fp_r;
+} fpregset_t;
+
+struct sigcontext {
+	unsigned long long sc_regs[32];
+	unsigned long long sc_fpregs[32];
+	unsigned long long sc_mdhi;
+	unsigned long long sc_hi1;
+	unsigned long long sc_hi2;
+	unsigned long long sc_hi3;
+	unsigned long long sc_mdlo;
+	unsigned long long sc_lo1;
+	unsigned long long sc_lo2;
+	unsigned long long sc_lo3;
+	unsigned long long sc_pc;
+	unsigned int sc_fpc_csr;
+	unsigned int sc_used_math;
+	unsigned int sc_dsp;
+	unsigned int sc_reserved;
+};
+
+typedef struct {
+	gregset_t gregs;
+	fpregset_t fpregs;
+	greg_t mdhi;
+	greg_t hi1;
+	greg_t hi2;
+	greg_t hi3;
+	greg_t mdlo;
+	greg_t lo1;
+	greg_t lo2;
+	greg_t lo3;
+	greg_t pc;
+	unsigned int fpc_csr;
+	unsigned int used_math;
+	unsigned int dsp;
+	unsigned int reserved;
+} mcontext_t;
+
+#else
+typedef struct {
+	unsigned long long __mc1[32];
+	double __mc2[32];
+	unsigned long long __mc3[9];
+	unsigned __mc4[4];
+} mcontext_t;
+#endif
+
+struct sigaltstack {
+	void *ss_sp;
+	size_t ss_size;
+	int ss_flags;
+};
+
+typedef struct __ucontext {
+	unsigned long uc_flags;
+	struct __ucontext *uc_link;
+	stack_t uc_stack;
+	mcontext_t uc_mcontext;
+	sigset_t uc_sigmask;
+} ucontext_t;
+
+#define SA_NOCLDSTOP  1
+#define SA_NOCLDWAIT  0x10000
+#define SA_SIGINFO    8
+#define SA_ONSTACK    0x08000000
+#define SA_RESTART    0x10000000
+#define SA_NODEFER    0x40000000
+#define SA_RESETHAND  0x80000000
+
+#undef SIG_BLOCK
+#undef SIG_UNBLOCK
+#undef SIG_SETMASK
+#define SIG_BLOCK     1
+#define SIG_UNBLOCK   2
+#define SIG_SETMASK   3
+
+#undef SI_ASYNCIO
+#undef SI_MESGQ
+#undef SI_TIMER
+#define SI_ASYNCIO (-2)
+#define SI_MESGQ (-4)
+#define SI_TIMER (-3)
+
+#define __SI_SWAP_ERRNO_CODE
+
+#endif
+
+#define SIGHUP    1
+#define SIGINT    2
+#define SIGQUIT   3
+#define SIGILL    4
+#define SIGTRAP   5
+#define SIGABRT   6
+#define SIGIOT    SIGABRT
+#define SIGEMT    7
+#define SIGFPE    8
+#define SIGKILL   9
+#define SIGBUS    10
+#define SIGSEGV   11
+#define SIGSYS    12
+#define SIGPIPE   13
+#define SIGALRM   14
+#define SIGTERM   15
+#define SIGUSR1   16
+#define SIGUSR2   17
+#define SIGCHLD   18
+#define SIGPWR    19
+#define SIGWINCH  20
+#define SIGURG    21
+#define SIGIO     22
+#define SIGPOLL   SIGIO
+#define SIGSTOP   23
+#define SIGTSTP   24
+#define SIGCONT   25
+#define SIGTTIN   26
+#define SIGTTOU   27
+#define SIGVTALRM 28
+#define SIGPROF   29
+#define SIGXCPU   30
+#define SIGXFSZ   31
+#define SIGUNUSED SIGSYS
+
+#define _NSIG 128
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/socket.h b/zig/lib/libc/musl/arch/mipsn32/bits/socket.h
new file mode 100644
index 0000000000..02fbb88b4d
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/socket.h
@@ -0,0 +1,35 @@
+#define SOCK_STREAM    2
+#define SOCK_DGRAM     1
+
+#define SOL_SOCKET     65535
+
+#define SO_DEBUG        1
+
+#define SO_REUSEADDR    0x0004
+#define SO_KEEPALIVE    0x0008
+#define SO_DONTROUTE    0x0010
+#define SO_BROADCAST    0x0020
+#define SO_LINGER       0x0080
+#define SO_OOBINLINE    0x0100
+#define SO_REUSEPORT    0x0200
+#define SO_SNDBUF       0x1001
+#define SO_RCVBUF       0x1002
+#define SO_SNDLOWAT     0x1003
+#define SO_RCVLOWAT     0x1004
+#define SO_ERROR        0x1007
+#define SO_TYPE         0x1008
+#define SO_ACCEPTCONN   0x1009
+#define SO_PROTOCOL     0x1028
+#define SO_DOMAIN       0x1029
+
+#define SO_NO_CHECK     11
+#define SO_PRIORITY     12
+#define SO_BSDCOMPAT    14
+#define SO_PASSCRED     17
+#define SO_PEERCRED     18
+#define SO_PEERSEC      30
+#define SO_SNDBUFFORCE  31
+#define SO_RCVBUFFORCE  33
+
+#define SOCK_NONBLOCK     0200
+#define SOCK_CLOEXEC  02000000
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/stat.h b/zig/lib/libc/musl/arch/mipsn32/bits/stat.h
new file mode 100644
index 0000000000..6e2f280868
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/stat.h
@@ -0,0 +1,23 @@
+struct stat {
+	dev_t st_dev;
+	long __pad1[2];
+	ino_t st_ino;
+	mode_t st_mode;
+	nlink_t st_nlink;
+	uid_t st_uid;
+	gid_t st_gid;
+	dev_t st_rdev;
+	long __pad2[2];
+	off_t st_size;
+	struct {
+		long tv_sec;
+		long tv_nsec;
+	} __st_atim32, __st_mtim32, __st_ctim32;
+	blksize_t st_blksize;
+	long __pad3;
+	blkcnt_t st_blocks;
+	struct timespec st_atim;
+	struct timespec st_mtim;
+	struct timespec st_ctim;
+	long __pad4[2];
+};
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/statfs.h b/zig/lib/libc/musl/arch/mipsn32/bits/statfs.h
new file mode 100644
index 0000000000..a73bd547cd
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/statfs.h
@@ -0,0 +1,8 @@
+struct statfs {
+	unsigned long f_type, f_bsize, f_frsize;
+	fsblkcnt_t f_blocks, f_bfree;
+	fsfilcnt_t f_files, f_ffree;
+	fsblkcnt_t f_bavail;
+	fsid_t f_fsid;
+	unsigned long f_namelen, f_flags, f_spare[5];
+};
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/stdint.h b/zig/lib/libc/musl/arch/mipsn32/bits/stdint.h
new file mode 100644
index 0000000000..d1b2712199
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/stdint.h
@@ -0,0 +1,20 @@
+typedef int32_t int_fast16_t;
+typedef int32_t int_fast32_t;
+typedef uint32_t uint_fast16_t;
+typedef uint32_t uint_fast32_t;
+
+#define INT_FAST16_MIN  INT32_MIN
+#define INT_FAST32_MIN  INT32_MIN
+
+#define INT_FAST16_MAX  INT32_MAX
+#define INT_FAST32_MAX  INT32_MAX
+
+#define UINT_FAST16_MAX UINT32_MAX
+#define UINT_FAST32_MAX UINT32_MAX
+
+#define INTPTR_MIN      INT32_MIN
+#define INTPTR_MAX      INT32_MAX
+#define UINTPTR_MAX     UINT32_MAX
+#define PTRDIFF_MIN     INT32_MIN
+#define PTRDIFF_MAX     INT32_MAX
+#define SIZE_MAX        UINT32_MAX
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/termios.h b/zig/lib/libc/musl/arch/mipsn32/bits/termios.h
new file mode 100644
index 0000000000..9d571f78f6
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/termios.h
@@ -0,0 +1,169 @@
+struct termios {
+	tcflag_t c_iflag;
+	tcflag_t c_oflag;
+	tcflag_t c_cflag;
+	tcflag_t c_lflag;
+	cc_t c_line;
+	cc_t c_cc[NCCS];
+	speed_t __c_ispeed;
+	speed_t __c_ospeed;
+};
+
+#define VINTR     0
+#define VQUIT     1
+#define VERASE    2
+#define VKILL     3
+#define VMIN      4
+#define VTIME     5
+#define VEOL2     6
+#define VSWTC     7
+#define VSWTCH    7
+#define VSTART    8
+#define VSTOP     9
+#define VSUSP    10
+#define VREPRINT 12
+#define VDISCARD 13
+#define VWERASE  14
+#define VLNEXT   15
+#define VEOF     16
+#define VEOL     17
+
+#define IGNBRK  0000001
+#define BRKINT  0000002
+#define IGNPAR  0000004
+#define PARMRK  0000010
+#define INPCK   0000020
+#define ISTRIP  0000040
+#define INLCR   0000100
+#define IGNCR   0000200
+#define ICRNL   0000400
+#define IUCLC   0001000
+#define IXON    0002000
+#define IXANY   0004000
+#define IXOFF   0010000
+#define IMAXBEL 0020000
+#define IUTF8   0040000
+
+#define OPOST  0000001
+#define OLCUC  0000002
+#define ONLCR  0000004
+#define OCRNL  0000010
+#define ONOCR  0000020
+#define ONLRET 0000040
+#define OFILL  0000100
+#define OFDEL  0000200
+#if defined(_GNU_SOURCE) || defined(_BSD_SOURCE) || defined(_XOPEN_SOURCE)
+#define NLDLY  0000400
+#define NL0    0000000
+#define NL1    0000400
+#define CRDLY  0003000
+#define CR0    0000000
+#define CR1    0001000
+#define CR2    0002000
+#define CR3    0003000
+#define TABDLY 0014000
+#define TAB0   0000000
+#define TAB1   0004000
+#define TAB2   0010000
+#define TAB3   0014000
+#define BSDLY  0020000
+#define BS0    0000000
+#define BS1    0020000
+#define FFDLY  0100000
+#define FF0    0000000
+#define FF1    0100000
+#endif
+
+#define VTDLY  0040000
+#define VT0    0000000
+#define VT1    0040000
+
+#define B0       0000000
+#define B50      0000001
+#define B75      0000002
+#define B110     0000003
+#define B134     0000004
+#define B150     0000005
+#define B200     0000006
+#define B300     0000007
+#define B600     0000010
+#define B1200    0000011
+#define B1800    0000012
+#define B2400    0000013
+#define B4800    0000014
+#define B9600    0000015
+#define B19200   0000016
+#define B38400   0000017
+
+#define B57600   0010001
+#define B115200  0010002
+#define B230400  0010003
+#define B460800  0010004
+#define B500000  0010005
+#define B576000  0010006
+#define B921600  0010007
+#define B1000000 0010010
+#define B1152000 0010011
+#define B1500000 0010012
+#define B2000000 0010013
+#define B2500000 0010014
+#define B3000000 0010015
+#define B3500000 0010016
+#define B4000000 0010017
+
+#define CSIZE  0000060
+#define CS5    0000000
+#define CS6    0000020
+#define CS7    0000040
+#define CS8    0000060
+#define CSTOPB 0000100
+#define CREAD  0000200
+#define PARENB 0000400
+#define PARODD 0001000
+#define HUPCL  0002000
+#define CLOCAL 0004000
+
+#define ISIG   0000001
+#define ICANON 0000002
+#define ECHO   0000010
+#define ECHOE  0000020
+#define ECHOK  0000040
+#define ECHONL 0000100
+#define NOFLSH 0000200
+#define IEXTEN 0000400
+#define TOSTOP 0100000
+#define ITOSTOP 0100000
+
+#define TCOOFF 0
+#define TCOON  1
+#define TCIOFF 2
+#define TCION  3
+
+#define TCIFLUSH  0
+#define TCOFLUSH  1
+#define TCIOFLUSH 2
+
+#define TCSANOW   0
+#define TCSADRAIN 1
+#define TCSAFLUSH 2
+
+#if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+#define EXTA    0000016
+#define EXTB    0000017
+#define CBAUD   0010017
+#define CBAUDEX 0010000
+#define CIBAUD  002003600000
+#define CMSPAR  010000000000
+#define CRTSCTS 020000000000
+
+#define XCASE   0000004
+#define ECHOCTL 0001000
+#define ECHOPRT 0002000
+#define ECHOKE  0004000
+#define FLUSHO  0020000
+#define PENDIN  0040000
+#define EXTPROC 0200000
+
+#define XTABS  0014000
+#define TIOCSER_TEMT 1
+#endif
diff --git a/zig/lib/libc/musl/arch/mipsn32/bits/user.h b/zig/lib/libc/musl/arch/mipsn32/bits/user.h
new file mode 100644
index 0000000000..60fa1fda93
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/bits/user.h
@@ -0,0 +1,15 @@
+struct user {
+	unsigned long regs[102];
+	unsigned long u_tsize, u_dsize, u_ssize;
+	unsigned long long start_code, start_data, start_stack;
+	long long signal;
+	unsigned long long *u_ar0;
+	unsigned long long magic;
+	char u_comm[32];
+};
+
+#define ELF_NGREG 45
+#define ELF_NFPREG 33
+
+typedef unsigned long elf_greg_t, elf_gregset_t[ELF_NGREG];
+typedef double elf_fpreg_t, elf_fpregset_t[ELF_NFPREG];
diff --git a/zig/lib/libc/musl/arch/mipsn32/crt_arch.h b/zig/lib/libc/musl/arch/mipsn32/crt_arch.h
new file mode 100644
index 0000000000..eb5928ccb2
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/crt_arch.h
@@ -0,0 +1,32 @@
+__asm__(
+".set push\n"
+".set noreorder\n"
+".text \n"
+".global _" START "\n"
+".global " START "\n"
+".global " START "_data\n"
+".type   _" START ", @function\n"
+".type   " START ", @function\n"
+".type   " START "_data, @function\n"
+"_" START ":\n"
+"" START ":\n"
+"	bal 1f \n"
+"	move $fp, $0 \n"
+"" START "_data: \n"
+"	.gpword " START "_data \n"
+"	.gpword " START "_c \n"
+".weak _DYNAMIC \n"
+".hidden _DYNAMIC \n"
+"	.gpword _DYNAMIC \n"
+"1:	lw $gp, 0($ra) \n"
+"	subu $gp, $ra, $gp \n"
+"	move $4, $sp \n"
+"	lw $5, 8($ra) \n"
+"	addu $5, $5, $gp \n"
+"	lw $25, 4($ra) \n"
+"	addu $25, $25, $gp \n"
+"	and $sp, $sp, -8 \n"
+"	jalr $25 \n"
+"	subu $sp, $sp, 16 \n"
+".set pop \n"
+);
diff --git a/zig/lib/libc/musl/arch/mipsn32/ksigaction.h b/zig/lib/libc/musl/arch/mipsn32/ksigaction.h
new file mode 100644
index 0000000000..485abf756d
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/ksigaction.h
@@ -0,0 +1,10 @@
+#include <features.h>
+
+struct k_sigaction {
+	unsigned flags;
+	void (*handler)(int);
+	unsigned long mask[4];
+	void *unused;
+};
+
+hidden void __restore(), __restore_rt();
diff --git a/zig/lib/libc/musl/arch/mipsn32/kstat.h b/zig/lib/libc/musl/arch/mipsn32/kstat.h
new file mode 100644
index 0000000000..3841559c2c
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/kstat.h
@@ -0,0 +1,22 @@
+struct kstat {
+	unsigned st_dev;
+	long __pad1[3];
+	ino_t st_ino;
+	mode_t st_mode;
+	nlink_t st_nlink;
+	uid_t st_uid;
+	gid_t st_gid;
+	unsigned st_rdev;
+	long __pad2[3];
+	off_t st_size;
+	long st_atime_sec;
+	long st_atime_nsec;
+	long st_mtime_sec;
+	long st_mtime_nsec;
+	long st_ctime_sec;
+	long st_ctime_nsec;
+	blksize_t st_blksize;
+	long __pad3;
+	blkcnt_t st_blocks;
+	long __pad4[14];
+};
diff --git a/zig/lib/libc/musl/arch/mipsn32/pthread_arch.h b/zig/lib/libc/musl/arch/mipsn32/pthread_arch.h
new file mode 100644
index 0000000000..c45347ab92
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/pthread_arch.h
@@ -0,0 +1,19 @@
+static inline uintptr_t __get_tp()
+{
+#if __mips_isa_rev < 2
+	register uintptr_t tp __asm__("$3");
+	__asm__ (".word 0x7c03e83b" : "=r" (tp) );
+#else
+	uintptr_t tp;
+	__asm__ ("rdhwr %0, $29" : "=r" (tp) );
+#endif
+	return tp;
+}
+
+#define TLS_ABOVE_TP
+#define GAP_ABOVE_TP 0
+
+#define TP_OFFSET 0x7000
+#define DTP_OFFSET 0x8000
+
+#define MC_PC pc
diff --git a/zig/lib/libc/musl/arch/mipsn32/reloc.h b/zig/lib/libc/musl/arch/mipsn32/reloc.h
new file mode 100644
index 0000000000..bf00bd6afc
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/reloc.h
@@ -0,0 +1,51 @@
+#if __mips_isa_rev >= 6
+#define ISA_SUFFIX "r6"
+#else
+#define ISA_SUFFIX ""
+#endif
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+#define ENDIAN_SUFFIX "el"
+#else
+#define ENDIAN_SUFFIX ""
+#endif
+
+#ifdef __mips_soft_float
+#define FP_SUFFIX "-sf"
+#else
+#define FP_SUFFIX ""
+#endif
+
+#define LDSO_ARCH "mipsn32" ISA_SUFFIX ENDIAN_SUFFIX FP_SUFFIX
+
+#define TPOFF_K (-0x7000)
+
+#define REL_SYM_OR_REL  R_MIPS_REL32
+#define REL_PLT         R_MIPS_JUMP_SLOT
+#define REL_COPY        R_MIPS_COPY
+#define REL_DTPMOD      R_MIPS_TLS_DTPMOD32
+#define REL_DTPOFF      R_MIPS_TLS_DTPREL32
+#define REL_TPOFF       R_MIPS_TLS_TPREL32
+
+#define NEED_MIPS_GOT_RELOCS 1
+#define DT_DEBUG_INDIRECT DT_MIPS_RLD_MAP
+#define DT_DEBUG_INDIRECT_REL DT_MIPS_RLD_MAP_REL
+#define ARCH_SYM_REJECT_UND(s) (!((s)->st_other & STO_MIPS_PLT))
+
+#define CRTJMP(pc,sp) __asm__ __volatile__( \
+	"move $sp,%1 ; jr %0" : : "r"(pc), "r"(sp) : "memory" )
+
+#define GETFUNCSYM(fp, sym, got) __asm__ ( \
+	".hidden " #sym "\n" \
+	".set push \n" \
+	".set noreorder \n" \
+	"	bal 1f \n" \
+	"	nop \n" \
+	"	.gpword . \n" \
+	"	.gpword " #sym " \n" \
+	"1:	lw %0, ($ra) \n" \
+	"	subu %0, $ra, %0 \n" \
+	"	lw $ra, 4($ra) \n" \
+	"	addu %0, %0, $ra \n" \
+	".set pop \n" \
+	: "=r"(*(fp)) : : "memory", "ra" )
diff --git a/zig/lib/libc/musl/arch/mipsn32/syscall_arch.h b/zig/lib/libc/musl/arch/mipsn32/syscall_arch.h
new file mode 100644
index 0000000000..c681905d0f
--- /dev/null
+++ b/zig/lib/libc/musl/arch/mipsn32/syscall_arch.h
@@ -0,0 +1,130 @@
+#define __SYSCALL_LL_E(x) (x)
+#define __SYSCALL_LL_O(x) (x)
+
+#define SYSCALL_RLIM_INFINITY (-1UL/2)
+
+#if __mips_isa_rev >= 6
+#define SYSCALL_CLOBBERLIST \
+	"$1", "$3", "$10", "$11", "$12", "$13", \
+	"$14", "$15", "$24", "$25", "memory"
+#else
+#define SYSCALL_CLOBBERLIST \
+	"$1", "$3", "$10", "$11", "$12", "$13", \
+	"$14", "$15", "$24", "$25", "hi", "lo", "memory"
+#endif
+
+static inline long __syscall0(long n)
+{
+	register long r7 __asm__("$7");
+	register long r2 __asm__("$2");
+	__asm__ __volatile__ (
+		"daddu $2,$0,%2 ; syscall"
+		: "=&r"(r2), "=r"(r7)
+		: "ir"(n), "0"(r2)
+		: SYSCALL_CLOBBERLIST);
+	return r7 && r2>0 ? -r2 : r2;
+}
+
+static inline long __syscall1(long n, long a)
+{
+	register long r4 __asm__("$4") = a;
+	register long r7 __asm__("$7");
+	register long r2 __asm__("$2");
+	__asm__ __volatile__ (
+		"daddu $2,$0,%2 ; syscall"
+		: "=&r"(r2), "=r"(r7)
+		: "ir"(n), "0"(r2), "r"(r4)
+		: SYSCALL_CLOBBERLIST);
+	return r7 && r2>0 ? -r2 : r2;
+}
+
+static inline long __syscall2(long n, long a, long b)
+{
+	register long r4 __asm__("$4") = a;
+	register long r5 __asm__("$5") = b;
+	register long r7 __asm__("$7");
+	register long r2 __asm__("$2");
+
+	__asm__ __volatile__ (
+		"daddu $2,$0,%2 ; syscall"
+		: "=&r"(r2), "=r"(r7)
+		: "ir"(n), "0"(r2), "r"(r4), "r"(r5)
+		: SYSCALL_CLOBBERLIST);
+	return r7 && r2>0 ? -r2 : r2;
+}
+
+static inline long __syscall3(long n, long a, long b, long c)
+{
+	register long r4 __asm__("$4") = a;
+	register long r5 __asm__("$5") = b;
+	register long r6 __asm__("$6") = c;
+	register long r7 __asm__("$7");
+	register long r2 __asm__("$2");
+
+	__asm__ __volatile__ (
+		"daddu $2,$0,%2 ; syscall"
+		: "=&r"(r2), "=r"(r7)
+		: "ir"(n), "0"(r2), "r"(r4), "r"(r5), "r"(r6)
+		: SYSCALL_CLOBBERLIST);
+	return r7 && r2>0 ? -r2 : r2;
+}
+
+static inline long __syscall4(long n, long a, long b, long c, long d)
+{
+	register long r4 __asm__("$4") = a;
+	register long r5 __asm__("$5") = b;
+	register long r6 __asm__("$6") = c;
+	register long r7 __asm__("$7") = d;
+	register long r2 __asm__("$2");
+
+	__asm__ __volatile__ (
+		"daddu $2,$0,%2 ; syscall"
+		: "=&r"(r2), "+r"(r7)
+		: "ir"(n), "0"(r2), "r"(r4), "r"(r5), "r"(r6)
+		: SYSCALL_CLOBBERLIST);
+	return r7 && r2>0 ? -r2 : r2;
+}
+
+static inline long __syscall5(long n, long a, long b, long c, long d, long e)
+{
+	register long r4 __asm__("$4") = a;
+	register long r5 __asm__("$5") = b;
+	register long r6 __asm__("$6") = c;
+	register long r7 __asm__("$7") = d;
+	register long r8 __asm__("$8") = e;
+	register long r2 __asm__("$2");
+
+	__asm__ __volatile__ (
+		"daddu $2,$0,%2 ; syscall"
+		: "=&r"(r2), "+r"(r7)
+		: "ir"(n), "0"(r2), "r"(r4), "r"(r5), "r"(r6), "r"(r8)
+		: SYSCALL_CLOBBERLIST);
+	return r7 && r2>0 ? -r2 : r2;
+}
+
+static inline long __syscall6(long n, long a, long b, long c, long d, long e, long f)
+{
+	register long r4 __asm__("$4") = a;
+	register long r5 __asm__("$5") = b;
+	register long r6 __asm__("$6") = c;
+	register long r7 __asm__("$7") = d;
+	register long r8 __asm__("$8") = e;
+	register long r9 __asm__("$9") = f;
+	register long r2 __asm__("$2");
+
+	__asm__ __volatile__ (
+		"daddu $2,$0,%2 ; syscall"
+		: "=&r"(r2), "+r"(r7)
+		: "ir"(n), "0"(r2), "r"(r4), "r"(r5), "r"(r6), "r"(r8), "r"(r9)
+		: SYSCALL_CLOBBERLIST);
+	return r7 && r2>0 ? -r2 : r2;
+}
+
+#define VDSO_USEFUL
+#define VDSO_CGT32_SYM "__vdso_clock_gettime"
+#define VDSO_CGT32_VER "LINUX_2.6"
+#define VDSO_CGT_SYM "__vdso_clock_gettime64"
+#define VDSO_CGT_VER "LINUX_2.6"
+
+#define SO_SNDTIMEO_OLD 0x1005
+#define SO_RCVTIMEO_OLD 0x1006
diff --git a/zig/lib/libc/musl/arch/powerpc/bits/alltypes.h.in b/zig/lib/libc/musl/arch/powerpc/bits/alltypes.h.in
deleted file mode 100644
index b48df6a625..0000000000
--- a/zig/lib/libc/musl/arch/powerpc/bits/alltypes.h.in
+++ /dev/null
@@ -1,20 +0,0 @@
-#define _REDIR_TIME64 1
-#define _Addr int
-#define _Int64 long long
-#define _Reg int
-
-#define __BYTE_ORDER 4321
-#define __LONG_MAX 0x7fffffffL
-
-#ifndef __cplusplus
-#ifdef __WCHAR_TYPE__
-TYPEDEF __WCHAR_TYPE__ wchar_t;
-#else
-TYPEDEF long wchar_t;
-#endif
-#endif
-
-TYPEDEF float float_t;
-TYPEDEF double double_t;
-
-TYPEDEF struct { long long __ll; long double __ld; } max_align_t;
diff --git a/zig/lib/libc/musl/arch/powerpc/bits/syscall.h.in b/zig/lib/libc/musl/arch/powerpc/bits/syscall.h.in
deleted file mode 100644
index ea95f3ed1e..0000000000
--- a/zig/lib/libc/musl/arch/powerpc/bits/syscall.h.in
+++ /dev/null
@@ -1,433 +0,0 @@
-#define __NR_restart_syscall          0
-#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_waitpid                  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_break                   17
-#define __NR_oldstat                 18
-#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_oldfstat                28
-#define __NR_pause                   29
-#define __NR_utime                   30
-#define __NR_stty                    31
-#define __NR_gtty                    32
-#define __NR_access                  33
-#define __NR_nice                    34
-#define __NR_ftime                   35
-#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_prof                    44
-#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_lock                    53
-#define __NR_ioctl                   54
-#define __NR_fcntl                   55
-#define __NR_mpx                     56
-#define __NR_setpgid                 57
-#define __NR_ulimit                  58
-#define __NR_oldolduname             59
-#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_sgetmask                68
-#define __NR_ssetmask                69
-#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_time32            78
-#define __NR_settimeofday_time32            79
-#define __NR_getgroups               80
-#define __NR_setgroups               81
-#define __NR_select                  82
-#define __NR_symlink                 83
-#define __NR_oldlstat                84
-#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_profil                  98
-#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_olduname               109
-#define __NR_iopl                   110
-#define __NR_vhangup                111
-#define __NR_idle                   112
-#define __NR_vm86                   113
-#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_modify_ldt             123
-#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           166
-#define __NR_poll                   167
-#define __NR_nfsservctl             168
-#define __NR_setresgid              169
-#define __NR_getresgid              170
-#define __NR_prctl                  171
-#define __NR_rt_sigreturn           172
-#define __NR_rt_sigaction           173
-#define __NR_rt_sigprocmask         174
-#define __NR_rt_sigpending          175
-#define __NR_rt_sigtimedwait        176
-#define __NR_rt_sigqueueinfo        177
-#define __NR_rt_sigsuspend          178
-#define __NR_pread64                179
-#define __NR_pwrite64               180
-#define __NR_chown                  181
-#define __NR_getcwd                 182
-#define __NR_capget                 183
-#define __NR_capset                 184
-#define __NR_sigaltstack            185
-#define __NR_sendfile               186
-#define __NR_getpmsg                187
-#define __NR_putpmsg                188
-#define __NR_vfork                  189
-#define __NR_ugetrlimit             190
-#define __NR_readahead              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_pciconfig_read         198
-#define __NR_pciconfig_write        199
-#define __NR_pciconfig_iobase       200
-#define __NR_multiplexer            201
-#define __NR_getdents64             202
-#define __NR_pivot_root             203
-#define __NR_fcntl64                204
-#define __NR_madvise                205
-#define __NR_mincore                206
-#define __NR_gettid                 207
-#define __NR_tkill                  208
-#define __NR_setxattr               209
-#define __NR_lsetxattr              210
-#define __NR_fsetxattr              211
-#define __NR_getxattr               212
-#define __NR_lgetxattr              213
-#define __NR_fgetxattr              214
-#define __NR_listxattr              215
-#define __NR_llistxattr             216
-#define __NR_flistxattr             217
-#define __NR_removexattr            218
-#define __NR_lremovexattr           219
-#define __NR_fremovexattr           220
-#define __NR_futex                  221
-#define __NR_sched_setaffinity      222
-#define __NR_sched_getaffinity      223
-#define __NR_tuxcall                225
-#define __NR_sendfile64             226
-#define __NR_io_setup               227
-#define __NR_io_destroy             228
-#define __NR_io_getevents           229
-#define __NR_io_submit              230
-#define __NR_io_cancel              231
-#define __NR_set_tid_address        232
-#define __NR_fadvise64              233
-#define __NR_exit_group             234
-#define __NR_lookup_dcookie         235
-#define __NR_epoll_create           236
-#define __NR_epoll_ctl              237
-#define __NR_epoll_wait             238
-#define __NR_remap_file_pages       239
-#define __NR_timer_create           240
-#define __NR_timer_settime32          241
-#define __NR_timer_gettime32          242
-#define __NR_timer_getoverrun       243
-#define __NR_timer_delete           244
-#define __NR_clock_settime32          245
-#define __NR_clock_gettime32          246
-#define __NR_clock_getres_time32           247
-#define __NR_clock_nanosleep_time32        248
-#define __NR_swapcontext            249
-#define __NR_tgkill                 250
-#define __NR_utimes                 251
-#define __NR_statfs64               252
-#define __NR_fstatfs64              253
-#define __NR_fadvise64_64           254
-#define __NR_rtas		255
-#define __NR_sys_debug_setcontext 256
-#define __NR_migrate_pages	258
-#define __NR_mbind		259
-#define __NR_get_mempolicy	260
-#define __NR_set_mempolicy	261
-#define __NR_mq_open		262
-#define __NR_mq_unlink		263
-#define __NR_mq_timedsend	264
-#define __NR_mq_timedreceive	265
-#define __NR_mq_notify		266
-#define __NR_mq_getsetattr	267
-#define __NR_kexec_load		268
-#define __NR_add_key		269
-#define __NR_request_key	270
-#define __NR_keyctl		271
-#define __NR_waitid		272
-#define __NR_ioprio_set		273
-#define __NR_ioprio_get		274
-#define __NR_inotify_init	275
-#define __NR_inotify_add_watch	276
-#define __NR_inotify_rm_watch	277
-#define __NR_spu_run		278
-#define __NR_spu_create		279
-#define __NR_pselect6		280
-#define __NR_ppoll		281
-#define __NR_unshare		282
-#define __NR_splice		283
-#define __NR_tee		284
-#define __NR_vmsplice		285
-#define __NR_openat		286
-#define __NR_mkdirat		287
-#define __NR_mknodat		288
-#define __NR_fchownat		289
-#define __NR_futimesat		290
-#define __NR_fstatat64		291
-#define __NR_unlinkat		292
-#define __NR_renameat		293
-#define __NR_linkat		294
-#define __NR_symlinkat		295
-#define __NR_readlinkat		296
-#define __NR_fchmodat		297
-#define __NR_faccessat		298
-#define __NR_get_robust_list	299
-#define __NR_set_robust_list	300
-#define __NR_move_pages		301
-#define __NR_getcpu		302
-#define __NR_epoll_pwait	303
-#define __NR_utimensat		304
-#define __NR_signalfd		305
-#define __NR_timerfd_create     306
-#define __NR_eventfd		307
-#define __NR_sync_file_range2	308
-#define __NR_fallocate		309
-#define __NR_subpage_prot		310
-#define __NR_timerfd_settime32	311
-#define __NR_timerfd_gettime32	312
-#define __NR_signalfd4		313
-#define __NR_eventfd2		314
-#define __NR_epoll_create1	315
-#define __NR_dup3			316
-#define __NR_pipe2		317
-#define __NR_inotify_init1	318
-#define __NR_perf_event_open       319
-#define __NR_preadv                320
-#define __NR_pwritev               321
-#define __NR_rt_tgsigqueueinfo     322
-#define __NR_fanotify_init         323
-#define __NR_fanotify_mark         324
-#define __NR_prlimit64             325
-#define __NR_socket                326
-#define __NR_bind                  327
-#define __NR_connect               328
-#define __NR_listen                329
-#define __NR_accept                330
-#define __NR_getsockname           331
-#define __NR_getpeername           332
-#define __NR_socketpair            333
-#define __NR_send                  334
-#define __NR_sendto                335
-#define __NR_recv                  336
-#define __NR_recvfrom              337
-#define __NR_shutdown              338
-#define __NR_setsockopt            339
-#define __NR_getsockopt            340
-#define __NR_sendmsg               341
-#define __NR_recvmsg               342
-#define __NR_recvmmsg              343
-#define __NR_accept4               344
-#define __NR_name_to_handle_at     345
-#define __NR_open_by_handle_at     346
-#define __NR_clock_adjtime         347
-#define __NR_syncfs                348
-#define __NR_sendmmsg              349
-#define __NR_setns                 350
-#define __NR_process_vm_readv      351
-#define __NR_process_vm_writev     352
-#define __NR_finit_module          353
-#define __NR_kcmp                  354
-#define __NR_sched_setattr         355
-#define __NR_sched_getattr         356
-#define __NR_renameat2             357
-#define __NR_seccomp               358
-#define __NR_getrandom             359
-#define __NR_memfd_create          360
-#define __NR_bpf                   361
-#define __NR_execveat              362
-#define __NR_switch_endian         363
-#define __NR_userfaultfd           364
-#define __NR_membarrier            365
-#define __NR_mlock2                378
-#define __NR_copy_file_range       379
-#define __NR_preadv2               380
-#define __NR_pwritev2              381
-#define __NR_kexec_file_load       382
-#define __NR_statx                 383
-#define __NR_pkey_alloc            384
-#define __NR_pkey_free             385
-#define __NR_pkey_mprotect         386
-#define __NR_rseq                  387
-#define __NR_io_pgetevents         388
-#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_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
-
diff --git a/zig/lib/libc/musl/arch/powerpc64/bits/alltypes.h.in b/zig/lib/libc/musl/arch/powerpc64/bits/alltypes.h.in
deleted file mode 100644
index 143ffa8d25..0000000000
--- a/zig/lib/libc/musl/arch/powerpc64/bits/alltypes.h.in
+++ /dev/null
@@ -1,20 +0,0 @@
-#define _Addr long
-#define _Int64 long
-#define _Reg long
-
-#if __BIG_ENDIAN__
-#define __BYTE_ORDER 4321
-#else
-#define __BYTE_ORDER 1234
-#endif
-
-#define __LONG_MAX 0x7fffffffffffffffL
-
-#ifndef __cplusplus
-TYPEDEF int wchar_t;
-#endif
-
-TYPEDEF float float_t;
-TYPEDEF double double_t;
-
-TYPEDEF struct { long long __ll; long double __ld; } max_align_t;
diff --git a/zig/lib/libc/musl/arch/powerpc64/bits/syscall.h.in b/zig/lib/libc/musl/arch/powerpc64/bits/syscall.h.in
deleted file mode 100644
index 435510796a..0000000000
--- a/zig/lib/libc/musl/arch/powerpc64/bits/syscall.h.in
+++ /dev/null
@@ -1,405 +0,0 @@
-#define __NR_restart_syscall          0
-#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_waitpid                  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_break                   17
-#define __NR_oldstat                 18
-#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_oldfstat                28
-#define __NR_pause                   29
-#define __NR_utime                   30
-#define __NR_stty                    31
-#define __NR_gtty                    32
-#define __NR_access                  33
-#define __NR_nice                    34
-#define __NR_ftime                   35
-#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_prof                    44
-#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_lock                    53
-#define __NR_ioctl                   54
-#define __NR_fcntl                   55
-#define __NR_mpx                     56
-#define __NR_setpgid                 57
-#define __NR_ulimit                  58
-#define __NR_oldolduname             59
-#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_sgetmask                68
-#define __NR_ssetmask                69
-#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_select                  82
-#define __NR_symlink                 83
-#define __NR_oldlstat                84
-#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_profil                  98
-#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_olduname               109
-#define __NR_iopl                   110
-#define __NR_vhangup                111
-#define __NR_idle                   112
-#define __NR_vm86                   113
-#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_modify_ldt             123
-#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           166
-#define __NR_poll                   167
-#define __NR_nfsservctl             168
-#define __NR_setresgid              169
-#define __NR_getresgid              170
-#define __NR_prctl                  171
-#define __NR_rt_sigreturn           172
-#define __NR_rt_sigaction           173
-#define __NR_rt_sigprocmask         174
-#define __NR_rt_sigpending          175
-#define __NR_rt_sigtimedwait        176
-#define __NR_rt_sigqueueinfo        177
-#define __NR_rt_sigsuspend          178
-#define __NR_pread64                179
-#define __NR_pwrite64               180
-#define __NR_chown                  181
-#define __NR_getcwd                 182
-#define __NR_capget                 183
-#define __NR_capset                 184
-#define __NR_sigaltstack            185
-#define __NR_sendfile               186
-#define __NR_getpmsg                187
-#define __NR_putpmsg                188
-#define __NR_vfork                  189
-#define __NR_ugetrlimit             190
-#define __NR_readahead              191
-#define __NR_pciconfig_read         198
-#define __NR_pciconfig_write        199
-#define __NR_pciconfig_iobase       200
-#define __NR_multiplexer            201
-#define __NR_getdents64             202
-#define __NR_pivot_root             203
-#define __NR_madvise                205
-#define __NR_mincore                206
-#define __NR_gettid                 207
-#define __NR_tkill                  208
-#define __NR_setxattr               209
-#define __NR_lsetxattr              210
-#define __NR_fsetxattr              211
-#define __NR_getxattr               212
-#define __NR_lgetxattr              213
-#define __NR_fgetxattr              214
-#define __NR_listxattr              215
-#define __NR_llistxattr             216
-#define __NR_flistxattr             217
-#define __NR_removexattr            218
-#define __NR_lremovexattr           219
-#define __NR_fremovexattr           220
-#define __NR_futex                  221
-#define __NR_sched_setaffinity      222
-#define __NR_sched_getaffinity      223
-#define __NR_tuxcall                225
-#define __NR_io_setup               227
-#define __NR_io_destroy             228
-#define __NR_io_getevents           229
-#define __NR_io_submit              230
-#define __NR_io_cancel              231
-#define __NR_set_tid_address        232
-#define __NR_fadvise64              233
-#define __NR_exit_group             234
-#define __NR_lookup_dcookie         235
-#define __NR_epoll_create           236
-#define __NR_epoll_ctl              237
-#define __NR_epoll_wait             238
-#define __NR_remap_file_pages       239
-#define __NR_timer_create           240
-#define __NR_timer_settime          241
-#define __NR_timer_gettime          242
-#define __NR_timer_getoverrun       243
-#define __NR_timer_delete           244
-#define __NR_clock_settime          245
-#define __NR_clock_gettime          246
-#define __NR_clock_getres           247
-#define __NR_clock_nanosleep        248
-#define __NR_swapcontext            249
-#define __NR_tgkill                 250
-#define __NR_utimes                 251
-#define __NR_statfs64               252
-#define __NR_fstatfs64              253
-#define __NR_rtas                   255
-#define __NR_sys_debug_setcontext   256
-#define __NR_migrate_pages          258
-#define __NR_mbind                  259
-#define __NR_get_mempolicy          260
-#define __NR_set_mempolicy          261
-#define __NR_mq_open                262
-#define __NR_mq_unlink              263
-#define __NR_mq_timedsend           264
-#define __NR_mq_timedreceive        265
-#define __NR_mq_notify              266
-#define __NR_mq_getsetattr          267
-#define __NR_kexec_load             268
-#define __NR_add_key                269
-#define __NR_request_key            270
-#define __NR_keyctl                 271
-#define __NR_waitid                 272
-#define __NR_ioprio_set             273
-#define __NR_ioprio_get             274
-#define __NR_inotify_init           275
-#define __NR_inotify_add_watch      276
-#define __NR_inotify_rm_watch       277
-#define __NR_spu_run                278
-#define __NR_spu_create             279
-#define __NR_pselect6               280
-#define __NR_ppoll                  281
-#define __NR_unshare                282
-#define __NR_splice                 283
-#define __NR_tee                    284
-#define __NR_vmsplice               285
-#define __NR_openat                 286
-#define __NR_mkdirat                287
-#define __NR_mknodat                288
-#define __NR_fchownat               289
-#define __NR_futimesat              290
-#define __NR_newfstatat             291
-#define __NR_unlinkat               292
-#define __NR_renameat               293
-#define __NR_linkat                 294
-#define __NR_symlinkat              295
-#define __NR_readlinkat             296
-#define __NR_fchmodat               297
-#define __NR_faccessat              298
-#define __NR_get_robust_list        299
-#define __NR_set_robust_list        300
-#define __NR_move_pages             301
-#define __NR_getcpu                 302
-#define __NR_epoll_pwait            303
-#define __NR_utimensat              304
-#define __NR_signalfd               305
-#define __NR_timerfd_create         306
-#define __NR_eventfd                307
-#define __NR_sync_file_range2       308
-#define __NR_fallocate              309
-#define __NR_subpage_prot           310
-#define __NR_timerfd_settime        311
-#define __NR_timerfd_gettime        312
-#define __NR_signalfd4              313
-#define __NR_eventfd2               314
-#define __NR_epoll_create1          315
-#define __NR_dup3                   316
-#define __NR_pipe2                  317
-#define __NR_inotify_init1          318
-#define __NR_perf_event_open        319
-#define __NR_preadv                 320
-#define __NR_pwritev                321
-#define __NR_rt_tgsigqueueinfo      322
-#define __NR_fanotify_init          323
-#define __NR_fanotify_mark          324
-#define __NR_prlimit64              325
-#define __NR_socket                 326
-#define __NR_bind                   327
-#define __NR_connect                328
-#define __NR_listen                 329
-#define __NR_accept                 330
-#define __NR_getsockname            331
-#define __NR_getpeername            332
-#define __NR_socketpair             333
-#define __NR_send                   334
-#define __NR_sendto                 335
-#define __NR_recv                   336
-#define __NR_recvfrom               337
-#define __NR_shutdown               338
-#define __NR_setsockopt             339
-#define __NR_getsockopt             340
-#define __NR_sendmsg                341
-#define __NR_recvmsg                342
-#define __NR_recvmmsg               343
-#define __NR_accept4                344
-#define __NR_name_to_handle_at      345
-#define __NR_open_by_handle_at      346
-#define __NR_clock_adjtime          347
-#define __NR_syncfs                 348
-#define __NR_sendmmsg               349
-#define __NR_setns                  350
-#define __NR_process_vm_readv       351
-#define __NR_process_vm_writev      352
-#define __NR_finit_module           353
-#define __NR_kcmp                   354
-#define __NR_sched_setattr          355
-#define __NR_sched_getattr          356
-#define __NR_renameat2              357
-#define __NR_seccomp                358
-#define __NR_getrandom              359
-#define __NR_memfd_create           360
-#define __NR_bpf                    361
-#define __NR_execveat               362
-#define __NR_switch_endian          363
-#define __NR_userfaultfd            364
-#define __NR_membarrier             365
-#define __NR_mlock2                 378
-#define __NR_copy_file_range        379
-#define __NR_preadv2                380
-#define __NR_pwritev2               381
-#define __NR_kexec_file_load        382
-#define __NR_statx                  383
-#define __NR_pkey_alloc             384
-#define __NR_pkey_free              385
-#define __NR_pkey_mprotect          386
-#define __NR_rseq                   387
-#define __NR_io_pgetevents          388
-#define __NR_semtimedop             392
-#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_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_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
-
diff --git a/zig/lib/libc/musl/arch/riscv32/bits/alltypes.h.in b/zig/lib/libc/musl/arch/riscv32/bits/alltypes.h.in
deleted file mode 100644
index e2b6129e46..0000000000
--- a/zig/lib/libc/musl/arch/riscv32/bits/alltypes.h.in
+++ /dev/null
@@ -1,18 +0,0 @@
-#define _Addr int
-#define _Int64 long long
-#define _Reg int
-
-#define __BYTE_ORDER 1234
-#define __LONG_MAX 0x7fffffffL
-
-#ifndef __cplusplus
-TYPEDEF int wchar_t;
-#endif
-
-TYPEDEF int blksize_t;
-TYPEDEF unsigned int nlink_t;
-
-TYPEDEF float float_t;
-TYPEDEF double double_t;
-
-TYPEDEF struct { long long __ll; long double __ld; } max_align_t;
diff --git a/zig/lib/libc/musl/arch/riscv32/bits/syscall.h.in b/zig/lib/libc/musl/arch/riscv32/bits/syscall.h.in
deleted file mode 100644
index 9228d84089..0000000000
--- a/zig/lib/libc/musl/arch/riscv32/bits/syscall.h.in
+++ /dev/null
@@ -1,300 +0,0 @@
-#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_nanosleep 101
-#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_arch_specific_syscall 244
-#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_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_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_futex __NR_futex_time64
-
-#define __NR_sysriscv __NR_arch_specific_syscall
-#define __NR_riscv_flush_icache (__NR_sysriscv + 15)
diff --git a/zig/lib/libc/musl/arch/riscv64/bits/alltypes.h.in b/zig/lib/libc/musl/arch/riscv64/bits/alltypes.h.in
deleted file mode 100644
index 4579d1740b..0000000000
--- a/zig/lib/libc/musl/arch/riscv64/bits/alltypes.h.in
+++ /dev/null
@@ -1,18 +0,0 @@
-#define _Addr long
-#define _Int64 long
-#define _Reg long
-
-#define __BYTE_ORDER 1234
-#define __LONG_MAX 0x7fffffffffffffffL
-
-#ifndef __cplusplus
-TYPEDEF int wchar_t;
-#endif
-
-TYPEDEF int blksize_t;
-TYPEDEF unsigned int nlink_t;
-
-TYPEDEF float float_t;
-TYPEDEF double double_t;
-
-TYPEDEF struct { long long __ll; long double __ld; } max_align_t;
diff --git a/zig/lib/libc/musl/arch/riscv64/bits/syscall.h.in b/zig/lib/libc/musl/arch/riscv64/bits/syscall.h.in
deleted file mode 100644
index e362bd0ec5..0000000000
--- a/zig/lib/libc/musl/arch/riscv64/bits/syscall.h.in
+++ /dev/null
@@ -1,309 +0,0 @@
-#define __NR_io_setup 0
-#define __NR_io_destroy 1
-#define __NR_io_submit 2
-#define __NR_io_cancel 3
-#define __NR_io_getevents 4
-#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_fcntl 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_statfs 43
-#define __NR_fstatfs 44
-#define __NR_truncate 45
-#define __NR_ftruncate 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_lseek 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_sendfile 71
-#define __NR_pselect6 72
-#define __NR_ppoll 73
-#define __NR_signalfd4 74
-#define __NR_vmsplice 75
-#define __NR_splice 76
-#define __NR_tee 77
-#define __NR_readlinkat 78
-#define __NR_newfstatat 79
-#define __NR_fstat 80
-#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_timerfd_settime 86
-#define __NR_timerfd_gettime 87
-#define __NR_utimensat 88
-#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_futex 98
-#define __NR_set_robust_list 99
-#define __NR_get_robust_list 100
-#define __NR_nanosleep 101
-#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_gettime 108
-#define __NR_timer_getoverrun 109
-#define __NR_timer_settime 110
-#define __NR_timer_delete 111
-#define __NR_clock_settime 112
-#define __NR_clock_gettime 113
-#define __NR_clock_getres 114
-#define __NR_clock_nanosleep 115
-#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_sched_rr_get_interval 127
-#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_sigtimedwait 137
-#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_getrlimit 163
-#define __NR_setrlimit 164
-#define __NR_getrusage 165
-#define __NR_umask 166
-#define __NR_prctl 167
-#define __NR_getcpu 168
-#define __NR_gettimeofday 169
-#define __NR_settimeofday 170
-#define __NR_adjtimex 171
-#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_timedsend 182
-#define __NR_mq_timedreceive 183
-#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_semtimedop 192
-#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_mmap 222
-#define __NR_fadvise64 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_recvmmsg 243
-#define __NR_arch_specific_syscall 244
-#define __NR_wait4 260
-#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_clock_adjtime 266
-#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_io_pgetevents 292
-#define __NR_rseq 293
-#define __NR_kexec_file_load 294
-#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_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_sysriscv __NR_arch_specific_syscall
-#define __NR_riscv_flush_icache (__NR_sysriscv + 15)
diff --git a/zig/lib/libc/musl/arch/s390x/bits/alltypes.h.in b/zig/lib/libc/musl/arch/s390x/bits/alltypes.h.in
deleted file mode 100644
index 6c0eb7f4b8..0000000000
--- a/zig/lib/libc/musl/arch/s390x/bits/alltypes.h.in
+++ /dev/null
@@ -1,19 +0,0 @@
-#define _Addr long
-#define _Int64 long
-#define _Reg long
-
-#define __BYTE_ORDER 4321
-#define __LONG_MAX 0x7fffffffffffffffL
-
-#ifndef __cplusplus
-TYPEDEF int wchar_t;
-#endif
-
-#if defined(__FLT_EVAL_METHOD__) && __FLT_EVAL_METHOD__ == 1
-TYPEDEF double float_t;
-#else
-TYPEDEF float float_t;
-#endif
-TYPEDEF double double_t;
-
-TYPEDEF struct { long long __ll; long double __ld; } max_align_t;
diff --git a/zig/lib/libc/musl/arch/s390x/bits/syscall.h.in b/zig/lib/libc/musl/arch/s390x/bits/syscall.h.in
deleted file mode 100644
index e60711a6e1..0000000000
--- a/zig/lib/libc/musl/arch/s390x/bits/syscall.h.in
+++ /dev/null
@@ -1,371 +0,0 @@
-#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_mknod                       14
-#define __NR_chmod                       15
-#define __NR_lseek                       19
-#define __NR_getpid                      20
-#define __NR_mount                       21
-#define __NR_umount                      22
-#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_signal                      48
-#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_sigsuspend                  72
-#define __NR_sigpending                  73
-#define __NR_sethostname                 74
-#define __NR_setrlimit                   75
-#define __NR_getrusage                   77
-#define __NR_gettimeofday                78
-#define __NR_settimeofday                79
-#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_getpriority                 96
-#define __NR_setpriority                 97
-#define __NR_statfs                      99
-#define __NR_fstatfs                    100
-#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_getdents                   141
-#define __NR_select                     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_query_module               167
-#define __NR_poll                       168
-#define __NR_nfsservctl                 169
-#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_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_getrlimit                  191
-#define __NR_lchown                     198
-#define __NR_getuid                     199
-#define __NR_getgid                     200
-#define __NR_geteuid                    201
-#define __NR_getegid                    202
-#define __NR_setreuid                   203
-#define __NR_setregid                   204
-#define __NR_getgroups                  205
-#define __NR_setgroups                  206
-#define __NR_fchown                     207
-#define __NR_setresuid                  208
-#define __NR_getresuid                  209
-#define __NR_setresgid                  210
-#define __NR_getresgid                  211
-#define __NR_chown                      212
-#define __NR_setuid                     213
-#define __NR_setgid                     214
-#define __NR_setfsuid                   215
-#define __NR_setfsgid                   216
-#define __NR_pivot_root                 217
-#define __NR_mincore                    218
-#define __NR_madvise                    219
-#define __NR_getdents64                 220
-#define __NR_readahead                  222
-#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_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_newfstatat                 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_semtimedop                 392
-#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_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_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
-
diff --git a/zig/lib/libc/musl/arch/x32/atomic_arch.h b/zig/lib/libc/musl/arch/x32/atomic_arch.h
new file mode 100644
index 0000000000..918c2d4eec
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/atomic_arch.h
@@ -0,0 +1,121 @@
+#define a_cas a_cas
+static inline int a_cas(volatile int *p, int t, int s)
+{
+	__asm__ __volatile__ (
+		"lock ; cmpxchg %3, %1"
+		: "=a"(t), "=m"(*p) : "a"(t), "r"(s) : "memory" );
+	return t;
+}
+
+#define a_swap a_swap
+static inline int a_swap(volatile int *p, int v)
+{
+	__asm__ __volatile__(
+		"xchg %0, %1"
+		: "=r"(v), "=m"(*p) : "0"(v) : "memory" );
+	return v;
+}
+
+#define a_fetch_add a_fetch_add
+static inline int a_fetch_add(volatile int *p, int v)
+{
+	__asm__ __volatile__(
+		"lock ; xadd %0, %1"
+		: "=r"(v), "=m"(*p) : "0"(v) : "memory" );
+	return v;
+}
+
+#define a_and a_and
+static inline void a_and(volatile int *p, int v)
+{
+	__asm__ __volatile__(
+		"lock ; and %1, %0"
+		: "=m"(*p) : "r"(v) : "memory" );
+}
+
+#define a_or a_or
+static inline void a_or(volatile int *p, int v)
+{
+	__asm__ __volatile__(
+		"lock ; or %1, %0"
+		: "=m"(*p) : "r"(v) : "memory" );
+}
+
+#define a_and_64 a_and_64
+static inline void a_and_64(volatile uint64_t *p, uint64_t v)
+{
+	__asm__ __volatile(
+		"lock ; and %1, %0"
+		 : "=m"(*p) : "r"(v) : "memory" );
+}
+
+#define a_or_64 a_or_64
+static inline void a_or_64(volatile uint64_t *p, uint64_t v)
+{
+	__asm__ __volatile__(
+		"lock ; or %1, %0"
+		 : "=m"(*p) : "r"(v) : "memory" );
+}
+
+#define a_inc a_inc
+static inline void a_inc(volatile int *p)
+{
+	__asm__ __volatile__(
+		"lock ; incl %0"
+		: "=m"(*p) : "m"(*p) : "memory" );
+}
+
+#define a_dec a_dec
+static inline void a_dec(volatile int *p)
+{
+	__asm__ __volatile__(
+		"lock ; decl %0"
+		: "=m"(*p) : "m"(*p) : "memory" );
+}
+
+#define a_store a_store
+static inline void a_store(volatile int *p, int x)
+{
+	__asm__ __volatile__(
+		"mov %1, %0 ; lock ; orl $0,(%%rsp)"
+		: "=m"(*p) : "r"(x) : "memory" );
+}
+
+#define a_barrier a_barrier
+static inline void a_barrier()
+{
+	__asm__ __volatile__( "" : : : "memory" );
+}
+
+#define a_spin a_spin
+static inline void a_spin()
+{
+	__asm__ __volatile__( "pause" : : : "memory" );
+}
+
+#define a_crash a_crash
+static inline void a_crash()
+{
+	__asm__ __volatile__( "hlt" : : : "memory" );
+}
+
+#define a_ctz_64 a_ctz_64
+static inline int a_ctz_64(uint64_t x)
+{
+	__asm__( "bsf %1,%0" : "=r"(x) : "r"(x) );
+	return x;
+}
+
+#define a_ctz_32 a_ctz_32
+static inline int a_ctz_32(uint32_t x)
+{
+	__asm__( "bsf %1,%0" : "=r"(x) : "r"(x) );
+	return x;
+}
+
+#define a_clz_64 a_clz_64
+static inline int a_clz_64(uint64_t x)
+{
+	__asm__( "bsr %1,%0 ; xor $63,%0" : "=r"(x) : "r"(x) );
+	return x;
+}
diff --git a/zig/lib/libc/musl/arch/x32/bits/fcntl.h b/zig/lib/libc/musl/arch/x32/bits/fcntl.h
new file mode 100644
index 0000000000..08627f812a
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/fcntl.h
@@ -0,0 +1,40 @@
+#define O_CREAT        0100
+#define O_EXCL         0200
+#define O_NOCTTY       0400
+#define O_TRUNC       01000
+#define O_APPEND      02000
+#define O_NONBLOCK    04000
+#define O_DSYNC      010000
+#define O_SYNC     04010000
+#define O_RSYNC    04010000
+#define O_DIRECTORY 0200000
+#define O_NOFOLLOW  0400000
+#define O_CLOEXEC  02000000
+
+#define O_ASYNC      020000
+#define O_DIRECT     040000
+#define O_LARGEFILE 0100000
+#define O_NOATIME  01000000
+#define O_PATH    010000000
+#define O_TMPFILE 020200000
+#define O_NDELAY O_NONBLOCK
+
+#define F_DUPFD  0
+#define F_GETFD  1
+#define F_SETFD  2
+#define F_GETFL  3
+#define F_SETFL  4
+
+#define F_SETOWN 8
+#define F_GETOWN 9
+#define F_SETSIG 10
+#define F_GETSIG 11
+
+#define F_GETLK 5
+#define F_SETLK 6
+#define F_SETLKW 7
+
+#define F_SETOWN_EX 15
+#define F_GETOWN_EX 16
+
+#define F_GETOWNER_UIDS 17
diff --git a/zig/lib/libc/musl/arch/x32/bits/fenv.h b/zig/lib/libc/musl/arch/x32/bits/fenv.h
new file mode 100644
index 0000000000..24df0417f2
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/fenv.h
@@ -0,0 +1,34 @@
+#define FE_INVALID    1
+#define __FE_DENORM   2
+#define FE_DIVBYZERO  4
+#define FE_OVERFLOW   8
+#define FE_UNDERFLOW  16
+#define FE_INEXACT    32
+
+#define FE_ALL_EXCEPT 63
+
+#define FE_TONEAREST  0
+#define FE_DOWNWARD   0x400
+#define FE_UPWARD     0x800
+#define FE_TOWARDZERO 0xc00
+
+typedef unsigned short fexcept_t;
+
+typedef struct {
+	unsigned short __control_word;
+	unsigned short __unused1;
+	unsigned short __status_word;
+	unsigned short __unused2;
+	unsigned short __tags;
+	unsigned short __unused3;
+	unsigned int __eip;
+	unsigned short __cs_selector;
+	unsigned int __opcode:11;
+	unsigned int __unused4:5;
+	unsigned int __data_offset;
+	unsigned short __data_selector;
+	unsigned short __unused5;
+	unsigned int __mxcsr;
+} fenv_t;
+
+#define FE_DFL_ENV      ((const fenv_t *) -1)
diff --git a/zig/lib/libc/musl/arch/x32/bits/float.h b/zig/lib/libc/musl/arch/x32/bits/float.h
new file mode 100644
index 0000000000..4d8e78641b
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/float.h
@@ -0,0 +1,20 @@
+#ifdef __FLT_EVAL_METHOD__
+#define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
+#else
+#define FLT_EVAL_METHOD 0
+#endif
+
+#define LDBL_TRUE_MIN 3.6451995318824746025e-4951L
+#define LDBL_MIN     3.3621031431120935063e-4932L
+#define LDBL_MAX     1.1897314953572317650e+4932L
+#define LDBL_EPSILON 1.0842021724855044340e-19L
+
+#define LDBL_MANT_DIG 64
+#define LDBL_MIN_EXP (-16381)
+#define LDBL_MAX_EXP 16384
+
+#define LDBL_DIG 18
+#define LDBL_MIN_10_EXP (-4931)
+#define LDBL_MAX_10_EXP 4932
+
+#define DECIMAL_DIG 21
diff --git a/zig/lib/libc/musl/arch/x32/bits/io.h b/zig/lib/libc/musl/arch/x32/bits/io.h
new file mode 100644
index 0000000000..dd5bddc967
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/io.h
@@ -0,0 +1,77 @@
+static __inline void outb(unsigned char __val, unsigned short __port)
+{
+	__asm__ volatile ("outb %0,%1" : : "a" (__val), "dN" (__port));
+}
+
+static __inline void outw(unsigned short __val, unsigned short __port)
+{
+	__asm__ volatile ("outw %0,%1" : : "a" (__val), "dN" (__port));
+}
+
+static __inline void outl(unsigned int __val, unsigned short __port)
+{
+	__asm__ volatile ("outl %0,%1" : : "a" (__val), "dN" (__port));
+}
+
+static __inline unsigned char inb(unsigned short __port)
+{
+	unsigned char __val;
+	__asm__ volatile ("inb %1,%0" : "=a" (__val) : "dN" (__port));
+	return __val;
+}
+
+static __inline unsigned short inw(unsigned short __port)
+{
+	unsigned short __val;
+	__asm__ volatile ("inw %1,%0" : "=a" (__val) : "dN" (__port));
+	return __val;
+}
+
+static __inline unsigned int inl(unsigned short __port)
+{
+	unsigned int __val;
+	__asm__ volatile ("inl %1,%0" : "=a" (__val) : "dN" (__port));
+	return __val;
+}
+
+static __inline void outsb(unsigned short __port, const void *__buf, unsigned long __n)
+{
+	__asm__ volatile ("cld; rep; outsb"
+		      : "+S" (__buf), "+c" (__n)
+		      : "d" (__port));
+}
+
+static __inline void outsw(unsigned short __port, const void *__buf, unsigned long __n)
+{
+	__asm__ volatile ("cld; rep; outsw"
+		      : "+S" (__buf), "+c" (__n)
+		      : "d" (__port));
+}
+
+static __inline void outsl(unsigned short __port, const void *__buf, unsigned long __n)
+{
+	__asm__ volatile ("cld; rep; outsl"
+		      : "+S" (__buf), "+c"(__n)
+		      : "d" (__port));
+}
+
+static __inline void insb(unsigned short __port, void *__buf, unsigned long __n)
+{
+	__asm__ volatile ("cld; rep; insb"
+		      : "+D" (__buf), "+c" (__n)
+		      : "d" (__port));
+}
+
+static __inline void insw(unsigned short __port, void *__buf, unsigned long __n)
+{
+	__asm__ volatile ("cld; rep; insw"
+		      : "+D" (__buf), "+c" (__n)
+		      : "d" (__port));
+}
+
+static __inline void insl(unsigned short __port, void *__buf, unsigned long __n)
+{
+	__asm__ volatile ("cld; rep; insl"
+		      : "+D" (__buf), "+c" (__n)
+		      : "d" (__port));
+}
diff --git a/zig/lib/libc/musl/arch/x32/bits/ioctl_fix.h b/zig/lib/libc/musl/arch/x32/bits/ioctl_fix.h
new file mode 100644
index 0000000000..83b957bddb
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/ioctl_fix.h
@@ -0,0 +1,4 @@
+#undef SIOCGSTAMP
+#undef SIOCGSTAMPNS
+#define SIOCGSTAMP      0x8906
+#define SIOCGSTAMPNS    0x8907
diff --git a/zig/lib/libc/musl/arch/x32/bits/ipc.h b/zig/lib/libc/musl/arch/x32/bits/ipc.h
new file mode 100644
index 0000000000..a12380f638
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/ipc.h
@@ -0,0 +1,11 @@
+struct ipc_perm {
+	key_t __ipc_perm_key;
+	uid_t uid;
+	gid_t gid;
+	uid_t cuid;
+	gid_t cgid;
+	mode_t mode;
+	int __ipc_perm_seq;
+	long long __pad1;
+	long long __pad2;
+};
diff --git a/zig/lib/libc/musl/arch/x32/bits/limits.h b/zig/lib/libc/musl/arch/x32/bits/limits.h
new file mode 100644
index 0000000000..07743b6fd6
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/limits.h
@@ -0,0 +1 @@
+#define PAGESIZE 4096
diff --git a/zig/lib/libc/musl/arch/x32/bits/mman.h b/zig/lib/libc/musl/arch/x32/bits/mman.h
new file mode 100644
index 0000000000..ba2d6f7a83
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/mman.h
@@ -0,0 +1 @@
+#define MAP_32BIT      0x40
diff --git a/zig/lib/libc/musl/arch/x32/bits/msg.h b/zig/lib/libc/musl/arch/x32/bits/msg.h
new file mode 100644
index 0000000000..63ae987734
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/msg.h
@@ -0,0 +1,15 @@
+struct msqid_ds {
+	struct ipc_perm msg_perm;
+	time_t msg_stime;
+	time_t msg_rtime;
+	time_t msg_ctime;
+	unsigned long msg_cbytes;
+	long __unused1;
+	msgqnum_t msg_qnum;
+	long __unused2;
+	msglen_t msg_qbytes;
+	long __unused3;
+	pid_t msg_lspid;
+	pid_t msg_lrpid;
+	unsigned long long __unused[2];
+};
diff --git a/zig/lib/libc/musl/arch/x32/bits/posix.h b/zig/lib/libc/musl/arch/x32/bits/posix.h
new file mode 100644
index 0000000000..30a38714f3
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/posix.h
@@ -0,0 +1,2 @@
+#define _POSIX_V6_ILP32_OFFBIG  1
+#define _POSIX_V7_ILP32_OFFBIG  1
diff --git a/zig/lib/libc/musl/arch/x32/bits/ptrace.h b/zig/lib/libc/musl/arch/x32/bits/ptrace.h
new file mode 100644
index 0000000000..7f8a09b521
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/ptrace.h
@@ -0,0 +1,13 @@
+#define PTRACE_GET_THREAD_AREA		25
+#define PTRACE_SET_THREAD_AREA		26
+#define PTRACE_ARCH_PRCTL		30
+#define PTRACE_SYSEMU			31
+#define PTRACE_SYSEMU_SINGLESTEP	32
+#define PTRACE_SINGLEBLOCK		33
+
+#define PT_GET_THREAD_AREA PTRACE_GET_THREAD_AREA
+#define PT_SET_THREAD_AREA PTRACE_SET_THREAD_AREA
+#define PT_ARCH_PRCTL PTRACE_ARCH_PRCTL
+#define PT_SYSEMU PTRACE_SYSEMU
+#define PT_SYSEMU_SINGLESTEP PTRACE_SYSEMU_SINGLESTEP
+#define PT_STEPBLOCK PTRACE_SINGLEBLOCK
diff --git a/zig/lib/libc/musl/arch/x32/bits/reg.h b/zig/lib/libc/musl/arch/x32/bits/reg.h
new file mode 100644
index 0000000000..5faaef1aeb
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/reg.h
@@ -0,0 +1,29 @@
+#undef __WORDSIZE
+#define __WORDSIZE 32
+#define R15    0
+#define R14    1
+#define R13    2
+#define R12    3
+#define RBP    4
+#define RBX    5
+#define R11    6
+#define R10    7
+#define R9     8
+#define R8     9
+#define RAX    10
+#define RCX    11
+#define RDX    12
+#define RSI    13
+#define RDI    14
+#define ORIG_RAX 15
+#define RIP    16
+#define CS     17
+#define EFLAGS 18
+#define RSP    19
+#define SS     20
+#define FS_BASE 21
+#define GS_BASE 22
+#define DS     23
+#define ES     24
+#define FS     25
+#define GS     26
diff --git a/zig/lib/libc/musl/arch/x32/bits/sem.h b/zig/lib/libc/musl/arch/x32/bits/sem.h
new file mode 100644
index 0000000000..18745f4c84
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/sem.h
@@ -0,0 +1,11 @@
+struct semid_ds {
+	struct ipc_perm sem_perm;
+	time_t sem_otime;
+	long long __unused1;
+	time_t sem_ctime;
+	long long __unused2;
+	unsigned short sem_nsems;
+	char __sem_nsems_pad[sizeof(long long)-sizeof(short)];
+	long long __unused3;
+	long long __unused4;
+};
diff --git a/zig/lib/libc/musl/arch/x32/bits/setjmp.h b/zig/lib/libc/musl/arch/x32/bits/setjmp.h
new file mode 100644
index 0000000000..a9262a6470
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/setjmp.h
@@ -0,0 +1 @@
+typedef unsigned long long __jmp_buf[8];
diff --git a/zig/lib/libc/musl/arch/x32/bits/shm.h b/zig/lib/libc/musl/arch/x32/bits/shm.h
new file mode 100644
index 0000000000..fa88c1e976
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/shm.h
@@ -0,0 +1,32 @@
+#define SHMLBA 4096
+
+struct shmid_ds {
+	struct ipc_perm shm_perm;
+	size_t shm_segsz;
+	time_t shm_atime;
+	time_t shm_dtime;
+	time_t shm_ctime;
+	pid_t shm_cpid;
+	pid_t shm_lpid;
+	unsigned long shm_nattch;
+	unsigned long __pad0;
+	unsigned long long __pad1;
+	unsigned long long __pad2;
+};
+
+struct shminfo {
+	unsigned long shmmax, __pad0, shmmin, __pad1, shmmni, __pad2,
+	              shmseg, __pad3, shmall, __pad4;
+	unsigned long long __unused[4];
+};
+
+struct shm_info {
+	int __used_ids;
+	int __pad_ids;
+	unsigned long shm_tot, __pad0, shm_rss, __pad1, shm_swp, __pad2;
+	unsigned long __swap_attempts, __pad3, __swap_successes, __pad4;
+}
+#ifdef __GNUC__
+__attribute__((__aligned__(8)))
+#endif
+;
diff --git a/zig/lib/libc/musl/arch/x32/bits/signal.h b/zig/lib/libc/musl/arch/x32/bits/signal.h
new file mode 100644
index 0000000000..097be6f457
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/signal.h
@@ -0,0 +1,153 @@
+#if defined(_POSIX_SOURCE) || defined(_POSIX_C_SOURCE) \
+ || defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+
+#if defined(_XOPEN_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+#define MINSIGSTKSZ 2048
+#define SIGSTKSZ 8192
+#endif
+
+#ifdef _GNU_SOURCE
+enum { REG_R8 = 0 };
+#define REG_R8 REG_R8
+enum { REG_R9 = 1 };
+#define REG_R9 REG_R9
+enum { REG_R10 = 2 };
+#define REG_R10 REG_R10
+enum { REG_R11 = 3 };
+#define REG_R11 REG_R11
+enum { REG_R12 = 4 };
+#define REG_R12 REG_R12
+enum { REG_R13 = 5 };
+#define REG_R13 REG_R13
+enum { REG_R14 = 6 };
+#define REG_R14 REG_R14
+enum { REG_R15 = 7 };
+#define REG_R15 REG_R15
+enum { REG_RDI = 8 };
+#define REG_RDI REG_RDI
+enum { REG_RSI = 9 };
+#define REG_RSI REG_RSI
+enum { REG_RBP = 10 };
+#define REG_RBP REG_RBP
+enum { REG_RBX = 11 };
+#define REG_RBX REG_RBX
+enum { REG_RDX = 12 };
+#define REG_RDX REG_RDX
+enum { REG_RAX = 13 };
+#define REG_RAX REG_RAX
+enum { REG_RCX = 14 };
+#define REG_RCX REG_RCX
+enum { REG_RSP = 15 };
+#define REG_RSP REG_RSP
+enum { REG_RIP = 16 };
+#define REG_RIP REG_RIP
+enum { REG_EFL = 17 };
+#define REG_EFL REG_EFL
+enum { REG_CSGSFS = 18 };
+#define REG_CSGSFS REG_CSGSFS
+enum { REG_ERR = 19 };
+#define REG_ERR REG_ERR
+enum { REG_TRAPNO = 20 };
+#define REG_TRAPNO REG_TRAPNO
+enum { REG_OLDMASK = 21 };
+#define REG_OLDMASK REG_OLDMASK
+enum { REG_CR2 = 22 };
+#define REG_CR2 REG_CR2
+#endif
+
+#if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+typedef long long greg_t, gregset_t[23];
+typedef struct _fpstate {
+	unsigned short cwd, swd, ftw, fop;
+	unsigned long long rip, rdp;
+	unsigned mxcsr, mxcr_mask;
+	struct {
+		unsigned short significand[4], exponent, padding[3];
+	} _st[8];
+	struct {
+		unsigned element[4];
+	} _xmm[16];
+	unsigned padding[24];
+} *fpregset_t;
+struct sigcontext {
+	unsigned long long r8, r9, r10, r11, r12, r13, r14, r15;
+	unsigned long long rdi, rsi, rbp, rbx, rdx, rax, rcx, rsp, rip, eflags;
+	unsigned short cs, gs, fs, __pad0;
+	unsigned long long err, trapno, oldmask, cr2;
+	struct _fpstate *fpstate;
+	unsigned long long __reserved1[8];
+};
+typedef struct {
+	gregset_t gregs;
+	fpregset_t fpregs;
+	unsigned long long __reserved1[8];
+} mcontext_t;
+#else
+typedef struct {
+	unsigned long long __space[32];
+} mcontext_t;
+#endif
+
+struct sigaltstack {
+	void *ss_sp;
+	int ss_flags;
+	size_t ss_size;
+};
+
+typedef struct __ucontext {
+	unsigned long uc_flags;
+	struct __ucontext *uc_link;
+	stack_t uc_stack;
+	mcontext_t uc_mcontext;
+	sigset_t uc_sigmask;
+	unsigned long long __fpregs_mem[64];
+} ucontext_t;
+
+#define SA_NOCLDSTOP  1
+#define SA_NOCLDWAIT  2
+#define SA_SIGINFO    4
+#define SA_ONSTACK    0x08000000
+#define SA_RESTART    0x10000000
+#define SA_NODEFER    0x40000000
+#define SA_RESETHAND  0x80000000
+#define SA_RESTORER   0x04000000
+
+#endif
+
+#define SIGHUP    1
+#define SIGINT    2
+#define SIGQUIT   3
+#define SIGILL    4
+#define SIGTRAP   5
+#define SIGABRT   6
+#define SIGIOT    SIGABRT
+#define SIGBUS    7
+#define SIGFPE    8
+#define SIGKILL   9
+#define SIGUSR1   10
+#define SIGSEGV   11
+#define SIGUSR2   12
+#define SIGPIPE   13
+#define SIGALRM   14
+#define SIGTERM   15
+#define SIGSTKFLT 16
+#define SIGCHLD   17
+#define SIGCONT   18
+#define SIGSTOP   19
+#define SIGTSTP   20
+#define SIGTTIN   21
+#define SIGTTOU   22
+#define SIGURG    23
+#define SIGXCPU   24
+#define SIGXFSZ   25
+#define SIGVTALRM 26
+#define SIGPROF   27
+#define SIGWINCH  28
+#define SIGIO     29
+#define SIGPOLL   29
+#define SIGPWR    30
+#define SIGSYS    31
+#define SIGUNUSED SIGSYS
+
+#define _NSIG 65
+
diff --git a/zig/lib/libc/musl/arch/x32/bits/socket.h b/zig/lib/libc/musl/arch/x32/bits/socket.h
new file mode 100644
index 0000000000..8d83001027
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/socket.h
@@ -0,0 +1,5 @@
+#define SO_RCVTIMEO     20
+#define SO_SNDTIMEO     21
+#define SO_TIMESTAMP    29
+#define SO_TIMESTAMPNS  35
+#define SO_TIMESTAMPING 37
diff --git a/zig/lib/libc/musl/arch/x32/bits/stat.h b/zig/lib/libc/musl/arch/x32/bits/stat.h
new file mode 100644
index 0000000000..1f3aa1ed19
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/stat.h
@@ -0,0 +1,22 @@
+/* copied from kernel definition, but with padding replaced
+ * by the corresponding correctly-sized userspace types. */
+
+struct stat {
+	dev_t st_dev;
+	ino_t st_ino;
+	nlink_t st_nlink;
+
+	mode_t st_mode;
+	uid_t st_uid;
+	gid_t st_gid;
+	unsigned int    __pad0;
+	dev_t st_rdev;
+	off_t st_size;
+	blksize_t st_blksize;
+	blkcnt_t st_blocks;
+
+	struct timespec st_atim;
+	struct timespec st_mtim;
+	struct timespec st_ctim;
+	long long __unused[3];
+};
diff --git a/zig/lib/libc/musl/arch/x32/bits/statfs.h b/zig/lib/libc/musl/arch/x32/bits/statfs.h
new file mode 100644
index 0000000000..79aec35d61
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/statfs.h
@@ -0,0 +1,9 @@
+struct statfs {
+	unsigned long f_type, __pad0, f_bsize, __pad1;
+	fsblkcnt_t f_blocks, f_bfree, f_bavail;
+	fsfilcnt_t f_files, f_ffree;
+	fsid_t f_fsid;
+	unsigned long f_namelen, __pad2, f_frsize, __pad3;
+	unsigned long f_flags, __pad4;
+	unsigned long long f_spare[4];
+};
diff --git a/zig/lib/libc/musl/arch/x32/bits/stdint.h b/zig/lib/libc/musl/arch/x32/bits/stdint.h
new file mode 100644
index 0000000000..d1b2712199
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/stdint.h
@@ -0,0 +1,20 @@
+typedef int32_t int_fast16_t;
+typedef int32_t int_fast32_t;
+typedef uint32_t uint_fast16_t;
+typedef uint32_t uint_fast32_t;
+
+#define INT_FAST16_MIN  INT32_MIN
+#define INT_FAST32_MIN  INT32_MIN
+
+#define INT_FAST16_MAX  INT32_MAX
+#define INT_FAST32_MAX  INT32_MAX
+
+#define UINT_FAST16_MAX UINT32_MAX
+#define UINT_FAST32_MAX UINT32_MAX
+
+#define INTPTR_MIN      INT32_MIN
+#define INTPTR_MAX      INT32_MAX
+#define UINTPTR_MAX     UINT32_MAX
+#define PTRDIFF_MIN     INT32_MIN
+#define PTRDIFF_MAX     INT32_MAX
+#define SIZE_MAX        UINT32_MAX
diff --git a/zig/lib/libc/musl/arch/x32/bits/user.h b/zig/lib/libc/musl/arch/x32/bits/user.h
new file mode 100644
index 0000000000..eac82a14bc
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/bits/user.h
@@ -0,0 +1,41 @@
+#undef __WORDSIZE
+#define __WORDSIZE 32
+
+typedef struct user_fpregs_struct {
+	uint16_t cwd, swd, ftw, fop;
+	uint64_t rip, rdp;
+	uint32_t mxcsr, mxcr_mask;
+	uint32_t st_space[32], xmm_space[64], padding[24];
+} elf_fpregset_t;
+
+struct user_regs_struct {
+	unsigned long r15, r14, r13, r12, rbp, rbx, r11, r10, r9, r8;
+	unsigned long rax, rcx, rdx, rsi, rdi, orig_rax, rip;
+	unsigned long cs, eflags, rsp, ss, fs_base, gs_base, ds, es, fs, gs;
+};
+#define ELF_NGREG 27
+typedef unsigned long long elf_greg_t, elf_gregset_t[ELF_NGREG];
+
+struct user {
+	struct user_regs_struct		regs;
+	int				u_fpvalid;
+	struct user_fpregs_struct	i387;
+	unsigned long			u_tsize;
+	unsigned long			u_dsize;
+	unsigned long			u_ssize;
+	unsigned long			start_code;
+	unsigned long			start_stack;
+	long				signal;
+	int				reserved;
+	struct user_regs_struct		*u_ar0;
+	struct user_fpregs_struct	*u_fpstate;
+	unsigned long			magic;
+	char				u_comm[32];
+	unsigned long			u_debugreg[8];
+};
+
+#define PAGE_MASK		(~(PAGESIZE-1))
+#define NBPG			PAGESIZE
+#define UPAGES			1
+#define HOST_TEXT_START_ADDR	(u.start_code)
+#define HOST_STACK_END_ADDR	(u.start_stack + u.u_ssize * NBPG)
diff --git a/zig/lib/libc/musl/arch/x32/crt_arch.h b/zig/lib/libc/musl/arch/x32/crt_arch.h
new file mode 100644
index 0000000000..3eec61bdcd
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/crt_arch.h
@@ -0,0 +1,12 @@
+__asm__(
+".text \n"
+".global " START " \n"
+START ": \n"
+"	xor %rbp,%rbp \n"
+"	mov %rsp,%rdi \n"
+".weak _DYNAMIC \n"
+".hidden _DYNAMIC \n"
+"	lea _DYNAMIC(%rip),%rsi \n"
+"	andq $-16,%rsp \n"
+"	call " START "_c \n"
+);
diff --git a/zig/lib/libc/musl/arch/x32/ksigaction.h b/zig/lib/libc/musl/arch/x32/ksigaction.h
new file mode 100644
index 0000000000..c40e356842
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/ksigaction.h
@@ -0,0 +1,11 @@
+#include <features.h>
+
+struct k_sigaction {
+	void (*handler)(int);
+	unsigned long flags;
+	void (*restorer)(void);
+	unsigned mask[2];
+};
+
+hidden void __restore_rt();
+#define __restore __restore_rt
diff --git a/zig/lib/libc/musl/arch/x32/kstat.h b/zig/lib/libc/musl/arch/x32/kstat.h
new file mode 100644
index 0000000000..ce25fce35e
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/kstat.h
@@ -0,0 +1,22 @@
+struct kstat {
+	dev_t st_dev;
+	ino_t st_ino;
+	nlink_t st_nlink;
+
+	mode_t st_mode;
+	uid_t st_uid;
+	gid_t st_gid;
+	unsigned int    __pad0;
+	dev_t st_rdev;
+	off_t st_size;
+	blksize_t st_blksize;
+	blkcnt_t st_blocks;
+
+	long long st_atime_sec;
+	long st_atime_nsec;
+	long long st_mtime_sec;
+	long st_mtime_nsec;
+	long long st_ctime_sec;
+	long st_ctime_nsec;
+	long long __unused[3];
+};
diff --git a/zig/lib/libc/musl/arch/x32/pthread_arch.h b/zig/lib/libc/musl/arch/x32/pthread_arch.h
new file mode 100644
index 0000000000..c1e7716d52
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/pthread_arch.h
@@ -0,0 +1,12 @@
+static inline uintptr_t __get_tp()
+{
+	uintptr_t tp;
+	__asm__ ("mov %%fs:0,%0" : "=r" (tp) );
+	return tp;
+}
+
+#define MC_PC gregs[REG_RIP]
+
+#define CANARY_PAD
+
+#define tls_mod_off_t unsigned long long
diff --git a/zig/lib/libc/musl/arch/x32/reloc.h b/zig/lib/libc/musl/arch/x32/reloc.h
new file mode 100644
index 0000000000..dc039adf5b
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/reloc.h
@@ -0,0 +1,31 @@
+#define LDSO_ARCH "x32"
+
+/* FIXME: x32 is very strange in its use of 64-bit relocation types in
+ * a 32-bit environment. As long as the memory at reloc_addr is
+ * zero-filled prior to relocations, just treating 64-bit relocations
+ * as operating on 32-bit slots should be fine, but this should be
+ * checked. In particular, R_X86_64_64, R_X86_64_DTPOFF64, and
+ * R_X86_64_TPOFF64 may need checking. */
+
+/* The R_X86_64_64, R_X86_64_DTPOFF32, and R_X86_64_TPOFF32 reloc types
+ * were previously mapped in the switch table form of this file; however,
+ * they do not seem to be used/usable for anything. If needed, new
+ * mappings will have to be added. */
+
+#define REL_SYMBOLIC    R_X86_64_32
+#define REL_OFFSET      R_X86_64_PC32
+#define REL_GOT         R_X86_64_GLOB_DAT
+#define REL_PLT         R_X86_64_JUMP_SLOT
+#define REL_RELATIVE    R_X86_64_RELATIVE
+#define REL_COPY        R_X86_64_COPY
+#define REL_DTPMOD      R_X86_64_DTPMOD64
+#define REL_DTPOFF      R_X86_64_DTPOFF64
+#define REL_TPOFF       R_X86_64_TPOFF64
+
+#define CRTJMP(pc,sp) __asm__ __volatile__( \
+	"mov %1,%%esp ; jmp *%0" : : "r"((uint64_t)(uintptr_t)pc), "r"(sp) : "memory" )
+
+#define GETFUNCSYM(fp, sym, got) __asm__ ( \
+	".hidden " #sym "\n" \
+	"	lea " #sym "(%%rip),%0\n" \
+	: "=r"(*fp) : : "memory" )
diff --git a/zig/lib/libc/musl/arch/x32/syscall_arch.h b/zig/lib/libc/musl/arch/x32/syscall_arch.h
new file mode 100644
index 0000000000..e0111cc0ea
--- /dev/null
+++ b/zig/lib/libc/musl/arch/x32/syscall_arch.h
@@ -0,0 +1,93 @@
+#define __SYSCALL_LL_E(x) (x)
+#define __SYSCALL_LL_O(x) (x)
+
+#define __scc(X) sizeof(1?(X):0ULL) < 8 ? (unsigned long) (X) : (long long) (X)
+typedef long long syscall_arg_t;
+
+static __inline long __syscall0(long long n)
+{
+	unsigned long ret;
+	__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n) : "rcx", "r11", "memory");
+	return ret;
+}
+
+static __inline long __syscall1(long long n, long long a1)
+{
+	unsigned long ret;
+	__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1) : "rcx", "r11", "memory");
+	return ret;
+}
+
+static __inline long __syscall2(long long n, long long a1, long long a2)
+{
+	unsigned long ret;
+	__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2)
+					: "rcx", "r11", "memory");
+	return ret;
+}
+
+static __inline long __syscall3(long long n, long long a1, long long a2, long long a3)
+{
+	unsigned long ret;
+	__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
+						  "d"(a3) : "rcx", "r11", "memory");
+	return ret;
+}
+
+static __inline long __syscall4(long long n, long long a1, long long a2, long long a3,
+                                     long long a4_)
+{
+	unsigned long ret;
+	register long long a4 __asm__("r10") = a4_;
+	__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
+					  "d"(a3), "r"(a4): "rcx", "r11", "memory");
+	return ret;
+}
+
+static __inline long __syscall5(long long n, long long a1, long long a2, long long a3,
+                                     long long a4_, long long a5_)
+{
+	unsigned long ret;
+	register long long a4 __asm__("r10") = a4_;
+	register long long a5 __asm__("r8") = a5_;
+	__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
+					  "d"(a3), "r"(a4), "r"(a5) : "rcx", "r11", "memory");
+	return ret;
+}
+
+static __inline long __syscall6(long long n, long long a1, long long a2, long long a3,
+                                     long long a4_, long long a5_, long long a6_)
+{
+	unsigned long ret;
+	register long long a4 __asm__("r10") = a4_;
+	register long long a5 __asm__("r8") = a5_;
+	register long long a6 __asm__("r9") = a6_;
+	__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
+					  "d"(a3), "r"(a4), "r"(a5), "r"(a6) : "rcx", "r11", "memory");
+	return ret;
+}
+
+#undef SYS_futimesat
+
+#define SYS_clock_gettime64 SYS_clock_gettime
+#define SYS_clock_settime64 SYS_clock_settime
+#define SYS_clock_adjtime64 SYS_clock_adjtime
+#define SYS_clock_nanosleep_time64 SYS_clock_nanosleep
+#define SYS_timer_gettime64 SYS_timer_gettime
+#define SYS_timer_settime64 SYS_timer_settime
+#define SYS_timerfd_gettime64 SYS_timerfd_gettime
+#define SYS_timerfd_settime64 SYS_timerfd_settime
+#define SYS_utimensat_time64 SYS_utimensat
+#define SYS_pselect6_time64 SYS_pselect6
+#define SYS_ppoll_time64 SYS_ppoll
+#define SYS_recvmmsg_time64 SYS_recvmmsg
+#define SYS_mq_timedsend_time64 SYS_mq_timedsend
+#define SYS_mq_timedreceive_time64 SYS_mq_timedreceive
+#define SYS_semtimedop_time64 SYS_semtimedop
+#define SYS_rt_sigtimedwait_time64 SYS_rt_sigtimedwait
+#define SYS_futex_time64 SYS_futex
+#define SYS_sched_rr_get_interval_time64 SYS_sched_rr_get_interval
+#define SYS_getrusage_time64 SYS_getrusage
+#define SYS_wait4_time64 SYS_wait4
+
+#define IPC_64 0
diff --git a/zig/lib/libc/musl/arch/x86_64/bits/alltypes.h.in b/zig/lib/libc/musl/arch/x86_64/bits/alltypes.h.in
deleted file mode 100644
index 5cd8a2997f..0000000000
--- a/zig/lib/libc/musl/arch/x86_64/bits/alltypes.h.in
+++ /dev/null
@@ -1,20 +0,0 @@
-#define _Addr long
-#define _Int64 long
-#define _Reg long
-
-#define __BYTE_ORDER 1234
-#define __LONG_MAX 0x7fffffffffffffffL
-
-#ifndef __cplusplus
-TYPEDEF int wchar_t;
-#endif
-
-#if defined(__FLT_EVAL_METHOD__) && __FLT_EVAL_METHOD__ == 2
-TYPEDEF long double float_t;
-TYPEDEF long double double_t;
-#else
-TYPEDEF float float_t;
-TYPEDEF double double_t;
-#endif
-
-TYPEDEF struct { long long __ll; long double __ld; } max_align_t;
diff --git a/zig/lib/libc/musl/arch/x86_64/bits/syscall.h.in b/zig/lib/libc/musl/arch/x86_64/bits/syscall.h.in
deleted file mode 100644
index 6543bbba78..0000000000
--- a/zig/lib/libc/musl/arch/x86_64/bits/syscall.h.in
+++ /dev/null
@@ -1,364 +0,0 @@
-#define __NR_read				0
-#define __NR_write				1
-#define __NR_open				2
-#define __NR_close				3
-#define __NR_stat				4
-#define __NR_fstat				5
-#define __NR_lstat				6
-#define __NR_poll				7
-#define __NR_lseek				8
-#define __NR_mmap				9
-#define __NR_mprotect			10
-#define __NR_munmap				11
-#define __NR_brk				12
-#define __NR_rt_sigaction		13
-#define __NR_rt_sigprocmask		14
-#define __NR_rt_sigreturn		15
-#define __NR_ioctl				16
-#define __NR_pread64			17
-#define __NR_pwrite64			18
-#define __NR_readv				19
-#define __NR_writev				20
-#define __NR_access				21
-#define __NR_pipe				22
-#define __NR_select				23
-#define __NR_sched_yield		24
-#define __NR_mremap				25
-#define __NR_msync				26
-#define __NR_mincore			27
-#define __NR_madvise			28
-#define __NR_shmget				29
-#define __NR_shmat				30
-#define __NR_shmctl				31
-#define __NR_dup				32
-#define __NR_dup2				33
-#define __NR_pause				34
-#define __NR_nanosleep			35
-#define __NR_getitimer			36
-#define __NR_alarm				37
-#define __NR_setitimer			38
-#define __NR_getpid				39
-#define __NR_sendfile			40
-#define __NR_socket				41
-#define __NR_connect			42
-#define __NR_accept				43
-#define __NR_sendto				44
-#define __NR_recvfrom			45
-#define __NR_sendmsg			46
-#define __NR_recvmsg			47
-#define __NR_shutdown			48
-#define __NR_bind				49
-#define __NR_listen				50
-#define __NR_getsockname		51
-#define __NR_getpeername		52
-#define __NR_socketpair			53
-#define __NR_setsockopt			54
-#define __NR_getsockopt			55
-#define __NR_clone				56
-#define __NR_fork				57
-#define __NR_vfork				58
-#define __NR_execve				59
-#define __NR_exit				60
-#define __NR_wait4				61
-#define __NR_kill				62
-#define __NR_uname				63
-#define __NR_semget				64
-#define __NR_semop				65
-#define __NR_semctl				66
-#define __NR_shmdt				67
-#define __NR_msgget				68
-#define __NR_msgsnd				69
-#define __NR_msgrcv				70
-#define __NR_msgctl				71
-#define __NR_fcntl				72
-#define __NR_flock				73
-#define __NR_fsync				74
-#define __NR_fdatasync			75
-#define __NR_truncate			76
-#define __NR_ftruncate			77
-#define __NR_getdents			78
-#define __NR_getcwd				79
-#define __NR_chdir				80
-#define __NR_fchdir				81
-#define __NR_rename				82
-#define __NR_mkdir				83
-#define __NR_rmdir				84
-#define __NR_creat				85
-#define __NR_link				86
-#define __NR_unlink				87
-#define __NR_symlink			88
-#define __NR_readlink			89
-#define __NR_chmod				90
-#define __NR_fchmod				91
-#define __NR_chown				92
-#define __NR_fchown				93
-#define __NR_lchown				94
-#define __NR_umask				95
-#define __NR_gettimeofday		96
-#define __NR_getrlimit			97
-#define __NR_getrusage			98
-#define __NR_sysinfo			99
-#define __NR_times				100
-#define __NR_ptrace				101
-#define __NR_getuid				102
-#define __NR_syslog				103
-#define __NR_getgid				104
-#define __NR_setuid				105
-#define __NR_setgid				106
-#define __NR_geteuid			107
-#define __NR_getegid			108
-#define __NR_setpgid			109
-#define __NR_getppid			110
-#define __NR_getpgrp			111
-#define __NR_setsid				112
-#define __NR_setreuid			113
-#define __NR_setregid			114
-#define __NR_getgroups			115
-#define __NR_setgroups			116
-#define __NR_setresuid			117
-#define __NR_getresuid			118
-#define __NR_setresgid			119
-#define __NR_getresgid			120
-#define __NR_getpgid			121
-#define __NR_setfsuid			122
-#define __NR_setfsgid			123
-#define __NR_getsid				124
-#define __NR_capget				125
-#define __NR_capset				126
-#define __NR_rt_sigpending		127
-#define __NR_rt_sigtimedwait	128
-#define __NR_rt_sigqueueinfo	129
-#define __NR_rt_sigsuspend		130
-#define __NR_sigaltstack		131
-#define __NR_utime				132
-#define __NR_mknod				133
-#define __NR_uselib				134
-#define __NR_personality		135
-#define __NR_ustat				136
-#define __NR_statfs				137
-#define __NR_fstatfs			138
-#define __NR_sysfs				139
-#define __NR_getpriority			140
-#define __NR_setpriority			141
-#define __NR_sched_setparam			142
-#define __NR_sched_getparam			143
-#define __NR_sched_setscheduler		144
-#define __NR_sched_getscheduler		145
-#define __NR_sched_get_priority_max	146
-#define __NR_sched_get_priority_min	147
-#define __NR_sched_rr_get_interval	148
-#define __NR_mlock					149
-#define __NR_munlock				150
-#define __NR_mlockall				151
-#define __NR_munlockall				152
-#define __NR_vhangup				153
-#define __NR_modify_ldt				154
-#define __NR_pivot_root				155
-#define __NR__sysctl				156
-#define __NR_prctl					157
-#define __NR_arch_prctl				158
-#define __NR_adjtimex				159
-#define __NR_setrlimit				160
-#define __NR_chroot					161
-#define __NR_sync					162
-#define __NR_acct					163
-#define __NR_settimeofday			164
-#define __NR_mount					165
-#define __NR_umount2				166
-#define __NR_swapon					167
-#define __NR_swapoff				168
-#define __NR_reboot					169
-#define __NR_sethostname			170
-#define __NR_setdomainname			171
-#define __NR_iopl					172
-#define __NR_ioperm					173
-#define __NR_create_module			174
-#define __NR_init_module			175
-#define __NR_delete_module			176
-#define __NR_get_kernel_syms		177
-#define __NR_query_module			178
-#define __NR_quotactl				179
-#define __NR_nfsservctl				180
-#define __NR_getpmsg				181
-#define __NR_putpmsg				182
-#define __NR_afs_syscall			183
-#define __NR_tuxcall				184
-#define __NR_security				185
-#define __NR_gettid					186
-#define __NR_readahead				187
-#define __NR_setxattr				188
-#define __NR_lsetxattr				189
-#define __NR_fsetxattr				190
-#define __NR_getxattr				191
-#define __NR_lgetxattr				192
-#define __NR_fgetxattr				193
-#define __NR_listxattr				194
-#define __NR_llistxattr				195
-#define __NR_flistxattr				196
-#define __NR_removexattr			197
-#define __NR_lremovexattr			198
-#define __NR_fremovexattr			199
-#define __NR_tkill					200
-#define __NR_time					201
-#define __NR_futex					202
-#define __NR_sched_setaffinity		203
-#define __NR_sched_getaffinity		204
-#define __NR_set_thread_area		205
-#define __NR_io_setup				206
-#define __NR_io_destroy				207
-#define __NR_io_getevents			208
-#define __NR_io_submit				209
-#define __NR_io_cancel				210
-#define __NR_get_thread_area		211
-#define __NR_lookup_dcookie			212
-#define __NR_epoll_create			213
-#define __NR_epoll_ctl_old			214
-#define __NR_epoll_wait_old			215
-#define __NR_remap_file_pages		216
-#define __NR_getdents64				217
-#define __NR_set_tid_address		218
-#define __NR_restart_syscall		219
-#define __NR_semtimedop				220
-#define __NR_fadvise64				221
-#define __NR_timer_create			222
-#define __NR_timer_settime			223
-#define __NR_timer_gettime			224
-#define __NR_timer_getoverrun		225
-#define __NR_timer_delete			226
-#define __NR_clock_settime			227
-#define __NR_clock_gettime			228
-#define __NR_clock_getres			229
-#define __NR_clock_nanosleep		230
-#define __NR_exit_group				231
-#define __NR_epoll_wait				232
-#define __NR_epoll_ctl				233
-#define __NR_tgkill					234
-#define __NR_utimes					235
-#define __NR_vserver				236
-#define __NR_mbind					237
-#define __NR_set_mempolicy			238
-#define __NR_get_mempolicy			239
-#define __NR_mq_open				240
-#define __NR_mq_unlink				241
-#define __NR_mq_timedsend			242
-#define __NR_mq_timedreceive		243
-#define __NR_mq_notify				244
-#define __NR_mq_getsetattr			245
-#define __NR_kexec_load				246
-#define __NR_waitid					247
-#define __NR_add_key				248
-#define __NR_request_key			249
-#define __NR_keyctl					250
-#define __NR_ioprio_set				251
-#define __NR_ioprio_get				252
-#define __NR_inotify_init			253
-#define __NR_inotify_add_watch		254
-#define __NR_inotify_rm_watch		255
-#define __NR_migrate_pages			256
-#define __NR_openat					257
-#define __NR_mkdirat				258
-#define __NR_mknodat				259
-#define __NR_fchownat				260
-#define __NR_futimesat				261
-#define __NR_newfstatat				262
-#define __NR_unlinkat				263
-#define __NR_renameat				264
-#define __NR_linkat					265
-#define __NR_symlinkat				266
-#define __NR_readlinkat				267
-#define __NR_fchmodat				268
-#define __NR_faccessat				269
-#define __NR_pselect6				270
-#define __NR_ppoll					271
-#define __NR_unshare				272
-#define __NR_set_robust_list		273
-#define __NR_get_robust_list		274
-#define __NR_splice					275
-#define __NR_tee					276
-#define __NR_sync_file_range		277
-#define __NR_vmsplice				278
-#define __NR_move_pages				279
-#define __NR_utimensat				280
-#define __NR_epoll_pwait			281
-#define __NR_signalfd				282
-#define __NR_timerfd_create			283
-#define __NR_eventfd				284
-#define __NR_fallocate				285
-#define __NR_timerfd_settime		286
-#define __NR_timerfd_gettime		287
-#define __NR_accept4				288
-#define __NR_signalfd4				289
-#define __NR_eventfd2				290
-#define __NR_epoll_create1			291
-#define __NR_dup3					292
-#define __NR_pipe2					293
-#define __NR_inotify_init1			294
-#define __NR_preadv					295
-#define __NR_pwritev				296
-#define __NR_rt_tgsigqueueinfo		297
-#define __NR_perf_event_open		298
-#define __NR_recvmmsg				299
-#define __NR_fanotify_init			300
-#define __NR_fanotify_mark			301
-#define __NR_prlimit64				302
-#define __NR_name_to_handle_at			303
-#define __NR_open_by_handle_at			304
-#define __NR_clock_adjtime			305
-#define __NR_syncfs				306
-#define __NR_sendmmsg				307
-#define __NR_setns				308
-#define __NR_getcpu				309
-#define __NR_process_vm_readv			310
-#define __NR_process_vm_writev			311
-#define __NR_kcmp				312
-#define __NR_finit_module			313
-#define __NR_sched_setattr			314
-#define __NR_sched_getattr			315
-#define __NR_renameat2				316
-#define __NR_seccomp				317
-#define __NR_getrandom				318
-#define __NR_memfd_create			319
-#define __NR_kexec_file_load			320
-#define __NR_bpf				321
-#define __NR_execveat				322
-#define __NR_userfaultfd			323
-#define __NR_membarrier				324
-#define __NR_mlock2				325
-#define __NR_copy_file_range			326
-#define __NR_preadv2				327
-#define __NR_pwritev2				328
-#define __NR_pkey_mprotect			329
-#define __NR_pkey_alloc				330
-#define __NR_pkey_free				331
-#define __NR_statx				332
-#define __NR_io_pgetevents			333
-#define __NR_rseq				334
-#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_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
-
diff --git a/zig/lib/libc/musl/crt/mipsn32/crtn.s b/zig/lib/libc/musl/crt/mipsn32/crtn.s
index dccd7e8901..66f0c7a680 100644
--- a/zig/lib/libc/musl/crt/mipsn32/crtn.s
+++ b/zig/lib/libc/musl/crt/mipsn32/crtn.s
@@ -2,11 +2,13 @@
 .section	.init
 	ld	$gp, 16($sp)
 	ld	$ra, 24($sp)
-	j	$ra
+	# zig patch: j <reg> -> jr <reg> for https://github.com/ziglang/zig/issues/21315
+	jr $ra
 	addu	$sp, $sp, 32
 
 .section	.fini
 	ld	$gp, 16($sp)
 	ld	$ra, 24($sp)
-	j	$ra
+	# zig patch: j <reg> -> jr <reg> for https://github.com/ziglang/zig/issues/21315
+	jr $ra
 	addu	$sp, $sp, 32
diff --git a/zig/lib/libc/musl/include/alltypes.h.in b/zig/lib/libc/musl/include/alltypes.h.in
deleted file mode 100644
index d47aeea9aa..0000000000
--- a/zig/lib/libc/musl/include/alltypes.h.in
+++ /dev/null
@@ -1,95 +0,0 @@
-#define __LITTLE_ENDIAN 1234
-#define __BIG_ENDIAN 4321
-#define __USE_TIME_BITS64 1
-
-TYPEDEF unsigned _Addr size_t;
-TYPEDEF unsigned _Addr uintptr_t;
-TYPEDEF _Addr ptrdiff_t;
-TYPEDEF _Addr ssize_t;
-TYPEDEF _Addr intptr_t;
-TYPEDEF _Addr regoff_t;
-TYPEDEF _Reg register_t;
-TYPEDEF _Int64 time_t;
-TYPEDEF _Int64 suseconds_t;
-
-TYPEDEF signed char     int8_t;
-TYPEDEF signed short    int16_t;
-TYPEDEF signed int      int32_t;
-TYPEDEF signed _Int64   int64_t;
-TYPEDEF signed _Int64   intmax_t;
-TYPEDEF unsigned char   uint8_t;
-TYPEDEF unsigned short  uint16_t;
-TYPEDEF unsigned int    uint32_t;
-TYPEDEF unsigned _Int64 uint64_t;
-TYPEDEF unsigned _Int64 u_int64_t;
-TYPEDEF unsigned _Int64 uintmax_t;
-
-TYPEDEF unsigned mode_t;
-TYPEDEF unsigned _Reg nlink_t;
-TYPEDEF _Int64 off_t;
-TYPEDEF unsigned _Int64 ino_t;
-TYPEDEF unsigned _Int64 dev_t;
-TYPEDEF long blksize_t;
-TYPEDEF _Int64 blkcnt_t;
-TYPEDEF unsigned _Int64 fsblkcnt_t;
-TYPEDEF unsigned _Int64 fsfilcnt_t;
-
-TYPEDEF unsigned wint_t;
-TYPEDEF unsigned long wctype_t;
-
-TYPEDEF void * timer_t;
-TYPEDEF int clockid_t;
-TYPEDEF long clock_t;
-STRUCT timeval { time_t tv_sec; suseconds_t tv_usec; };
-STRUCT timespec { time_t tv_sec; int :8*(sizeof(time_t)-sizeof(long))*(__BYTE_ORDER==4321); long tv_nsec; int :8*(sizeof(time_t)-sizeof(long))*(__BYTE_ORDER!=4321); };
-
-TYPEDEF int pid_t;
-TYPEDEF unsigned id_t;
-TYPEDEF unsigned uid_t;
-TYPEDEF unsigned gid_t;
-TYPEDEF int key_t;
-TYPEDEF unsigned useconds_t;
-
-#ifdef __cplusplus
-TYPEDEF unsigned long pthread_t;
-#else
-TYPEDEF struct __pthread * pthread_t;
-#endif
-TYPEDEF int pthread_once_t;
-TYPEDEF unsigned pthread_key_t;
-TYPEDEF int pthread_spinlock_t;
-TYPEDEF struct { unsigned __attr; } pthread_mutexattr_t;
-TYPEDEF struct { unsigned __attr; } pthread_condattr_t;
-TYPEDEF struct { unsigned __attr; } pthread_barrierattr_t;
-TYPEDEF struct { unsigned __attr[2]; } pthread_rwlockattr_t;
-
-STRUCT _IO_FILE { char __x; };
-TYPEDEF struct _IO_FILE FILE;
-
-TYPEDEF __builtin_va_list va_list;
-TYPEDEF __builtin_va_list __isoc_va_list;
-
-TYPEDEF struct __mbstate_t { unsigned __opaque1, __opaque2; } mbstate_t;
-
-TYPEDEF struct __locale_struct * locale_t;
-
-TYPEDEF struct __sigset_t { unsigned long __bits[128/sizeof(long)]; } sigset_t;
-
-STRUCT iovec { void *iov_base; size_t iov_len; };
-
-STRUCT winsize { unsigned short ws_row, ws_col, ws_xpixel, ws_ypixel; };
-
-TYPEDEF unsigned socklen_t;
-TYPEDEF unsigned short sa_family_t;
-
-TYPEDEF struct { union { int __i[sizeof(long)==8?14:9]; volatile int __vi[sizeof(long)==8?14:9]; unsigned long __s[sizeof(long)==8?7:9]; } __u; } pthread_attr_t;
-TYPEDEF struct { union { int __i[sizeof(long)==8?10:6]; volatile int __vi[sizeof(long)==8?10:6]; volatile void *volatile __p[sizeof(long)==8?5:6]; } __u; } pthread_mutex_t;
-TYPEDEF struct { union { int __i[sizeof(long)==8?10:6]; volatile int __vi[sizeof(long)==8?10:6]; volatile void *volatile __p[sizeof(long)==8?5:6]; } __u; } mtx_t;
-TYPEDEF struct { union { int __i[12]; volatile int __vi[12]; void *__p[12*sizeof(int)/sizeof(void*)]; } __u; } pthread_cond_t;
-TYPEDEF struct { union { int __i[12]; volatile int __vi[12]; void *__p[12*sizeof(int)/sizeof(void*)]; } __u; } cnd_t;
-TYPEDEF struct { union { int __i[sizeof(long)==8?14:8]; volatile int __vi[sizeof(long)==8?14:8]; void *__p[sizeof(long)==8?7:8]; } __u; } pthread_rwlock_t;
-TYPEDEF struct { union { int __i[sizeof(long)==8?8:5]; volatile int __vi[sizeof(long)==8?8:5]; void *__p[sizeof(long)==8?4:5]; } __u; } pthread_barrier_t;
-
-#undef _Addr
-#undef _Int64
-#undef _Reg
diff --git a/zig/lib/libc/musl/ldso/dlstart.c b/zig/lib/libc/musl/ldso/dlstart.c
index 20d50f2cbc..259f5e18ee 100644
--- a/zig/lib/libc/musl/ldso/dlstart.c
+++ b/zig/lib/libc/musl/ldso/dlstart.c
@@ -140,6 +140,21 @@ hidden void _dlstart_c(size_t *sp, size_t *dynv)
 		size_t *rel_addr = (void *)(base + rel[0]);
 		*rel_addr = base + rel[2];
 	}
+
+	rel = (void *)(base+dyn[DT_RELR]);
+	rel_size = dyn[DT_RELRSZ];
+	size_t *relr_addr = 0;
+	for (; rel_size; rel++, rel_size-=sizeof(size_t)) {
+		if ((rel[0]&1) == 0) {
+			relr_addr = (void *)(base + rel[0]);
+			*relr_addr++ += base;
+		} else {
+			for (size_t i=0, bitmap=rel[0]; bitmap>>=1; i++)
+				if (bitmap&1)
+					relr_addr[i] += base;
+			relr_addr += 8*sizeof(size_t)-1;
+		}
+	}
 #endif
 
 	stage2_func dls2;
diff --git a/zig/lib/std/Build.zig b/zig/lib/std/Build.zig
index 988a72c129..041de3e06f 100644
--- a/zig/lib/std/Build.zig
+++ b/zig/lib/std/Build.zig
@@ -123,6 +123,7 @@ pub const Graph = struct {
     incremental: ?bool = null,
     random_seed: u32 = 0,
     dependency_cache: InitializedDepMap = .empty,
+    allow_so_scripts: ?bool = null,
 };
 
 const AvailableDeps = []const struct { []const u8, []const u8 };
diff --git a/zig/lib/std/Build/Cache.zig b/zig/lib/std/Build/Cache.zig
index 53f1dcff29..16ecf3c0b0 100644
--- a/zig/lib/std/Build/Cache.zig
+++ b/zig/lib/std/Build/Cache.zig
@@ -142,6 +142,9 @@ pub const hasher_init: Hasher = Hasher.init(&[_]u8{
 pub const File = struct {
     prefixed_path: PrefixedPath,
     max_file_size: ?usize,
+    /// Populated if the user calls `addOpenedFile`.
+    /// The handle is not owned here.
+    handle: ?fs.File,
     stat: Stat,
     bin_digest: BinDigest,
     contents: ?[]const u8,
@@ -150,6 +153,14 @@ pub const File = struct {
         inode: fs.File.INode,
         size: u64,
         mtime: i128,
+
+        pub fn fromFs(fs_stat: fs.File.Stat) Stat {
+            return .{
+                .inode = fs_stat.inode,
+                .size = fs_stat.size,
+                .mtime = fs_stat.mtime,
+            };
+        }
     };
 
     pub fn deinit(self: *File, gpa: Allocator) void {
@@ -165,6 +176,11 @@ pub const File = struct {
         const new = new_max_size orelse return;
         file.max_file_size = if (file.max_file_size) |old| @max(old, new) else new;
     }
+
+    pub fn updateHandle(file: *File, new_handle: ?fs.File) void {
+        const handle = new_handle orelse return;
+        file.handle = handle;
+    }
 };
 
 pub const HashHelper = struct {
@@ -205,6 +221,7 @@ pub const HashHelper = struct {
                         hh.add(linux.range.min);
                         hh.add(linux.range.max);
                         hh.add(linux.glibc);
+                        hh.add(linux.android);
                     },
                     .windows => |windows| {
                         hh.add(windows.min);
@@ -355,15 +372,20 @@ pub const Manifest = struct {
     /// var file_contents = cache_hash.files.keys()[file_index].contents.?;
     /// ```
     pub fn addFilePath(m: *Manifest, file_path: Path, max_file_size: ?usize) !usize {
+        return addOpenedFile(m, file_path, null, max_file_size);
+    }
+
+    /// Same as `addFilePath` except the file has already been opened.
+    pub fn addOpenedFile(m: *Manifest, path: Path, handle: ?fs.File, max_file_size: ?usize) !usize {
         const gpa = m.cache.gpa;
         try m.files.ensureUnusedCapacity(gpa, 1);
         const resolved_path = try fs.path.resolve(gpa, &.{
-            file_path.root_dir.path orelse ".",
-            file_path.subPathOrDot(),
+            path.root_dir.path orelse ".",
+            path.subPathOrDot(),
         });
         errdefer gpa.free(resolved_path);
         const prefixed_path = try m.cache.findPrefixResolved(resolved_path);
-        return addFileInner(m, prefixed_path, max_file_size);
+        return addFileInner(m, prefixed_path, handle, max_file_size);
     }
 
     /// Deprecated; use `addFilePath`.
@@ -375,13 +397,14 @@ pub const Manifest = struct {
         const prefixed_path = try self.cache.findPrefix(file_path);
         errdefer gpa.free(prefixed_path.sub_path);
 
-        return addFileInner(self, prefixed_path, max_file_size);
+        return addFileInner(self, prefixed_path, null, max_file_size);
     }
 
-    fn addFileInner(self: *Manifest, prefixed_path: PrefixedPath, max_file_size: ?usize) !usize {
+    fn addFileInner(self: *Manifest, prefixed_path: PrefixedPath, handle: ?fs.File, max_file_size: ?usize) usize {
         const gop = self.files.getOrPutAssumeCapacityAdapted(prefixed_path, FilesAdapter{});
         if (gop.found_existing) {
             gop.key_ptr.updateMaxSize(max_file_size);
+            gop.key_ptr.updateHandle(handle);
             return gop.index;
         }
         gop.key_ptr.* = .{
@@ -390,6 +413,7 @@ pub const Manifest = struct {
             .max_file_size = max_file_size,
             .stat = undefined,
             .bin_digest = undefined,
+            .handle = handle,
         };
 
         self.hash.add(prefixed_path.prefix);
@@ -557,6 +581,7 @@ pub const Manifest = struct {
                             },
                             .contents = null,
                             .max_file_size = null,
+                            .handle = null,
                             .stat = .{
                                 .size = stat_size,
                                 .inode = stat_inode,
@@ -700,12 +725,19 @@ pub const Manifest = struct {
     }
 
     fn populateFileHash(self: *Manifest, ch_file: *File) !void {
-        const pp = ch_file.prefixed_path;
-        const dir = self.cache.prefixes()[pp.prefix].handle;
-        const file = try dir.openFile(pp.sub_path, .{});
-        defer file.close();
+        if (ch_file.handle) |handle| {
+            return populateFileHashHandle(self, ch_file, handle);
+        } else {
+            const pp = ch_file.prefixed_path;
+            const dir = self.cache.prefixes()[pp.prefix].handle;
+            const handle = try dir.openFile(pp.sub_path, .{});
+            defer handle.close();
+            return populateFileHashHandle(self, ch_file, handle);
+        }
+    }
 
-        const actual_stat = try file.stat();
+    fn populateFileHashHandle(self: *Manifest, ch_file: *File, handle: fs.File) !void {
+        const actual_stat = try handle.stat();
         ch_file.stat = .{
             .size = actual_stat.size,
             .mtime = actual_stat.mtime,
@@ -731,8 +763,7 @@ pub const Manifest = struct {
             var hasher = hasher_init;
             var off: usize = 0;
             while (true) {
-                // give me everything you've got, captain
-                const bytes_read = try file.read(contents[off..]);
+                const bytes_read = try handle.pread(contents[off..], off);
                 if (bytes_read == 0) break;
                 hasher.update(contents[off..][0..bytes_read]);
                 off += bytes_read;
@@ -741,7 +772,7 @@ pub const Manifest = struct {
 
             ch_file.contents = contents;
         } else {
-            try hashFile(file, &ch_file.bin_digest);
+            try hashFile(handle, &ch_file.bin_digest);
         }
 
         self.hash.hasher.update(&ch_file.bin_digest);
@@ -805,6 +836,7 @@ pub const Manifest = struct {
         gop.key_ptr.* = .{
             .prefixed_path = prefixed_path,
             .max_file_size = null,
+            .handle = null,
             .stat = undefined,
             .bin_digest = undefined,
             .contents = null,
@@ -843,6 +875,7 @@ pub const Manifest = struct {
         new_file.* = .{
             .prefixed_path = prefixed_path,
             .max_file_size = null,
+            .handle = null,
             .stat = stat,
             .bin_digest = undefined,
             .contents = null,
@@ -1059,6 +1092,7 @@ pub const Manifest = struct {
             gop.key_ptr.* = .{
                 .prefixed_path = prefixed_path,
                 .max_file_size = file.max_file_size,
+                .handle = file.handle,
                 .stat = file.stat,
                 .bin_digest = file.bin_digest,
                 .contents = null,
@@ -1095,14 +1129,14 @@ pub fn writeSmallFile(dir: fs.Dir, sub_path: []const u8, data: []const u8) !void
 
 fn hashFile(file: fs.File, bin_digest: *[Hasher.mac_length]u8) !void {
     var buf: [1024]u8 = undefined;
-
     var hasher = hasher_init;
+    var off: u64 = 0;
     while (true) {
-        const bytes_read = try file.read(&buf);
+        const bytes_read = try file.pread(&buf, off);
         if (bytes_read == 0) break;
         hasher.update(buf[0..bytes_read]);
+        off += bytes_read;
     }
-
     hasher.final(bin_digest);
 }
 
diff --git a/zig/lib/std/Build/Module.zig b/zig/lib/std/Build/Module.zig
index 253945b3d7..347695a4c0 100644
--- a/zig/lib/std/Build/Module.zig
+++ b/zig/lib/std/Build/Module.zig
@@ -492,11 +492,11 @@ pub fn linkSystemLibrary(
     const b = m.owner;
 
     const target = m.requireKnownTarget();
-    if (target.is_libc_lib_name(name)) {
+    if (std.zig.target.isLibCLibName(target, name)) {
         m.link_libc = true;
         return;
     }
-    if (target.is_libcpp_lib_name(name)) {
+    if (std.zig.target.isLibCxxLibName(target, name)) {
         m.link_libcpp = true;
         return;
     }
diff --git a/zig/lib/std/Build/Step/Compile.zig b/zig/lib/std/Build/Step/Compile.zig
index a977dc3056..f0dad8b49a 100644
--- a/zig/lib/std/Build/Step/Compile.zig
+++ b/zig/lib/std/Build/Step/Compile.zig
@@ -186,6 +186,15 @@ want_lto: ?bool = null,
 use_llvm: ?bool,
 use_lld: ?bool,
 
+/// Corresponds to the `-fallow-so-scripts` / `-fno-allow-so-scripts` CLI
+/// flags, overriding the global user setting provided to the `zig build`
+/// command.
+///
+/// The compiler defaults this value to off so that users whose system shared
+/// libraries are all ELF files don't have to pay the cost of checking every
+/// file to find out if it is a text file instead.
+allow_so_scripts: ?bool = null,
+
 /// This is an advanced setting that can change the intent of this Compile step.
 /// If this value is non-null, it means that this Compile step exists to
 /// check for compile errors and return *success* if they match, and failure
@@ -236,6 +245,7 @@ pub const ExpectedCompileErrors = union(enum) {
     contains: []const u8,
     exact: []const []const u8,
     starts_with: []const u8,
+    stderr_contains: []const u8,
 };
 
 pub const Entry = union(enum) {
@@ -611,11 +621,13 @@ pub fn dependsOnSystemLibrary(compile: *const Compile, name: []const u8) bool {
         is_linking_libcpp = is_linking_libcpp or module.link_libcpp == true;
     }
 
-    if (compile.rootModuleTarget().is_libc_lib_name(name)) {
+    const target = compile.rootModuleTarget();
+
+    if (std.zig.target.isLibCLibName(target, name)) {
         return is_linking_libc;
     }
 
-    if (compile.rootModuleTarget().is_libcpp_lib_name(name)) {
+    if (std.zig.target.isLibCxxLibName(target, name)) {
         return is_linking_libcpp;
     }
 
@@ -1033,6 +1045,7 @@ fn getZigArgs(compile: *Compile, fuzz: bool) ![][]const u8 {
     if (b.reference_trace) |some| {
         try zig_args.append(try std.fmt.allocPrint(arena, "-freference-trace={d}", .{some}));
     }
+    try addFlag(&zig_args, "allow-so-scripts", compile.allow_so_scripts orelse b.graph.allow_so_scripts);
 
     try addFlag(&zig_args, "llvm", compile.use_llvm);
     try addFlag(&zig_args, "lld", compile.use_lld);
@@ -1943,24 +1956,24 @@ fn checkCompileErrors(compile: *Compile) !void {
 
     const arena = compile.step.owner.allocator;
 
-    var actual_stderr_list = std.ArrayList(u8).init(arena);
+    var actual_errors_list = std.ArrayList(u8).init(arena);
     try actual_eb.renderToWriter(.{
         .ttyconf = .no_color,
         .include_reference_trace = false,
         .include_source_line = false,
-    }, actual_stderr_list.writer());
-    const actual_stderr = try actual_stderr_list.toOwnedSlice();
+    }, actual_errors_list.writer());
+    const actual_errors = try actual_errors_list.toOwnedSlice();
 
     // Render the expected lines into a string that we can compare verbatim.
     var expected_generated = std.ArrayList(u8).init(arena);
     const expect_errors = compile.expect_errors.?;
 
-    var actual_line_it = mem.splitScalar(u8, actual_stderr, '\n');
+    var actual_line_it = mem.splitScalar(u8, actual_errors, '\n');
 
     // TODO merge this with the testing.expectEqualStrings logic, and also CheckFile
     switch (expect_errors) {
         .starts_with => |expect_starts_with| {
-            if (std.mem.startsWith(u8, actual_stderr, expect_starts_with)) return;
+            if (std.mem.startsWith(u8, actual_errors, expect_starts_with)) return;
             return compile.step.fail(
                 \\
                 \\========= should start with: ============
@@ -1968,7 +1981,7 @@ fn checkCompileErrors(compile: *Compile) !void {
                 \\========= but not found: ================
                 \\{s}
                 \\=========================================
-            , .{ expect_starts_with, actual_stderr });
+            , .{ expect_starts_with, actual_errors });
         },
         .contains => |expect_line| {
             while (actual_line_it.next()) |actual_line| {
@@ -1976,6 +1989,29 @@ fn checkCompileErrors(compile: *Compile) !void {
                 return;
             }
 
+            return compile.step.fail(
+                \\
+                \\========= should contain: ===============
+                \\{s}
+                \\========= but not found: ================
+                \\{s}
+                \\=========================================
+            , .{ expect_line, actual_errors });
+        },
+        .stderr_contains => |expect_line| {
+            const actual_stderr: []const u8 = if (compile.step.result_error_msgs.items.len > 0)
+                compile.step.result_error_msgs.items[0]
+            else
+                &.{};
+            compile.step.result_error_msgs.clearRetainingCapacity();
+
+            var stderr_line_it = mem.splitScalar(u8, actual_stderr, '\n');
+
+            while (stderr_line_it.next()) |actual_line| {
+                if (!matchCompileError(actual_line, expect_line)) continue;
+                return;
+            }
+
             return compile.step.fail(
                 \\
                 \\========= should contain: ===============
@@ -2001,7 +2037,7 @@ fn checkCompileErrors(compile: *Compile) !void {
                 try expected_generated.append('\n');
             }
 
-            if (mem.eql(u8, expected_generated.items, actual_stderr)) return;
+            if (mem.eql(u8, expected_generated.items, actual_errors)) return;
 
             return compile.step.fail(
                 \\
@@ -2010,7 +2046,7 @@ fn checkCompileErrors(compile: *Compile) !void {
                 \\========= but found: ====================
                 \\{s}
                 \\=========================================
-            , .{ expected_generated.items, actual_stderr });
+            , .{ expected_generated.items, actual_errors });
         },
     }
 }
diff --git a/zig/lib/std/Build/Watch.zig b/zig/lib/std/Build/Watch.zig
index c8f6c0d64f..2ddb3ca4c2 100644
--- a/zig/lib/std/Build/Watch.zig
+++ b/zig/lib/std/Build/Watch.zig
@@ -10,6 +10,8 @@ dir_table: DirTable,
 os: Os,
 generation: Generation,
 
+pub const have_impl = Os != void;
+
 /// Key is the directory to watch which contains one or more files we are
 /// interested in noticing changes to.
 ///
@@ -89,6 +91,38 @@ const Os = switch (builtin.os.tag) {
             };
         };
 
+        fn init() !Watch {
+            const fan_fd = std.posix.fanotify_init(.{
+                .CLASS = .NOTIF,
+                .CLOEXEC = true,
+                .NONBLOCK = true,
+                .REPORT_NAME = true,
+                .REPORT_DIR_FID = true,
+                .REPORT_FID = true,
+                .REPORT_TARGET_FID = true,
+            }, 0) catch |err| switch (err) {
+                error.UnsupportedFlags => fatal("fanotify_init failed due to old kernel; requires 5.17+", .{}),
+                else => |e| return e,
+            };
+            return .{
+                .dir_table = .{},
+                .os = switch (builtin.os.tag) {
+                    .linux => .{
+                        .handle_table = .{},
+                        .poll_fds = .{
+                            .{
+                                .fd = fan_fd,
+                                .events = std.posix.POLL.IN,
+                                .revents = undefined,
+                            },
+                        },
+                    },
+                    else => {},
+                },
+                .generation = 0,
+            };
+        }
+
         fn getDirHandle(gpa: Allocator, path: std.Build.Cache.Path) !FileHandle {
             var file_handle_buffer: [@sizeOf(std.os.linux.file_handle) + 128]u8 align(@alignOf(std.os.linux.file_handle)) = undefined;
             var mount_id: i32 = undefined;
@@ -236,6 +270,16 @@ const Os = switch (builtin.os.tag) {
                 w.generation +%= 1;
             }
         }
+
+        fn wait(w: *Watch, gpa: Allocator, timeout: Timeout) !WaitResult {
+            const events_len = try std.posix.poll(&w.os.poll_fds, timeout.to_i32_ms());
+            return if (events_len == 0)
+                .timeout
+            else if (try Os.markDirtySteps(w, gpa))
+                .dirty
+            else
+                .clean;
+        }
     },
     .windows => struct {
         const windows = std.os.windows;
@@ -356,6 +400,21 @@ const Os = switch (builtin.os.tag) {
             }
         };
 
+        fn init() !Watch {
+            return .{
+                .dir_table = .{},
+                .os = switch (builtin.os.tag) {
+                    .windows => .{
+                        .handle_table = .{},
+                        .dir_list = .{},
+                        .io_cp = null,
+                    },
+                    else => {},
+                },
+                .generation = 0,
+            };
+        }
+
         fn getFileId(handle: windows.HANDLE) !FileId {
             var file_id: FileId = undefined;
             var io_status: windows.IO_STATUS_BLOCK = undefined;
@@ -509,59 +568,258 @@ const Os = switch (builtin.os.tag) {
                 w.generation +%= 1;
             }
         }
+
+        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.
+                .Cancelled => continue,
+                else => break error.Unexpected,
+            };
+        }
     },
-    else => void,
-};
+    .dragonfly, .freebsd, .netbsd, .openbsd, .ios, .macos, .tvos, .visionos, .watchos, .haiku => struct {
+        const posix = std.posix;
 
-pub fn init() !Watch {
-    switch (builtin.os.tag) {
-        .linux => {
-            const fan_fd = std.posix.fanotify_init(.{
-                .CLASS = .NOTIF,
+        kq_fd: i32,
+        /// Indexes correspond 1:1 with `dir_table`.
+        handles: std.MultiArrayList(struct {
+            rs: ReactionSet,
+            /// If the corresponding dir_table Path has sub_path == "", then it
+            /// suffices as the open directory handle, and this value will be
+            /// -1. Otherwise, it needs to be opened in update(), and will be
+            /// stored here.
+            dir_fd: i32,
+            /// Number of files being watched by this directory handle.
+            ref_count: u32,
+        }),
+
+        const dir_open_flags: posix.O = f: {
+            var f: posix.O = .{
+                .ACCMODE = .RDONLY,
+                .NOFOLLOW = false,
+                .DIRECTORY = true,
                 .CLOEXEC = true,
-                .NONBLOCK = true,
-                .REPORT_NAME = true,
-                .REPORT_DIR_FID = true,
-                .REPORT_FID = true,
-                .REPORT_TARGET_FID = true,
-            }, 0) catch |err| switch (err) {
-                error.UnsupportedFlags => fatal("fanotify_init failed due to old kernel; requires 5.17+", .{}),
-                else => |e| return e,
-            };
-            return .{
-                .dir_table = .{},
-                .os = switch (builtin.os.tag) {
-                    .linux => .{
-                        .handle_table = .{},
-                        .poll_fds = .{
-                            .{
-                                .fd = fan_fd,
-                                .events = std.posix.POLL.IN,
-                                .revents = undefined,
-                            },
-                        },
-                    },
-                    else => {},
-                },
-                .generation = 0,
             };
-        },
-        .windows => {
+            if (@hasField(posix.O, "EVTONLY")) f.EVTONLY = true;
+            if (@hasField(posix.O, "PATH")) f.PATH = true;
+            break :f f;
+        };
+
+        const EV = std.c.EV;
+        const NOTE = std.c.NOTE;
+
+        fn init() !Watch {
+            const kq_fd = try posix.kqueue();
+            errdefer posix.close(kq_fd);
             return .{
                 .dir_table = .{},
-                .os = switch (builtin.os.tag) {
-                    .windows => .{
-                        .handle_table = .{},
-                        .dir_list = .{},
-                        .io_cp = null,
-                    },
-                    else => {},
+                .os = .{
+                    .kq_fd = kq_fd,
+                    .handles = .empty,
                 },
                 .generation = 0,
             };
-        },
-        else => @panic("unimplemented"),
-    }
+        }
+
+        fn update(w: *Watch, gpa: Allocator, steps: []const *Step) !void {
+            const handles = &w.os.handles;
+            for (steps) |step| {
+                for (step.inputs.table.keys(), step.inputs.table.values()) |path, *files| {
+                    const reaction_set = rs: {
+                        const gop = try w.dir_table.getOrPut(gpa, path);
+                        if (!gop.found_existing) {
+                            const skip_open_dir = path.sub_path.len == 0;
+                            const dir_fd = if (skip_open_dir)
+                                path.root_dir.handle.fd
+                            else
+                                posix.openat(path.root_dir.handle.fd, path.sub_path, dir_open_flags, 0) catch |err| {
+                                    fatal("failed to open directory {}: {s}", .{ path, @errorName(err) });
+                                };
+                            // Empirically the dir has to stay open or else no events are triggered.
+                            errdefer if (!skip_open_dir) posix.close(dir_fd);
+                            const changes = [1]posix.Kevent{.{
+                                .ident = @bitCast(@as(isize, dir_fd)),
+                                .filter = std.c.EVFILT.VNODE,
+                                .flags = EV.ADD | EV.ENABLE | EV.CLEAR,
+                                .fflags = NOTE.DELETE | NOTE.WRITE | NOTE.RENAME | NOTE.REVOKE,
+                                .data = 0,
+                                .udata = gop.index,
+                            }};
+                            _ = try posix.kevent(w.os.kq_fd, &changes, &.{}, null);
+                            assert(handles.len == gop.index);
+                            try handles.append(gpa, .{
+                                .rs = .{},
+                                .dir_fd = if (skip_open_dir) -1 else dir_fd,
+                                .ref_count = 1,
+                            });
+                        } else {
+                            handles.items(.ref_count)[gop.index] += 1;
+                        }
+                        break :rs &handles.items(.rs)[gop.index];
+                    };
+                    for (files.items) |basename| {
+                        const gop = try reaction_set.getOrPut(gpa, basename);
+                        if (!gop.found_existing) gop.value_ptr.* = .{};
+                        try gop.value_ptr.put(gpa, step, w.generation);
+                    }
+                }
+            }
+
+            {
+                // Remove marks for files that are no longer inputs.
+                var i: usize = 0;
+                while (i < handles.len) {
+                    {
+                        const reaction_set = &handles.items(.rs)[i];
+                        var step_set_i: usize = 0;
+                        while (step_set_i < reaction_set.entries.len) {
+                            const step_set = &reaction_set.values()[step_set_i];
+                            var dirent_i: usize = 0;
+                            while (dirent_i < step_set.entries.len) {
+                                const generations = step_set.values();
+                                if (generations[dirent_i] == w.generation) {
+                                    dirent_i += 1;
+                                    continue;
+                                }
+                                step_set.swapRemoveAt(dirent_i);
+                            }
+                            if (step_set.entries.len > 0) {
+                                step_set_i += 1;
+                                continue;
+                            }
+                            reaction_set.swapRemoveAt(step_set_i);
+                        }
+                        if (reaction_set.entries.len > 0) {
+                            i += 1;
+                            continue;
+                        }
+                    }
+
+                    const ref_count_ptr = &handles.items(.ref_count)[i];
+                    ref_count_ptr.* -= 1;
+                    if (ref_count_ptr.* > 0) continue;
+
+                    // If the sub_path == "" then this patch has already the
+                    // dir fd that we need to use as the ident to remove the
+                    // event. If it was opened above with openat() then we need
+                    // to access that data via the dir_fd field.
+                    const path = w.dir_table.keys()[i];
+                    const dir_fd = if (path.sub_path.len == 0)
+                        path.root_dir.handle.fd
+                    else
+                        handles.items(.dir_fd)[i];
+                    assert(dir_fd != -1);
+
+                    // The changelist also needs to update the udata field of the last
+                    // event, since we are doing a swap remove, and we store the dir_table
+                    // index in the udata field.
+                    const last_dir_fd = fd: {
+                        const last_path = w.dir_table.keys()[handles.len - 1];
+                        const last_dir_fd = if (last_path.sub_path.len != 0)
+                            last_path.root_dir.handle.fd
+                        else
+                            handles.items(.dir_fd)[i];
+                        assert(last_dir_fd != -1);
+                        break :fd last_dir_fd;
+                    };
+                    const changes = [_]posix.Kevent{
+                        .{
+                            .ident = @bitCast(@as(isize, dir_fd)),
+                            .filter = std.c.EVFILT.VNODE,
+                            .flags = EV.DELETE,
+                            .fflags = 0,
+                            .data = 0,
+                            .udata = i,
+                        },
+                        .{
+                            .ident = @bitCast(@as(isize, last_dir_fd)),
+                            .filter = std.c.EVFILT.VNODE,
+                            .flags = EV.ADD,
+                            .fflags = NOTE.DELETE | NOTE.WRITE | NOTE.RENAME | NOTE.REVOKE,
+                            .data = 0,
+                            .udata = i,
+                        },
+                    };
+                    const filtered_changes = if (i == handles.len - 1) changes[0..1] else &changes;
+                    _ = try posix.kevent(w.os.kq_fd, filtered_changes, &.{}, null);
+                    if (path.sub_path.len != 0) posix.close(dir_fd);
+
+                    w.dir_table.swapRemoveAt(i);
+                    handles.swapRemove(i);
+                }
+                w.generation +%= 1;
+            }
+        }
+
+        fn wait(w: *Watch, gpa: Allocator, timeout: Timeout) !WaitResult {
+            var timespec_buffer: posix.timespec = undefined;
+            var event_buffer: [100]posix.Kevent = undefined;
+            var n = try posix.kevent(w.os.kq_fd, &.{}, &event_buffer, timeout.toTimespec(&timespec_buffer));
+            if (n == 0) return .timeout;
+            const reaction_sets = w.os.handles.items(.rs);
+            var any_dirty = markDirtySteps(gpa, reaction_sets, event_buffer[0..n], false);
+            timespec_buffer = .{ .sec = 0, .nsec = 0 };
+            while (n == event_buffer.len) {
+                n = try posix.kevent(w.os.kq_fd, &.{}, &event_buffer, &timespec_buffer);
+                if (n == 0) break;
+                any_dirty = markDirtySteps(gpa, reaction_sets, event_buffer[0..n], any_dirty);
+            }
+            return if (any_dirty) .dirty else .clean;
+        }
+
+        fn markDirtySteps(
+            gpa: Allocator,
+            reaction_sets: []ReactionSet,
+            events: []const std.c.Kevent,
+            start_any_dirty: bool,
+        ) bool {
+            var any_dirty = start_any_dirty;
+            for (events) |event| {
+                const index: usize = @intCast(event.udata);
+                const reaction_set = &reaction_sets[index];
+                // If we knew the basename of the changed file, here we would
+                // mark only the step set dirty, and possibly the glob set:
+                //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);
+                // However we don't know the file name so just mark all the
+                // sets dirty for this directory.
+                for (reaction_set.values()) |*step_set| {
+                    any_dirty = markStepSetDirty(gpa, step_set, any_dirty);
+                }
+            }
+            return any_dirty;
+        }
+    },
+    else => void,
+};
+
+pub fn init() !Watch {
+    return Os.init();
 }
 
 pub const Match = struct {
@@ -609,10 +867,7 @@ fn markStepSetDirty(gpa: Allocator, step_set: *StepSet, any_dirty: bool) bool {
 }
 
 pub fn update(w: *Watch, gpa: Allocator, steps: []const *Step) !void {
-    switch (builtin.os.tag) {
-        .linux, .windows => return Os.update(w, gpa, steps),
-        else => @compileError("unimplemented"),
-    }
+    return Os.update(w, gpa, steps);
 }
 
 pub const Timeout = union(enum) {
@@ -625,6 +880,20 @@ pub const Timeout = union(enum) {
             .ms => |ms| ms,
         };
     }
+
+    pub fn toTimespec(t: Timeout, buf: *std.posix.timespec) ?*std.posix.timespec {
+        return switch (t) {
+            .none => null,
+            .ms => |ms_u16| {
+                const ms: isize = ms_u16;
+                buf.* = .{
+                    .sec = @divTrunc(ms, std.time.ms_per_s),
+                    .nsec = @rem(ms, std.time.ms_per_s) * std.time.ns_per_ms,
+                };
+                return buf;
+            },
+        };
+    }
 };
 
 pub const WaitResult = enum {
@@ -638,46 +907,5 @@ pub const WaitResult = enum {
 };
 
 pub fn wait(w: *Watch, gpa: Allocator, timeout: Timeout) !WaitResult {
-    switch (builtin.os.tag) {
-        .linux => {
-            const events_len = try std.posix.poll(&w.os.poll_fds, timeout.to_i32_ms());
-            return if (events_len == 0)
-                .timeout
-            else if (try Os.markDirtySteps(w, gpa))
-                .dirty
-            else
-                .clean;
-        },
-        .windows => {
-            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.
-                .Cancelled => continue,
-                else => break error.Unexpected,
-            };
-        },
-        else => @compileError("unimplemented"),
-    }
+    return Os.wait(w, gpa, timeout);
 }
diff --git a/zig/lib/std/Progress.zig b/zig/lib/std/Progress.zig
index 7e24f25c73..513a939367 100644
--- a/zig/lib/std/Progress.zig
+++ b/zig/lib/std/Progress.zig
@@ -188,7 +188,8 @@ pub const Node = struct {
         var opt_free_index = @atomicLoad(Node.OptionalIndex, freelist_head, .seq_cst);
         while (opt_free_index.unwrap()) |free_index| {
             const freelist_ptr = freelistByIndex(free_index);
-            opt_free_index = @cmpxchgWeak(Node.OptionalIndex, freelist_head, opt_free_index, freelist_ptr.*, .seq_cst, .seq_cst) orelse {
+            const next = @atomicLoad(Node.OptionalIndex, freelist_ptr, .seq_cst);
+            opt_free_index = @cmpxchgWeak(Node.OptionalIndex, freelist_head, opt_free_index, next, .seq_cst, .seq_cst) orelse {
                 // We won the allocation race.
                 return init(free_index, parent, name, estimated_total_items);
             };
@@ -249,7 +250,7 @@ pub const Node = struct {
             const freelist_head = &global_progress.node_freelist_first;
             var first = @atomicLoad(Node.OptionalIndex, freelist_head, .seq_cst);
             while (true) {
-                freelistByIndex(index).* = first;
+                @atomicStore(Node.OptionalIndex, freelistByIndex(index), first, .seq_cst);
                 first = @cmpxchgWeak(Node.OptionalIndex, freelist_head, first, index.toOptional(), .seq_cst, .seq_cst) orelse break;
             }
         } else {
diff --git a/zig/lib/std/Random.zig b/zig/lib/std/Random.zig
index 3de754c6de..74df589a67 100644
--- a/zig/lib/std/Random.zig
+++ b/zig/lib/std/Random.zig
@@ -86,7 +86,7 @@ pub fn enumValueWithIndex(r: Random, comptime EnumType: type, comptime Index: ty
     const values = comptime std.enums.values(EnumType);
     comptime assert(values.len > 0); // can't return anything
     comptime assert(maxInt(Index) >= values.len - 1); // can't access all values
-    comptime if (values.len == 1) return values[0];
+    if (values.len == 1) return values[0];
 
     const index = if (comptime values.len - 1 == maxInt(Index))
         r.int(Index)
diff --git a/zig/lib/std/SemanticVersion.zig b/zig/lib/std/SemanticVersion.zig
index bde3e906d8..7cb3888e54 100644
--- a/zig/lib/std/SemanticVersion.zig
+++ b/zig/lib/std/SemanticVersion.zig
@@ -299,7 +299,7 @@ test "precedence" {
 
 test "zig_version" {
     // An approximate Zig build that predates this test.
-    const older_version = .{ .major = 0, .minor = 8, .patch = 0, .pre = "dev.874" };
+    const older_version: Version = .{ .major = 0, .minor = 8, .patch = 0, .pre = "dev.874" };
 
     // Simulated compatibility check using Zig version.
     const compatible = comptime @import("builtin").zig_version.order(older_version) == .gt;
diff --git a/zig/lib/std/Target.zig b/zig/lib/std/Target.zig
index efe8ad4809..b2808255b0 100644
--- a/zig/lib/std/Target.zig
+++ b/zig/lib/std/Target.zig
@@ -157,52 +157,65 @@ pub const Os = struct {
             };
         }
 
-        pub inline fn getVersionRangeTag(tag: Tag) @typeInfo(TaggedVersionRange).@"union".tag_type.? {
+        pub inline fn versionRangeTag(tag: Tag) @typeInfo(TaggedVersionRange).@"union".tag_type.? {
             return switch (tag) {
                 .freestanding,
-                .fuchsia,
-                .ps3,
-                .zos,
+                .other,
+
+                .elfiamcu,
+
                 .haiku,
-                .rtems,
-                .aix,
-                .cuda,
-                .nvcl,
-                .amdhsa,
+                .plan9,
+                .serenity,
+
+                // This should use semver once we determine the version history.
+                .bridgeos,
+
+                .illumos,
+
+                .ps3,
                 .ps4,
                 .ps5,
-                .elfiamcu,
+
+                .emscripten,
+
                 .mesa3d,
+                => .none,
+
                 .contiki,
-                .amdpal,
+                .fuchsia,
                 .hermit,
+
+                .aix,
                 .hurd,
-                .emscripten,
-                .uefi,
-                .opencl, // TODO: OpenCL versions
-                .opengl, // TODO: GLSL versions
-                .vulkan,
-                .plan9,
-                .illumos,
-                .serenity,
-                .other,
-                => .none,
+                .rtems,
+                .zos,
 
-                // This should use semver once we determine the version history.
-                .bridgeos => .none,
+                .dragonfly,
+                .freebsd,
+                .netbsd,
+                .openbsd,
 
                 .driverkit,
-                .freebsd,
                 .macos,
                 .ios,
                 .tvos,
-                .watchos,
                 .visionos,
-                .netbsd,
-                .openbsd,
-                .dragonfly,
+                .watchos,
+
                 .solaris,
+
+                .uefi,
+
                 .wasi,
+
+                .amdhsa,
+                .amdpal,
+                .cuda,
+                .nvcl,
+                .opencl,
+                .opengl,
+                .vulkan,
                 => .semver,
 
                 .linux => .linux,
@@ -257,10 +270,11 @@ pub const Os = struct {
         win11_zn = 0x0A00000E, //aka win11_21h2
         win11_ga = 0x0A00000F, //aka win11_22h2
         win11_ge = 0x0A000010, //aka win11_23h2
+        win11_dt = 0x0A000011, //aka win11_24h2
         _,
 
         /// Latest Windows version that the Zig Standard Library is aware of
-        pub const latest = WindowsVersion.win11_ge;
+        pub const latest = WindowsVersion.win11_dt;
 
         /// Compared against build numbers reported by the runtime to distinguish win10 versions,
         /// where 0x0A000000 + index corresponds to the WindowsVersion u32 value.
@@ -282,6 +296,7 @@ pub const Os = struct {
             22000, //win11_zn aka win11_21h2
             22621, //win11_ga aka win11_22h2
             22631, //win11_ge aka win11_23h2
+            26100, //win11_dt aka win11_24h2
         };
 
         /// Returns whether the first version `ver` is newer (greater) than or equal to the second version `ver`.
@@ -344,6 +359,8 @@ pub const Os = struct {
     pub const LinuxVersionRange = struct {
         range: std.SemanticVersion.Range,
         glibc: std.SemanticVersion,
+        /// Android API level.
+        android: u32 = 14, // This default value is to be deleted after zig1.wasm is updated.
 
         pub inline fn includesVersion(range: LinuxVersionRange, ver: std.SemanticVersion) bool {
             return range.range.includesVersion(ver);
@@ -391,84 +408,106 @@ pub const Os = struct {
         pub fn default(tag: Tag, arch: Cpu.Arch) VersionRange {
             return switch (tag) {
                 .freestanding,
-                .fuchsia,
-                .ps3,
-                .zos,
-                .haiku,
-                .rtems,
-                .aix,
-                .cuda,
-                .nvcl,
-                .amdhsa,
-                .ps4,
-                .ps5,
+                .other,
+
                 .elfiamcu,
-                .mesa3d,
-                .contiki,
-                .amdpal,
-                .hermit,
-                .hurd,
-                .emscripten,
-                .uefi,
-                .opencl, // TODO: OpenCL versions
-                .opengl, // TODO: GLSL versions
-                .vulkan,
+
+                .haiku,
                 .plan9,
-                .illumos,
                 .serenity,
+
+                // This should use semver once we determine the version history.
                 .bridgeos,
-                .other,
+
+                .illumos,
+
+                .ps3,
+                .ps4,
+                .ps5,
+
+                .emscripten,
+
+                .mesa3d,
                 => .{ .none = {} },
 
-                .freebsd => .{
-                    .semver = std.SemanticVersion.Range{
-                        .min = .{ .major = 12, .minor = 0, .patch = 0 },
-                        .max = .{ .major = 14, .minor = 0, .patch = 0 },
+                .contiki => .{
+                    .semver = .{
+                        .min = .{ .major = 4, .minor = 0, .patch = 0 },
+                        .max = .{ .major = 4, .minor = 9, .patch = 0 },
                     },
                 },
-                .driverkit => .{
+                .fuchsia => .{
                     .semver = .{
-                        .min = .{ .major = 19, .minor = 0, .patch = 0 },
-                        .max = .{ .major = 24, .minor = 0, .patch = 0 },
+                        .min = .{ .major = 1, .minor = 1, .patch = 0 },
+                        .max = .{ .major = 20, .minor = 1, .patch = 0 },
                     },
                 },
-                .macos => switch (arch) {
-                    .aarch64 => VersionRange{
-                        .semver = .{
-                            .min = .{ .major = 11, .minor = 7, .patch = 1 },
-                            .max = .{ .major = 14, .minor = 6, .patch = 1 },
-                        },
+                .hermit => .{
+                    .semver = .{
+                        .min = .{ .major = 0, .minor = 4, .patch = 0 },
+                        .max = .{ .major = 0, .minor = 8, .patch = 0 },
+                    },
+                },
+
+                .aix => .{
+                    .semver = .{
+                        .min = .{ .major = 7, .minor = 2, .patch = 5 },
+                        .max = .{ .major = 7, .minor = 3, .patch = 2 },
+                    },
+                },
+                .hurd => .{
+                    .semver = .{
+                        .min = .{ .major = 0, .minor = 9, .patch = 0 },
+                        .max = .{ .major = 0, .minor = 9, .patch = 0 },
                     },
-                    .x86_64 => VersionRange{
-                        .semver = .{
-                            .min = .{ .major = 11, .minor = 7, .patch = 1 },
-                            .max = .{ .major = 14, .minor = 6, .patch = 1 },
+                },
+                .linux => .{
+                    .linux = .{
+                        .range = .{
+                            .min = .{ .major = 4, .minor = 19, .patch = 0 },
+                            .max = .{ .major = 6, .minor = 11, .patch = 5 },
+                        },
+                        .glibc = blk: {
+                            const default_min: std.SemanticVersion = .{ .major = 2, .minor = 28, .patch = 0 };
+
+                            for (std.zig.target.available_libcs) |libc| {
+                                // We don't know the ABI here. We can get away with not checking it
+                                // for now, but that may not always remain true.
+                                if (libc.os != tag or libc.arch != arch) continue;
+
+                                if (libc.glibc_min) |min| {
+                                    if (min.order(default_min) == .gt) break :blk min;
+                                }
+                            }
+
+                            break :blk default_min;
                         },
+                        .android = 14,
                     },
-                    else => unreachable,
                 },
-                .ios => .{
+                .rtems => .{
                     .semver = .{
-                        .min = .{ .major = 12, .minor = 0, .patch = 0 },
-                        .max = .{ .major = 17, .minor = 6, .patch = 1 },
+                        .min = .{ .major = 5, .minor = 1, .patch = 0 },
+                        .max = .{ .major = 5, .minor = 3, .patch = 0 },
                     },
                 },
-                .watchos => .{
+                .zos => .{
                     .semver = .{
-                        .min = .{ .major = 6, .minor = 0, .patch = 0 },
-                        .max = .{ .major = 10, .minor = 6, .patch = 0 },
+                        .min = .{ .major = 2, .minor = 5, .patch = 0 },
+                        .max = .{ .major = 3, .minor = 1, .patch = 0 },
                     },
                 },
-                .tvos => .{
+
+                .dragonfly => .{
                     .semver = .{
-                        .min = .{ .major = 13, .minor = 0, .patch = 0 },
-                        .max = .{ .major = 17, .minor = 6, .patch = 0 },
+                        .min = .{ .major = 5, .minor = 8, .patch = 0 },
+                        .max = .{ .major = 6, .minor = 4, .patch = 0 },
                     },
                 },
-                .visionos => .{
+                .freebsd => .{
                     .semver = .{
-                        .min = .{ .major = 1, .minor = 0, .patch = 0 },
-                        .max = .{ .major = 1, .minor = 3, .patch = 0 },
+                        .min = .{ .major = 12, .minor = 0, .patch = 0 },
+                        .max = .{ .major = 14, .minor = 1, .patch = 0 },
                     },
                 },
                 .netbsd => .{
@@ -480,49 +519,51 @@ pub const Os = struct {
                 .openbsd => .{
                     .semver = .{
                         .min = .{ .major = 7, .minor = 3, .patch = 0 },
-                        .max = .{ .major = 7, .minor = 5, .patch = 0 },
+                        .max = .{ .major = 7, .minor = 6, .patch = 0 },
                     },
                 },
-                .dragonfly => .{
+
+                .driverkit => .{
                     .semver = .{
-                        .min = .{ .major = 5, .minor = 8, .patch = 0 },
-                        .max = .{ .major = 6, .minor = 4, .patch = 0 },
+                        .min = .{ .major = 19, .minor = 0, .patch = 0 },
+                        .max = .{ .major = 24, .minor = 2, .patch = 0 },
                     },
                 },
-                .solaris => .{
+                .macos => .{
                     .semver = .{
-                        .min = .{ .major = 11, .minor = 0, .patch = 0 },
-                        .max = .{ .major = 11, .minor = 4, .patch = 0 },
+                        .min = .{ .major = 11, .minor = 7, .patch = 1 },
+                        .max = .{ .major = 15, .minor = 2, .patch = 0 },
                     },
                 },
-                .wasi => .{
+                .ios => .{
                     .semver = .{
-                        .min = .{ .major = 0, .minor = 1, .patch = 0 },
-                        .max = .{ .major = 0, .minor = 1, .patch = 0 },
+                        .min = .{ .major = 12, .minor = 0, .patch = 0 },
+                        .max = .{ .major = 18, .minor = 1, .patch = 0 },
+                    },
+                },
+                .tvos => .{
+                    .semver = .{
+                        .min = .{ .major = 13, .minor = 0, .patch = 0 },
+                        .max = .{ .major = 18, .minor = 1, .patch = 0 },
+                    },
+                },
+                .visionos => .{
+                    .semver = .{
+                        .min = .{ .major = 1, .minor = 0, .patch = 0 },
+                        .max = .{ .major = 2, .minor = 1, .patch = 0 },
+                    },
+                },
+                .watchos => .{
+                    .semver = .{
+                        .min = .{ .major = 6, .minor = 0, .patch = 0 },
+                        .max = .{ .major = 11, .minor = 1, .patch = 0 },
                     },
                 },
 
-                .linux => .{
-                    .linux = .{
-                        .range = .{
-                            .min = .{ .major = 4, .minor = 19, .patch = 0 },
-                            .max = .{ .major = 6, .minor = 10, .patch = 3 },
-                        },
-                        .glibc = blk: {
-                            const default_min = .{ .major = 2, .minor = 28, .patch = 0 };
-
-                            for (std.zig.target.available_libcs) |libc| {
-                                // We don't know the ABI here. We can get away with not checking it
-                                // for now, but that may not always remain true.
-                                if (libc.os != tag or libc.arch != arch) continue;
-
-                                if (libc.glibc_min) |min| {
-                                    if (min.order(default_min) == .gt) break :blk min;
-                                }
-                            }
-
-                            break :blk default_min;
-                        },
+                .solaris => .{
+                    .semver = .{
+                        .min = .{ .major = 11, .minor = 0, .patch = 0 },
+                        .max = .{ .major = 11, .minor = 4, .patch = 0 },
                     },
                 },
 
@@ -532,6 +573,58 @@ pub const Os = struct {
                         .max = WindowsVersion.latest,
                     },
                 },
+                .uefi => .{
+                    .semver = .{
+                        .min = .{ .major = 2, .minor = 0, .patch = 0 },
+                        .max = .{ .major = 2, .minor = 9, .patch = 0 },
+                    },
+                },
+
+                .wasi => .{
+                    .semver = .{
+                        .min = .{ .major = 0, .minor = 1, .patch = 0 },
+                        .max = .{ .major = 0, .minor = 2, .patch = 2 },
+                    },
+                },
+
+                .amdhsa => .{
+                    .semver = .{
+                        .min = .{ .major = 5, .minor = 0, .patch = 2 },
+                        .max = .{ .major = 6, .minor = 2, .patch = 2 },
+                    },
+                },
+                .amdpal => .{
+                    .semver = .{
+                        .min = .{ .major = 1, .minor = 1, .patch = 0 },
+                        .max = .{ .major = 3, .minor = 5, .patch = 0 },
+                    },
+                },
+                .cuda => .{
+                    .semver = .{
+                        .min = .{ .major = 11, .minor = 0, .patch = 1 },
+                        .max = .{ .major = 12, .minor = 6, .patch = 1 },
+                    },
+                },
+                .nvcl,
+                .opencl,
+                => .{
+                    .semver = .{
+                        .min = .{ .major = 2, .minor = 2, .patch = 0 },
+                        .max = .{ .major = 3, .minor = 0, .patch = 0 },
+                    },
+                },
+                .opengl => .{
+                    .semver = .{
+                        .min = .{ .major = 4, .minor = 5, .patch = 0 },
+                        .max = .{ .major = 4, .minor = 6, .patch = 0 },
+                    },
+                },
+                .vulkan => .{
+                    .semver = .{
+                        .min = .{ .major = 1, .minor = 2, .patch = 0 },
+                        .max = .{ .major = 1, .minor = 3, .patch = 0 },
+                    },
+                },
             };
         }
     };
@@ -545,8 +638,8 @@ pub const Os = struct {
 
     /// Provides a tagged union. `Target` does not store the tag because it is
     /// redundant with the OS tag; this function abstracts that part away.
-    pub inline fn getVersionRange(os: Os) TaggedVersionRange {
-        return switch (os.tag.getVersionRangeTag()) {
+    pub inline fn versionRange(os: Os) TaggedVersionRange {
+        return switch (os.tag.versionRangeTag()) {
             .none => .{ .none = {} },
             .semver => .{ .semver = os.version_range.semver },
             .linux => .{ .linux = os.version_range.linux },
@@ -556,12 +649,12 @@ pub const Os = struct {
 
     /// Checks if system is guaranteed to be at least `version` or older than `version`.
     /// Returns `null` if a runtime check is required.
-    pub inline fn isAtLeast(os: Os, comptime tag: Tag, ver: switch (tag.getVersionRangeTag()) {
+    pub inline fn isAtLeast(os: Os, comptime tag: Tag, ver: switch (tag.versionRangeTag()) {
         .none => void,
         .semver, .linux => std.SemanticVersion,
         .windows => WindowsVersion,
     }) ?bool {
-        return if (os.tag != tag) false else switch (tag.getVersionRangeTag()) {
+        return if (os.tag != tag) false else switch (tag.versionRangeTag()) {
             .none => true,
             inline .semver,
             .linux,
@@ -626,7 +719,7 @@ pub const Os = struct {
 
 pub const aarch64 = @import("Target/aarch64.zig");
 pub const arc = @import("Target/arc.zig");
-pub const amdgpu = @import("Target/amdgpu.zig");
+pub const amdgcn = @import("Target/amdgcn.zig");
 pub const arm = @import("Target/arm.zig");
 pub const avr = @import("Target/avr.zig");
 pub const bpf = @import("Target/bpf.zig");
@@ -668,6 +761,8 @@ pub const Abi = enum {
     android,
     androideabi,
     musl,
+    muslabin32,
+    muslabi64,
     musleabi,
     musleabihf,
     muslx32,
@@ -700,9 +795,7 @@ pub const Abi = enum {
 
     pub fn default(arch: Cpu.Arch, os: Os) Abi {
         return if (arch.isWasm()) .musl else switch (os.tag) {
-            .freestanding,
-            .other,
-            => switch (arch) {
+            .freestanding, .other => switch (arch) {
                 // Soft float is usually a sane default for freestanding.
                 .arm,
                 .armeb,
@@ -716,14 +809,32 @@ pub const Abi = enum {
                 => .eabi,
                 else => .none,
             },
-            .aix,
-            => if (arch == .powerpc) .eabihf else .none,
-            .linux,
-            .wasi,
-            .emscripten,
-            => .musl,
-            .rtems,
-            => switch (arch) {
+            .aix => if (arch == .powerpc) .eabihf else .none,
+            .haiku => switch (arch) {
+                .arm,
+                .thumb,
+                .powerpc,
+                => .eabihf,
+                else => .none,
+            },
+            .hurd => .gnu,
+            .linux => switch (arch) {
+                .arm,
+                .armeb,
+                .thumb,
+                .thumbeb,
+                .powerpc,
+                .powerpcle,
+                => .musleabihf,
+                // Soft float tends to be more common for CSKY and MIPS.
+                .csky,
+                => .gnueabi, // No musl support.
+                .mips,
+                .mipsel,
+                => .musleabi,
+                else => .musl,
+            },
+            .rtems => switch (arch) {
                 .arm,
                 .armeb,
                 .thumb,
@@ -735,37 +846,33 @@ pub const Abi = enum {
                 => .eabihf,
                 else => .none,
             },
-            .hurd,
-            .windows,
-            => .gnu,
-            .freebsd,
-            => switch (arch) {
+            .freebsd => switch (arch) {
                 .arm,
                 .armeb,
                 .thumb,
                 .thumbeb,
                 .powerpc,
                 => .eabihf,
+                // Soft float tends to be more common for MIPS.
                 .mips,
                 .mipsel,
                 => .eabi,
                 else => .none,
             },
-            .netbsd,
-            => switch (arch) {
+            .netbsd => switch (arch) {
                 .arm,
                 .armeb,
                 .thumb,
                 .thumbeb,
                 .powerpc,
                 => .eabihf,
+                // Soft float tends to be more common for MIPS.
                 .mips,
                 .mipsel,
                 => .eabi,
                 else => .none,
             },
-            .openbsd,
-            => switch (arch) {
+            .openbsd => switch (arch) {
                 .arm,
                 .thumb,
                 => .eabi,
@@ -773,18 +880,16 @@ pub const Abi = enum {
                 => .eabihf,
                 else => .none,
             },
-            .ios,
-            => if (arch == .x86_64) .macabi else .none,
-            .tvos,
-            .visionos,
-            => if (arch == .x86_64) .simulator else .none,
-            .uefi,
-            => .msvc,
+            .ios => if (arch == .x86_64) .macabi else .none,
+            .tvos, .visionos, .watchos => if (arch == .x86_64) .simulator else .none,
+            .windows => .gnu,
+            .uefi => .msvc,
+            .wasi, .emscripten => .musl,
+
             .contiki,
             .elfiamcu,
             .fuchsia,
             .hermit,
-            .haiku,
             .plan9,
             .serenity,
             .zos,
@@ -792,7 +897,6 @@ pub const Abi = enum {
             .bridgeos,
             .driverkit,
             .macos,
-            .watchos,
             .illumos,
             .solaris,
             .ps3,
@@ -829,6 +933,8 @@ pub const Abi = enum {
     pub inline fn isMusl(abi: Abi) bool {
         return switch (abi) {
             .musl,
+            .muslabin32,
+            .muslabi64,
             .musleabi,
             .musleabihf,
             .muslx32,
@@ -925,8 +1031,6 @@ pub const ObjectFormat = enum {
 };
 
 pub fn toElfMachine(target: Target) std.elf.EM {
-    if (target.os.tag == .elfiamcu) return .IAMCU;
-
     return switch (target.cpu.arch) {
         .amdgcn => .AMDGPU,
         .arc => .ARC_COMPACT,
@@ -950,7 +1054,7 @@ pub fn toElfMachine(target: Target) std.elf.EM {
         .sparc64 => .SPARCV9,
         .spu_2 => .SPU_2,
         .ve => .VE,
-        .x86 => .@"386",
+        .x86 => if (target.os.tag == .elfiamcu) .IAMCU else .@"386",
         .x86_64 => .X86_64,
         .xcore => .XCORE,
         .xtensa => .XTENSA,
@@ -972,7 +1076,7 @@ pub fn toElfMachine(target: Target) std.elf.EM {
 pub fn toCoffMachine(target: Target) std.coff.MachineType {
     return switch (target.cpu.arch) {
         .arm => .ARM,
-        .thumb => .THUMB,
+        .thumb => .ARMNT,
         .aarch64 => .ARM64,
         .loongarch32 => .LOONGARCH32,
         .loongarch64 => .LOONGARCH64,
@@ -1279,31 +1383,28 @@ pub const Cpu = struct {
             };
         }
 
-        pub inline fn isARM(arch: Arch) bool {
+        /// Note that this includes Thumb.
+        pub inline fn isArm(arch: Arch) bool {
             return switch (arch) {
                 .arm, .armeb => true,
-                else => false,
+                else => arch.isThumb(),
             };
         }
 
-        pub inline fn isAARCH64(arch: Arch) bool {
+        pub inline fn isThumb(arch: Arch) bool {
             return switch (arch) {
-                .aarch64, .aarch64_be => true,
+                .thumb, .thumbeb => true,
                 else => false,
             };
         }
 
-        pub inline fn isThumb(arch: Arch) bool {
+        pub inline fn isAARCH64(arch: Arch) bool {
             return switch (arch) {
-                .thumb, .thumbeb => true,
+                .aarch64, .aarch64_be => true,
                 else => false,
             };
         }
 
-        pub inline fn isArmOrThumb(arch: Arch) bool {
-            return arch.isARM() or arch.isThumb();
-        }
-
         pub inline fn isWasm(arch: Arch) bool {
             return switch (arch) {
                 .wasm32, .wasm64 => true,
@@ -1472,7 +1573,7 @@ pub const Cpu = struct {
                 .fs, .gs, .ss => arch == .x86_64 or arch == .x86,
                 .global, .constant, .local, .shared => is_gpu,
                 .param => is_nvptx,
-                .input, .output, .uniform => is_spirv,
+                .input, .output, .uniform, .push_constant, .storage_buffer => is_spirv,
                 // TODO this should also check how many flash banks the cpu has
                 .flash, .flash1, .flash2, .flash3, .flash4, .flash5 => arch == .avr,
 
@@ -1491,7 +1592,6 @@ pub const Cpu = struct {
                 .loongarch32, .loongarch64 => "loongarch",
                 .mips, .mipsel, .mips64, .mips64el => "mips",
                 .powerpc, .powerpcle, .powerpc64, .powerpc64le => "powerpc",
-                .amdgcn => "amdgpu",
                 .riscv32, .riscv64 => "riscv",
                 .sparc, .sparc64 => "sparc",
                 .s390x => "s390x",
@@ -1520,7 +1620,7 @@ pub const Cpu = struct {
                 .mips, .mipsel, .mips64, .mips64el => &mips.all_features,
                 .msp430 => &msp430.all_features,
                 .powerpc, .powerpcle, .powerpc64, .powerpc64le => &powerpc.all_features,
-                .amdgcn => &amdgpu.all_features,
+                .amdgcn => &amdgcn.all_features,
                 .riscv32, .riscv64 => &riscv.all_features,
                 .sparc, .sparc64 => &sparc.all_features,
                 .spirv, .spirv32, .spirv64 => &spirv.all_features,
@@ -1552,7 +1652,7 @@ pub const Cpu = struct {
                 .mips, .mipsel, .mips64, .mips64el => comptime allCpusFromDecls(mips.cpu),
                 .msp430 => comptime allCpusFromDecls(msp430.cpu),
                 .powerpc, .powerpcle, .powerpc64, .powerpc64le => comptime allCpusFromDecls(powerpc.cpu),
-                .amdgcn => comptime allCpusFromDecls(amdgpu.cpu),
+                .amdgcn => comptime allCpusFromDecls(amdgcn.cpu),
                 .riscv32, .riscv64 => comptime allCpusFromDecls(riscv.cpu),
                 .sparc, .sparc64 => comptime allCpusFromDecls(sparc.cpu),
                 .spirv, .spirv32, .spirv64 => comptime allCpusFromDecls(spirv.cpu),
@@ -1602,6 +1702,165 @@ pub const Cpu = struct {
                 else => ".X",
             };
         }
+
+        /// Returns the array of `Arch` to which a specific `std.builtin.CallingConvention` applies.
+        /// Asserts that `cc` is not `.auto`, `.@"async"`, `.naked`, or `.@"inline"`.
+        pub fn fromCallingConvention(cc: std.builtin.CallingConvention.Tag) []const Arch {
+            return switch (cc) {
+                .auto,
+                .@"async",
+                .naked,
+                .@"inline",
+                => unreachable,
+
+                .x86_64_sysv,
+                .x86_64_win,
+                .x86_64_regcall_v3_sysv,
+                .x86_64_regcall_v4_win,
+                .x86_64_vectorcall,
+                .x86_64_interrupt,
+                => &.{.x86_64},
+
+                .x86_sysv,
+                .x86_win,
+                .x86_stdcall,
+                .x86_fastcall,
+                .x86_thiscall,
+                .x86_thiscall_mingw,
+                .x86_regcall_v3,
+                .x86_regcall_v4_win,
+                .x86_vectorcall,
+                .x86_interrupt,
+                => &.{.x86},
+
+                .aarch64_aapcs,
+                .aarch64_aapcs_darwin,
+                .aarch64_aapcs_win,
+                .aarch64_vfabi,
+                .aarch64_vfabi_sve,
+                => &.{ .aarch64, .aarch64_be },
+
+                .arm_apcs,
+                .arm_aapcs,
+                .arm_aapcs_vfp,
+                .arm_aapcs16_vfp,
+                .arm_interrupt,
+                => &.{ .arm, .armeb, .thumb, .thumbeb },
+
+                .mips64_n64,
+                .mips64_n32,
+                .mips64_interrupt,
+                => &.{ .mips64, .mips64el },
+
+                .mips_o32,
+                .mips_interrupt,
+                => &.{ .mips, .mipsel },
+
+                .riscv64_lp64,
+                .riscv64_lp64_v,
+                .riscv64_interrupt,
+                => &.{.riscv64},
+
+                .riscv32_ilp32,
+                .riscv32_ilp32_v,
+                .riscv32_interrupt,
+                => &.{.riscv32},
+
+                .sparc64_sysv,
+                => &.{.sparc64},
+
+                .sparc_sysv,
+                => &.{.sparc},
+
+                .powerpc64_elf,
+                .powerpc64_elf_altivec,
+                .powerpc64_elf_v2,
+                => &.{ .powerpc64, .powerpc64le },
+
+                .powerpc_sysv,
+                .powerpc_sysv_altivec,
+                .powerpc_aix,
+                .powerpc_aix_altivec,
+                => &.{ .powerpc, .powerpcle },
+
+                .wasm_watc,
+                => &.{ .wasm64, .wasm32 },
+
+                .arc_sysv,
+                => &.{.arc},
+
+                .avr_gnu,
+                .avr_builtin,
+                .avr_signal,
+                .avr_interrupt,
+                => &.{.avr},
+
+                .bpf_std,
+                => &.{ .bpfel, .bpfeb },
+
+                .csky_sysv,
+                .csky_interrupt,
+                => &.{.csky},
+
+                .hexagon_sysv,
+                .hexagon_sysv_hvx,
+                => &.{.hexagon},
+
+                .lanai_sysv,
+                => &.{.lanai},
+
+                .loongarch64_lp64,
+                => &.{.loongarch64},
+
+                .loongarch32_ilp32,
+                => &.{.loongarch32},
+
+                .m68k_sysv,
+                .m68k_gnu,
+                .m68k_rtd,
+                .m68k_interrupt,
+                => &.{.m68k},
+
+                .msp430_eabi,
+                => &.{.msp430},
+
+                .propeller1_sysv,
+                => &.{.propeller1},
+
+                .propeller2_sysv,
+                => &.{.propeller2},
+
+                .s390x_sysv,
+                .s390x_sysv_vx,
+                => &.{.s390x},
+
+                .ve_sysv,
+                => &.{.ve},
+
+                .xcore_xs1,
+                .xcore_xs2,
+                => &.{.xcore},
+
+                .xtensa_call0,
+                .xtensa_windowed,
+                => &.{.xtensa},
+
+                .amdgcn_device,
+                .amdgcn_kernel,
+                .amdgcn_cs,
+                => &.{.amdgcn},
+
+                .nvptx_device,
+                .nvptx_kernel,
+                => &.{ .nvptx, .nvptx64 },
+
+                .spirv_device,
+                .spirv_kernel,
+                .spirv_fragment,
+                .spirv_vertex,
+                => &.{ .spirv, .spirv32, .spirv64 },
+            };
+        }
     };
 
     pub const Model = struct {
@@ -1619,6 +1878,9 @@ pub const Cpu = struct {
             };
         }
 
+        /// Returns the most bare-bones CPU model that is valid for `arch`. Note that this function
+        /// can return CPU models that are understood by LLVM, but *not* understood by Clang. If
+        /// Clang compatibility is important, consider using `baseline` instead.
         pub fn generic(arch: Arch) *const Model {
             const S = struct {
                 const generic_model = Model{
@@ -1628,10 +1890,11 @@ pub const Cpu = struct {
                 };
             };
             return switch (arch) {
+                .amdgcn => &amdgcn.cpu.gfx600,
                 .arc => &arc.cpu.generic,
                 .arm, .armeb, .thumb, .thumbeb => &arm.cpu.generic,
                 .aarch64, .aarch64_be => &aarch64.cpu.generic,
-                .avr => &avr.cpu.avr2,
+                .avr => &avr.cpu.avr1,
                 .bpfel, .bpfeb => &bpf.cpu.generic,
                 .csky => &csky.cpu.generic,
                 .hexagon => &hexagon.cpu.generic,
@@ -1642,13 +1905,10 @@ pub const Cpu = struct {
                 .mips, .mipsel => &mips.cpu.mips32,
                 .mips64, .mips64el => &mips.cpu.mips64,
                 .msp430 => &msp430.cpu.generic,
-                .powerpc => &powerpc.cpu.ppc,
-                .powerpcle => &powerpc.cpu.ppc,
-                .powerpc64 => &powerpc.cpu.ppc64,
-                .powerpc64le => &powerpc.cpu.ppc64le,
+                .powerpc, .powerpcle => &powerpc.cpu.ppc,
+                .powerpc64, .powerpc64le => &powerpc.cpu.ppc64,
                 .propeller1 => &propeller.cpu.generic,
                 .propeller2 => &propeller.cpu.generic,
-                .amdgcn => &amdgpu.cpu.generic,
                 .riscv32 => &riscv.cpu.generic_rv32,
                 .riscv64 => &riscv.cpu.generic_rv64,
                 .spirv, .spirv32, .spirv64 => &spirv.cpu.generic,
@@ -1669,17 +1929,50 @@ pub const Cpu = struct {
             };
         }
 
-        pub fn baseline(arch: Arch) *const Model {
+        /// Returns a conservative CPU model for `arch` that is expected to be compatible with the
+        /// vast majority of hardware available. This function is guaranteed to return CPU models
+        /// that are understood by both LLVM and Clang, unlike `generic`.
+        ///
+        /// For certain `os` values, this function will additionally bump the baseline higher than
+        /// the baseline would be for `arch` in isolation; for example, for `aarch64-macos`, the
+        /// baseline is considered to be `apple_m1`. To avoid this behavior entirely, pass
+        /// `Os.Tag.freestanding`.
+        pub fn baseline(arch: Arch, os: Os) *const Model {
             return switch (arch) {
+                .amdgcn => &amdgcn.cpu.gfx906,
                 .arm, .armeb, .thumb, .thumbeb => &arm.cpu.baseline,
+                .aarch64 => switch (os.tag) {
+                    .bridgeos, .driverkit, .macos => &aarch64.cpu.apple_m1,
+                    .ios, .tvos => &aarch64.cpu.apple_a7,
+                    .visionos => &aarch64.cpu.apple_m2,
+                    .watchos => &aarch64.cpu.apple_s4,
+                    else => generic(arch),
+                },
+                .avr => &avr.cpu.avr2,
+                .bpfel, .bpfeb => &bpf.cpu.v1,
+                .csky => &csky.cpu.ck810, // gcc/clang do not have a generic csky model.
                 .hexagon => &hexagon.cpu.hexagonv60, // gcc/clang do not have a generic hexagon model.
+                .lanai => &lanai.cpu.v11, // clang does not have a generic lanai model.
+                .loongarch64 => &loongarch.cpu.loongarch64,
+                .m68k => &m68k.cpu.M68000,
+                .mips, .mipsel => &mips.cpu.mips32r2,
+                .mips64, .mips64el => &mips.cpu.mips64r2,
+                .msp430 => &msp430.cpu.msp430,
+                .nvptx, .nvptx64 => &nvptx.cpu.sm_52,
+                .powerpc64le => &powerpc.cpu.ppc64le,
                 .riscv32 => &riscv.cpu.baseline_rv32,
                 .riscv64 => &riscv.cpu.baseline_rv64,
-                .x86 => &x86.cpu.pentium4,
-                .nvptx, .nvptx64 => &nvptx.cpu.sm_20,
                 .s390x => &s390x.cpu.arch8, // gcc/clang do not have a generic s390x model.
                 .sparc => &sparc.cpu.v9, // glibc does not work with 'plain' v8.
-                .loongarch64 => &loongarch.cpu.loongarch64,
+                .x86 => &x86.cpu.pentium4,
+                .x86_64 => switch (os.tag) {
+                    .driverkit => &x86.cpu.nehalem,
+                    .ios, .macos, .tvos, .visionos, .watchos => &x86.cpu.core2,
+                    .ps4 => &x86.cpu.btver2,
+                    .ps5 => &x86.cpu.znver2,
+                    else => generic(arch),
+                },
+                .xcore => &xcore.cpu.xs1b_generic,
 
                 else => generic(arch),
             };
@@ -1688,8 +1981,8 @@ pub const Cpu = struct {
 
     /// The "default" set of CPU features for cross-compiling. A conservative set
     /// of features that is expected to be supported on most available hardware.
-    pub fn baseline(arch: Arch) Cpu {
-        return Model.baseline(arch).toCpu(arch);
+    pub fn baseline(arch: Arch, os: Os) Cpu {
+        return Model.baseline(arch, os).toCpu(arch);
     }
 };
 
@@ -1749,10 +2042,6 @@ pub inline fn isBSD(target: Target) bool {
     return target.os.tag.isBSD();
 }
 
-pub inline fn isBpfFreestanding(target: Target) bool {
-    return target.cpu.arch.isBpf() and target.os.tag == .freestanding;
-}
-
 pub inline fn isGnuLibC(target: Target) bool {
     return target.os.tag.isGnuLibC(target.abi);
 }
@@ -1770,30 +2059,6 @@ pub inline fn floatAbi(target: Target) FloatAbi {
     return target.abi.floatAbi();
 }
 
-pub inline fn hasDynamicLinker(target: Target) bool {
-    if (target.cpu.arch.isWasm()) {
-        return false;
-    }
-    switch (target.os.tag) {
-        .freestanding,
-        .ios,
-        .tvos,
-        .watchos,
-        .macos,
-        .visionos,
-        .uefi,
-        .windows,
-        .emscripten,
-        .opencl,
-        .opengl,
-        .vulkan,
-        .plan9,
-        .other,
-        => return false,
-        else => return true,
-    }
-}
-
 pub const DynamicLinker = struct {
     /// Contains the memory used to store the dynamic linker path. This field
     /// should not be used directly. See `get` and `set`. This field exists so
@@ -1824,225 +2089,322 @@ pub const DynamicLinker = struct {
         return if (dl.len > 0) dl.buffer[0..dl.len] else null;
     }
 
-    /// Asserts that the length is less than or equal to 255 bytes.
-    pub fn set(dl: *DynamicLinker, maybe_path: ?[]const u8) void {
-        const path = maybe_path orelse "";
-        @memcpy(dl.buffer[0..path.len], path);
-        dl.len = @intCast(path.len);
-    }
+    /// Asserts that the length is less than or equal to 255 bytes.
+    pub fn set(dl: *DynamicLinker, maybe_path: ?[]const u8) void {
+        const path = maybe_path orelse "";
+        @memcpy(dl.buffer[0..path.len], path);
+        dl.len = @intCast(path.len);
+    }
+
+    /// Asserts that the length is less than or equal to 255 bytes.
+    pub fn setFmt(dl: *DynamicLinker, comptime fmt_str: []const u8, args: anytype) !void {
+        dl.len = @intCast((try std.fmt.bufPrint(&dl.buffer, fmt_str, args)).len);
+    }
+
+    pub fn eql(lhs: DynamicLinker, rhs: DynamicLinker) bool {
+        return std.mem.eql(u8, lhs.buffer[0..lhs.len], rhs.buffer[0..rhs.len]);
+    }
+
+    pub const Kind = enum {
+        /// No dynamic linker.
+        none,
+        /// Dynamic linker path is determined by the arch/OS components.
+        arch_os,
+        /// Dynamic linker path is determined by the arch/OS/ABI components.
+        arch_os_abi,
+    };
+
+    pub fn kind(os: Os.Tag) Kind {
+        return switch (os) {
+            .fuchsia,
+
+            .haiku,
+            .serenity,
+
+            .dragonfly,
+            .freebsd,
+            .netbsd,
+            .openbsd,
+
+            .bridgeos,
+            .driverkit,
+            .ios,
+            .macos,
+            .tvos,
+            .visionos,
+            .watchos,
+
+            .illumos,
+            .solaris,
+            => .arch_os,
+            .hurd,
+            .linux,
+            => .arch_os_abi,
+            .freestanding,
+            .other,
+
+            .contiki,
+            .elfiamcu,
+            .hermit,
+
+            .aix,
+            .plan9,
+            .rtems,
+            .zos,
+
+            .uefi,
+            .windows,
+
+            .emscripten,
+            .wasi,
 
-    /// Asserts that the length is less than or equal to 255 bytes.
-    pub fn setFmt(dl: *DynamicLinker, comptime fmt_str: []const u8, args: anytype) !void {
-        dl.len = @intCast((try std.fmt.bufPrint(&dl.buffer, fmt_str, args)).len);
-    }
+            .amdhsa,
+            .amdpal,
+            .cuda,
+            .mesa3d,
+            .nvcl,
+            .opencl,
+            .opengl,
+            .vulkan,
 
-    pub fn eql(lhs: DynamicLinker, rhs: DynamicLinker) bool {
-        return std.mem.eql(u8, lhs.buffer[0..lhs.len], rhs.buffer[0..rhs.len]);
+            .ps3,
+            .ps4,
+            .ps5,
+            => .none,
+        };
     }
 
+    /// The strictness of this function depends on the value of `kind(os.tag)`:
+    ///
+    /// * `.none`: Ignores all arguments and just returns `none`.
+    /// * `.arch_os`: Ignores `abi` and returns the dynamic linker matching `cpu` and `os`.
+    /// * `.arch_os_abi`: Returns the dynamic linker matching `cpu`, `os`, and `abi`.
+    ///
+    /// In the case of `.arch_os` in particular, callers should be aware that a valid dynamic linker
+    /// being returned only means that the `cpu` + `os` combination represents a platform that
+    /// actually exists and which has an established dynamic linker path that does not change with
+    /// the ABI; it does not necessarily mean that `abi` makes any sense at all for that platform.
+    /// The responsibility for determining whether `abi` is valid in this case rests with the
+    /// caller. `Abi.default()` can be used to pick a best-effort default ABI for such platforms.
     pub fn standard(cpu: Cpu, os: Os, abi: Abi) DynamicLinker {
         return switch (os.tag) {
-            .fuchsia => init("ld.so.1"), // Fuchsia is unusual in that `DT_INTERP` is just a basename.
+            .fuchsia => switch (cpu.arch) {
+                .aarch64,
+                .riscv64,
+                .x86_64,
+                => init("ld.so.1"), // Fuchsia is unusual in that `DT_INTERP` is just a basename.
+                else => none,
+            },
 
-            .haiku => init("/system/runtime_loader"),
+            .haiku => switch (cpu.arch) {
+                .arm,
+                .thumb,
+                .aarch64,
+                .m68k,
+                .powerpc,
+                .riscv64,
+                .sparc64,
+                .x86,
+                .x86_64,
+                => init("/system/runtime_loader"),
+                else => none,
+            },
 
             .hurd => switch (cpu.arch) {
                 .aarch64,
                 .aarch64_be,
                 => |arch| initFmt("/lib/ld-{s}{s}.so.1", .{
                     @tagName(arch),
-                    if (abi == .gnuilp32) "_ilp32" else "",
+                    switch (abi) {
+                        .gnu => "",
+                        .gnuilp32 => "_ilp32",
+                        else => return none,
+                    },
                 }),
 
-                .x86 => init("/lib/ld.so.1"),
-                .x86_64 => initFmt("/lib/ld-{s}.so.1", .{if (abi == .gnux32) "x32" else "x86-64"}),
+                .x86 => if (abi == .gnu) init("/lib/ld.so.1") else none,
+                .x86_64 => initFmt("/lib/ld-{s}.so.1", .{switch (abi) {
+                    .gnu => "x86-64",
+                    .gnux32 => "x32",
+                    else => return none,
+                }}),
 
-                // These are unsupported by Hurd/glibc.
-                .amdgcn,
-                .arc,
-                .arm,
-                .armeb,
-                .thumb,
-                .thumbeb,
-                .avr,
-                .bpfel,
-                .bpfeb,
-                .csky,
-                .hexagon,
-                .kalimba,
-                .lanai,
-                .loongarch32,
-                .loongarch64,
-                .m68k,
-                .mips,
-                .mipsel,
-                .mips64,
-                .mips64el,
-                .msp430,
-                .nvptx,
-                .nvptx64,
-                .powerpc,
-                .powerpcle,
-                .powerpc64,
-                .powerpc64le,
-                .propeller1,
-                .propeller2,
-                .riscv32,
-                .riscv64,
-                .s390x,
-                .sparc,
-                .sparc64,
-                .spirv,
-                .spirv32,
-                .spirv64,
-                .spu_2,
-                .ve,
-                .wasm32,
-                .wasm64,
-                .xcore,
-                .xtensa,
-                => none,
+                else => none,
             },
 
             .linux => if (abi.isAndroid())
-                initFmt("/system/bin/linker{s}", .{if (ptrBitWidth_cpu_abi(cpu, abi) == 64) "64" else ""})
+                switch (cpu.arch) {
+                    .arm,
+                    .thumb,
+                    => if (abi == .androideabi) init("/system/bin/linker") else none,
+
+                    .aarch64,
+                    .riscv64,
+                    .x86,
+                    .x86_64,
+                    => if (abi == .android) initFmt("/system/bin/linker{s}", .{
+                        if (ptrBitWidth_cpu_abi(cpu, abi) == 64) "64" else "",
+                    }) else none,
+
+                    else => none,
+                }
             else if (abi.isMusl())
                 switch (cpu.arch) {
                     .arm,
                     .armeb,
                     .thumb,
                     .thumbeb,
+                    => |arch| initFmt("/lib/ld-musl-arm{s}{s}.so.1", .{
+                        if (arch == .armeb or arch == .thumbeb) "eb" else "",
+                        switch (abi) {
+                            .musleabi => "",
+                            .musleabihf => "hf",
+                            else => return none,
+                        },
+                    }),
+
                     .aarch64,
                     .aarch64_be,
-                    .loongarch64,
+                    .loongarch64, // TODO: `-sp` and `-sf` ABI support in LLVM 20.
                     .m68k,
-                    .powerpc,
                     .powerpc64,
                     .powerpc64le,
-                    .riscv32,
-                    .riscv64,
                     .s390x,
-                    .x86,
-                    .x86_64,
-                    => |arch| initFmt("/lib/ld-musl-{s}{s}.so.1", .{
-                        switch (arch) {
-                            .thumb => "arm",
-                            .thumbeb => "armeb",
-                            .x86 => "i386",
-                            .x86_64 => if (abi == .muslx32) "x32" else "x86_64",
-                            else => @tagName(arch),
-                        },
-                        switch (arch) {
-                            .arm, .armeb, .thumb, .thumbeb => if (abi.floatAbi() == .hard) "hf" else "",
-                            .aarch64, .aarch64_be => if (abi == .gnuilp32) "_ilp32" else "",
-                            .riscv32, .riscv64 => if (std.Target.riscv.featureSetHas(cpu.features, .d))
-                                ""
-                            else if (std.Target.riscv.featureSetHas(cpu.features, .f))
-                                "-sp"
-                            else
-                                "-sf",
-                            else => if (abi.floatAbi() == .soft) "-sf" else "",
-                        },
-                    }),
+                    => |arch| if (abi == .musl) initFmt("/lib/ld-musl-{s}.so.1", .{@tagName(arch)}) else none,
 
-                    // The naming scheme for MIPS is a bit irregular.
                     .mips,
                     .mipsel,
+                    => |arch| initFmt("/lib/ld-musl-mips{s}{s}{s}.so.1", .{
+                        if (mips.featureSetHas(cpu.features, .mips32r6)) "r6" else "",
+                        if (arch == .mipsel) "el" else "",
+                        switch (abi) {
+                            .musleabi => "-sf",
+                            .musleabihf => "",
+                            else => return none,
+                        },
+                    }),
+
                     .mips64,
                     .mips64el,
-                    => |arch| initFmt("/lib/ld-musl-mips{s}{s}{s}{s}.so.1", .{
-                        if (arch.isMIPS64()) "64" else "", // TODO: `n32` ABI support in LLVM 20.
-                        if (mips.featureSetHas(cpu.features, if (arch.isMIPS64()) .mips64r6 else .mips32r6)) "r6" else "",
-                        if (arch.endian() == .little) "el" else "",
-                        if (abi.floatAbi() == .soft) "-sf" else "",
+                    => |arch| initFmt("/lib/ld-musl-mips{s}{s}{s}.so.1", .{
+                        switch (abi) {
+                            .muslabi64 => "64",
+                            .muslabin32 => "n32",
+                            else => return none,
+                        },
+                        if (mips.featureSetHas(cpu.features, .mips64r6)) "r6" else "",
+                        if (arch == .mips64el) "el" else "",
                     }),
 
-                    // These are unsupported by musl.
-                    .amdgcn,
-                    .arc,
-                    .avr,
-                    .csky,
-                    .bpfel,
-                    .bpfeb,
-                    .hexagon,
-                    .kalimba,
-                    .lanai,
-                    .loongarch32,
-                    .msp430,
-                    .nvptx,
-                    .nvptx64,
-                    .powerpcle,
-                    .propeller1,
-                    .propeller2,
-                    .sparc,
-                    .sparc64,
-                    .spirv,
-                    .spirv32,
-                    .spirv64,
-                    .spu_2,
-                    .ve,
-                    .wasm32,
-                    .wasm64,
-                    .xcore,
-                    .xtensa,
-                    => none,
+                    .powerpc => initFmt("/lib/ld-musl-powerpc{s}.so.1", .{switch (abi) {
+                        .musleabi => "-sf",
+                        .musleabihf => "",
+                        else => return none,
+                    }}),
+
+                    .riscv32,
+                    .riscv64,
+                    => |arch| if (abi == .musl) initFmt("/lib/ld-musl-{s}{s}.so.1", .{
+                        @tagName(arch),
+                        if (riscv.featureSetHas(cpu.features, .d))
+                            ""
+                        else if (riscv.featureSetHas(cpu.features, .f))
+                            "-sp"
+                        else
+                            "-sf",
+                    }) else none,
+
+                    .x86 => if (abi == .musl) init("/lib/ld-musl-i386.so.1") else none,
+                    .x86_64 => initFmt("/lib/ld-musl-{s}.so.1", .{switch (abi) {
+                        .musl => "x86_64",
+                        .muslx32 => "x32",
+                        else => return none,
+                    }}),
+
+                    else => none,
                 }
             else if (abi.isGnu())
                 switch (cpu.arch) {
                     // TODO: `eb` architecture support.
                     // TODO: `700` ABI support.
-                    .arc => init("/lib/ld-linux-arc.so.2"),
+                    .arc => if (abi == .gnu) init("/lib/ld-linux-arc.so.2") else none,
 
                     // TODO: OABI support (`/lib/ld-linux.so.2`).
                     .arm,
                     .armeb,
                     .thumb,
                     .thumbeb,
-                    => initFmt("/lib/ld-linux{s}.so.3", .{if (abi.floatAbi() == .hard) "-armhf" else ""}),
+                    => initFmt("/lib/ld-linux{s}.so.3", .{switch (abi) {
+                        .gnueabi => "",
+                        .gnueabihf => "-armhf",
+                        else => return none,
+                    }}),
 
                     .aarch64,
                     .aarch64_be,
                     => |arch| initFmt("/lib/ld-linux-{s}{s}.so.1", .{
                         @tagName(arch),
-                        if (abi == .gnuilp32) "_ilp32" else "",
+                        switch (abi) {
+                            .gnu => "",
+                            .gnuilp32 => "_ilp32",
+                            else => return none,
+                        },
                     }),
 
                     // TODO: `-be` architecture support.
-                    .csky => initFmt("/lib/ld-linux-cskyv2{s}.so.1", .{if (abi.floatAbi() == .hard) "-hf" else ""}),
+                    .csky => initFmt("/lib/ld-linux-cskyv2{s}.so.1", .{switch (abi) {
+                        .gnueabi => "",
+                        .gnueabihf => "-hf",
+                        else => return none,
+                    }}),
 
                     .loongarch64 => initFmt("/lib64/ld-linux-loongarch-{s}.so.1", .{switch (abi) {
+                        .gnu => "lp64d",
                         .gnuf32 => "lp64f",
                         .gnusf => "lp64s",
-                        else => "lp64d",
+                        else => return none,
                     }}),
 
-                    .m68k => init("/lib/ld.so.1"),
+                    .m68k => if (abi == .gnu) init("/lib/ld.so.1") else none,
 
                     .mips,
                     .mipsel,
+                    => switch (abi) {
+                        .gnueabi,
+                        .gnueabihf,
+                        => initFmt("/lib/ld{s}.so.1", .{
+                            if (mips.featureSetHas(cpu.features, .nan2008)) "-linux-mipsn8" else "",
+                        }),
+                        else => none,
+                    },
+
                     .mips64,
                     .mips64el,
                     => initFmt("/lib{s}/ld{s}.so.1", .{
                         switch (abi) {
-                            .gnuabin32 => "32",
                             .gnuabi64 => "64",
-                            else => "",
+                            .gnuabin32 => "32",
+                            else => return none,
                         },
                         if (mips.featureSetHas(cpu.features, .nan2008)) "-linux-mipsn8" else "",
                     }),
 
-                    .powerpc => init("/lib/ld.so.1"),
-                    // TODO: ELFv2 ABI opt-in support.
-                    .powerpc64 => init("/lib64/ld64.so.1"),
-                    .powerpc64le => init("/lib64/ld64.so.2"),
+                    .powerpc => switch (abi) {
+                        .gnueabi,
+                        .gnueabihf,
+                        => init("/lib/ld.so.1"),
+                        else => none,
+                    },
+                    // TODO: ELFv2 ABI (`/lib64/ld64.so.2`) opt-in support.
+                    .powerpc64 => if (abi == .gnu) init("/lib64/ld64.so.1") else none,
+                    .powerpc64le => if (abi == .gnu) init("/lib64/ld64.so.2") else none,
 
                     .riscv32,
                     .riscv64,
-                    => |arch| initFmt("/lib/ld-linux-{s}-{s}{s}.so.1", .{
-                        @tagName(arch),
+                    => |arch| if (abi == .gnu) initFmt("/lib/ld-linux-{s}{s}.so.1", .{
                         switch (arch) {
-                            .riscv32 => "ilp32",
-                            .riscv64 => "lp64",
+                            .riscv32 => "riscv32-ilp32",
+                            .riscv64 => "riscv64-lp64",
                             else => unreachable,
                         },
                         if (riscv.featureSetHas(cpu.features, .d))
@@ -2051,78 +2413,130 @@ pub const DynamicLinker = struct {
                             "f"
                         else
                             "",
-                    }),
+                    }) else none,
 
-                    .s390x => init("/lib/ld64.so.1"),
+                    .s390x => if (abi == .gnu) init("/lib/ld64.so.1") else none,
 
-                    .sparc => init("/lib/ld-linux.so.2"),
-                    .sparc64 => init("/lib64/ld-linux.so.2"),
+                    .sparc => if (abi == .gnu) init("/lib/ld-linux.so.2") else none,
+                    .sparc64 => if (abi == .gnu) init("/lib64/ld-linux.so.2") else none,
 
-                    .x86 => init("/lib/ld-linux.so.2"),
-                    .x86_64 => init(if (abi == .gnux32) "/libx32/ld-linux-x32.so.2" else "/lib64/ld-linux-x86-64.so.2"),
+                    .x86 => if (abi == .gnu) init("/lib/ld-linux.so.2") else none,
+                    .x86_64 => switch (abi) {
+                        .gnu => init("/lib64/ld-linux-x86-64.so.2"),
+                        .gnux32 => init("/libx32/ld-linux-x32.so.2"),
+                        else => none,
+                    },
 
-                    .xtensa => init("/lib/ld.so.1"),
+                    .xtensa => if (abi == .gnu) init("/lib/ld.so.1") else none,
 
-                    // These are unsupported by glibc.
-                    .amdgcn,
-                    .avr,
-                    .bpfeb,
-                    .bpfel,
-                    .hexagon,
-                    .kalimba,
-                    .lanai,
-                    .loongarch32,
-                    .msp430,
-                    .nvptx,
-                    .nvptx64,
-                    .powerpcle,
-                    .propeller1,
-                    .propeller2,
-                    .spirv,
-                    .spirv32,
-                    .spirv64,
-                    .spu_2,
-                    .ve,
-                    .wasm32,
-                    .wasm64,
-                    .xcore,
-                    => none,
+                    else => none,
                 }
             else
                 none, // Not a known Linux libc.
 
-            .serenity => init("/usr/lib/Loader.so"),
+            .serenity => switch (cpu.arch) {
+                .aarch64,
+                .riscv64,
+                .x86_64,
+                => init("/usr/lib/Loader.so"),
+                else => none,
+            },
 
-            .dragonfly => initFmt("{s}/libexec/ld-elf.so.2", .{
+            .dragonfly => if (cpu.arch == .x86_64) initFmt("{s}/libexec/ld-elf.so.2", .{
                 if (os.version_range.semver.isAtLeast(.{ .major = 3, .minor = 8, .patch = 0 }) orelse false)
                     ""
                 else
                     "/usr",
-            }),
+            }) else none,
 
-            .freebsd => initFmt("{s}/libexec/ld-elf.so.1", .{
-                if (os.version_range.semver.isAtLeast(.{ .major = 6, .minor = 0, .patch = 0 }) orelse false)
-                    ""
-                else
-                    "/usr",
-            }),
+            .freebsd => switch (cpu.arch) {
+                .arm,
+                .armeb,
+                .thumb,
+                .thumbeb,
+                .aarch64,
+                .mips,
+                .mipsel,
+                .mips64,
+                .mips64el,
+                .powerpc,
+                .powerpc64,
+                .powerpc64le,
+                .riscv64,
+                .sparc64,
+                .x86,
+                .x86_64,
+                => initFmt("{s}/libexec/ld-elf.so.1", .{
+                    if (os.version_range.semver.isAtLeast(.{ .major = 6, .minor = 0, .patch = 0 }) orelse false)
+                        ""
+                    else
+                        "/usr",
+                }),
+                else => none,
+            },
 
-            .netbsd => init("/libexec/ld.elf_so"),
+            .netbsd => switch (cpu.arch) {
+                .arm,
+                .armeb,
+                .thumb,
+                .thumbeb,
+                .aarch64,
+                .aarch64_be,
+                .m68k,
+                .mips,
+                .mipsel,
+                .mips64,
+                .mips64el,
+                .powerpc,
+                .riscv64,
+                .sparc,
+                .sparc64,
+                .x86,
+                .x86_64,
+                => init("/libexec/ld.elf_so"),
+                else => none,
+            },
 
-            .openbsd => init("/usr/libexec/ld.so"),
+            .openbsd => switch (cpu.arch) {
+                .arm,
+                .thumb,
+                .aarch64,
+                .mips64,
+                .mips64el,
+                .powerpc,
+                .powerpc64,
+                .riscv64,
+                .sparc64,
+                .x86,
+                .x86_64,
+                => init("/usr/libexec/ld.so"),
+                else => none,
+            },
 
-            .bridgeos,
+            .bridgeos => if (cpu.arch == .aarch64) init("/usr/lib/dyld") else none,
             .driverkit,
             .ios,
             .macos,
             .tvos,
             .visionos,
             .watchos,
-            => init("/usr/lib/dyld"),
+            => switch (cpu.arch) {
+                .aarch64,
+                .x86_64,
+                => init("/usr/lib/dyld"),
+                else => none,
+            },
 
             .illumos,
             .solaris,
-            => initFmt("/lib/{s}ld.so.1", .{if (ptrBitWidth_cpu_abi(cpu, abi) == 64) "64/" else ""}),
+            => switch (cpu.arch) {
+                .sparc,
+                .sparc64,
+                .x86,
+                .x86_64,
+                => initFmt("/lib/{s}ld.so.1", .{if (ptrBitWidth_cpu_abi(cpu, .none) == 64) "64/" else ""}),
+                else => none,
+            },
 
             // Operating systems in this list have been verified as not having a standard
             // dynamic linker path.
@@ -2170,8 +2584,8 @@ pub fn standardDynamicLinkerPath(target: Target) DynamicLinker {
 
 pub fn ptrBitWidth_cpu_abi(cpu: Cpu, abi: Abi) u16 {
     switch (abi) {
-        .gnux32, .muslx32, .gnuabin32, .gnuilp32, .ilp32 => return 32,
-        .gnuabi64 => return 64,
+        .gnux32, .muslx32, .gnuabin32, .muslabin32, .gnuilp32, .ilp32 => return 32,
+        .gnuabi64, .muslabi64 => return 64,
         else => {},
     }
     return switch (cpu.arch) {
@@ -2374,7 +2788,10 @@ pub fn cTypeBitSize(target: Target, c_type: CType) u16 {
                 .char => return 8,
                 .short, .ushort => return 16,
                 .int, .uint, .float => return 32,
-                .long, .ulong => return if (target.abi != .gnuabin32) 64 else 32,
+                .long, .ulong => switch (target.abi) {
+                    .gnuabin32, .muslabin32 => return 32,
+                    else => return 64,
+                },
                 .longlong, .ulonglong, .double => return 64,
                 .longdouble => return 128,
             },
@@ -2407,6 +2824,8 @@ pub fn cTypeBitSize(target: Target, c_type: CType) u16 {
                     .powerpc64le,
                     => switch (target.abi) {
                         .musl,
+                        .muslabin32,
+                        .muslabi64,
                         .musleabi,
                         .musleabihf,
                         .muslx32,
@@ -2462,7 +2881,10 @@ pub fn cTypeBitSize(target: Target, c_type: CType) u16 {
                 .char => return 8,
                 .short, .ushort => return 16,
                 .int, .uint, .float => return 32,
-                .long, .ulong => return if (target.abi != .gnuabin32) 64 else 32,
+                .long, .ulong => switch (target.abi) {
+                    .gnuabin32, .muslabin32 => return 32,
+                    else => return 64,
+                },
                 .longlong, .ulonglong, .double => return 64,
                 .longdouble => if (target.os.tag == .freebsd) return 64 else return 128,
             },
@@ -2493,6 +2915,8 @@ pub fn cTypeBitSize(target: Target, c_type: CType) u16 {
                     .powerpcle,
                     => switch (target.abi) {
                         .musl,
+                        .muslabin32,
+                        .muslabi64,
                         .musleabi,
                         .musleabihf,
                         .muslx32,
@@ -2507,6 +2931,8 @@ pub fn cTypeBitSize(target: Target, c_type: CType) u16 {
                     .powerpc64le,
                     => switch (target.abi) {
                         .musl,
+                        .muslabin32,
+                        .muslabi64,
                         .musleabi,
                         .musleabihf,
                         .muslx32,
@@ -2704,7 +3130,6 @@ pub fn cTypeAlignment(target: Target, c_type: CType) u16 {
             .csky,
             .x86,
             .xcore,
-            .loongarch32,
             .kalimba,
             .spu_2,
             .xtensa,
@@ -2728,6 +3153,7 @@ pub fn cTypeAlignment(target: Target, c_type: CType) u16 {
 
             .aarch64,
             .aarch64_be,
+            .loongarch32,
             .loongarch64,
             .mips64,
             .mips64el,
@@ -2808,7 +3234,6 @@ pub fn cTypePreferredAlignment(target: Target, c_type: CType) u16 {
 
             .csky,
             .xcore,
-            .loongarch32,
             .kalimba,
             .spu_2,
             .xtensa,
@@ -2838,6 +3263,7 @@ pub fn cTypePreferredAlignment(target: Target, c_type: CType) u16 {
 
             .aarch64,
             .aarch64_be,
+            .loongarch32,
             .loongarch64,
             .mips64,
             .mips64el,
@@ -2863,139 +3289,75 @@ pub fn cTypePreferredAlignment(target: Target, c_type: CType) u16 {
     );
 }
 
-pub fn is_libc_lib_name(target: std.Target, name: []const u8) bool {
-    const ignore_case = target.os.tag == .macos or target.os.tag == .windows;
-
-    if (eqlIgnoreCase(ignore_case, name, "c"))
-        return true;
-
-    if (target.isMinGW()) {
-        if (eqlIgnoreCase(ignore_case, name, "m"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "mingw32"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "msvcrt-os"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "mingwex"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "uuid"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "bits"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "dmoguids"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "dxerr8"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "dxerr9"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "mfuuid"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "msxml2"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "msxml6"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "amstrmid"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "wbemuuid"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "wmcodecdspuuid"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "dxguid"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "ksguid"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "locationapi"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "portabledeviceguids"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "mfuuid"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "dloadhelper"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "strmiids"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "mfuuid"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "adsiid"))
-            return true;
-
-        return false;
-    }
-
-    if (target.abi.isGnu() or target.abi.isMusl()) {
-        if (eqlIgnoreCase(ignore_case, name, "m"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "rt"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "pthread"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "util"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "xnet"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "resolv"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "dl"))
-            return true;
-    }
-
-    if (target.abi.isMusl()) {
-        if (eqlIgnoreCase(ignore_case, name, "crypt"))
-            return true;
-    }
-
-    if (target.os.tag.isDarwin()) {
-        if (eqlIgnoreCase(ignore_case, name, "System"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "c"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "dbm"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "dl"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "info"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "m"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "poll"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "proc"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "pthread"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "rpcsvc"))
-            return true;
-    }
-
-    if (target.os.isAtLeast(.macos, .{ .major = 10, .minor = 8, .patch = 0 }) orelse false) {
-        if (eqlIgnoreCase(ignore_case, name, "mx"))
-            return true;
-    }
-
-    if (target.os.tag == .haiku) {
-        if (eqlIgnoreCase(ignore_case, name, "root"))
-            return true;
-        if (eqlIgnoreCase(ignore_case, name, "network"))
-            return true;
-    }
-
-    return false;
-}
-
-pub fn is_libcpp_lib_name(target: std.Target, name: []const u8) bool {
-    const ignore_case = target.os.tag.isDarwin() or target.os.tag == .windows;
-
-    return eqlIgnoreCase(ignore_case, name, "c++") or
-        eqlIgnoreCase(ignore_case, name, "stdc++") or
-        eqlIgnoreCase(ignore_case, name, "c++abi");
-}
-
-fn eqlIgnoreCase(ignore_case: bool, a: []const u8, b: []const u8) bool {
-    if (ignore_case) {
-        return std.ascii.eqlIgnoreCase(a, b);
-    } else {
-        return std.mem.eql(u8, a, b);
-    }
+pub fn cCallingConvention(target: Target) ?std.builtin.CallingConvention {
+    return switch (target.cpu.arch) {
+        .x86_64 => switch (target.os.tag) {
+            .windows, .uefi => .{ .x86_64_win = .{} },
+            else => .{ .x86_64_sysv = .{} },
+        },
+        .x86 => switch (target.os.tag) {
+            .windows, .uefi => .{ .x86_win = .{} },
+            else => .{ .x86_sysv = .{} },
+        },
+        .aarch64, .aarch64_be => if (target.os.tag.isDarwin()) cc: {
+            break :cc .{ .aarch64_aapcs_darwin = .{} };
+        } else switch (target.os.tag) {
+            .windows => .{ .aarch64_aapcs_win = .{} },
+            else => .{ .aarch64_aapcs = .{} },
+        },
+        .arm, .armeb, .thumb, .thumbeb => switch (target.os.tag) {
+            .netbsd => .{ .arm_apcs = .{} },
+            .watchos => .{ .arm_aapcs16_vfp = .{} },
+            else => switch (target.abi.floatAbi()) {
+                .soft => .{ .arm_aapcs = .{} },
+                .hard => .{ .arm_aapcs_vfp = .{} },
+            },
+        },
+        .mips64, .mips64el => switch (target.abi) {
+            .gnuabin32 => .{ .mips64_n32 = .{} },
+            else => .{ .mips64_n64 = .{} },
+        },
+        .mips, .mipsel => .{ .mips_o32 = .{} },
+        .riscv64 => .{ .riscv64_lp64 = .{} },
+        .riscv32 => .{ .riscv32_ilp32 = .{} },
+        .sparc64 => .{ .sparc64_sysv = .{} },
+        .sparc => .{ .sparc_sysv = .{} },
+        .powerpc64 => if (target.isMusl())
+            .{ .powerpc64_elf_v2 = .{} }
+        else
+            .{ .powerpc64_elf = .{} },
+        .powerpc64le => .{ .powerpc64_elf_v2 = .{} },
+        .powerpc, .powerpcle => switch (target.os.tag) {
+            .aix => .{ .powerpc_aix = .{} },
+            else => .{ .powerpc_sysv = .{} },
+        },
+        .wasm32 => .{ .wasm_watc = .{} },
+        .wasm64 => .{ .wasm_watc = .{} },
+        .arc => .{ .arc_sysv = .{} },
+        .avr => .avr_gnu,
+        .bpfel, .bpfeb => .{ .bpf_std = .{} },
+        .csky => .{ .csky_sysv = .{} },
+        .hexagon => .{ .hexagon_sysv = .{} },
+        .kalimba => null,
+        .lanai => .{ .lanai_sysv = .{} },
+        .loongarch64 => .{ .loongarch64_lp64 = .{} },
+        .loongarch32 => .{ .loongarch32_ilp32 = .{} },
+        .m68k => if (target.abi.isGnu() or target.abi.isMusl())
+            .{ .m68k_gnu = .{} }
+        else
+            .{ .m68k_sysv = .{} },
+        .msp430 => .{ .msp430_eabi = .{} },
+        .propeller1 => .{ .propeller1_sysv = .{} },
+        .propeller2 => .{ .propeller2_sysv = .{} },
+        .s390x => .{ .s390x_sysv = .{} },
+        .spu_2 => null,
+        .ve => .{ .ve_sysv = .{} },
+        .xcore => .{ .xcore_xs1 = .{} },
+        .xtensa => .{ .xtensa_call0 = .{} },
+        .amdgcn => .{ .amdgcn_device = .{} },
+        .nvptx, .nvptx64 => .nvptx_device,
+        .spirv, .spirv32, .spirv64 => .spirv_device,
+    };
 }
 
 pub fn osArchName(target: std.Target) [:0]const u8 {
diff --git a/zig/lib/std/Target/Query.zig b/zig/lib/std/Target/Query.zig
index e22fbcbf53..f3e280ee32 100644
--- a/zig/lib/std/Target/Query.zig
+++ b/zig/lib/std/Target/Query.zig
@@ -6,7 +6,7 @@
 /// `null` means native.
 cpu_arch: ?Target.Cpu.Arch = null,
 
-cpu_model: CpuModel = CpuModel.determined_by_cpu_arch,
+cpu_model: CpuModel = CpuModel.determined_by_arch_os,
 
 /// Sparse set of CPU features to add to the set from `cpu_model`.
 cpu_features_add: Target.Cpu.Feature.Set = Target.Cpu.Feature.Set.empty,
@@ -25,10 +25,14 @@ os_version_min: ?OsVersion = null,
 /// When `os_tag` is native, `null` means equal to the native OS version.
 os_version_max: ?OsVersion = null,
 
-/// `null` means default when cross compiling, or native when os_tag is native.
+/// `null` means default when cross compiling, or native when `os_tag` is native.
 /// If `isGnuLibC()` is `false`, this must be `null` and is ignored.
 glibc_version: ?SemanticVersion = null,
 
+/// `null` means default when cross compiling, or native when `os_tag` is native.
+/// If `isAndroid()` is `false`, this must be `null` and is ignored.
+android_api_level: ?u32 = null,
+
 /// `null` means the native C ABI, if `os_tag` is native, otherwise it means the default C ABI.
 abi: ?Target.Abi = null,
 
@@ -48,7 +52,7 @@ pub const CpuModel = union(enum) {
 
     /// If CPU Architecture is native, then the CPU model will be native. Otherwise,
     /// it will be baseline.
-    determined_by_cpu_arch,
+    determined_by_arch_os,
 
     explicit: *const Target.Cpu.Model,
 
@@ -58,7 +62,7 @@ pub const CpuModel = union(enum) {
         const b_tag: Tag = b;
         if (a_tag != b_tag) return false;
         return switch (a) {
-            .native, .baseline, .determined_by_cpu_arch => true,
+            .native, .baseline, .determined_by_arch_os => true,
             .explicit => |a_model| a_model == b.explicit,
         };
     }
@@ -98,10 +102,8 @@ pub fn fromTarget(target: Target) Query {
         .os_version_min = undefined,
         .os_version_max = undefined,
         .abi = target.abi,
-        .glibc_version = if (target.isGnuLibC())
-            target.os.version_range.linux.glibc
-        else
-            null,
+        .glibc_version = if (target.isGnuLibC()) target.os.version_range.linux.glibc else null,
+        .android_api_level = if (target.abi.isAndroid()) target.os.version_range.linux.android else null,
     };
     result.updateOsVersionRange(target.os);
 
@@ -124,7 +126,7 @@ pub fn fromTarget(target: Target) Query {
 }
 
 fn updateOsVersionRange(self: *Query, os: Target.Os) void {
-    self.os_version_min, self.os_version_max = switch (os.tag.getVersionRangeTag()) {
+    self.os_version_min, self.os_version_max = switch (os.tag.versionRangeTag()) {
         .none => .{ .{ .none = {} }, .{ .none = {} } },
         .semver => .{
             .{ .semver = os.version_range.semver.min },
@@ -147,7 +149,7 @@ pub const ParseOptions = struct {
     /// The fields are, respectively:
     /// * CPU Architecture
     /// * Operating System (and optional version range)
-    /// * C ABI (optional, with optional glibc version)
+    /// * C ABI (optional, with optional glibc version or Android API level)
     /// The string "native" can be used for CPU architecture as well as Operating System.
     /// If the CPU Architecture is specified as "native", then the Operating System and C ABI may be omitted.
     arch_os_abi: []const u8 = "native",
@@ -191,6 +193,9 @@ pub const ParseOptions = struct {
 
         /// If error.UnknownCpuFeature is returned, this will be populated.
         unknown_feature_name: ?[]const u8 = null,
+
+        /// If error.UnknownArchitecture is returned, this will be populated.
+        unknown_architecture_name: ?[]const u8 = null,
     };
 };
 
@@ -206,8 +211,10 @@ pub fn parse(args: ParseOptions) !Query {
     const arch_name = it.first();
     const arch_is_native = mem.eql(u8, arch_name, "native");
     if (!arch_is_native) {
-        result.cpu_arch = std.meta.stringToEnum(Target.Cpu.Arch, arch_name) orelse
+        result.cpu_arch = std.meta.stringToEnum(Target.Cpu.Arch, arch_name) orelse {
+            diags.unknown_architecture_name = arch_name;
             return error.UnknownArchitecture;
+        };
     }
     const arch = result.cpu_arch orelse builtin.cpu.arch;
     diags.arch = arch;
@@ -234,6 +241,11 @@ pub fn parse(args: ParseOptions) !Query {
                     error.Overflow => return error.InvalidAbiVersion,
                     error.InvalidVersion => return error.InvalidAbiVersion,
                 };
+            } else if (abi.isAndroid()) {
+                result.android_api_level = std.fmt.parseUnsigned(u32, abi_ver_text, 10) catch |err| switch (err) {
+                    error.InvalidCharacter => return error.InvalidVersion,
+                    error.Overflow => return error.Overflow,
+                };
             } else {
                 return error.InvalidAbiVersion;
             }
@@ -349,13 +361,13 @@ test parseVersion {
 
 pub fn isNativeCpu(self: Query) bool {
     return self.cpu_arch == null and
-        (self.cpu_model == .native or self.cpu_model == .determined_by_cpu_arch) and
+        (self.cpu_model == .native or self.cpu_model == .determined_by_arch_os) and
         self.cpu_features_sub.isEmpty() and self.cpu_features_add.isEmpty();
 }
 
 pub fn isNativeOs(self: Query) bool {
     return self.os_tag == null and self.os_version_min == null and self.os_version_max == null and
-        self.dynamic_linker.get() == null and self.glibc_version == null;
+        self.dynamic_linker.get() == null and self.glibc_version == null and self.android_api_level == null;
 }
 
 pub fn isNativeAbi(self: Query) bool {
@@ -374,7 +386,9 @@ pub fn canDetectLibC(self: Query) bool {
     if (self.isNativeOs()) return true;
     if (self.os_tag) |os| {
         if (builtin.os.tag == .macos and os.isDarwin()) return true;
-        if (os == .linux and self.abi.isAndroid()) return true;
+        if (os == .linux) {
+            if (self.abi) |abi| if (abi.isAndroid()) return true;
+        }
     }
     return false;
 }
@@ -437,6 +451,13 @@ pub fn zigTriple(self: Query, allocator: Allocator) Allocator.Error![]u8 {
         result.appendSliceAssumeCapacity(name);
         result.appendAssumeCapacity('.');
         try formatVersion(v, result.writer());
+    } else if (self.android_api_level) |lvl| {
+        const name = if (self.abi) |abi| @tagName(abi) else "android";
+        try result.ensureUnusedCapacity(name.len + 2);
+        result.appendAssumeCapacity('-');
+        result.appendSliceAssumeCapacity(name);
+        result.appendAssumeCapacity('.');
+        try result.writer().print("{d}", .{lvl});
     } else if (self.abi) |abi| {
         const name = @tagName(abi);
         try result.ensureUnusedCapacity(name.len + 1);
@@ -459,7 +480,7 @@ pub fn serializeCpu(q: Query, buffer: *std.ArrayList(u8)) Allocator.Error!void {
         .baseline => {
             buffer.appendSliceAssumeCapacity("baseline");
         },
-        .determined_by_cpu_arch => {
+        .determined_by_arch_os => {
             if (q.cpu_arch == null) {
                 buffer.appendSliceAssumeCapacity("native");
             } else {
@@ -521,7 +542,7 @@ fn parseOs(result: *Query, diags: *ParseOptions.Diagnostics, text: []const u8) !
     diags.os_tag = tag;
 
     const version_text = it.rest();
-    if (version_text.len > 0) switch (tag.getVersionRangeTag()) {
+    if (version_text.len > 0) switch (tag.versionRangeTag()) {
         .none => return error.InvalidOperatingSystemVersion,
         .semver, .linux => range: {
             var range_it = mem.splitSequence(u8, version_text, "...");
@@ -559,6 +580,7 @@ pub fn eql(a: Query, b: Query) bool {
     if (!OsVersion.eqlOpt(a.os_version_min, b.os_version_min)) return false;
     if (!OsVersion.eqlOpt(a.os_version_max, b.os_version_max)) return false;
     if (!versionEqualOpt(a.glibc_version, b.glibc_version)) return false;
+    if (a.android_api_level != b.android_api_level) return false;
     if (a.abi != b.abi) return false;
     if (!a.dynamic_linker.eql(b.dynamic_linker)) return false;
     if (a.ofmt != b.ofmt) return false;
@@ -590,6 +612,15 @@ test parse {
 
         try std.testing.expectEqualSlices(u8, "native-native-gnu.2.1.1", text);
     }
+    if (builtin.target.abi.isAndroid()) {
+        var query = try Query.parse(.{});
+        query.android_api_level = 30;
+
+        const text = try query.zigTriple(std.testing.allocator);
+        defer std.testing.allocator.free(text);
+
+        try std.testing.expectEqualSlices(u8, "native-native-android.30", text);
+    }
     {
         const query = try Query.parse(.{
             .arch_os_abi = "aarch64-linux",
@@ -675,4 +706,25 @@ test parse {
         defer std.testing.allocator.free(text);
         try std.testing.expectEqualSlices(u8, "aarch64-linux.3.10...4.4.1-gnu.2.27", text);
     }
+    {
+        const query = try Query.parse(.{
+            .arch_os_abi = "aarch64-linux.3.10...4.4.1-android.30",
+        });
+        const target = try std.zig.system.resolveTargetQuery(query);
+
+        try std.testing.expect(target.cpu.arch == .aarch64);
+        try std.testing.expect(target.os.tag == .linux);
+        try std.testing.expect(target.os.version_range.linux.range.min.major == 3);
+        try std.testing.expect(target.os.version_range.linux.range.min.minor == 10);
+        try std.testing.expect(target.os.version_range.linux.range.min.patch == 0);
+        try std.testing.expect(target.os.version_range.linux.range.max.major == 4);
+        try std.testing.expect(target.os.version_range.linux.range.max.minor == 4);
+        try std.testing.expect(target.os.version_range.linux.range.max.patch == 1);
+        try std.testing.expect(target.os.version_range.linux.android == 30);
+        try std.testing.expect(target.abi == .android);
+
+        const text = try query.zigTriple(std.testing.allocator);
+        defer std.testing.allocator.free(text);
+        try std.testing.expectEqualSlices(u8, "aarch64-linux.3.10...4.4.1-android.30", text);
+    }
 }
diff --git a/zig/lib/std/Target/amdgpu.zig b/zig/lib/std/Target/amdgcn.zig
similarity index 100%
rename from zig/lib/std/Target/amdgpu.zig
rename to zig/lib/std/Target/amdgcn.zig
diff --git a/zig/lib/std/Target/arm.zig b/zig/lib/std/Target/arm.zig
index 9e4e72a05a..2fcae7287b 100644
--- a/zig/lib/std/Target/arm.zig
+++ b/zig/lib/std/Target/arm.zig
@@ -158,10 +158,8 @@ pub const Feature = enum {
     v6t2,
     v7a,
     v7em,
-    v7k,
     v7m,
     v7r,
-    v7s,
     v7ve,
     v8_1a,
     v8_1m_main,
@@ -1177,13 +1175,6 @@ pub const all_features = blk: {
             .thumb_mode,
         }),
     };
-    result[@intFromEnum(Feature.v7k)] = .{
-        .llvm_name = "armv7k",
-        .description = "ARMv7a architecture",
-        .dependencies = featureSet(&[_]Feature{
-            .v7a,
-        }),
-    };
     result[@intFromEnum(Feature.v7m)] = .{
         .llvm_name = "armv7-m",
         .description = "ARMv7m architecture",
@@ -1208,13 +1199,6 @@ pub const all_features = blk: {
             .rclass,
         }),
     };
-    result[@intFromEnum(Feature.v7s)] = .{
-        .llvm_name = "armv7s",
-        .description = "ARMv7a architecture",
-        .dependencies = featureSet(&[_]Feature{
-            .v7a,
-        }),
-    };
     result[@intFromEnum(Feature.v7ve)] = .{
         .llvm_name = "armv7ve",
         .description = "ARMv7ve architecture",
diff --git a/zig/lib/std/Thread.zig b/zig/lib/std/Thread.zig
index a5c03138f7..aa21a8a0ea 100644
--- a/zig/lib/std/Thread.zig
+++ b/zig/lib/std/Thread.zig
@@ -589,7 +589,7 @@ const WindowsThreadImpl = struct {
             fn_args: Args,
             thread: ThreadCompletion,
 
-            fn entryFn(raw_ptr: windows.PVOID) callconv(.C) windows.DWORD {
+            fn entryFn(raw_ptr: windows.PVOID) callconv(.winapi) windows.DWORD {
                 const self: *@This() = @ptrCast(@alignCast(raw_ptr));
                 defer switch (self.thread.completion.swap(.completed, .seq_cst)) {
                     .running => {},
@@ -749,7 +749,7 @@ const PosixThreadImpl = struct {
         const allocator = std.heap.c_allocator;
 
         const Instance = struct {
-            fn entryFn(raw_arg: ?*anyopaque) callconv(.C) ?*anyopaque {
+            fn entryFn(raw_arg: ?*anyopaque) callconv(.c) ?*anyopaque {
                 const args_ptr: *Args = @ptrCast(@alignCast(raw_arg));
                 defer allocator.destroy(args_ptr);
                 return callFn(f, args_ptr.*);
@@ -1141,8 +1141,7 @@ const LinuxThreadImpl = struct {
 
     fn getCpuCount() !usize {
         const cpu_set = try posix.sched_getaffinity(0);
-        // TODO: should not need this usize cast
-        return @as(usize, posix.CPU_COUNT(cpu_set));
+        return posix.CPU_COUNT(cpu_set);
     }
 
     thread: *ThreadCompletion,
@@ -1338,7 +1337,7 @@ const LinuxThreadImpl = struct {
                       [len] "r" (self.mapped.len),
                     : "memory"
                 ),
-                .loongarch64 => asm volatile (
+                .loongarch32, .loongarch64 => asm volatile (
                     \\ or      $a0, $zero, %[ptr]
                     \\ or      $a1, $zero, %[len]
                     \\ ori     $a7, $zero, 215     # SYS_munmap
@@ -1364,7 +1363,7 @@ const LinuxThreadImpl = struct {
             fn_args: Args,
             thread: ThreadCompletion,
 
-            fn entryFn(raw_arg: usize) callconv(.C) u8 {
+            fn entryFn(raw_arg: usize) callconv(.c) u8 {
                 const self = @as(*@This(), @ptrFromInt(raw_arg));
                 defer switch (self.thread.completion.swap(.completed, .seq_cst)) {
                     .running => {},
diff --git a/zig/lib/std/Thread/WaitGroup.zig b/zig/lib/std/Thread/WaitGroup.zig
index bdc49587bf..52e9c379c2 100644
--- a/zig/lib/std/Thread/WaitGroup.zig
+++ b/zig/lib/std/Thread/WaitGroup.zig
@@ -14,6 +14,11 @@ pub fn start(self: *WaitGroup) void {
     assert((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);
diff --git a/zig/lib/std/array_list.zig b/zig/lib/std/array_list.zig
index ac1b144690..197b8c7fba 100644
--- a/zig/lib/std/array_list.zig
+++ b/zig/lib/std/array_list.zig
@@ -100,7 +100,7 @@ pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
         /// of this ArrayList. Empties this ArrayList.
         pub fn moveToUnmanaged(self: *Self) ArrayListAlignedUnmanaged(T, alignment) {
             const allocator = self.allocator;
-            const result = .{ .items = self.items, .capacity = self.capacity };
+            const result: ArrayListAlignedUnmanaged(T, alignment) = .{ .items = self.items, .capacity = self.capacity };
             self.* = init(allocator);
             return result;
         }
diff --git a/zig/lib/std/atomic.zig b/zig/lib/std/atomic.zig
index e1a6767590..5630bf6bf5 100644
--- a/zig/lib/std/atomic.zig
+++ b/zig/lib/std/atomic.zig
@@ -408,79 +408,87 @@ test spinLoopHint {
     }
 }
 
+pub fn cacheLineForCpu(cpu: std.Target.Cpu) u16 {
+    return switch (cpu.arch) {
+        // x86_64: Starting from Intel's Sandy Bridge, the spatial prefetcher pulls in pairs of 64-byte cache lines at a time.
+        // - https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-optimization-manual.pdf
+        // - https://github.com/facebook/folly/blob/1b5288e6eea6df074758f877c849b6e73bbb9fbb/folly/lang/Align.h#L107
+        //
+        // aarch64: Some big.LITTLE ARM archs have "big" cores with 128-byte cache lines:
+        // - https://www.mono-project.com/news/2016/09/12/arm64-icache/
+        // - https://cpufun.substack.com/p/more-m1-fun-hardware-information
+        //
+        // - https://github.com/torvalds/linux/blob/3a7e02c040b130b5545e4b115aada7bacd80a2b6/arch/arc/Kconfig#L212
+        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_ppc64x.go#L9
+        .x86_64,
+        .aarch64,
+        .aarch64_be,
+        .arc,
+        .powerpc64,
+        .powerpc64le,
+        => 128,
+
+        // https://github.com/llvm/llvm-project/blob/e379094328e49731a606304f7e3559d4f1fa96f9/clang/lib/Basic/Targets/Hexagon.h#L145-L151
+        .hexagon,
+        => if (std.Target.hexagon.featureSetHas(cpu.features, .v73)) 64 else 32,
+
+        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_arm.go#L7
+        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_mips.go#L7
+        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_mipsle.go#L7
+        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_mips64x.go#L9
+        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_riscv64.go#L7
+        // - https://github.com/torvalds/linux/blob/3a7e02c040b130b5545e4b115aada7bacd80a2b6/arch/sparc/include/asm/cache.h#L14
+        .arm,
+        .armeb,
+        .thumb,
+        .thumbeb,
+        .mips,
+        .mipsel,
+        .mips64,
+        .mips64el,
+        .riscv32,
+        .riscv64,
+        .sparc,
+        .sparc64,
+        => 32,
+
+        // - https://github.com/torvalds/linux/blob/3a7e02c040b130b5545e4b115aada7bacd80a2b6/arch/m68k/include/asm/cache.h#L10
+        .m68k,
+        => 16,
+
+        // - https://www.ti.com/lit/pdf/slaa498
+        .msp430,
+        => 8,
+
+        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_s390x.go#L7
+        // - https://sxauroratsubasa.sakura.ne.jp/documents/guide/pdfs/Aurora_ISA_guide.pdf
+        .s390x,
+        .ve,
+        => 256,
+
+        // Other x86 and WASM platforms have 64-byte cache lines.
+        // The rest of the architectures are assumed to be similar.
+        // - https://github.com/golang/go/blob/dda2991c2ea0c5914714469c4defc2562a907230/src/internal/cpu/cpu_x86.go#L9
+        // - https://github.com/golang/go/blob/0a9321ad7f8c91e1b0c7184731257df923977eb9/src/internal/cpu/cpu_loong64.go#L11
+        // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_wasm.go#L7
+        // - https://github.com/torvalds/linux/blob/3a7e02c040b130b5545e4b115aada7bacd80a2b6/arch/xtensa/variants/csp/include/variant/core.h#L209
+        // - https://github.com/torvalds/linux/blob/3a7e02c040b130b5545e4b115aada7bacd80a2b6/arch/csky/Kconfig#L183
+        // - https://www.xmos.com/download/The-XMOS-XS3-Architecture.pdf
+        else => 64,
+    };
+}
+
 /// The estimated size of the CPU's cache line when atomically updating memory.
 /// Add this much padding or align to this boundary to avoid atomically-updated
 /// memory from forcing cache invalidations on near, but non-atomic, memory.
 ///
 /// https://en.wikipedia.org/wiki/False_sharing
 /// https://github.com/golang/go/search?q=CacheLinePadSize
-pub const cache_line = switch (builtin.cpu.arch) {
-    // x86_64: Starting from Intel's Sandy Bridge, the spatial prefetcher pulls in pairs of 64-byte cache lines at a time.
-    // - https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-optimization-manual.pdf
-    // - https://github.com/facebook/folly/blob/1b5288e6eea6df074758f877c849b6e73bbb9fbb/folly/lang/Align.h#L107
-    //
-    // aarch64: Some big.LITTLE ARM archs have "big" cores with 128-byte cache lines:
-    // - https://www.mono-project.com/news/2016/09/12/arm64-icache/
-    // - https://cpufun.substack.com/p/more-m1-fun-hardware-information
-    //
-    // - https://github.com/torvalds/linux/blob/3a7e02c040b130b5545e4b115aada7bacd80a2b6/arch/arc/Kconfig#L212
-    // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_ppc64x.go#L9
-    .x86_64,
-    .aarch64,
-    .aarch64_be,
-    .arc,
-    .powerpc64,
-    .powerpc64le,
-    => 128,
-
-    // https://github.com/llvm/llvm-project/blob/e379094328e49731a606304f7e3559d4f1fa96f9/clang/lib/Basic/Targets/Hexagon.h#L145-L151
-    .hexagon,
-    => if (std.Target.hexagon.featureSetHas(builtin.target.cpu.features, .v73)) 64 else 32,
-
-    // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_arm.go#L7
-    // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_mips.go#L7
-    // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_mipsle.go#L7
-    // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_mips64x.go#L9
-    // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_riscv64.go#L7
-    // - https://github.com/torvalds/linux/blob/3a7e02c040b130b5545e4b115aada7bacd80a2b6/arch/sparc/include/asm/cache.h#L14
-    .arm,
-    .armeb,
-    .thumb,
-    .thumbeb,
-    .mips,
-    .mipsel,
-    .mips64,
-    .mips64el,
-    .riscv32,
-    .riscv64,
-    .sparc,
-    .sparc64,
-    => 32,
-
-    // - https://github.com/torvalds/linux/blob/3a7e02c040b130b5545e4b115aada7bacd80a2b6/arch/m68k/include/asm/cache.h#L10
-    .m68k,
-    => 16,
-
-    // - https://www.ti.com/lit/pdf/slaa498
-    .msp430,
-    => 8,
-
-    // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_s390x.go#L7
-    // - https://sxauroratsubasa.sakura.ne.jp/documents/guide/pdfs/Aurora_ISA_guide.pdf
-    .s390x,
-    .ve,
-    => 256,
-
-    // Other x86 and WASM platforms have 64-byte cache lines.
-    // The rest of the architectures are assumed to be similar.
-    // - https://github.com/golang/go/blob/dda2991c2ea0c5914714469c4defc2562a907230/src/internal/cpu/cpu_x86.go#L9
-    // - https://github.com/golang/go/blob/0a9321ad7f8c91e1b0c7184731257df923977eb9/src/internal/cpu/cpu_loong64.go#L11
-    // - https://github.com/golang/go/blob/3dd58676054223962cd915bb0934d1f9f489d4d2/src/internal/cpu/cpu_wasm.go#L7
-    // - https://github.com/torvalds/linux/blob/3a7e02c040b130b5545e4b115aada7bacd80a2b6/arch/xtensa/variants/csp/include/variant/core.h#L209
-    // - https://github.com/torvalds/linux/blob/3a7e02c040b130b5545e4b115aada7bacd80a2b6/arch/csky/Kconfig#L183
-    // - https://www.xmos.com/download/The-XMOS-XS3-Architecture.pdf
-    else => 64,
-};
+pub const cache_line = cacheLineForCpu(builtin.cpu);
+
+test "current CPU has a cache line size" {
+    _ = cache_line;
+}
 
 const std = @import("std.zig");
 const builtin = @import("builtin");
diff --git a/zig/lib/std/builtin.zig b/zig/lib/std/builtin.zig
index 628b736d82..ed18965e50 100644
--- a/zig/lib/std/builtin.zig
+++ b/zig/lib/std/builtin.zig
@@ -160,54 +160,340 @@ pub const OptimizeMode = enum {
 /// Deprecated; use OptimizeMode.
 pub const Mode = OptimizeMode;
 
+/// The calling convention of a function defines how arguments and return values are passed, as well
+/// as any other requirements which callers and callees must respect, such as register preservation
+/// and stack alignment.
+///
 /// This data structure is used by the Zig language code generation and
 /// therefore must be kept in sync with the compiler implementation.
-pub const CallingConvention = enum(u8) {
-    /// This is the default Zig calling convention used when not using `export` on `fn`
-    /// and no other calling convention is specified.
-    Unspecified,
-    /// Matches the C ABI for the target.
-    /// This is the default calling convention when using `export` on `fn`
-    /// and no other calling convention is specified.
-    C,
-    /// This makes a function not have any function prologue or epilogue,
-    /// making the function itself uncallable in regular Zig code.
-    /// This can be useful when integrating with assembly.
-    Naked,
-    /// Functions with this calling convention are called asynchronously,
-    /// as if called as `async function()`.
-    Async,
-    /// Functions with this calling convention are inlined at all call sites.
-    Inline,
-    /// x86-only.
-    Interrupt,
-    Signal,
-    /// x86-only.
-    Stdcall,
-    /// x86-only.
-    Fastcall,
-    /// x86-only.
-    Vectorcall,
-    /// x86-only.
-    Thiscall,
+pub const CallingConvention = union(enum(u8)) {
+    pub const Tag = @typeInfo(CallingConvention).@"union".tag_type.?;
+
+    /// This is an alias for the default C calling convention for this target.
+    /// Functions marked as `extern` or `export` are given this calling convention by default.
+    pub const c = builtin.target.cCallingConvention().?;
+
+    pub const winapi: CallingConvention = switch (builtin.target.cpu.arch) {
+        .x86_64 => .{ .x86_64_win = .{} },
+        .x86 => .{ .x86_stdcall = .{} },
+        .aarch64 => .{ .aarch64_aapcs_win = .{} },
+        .thumb => .{ .arm_aapcs_vfp = .{} },
+        else => unreachable,
+    };
+
+    pub const kernel: CallingConvention = switch (builtin.target.cpu.arch) {
+        .amdgcn => .amdgcn_kernel,
+        .nvptx, .nvptx64 => .nvptx_kernel,
+        .spirv, .spirv32, .spirv64 => .spirv_kernel,
+        else => unreachable,
+    };
+
+    /// Deprecated; use `.auto`.
+    pub const Unspecified: CallingConvention = .auto;
+    /// Deprecated; use `.c`.
+    pub const C: CallingConvention = .c;
+    /// Deprecated; use `.naked`.
+    pub const Naked: CallingConvention = .naked;
+    /// Deprecated; use `.@"async"`.
+    pub const Async: CallingConvention = .@"async";
+    /// Deprecated; use `.@"inline"`.
+    pub const Inline: CallingConvention = .@"inline";
+    /// Deprecated; use `.x86_64_interrupt`, `.x86_interrupt`, or `.avr_interrupt`.
+    pub const Interrupt: CallingConvention = switch (builtin.target.cpu.arch) {
+        .x86_64 => .{ .x86_64_interrupt = .{} },
+        .x86 => .{ .x86_interrupt = .{} },
+        .avr => .avr_interrupt,
+        else => unreachable,
+    };
+    /// Deprecated; use `.avr_signal`.
+    pub const Signal: CallingConvention = .avr_signal;
+    /// Deprecated; use `.x86_stdcall`.
+    pub const Stdcall: CallingConvention = .{ .x86_stdcall = .{} };
+    /// Deprecated; use `.x86_fastcall`.
+    pub const Fastcall: CallingConvention = .{ .x86_fastcall = .{} };
+    /// Deprecated; use `.x86_64_vectorcall`, `.x86_vectorcall`, or `aarch64_vfabi`.
+    pub const Vectorcall: CallingConvention = switch (builtin.target.cpu.arch) {
+        .x86_64 => .{ .x86_64_vectorcall = .{} },
+        .x86 => .{ .x86_vectorcall = .{} },
+        .aarch64, .aarch64_be => .{ .aarch64_vfabi = .{} },
+        else => unreachable,
+    };
+    /// Deprecated; use `.x86_thiscall`.
+    pub const Thiscall: CallingConvention = .{ .x86_thiscall = .{} };
+    /// Deprecated; use `.arm_apcs`.
+    pub const APCS: CallingConvention = .{ .arm_apcs = .{} };
+    /// Deprecated; use `.arm_aapcs`.
+    pub const AAPCS: CallingConvention = .{ .arm_aapcs = .{} };
+    /// Deprecated; use `.arm_aapcs_vfp`.
+    pub const AAPCSVFP: CallingConvention = .{ .arm_aapcs_vfp = .{} };
+    /// Deprecated; use `.x86_64_sysv`.
+    pub const SysV: CallingConvention = .{ .x86_64_sysv = .{} };
+    /// Deprecated; use `.x86_64_win`.
+    pub const Win64: CallingConvention = .{ .x86_64_win = .{} };
+    /// Deprecated; use `.kernel`.
+    pub const Kernel: CallingConvention = .kernel;
+    /// Deprecated; use `.spirv_fragment`.
+    pub const Fragment: CallingConvention = .spirv_fragment;
+    /// Deprecated; use `.spirv_vertex`.
+    pub const Vertex: CallingConvention = .spirv_vertex;
+
+    /// The default Zig calling convention when neither `export` nor `inline` is specified.
+    /// This calling convention makes no guarantees about stack alignment, registers, etc.
+    /// It can only be used within this Zig compilation unit.
+    auto,
+
+    /// The calling convention of a function that can be called with `async` syntax. An `async` call
+    /// of a runtime-known function must target a function with this calling convention.
+    /// Comptime-known functions with other calling conventions may be coerced to this one.
+    @"async",
+
+    /// Functions with this calling convention have no prologue or epilogue, making the function
+    /// uncallable in regular Zig code. This can be useful when integrating with assembly.
+    naked,
+
+    /// This calling convention is exactly equivalent to using the `inline` keyword on a function
+    /// definition. This function will be semantically inlined by the Zig compiler at call sites.
+    /// Pointers to inline functions are comptime-only.
+    @"inline",
+
+    // Calling conventions for the `x86_64` architecture.
+    x86_64_sysv: CommonOptions,
+    x86_64_win: CommonOptions,
+    x86_64_regcall_v3_sysv: CommonOptions,
+    x86_64_regcall_v4_win: CommonOptions,
+    x86_64_vectorcall: CommonOptions,
+    x86_64_interrupt: CommonOptions,
+
+    // Calling conventions for the `x86` architecture.
+    x86_sysv: X86RegparmOptions,
+    x86_win: X86RegparmOptions,
+    x86_stdcall: X86RegparmOptions,
+    x86_fastcall: CommonOptions,
+    x86_thiscall: CommonOptions,
+    x86_thiscall_mingw: CommonOptions,
+    x86_regcall_v3: CommonOptions,
+    x86_regcall_v4_win: CommonOptions,
+    x86_vectorcall: CommonOptions,
+    x86_interrupt: CommonOptions,
+
+    // Calling conventions for the `aarch64` and `aarch64_be` architectures.
+    aarch64_aapcs: CommonOptions,
+    aarch64_aapcs_darwin: CommonOptions,
+    aarch64_aapcs_win: CommonOptions,
+    aarch64_vfabi: CommonOptions,
+    aarch64_vfabi_sve: CommonOptions,
+
+    // Calling convetions for the `arm`, `armeb`, `thumb`, and `thumbeb` architectures.
     /// ARM Procedure Call Standard (obsolete)
-    /// ARM-only.
-    APCS,
-    /// ARM Architecture Procedure Call Standard (current standard)
-    /// ARM-only.
-    AAPCS,
+    arm_apcs: CommonOptions,
+    /// ARM Architecture Procedure Call Standard
+    arm_aapcs: CommonOptions,
     /// ARM Architecture Procedure Call Standard Vector Floating-Point
-    /// ARM-only.
-    AAPCSVFP,
-    /// x86-64-only.
-    SysV,
-    /// x86-64-only.
-    Win64,
-    /// AMD GPU, NVPTX, or SPIR-V kernel
-    Kernel,
-    // Vulkan-only
-    Fragment,
-    Vertex,
+    arm_aapcs_vfp: CommonOptions,
+    arm_aapcs16_vfp: CommonOptions,
+    arm_interrupt: ArmInterruptOptions,
+
+    // Calling conventions for the `mips64` and `mips64el` architectures.
+    mips64_n64: CommonOptions,
+    mips64_n32: CommonOptions,
+    mips64_interrupt: MipsInterruptOptions,
+
+    // Calling conventions for the `mips` and `mipsel` architectures.
+    mips_o32: CommonOptions,
+    mips_interrupt: MipsInterruptOptions,
+
+    // Calling conventions for the `riscv64` architecture.
+    riscv64_lp64: CommonOptions,
+    riscv64_lp64_v: CommonOptions,
+    riscv64_interrupt: RiscvInterruptOptions,
+
+    // Calling conventions for the `riscv32` architecture.
+    riscv32_ilp32: CommonOptions,
+    riscv32_ilp32_v: CommonOptions,
+    riscv32_interrupt: RiscvInterruptOptions,
+
+    // Calling conventions for the `sparc64` architecture.
+    sparc64_sysv: CommonOptions,
+
+    // Calling conventions for the `sparc` architecture.
+    sparc_sysv: CommonOptions,
+
+    // Calling conventions for the `powerpc64` and `powerpc64le` architectures.
+    powerpc64_elf: CommonOptions,
+    powerpc64_elf_altivec: CommonOptions,
+    powerpc64_elf_v2: CommonOptions,
+
+    // Calling conventions for the `powerpc` and `powerpcle` architectures.
+    powerpc_sysv: CommonOptions,
+    powerpc_sysv_altivec: CommonOptions,
+    powerpc_aix: CommonOptions,
+    powerpc_aix_altivec: CommonOptions,
+
+    /// The standard `wasm32` and `wasm64` calling convention, as specified in the WebAssembly Tool Conventions.
+    wasm_watc: CommonOptions,
+
+    /// The standard `arc` calling convention.
+    arc_sysv: CommonOptions,
+
+    // Calling conventions for the `avr` architecture.
+    avr_gnu,
+    avr_builtin,
+    avr_signal,
+    avr_interrupt,
+
+    /// The standard `bpfel`/`bpfeb` calling convention.
+    bpf_std: CommonOptions,
+
+    // Calling conventions for the `csky` architecture.
+    csky_sysv: CommonOptions,
+    csky_interrupt: CommonOptions,
+
+    // Calling conventions for the `hexagon` architecture.
+    hexagon_sysv: CommonOptions,
+    hexagon_sysv_hvx: CommonOptions,
+
+    /// The standard `lanai` calling convention.
+    lanai_sysv: CommonOptions,
+
+    /// The standard `loongarch64` calling convention.
+    loongarch64_lp64: CommonOptions,
+
+    /// The standard `loongarch32` calling convention.
+    loongarch32_ilp32: CommonOptions,
+
+    // Calling conventions for the `m68k` architecture.
+    m68k_sysv: CommonOptions,
+    m68k_gnu: CommonOptions,
+    m68k_rtd: CommonOptions,
+    m68k_interrupt: CommonOptions,
+
+    /// The standard `msp430` calling convention.
+    msp430_eabi: CommonOptions,
+
+    /// The standard `propeller1` calling convention.
+    propeller1_sysv: CommonOptions,
+
+    /// The standard `propeller2` calling convention.
+    propeller2_sysv: CommonOptions,
+
+    // Calling conventions for the `s390x` architecture.
+    s390x_sysv: CommonOptions,
+    s390x_sysv_vx: CommonOptions,
+
+    /// The standard `ve` calling convention.
+    ve_sysv: CommonOptions,
+
+    // Calling conventions for the `xcore` architecture.
+    xcore_xs1: CommonOptions,
+    xcore_xs2: CommonOptions,
+
+    // Calling conventions for the `xtensa` architecture.
+    xtensa_call0: CommonOptions,
+    xtensa_windowed: CommonOptions,
+
+    // Calling conventions for the `amdgcn` architecture.
+    amdgcn_device: CommonOptions,
+    amdgcn_kernel,
+    amdgcn_cs: CommonOptions,
+
+    // Calling conventions for the `nvptx` and `nvptx64` architectures.
+    nvptx_device,
+    nvptx_kernel,
+
+    // Calling conventions for kernels and shaders on the `spirv`, `spirv32`, and `spirv64` architectures.
+    spirv_device,
+    spirv_kernel,
+    spirv_fragment,
+    spirv_vertex,
+
+    /// Options shared across most calling conventions.
+    pub const CommonOptions = struct {
+        /// The boundary the stack is aligned to when the function is called.
+        /// `null` means the default for this calling convention.
+        incoming_stack_alignment: ?u64 = null,
+    };
+
+    /// Options for x86 calling conventions which support the regparm attribute to pass some
+    /// arguments in registers.
+    pub const X86RegparmOptions = struct {
+        /// The boundary the stack is aligned to when the function is called.
+        /// `null` means the default for this calling convention.
+        incoming_stack_alignment: ?u64 = null,
+        /// The number of arguments to pass in registers before passing the remaining arguments
+        /// according to the calling convention.
+        /// Equivalent to `__attribute__((regparm(x)))` in Clang and GCC.
+        register_params: u2 = 0,
+    };
+
+    /// Options for the `arm_interrupt` calling convention.
+    pub const ArmInterruptOptions = struct {
+        /// The boundary the stack is aligned to when the function is called.
+        /// `null` means the default for this calling convention.
+        incoming_stack_alignment: ?u64 = null,
+        /// The kind of interrupt being received.
+        type: InterruptType = .generic,
+
+        pub const InterruptType = enum(u3) {
+            generic,
+            irq,
+            fiq,
+            swi,
+            abort,
+            undef,
+        };
+    };
+
+    /// Options for the `mips_interrupt` and `mips64_interrupt` calling conventions.
+    pub const MipsInterruptOptions = struct {
+        /// The boundary the stack is aligned to when the function is called.
+        /// `null` means the default for this calling convention.
+        incoming_stack_alignment: ?u64 = null,
+        /// The interrupt mode.
+        mode: InterruptMode = .eic,
+
+        pub const InterruptMode = enum(u4) {
+            eic,
+            sw0,
+            sw1,
+            hw0,
+            hw1,
+            hw2,
+            hw3,
+            hw4,
+            hw5,
+        };
+    };
+
+    /// Options for the `riscv32_interrupt` and `riscv64_interrupt` calling conventions.
+    pub const RiscvInterruptOptions = struct {
+        /// The boundary the stack is aligned to when the function is called.
+        /// `null` means the default for this calling convention.
+        incoming_stack_alignment: ?u64 = null,
+        /// The privilege mode.
+        mode: PrivilegeMode,
+
+        pub const PrivilegeMode = enum(u2) {
+            supervisor,
+            machine,
+        };
+    };
+
+    /// Returns the array of `std.Target.Cpu.Arch` to which this `CallingConvention` applies.
+    /// Asserts that `cc` is not `.auto`, `.@"async"`, `.naked`, or `.@"inline"`.
+    pub fn archs(cc: CallingConvention) []const std.Target.Cpu.Arch {
+        return std.Target.Cpu.Arch.fromCallingConvention(cc);
+    }
+
+    pub fn eql(a: CallingConvention, b: CallingConvention) bool {
+        return std.meta.eql(a, b);
+    }
+
+    pub fn withStackAlign(cc: CallingConvention, incoming_stack_alignment: u64) CallingConvention {
+        const tag: CallingConvention.Tag = cc;
+        var result = cc;
+        @field(result, @tagName(tag)).incoming_stack_alignment = incoming_stack_alignment;
+        return result;
+    }
 };
 
 /// This data structure is used by the Zig language code generation and
@@ -228,6 +514,8 @@ pub const AddressSpace = enum(u5) {
     input,
     output,
     uniform,
+    push_constant,
+    storage_buffer,
 
     // AVR address spaces.
     flash,
@@ -683,6 +971,7 @@ pub const ExternOptions = struct {
     library_name: ?[]const u8 = null,
     linkage: GlobalLinkage = .strong,
     is_thread_local: bool = false,
+    is_dll_import: bool = false,
 };
 
 /// This data structure is used by the Zig language code generation and
diff --git a/zig/lib/std/c.zig b/zig/lib/std/c.zig
index d28f5b0ac4..94d2a3405a 100644
--- a/zig/lib/std/c.zig
+++ b/zig/lib/std/c.zig
@@ -44,22 +44,26 @@ comptime {
     }
 }
 
-/// If not linking libc, returns false.
-/// If linking musl libc, returns true.
-/// If linking gnu libc (glibc), returns true if the target version is greater
-/// than or equal to `glibc_version`.
-/// If linking a libc other than these, returns `false`.
-pub inline fn versionCheck(comptime glibc_version: std.SemanticVersion) bool {
+/// * If not linking libc, returns `false`.
+/// * If linking musl libc, returns `true`.
+/// * If linking GNU libc (glibc), returns `true` if the target version is greater than or equal to
+///   `version`.
+/// * If linking Android libc (bionic), returns `true` if the target API level is greater than or
+///   equal to `version.major`, ignoring other components.
+/// * If linking a libc other than these, returns `false`.
+pub inline fn versionCheck(comptime version: std.SemanticVersion) bool {
     return comptime blk: {
         if (!builtin.link_libc) break :blk false;
         if (native_abi.isMusl()) break :blk true;
         if (builtin.target.isGnuLibC()) {
             const ver = builtin.os.version_range.linux.glibc;
-            const order = ver.order(glibc_version);
+            const order = ver.order(version);
             break :blk switch (order) {
                 .gt, .eq => true,
                 .lt => false,
             };
+        } else if (builtin.abi.isAndroid()) {
+            break :blk builtin.os.version_range.linux.android >= version.major;
         } else {
             break :blk false;
         }
@@ -6017,6 +6021,13 @@ pub const utsname = switch (native_os) {
         machine: [256:0]u8,
         domainname: [256:0]u8,
     },
+    .macos => extern struct {
+        sysname: [256:0]u8,
+        nodename: [256:0]u8,
+        release: [256:0]u8,
+        version: [256:0]u8,
+        machine: [256:0]u8,
+    },
     else => void,
 };
 pub const PR = switch (native_os) {
@@ -8802,7 +8813,7 @@ pub const NOTE = switch (native_os) {
         pub const EXIT_DETAIL = 0x02000000;
         /// mask for signal & exit status
         pub const PDATAMASK = 0x000fffff;
-        pub const PCTRLMASK = (~PDATAMASK);
+        pub const PCTRLMASK = 0xf0000000;
         pub const EXIT_DETAIL_MASK = 0x00070000;
         pub const EXIT_DECRYPTFAIL = 0x00010000;
         pub const EXIT_MEMORY = 0x00020000;
@@ -8936,7 +8947,7 @@ pub const NOTE = switch (native_os) {
         pub const EXEC = 0x20000000;
         /// mask for signal & exit status
         pub const PDATAMASK = 0x000fffff;
-        pub const PCTRLMASK = (~PDATAMASK);
+        pub const PCTRLMASK = 0xf0000000;
         /// data is seconds
         pub const SECONDS = 0x00000001;
         /// data is milliseconds
@@ -9658,7 +9669,6 @@ pub const system_info = haiku.system_info;
 pub const team_id = haiku.team_id;
 pub const team_info = haiku.team_info;
 pub const thread_id = haiku.thread_id;
-pub const vregs = haiku.vregs;
 
 pub const AUTH = openbsd.AUTH;
 pub const BI = openbsd.BI;
@@ -9784,6 +9794,8 @@ pub const dispatch_semaphore_signal = darwin.dispatch_semaphore_signal;
 pub const dispatch_semaphore_wait = darwin.dispatch_semaphore_wait;
 pub const dispatch_time = darwin.dispatch_time;
 pub const fcopyfile = darwin.fcopyfile;
+pub const ipc_space_t = darwin.ipc_space_t;
+pub const ipc_space_port_t = darwin.ipc_space_port_t;
 pub const kern_return_t = darwin.kern_return_t;
 pub const kevent64 = darwin.kevent64;
 pub const mach_absolute_time = darwin.mach_absolute_time;
@@ -9801,10 +9813,12 @@ pub const mach_port_t = darwin.mach_port_t;
 pub const mach_task_basic_info = darwin.mach_task_basic_info;
 pub const mach_task_self = darwin.mach_task_self;
 pub const mach_timebase_info = darwin.mach_timebase_info;
+pub const mach_vm_address_t = darwin.mach_vm_address_t;
 pub const mach_vm_protect = darwin.mach_vm_protect;
 pub const mach_vm_read = darwin.mach_vm_read;
 pub const mach_vm_region = darwin.mach_vm_region;
 pub const mach_vm_region_recurse = darwin.mach_vm_region_recurse;
+pub const mach_vm_size_t = darwin.mach_vm_size_t;
 pub const mach_vm_write = darwin.mach_vm_write;
 pub const os_log_create = darwin.os_log_create;
 pub const os_log_type_enabled = darwin.os_log_type_enabled;
@@ -9861,6 +9875,7 @@ pub const thread_set_state = darwin.thread_set_state;
 pub const vm_deallocate = darwin.vm_deallocate;
 pub const vm_machine_attribute = darwin.vm_machine_attribute;
 pub const vm_machine_attribute_val_t = darwin.vm_machine_attribute_val_t;
+pub const vm_map_t = darwin.vm_map_t;
 pub const vm_offset_t = darwin.vm_offset_t;
 pub const vm_prot_t = darwin.vm_prot_t;
 pub const vm_region_basic_info_64 = darwin.vm_region_basic_info_64;
@@ -9871,6 +9886,46 @@ pub const vm_region_submap_info_64 = darwin.vm_region_submap_info_64;
 pub const vm_region_submap_short_info_64 = darwin.vm_region_submap_short_info_64;
 pub const vm_region_top_info = darwin.vm_region_top_info;
 
+pub const caddr_t = darwin.caddr_t;
+pub const exception_behavior_array_t = darwin.exception_behavior_array_t;
+pub const exception_behavior_t = darwin.exception_behavior_t;
+pub const exception_data_t = darwin.exception_data_t;
+pub const exception_data_type_t = darwin.exception_data_type_t;
+pub const exception_flavor_array_t = darwin.exception_flavor_array_t;
+pub const exception_handler_array_t = darwin.exception_handler_array_t;
+pub const exception_handler_t = darwin.exception_handler_t;
+pub const exception_mask_array_t = darwin.exception_mask_array_t;
+pub const exception_mask_t = darwin.exception_mask_t;
+pub const exception_port_array_t = darwin.exception_port_array_t;
+pub const exception_port_t = darwin.exception_port_t;
+pub const mach_exception_data_t = darwin.mach_exception_data_t;
+pub const mach_exception_data_type_t = darwin.mach_exception_data_type_t;
+pub const mach_msg_bits_t = darwin.mach_msg_bits_t;
+pub const mach_msg_id_t = darwin.mach_msg_id_t;
+pub const mach_msg_option_t = darwin.mach_msg_option_t;
+pub const mach_msg_size_t = darwin.mach_msg_size_t;
+pub const mach_msg_timeout_t = darwin.mach_msg_timeout_t;
+pub const mach_msg_type_name_t = darwin.mach_msg_type_name_t;
+pub const mach_port_right_t = darwin.mach_port_right_t;
+pub const memory_object_offset_t = darwin.memory_object_offset_t;
+pub const policy_t = darwin.policy_t;
+pub const task_policy_flavor_t = darwin.task_policy_flavor_t;
+pub const task_policy_t = darwin.task_policy_t;
+pub const task_t = darwin.task_t;
+pub const thread_act_t = darwin.thread_act_t;
+pub const thread_flavor_t = darwin.thread_flavor_t;
+pub const thread_port_t = darwin.thread_port_t;
+pub const thread_state_flavor_t = darwin.thread_state_flavor_t;
+pub const thread_state_t = darwin.thread_state_t;
+pub const thread_t = darwin.thread_t;
+pub const time_value_t = darwin.time_value_t;
+pub const vm32_object_id_t = darwin.vm32_object_id_t;
+pub const vm_behavior_t = darwin.vm_behavior_t;
+pub const vm_inherit_t = darwin.vm_inherit_t;
+pub const vm_map_read_t = darwin.vm_map_read_t;
+pub const vm_object_id_t = darwin.vm_object_id_t;
+pub const vm_region_flavor_t = darwin.vm_region_flavor_t;
+
 pub const _ksiginfo = netbsd._ksiginfo;
 pub const _lwp_self = netbsd._lwp_self;
 pub const lwpid_t = netbsd.lwpid_t;
diff --git a/zig/lib/std/c/darwin.zig b/zig/lib/std/c/darwin.zig
index 573f29150d..b925a15942 100644
--- a/zig/lib/std/c/darwin.zig
+++ b/zig/lib/std/c/darwin.zig
@@ -59,6 +59,7 @@ pub const EXC = enum(exception_type_t) {
     pub const SOFT_SIGNAL = 0x10003;
 
     pub const MASK = packed struct(u32) {
+        _0: u1 = 0,
         BAD_ACCESS: bool = false,
         BAD_INSTRUCTION: bool = false,
         ARITHMETIC: bool = false,
@@ -72,6 +73,7 @@ pub const EXC = enum(exception_type_t) {
         RESOURCE: bool = false,
         GUARD: bool = false,
         CORPSE_NOTIFY: bool = false,
+        _14: u18 = 0,
 
         pub const MACHINE: MASK = @bitCast(@as(u32, 0));
 
diff --git a/zig/lib/std/compress/zstandard/decode/block.zig b/zig/lib/std/compress/zstandard/decode/block.zig
index d43f360c21..101abfc9b7 100644
--- a/zig/lib/std/compress/zstandard/decode/block.zig
+++ b/zig/lib/std/compress/zstandard/decode/block.zig
@@ -405,7 +405,7 @@ pub const DecodeState = struct {
     };
     fn readLiteralsBits(
         self: *DecodeState,
-        bit_count_to_read: usize,
+        bit_count_to_read: u16,
     ) LiteralBitsError!u16 {
         return self.literal_stream_reader.readBitsNoEof(u16, bit_count_to_read) catch bits: {
             if (self.literal_streams == .four and self.literal_stream_index < 3) {
diff --git a/zig/lib/std/compress/zstandard/decode/huffman.zig b/zig/lib/std/compress/zstandard/decode/huffman.zig
index 9fc5cac7e5..4728ccd027 100644
--- a/zig/lib/std/compress/zstandard/decode/huffman.zig
+++ b/zig/lib/std/compress/zstandard/decode/huffman.zig
@@ -63,7 +63,7 @@ fn decodeFseHuffmanTreeSlice(src: []const u8, compressed_size: usize, weights: *
 
 fn assignWeights(
     huff_bits: *readers.ReverseBitReader,
-    accuracy_log: usize,
+    accuracy_log: u16,
     entries: *[1 << 6]Table.Fse,
     weights: *[256]u4,
 ) !usize {
@@ -73,7 +73,7 @@ fn assignWeights(
 
     while (i < 254) {
         const even_data = entries[even_state];
-        var read_bits: usize = 0;
+        var read_bits: u16 = 0;
         const even_bits = huff_bits.readBits(u32, even_data.bits, &read_bits) catch unreachable;
         weights[i] = std.math.cast(u4, even_data.symbol) orelse return error.MalformedHuffmanTree;
         i += 1;
diff --git a/zig/lib/std/compress/zstandard/readers.zig b/zig/lib/std/compress/zstandard/readers.zig
index f95573f77b..d7bf90ed80 100644
--- a/zig/lib/std/compress/zstandard/readers.zig
+++ b/zig/lib/std/compress/zstandard/readers.zig
@@ -42,11 +42,11 @@ pub const ReverseBitReader = struct {
         if (i == 8) return error.BitStreamHasNoStartBit;
     }
 
-    pub fn readBitsNoEof(self: *@This(), comptime U: type, num_bits: usize) error{EndOfStream}!U {
+    pub fn readBitsNoEof(self: *@This(), comptime U: type, num_bits: u16) error{EndOfStream}!U {
         return self.bit_reader.readBitsNoEof(U, num_bits);
     }
 
-    pub fn readBits(self: *@This(), comptime U: type, num_bits: usize, out_bits: *usize) error{}!U {
+    pub fn readBits(self: *@This(), comptime U: type, num_bits: u16, out_bits: *u16) error{}!U {
         return try self.bit_reader.readBits(U, num_bits, out_bits);
     }
 
@@ -55,7 +55,7 @@ pub const ReverseBitReader = struct {
     }
 
     pub fn isEmpty(self: ReverseBitReader) bool {
-        return self.byte_reader.remaining_bytes == 0 and self.bit_reader.bit_count == 0;
+        return self.byte_reader.remaining_bytes == 0 and self.bit_reader.count == 0;
     }
 };
 
@@ -63,11 +63,11 @@ pub fn BitReader(comptime Reader: type) type {
     return struct {
         underlying: std.io.BitReader(.little, Reader),
 
-        pub fn readBitsNoEof(self: *@This(), comptime U: type, num_bits: usize) !U {
+        pub fn readBitsNoEof(self: *@This(), comptime U: type, num_bits: u16) !U {
             return self.underlying.readBitsNoEof(U, num_bits);
         }
 
-        pub fn readBits(self: *@This(), comptime U: type, num_bits: usize, out_bits: *usize) !U {
+        pub fn readBits(self: *@This(), comptime U: type, num_bits: u16, out_bits: *u16) !U {
             return self.underlying.readBits(U, num_bits, out_bits);
         }
 
diff --git a/zig/lib/std/crypto/25519/ed25519.zig b/zig/lib/std/crypto/25519/ed25519.zig
index d7b51271d2..3e5fb8bb3c 100644
--- a/zig/lib/std/crypto/25519/ed25519.zig
+++ b/zig/lib/std/crypto/25519/ed25519.zig
@@ -151,7 +151,9 @@ pub const Ed25519 = struct {
         a: Curve,
         expected_r: Curve,
 
-        fn init(sig: Signature, public_key: PublicKey) (NonCanonicalError || EncodingError || IdentityElementError)!Verifier {
+        pub const InitError = NonCanonicalError || EncodingError || IdentityElementError;
+
+        fn init(sig: Signature, public_key: PublicKey) InitError!Verifier {
             const r = sig.r;
             const s = sig.s;
             try Curve.scalar.rejectNonCanonical(s);
@@ -173,8 +175,11 @@ pub const Ed25519 = struct {
             self.h.update(msg);
         }
 
+        pub const VerifyError = WeakPublicKeyError || IdentityElementError ||
+            SignatureVerificationError;
+
         /// Verify that the signature is valid for the entire message.
-        pub fn verify(self: *Verifier) (SignatureVerificationError || WeakPublicKeyError || IdentityElementError)!void {
+        pub fn verify(self: *Verifier) VerifyError!void {
             var hram64: [Sha512.digest_length]u8 = undefined;
             self.h.final(&hram64);
             const hram = Curve.scalar.reduce64(hram64);
@@ -197,10 +202,10 @@ pub const Ed25519 = struct {
         s: CompressedScalar,
 
         /// Return the raw signature (r, s) in little-endian format.
-        pub fn toBytes(self: Signature) [encoded_length]u8 {
+        pub fn toBytes(sig: Signature) [encoded_length]u8 {
             var bytes: [encoded_length]u8 = undefined;
-            bytes[0..Curve.encoded_length].* = self.r;
-            bytes[Curve.encoded_length..].* = self.s;
+            bytes[0..Curve.encoded_length].* = sig.r;
+            bytes[Curve.encoded_length..].* = sig.s;
             return bytes;
         }
 
@@ -214,17 +219,19 @@ pub const Ed25519 = struct {
         }
 
         /// Create a Verifier for incremental verification of a signature.
-        pub fn verifier(self: Signature, public_key: PublicKey) (NonCanonicalError || EncodingError || IdentityElementError)!Verifier {
-            return Verifier.init(self, public_key);
+        pub fn verifier(sig: Signature, public_key: PublicKey) Verifier.InitError!Verifier {
+            return Verifier.init(sig, public_key);
         }
 
+        pub const VerifyError = Verifier.InitError || Verifier.VerifyError;
+
         /// Verify the signature against a message and public key.
         /// Return IdentityElement or NonCanonical if the public key or signature are not in the expected range,
         /// or SignatureVerificationError if the signature is invalid for the given message and key.
-        pub fn verify(self: Signature, msg: []const u8, public_key: PublicKey) (IdentityElementError || NonCanonicalError || SignatureVerificationError || EncodingError || WeakPublicKeyError)!void {
-            var st = try Verifier.init(self, public_key);
+        pub fn verify(sig: Signature, msg: []const u8, public_key: PublicKey) VerifyError!void {
+            var st = try sig.verifier(public_key);
             st.update(msg);
-            return st.verify();
+            try st.verify();
         }
     };
 
diff --git a/zig/lib/std/crypto/25519/field.zig b/zig/lib/std/crypto/25519/field.zig
index e18093f4c2..c2fc8408bd 100644
--- a/zig/lib/std/crypto/25519/field.zig
+++ b/zig/lib/std/crypto/25519/field.zig
@@ -6,9 +6,9 @@ const NonCanonicalError = crypto.errors.NonCanonicalError;
 const NotSquareError = crypto.errors.NotSquareError;
 
 // Inline conditionally, when it can result in large code generation.
-const bloaty_inline = switch (builtin.mode) {
-    .ReleaseSafe, .ReleaseFast => .Inline,
-    .Debug, .ReleaseSmall => .Unspecified,
+const bloaty_inline: std.builtin.CallingConvention = switch (builtin.mode) {
+    .ReleaseSafe, .ReleaseFast => .@"inline",
+    .Debug, .ReleaseSmall => .auto,
 };
 
 pub const Fe = struct {
diff --git a/zig/lib/std/crypto/Certificate.zig b/zig/lib/std/crypto/Certificate.zig
index 3580d11fcd..9ca6aa5e48 100644
--- a/zig/lib/std/crypto/Certificate.zig
+++ b/zig/lib/std/crypto/Certificate.zig
@@ -20,18 +20,18 @@ pub const Algorithm = enum {
     curveEd25519,
 
     pub const map = std.StaticStringMap(Algorithm).initComptime(.{
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05 }, .sha1WithRSAEncryption },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0B }, .sha256WithRSAEncryption },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0C }, .sha384WithRSAEncryption },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0D }, .sha512WithRSAEncryption },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0E }, .sha224WithRSAEncryption },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x01 }, .ecdsa_with_SHA224 },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02 }, .ecdsa_with_SHA256 },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x03 }, .ecdsa_with_SHA384 },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x04 }, .ecdsa_with_SHA512 },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x02 }, .md2WithRSAEncryption },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x04 }, .md5WithRSAEncryption },
-        .{ &[_]u8{ 0x2B, 0x65, 0x70 }, .curveEd25519 },
+        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05 }, .sha1WithRSAEncryption },
+        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0B }, .sha256WithRSAEncryption },
+        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0C }, .sha384WithRSAEncryption },
+        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0D }, .sha512WithRSAEncryption },
+        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0E }, .sha224WithRSAEncryption },
+        .{ &.{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x01 }, .ecdsa_with_SHA224 },
+        .{ &.{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02 }, .ecdsa_with_SHA256 },
+        .{ &.{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x03 }, .ecdsa_with_SHA384 },
+        .{ &.{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x04 }, .ecdsa_with_SHA512 },
+        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x02 }, .md2WithRSAEncryption },
+        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x04 }, .md5WithRSAEncryption },
+        .{ &.{ 0x2B, 0x65, 0x70 }, .curveEd25519 },
     });
 
     pub fn Hash(comptime algorithm: Algorithm) type {
@@ -49,13 +49,15 @@ pub const Algorithm = enum {
 
 pub const AlgorithmCategory = enum {
     rsaEncryption,
+    rsassa_pss,
     X9_62_id_ecPublicKey,
     curveEd25519,
 
     pub const map = std.StaticStringMap(AlgorithmCategory).initComptime(.{
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01 }, .rsaEncryption },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01 }, .X9_62_id_ecPublicKey },
-        .{ &[_]u8{ 0x2B, 0x65, 0x70 }, .curveEd25519 },
+        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01 }, .rsaEncryption },
+        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0A }, .rsassa_pss },
+        .{ &.{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01 }, .X9_62_id_ecPublicKey },
+        .{ &.{ 0x2B, 0x65, 0x70 }, .curveEd25519 },
     });
 };
 
@@ -74,18 +76,18 @@ pub const Attribute = enum {
     domainComponent,
 
     pub const map = std.StaticStringMap(Attribute).initComptime(.{
-        .{ &[_]u8{ 0x55, 0x04, 0x03 }, .commonName },
-        .{ &[_]u8{ 0x55, 0x04, 0x05 }, .serialNumber },
-        .{ &[_]u8{ 0x55, 0x04, 0x06 }, .countryName },
-        .{ &[_]u8{ 0x55, 0x04, 0x07 }, .localityName },
-        .{ &[_]u8{ 0x55, 0x04, 0x08 }, .stateOrProvinceName },
-        .{ &[_]u8{ 0x55, 0x04, 0x09 }, .streetAddress },
-        .{ &[_]u8{ 0x55, 0x04, 0x0A }, .organizationName },
-        .{ &[_]u8{ 0x55, 0x04, 0x0B }, .organizationalUnitName },
-        .{ &[_]u8{ 0x55, 0x04, 0x11 }, .postalCode },
-        .{ &[_]u8{ 0x55, 0x04, 0x61 }, .organizationIdentifier },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x01 }, .pkcs9_emailAddress },
-        .{ &[_]u8{ 0x09, 0x92, 0x26, 0x89, 0x93, 0xF2, 0x2C, 0x64, 0x01, 0x19 }, .domainComponent },
+        .{ &.{ 0x55, 0x04, 0x03 }, .commonName },
+        .{ &.{ 0x55, 0x04, 0x05 }, .serialNumber },
+        .{ &.{ 0x55, 0x04, 0x06 }, .countryName },
+        .{ &.{ 0x55, 0x04, 0x07 }, .localityName },
+        .{ &.{ 0x55, 0x04, 0x08 }, .stateOrProvinceName },
+        .{ &.{ 0x55, 0x04, 0x09 }, .streetAddress },
+        .{ &.{ 0x55, 0x04, 0x0A }, .organizationName },
+        .{ &.{ 0x55, 0x04, 0x0B }, .organizationalUnitName },
+        .{ &.{ 0x55, 0x04, 0x11 }, .postalCode },
+        .{ &.{ 0x55, 0x04, 0x61 }, .organizationIdentifier },
+        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x01 }, .pkcs9_emailAddress },
+        .{ &.{ 0x09, 0x92, 0x26, 0x89, 0x93, 0xF2, 0x2C, 0x64, 0x01, 0x19 }, .domainComponent },
     });
 };
 
@@ -95,9 +97,9 @@ pub const NamedCurve = enum {
     X9_62_prime256v1,
 
     pub const map = std.StaticStringMap(NamedCurve).initComptime(.{
-        .{ &[_]u8{ 0x2B, 0x81, 0x04, 0x00, 0x22 }, .secp384r1 },
-        .{ &[_]u8{ 0x2B, 0x81, 0x04, 0x00, 0x23 }, .secp521r1 },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07 }, .X9_62_prime256v1 },
+        .{ &.{ 0x2B, 0x81, 0x04, 0x00, 0x22 }, .secp384r1 },
+        .{ &.{ 0x2B, 0x81, 0x04, 0x00, 0x23 }, .secp521r1 },
+        .{ &.{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07 }, .X9_62_prime256v1 },
     });
 
     pub fn Curve(comptime curve: NamedCurve) type {
@@ -131,28 +133,28 @@ pub const ExtensionId = enum {
     netscape_comment,
 
     pub const map = std.StaticStringMap(ExtensionId).initComptime(.{
-        .{ &[_]u8{ 0x55, 0x04, 0x03 }, .commonName },
-        .{ &[_]u8{ 0x55, 0x1D, 0x01 }, .authority_key_identifier },
-        .{ &[_]u8{ 0x55, 0x1D, 0x07 }, .subject_alt_name },
-        .{ &[_]u8{ 0x55, 0x1D, 0x0E }, .subject_key_identifier },
-        .{ &[_]u8{ 0x55, 0x1D, 0x0F }, .key_usage },
-        .{ &[_]u8{ 0x55, 0x1D, 0x0A }, .basic_constraints },
-        .{ &[_]u8{ 0x55, 0x1D, 0x10 }, .private_key_usage_period },
-        .{ &[_]u8{ 0x55, 0x1D, 0x11 }, .subject_alt_name },
-        .{ &[_]u8{ 0x55, 0x1D, 0x12 }, .issuer_alt_name },
-        .{ &[_]u8{ 0x55, 0x1D, 0x13 }, .basic_constraints },
-        .{ &[_]u8{ 0x55, 0x1D, 0x14 }, .crl_number },
-        .{ &[_]u8{ 0x55, 0x1D, 0x1F }, .crl_distribution_points },
-        .{ &[_]u8{ 0x55, 0x1D, 0x20 }, .certificate_policies },
-        .{ &[_]u8{ 0x55, 0x1D, 0x23 }, .authority_key_identifier },
-        .{ &[_]u8{ 0x55, 0x1D, 0x25 }, .ext_key_usage },
-        .{ &[_]u8{ 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x15, 0x01 }, .msCertsrvCAVersion },
-        .{ &[_]u8{ 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01 }, .info_access },
-        .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF6, 0x7D, 0x07, 0x41, 0x00 }, .entrustVersInfo },
-        .{ &[_]u8{ 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x14, 0x02 }, .enroll_certtype },
-        .{ &[_]u8{ 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x0c }, .pe_logotype },
-        .{ &[_]u8{ 0x60, 0x86, 0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x01 }, .netscape_cert_type },
-        .{ &[_]u8{ 0x60, 0x86, 0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x0d }, .netscape_comment },
+        .{ &.{ 0x55, 0x04, 0x03 }, .commonName },
+        .{ &.{ 0x55, 0x1D, 0x01 }, .authority_key_identifier },
+        .{ &.{ 0x55, 0x1D, 0x07 }, .subject_alt_name },
+        .{ &.{ 0x55, 0x1D, 0x0E }, .subject_key_identifier },
+        .{ &.{ 0x55, 0x1D, 0x0F }, .key_usage },
+        .{ &.{ 0x55, 0x1D, 0x0A }, .basic_constraints },
+        .{ &.{ 0x55, 0x1D, 0x10 }, .private_key_usage_period },
+        .{ &.{ 0x55, 0x1D, 0x11 }, .subject_alt_name },
+        .{ &.{ 0x55, 0x1D, 0x12 }, .issuer_alt_name },
+        .{ &.{ 0x55, 0x1D, 0x13 }, .basic_constraints },
+        .{ &.{ 0x55, 0x1D, 0x14 }, .crl_number },
+        .{ &.{ 0x55, 0x1D, 0x1F }, .crl_distribution_points },
+        .{ &.{ 0x55, 0x1D, 0x20 }, .certificate_policies },
+        .{ &.{ 0x55, 0x1D, 0x23 }, .authority_key_identifier },
+        .{ &.{ 0x55, 0x1D, 0x25 }, .ext_key_usage },
+        .{ &.{ 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x15, 0x01 }, .msCertsrvCAVersion },
+        .{ &.{ 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01 }, .info_access },
+        .{ &.{ 0x2A, 0x86, 0x48, 0x86, 0xF6, 0x7D, 0x07, 0x41, 0x00 }, .entrustVersInfo },
+        .{ &.{ 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x14, 0x02 }, .enroll_certtype },
+        .{ &.{ 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x0c }, .pe_logotype },
+        .{ &.{ 0x60, 0x86, 0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x01 }, .netscape_cert_type },
+        .{ &.{ 0x60, 0x86, 0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x0d }, .netscape_comment },
     });
 };
 
@@ -185,6 +187,7 @@ pub const Parsed = struct {
 
     pub const PubKeyAlgo = union(AlgorithmCategory) {
         rsaEncryption: void,
+        rsassa_pss: void,
         X9_62_id_ecPublicKey: NamedCurve,
         curveEd25519: void,
     };
@@ -386,7 +389,7 @@ test "Parsed.checkHostName" {
     try expectEqual(true, Parsed.checkHostName("bar.ziglang.org", "*.Ziglang.ORG"));
 }
 
-pub const ParseError = der.Element.ParseElementError || ParseVersionError || ParseTimeError || ParseEnumError || ParseBitStringError;
+pub const ParseError = der.Element.ParseError || ParseVersionError || ParseTimeError || ParseEnumError || ParseBitStringError;
 
 pub fn parse(cert: Certificate) ParseError!Parsed {
     const cert_bytes = cert.buffer;
@@ -413,13 +416,9 @@ pub fn parse(cert: Certificate) ParseError!Parsed {
     const pub_key_info = try der.Element.parse(cert_bytes, subject.slice.end);
     const pub_key_signature_algorithm = try der.Element.parse(cert_bytes, pub_key_info.slice.start);
     const pub_key_algo_elem = try der.Element.parse(cert_bytes, pub_key_signature_algorithm.slice.start);
-    const pub_key_algo_tag = try parseAlgorithmCategory(cert_bytes, pub_key_algo_elem);
-    var pub_key_algo: Parsed.PubKeyAlgo = undefined;
-    switch (pub_key_algo_tag) {
-        .rsaEncryption => {
-            pub_key_algo = .{ .rsaEncryption = {} };
-        },
-        .X9_62_id_ecPublicKey => {
+    const pub_key_algo: Parsed.PubKeyAlgo = switch (try parseAlgorithmCategory(cert_bytes, pub_key_algo_elem)) {
+        inline else => |tag| @unionInit(Parsed.PubKeyAlgo, @tagName(tag), {}),
+        .X9_62_id_ecPublicKey => pub_key_algo: {
             // RFC 5480 Section 2.1.1.1 Named Curve
             // ECParameters ::= CHOICE {
             //   namedCurve         OBJECT IDENTIFIER
@@ -428,12 +427,9 @@ pub fn parse(cert: Certificate) ParseError!Parsed {
             // }
             const params_elem = try der.Element.parse(cert_bytes, pub_key_algo_elem.slice.end);
             const named_curve = try parseNamedCurve(cert_bytes, params_elem);
-            pub_key_algo = .{ .X9_62_id_ecPublicKey = named_curve };
-        },
-        .curveEd25519 => {
-            pub_key_algo = .{ .curveEd25519 = {} };
+            break :pub_key_algo .{ .X9_62_id_ecPublicKey = named_curve };
         },
-    }
+    };
     const pub_key_elem = try der.Element.parse(cert_bytes, pub_key_signature_algorithm.slice.end);
     const pub_key = try parseBitString(cert, pub_key_elem);
 
@@ -731,7 +727,7 @@ pub fn parseVersion(bytes: []const u8, version_elem: der.Element) ParseVersionEr
 
 fn verifyRsa(
     comptime Hash: type,
-    message: []const u8,
+    msg: []const u8,
     sig: []const u8,
     pub_key_algo: Parsed.PubKeyAlgo,
     pub_key: []const u8,
@@ -743,59 +739,14 @@ fn verifyRsa(
     if (exponent.len > modulus.len) return error.CertificatePublicKeyInvalid;
     if (sig.len != modulus.len) return error.CertificateSignatureInvalidLength;
 
-    const hash_der = switch (Hash) {
-        crypto.hash.Sha1 => [_]u8{
-            0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e,
-            0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14,
-        },
-        crypto.hash.sha2.Sha224 => [_]u8{
-            0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
-            0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05,
-            0x00, 0x04, 0x1c,
-        },
-        crypto.hash.sha2.Sha256 => [_]u8{
-            0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
-            0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
-            0x00, 0x04, 0x20,
-        },
-        crypto.hash.sha2.Sha384 => [_]u8{
-            0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
-            0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
-            0x00, 0x04, 0x30,
-        },
-        crypto.hash.sha2.Sha512 => [_]u8{
-            0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
-            0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
-            0x00, 0x04, 0x40,
-        },
-        else => @compileError("unreachable"),
-    };
-
-    var msg_hashed: [Hash.digest_length]u8 = undefined;
-    Hash.hash(message, &msg_hashed, .{});
-
     switch (modulus.len) {
         inline 128, 256, 384, 512 => |modulus_len| {
-            const ps_len = modulus_len - (hash_der.len + msg_hashed.len) - 3;
-            const em: [modulus_len]u8 =
-                [2]u8{ 0, 1 } ++
-                ([1]u8{0xff} ** ps_len) ++
-                [1]u8{0} ++
-                hash_der ++
-                msg_hashed;
-
-            const public_key = rsa.PublicKey.fromBytes(exponent, modulus) catch return error.CertificateSignatureInvalid;
-            const em_dec = rsa.encrypt(modulus_len, sig[0..modulus_len].*, public_key) catch |err| switch (err) {
-                error.MessageTooLong => unreachable,
-            };
-
-            if (!mem.eql(u8, &em, &em_dec)) {
+            const public_key = rsa.PublicKey.fromBytes(exponent, modulus) catch
+                return error.CertificateSignatureInvalid;
+            rsa.PKCS1v1_5Signature.verify(modulus_len, sig[0..modulus_len].*, msg, public_key, Hash) catch
                 return error.CertificateSignatureInvalid;
-            }
-        },
-        else => {
-            return error.CertificateSignatureUnsupportedBitCount;
         },
+        else => return error.CertificateSignatureUnsupportedBitCount,
     }
 }
 
@@ -908,9 +859,9 @@ pub const der = struct {
             pub const empty: Slice = .{ .start = 0, .end = 0 };
         };
 
-        pub const ParseElementError = error{CertificateFieldHasInvalidLength};
+        pub const ParseError = error{CertificateFieldHasInvalidLength};
 
-        pub fn parse(bytes: []const u8, index: u32) ParseElementError!Element {
+        pub fn parse(bytes: []const u8, index: u32) Element.ParseError!Element {
             var i = index;
             const identifier = @as(Identifier, @bitCast(bytes[i]));
             i += 1;
@@ -958,21 +909,41 @@ pub const rsa = struct {
     const Modulus = std.crypto.ff.Modulus(max_modulus_bits);
     const Fe = Modulus.Fe;
 
+    /// RFC 3447 8.1 RSASSA-PSS
     pub const PSSSignature = struct {
         pub fn fromBytes(comptime modulus_len: usize, msg: []const u8) [modulus_len]u8 {
-            var result = [1]u8{0} ** modulus_len;
-            std.mem.copyForwards(u8, &result, msg);
+            var result: [modulus_len]u8 = undefined;
+            @memcpy(result[0..msg.len], msg);
+            @memset(result[msg.len..], 0);
             return result;
         }
 
-        pub fn verify(comptime modulus_len: usize, sig: [modulus_len]u8, msg: []const u8, public_key: PublicKey, comptime Hash: type) !void {
+        pub const VerifyError = EncryptError || error{InvalidSignature};
+
+        pub fn verify(
+            comptime modulus_len: usize,
+            sig: [modulus_len]u8,
+            msg: []const u8,
+            public_key: PublicKey,
+            comptime Hash: type,
+        ) VerifyError!void {
+            try concatVerify(modulus_len, sig, &.{msg}, public_key, Hash);
+        }
+
+        pub fn concatVerify(
+            comptime modulus_len: usize,
+            sig: [modulus_len]u8,
+            msg: []const []const u8,
+            public_key: PublicKey,
+            comptime Hash: type,
+        ) VerifyError!void {
             const mod_bits = public_key.n.bits();
             const em_dec = try encrypt(modulus_len, sig, public_key);
 
-            EMSA_PSS_VERIFY(msg, &em_dec, mod_bits - 1, Hash.digest_length, Hash) catch unreachable;
+            try EMSA_PSS_VERIFY(msg, &em_dec, mod_bits - 1, Hash.digest_length, Hash);
         }
 
-        fn EMSA_PSS_VERIFY(msg: []const u8, em: []const u8, emBit: usize, sLen: usize, comptime Hash: type) !void {
+        fn EMSA_PSS_VERIFY(msg: []const []const u8, em: []const u8, emBit: usize, sLen: usize, comptime Hash: type) VerifyError!void {
             // 1.   If the length of M is greater than the input limitation for
             //      the hash function (2^61 - 1 octets for SHA-1), output
             //      "inconsistent" and stop.
@@ -986,7 +957,11 @@ pub const rsa = struct {
 
             // 2.   Let mHash = Hash(M), an octet string of length hLen.
             var mHash: [Hash.digest_length]u8 = undefined;
-            Hash.hash(msg, &mHash, .{});
+            {
+                var hasher: Hash = .init(.{});
+                for (msg) |part| hasher.update(part);
+                hasher.final(&mHash);
+            }
 
             // 3.   If emLen < hLen + sLen + 2, output "inconsistent" and stop.
             if (emLen < Hash.digest_length + sLen + 2) {
@@ -1082,25 +1057,14 @@ pub const rsa = struct {
         }
 
         fn MGF1(comptime Hash: type, out: []u8, seed: *const [Hash.digest_length]u8, len: usize) ![]u8 {
-            var counter: usize = 0;
+            var counter: u32 = 0;
             var idx: usize = 0;
-            var c: [4]u8 = undefined;
-            var hash: [Hash.digest_length + c.len]u8 = undefined;
-            @memcpy(hash[0..Hash.digest_length], seed);
-            var hashed: [Hash.digest_length]u8 = undefined;
+            var hash = seed.* ++ @as([4]u8, undefined);
 
             while (idx < len) {
-                c[0] = @as(u8, @intCast((counter >> 24) & 0xFF));
-                c[1] = @as(u8, @intCast((counter >> 16) & 0xFF));
-                c[2] = @as(u8, @intCast((counter >> 8) & 0xFF));
-                c[3] = @as(u8, @intCast(counter & 0xFF));
-
-                std.mem.copyForwards(u8, hash[seed.len..], &c);
-                Hash.hash(&hash, &hashed, .{});
-
-                std.mem.copyForwards(u8, out[idx..], &hashed);
-                idx += hashed.len;
-
+                std.mem.writeInt(u32, hash[seed.len..][0..4], counter, .big);
+                Hash.hash(&hash, out[idx..][0..Hash.digest_length], .{});
+                idx += Hash.digest_length;
                 counter += 1;
             }
 
@@ -1108,11 +1072,128 @@ pub const rsa = struct {
         }
     };
 
+    /// RFC 3447 8.2 RSASSA-PKCS1-v1_5
+    pub const PKCS1v1_5Signature = struct {
+        pub fn fromBytes(comptime modulus_len: usize, msg: []const u8) [modulus_len]u8 {
+            var result: [modulus_len]u8 = undefined;
+            @memcpy(result[0..msg.len], msg);
+            @memset(result[msg.len..], 0);
+            return result;
+        }
+
+        pub const VerifyError = EncryptError || error{InvalidSignature};
+
+        pub fn verify(
+            comptime modulus_len: usize,
+            sig: [modulus_len]u8,
+            msg: []const u8,
+            public_key: PublicKey,
+            comptime Hash: type,
+        ) VerifyError!void {
+            try concatVerify(modulus_len, sig, &.{msg}, public_key, Hash);
+        }
+
+        pub fn concatVerify(
+            comptime modulus_len: usize,
+            sig: [modulus_len]u8,
+            msg: []const []const u8,
+            public_key: PublicKey,
+            comptime Hash: type,
+        ) VerifyError!void {
+            const em_dec = try encrypt(modulus_len, sig, public_key);
+            const em = try EMSA_PKCS1_V1_5_ENCODE(msg, modulus_len, Hash);
+            if (!std.mem.eql(u8, &em_dec, &em)) return error.InvalidSignature;
+        }
+
+        fn EMSA_PKCS1_V1_5_ENCODE(msg: []const []const u8, comptime emLen: usize, comptime Hash: type) VerifyError![emLen]u8 {
+            comptime var em_index = emLen;
+            var em: [emLen]u8 = undefined;
+
+            // 1. Apply the hash function to the message M to produce a hash value
+            //    H:
+            //
+            //       H = Hash(M).
+            //
+            //    If the hash function outputs "message too long," output "message
+            //    too long" and stop.
+            var hasher: Hash = .init(.{});
+            for (msg) |part| hasher.update(part);
+            em_index -= Hash.digest_length;
+            hasher.final(em[em_index..]);
+
+            // 2. Encode the algorithm ID for the hash function and the hash value
+            //    into an ASN.1 value of type DigestInfo (see Appendix A.2.4) with
+            //    the Distinguished Encoding Rules (DER), where the type DigestInfo
+            //    has the syntax
+            //
+            //    DigestInfo ::= SEQUENCE {
+            //        digestAlgorithm AlgorithmIdentifier,
+            //        digest OCTET STRING
+            //    }
+            //
+            //    The first field identifies the hash function and the second
+            //    contains the hash value.  Let T be the DER encoding of the
+            //    DigestInfo value (see the notes below) and let tLen be the length
+            //    in octets of T.
+            const hash_der: []const u8 = &switch (Hash) {
+                crypto.hash.Sha1 => .{
+                    0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e,
+                    0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14,
+                },
+                crypto.hash.sha2.Sha224 => .{
+                    0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
+                    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05,
+                    0x00, 0x04, 0x1c,
+                },
+                crypto.hash.sha2.Sha256 => .{
+                    0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
+                    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
+                    0x00, 0x04, 0x20,
+                },
+                crypto.hash.sha2.Sha384 => .{
+                    0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
+                    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
+                    0x00, 0x04, 0x30,
+                },
+                crypto.hash.sha2.Sha512 => .{
+                    0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
+                    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
+                    0x00, 0x04, 0x40,
+                },
+                else => @compileError("unreachable"),
+            };
+            em_index -= hash_der.len;
+            @memcpy(em[em_index..][0..hash_der.len], hash_der);
+
+            // 3. If emLen < tLen + 11, output "intended encoded message length too
+            //    short" and stop.
+
+            // 4. Generate an octet string PS consisting of emLen - tLen - 3 octets
+            //    with hexadecimal value 0xff.  The length of PS will be at least 8
+            //    octets.
+            em_index -= 1;
+            @memset(em[2..em_index], 0xff);
+
+            // 5. Concatenate PS, the DER encoding T, and other padding to form the
+            //    encoded message EM as
+            //
+            //       EM = 0x00 || 0x01 || PS || 0x00 || T.
+            em[em_index] = 0x00;
+            em[1] = 0x01;
+            em[0] = 0x00;
+
+            // 6. Output EM.
+            return em;
+        }
+    };
+
     pub const PublicKey = struct {
         n: Modulus,
         e: Fe,
 
-        pub fn fromBytes(pub_bytes: []const u8, modulus_bytes: []const u8) !PublicKey {
+        pub const FromBytesError = error{CertificatePublicKeyInvalid};
+
+        pub fn fromBytes(pub_bytes: []const u8, modulus_bytes: []const u8) FromBytesError!PublicKey {
             // Reject modulus below 512 bits.
             // 512-bit RSA was factored in 1999, so this limit barely means anything,
             // but establish some limit now to ratchet in what we can.
@@ -1137,7 +1218,9 @@ pub const rsa = struct {
             };
         }
 
-        pub fn parseDer(pub_key: []const u8) !struct { modulus: []const u8, exponent: []const u8 } {
+        pub const ParseDerError = der.Element.ParseError || error{CertificateFieldHasWrongDataType};
+
+        pub fn parseDer(pub_key: []const u8) ParseDerError!struct { modulus: []const u8, exponent: []const u8 } {
             const pub_key_seq = try der.Element.parse(pub_key, 0);
             if (pub_key_seq.identifier.tag != .sequence) return error.CertificateFieldHasWrongDataType;
             const modulus_elem = try der.Element.parse(pub_key, pub_key_seq.slice.start);
@@ -1156,7 +1239,9 @@ pub const rsa = struct {
         }
     };
 
-    fn encrypt(comptime modulus_len: usize, msg: [modulus_len]u8, public_key: PublicKey) ![modulus_len]u8 {
+    const EncryptError = error{MessageTooLong};
+
+    fn encrypt(comptime modulus_len: usize, msg: [modulus_len]u8, public_key: PublicKey) EncryptError![modulus_len]u8 {
         const m = Fe.fromBytes(public_key.n, &msg, .big) catch return error.MessageTooLong;
         const e = public_key.n.powPublic(m, public_key.e) catch unreachable;
         var res: [modulus_len]u8 = undefined;
diff --git a/zig/lib/std/crypto/ascon.zig b/zig/lib/std/crypto/ascon.zig
index 8e5f48c9d2..a2168b8a9d 100644
--- a/zig/lib/std/crypto/ascon.zig
+++ b/zig/lib/std/crypto/ascon.zig
@@ -1,6 +1,6 @@
 //! Ascon is a 320-bit permutation, selected as new standard for lightweight cryptography
 //! in the NIST Lightweight Cryptography competition (2019–2023).
-//! https://csrc.nist.gov/News/2023/lightweight-cryptography-nist-selects-ascon
+//! https://csrc.nist.gov/pubs/sp/800/232/ipd
 //!
 //! The permutation is compact, and optimized for timing and side channel resistance,
 //! making it a good choice for embedded applications.
@@ -19,8 +19,9 @@ const native_endian = builtin.cpu.arch.endian();
 ///
 /// The state is represented as 5 64-bit words.
 ///
-/// The NIST submission (v1.2) serializes these words as big-endian,
-/// but software implementations are free to use native endianness.
+/// The original NIST submission (v1.2) serializes these words as big-endian,
+/// but NIST SP 800-232 switched to a little-endian representation.
+/// Software implementations are free to use native endianness with no security degradation.
 pub fn State(comptime endian: std.builtin.Endian) type {
     return struct {
         const Self = @This();
@@ -157,7 +158,7 @@ pub fn State(comptime endian: std.builtin.Endian) type {
 
         /// Apply a reduced-round permutation to the state.
         pub inline fn permuteR(state: *Self, comptime rounds: u4) void {
-            const rks = [12]u64{ 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87, 0x78, 0x69, 0x5a, 0x4b };
+            const rks = [16]u64{ 0x3c, 0x2d, 0x1e, 0x0f, 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87, 0x78, 0x69, 0x5a, 0x4b };
             inline for (rks[rks.len - rounds ..]) |rk| {
                 state.round(rk);
             }
diff --git a/zig/lib/std/crypto/ecdsa.zig b/zig/lib/std/crypto/ecdsa.zig
index 50f13a010d..649c967218 100644
--- a/zig/lib/std/crypto/ecdsa.zig
+++ b/zig/lib/std/crypto/ecdsa.zig
@@ -91,24 +91,26 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             s: Curve.scalar.CompressedScalar,
 
             /// Create a Verifier for incremental verification of a signature.
-            pub fn verifier(self: Signature, public_key: PublicKey) (NonCanonicalError || EncodingError || IdentityElementError)!Verifier {
-                return Verifier.init(self, public_key);
+            pub fn verifier(sig: Signature, public_key: PublicKey) Verifier.InitError!Verifier {
+                return Verifier.init(sig, public_key);
             }
 
+            pub const VerifyError = Verifier.InitError || Verifier.VerifyError;
+
             /// Verify the signature against a message and public key.
             /// Return IdentityElement or NonCanonical if the public key or signature are not in the expected range,
             /// or SignatureVerificationError if the signature is invalid for the given message and key.
-            pub fn verify(self: Signature, msg: []const u8, public_key: PublicKey) (IdentityElementError || NonCanonicalError || SignatureVerificationError)!void {
-                var st = try Verifier.init(self, public_key);
+            pub fn verify(sig: Signature, msg: []const u8, public_key: PublicKey) VerifyError!void {
+                var st = try sig.verifier(public_key);
                 st.update(msg);
-                return st.verify();
+                try st.verify();
             }
 
             /// Return the raw signature (r, s) in big-endian format.
-            pub fn toBytes(self: Signature) [encoded_length]u8 {
+            pub fn toBytes(sig: Signature) [encoded_length]u8 {
                 var bytes: [encoded_length]u8 = undefined;
-                @memcpy(bytes[0 .. encoded_length / 2], &self.r);
-                @memcpy(bytes[encoded_length / 2 ..], &self.s);
+                @memcpy(bytes[0 .. encoded_length / 2], &sig.r);
+                @memcpy(bytes[encoded_length / 2 ..], &sig.s);
                 return bytes;
             }
 
@@ -124,23 +126,23 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             /// Encode the signature using the DER format.
             /// The maximum length of the DER encoding is der_encoded_length_max.
             /// The function returns a slice, that can be shorter than der_encoded_length_max.
-            pub fn toDer(self: Signature, buf: *[der_encoded_length_max]u8) []u8 {
+            pub fn toDer(sig: Signature, buf: *[der_encoded_length_max]u8) []u8 {
                 var fb = io.fixedBufferStream(buf);
                 const w = fb.writer();
-                const r_len = @as(u8, @intCast(self.r.len + (self.r[0] >> 7)));
-                const s_len = @as(u8, @intCast(self.s.len + (self.s[0] >> 7)));
+                const r_len = @as(u8, @intCast(sig.r.len + (sig.r[0] >> 7)));
+                const s_len = @as(u8, @intCast(sig.s.len + (sig.s[0] >> 7)));
                 const seq_len = @as(u8, @intCast(2 + r_len + 2 + s_len));
                 w.writeAll(&[_]u8{ 0x30, seq_len }) catch unreachable;
                 w.writeAll(&[_]u8{ 0x02, r_len }) catch unreachable;
-                if (self.r[0] >> 7 != 0) {
+                if (sig.r[0] >> 7 != 0) {
                     w.writeByte(0x00) catch unreachable;
                 }
-                w.writeAll(&self.r) catch unreachable;
+                w.writeAll(&sig.r) catch unreachable;
                 w.writeAll(&[_]u8{ 0x02, s_len }) catch unreachable;
-                if (self.s[0] >> 7 != 0) {
+                if (sig.s[0] >> 7 != 0) {
                     w.writeByte(0x00) catch unreachable;
                 }
-                w.writeAll(&self.s) catch unreachable;
+                w.writeAll(&sig.s) catch unreachable;
                 return fb.getWritten();
             }
 
@@ -236,7 +238,9 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             s: Curve.scalar.Scalar,
             public_key: PublicKey,
 
-            fn init(sig: Signature, public_key: PublicKey) (IdentityElementError || NonCanonicalError)!Verifier {
+            pub const InitError = IdentityElementError || NonCanonicalError;
+
+            fn init(sig: Signature, public_key: PublicKey) InitError!Verifier {
                 const r = try Curve.scalar.Scalar.fromBytes(sig.r, .big);
                 const s = try Curve.scalar.Scalar.fromBytes(sig.s, .big);
                 if (r.isZero() or s.isZero()) return error.IdentityElement;
@@ -254,8 +258,11 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
                 self.h.update(data);
             }
 
+            pub const VerifyError = IdentityElementError || NonCanonicalError ||
+                SignatureVerificationError;
+
             /// Verify that the signature is valid for the entire message.
-            pub fn verify(self: *Verifier) (IdentityElementError || NonCanonicalError || SignatureVerificationError)!void {
+            pub fn verify(self: *Verifier) VerifyError!void {
                 const ht = Curve.scalar.encoded_length;
                 const h_len = @max(Hash.digest_length, ht);
                 var h: [h_len]u8 = [_]u8{0} ** h_len;
diff --git a/zig/lib/std/crypto/hkdf.zig b/zig/lib/std/crypto/hkdf.zig
index 9163ba9d15..d8270f984c 100644
--- a/zig/lib/std/crypto/hkdf.zig
+++ b/zig/lib/std/crypto/hkdf.zig
@@ -88,3 +88,12 @@ test "Hkdf" {
     hkdf.final(&prk2);
     try htest.assertEqual("077709362c2e32df0ddc3f0dc47bba6390b6c73bb50f9c3122ec844ad7c2b3e5", &prk2);
 }
+
+test "Hkdf Sha3-512" {
+    const sha3_512 = std.crypto.hash.sha3.Sha3_512;
+    const hmac_sha3_512 = hmac.Hmac(sha3_512);
+    const hkdf = Hkdf(hmac_sha3_512);
+    const prk = hkdf.extract("", "");
+    var out = [1]u8{0};
+    hkdf.expand(out[0..], "", prk);
+}
diff --git a/zig/lib/std/crypto/phc_encoding.zig b/zig/lib/std/crypto/phc_encoding.zig
index 3442073632..ba48a9954f 100644
--- a/zig/lib/std/crypto/phc_encoding.zig
+++ b/zig/lib/std/crypto/phc_encoding.zig
@@ -258,8 +258,7 @@ fn kvSplit(str: []const u8) !struct { key: []const u8, value: []const u8 } {
     var it = mem.splitScalar(u8, str, kv_delimiter_scalar);
     const key = it.first();
     const value = it.next() orelse return Error.InvalidEncoding;
-    const ret = .{ .key = key, .value = value };
-    return ret;
+    return .{ .key = key, .value = value };
 }
 
 test "phc format - encoding/decoding" {
diff --git a/zig/lib/std/crypto/sha3.zig b/zig/lib/std/crypto/sha3.zig
index 4ea09e0f93..a001538c1d 100644
--- a/zig/lib/std/crypto/sha3.zig
+++ b/zig/lib/std/crypto/sha3.zig
@@ -52,7 +52,7 @@ pub fn Keccak(comptime f: u11, comptime output_bits: u11, comptime default_delim
         st: State,
 
         /// The output length, in bytes.
-        pub const digest_length = output_bits / 8;
+        pub const digest_length = std.math.divCeil(comptime_int, output_bits, 8) catch unreachable;
         /// The block length, or rate, in bytes.
         pub const block_length = State.rate;
         /// The delimiter can be overwritten in the options.
diff --git a/zig/lib/std/crypto/tls.zig b/zig/lib/std/crypto/tls.zig
index fb1b550e42..74113225cb 100644
--- a/zig/lib/std/crypto/tls.zig
+++ b/zig/lib/std/crypto/tls.zig
@@ -54,6 +54,8 @@ pub const close_notify_alert = [_]u8{
 };
 
 pub const ProtocolVersion = enum(u16) {
+    tls_1_0 = 0x0301,
+    tls_1_1 = 0x0302,
     tls_1_2 = 0x0303,
     tls_1_3 = 0x0304,
     _,
@@ -69,14 +71,18 @@ pub const ContentType = enum(u8) {
 };
 
 pub const HandshakeType = enum(u8) {
+    hello_request = 0,
     client_hello = 1,
     server_hello = 2,
     new_session_ticket = 4,
     end_of_early_data = 5,
     encrypted_extensions = 8,
     certificate = 11,
+    server_key_exchange = 12,
     certificate_request = 13,
+    server_hello_done = 14,
     certificate_verify = 15,
+    client_key_exchange = 16,
     finished = 20,
     key_update = 24,
     message_hash = 254,
@@ -198,36 +204,36 @@ pub const AlertDescription = enum(u8) {
     _,
 
     pub fn toError(alert: AlertDescription) Error!void {
-        return switch (alert) {
+        switch (alert) {
             .close_notify => {}, // not an error
-            .unexpected_message => error.TlsAlertUnexpectedMessage,
-            .bad_record_mac => error.TlsAlertBadRecordMac,
-            .record_overflow => error.TlsAlertRecordOverflow,
-            .handshake_failure => error.TlsAlertHandshakeFailure,
-            .bad_certificate => error.TlsAlertBadCertificate,
-            .unsupported_certificate => error.TlsAlertUnsupportedCertificate,
-            .certificate_revoked => error.TlsAlertCertificateRevoked,
-            .certificate_expired => error.TlsAlertCertificateExpired,
-            .certificate_unknown => error.TlsAlertCertificateUnknown,
-            .illegal_parameter => error.TlsAlertIllegalParameter,
-            .unknown_ca => error.TlsAlertUnknownCa,
-            .access_denied => error.TlsAlertAccessDenied,
-            .decode_error => error.TlsAlertDecodeError,
-            .decrypt_error => error.TlsAlertDecryptError,
-            .protocol_version => error.TlsAlertProtocolVersion,
-            .insufficient_security => error.TlsAlertInsufficientSecurity,
-            .internal_error => error.TlsAlertInternalError,
-            .inappropriate_fallback => error.TlsAlertInappropriateFallback,
+            .unexpected_message => return error.TlsAlertUnexpectedMessage,
+            .bad_record_mac => return error.TlsAlertBadRecordMac,
+            .record_overflow => return error.TlsAlertRecordOverflow,
+            .handshake_failure => return error.TlsAlertHandshakeFailure,
+            .bad_certificate => return error.TlsAlertBadCertificate,
+            .unsupported_certificate => return error.TlsAlertUnsupportedCertificate,
+            .certificate_revoked => return error.TlsAlertCertificateRevoked,
+            .certificate_expired => return error.TlsAlertCertificateExpired,
+            .certificate_unknown => return error.TlsAlertCertificateUnknown,
+            .illegal_parameter => return error.TlsAlertIllegalParameter,
+            .unknown_ca => return error.TlsAlertUnknownCa,
+            .access_denied => return error.TlsAlertAccessDenied,
+            .decode_error => return error.TlsAlertDecodeError,
+            .decrypt_error => return error.TlsAlertDecryptError,
+            .protocol_version => return error.TlsAlertProtocolVersion,
+            .insufficient_security => return error.TlsAlertInsufficientSecurity,
+            .internal_error => return error.TlsAlertInternalError,
+            .inappropriate_fallback => return error.TlsAlertInappropriateFallback,
             .user_canceled => {}, // not an error
-            .missing_extension => error.TlsAlertMissingExtension,
-            .unsupported_extension => error.TlsAlertUnsupportedExtension,
-            .unrecognized_name => error.TlsAlertUnrecognizedName,
-            .bad_certificate_status_response => error.TlsAlertBadCertificateStatusResponse,
-            .unknown_psk_identity => error.TlsAlertUnknownPskIdentity,
-            .certificate_required => error.TlsAlertCertificateRequired,
-            .no_application_protocol => error.TlsAlertNoApplicationProtocol,
-            _ => error.TlsAlertUnknown,
-        };
+            .missing_extension => return error.TlsAlertMissingExtension,
+            .unsupported_extension => return error.TlsAlertUnsupportedExtension,
+            .unrecognized_name => return error.TlsAlertUnrecognizedName,
+            .bad_certificate_status_response => return error.TlsAlertBadCertificateStatusResponse,
+            .unknown_psk_identity => return error.TlsAlertUnknownPskIdentity,
+            .certificate_required => return error.TlsAlertCertificateRequired,
+            .no_application_protocol => return error.TlsAlertNoApplicationProtocol,
+            _ => return error.TlsAlertUnknown,
+        }
     }
 };
 
@@ -260,6 +266,17 @@ pub const SignatureScheme = enum(u16) {
     rsa_pkcs1_sha1 = 0x0201,
     ecdsa_sha1 = 0x0203,
 
+    ecdsa_brainpoolP256r1tls13_sha256 = 0x081a,
+    ecdsa_brainpoolP384r1tls13_sha384 = 0x081b,
+    ecdsa_brainpoolP512r1tls13_sha512 = 0x081c,
+
+    rsa_sha224 = 0x0301,
+    dsa_sha224 = 0x0302,
+    ecdsa_sha224 = 0x0303,
+    dsa_sha256 = 0x0402,
+    dsa_sha384 = 0x0502,
+    dsa_sha512 = 0x0602,
+
     _,
 };
 
@@ -285,7 +302,27 @@ pub const NamedGroup = enum(u16) {
     _,
 };
 
+pub const PskKeyExchangeMode = enum(u8) {
+    psk_ke = 0,
+    psk_dhe_ke = 1,
+    _,
+};
+
 pub const CipherSuite = enum(u16) {
+    RSA_WITH_AES_128_CBC_SHA = 0x002F,
+    DHE_RSA_WITH_AES_128_CBC_SHA = 0x0033,
+    RSA_WITH_AES_256_CBC_SHA = 0x0035,
+    DHE_RSA_WITH_AES_256_CBC_SHA = 0x0039,
+    RSA_WITH_AES_128_CBC_SHA256 = 0x003C,
+    RSA_WITH_AES_256_CBC_SHA256 = 0x003D,
+    DHE_RSA_WITH_AES_128_CBC_SHA256 = 0x0067,
+    DHE_RSA_WITH_AES_256_CBC_SHA256 = 0x006B,
+    RSA_WITH_AES_128_GCM_SHA256 = 0x009C,
+    RSA_WITH_AES_256_GCM_SHA384 = 0x009D,
+    DHE_RSA_WITH_AES_128_GCM_SHA256 = 0x009E,
+    DHE_RSA_WITH_AES_256_GCM_SHA384 = 0x009F,
+    EMPTY_RENEGOTIATION_INFO_SCSV = 0x00FF,
+
     AES_128_GCM_SHA256 = 0x1301,
     AES_256_GCM_SHA384 = 0x1302,
     CHACHA20_POLY1305_SHA256 = 0x1303,
@@ -293,6 +330,102 @@ pub const CipherSuite = enum(u16) {
     AES_128_CCM_8_SHA256 = 0x1305,
     AEGIS_256_SHA512 = 0x1306,
     AEGIS_128L_SHA256 = 0x1307,
+
+    ECDHE_ECDSA_WITH_AES_128_CBC_SHA = 0xC009,
+    ECDHE_ECDSA_WITH_AES_256_CBC_SHA = 0xC00A,
+    ECDHE_RSA_WITH_AES_128_CBC_SHA = 0xC013,
+    ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014,
+    ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 0xC023,
+    ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = 0xC024,
+    ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 0xC027,
+    ECDHE_RSA_WITH_AES_256_CBC_SHA384 = 0xC028,
+    ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = 0xC02B,
+    ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = 0xC02C,
+    ECDHE_RSA_WITH_AES_128_GCM_SHA256 = 0xC02F,
+    ECDHE_RSA_WITH_AES_256_GCM_SHA384 = 0xC030,
+
+    ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA8,
+    ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA9,
+    DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCAA,
+
+    _,
+
+    pub const With = enum {
+        AES_128_CBC_SHA,
+        AES_256_CBC_SHA,
+        AES_128_CBC_SHA256,
+        AES_256_CBC_SHA256,
+        AES_256_CBC_SHA384,
+
+        AES_128_GCM_SHA256,
+        AES_256_GCM_SHA384,
+
+        CHACHA20_POLY1305_SHA256,
+
+        AES_128_CCM_SHA256,
+        AES_128_CCM_8_SHA256,
+
+        AEGIS_256_SHA512,
+        AEGIS_128L_SHA256,
+    };
+
+    pub fn with(cipher_suite: CipherSuite) With {
+        return switch (cipher_suite) {
+            .RSA_WITH_AES_128_CBC_SHA,
+            .DHE_RSA_WITH_AES_128_CBC_SHA,
+            .ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
+            .ECDHE_RSA_WITH_AES_128_CBC_SHA,
+            => .AES_128_CBC_SHA,
+            .RSA_WITH_AES_256_CBC_SHA,
+            .DHE_RSA_WITH_AES_256_CBC_SHA,
+            .ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
+            .ECDHE_RSA_WITH_AES_256_CBC_SHA,
+            => .AES_256_CBC_SHA,
+            .RSA_WITH_AES_128_CBC_SHA256,
+            .DHE_RSA_WITH_AES_128_CBC_SHA256,
+            .ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
+            .ECDHE_RSA_WITH_AES_128_CBC_SHA256,
+            => .AES_128_CBC_SHA256,
+            .RSA_WITH_AES_256_CBC_SHA256,
+            .DHE_RSA_WITH_AES_256_CBC_SHA256,
+            => .AES_256_CBC_SHA256,
+            .ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
+            .ECDHE_RSA_WITH_AES_256_CBC_SHA384,
+            => .AES_256_CBC_SHA384,
+
+            .RSA_WITH_AES_128_GCM_SHA256,
+            .DHE_RSA_WITH_AES_128_GCM_SHA256,
+            .AES_128_GCM_SHA256,
+            .ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+            .ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+            => .AES_128_GCM_SHA256,
+            .RSA_WITH_AES_256_GCM_SHA384,
+            .DHE_RSA_WITH_AES_256_GCM_SHA384,
+            .AES_256_GCM_SHA384,
+            .ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+            .ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+            => .AES_256_GCM_SHA384,
+
+            .CHACHA20_POLY1305_SHA256,
+            .ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+            .ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
+            .DHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+            => .CHACHA20_POLY1305_SHA256,
+
+            .AES_128_CCM_SHA256 => .AES_128_CCM_SHA256,
+            .AES_128_CCM_8_SHA256 => .AES_128_CCM_8_SHA256,
+
+            .AEGIS_256_SHA512 => .AEGIS_256_SHA512,
+            .AEGIS_128L_SHA256 => .AEGIS_128L_SHA256,
+
+            .EMPTY_RENEGOTIATION_INFO_SCSV => unreachable,
+            _ => unreachable,
+        };
+    }
+};
+
+pub const CompressionMethod = enum(u8) {
+    null = 0,
     _,
 };
 
@@ -308,58 +441,114 @@ pub const KeyUpdateRequest = enum(u8) {
     _,
 };
 
-pub fn HandshakeCipherT(comptime AeadType: type, comptime HashType: type) type {
+pub const ChangeCipherSpecType = enum(u8) {
+    change_cipher_spec = 1,
+    _,
+};
+
+pub fn HandshakeCipherT(comptime AeadType: type, comptime HashType: type, comptime explicit_iv_length: comptime_int) type {
     return struct {
-        pub const AEAD = AeadType;
-        pub const Hash = HashType;
-        pub const Hmac = crypto.auth.hmac.Hmac(Hash);
-        pub const Hkdf = crypto.kdf.hkdf.Hkdf(Hmac);
+        pub const A = ApplicationCipherT(AeadType, HashType, explicit_iv_length);
 
-        handshake_secret: [Hkdf.prk_length]u8,
-        master_secret: [Hkdf.prk_length]u8,
-        client_handshake_key: [AEAD.key_length]u8,
-        server_handshake_key: [AEAD.key_length]u8,
-        client_finished_key: [Hmac.key_length]u8,
-        server_finished_key: [Hmac.key_length]u8,
-        client_handshake_iv: [AEAD.nonce_length]u8,
-        server_handshake_iv: [AEAD.nonce_length]u8,
-        transcript_hash: Hash,
+        transcript_hash: A.Hash,
+        version: union {
+            tls_1_2: struct {
+                expected_server_verify_data: [A.verify_data_length]u8,
+                app_cipher: A.Tls_1_2,
+            },
+            tls_1_3: struct {
+                handshake_secret: [A.Hkdf.prk_length]u8,
+                master_secret: [A.Hkdf.prk_length]u8,
+                client_handshake_key: [A.AEAD.key_length]u8,
+                server_handshake_key: [A.AEAD.key_length]u8,
+                client_finished_key: [A.Hmac.key_length]u8,
+                server_finished_key: [A.Hmac.key_length]u8,
+                client_handshake_iv: [A.AEAD.nonce_length]u8,
+                server_handshake_iv: [A.AEAD.nonce_length]u8,
+            },
+        },
     };
 }
 
 pub const HandshakeCipher = union(enum) {
-    AES_128_GCM_SHA256: HandshakeCipherT(crypto.aead.aes_gcm.Aes128Gcm, crypto.hash.sha2.Sha256),
-    AES_256_GCM_SHA384: HandshakeCipherT(crypto.aead.aes_gcm.Aes256Gcm, crypto.hash.sha2.Sha384),
-    CHACHA20_POLY1305_SHA256: HandshakeCipherT(crypto.aead.chacha_poly.ChaCha20Poly1305, crypto.hash.sha2.Sha256),
-    AEGIS_256_SHA512: HandshakeCipherT(crypto.aead.aegis.Aegis256, crypto.hash.sha2.Sha512),
-    AEGIS_128L_SHA256: HandshakeCipherT(crypto.aead.aegis.Aegis128L, crypto.hash.sha2.Sha256),
+    AES_128_GCM_SHA256: HandshakeCipherT(crypto.aead.aes_gcm.Aes128Gcm, crypto.hash.sha2.Sha256, 8),
+    AES_256_GCM_SHA384: HandshakeCipherT(crypto.aead.aes_gcm.Aes256Gcm, crypto.hash.sha2.Sha384, 8),
+    CHACHA20_POLY1305_SHA256: HandshakeCipherT(crypto.aead.chacha_poly.ChaCha20Poly1305, crypto.hash.sha2.Sha256, 0),
+    AEGIS_256_SHA512: HandshakeCipherT(crypto.aead.aegis.Aegis256, crypto.hash.sha2.Sha512, 0),
+    AEGIS_128L_SHA256: HandshakeCipherT(crypto.aead.aegis.Aegis128L, crypto.hash.sha2.Sha256, 0),
 };
 
-pub fn ApplicationCipherT(comptime AeadType: type, comptime HashType: type) type {
-    return struct {
+pub fn ApplicationCipherT(comptime AeadType: type, comptime HashType: type, comptime explicit_iv_length: comptime_int) type {
+    return union {
         pub const AEAD = AeadType;
         pub const Hash = HashType;
         pub const Hmac = crypto.auth.hmac.Hmac(Hash);
         pub const Hkdf = crypto.kdf.hkdf.Hkdf(Hmac);
 
-        client_secret: [Hash.digest_length]u8,
-        server_secret: [Hash.digest_length]u8,
-        client_key: [AEAD.key_length]u8,
-        server_key: [AEAD.key_length]u8,
-        client_iv: [AEAD.nonce_length]u8,
-        server_iv: [AEAD.nonce_length]u8,
+        pub const enc_key_length = AEAD.key_length;
+        pub const fixed_iv_length = AEAD.nonce_length - explicit_iv_length;
+        pub const record_iv_length = explicit_iv_length;
+        pub const mac_length = AEAD.tag_length;
+        pub const mac_key_length = Hmac.key_length_min;
+        pub const verify_data_length = 12;
+
+        tls_1_2: Tls_1_2,
+        tls_1_3: Tls_1_3,
+
+        pub const Tls_1_2 = extern struct {
+            client_write_MAC_key: [mac_key_length]u8,
+            server_write_MAC_key: [mac_key_length]u8,
+            client_write_key: [enc_key_length]u8,
+            server_write_key: [enc_key_length]u8,
+            client_write_IV: [fixed_iv_length]u8,
+            server_write_IV: [fixed_iv_length]u8,
+            // non-standard entropy
+            client_salt: [record_iv_length]u8,
+        };
+
+        pub const Tls_1_3 = struct {
+            client_secret: [Hash.digest_length]u8,
+            server_secret: [Hash.digest_length]u8,
+            client_key: [AEAD.key_length]u8,
+            server_key: [AEAD.key_length]u8,
+            client_iv: [AEAD.nonce_length]u8,
+            server_iv: [AEAD.nonce_length]u8,
+        };
     };
 }
 
 /// Encryption parameters for application traffic.
 pub const ApplicationCipher = union(enum) {
-    AES_128_GCM_SHA256: ApplicationCipherT(crypto.aead.aes_gcm.Aes128Gcm, crypto.hash.sha2.Sha256),
-    AES_256_GCM_SHA384: ApplicationCipherT(crypto.aead.aes_gcm.Aes256Gcm, crypto.hash.sha2.Sha384),
-    CHACHA20_POLY1305_SHA256: ApplicationCipherT(crypto.aead.chacha_poly.ChaCha20Poly1305, crypto.hash.sha2.Sha256),
-    AEGIS_256_SHA512: ApplicationCipherT(crypto.aead.aegis.Aegis256, crypto.hash.sha2.Sha512),
-    AEGIS_128L_SHA256: ApplicationCipherT(crypto.aead.aegis.Aegis128L, crypto.hash.sha2.Sha256),
+    AES_128_GCM_SHA256: ApplicationCipherT(crypto.aead.aes_gcm.Aes128Gcm, crypto.hash.sha2.Sha256, 8),
+    AES_256_GCM_SHA384: ApplicationCipherT(crypto.aead.aes_gcm.Aes256Gcm, crypto.hash.sha2.Sha384, 8),
+    CHACHA20_POLY1305_SHA256: ApplicationCipherT(crypto.aead.chacha_poly.ChaCha20Poly1305, crypto.hash.sha2.Sha256, 0),
+    AEGIS_256_SHA512: ApplicationCipherT(crypto.aead.aegis.Aegis256, crypto.hash.sha2.Sha512, 0),
+    AEGIS_128L_SHA256: ApplicationCipherT(crypto.aead.aegis.Aegis128L, crypto.hash.sha2.Sha256, 0),
 };
 
+pub fn hmacExpandLabel(
+    comptime Hmac: type,
+    secret: []const u8,
+    label_then_seed: []const []const u8,
+    comptime len: usize,
+) [len]u8 {
+    const initial_hmac: Hmac = .init(secret);
+    var a: [Hmac.mac_length]u8 = undefined;
+    var result: [std.mem.alignForwardAnyAlign(usize, len, Hmac.mac_length)]u8 = undefined;
+    var index: usize = 0;
+    while (index < result.len) : (index += Hmac.mac_length) {
+        var a_hmac = initial_hmac;
+        if (index > 0) a_hmac.update(&a) else for (label_then_seed) |part| a_hmac.update(part);
+        a_hmac.final(&a);
+
+        var result_hmac = initial_hmac;
+        result_hmac.update(&a);
+        for (label_then_seed) |part| result_hmac.update(part);
+        result_hmac.final(result[index..][0..Hmac.mac_length]);
+    }
+    return result[0..len].*;
+}
+
 pub fn hkdfExpandLabel(
     comptime Hkdf: type,
     key: [Hkdf.prk_length]u8,
@@ -399,38 +588,39 @@ pub fn hmac(comptime Hmac: type, message: []const u8, key: [Hmac.key_length]u8)
     return result;
 }
 
-pub inline fn extension(comptime et: ExtensionType, bytes: anytype) [2 + 2 + bytes.len]u8 {
-    return int2(@intFromEnum(et)) ++ array(1, bytes);
-}
-
-pub inline fn array(comptime elem_size: comptime_int, bytes: anytype) [2 + bytes.len]u8 {
-    comptime assert(bytes.len % elem_size == 0);
-    return int2(bytes.len) ++ bytes;
+pub inline fn extension(et: ExtensionType, bytes: anytype) [2 + 2 + bytes.len]u8 {
+    return int(u16, @intFromEnum(et)) ++ array(u16, u8, bytes);
 }
 
-pub inline fn enum_array(comptime E: type, comptime tags: []const E) [2 + @sizeOf(E) * tags.len]u8 {
-    assert(@sizeOf(E) == 2);
-    var result: [tags.len * 2]u8 = undefined;
-    for (tags, 0..) |elem, i| {
-        result[i * 2] = @as(u8, @truncate(@intFromEnum(elem) >> 8));
-        result[i * 2 + 1] = @as(u8, @truncate(@intFromEnum(elem)));
+pub inline fn array(
+    comptime Len: type,
+    comptime Elem: type,
+    elems: anytype,
+) [@divExact(@bitSizeOf(Len), 8) + @divExact(@bitSizeOf(Elem), 8) * elems.len]u8 {
+    const len_size = @divExact(@bitSizeOf(Len), 8);
+    const elem_size = @divExact(@bitSizeOf(Elem), 8);
+    var arr: [len_size + elem_size * elems.len]u8 = undefined;
+    std.mem.writeInt(Len, arr[0..len_size], @intCast(elem_size * elems.len), .big);
+    const ElemInt = @Type(.{ .int = .{ .signedness = .unsigned, .bits = @bitSizeOf(Elem) } });
+    for (0.., @as([elems.len]Elem, elems)) |index, elem| {
+        std.mem.writeInt(
+            ElemInt,
+            arr[len_size + elem_size * index ..][0..elem_size],
+            switch (@typeInfo(Elem)) {
+                .int => @as(Elem, elem),
+                .@"enum" => @intFromEnum(@as(Elem, elem)),
+                else => @bitCast(@as(Elem, elem)),
+            },
+            .big,
+        );
     }
-    return array(2, result);
+    return arr;
 }
 
-pub inline fn int2(x: u16) [2]u8 {
-    return .{
-        @as(u8, @truncate(x >> 8)),
-        @as(u8, @truncate(x)),
-    };
-}
-
-pub inline fn int3(x: u24) [3]u8 {
-    return .{
-        @as(u8, @truncate(x >> 16)),
-        @as(u8, @truncate(x >> 8)),
-        @as(u8, @truncate(x)),
-    };
+pub inline fn int(comptime Int: type, val: Int) [@divExact(@bitSizeOf(Int), 8)]u8 {
+    var arr: [@divExact(@bitSizeOf(Int), 8)]u8 = undefined;
+    std.mem.writeInt(Int, &arr, val, .big);
+    return arr;
 }
 
 /// An abstraction to ensure that protocol-parsing code does not perform an
@@ -512,9 +702,8 @@ pub const Decoder = struct {
                 else => @compileError("unsupported int type: " ++ @typeName(T)),
             },
             .@"enum" => |info| {
-                const int = d.decode(info.tag_type);
                 if (info.is_exhaustive) @compileError("exhaustive enum cannot be used");
-                return @as(T, @enumFromInt(int));
+                return @enumFromInt(d.decode(info.tag_type));
             },
             else => @compileError("unsupported type: " ++ @typeName(T)),
         }
diff --git a/zig/lib/std/crypto/tls/Client.zig b/zig/lib/std/crypto/tls/Client.zig
index 84dbb2167a..20ea485049 100644
--- a/zig/lib/std/crypto/tls/Client.zig
+++ b/zig/lib/std/crypto/tls/Client.zig
@@ -8,12 +8,12 @@ const assert = std.debug.assert;
 const Certificate = std.crypto.Certificate;
 
 const max_ciphertext_len = tls.max_ciphertext_len;
+const hmacExpandLabel = tls.hmacExpandLabel;
 const hkdfExpandLabel = tls.hkdfExpandLabel;
-const int2 = tls.int2;
-const int3 = tls.int3;
+const int = tls.int;
 const array = tls.array;
-const enum_array = tls.enum_array;
 
+tls_version: tls.ProtocolVersion,
 read_seq: u64,
 write_seq: u64,
 /// The starting index of cleartext bytes inside `partially_read_buffer`.
@@ -33,7 +33,7 @@ received_close_notify: bool,
 /// This makes the application vulnerable to truncation attacks unless the
 /// application layer itself verifies that the amount of data received equals
 /// the amount of data expected, such as HTTP with the Content-Length header.
-allow_truncation_attacks: bool = false,
+allow_truncation_attacks: bool,
 application_cipher: tls.ApplicationCipher,
 /// The size is enough to contain exactly one TLSCiphertext record.
 /// This buffer is segmented into four parts:
@@ -44,6 +44,24 @@ application_cipher: tls.ApplicationCipher,
 /// The fields `partial_cleartext_idx`, `partial_ciphertext_idx`, and
 /// `partial_ciphertext_end` describe the span of the segments.
 partially_read_buffer: [tls.max_ciphertext_record_len]u8,
+/// If non-null, ssl secrets are logged to a file.  Creating such a log file allows other
+/// programs with access to that file to decrypt all traffic over this connection.
+ssl_key_log: ?struct {
+    client_key_seq: u64,
+    server_key_seq: u64,
+    client_random: [32]u8,
+    file: std.fs.File,
+
+    fn clientCounter(key_log: *@This()) u64 {
+        defer key_log.client_key_seq += 1;
+        return key_log.client_key_seq;
+    }
+
+    fn serverCounter(key_log: *@This()) u64 {
+        defer key_log.server_key_seq += 1;
+        return key_log.server_key_seq;
+    }
+},
 
 /// This is an example of the type that is needed by the read and write
 /// functions. It can have any fields but it must at least have these
@@ -88,6 +106,32 @@ pub const StreamInterface = struct {
     }
 };
 
+pub const Options = struct {
+    /// How to perform host verification of server certificates.
+    host: union(enum) {
+        /// No host verification is performed, which prevents a trusted connection from
+        /// being established.
+        no_verification,
+        /// Verify that the server certificate was issues for a given host.
+        explicit: []const u8,
+    },
+    /// How to verify the authenticity of server certificates.
+    ca: union(enum) {
+        /// No ca verification is performed, which prevents a trusted connection from
+        /// being established.
+        no_verification,
+        /// Verify that the server certificate is a valid self-signed certificate.
+        /// This provides no authorization guarantees, as anyone can create a
+        /// self-signed certificate.
+        self_signed,
+        /// Verify that the server certificate is authorized by a given ca bundle.
+        bundle: Certificate.Bundle,
+    },
+    /// If non-null, ssl secrets are logged to this file.  Creating such a log file allows
+    /// other programs with access to that file to decrypt all traffic over this connection.
+    ssl_key_log_file: ?std.fs.File = null,
+};
+
 pub fn InitError(comptime Stream: type) type {
     return std.mem.Allocator.Error || Stream.WriteError || Stream.ReadError || tls.AlertDescription.Error || error{
         InsufficientEntropy,
@@ -136,326 +180,186 @@ pub fn InitError(comptime Stream: type) type {
     };
 }
 
-/// Initiates a TLS handshake and establishes a TLSv1.3 session with `stream`, which
+/// Initiates a TLS handshake and establishes a TLSv1.2 or TLSv1.3 session with `stream`, which
 /// must conform to `StreamInterface`.
 ///
 /// `host` is only borrowed during this function call.
-pub fn init(stream: anytype, ca_bundle: Certificate.Bundle, host: []const u8) InitError(@TypeOf(stream))!Client {
+pub fn init(stream: anytype, options: Options) InitError(@TypeOf(stream))!Client {
+    const host = switch (options.host) {
+        .no_verification => "",
+        .explicit => |host| host,
+    };
     const host_len: u16 = @intCast(host.len);
 
-    var random_buffer: [128]u8 = undefined;
+    var random_buffer: [176]u8 = undefined;
     crypto.random.bytes(&random_buffer);
-    const hello_rand = random_buffer[0..32].*;
+    const client_hello_rand = random_buffer[0..32].*;
+    var key_seq: u64 = 0;
+    var server_hello_rand: [32]u8 = undefined;
     const legacy_session_id = random_buffer[32..64].*;
-    const x25519_kp_seed = random_buffer[64..96].*;
-    const secp256r1_kp_seed = random_buffer[96..128].*;
 
-    const x25519_kp = crypto.dh.X25519.KeyPair.create(x25519_kp_seed) catch |err| switch (err) {
-        // Only possible to happen if the private key is all zeroes.
-        error.IdentityElement => return error.InsufficientEntropy,
-    };
-    const secp256r1_kp = crypto.sign.ecdsa.EcdsaP256Sha256.KeyPair.create(secp256r1_kp_seed) catch |err| switch (err) {
-        // Only possible to happen if the private key is all zeroes.
+    var key_share = KeyShare.init(random_buffer[64..176].*) catch |err| switch (err) {
+        // Only possible to happen if the seed is all zeroes.
         error.IdentityElement => return error.InsufficientEntropy,
     };
-    const ml_kem768_kp = crypto.kem.ml_kem.MLKem768.KeyPair.create(null) catch {};
 
-    const extensions_payload =
-        tls.extension(.supported_versions, [_]u8{
-        0x02, // byte length of supported versions
-        0x03, 0x04, // TLS 1.3
-    }) ++ tls.extension(.signature_algorithms, enum_array(tls.SignatureScheme, &.{
+    const extensions_payload = tls.extension(.supported_versions, array(u8, tls.ProtocolVersion, .{
+        .tls_1_3,
+        .tls_1_2,
+    })) ++ tls.extension(.signature_algorithms, array(u16, tls.SignatureScheme, .{
         .ecdsa_secp256r1_sha256,
         .ecdsa_secp384r1_sha384,
+        .rsa_pkcs1_sha256,
+        .rsa_pkcs1_sha384,
+        .rsa_pkcs1_sha512,
         .rsa_pss_rsae_sha256,
         .rsa_pss_rsae_sha384,
         .rsa_pss_rsae_sha512,
+        .rsa_pss_pss_sha256,
+        .rsa_pss_pss_sha384,
+        .rsa_pss_pss_sha512,
+        .rsa_pkcs1_sha1,
         .ed25519,
-    })) ++ tls.extension(.supported_groups, enum_array(tls.NamedGroup, &.{
+    })) ++ tls.extension(.supported_groups, array(u16, tls.NamedGroup, .{
         .x25519_ml_kem768,
         .secp256r1,
+        .secp384r1,
         .x25519,
-    })) ++ tls.extension(
-        .key_share,
-        array(1, int2(@intFromEnum(tls.NamedGroup.x25519)) ++
-            array(1, x25519_kp.public_key) ++
-            int2(@intFromEnum(tls.NamedGroup.secp256r1)) ++
-            array(1, secp256r1_kp.public_key.toUncompressedSec1()) ++
-            int2(@intFromEnum(tls.NamedGroup.x25519_ml_kem768)) ++
-            array(1, x25519_kp.public_key ++ ml_kem768_kp.public_key.toBytes())),
-    ) ++
-        int2(@intFromEnum(tls.ExtensionType.server_name)) ++
-        int2(host_len + 5) ++ // byte length of this extension payload
-        int2(host_len + 3) ++ // server_name_list byte count
-        [1]u8{0x00} ++ // name_type
-        int2(host_len);
+    })) ++ tls.extension(.psk_key_exchange_modes, array(u8, tls.PskKeyExchangeMode, .{
+        .psk_dhe_ke,
+    })) ++ tls.extension(.key_share, array(
+        u16,
+        u8,
+        int(u16, @intFromEnum(tls.NamedGroup.x25519_ml_kem768)) ++
+            array(u16, u8, key_share.ml_kem768_kp.public_key.toBytes() ++ key_share.x25519_kp.public_key) ++
+            int(u16, @intFromEnum(tls.NamedGroup.secp256r1)) ++
+            array(u16, u8, key_share.secp256r1_kp.public_key.toUncompressedSec1()) ++
+            int(u16, @intFromEnum(tls.NamedGroup.secp384r1)) ++
+            array(u16, u8, key_share.secp384r1_kp.public_key.toUncompressedSec1()) ++
+            int(u16, @intFromEnum(tls.NamedGroup.x25519)) ++
+            array(u16, u8, key_share.x25519_kp.public_key),
+    ));
+    const server_name_extension = int(u16, @intFromEnum(tls.ExtensionType.server_name)) ++
+        int(u16, 2 + 1 + 2 + host_len) ++ // byte length of this extension payload
+        int(u16, 1 + 2 + host_len) ++ // server_name_list byte count
+        .{0x00} ++ // name_type
+        int(u16, host_len);
+    const server_name_extension_len = switch (options.host) {
+        .no_verification => 0,
+        .explicit => server_name_extension.len + host_len,
+    };
 
     const extensions_header =
-        int2(@intCast(extensions_payload.len + host_len)) ++
-        extensions_payload;
-
-    const legacy_compression_methods = 0x0100;
+        int(u16, @intCast(extensions_payload.len + server_name_extension_len)) ++
+        extensions_payload ++
+        server_name_extension;
 
     const client_hello =
-        int2(@intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
-        hello_rand ++
+        int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
+        client_hello_rand ++
         [1]u8{32} ++ legacy_session_id ++
         cipher_suites ++
-        int2(legacy_compression_methods) ++
+        array(u8, tls.CompressionMethod, .{.null}) ++
         extensions_header;
 
-    const out_handshake =
-        [_]u8{@intFromEnum(tls.HandshakeType.client_hello)} ++
-        int3(@intCast(client_hello.len + host_len)) ++
+    const out_handshake = .{@intFromEnum(tls.HandshakeType.client_hello)} ++
+        int(u24, @intCast(client_hello.len - server_name_extension.len + server_name_extension_len)) ++
         client_hello;
 
-    const plaintext_header = [_]u8{
-        @intFromEnum(tls.ContentType.handshake),
-        0x03, 0x01, // legacy_record_version
-    } ++ int2(@intCast(out_handshake.len + host_len)) ++ out_handshake;
+    const cleartext_header_buf = .{@intFromEnum(tls.ContentType.handshake)} ++
+        int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_0)) ++
+        int(u16, @intCast(out_handshake.len - server_name_extension.len + server_name_extension_len)) ++
+        out_handshake;
+    const cleartext_header = switch (options.host) {
+        .no_verification => cleartext_header_buf[0 .. cleartext_header_buf.len - server_name_extension.len],
+        .explicit => &cleartext_header_buf,
+    };
 
     {
         var iovecs = [_]std.posix.iovec_const{
-            .{
-                .base = &plaintext_header,
-                .len = plaintext_header.len,
-            },
-            .{
-                .base = host.ptr,
-                .len = host.len,
-            },
+            .{ .base = cleartext_header.ptr, .len = cleartext_header.len },
+            .{ .base = host.ptr, .len = host.len },
         };
-        try stream.writevAll(&iovecs);
+        try stream.writevAll(iovecs[0..if (host.len == 0) 1 else 2]);
     }
 
-    const client_hello_bytes1 = plaintext_header[5..];
-
-    var handshake_cipher: tls.HandshakeCipher = undefined;
-    var handshake_buffer: [8000]u8 = undefined;
-    var d: tls.Decoder = .{ .buf = &handshake_buffer };
-    {
-        try d.readAtLeastOurAmt(stream, tls.record_header_len);
-        const ct = d.decode(tls.ContentType);
-        d.skip(2); // legacy_record_version
-        const record_len = d.decode(u16);
-        try d.readAtLeast(stream, record_len);
-        const server_hello_fragment = d.buf[d.idx..][0..record_len];
-        var ptd = try d.sub(record_len);
-        switch (ct) {
-            .alert => {
-                try ptd.ensure(2);
-                const level = ptd.decode(tls.AlertLevel);
-                const desc = ptd.decode(tls.AlertDescription);
-                _ = level;
-
-                // if this isn't a error alert, then it's a closure alert, which makes no sense in a handshake
-                try desc.toError();
-                // TODO: handle server-side closures
-                return error.TlsUnexpectedMessage;
-            },
-            .handshake => {
-                try ptd.ensure(4);
-                const handshake_type = ptd.decode(tls.HandshakeType);
-                if (handshake_type != .server_hello) return error.TlsUnexpectedMessage;
-                const length = ptd.decode(u24);
-                var hsd = try ptd.sub(length);
-                try hsd.ensure(2 + 32 + 1 + 32 + 2 + 1 + 2);
-                const legacy_version = hsd.decode(u16);
-                const random = hsd.array(32);
-                if (mem.eql(u8, random, &tls.hello_retry_request_sequence)) {
-                    // This is a HelloRetryRequest message. This client implementation
-                    // does not expect to get one.
-                    return error.TlsUnexpectedMessage;
-                }
-                const legacy_session_id_echo_len = hsd.decode(u8);
-                if (legacy_session_id_echo_len != 32) return error.TlsIllegalParameter;
-                const legacy_session_id_echo = hsd.array(32);
-                if (!mem.eql(u8, legacy_session_id_echo, &legacy_session_id))
-                    return error.TlsIllegalParameter;
-                const cipher_suite_tag = hsd.decode(tls.CipherSuite);
-                hsd.skip(1); // legacy_compression_method
-                const extensions_size = hsd.decode(u16);
-                var all_extd = try hsd.sub(extensions_size);
-                var supported_version: u16 = 0;
-                var shared_key: []const u8 = undefined;
-                var have_shared_key = false;
-                while (!all_extd.eof()) {
-                    try all_extd.ensure(2 + 2);
-                    const et = all_extd.decode(tls.ExtensionType);
-                    const ext_size = all_extd.decode(u16);
-                    var extd = try all_extd.sub(ext_size);
-                    switch (et) {
-                        .supported_versions => {
-                            if (supported_version != 0) return error.TlsIllegalParameter;
-                            try extd.ensure(2);
-                            supported_version = extd.decode(u16);
-                        },
-                        .key_share => {
-                            if (have_shared_key) return error.TlsIllegalParameter;
-                            have_shared_key = true;
-                            try extd.ensure(4);
-                            const named_group = extd.decode(tls.NamedGroup);
-                            const key_size = extd.decode(u16);
-                            try extd.ensure(key_size);
-                            switch (named_group) {
-                                .x25519_ml_kem768 => {
-                                    const xksl = crypto.dh.X25519.public_length;
-                                    const hksl = xksl + crypto.kem.ml_kem.MLKem768.ciphertext_length;
-                                    if (key_size != hksl)
-                                        return error.TlsIllegalParameter;
-                                    const server_ks = extd.array(hksl);
-
-                                    shared_key = &((crypto.dh.X25519.scalarmult(
-                                        x25519_kp.secret_key,
-                                        server_ks[0..xksl].*,
-                                    ) catch return error.TlsDecryptFailure) ++ (ml_kem768_kp.secret_key.decaps(
-                                        server_ks[xksl..hksl],
-                                    ) catch return error.TlsDecryptFailure));
-                                },
-                                .x25519 => {
-                                    const ksl = crypto.dh.X25519.public_length;
-                                    if (key_size != ksl) return error.TlsIllegalParameter;
-                                    const server_pub_key = extd.array(ksl);
-
-                                    shared_key = &(crypto.dh.X25519.scalarmult(
-                                        x25519_kp.secret_key,
-                                        server_pub_key.*,
-                                    ) catch return error.TlsDecryptFailure);
-                                },
-                                .secp256r1 => {
-                                    const server_pub_key = extd.slice(key_size);
-
-                                    const PublicKey = crypto.sign.ecdsa.EcdsaP256Sha256.PublicKey;
-                                    const pk = PublicKey.fromSec1(server_pub_key) catch {
-                                        return error.TlsDecryptFailure;
-                                    };
-                                    const mul = pk.p.mulPublic(secp256r1_kp.secret_key.bytes, .big) catch {
-                                        return error.TlsDecryptFailure;
-                                    };
-                                    shared_key = &mul.affineCoordinates().x.toBytes(.big);
-                                },
-                                else => {
-                                    return error.TlsIllegalParameter;
-                                },
-                            }
-                        },
-                        else => {},
-                    }
-                }
-                if (!have_shared_key) return error.TlsIllegalParameter;
-
-                const tls_version = if (supported_version == 0) legacy_version else supported_version;
-                if (tls_version != @intFromEnum(tls.ProtocolVersion.tls_1_3))
-                    return error.TlsIllegalParameter;
-
-                switch (cipher_suite_tag) {
-                    inline .AES_128_GCM_SHA256,
-                    .AES_256_GCM_SHA384,
-                    .CHACHA20_POLY1305_SHA256,
-                    .AEGIS_256_SHA512,
-                    .AEGIS_128L_SHA256,
-                    => |tag| {
-                        const P = std.meta.TagPayloadByName(tls.HandshakeCipher, @tagName(tag));
-                        handshake_cipher = @unionInit(tls.HandshakeCipher, @tagName(tag), .{
-                            .handshake_secret = undefined,
-                            .master_secret = undefined,
-                            .client_handshake_key = undefined,
-                            .server_handshake_key = undefined,
-                            .client_finished_key = undefined,
-                            .server_finished_key = undefined,
-                            .client_handshake_iv = undefined,
-                            .server_handshake_iv = undefined,
-                            .transcript_hash = P.Hash.init(.{}),
-                        });
-                        const p = &@field(handshake_cipher, @tagName(tag));
-                        p.transcript_hash.update(client_hello_bytes1); // Client Hello part 1
-                        p.transcript_hash.update(host); // Client Hello part 2
-                        p.transcript_hash.update(server_hello_fragment);
-                        const hello_hash = p.transcript_hash.peek();
-                        const zeroes = [1]u8{0} ** P.Hash.digest_length;
-                        const early_secret = P.Hkdf.extract(&[1]u8{0}, &zeroes);
-                        const empty_hash = tls.emptyHash(P.Hash);
-                        const hs_derived_secret = hkdfExpandLabel(P.Hkdf, early_secret, "derived", &empty_hash, P.Hash.digest_length);
-                        p.handshake_secret = P.Hkdf.extract(&hs_derived_secret, shared_key);
-                        const ap_derived_secret = hkdfExpandLabel(P.Hkdf, p.handshake_secret, "derived", &empty_hash, P.Hash.digest_length);
-                        p.master_secret = P.Hkdf.extract(&ap_derived_secret, &zeroes);
-                        const client_secret = hkdfExpandLabel(P.Hkdf, p.handshake_secret, "c hs traffic", &hello_hash, P.Hash.digest_length);
-                        const server_secret = hkdfExpandLabel(P.Hkdf, p.handshake_secret, "s hs traffic", &hello_hash, P.Hash.digest_length);
-                        p.client_finished_key = hkdfExpandLabel(P.Hkdf, client_secret, "finished", "", P.Hmac.key_length);
-                        p.server_finished_key = hkdfExpandLabel(P.Hkdf, server_secret, "finished", "", P.Hmac.key_length);
-                        p.client_handshake_key = hkdfExpandLabel(P.Hkdf, client_secret, "key", "", P.AEAD.key_length);
-                        p.server_handshake_key = hkdfExpandLabel(P.Hkdf, server_secret, "key", "", P.AEAD.key_length);
-                        p.client_handshake_iv = hkdfExpandLabel(P.Hkdf, client_secret, "iv", "", P.AEAD.nonce_length);
-                        p.server_handshake_iv = hkdfExpandLabel(P.Hkdf, server_secret, "iv", "", P.AEAD.nonce_length);
-                    },
-                    else => {
-                        return error.TlsIllegalParameter;
-                    },
-                }
-            },
-            else => return error.TlsUnexpectedMessage,
-        }
-    }
-
-    // This is used for two purposes:
+    var tls_version: tls.ProtocolVersion = undefined;
+    // These are used for two purposes:
     // * Detect whether a certificate is the first one presented, in which case
     //   we need to verify the host name.
+    var cert_index: usize = 0;
     // * Flip back and forth between the two cleartext buffers in order to keep
     //   the previous certificate in memory so that it can be verified by the
     //   next one.
-    var cert_index: usize = 0;
+    var cert_buf_index: usize = 0;
+    var write_seq: u64 = 0;
     var read_seq: u64 = 0;
     var prev_cert: Certificate.Parsed = undefined;
-    // Set to true once a trust chain has been established from the first
-    // certificate to a root CA.
+    const CipherState = enum {
+        /// No cipher is in use
+        cleartext,
+        /// Handshake cipher is in use
+        handshake,
+        /// Application cipher is in use
+        application,
+    };
+    var pending_cipher_state: CipherState = .cleartext;
+    var cipher_state = pending_cipher_state;
     const HandshakeState = enum {
+        /// In this state we expect only a server hello message.
+        hello,
         /// In this state we expect only an encrypted_extensions message.
         encrypted_extensions,
-        /// In this state we expect certificate messages.
+        /// In this state we expect certificate handshake messages.
         certificate,
         /// In this state we expect certificate or certificate_verify messages.
         /// certificate messages are ignored since the trust chain is already
         /// established.
         trust_chain_established,
-        /// In this state, we expect only the finished message.
+        /// In this state, we expect only the server_hello_done handshake message.
+        server_hello_done,
+        /// In this state, we expect only the finished handshake message.
         finished,
     };
-    var handshake_state: HandshakeState = .encrypted_extensions;
-    var cleartext_bufs: [2][8000]u8 = undefined;
-    var main_cert_pub_key_algo: Certificate.AlgorithmCategory = undefined;
-    var main_cert_pub_key_buf: [600]u8 = undefined;
-    var main_cert_pub_key_len: u16 = undefined;
+    var handshake_state: HandshakeState = .hello;
+    var handshake_cipher: tls.HandshakeCipher = undefined;
+    var main_cert_pub_key: CertificatePublicKey = undefined;
     const now_sec = std.time.timestamp();
 
-    while (true) {
+    var cleartext_fragment_start: usize = 0;
+    var cleartext_fragment_end: usize = 0;
+    var cleartext_bufs: [2][tls.max_ciphertext_inner_record_len]u8 = undefined;
+    var handshake_buffer: [tls.max_ciphertext_record_len]u8 = undefined;
+    var d: tls.Decoder = .{ .buf = &handshake_buffer };
+    fragment: while (true) {
         try d.readAtLeastOurAmt(stream, tls.record_header_len);
-        const record_header = d.buf[d.idx..][0..5];
-        const ct = d.decode(tls.ContentType);
+        const record_header = d.buf[d.idx..][0..tls.record_header_len];
+        const record_ct = d.decode(tls.ContentType);
         d.skip(2); // legacy_version
         const record_len = d.decode(u16);
         try d.readAtLeast(stream, record_len);
         var record_decoder = try d.sub(record_len);
-        switch (ct) {
-            .change_cipher_spec => {
-                try record_decoder.ensure(1);
-                if (record_decoder.decode(u8) != 0x01) return error.TlsIllegalParameter;
-            },
-            .application_data => {
-                const cleartext_buf = &cleartext_bufs[cert_index % 2];
-
-                const cleartext = switch (handshake_cipher) {
-                    inline else => |*p| c: {
-                        const P = @TypeOf(p.*);
-                        const ciphertext_len = record_len - P.AEAD.tag_length;
-                        try record_decoder.ensure(ciphertext_len + P.AEAD.tag_length);
-                        const ciphertext = record_decoder.slice(ciphertext_len);
-                        if (ciphertext.len > cleartext_buf.len) return error.TlsRecordOverflow;
-                        const cleartext = cleartext_buf[0..ciphertext.len];
+        var ctd, const ct = content: switch (cipher_state) {
+            .cleartext => .{ record_decoder, record_ct },
+            .handshake => {
+                std.debug.assert(tls_version == .tls_1_3);
+                if (record_ct != .application_data) return error.TlsUnexpectedMessage;
+                try record_decoder.ensure(record_len);
+                const cleartext_buf = &cleartext_bufs[cert_buf_index % 2];
+                switch (handshake_cipher) {
+                    inline else => |*p| {
+                        const pv = &p.version.tls_1_3;
+                        const P = @TypeOf(p.*).A;
+                        if (record_len < P.AEAD.tag_length) return error.TlsRecordOverflow;
+                        const ciphertext = record_decoder.slice(record_len - P.AEAD.tag_length);
+                        const cleartext_fragment_buf = cleartext_buf[cleartext_fragment_end..];
+                        if (ciphertext.len > cleartext_fragment_buf.len) return error.TlsRecordOverflow;
+                        const cleartext = cleartext_fragment_buf[0..ciphertext.len];
                         const auth_tag = record_decoder.array(P.AEAD.tag_length).*;
                         const nonce = if (builtin.zig_backend == .stage2_x86_64 and
                             P.AEAD.nonce_length > comptime std.simd.suggestVectorLength(u8) orelse 1)
                         nonce: {
-                            var nonce = p.server_handshake_iv;
+                            var nonce = pv.server_handshake_iv;
                             const operand = std.mem.readInt(u64, nonce[nonce.len - 8 ..], .big);
                             std.mem.writeInt(u64, nonce[nonce.len - 8 ..], operand ^ read_seq, .big);
                             break :nonce nonce;
@@ -463,268 +367,559 @@ pub fn init(stream: anytype, ca_bundle: Certificate.Bundle, host: []const u8) In
                             const V = @Vector(P.AEAD.nonce_length, u8);
                             const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
                             const operand: V = pad ++ @as([8]u8, @bitCast(big(read_seq)));
-                            break :nonce @as(V, p.server_handshake_iv) ^ operand;
+                            break :nonce @as(V, pv.server_handshake_iv) ^ operand;
                         };
-                        read_seq += 1;
-                        P.AEAD.decrypt(cleartext, ciphertext, auth_tag, record_header, nonce, p.server_handshake_key) catch
+                        P.AEAD.decrypt(cleartext, ciphertext, auth_tag, record_header, nonce, pv.server_handshake_key) catch
                             return error.TlsBadRecordMac;
-                        break :c @constCast(mem.trimRight(u8, cleartext, "\x00"));
+                        cleartext_fragment_end += std.mem.trimRight(u8, cleartext, "\x00").len;
                     },
-                };
-
-                const inner_ct: tls.ContentType = @enumFromInt(cleartext[cleartext.len - 1]);
-                if (inner_ct != .handshake) return error.TlsUnexpectedMessage;
+                }
+                read_seq += 1;
+                cleartext_fragment_end -= 1;
+                const ct: tls.ContentType = @enumFromInt(cleartext_buf[cleartext_fragment_end]);
+                if (ct != .handshake) return error.TlsUnexpectedMessage;
+                break :content .{ tls.Decoder.fromTheirSlice(@constCast(cleartext_buf[cleartext_fragment_start..cleartext_fragment_end])), ct };
+            },
+            .application => {
+                std.debug.assert(tls_version == .tls_1_2);
+                if (record_ct != .handshake) return error.TlsUnexpectedMessage;
+                try record_decoder.ensure(record_len);
+                const cleartext_buf = &cleartext_bufs[cert_buf_index % 2];
+                switch (handshake_cipher) {
+                    inline else => |*p| {
+                        const pv = &p.version.tls_1_2;
+                        const P = @TypeOf(p.*).A;
+                        if (record_len < P.record_iv_length + P.mac_length) return error.TlsRecordOverflow;
+                        const message_len: u16 = record_len - P.record_iv_length - P.mac_length;
+                        const cleartext_fragment_buf = cleartext_buf[cleartext_fragment_end..];
+                        if (message_len > cleartext_fragment_buf.len) return error.TlsRecordOverflow;
+                        const cleartext = cleartext_fragment_buf[0..message_len];
+                        const ad = std.mem.toBytes(big(read_seq)) ++
+                            record_header[0 .. 1 + 2] ++
+                            std.mem.toBytes(big(message_len));
+                        const record_iv = record_decoder.array(P.record_iv_length).*;
+                        const masked_read_seq = read_seq &
+                            comptime std.math.shl(u64, std.math.maxInt(u64), 8 * P.record_iv_length);
+                        const nonce: [P.AEAD.nonce_length]u8 = if (builtin.zig_backend == .stage2_x86_64 and
+                            P.AEAD.nonce_length > comptime std.simd.suggestVectorLength(u8) orelse 1)
+                        nonce: {
+                            var nonce = pv.app_cipher.server_write_IV ++ record_iv;
+                            const operand = std.mem.readInt(u64, nonce[nonce.len - 8 ..], .big);
+                            std.mem.writeInt(u64, nonce[nonce.len - 8 ..], operand ^ masked_read_seq, .big);
+                            break :nonce nonce;
+                        } else nonce: {
+                            const V = @Vector(P.AEAD.nonce_length, u8);
+                            const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                            const operand: V = pad ++ @as([8]u8, @bitCast(big(masked_read_seq)));
+                            break :nonce @as(V, pv.app_cipher.server_write_IV ++ record_iv) ^ operand;
+                        };
+                        const ciphertext = record_decoder.slice(message_len);
+                        const auth_tag = record_decoder.array(P.mac_length);
+                        P.AEAD.decrypt(cleartext, ciphertext, auth_tag.*, ad, nonce, pv.app_cipher.server_write_key) catch return error.TlsBadRecordMac;
+                        cleartext_fragment_end += message_len;
+                    },
+                }
+                read_seq += 1;
+                break :content .{ tls.Decoder.fromTheirSlice(cleartext_buf[cleartext_fragment_start..cleartext_fragment_end]), record_ct };
+            },
+        };
+        switch (ct) {
+            .alert => {
+                ctd.ensure(2) catch continue :fragment;
+                const level = ctd.decode(tls.AlertLevel);
+                const desc = ctd.decode(tls.AlertDescription);
+                _ = level;
 
-                var ctd = tls.Decoder.fromTheirSlice(cleartext[0 .. cleartext.len - 1]);
-                while (true) {
-                    try ctd.ensure(4);
-                    const handshake_type = ctd.decode(tls.HandshakeType);
-                    const handshake_len = ctd.decode(u24);
-                    var hsd = try ctd.sub(handshake_len);
-                    const wrapped_handshake = ctd.buf[ctd.idx - handshake_len - 4 .. ctd.idx];
-                    const handshake = ctd.buf[ctd.idx - handshake_len .. ctd.idx];
-                    switch (handshake_type) {
-                        .encrypted_extensions => {
-                            if (handshake_state != .encrypted_extensions) return error.TlsUnexpectedMessage;
-                            handshake_state = .certificate;
-                            switch (handshake_cipher) {
-                                inline else => |*p| p.transcript_hash.update(wrapped_handshake),
-                            }
+                // if this isn't a error alert, then it's a closure alert, which makes no sense in a handshake
+                try desc.toError();
+                // TODO: handle server-side closures
+                return error.TlsUnexpectedMessage;
+            },
+            .change_cipher_spec => {
+                ctd.ensure(1) catch continue :fragment;
+                if (ctd.decode(tls.ChangeCipherSpecType) != .change_cipher_spec) return error.TlsIllegalParameter;
+                cipher_state = pending_cipher_state;
+            },
+            .handshake => while (true) {
+                ctd.ensure(4) catch continue :fragment;
+                const handshake_type = ctd.decode(tls.HandshakeType);
+                const handshake_len = ctd.decode(u24);
+                var hsd = ctd.sub(handshake_len) catch continue :fragment;
+                const wrapped_handshake = ctd.buf[ctd.idx - handshake_len - 4 .. ctd.idx];
+                switch (handshake_type) {
+                    .server_hello => {
+                        if (cipher_state != .cleartext) return error.TlsUnexpectedMessage;
+                        if (handshake_state != .hello) return error.TlsUnexpectedMessage;
+                        try hsd.ensure(2 + 32 + 1);
+                        const legacy_version = hsd.decode(u16);
+                        @memcpy(&server_hello_rand, hsd.array(32));
+                        if (mem.eql(u8, &server_hello_rand, &tls.hello_retry_request_sequence)) {
+                            // This is a HelloRetryRequest message. This client implementation
+                            // does not expect to get one.
+                            return error.TlsUnexpectedMessage;
+                        }
+                        const legacy_session_id_echo_len = hsd.decode(u8);
+                        try hsd.ensure(legacy_session_id_echo_len + 2 + 1);
+                        const legacy_session_id_echo = hsd.slice(legacy_session_id_echo_len);
+                        const cipher_suite_tag = hsd.decode(tls.CipherSuite);
+                        hsd.skip(1); // legacy_compression_method
+                        var supported_version: ?u16 = null;
+                        if (!hsd.eof()) {
                             try hsd.ensure(2);
-                            const total_ext_size = hsd.decode(u16);
-                            var all_extd = try hsd.sub(total_ext_size);
+                            const extensions_size = hsd.decode(u16);
+                            var all_extd = try hsd.sub(extensions_size);
                             while (!all_extd.eof()) {
-                                try all_extd.ensure(4);
+                                try all_extd.ensure(2 + 2);
                                 const et = all_extd.decode(tls.ExtensionType);
                                 const ext_size = all_extd.decode(u16);
-                                const extd = try all_extd.sub(ext_size);
-                                _ = extd;
+                                var extd = try all_extd.sub(ext_size);
                                 switch (et) {
-                                    .server_name => {},
+                                    .supported_versions => {
+                                        if (supported_version) |_| return error.TlsIllegalParameter;
+                                        try extd.ensure(2);
+                                        supported_version = extd.decode(u16);
+                                    },
+                                    .key_share => {
+                                        if (key_share.getSharedSecret()) |_| return error.TlsIllegalParameter;
+                                        try extd.ensure(4);
+                                        const named_group = extd.decode(tls.NamedGroup);
+                                        const key_size = extd.decode(u16);
+                                        try extd.ensure(key_size);
+                                        try key_share.exchange(named_group, extd.slice(key_size));
+                                    },
                                     else => {},
                                 }
                             }
-                        },
-                        .certificate => cert: {
-                            switch (handshake_cipher) {
-                                inline else => |*p| p.transcript_hash.update(wrapped_handshake),
-                            }
-                            switch (handshake_state) {
-                                .certificate => {},
-                                .trust_chain_established => break :cert,
-                                else => return error.TlsUnexpectedMessage,
-                            }
-                            try hsd.ensure(1 + 4);
-                            const cert_req_ctx_len = hsd.decode(u8);
-                            if (cert_req_ctx_len != 0) return error.TlsIllegalParameter;
-                            const certs_size = hsd.decode(u24);
-                            var certs_decoder = try hsd.sub(certs_size);
-                            while (!certs_decoder.eof()) {
-                                try certs_decoder.ensure(3);
-                                const cert_size = certs_decoder.decode(u24);
-                                const certd = try certs_decoder.sub(cert_size);
-
-                                const subject_cert: Certificate = .{
-                                    .buffer = certd.buf,
-                                    .index = @intCast(certd.idx),
-                                };
-                                const subject = try subject_cert.parse();
-                                if (cert_index == 0) {
-                                    // Verify the host on the first certificate.
-                                    try subject.verifyHostName(host);
-
-                                    // Keep track of the public key for the
-                                    // certificate_verify message later.
-                                    main_cert_pub_key_algo = subject.pub_key_algo;
-                                    const pub_key = subject.pubKey();
-                                    if (pub_key.len > main_cert_pub_key_buf.len)
-                                        return error.CertificatePublicKeyInvalid;
-                                    @memcpy(main_cert_pub_key_buf[0..pub_key.len], pub_key);
-                                    main_cert_pub_key_len = @intCast(pub_key.len);
-                                } else {
-                                    try prev_cert.verify(subject, now_sec);
-                                }
+                        }
 
-                                if (ca_bundle.verify(subject, now_sec)) |_| {
-                                    handshake_state = .trust_chain_established;
-                                    break :cert;
-                                } else |err| switch (err) {
-                                    error.CertificateIssuerNotFound => {},
-                                    else => |e| return e,
-                                }
+                        tls_version = @enumFromInt(supported_version orelse legacy_version);
+                        switch (tls_version) {
+                            .tls_1_3 => if (!mem.eql(u8, legacy_session_id_echo, &legacy_session_id)) return error.TlsIllegalParameter,
+                            .tls_1_2 => if (mem.eql(u8, server_hello_rand[24..31], "DOWNGRD") and
+                                server_hello_rand[31] >> 1 == 0x00) return error.TlsIllegalParameter,
+                            else => return error.TlsIllegalParameter,
+                        }
 
-                                prev_cert = subject;
-                                cert_index += 1;
+                        switch (cipher_suite_tag) {
+                            inline .AES_128_GCM_SHA256,
+                            .AES_256_GCM_SHA384,
+                            .CHACHA20_POLY1305_SHA256,
+                            .AEGIS_256_SHA512,
+                            .AEGIS_128L_SHA256,
+
+                            .ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+                            .ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+                            .ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+                            => |tag| {
+                                handshake_cipher = @unionInit(tls.HandshakeCipher, @tagName(tag.with()), .{
+                                    .transcript_hash = .init(.{}),
+                                    .version = undefined,
+                                });
+                                const p = &@field(handshake_cipher, @tagName(tag.with()));
+                                p.transcript_hash.update(cleartext_header[tls.record_header_len..]); // Client Hello part 1
+                                p.transcript_hash.update(host); // Client Hello part 2
+                                p.transcript_hash.update(wrapped_handshake);
+                            },
+
+                            else => return error.TlsIllegalParameter,
+                        }
+                        switch (tls_version) {
+                            .tls_1_3 => {
+                                switch (cipher_suite_tag) {
+                                    inline .AES_128_GCM_SHA256,
+                                    .AES_256_GCM_SHA384,
+                                    .CHACHA20_POLY1305_SHA256,
+                                    .AEGIS_256_SHA512,
+                                    .AEGIS_128L_SHA256,
+                                    => |tag| {
+                                        const sk = key_share.getSharedSecret() orelse return error.TlsIllegalParameter;
+                                        const p = &@field(handshake_cipher, @tagName(tag.with()));
+                                        const P = @TypeOf(p.*).A;
+                                        const hello_hash = p.transcript_hash.peek();
+                                        const zeroes = [1]u8{0} ** P.Hash.digest_length;
+                                        const early_secret = P.Hkdf.extract(&[1]u8{0}, &zeroes);
+                                        const empty_hash = tls.emptyHash(P.Hash);
+                                        p.version = .{ .tls_1_3 = undefined };
+                                        const pv = &p.version.tls_1_3;
+                                        const hs_derived_secret = hkdfExpandLabel(P.Hkdf, early_secret, "derived", &empty_hash, P.Hash.digest_length);
+                                        pv.handshake_secret = P.Hkdf.extract(&hs_derived_secret, sk);
+                                        const ap_derived_secret = hkdfExpandLabel(P.Hkdf, pv.handshake_secret, "derived", &empty_hash, P.Hash.digest_length);
+                                        pv.master_secret = P.Hkdf.extract(&ap_derived_secret, &zeroes);
+                                        const client_secret = hkdfExpandLabel(P.Hkdf, pv.handshake_secret, "c hs traffic", &hello_hash, P.Hash.digest_length);
+                                        const server_secret = hkdfExpandLabel(P.Hkdf, pv.handshake_secret, "s hs traffic", &hello_hash, P.Hash.digest_length);
+                                        if (options.ssl_key_log_file) |key_log_file| logSecrets(key_log_file, .{
+                                            .client_random = &client_hello_rand,
+                                        }, .{
+                                            .SERVER_HANDSHAKE_TRAFFIC_SECRET = &server_secret,
+                                            .CLIENT_HANDSHAKE_TRAFFIC_SECRET = &client_secret,
+                                        });
+                                        pv.client_finished_key = hkdfExpandLabel(P.Hkdf, client_secret, "finished", "", P.Hmac.key_length);
+                                        pv.server_finished_key = hkdfExpandLabel(P.Hkdf, server_secret, "finished", "", P.Hmac.key_length);
+                                        pv.client_handshake_key = hkdfExpandLabel(P.Hkdf, client_secret, "key", "", P.AEAD.key_length);
+                                        pv.server_handshake_key = hkdfExpandLabel(P.Hkdf, server_secret, "key", "", P.AEAD.key_length);
+                                        pv.client_handshake_iv = hkdfExpandLabel(P.Hkdf, client_secret, "iv", "", P.AEAD.nonce_length);
+                                        pv.server_handshake_iv = hkdfExpandLabel(P.Hkdf, server_secret, "iv", "", P.AEAD.nonce_length);
+                                    },
+                                    else => return error.TlsIllegalParameter,
+                                }
+                                pending_cipher_state = .handshake;
+                                handshake_state = .encrypted_extensions;
+                            },
+                            .tls_1_2 => switch (cipher_suite_tag) {
+                                .ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+                                .ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+                                .ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+                                => handshake_state = .certificate,
+                                else => return error.TlsIllegalParameter,
+                            },
+                            else => return error.TlsIllegalParameter,
+                        }
+                    },
+                    .encrypted_extensions => {
+                        if (tls_version != .tls_1_3) return error.TlsUnexpectedMessage;
+                        if (cipher_state != .handshake) return error.TlsUnexpectedMessage;
+                        if (handshake_state != .encrypted_extensions) return error.TlsUnexpectedMessage;
+                        switch (handshake_cipher) {
+                            inline else => |*p| p.transcript_hash.update(wrapped_handshake),
+                        }
+                        try hsd.ensure(2);
+                        const total_ext_size = hsd.decode(u16);
+                        var all_extd = try hsd.sub(total_ext_size);
+                        while (!all_extd.eof()) {
+                            try all_extd.ensure(4);
+                            const et = all_extd.decode(tls.ExtensionType);
+                            const ext_size = all_extd.decode(u16);
+                            const extd = try all_extd.sub(ext_size);
+                            _ = extd;
+                            switch (et) {
+                                .server_name => {},
+                                else => {},
+                            }
+                        }
+                        handshake_state = .certificate;
+                    },
+                    .certificate => cert: {
+                        if (cipher_state == .application) return error.TlsUnexpectedMessage;
+                        switch (handshake_state) {
+                            .certificate => {},
+                            .trust_chain_established => break :cert,
+                            else => return error.TlsUnexpectedMessage,
+                        }
+                        switch (handshake_cipher) {
+                            inline else => |*p| p.transcript_hash.update(wrapped_handshake),
+                        }
 
+                        switch (tls_version) {
+                            .tls_1_3 => {
+                                try hsd.ensure(1 + 3);
+                                const cert_req_ctx_len = hsd.decode(u8);
+                                if (cert_req_ctx_len != 0) return error.TlsIllegalParameter;
+                            },
+                            .tls_1_2 => try hsd.ensure(3),
+                            else => unreachable,
+                        }
+                        const certs_size = hsd.decode(u24);
+                        var certs_decoder = try hsd.sub(certs_size);
+                        while (!certs_decoder.eof()) {
+                            try certs_decoder.ensure(3);
+                            const cert_size = certs_decoder.decode(u24);
+                            const certd = try certs_decoder.sub(cert_size);
+
+                            if (tls_version == .tls_1_3) {
                                 try certs_decoder.ensure(2);
                                 const total_ext_size = certs_decoder.decode(u16);
                                 const all_extd = try certs_decoder.sub(total_ext_size);
                                 _ = all_extd;
                             }
-                        },
-                        .certificate_verify => {
-                            switch (handshake_state) {
-                                .trust_chain_established => handshake_state = .finished,
-                                .certificate => return error.TlsCertificateNotVerified,
-                                else => return error.TlsUnexpectedMessage,
-                            }
 
-                            try hsd.ensure(4);
-                            const scheme = hsd.decode(tls.SignatureScheme);
-                            const sig_len = hsd.decode(u16);
-                            try hsd.ensure(sig_len);
-                            const encoded_sig = hsd.slice(sig_len);
-                            const max_digest_len = 64;
-                            var verify_buffer: [64 + 34 + max_digest_len]u8 =
-                                ([1]u8{0x20} ** 64) ++
-                                "TLS 1.3, server CertificateVerify\x00".* ++
-                                @as([max_digest_len]u8, undefined);
-
-                            const verify_bytes = switch (handshake_cipher) {
-                                inline else => |*p| v: {
-                                    const transcript_digest = p.transcript_hash.peek();
-                                    verify_buffer[verify_buffer.len - max_digest_len ..][0..transcript_digest.len].* = transcript_digest;
-                                    p.transcript_hash.update(wrapped_handshake);
-                                    break :v verify_buffer[0 .. verify_buffer.len - max_digest_len + transcript_digest.len];
-                                },
+                            const subject_cert: Certificate = .{
+                                .buffer = certd.buf,
+                                .index = @intCast(certd.idx),
                             };
-                            const main_cert_pub_key = main_cert_pub_key_buf[0..main_cert_pub_key_len];
-
-                            switch (scheme) {
-                                inline .ecdsa_secp256r1_sha256,
-                                .ecdsa_secp384r1_sha384,
-                                => |comptime_scheme| {
-                                    if (main_cert_pub_key_algo != .X9_62_id_ecPublicKey)
-                                        return error.TlsBadSignatureScheme;
-                                    const Ecdsa = SchemeEcdsa(comptime_scheme);
-                                    const sig = try Ecdsa.Signature.fromDer(encoded_sig);
-                                    const key = try Ecdsa.PublicKey.fromSec1(main_cert_pub_key);
-                                    try sig.verify(verify_bytes, key);
-                                },
-                                inline .rsa_pss_rsae_sha256,
-                                .rsa_pss_rsae_sha384,
-                                .rsa_pss_rsae_sha512,
-                                => |comptime_scheme| {
-                                    if (main_cert_pub_key_algo != .rsaEncryption)
-                                        return error.TlsBadSignatureScheme;
-
-                                    const Hash = SchemeHash(comptime_scheme);
-                                    const rsa = Certificate.rsa;
-                                    const components = try rsa.PublicKey.parseDer(main_cert_pub_key);
-                                    const exponent = components.exponent;
-                                    const modulus = components.modulus;
-                                    switch (modulus.len) {
-                                        inline 128, 256, 512 => |modulus_len| {
-                                            const key = try rsa.PublicKey.fromBytes(exponent, modulus);
-                                            const sig = rsa.PSSSignature.fromBytes(modulus_len, encoded_sig);
-                                            try rsa.PSSSignature.verify(modulus_len, sig, verify_bytes, key, Hash);
-                                        },
-                                        else => {
-                                            return error.TlsBadRsaSignatureBitCount;
-                                        },
-                                    }
+                            const subject = try subject_cert.parse();
+                            if (cert_index == 0) {
+                                // Verify the host on the first certificate.
+                                switch (options.host) {
+                                    .no_verification => {},
+                                    .explicit => try subject.verifyHostName(host),
+                                }
+
+                                // Keep track of the public key for the
+                                // certificate_verify message later.
+                                try main_cert_pub_key.init(subject.pub_key_algo, subject.pubKey());
+                            } else {
+                                try prev_cert.verify(subject, now_sec);
+                            }
+
+                            switch (options.ca) {
+                                .no_verification => {
+                                    handshake_state = .trust_chain_established;
+                                    break :cert;
                                 },
-                                inline .ed25519 => |comptime_scheme| {
-                                    if (main_cert_pub_key_algo != .curveEd25519) return error.TlsBadSignatureScheme;
-                                    const Eddsa = SchemeEddsa(comptime_scheme);
-                                    if (encoded_sig.len != Eddsa.Signature.encoded_length) return error.InvalidEncoding;
-                                    const sig = Eddsa.Signature.fromBytes(encoded_sig[0..Eddsa.Signature.encoded_length].*);
-                                    if (main_cert_pub_key.len != Eddsa.PublicKey.encoded_length) return error.InvalidEncoding;
-                                    const key = try Eddsa.PublicKey.fromBytes(main_cert_pub_key[0..Eddsa.PublicKey.encoded_length].*);
-                                    try sig.verify(verify_bytes, key);
+                                .self_signed => {
+                                    try subject.verify(subject, now_sec);
+                                    handshake_state = .trust_chain_established;
+                                    break :cert;
                                 },
-                                else => {
-                                    return error.TlsBadSignatureScheme;
+                                .bundle => |ca_bundle| if (ca_bundle.verify(subject, now_sec)) |_| {
+                                    handshake_state = .trust_chain_established;
+                                    break :cert;
+                                } else |err| switch (err) {
+                                    error.CertificateIssuerNotFound => {},
+                                    else => |e| return e,
                                 },
                             }
-                        },
-                        .finished => {
-                            if (handshake_state != .finished) return error.TlsUnexpectedMessage;
-                            // This message is to trick buggy proxies into behaving correctly.
-                            const client_change_cipher_spec_msg = [_]u8{
-                                @intFromEnum(tls.ContentType.change_cipher_spec),
-                                0x03, 0x03, // legacy protocol version
-                                0x00, 0x01, // length
-                                0x01,
-                            };
-                            const app_cipher = switch (handshake_cipher) {
-                                inline else => |*p, tag| c: {
-                                    const P = @TypeOf(p.*);
+
+                            prev_cert = subject;
+                            cert_index += 1;
+                        }
+                        cert_buf_index += 1;
+                    },
+                    .server_key_exchange => {
+                        if (tls_version != .tls_1_2) return error.TlsUnexpectedMessage;
+                        if (cipher_state != .cleartext) return error.TlsUnexpectedMessage;
+                        switch (handshake_state) {
+                            .trust_chain_established => {},
+                            .certificate => return error.TlsCertificateNotVerified,
+                            else => return error.TlsUnexpectedMessage,
+                        }
+
+                        switch (handshake_cipher) {
+                            inline else => |*p| p.transcript_hash.update(wrapped_handshake),
+                        }
+                        try hsd.ensure(1 + 2 + 1);
+                        const curve_type = hsd.decode(u8);
+                        if (curve_type != 0x03) return error.TlsIllegalParameter; // named_curve
+                        const named_group = hsd.decode(tls.NamedGroup);
+                        const key_size = hsd.decode(u8);
+                        try hsd.ensure(key_size);
+                        const server_pub_key = hsd.slice(key_size);
+                        try main_cert_pub_key.verifySignature(&hsd, &.{ &client_hello_rand, &server_hello_rand, hsd.buf[0..hsd.idx] });
+                        try key_share.exchange(named_group, server_pub_key);
+                        handshake_state = .server_hello_done;
+                    },
+                    .server_hello_done => {
+                        if (tls_version != .tls_1_2) return error.TlsUnexpectedMessage;
+                        if (cipher_state != .cleartext) return error.TlsUnexpectedMessage;
+                        if (handshake_state != .server_hello_done) return error.TlsUnexpectedMessage;
+
+                        const client_key_exchange_msg = .{@intFromEnum(tls.ContentType.handshake)} ++
+                            int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
+                            array(u16, u8, .{@intFromEnum(tls.HandshakeType.client_key_exchange)} ++
+                            array(u24, u8, array(u8, u8, key_share.secp256r1_kp.public_key.toUncompressedSec1())));
+                        const client_change_cipher_spec_msg = .{@intFromEnum(tls.ContentType.change_cipher_spec)} ++
+                            int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
+                            array(u16, tls.ChangeCipherSpecType, .{.change_cipher_spec});
+                        const pre_master_secret = key_share.getSharedSecret().?;
+                        switch (handshake_cipher) {
+                            inline else => |*p| {
+                                const P = @TypeOf(p.*).A;
+                                p.transcript_hash.update(wrapped_handshake);
+                                p.transcript_hash.update(client_key_exchange_msg[tls.record_header_len..]);
+                                const master_secret = hmacExpandLabel(P.Hmac, pre_master_secret, &.{
+                                    "master secret",
+                                    &client_hello_rand,
+                                    &server_hello_rand,
+                                }, 48);
+                                if (options.ssl_key_log_file) |key_log_file| logSecrets(key_log_file, .{
+                                    .client_random = &client_hello_rand,
+                                }, .{
+                                    .CLIENT_RANDOM = &master_secret,
+                                });
+                                const key_block = hmacExpandLabel(
+                                    P.Hmac,
+                                    &master_secret,
+                                    &.{ "key expansion", &server_hello_rand, &client_hello_rand },
+                                    @sizeOf(P.Tls_1_2),
+                                );
+                                const client_verify_cleartext = .{@intFromEnum(tls.HandshakeType.finished)} ++
+                                    array(u24, u8, hmacExpandLabel(
+                                    P.Hmac,
+                                    &master_secret,
+                                    &.{ "client finished", &p.transcript_hash.peek() },
+                                    P.verify_data_length,
+                                ));
+                                p.transcript_hash.update(&client_verify_cleartext);
+                                p.version = .{ .tls_1_2 = .{
+                                    .expected_server_verify_data = hmacExpandLabel(
+                                        P.Hmac,
+                                        &master_secret,
+                                        &.{ "server finished", &p.transcript_hash.finalResult() },
+                                        P.verify_data_length,
+                                    ),
+                                    .app_cipher = std.mem.bytesToValue(P.Tls_1_2, &key_block),
+                                } };
+                                const pv = &p.version.tls_1_2;
+                                const nonce: [P.AEAD.nonce_length]u8 = if (builtin.zig_backend == .stage2_x86_64 and
+                                    P.AEAD.nonce_length > comptime std.simd.suggestVectorLength(u8) orelse 1)
+                                nonce: {
+                                    var nonce = pv.app_cipher.client_write_IV ++ pv.app_cipher.client_salt;
+                                    const operand = std.mem.readInt(u64, nonce[nonce.len - 8 ..], .big);
+                                    std.mem.writeInt(u64, nonce[nonce.len - 8 ..], operand ^ write_seq, .big);
+                                    break :nonce nonce;
+                                } else nonce: {
+                                    const V = @Vector(P.AEAD.nonce_length, u8);
+                                    const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                                    const operand: V = pad ++ @as([8]u8, @bitCast(big(write_seq)));
+                                    break :nonce @as(V, pv.app_cipher.client_write_IV ++ pv.app_cipher.client_salt) ^ operand;
+                                };
+                                var client_verify_msg = .{@intFromEnum(tls.ContentType.handshake)} ++
+                                    int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
+                                    array(u16, u8, nonce[P.fixed_iv_length..].* ++
+                                    @as([client_verify_cleartext.len + P.mac_length]u8, undefined));
+                                P.AEAD.encrypt(
+                                    client_verify_msg[client_verify_msg.len - P.mac_length -
+                                        client_verify_cleartext.len ..][0..client_verify_cleartext.len],
+                                    client_verify_msg[client_verify_msg.len - P.mac_length ..][0..P.mac_length],
+                                    &client_verify_cleartext,
+                                    std.mem.toBytes(big(write_seq)) ++ client_verify_msg[0 .. 1 + 2] ++ int(u16, client_verify_cleartext.len),
+                                    nonce,
+                                    pv.app_cipher.client_write_key,
+                                );
+                                const all_msgs = client_key_exchange_msg ++ client_change_cipher_spec_msg ++ client_verify_msg;
+                                var all_msgs_vec = [_]std.posix.iovec_const{
+                                    .{ .base = &all_msgs, .len = all_msgs.len },
+                                };
+                                try stream.writevAll(&all_msgs_vec);
+                            },
+                        }
+                        write_seq += 1;
+                        pending_cipher_state = .application;
+                        handshake_state = .finished;
+                    },
+                    .certificate_verify => {
+                        if (tls_version != .tls_1_3) return error.TlsUnexpectedMessage;
+                        if (cipher_state != .handshake) return error.TlsUnexpectedMessage;
+                        switch (handshake_state) {
+                            .trust_chain_established => {},
+                            .certificate => return error.TlsCertificateNotVerified,
+                            else => return error.TlsUnexpectedMessage,
+                        }
+                        switch (handshake_cipher) {
+                            inline else => |*p| {
+                                try main_cert_pub_key.verifySignature(&hsd, &.{
+                                    " " ** 64 ++ "TLS 1.3, server CertificateVerify\x00",
+                                    &p.transcript_hash.peek(),
+                                });
+                                p.transcript_hash.update(wrapped_handshake);
+                            },
+                        }
+                        handshake_state = .finished;
+                    },
+                    .finished => {
+                        if (cipher_state == .cleartext) return error.TlsUnexpectedMessage;
+                        if (handshake_state != .finished) return error.TlsUnexpectedMessage;
+                        // This message is to trick buggy proxies into behaving correctly.
+                        const client_change_cipher_spec_msg = .{@intFromEnum(tls.ContentType.change_cipher_spec)} ++
+                            int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
+                            array(u16, tls.ChangeCipherSpecType, .{.change_cipher_spec});
+                        const app_cipher = app_cipher: switch (handshake_cipher) {
+                            inline else => |*p, tag| switch (tls_version) {
+                                .tls_1_3 => {
+                                    const pv = &p.version.tls_1_3;
+                                    const P = @TypeOf(p.*).A;
+                                    try hsd.ensure(P.Hmac.mac_length);
                                     const finished_digest = p.transcript_hash.peek();
                                     p.transcript_hash.update(wrapped_handshake);
-                                    const expected_server_verify_data = tls.hmac(P.Hmac, &finished_digest, p.server_finished_key);
-                                    if (!mem.eql(u8, &expected_server_verify_data, handshake))
-                                        return error.TlsDecryptError;
+                                    const expected_server_verify_data = tls.hmac(P.Hmac, &finished_digest, pv.server_finished_key);
+                                    if (!std.crypto.timing_safe.eql([P.Hmac.mac_length]u8, expected_server_verify_data, hsd.array(P.Hmac.mac_length).*)) return error.TlsDecryptError;
                                     const handshake_hash = p.transcript_hash.finalResult();
-                                    const verify_data = tls.hmac(P.Hmac, &handshake_hash, p.client_finished_key);
-                                    const out_cleartext = [_]u8{
-                                        @intFromEnum(tls.HandshakeType.finished),
-                                        0, 0, verify_data.len, // length
-                                    } ++ verify_data ++ [1]u8{@intFromEnum(tls.ContentType.handshake)};
+                                    const verify_data = tls.hmac(P.Hmac, &handshake_hash, pv.client_finished_key);
+                                    const out_cleartext = .{@intFromEnum(tls.HandshakeType.finished)} ++
+                                        array(u24, u8, verify_data) ++
+                                        .{@intFromEnum(tls.ContentType.handshake)};
 
                                     const wrapped_len = out_cleartext.len + P.AEAD.tag_length;
 
-                                    var finished_msg = [_]u8{
-                                        @intFromEnum(tls.ContentType.application_data),
-                                        0x03, 0x03, // legacy protocol version
-                                        0, wrapped_len, // byte length of encrypted record
-                                    } ++ @as([wrapped_len]u8, undefined);
+                                    var finished_msg = .{@intFromEnum(tls.ContentType.application_data)} ++
+                                        int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
+                                        array(u16, u8, @as([wrapped_len]u8, undefined));
 
-                                    const ad = finished_msg[0..5];
-                                    const ciphertext = finished_msg[5..][0..out_cleartext.len];
+                                    const ad = finished_msg[0..tls.record_header_len];
+                                    const ciphertext = finished_msg[tls.record_header_len..][0..out_cleartext.len];
                                     const auth_tag = finished_msg[finished_msg.len - P.AEAD.tag_length ..];
-                                    const nonce = p.client_handshake_iv;
-                                    P.AEAD.encrypt(ciphertext, auth_tag, &out_cleartext, ad, nonce, p.client_handshake_key);
-
-                                    const both_msgs = client_change_cipher_spec_msg ++ finished_msg;
-                                    var both_msgs_vec = [_]std.posix.iovec_const{.{
-                                        .base = &both_msgs,
-                                        .len = both_msgs.len,
-                                    }};
-                                    try stream.writevAll(&both_msgs_vec);
-
-                                    const client_secret = hkdfExpandLabel(P.Hkdf, p.master_secret, "c ap traffic", &handshake_hash, P.Hash.digest_length);
-                                    const server_secret = hkdfExpandLabel(P.Hkdf, p.master_secret, "s ap traffic", &handshake_hash, P.Hash.digest_length);
-                                    break :c @unionInit(tls.ApplicationCipher, @tagName(tag), .{
+                                    const nonce = pv.client_handshake_iv;
+                                    P.AEAD.encrypt(ciphertext, auth_tag, &out_cleartext, ad, nonce, pv.client_handshake_key);
+
+                                    const all_msgs = client_change_cipher_spec_msg ++ finished_msg;
+                                    var all_msgs_vec = [_]std.posix.iovec_const{
+                                        .{ .base = &all_msgs, .len = all_msgs.len },
+                                    };
+                                    try stream.writevAll(&all_msgs_vec);
+
+                                    const client_secret = hkdfExpandLabel(P.Hkdf, pv.master_secret, "c ap traffic", &handshake_hash, P.Hash.digest_length);
+                                    const server_secret = hkdfExpandLabel(P.Hkdf, pv.master_secret, "s ap traffic", &handshake_hash, P.Hash.digest_length);
+                                    if (options.ssl_key_log_file) |key_log_file| logSecrets(key_log_file, .{
+                                        .counter = key_seq,
+                                        .client_random = &client_hello_rand,
+                                    }, .{
+                                        .SERVER_TRAFFIC_SECRET = &server_secret,
+                                        .CLIENT_TRAFFIC_SECRET = &client_secret,
+                                    });
+                                    key_seq += 1;
+                                    break :app_cipher @unionInit(tls.ApplicationCipher, @tagName(tag), .{ .tls_1_3 = .{
                                         .client_secret = client_secret,
                                         .server_secret = server_secret,
                                         .client_key = hkdfExpandLabel(P.Hkdf, client_secret, "key", "", P.AEAD.key_length),
                                         .server_key = hkdfExpandLabel(P.Hkdf, server_secret, "key", "", P.AEAD.key_length),
                                         .client_iv = hkdfExpandLabel(P.Hkdf, client_secret, "iv", "", P.AEAD.nonce_length),
                                         .server_iv = hkdfExpandLabel(P.Hkdf, server_secret, "iv", "", P.AEAD.nonce_length),
-                                    });
+                                    } });
                                 },
-                            };
-                            const leftover = d.rest();
-                            var client: Client = .{
-                                .read_seq = 0,
-                                .write_seq = 0,
-                                .partial_cleartext_idx = 0,
-                                .partial_ciphertext_idx = 0,
-                                .partial_ciphertext_end = @intCast(leftover.len),
-                                .received_close_notify = false,
-                                .application_cipher = app_cipher,
-                                .partially_read_buffer = undefined,
-                            };
-                            @memcpy(client.partially_read_buffer[0..leftover.len], leftover);
-                            return client;
-                        },
-                        else => {
-                            return error.TlsUnexpectedMessage;
-                        },
-                    }
-                    if (ctd.eof()) break;
+                                .tls_1_2 => {
+                                    const pv = &p.version.tls_1_2;
+                                    const P = @TypeOf(p.*).A;
+                                    try hsd.ensure(P.verify_data_length);
+                                    if (!std.crypto.timing_safe.eql([P.verify_data_length]u8, pv.expected_server_verify_data, hsd.array(P.verify_data_length).*)) return error.TlsDecryptError;
+                                    break :app_cipher @unionInit(tls.ApplicationCipher, @tagName(tag), .{ .tls_1_2 = pv.app_cipher });
+                                },
+                                else => unreachable,
+                            },
+                        };
+                        const leftover = d.rest();
+                        var client: Client = .{
+                            .tls_version = tls_version,
+                            .read_seq = switch (tls_version) {
+                                .tls_1_3 => 0,
+                                .tls_1_2 => read_seq,
+                                else => unreachable,
+                            },
+                            .write_seq = switch (tls_version) {
+                                .tls_1_3 => 0,
+                                .tls_1_2 => write_seq,
+                                else => unreachable,
+                            },
+                            .partial_cleartext_idx = 0,
+                            .partial_ciphertext_idx = 0,
+                            .partial_ciphertext_end = @intCast(leftover.len),
+                            .received_close_notify = false,
+                            .allow_truncation_attacks = false,
+                            .application_cipher = app_cipher,
+                            .partially_read_buffer = undefined,
+                            .ssl_key_log = if (options.ssl_key_log_file) |key_log_file| .{
+                                .client_key_seq = key_seq,
+                                .server_key_seq = key_seq,
+                                .client_random = client_hello_rand,
+                                .file = key_log_file,
+                            } else null,
+                        };
+                        @memcpy(client.partially_read_buffer[0..leftover.len], leftover);
+                        return client;
+                    },
+                    else => return error.TlsUnexpectedMessage,
                 }
+                if (ctd.eof()) break;
+                cleartext_fragment_start = ctd.idx;
             },
-            else => {
-                return error.TlsUnexpectedMessage;
-            },
+            else => return error.TlsUnexpectedMessage,
         }
+        cleartext_fragment_start = 0;
+        cleartext_fragment_end = 0;
     }
 }
 
 /// Sends TLS-encrypted data to `stream`, which must conform to `StreamInterface`.
-/// Returns the number of plaintext bytes sent, which may be fewer than `bytes.len`.
+/// Returns the number of cleartext bytes sent, which may be fewer than `bytes.len`.
 pub fn write(c: *Client, stream: anytype, bytes: []const u8) !usize {
     return writeEnd(c, stream, bytes, false);
 }
@@ -749,7 +944,7 @@ pub fn writeAllEnd(c: *Client, stream: anytype, bytes: []const u8, end: bool) !v
 }
 
 /// Sends TLS-encrypted data to `stream`, which must conform to `StreamInterface`.
-/// Returns the number of plaintext bytes sent, which may be fewer than `bytes.len`.
+/// Returns the number of cleartext bytes sent, which may be fewer than `bytes.len`.
 /// If `end` is true, then this function additionally sends a `close_notify` alert,
 /// which is necessary for the server to distinguish between a properly finished
 /// TLS session, or a truncation attack.
@@ -813,62 +1008,126 @@ fn prepareCiphertextRecord(
     var iovec_end: usize = 0;
     var bytes_i: usize = 0;
     switch (c.application_cipher) {
-        inline else => |*p| {
-            const P = @TypeOf(p.*);
-            const overhead_len = tls.record_header_len + P.AEAD.tag_length + 1;
-            const close_notify_alert_reserved = tls.close_notify_alert.len + overhead_len;
-            while (true) {
-                const encrypted_content_len: u16 = @intCast(@min(
-                    @min(bytes.len - bytes_i, tls.max_ciphertext_inner_record_len),
-                    ciphertext_buf.len -|
-                        (close_notify_alert_reserved + overhead_len + ciphertext_end),
-                ));
-                if (encrypted_content_len == 0) return .{
-                    .iovec_end = iovec_end,
-                    .ciphertext_end = ciphertext_end,
-                    .overhead_len = overhead_len,
-                };
-
-                @memcpy(cleartext_buf[0..encrypted_content_len], bytes[bytes_i..][0..encrypted_content_len]);
-                cleartext_buf[encrypted_content_len] = @intFromEnum(inner_content_type);
-                bytes_i += encrypted_content_len;
-                const ciphertext_len = encrypted_content_len + 1;
-                const cleartext = cleartext_buf[0..ciphertext_len];
-
-                const record_start = ciphertext_end;
-                const ad = ciphertext_buf[ciphertext_end..][0..5];
-                ad.* =
-                    [_]u8{@intFromEnum(tls.ContentType.application_data)} ++
-                    int2(@intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
-                    int2(ciphertext_len + P.AEAD.tag_length);
-                ciphertext_end += ad.len;
-                const ciphertext = ciphertext_buf[ciphertext_end..][0..ciphertext_len];
-                ciphertext_end += ciphertext_len;
-                const auth_tag = ciphertext_buf[ciphertext_end..][0..P.AEAD.tag_length];
-                ciphertext_end += auth_tag.len;
-                const nonce = if (builtin.zig_backend == .stage2_x86_64 and
-                    P.AEAD.nonce_length > comptime std.simd.suggestVectorLength(u8) orelse 1)
-                nonce: {
-                    var nonce = p.client_iv;
-                    const operand = std.mem.readInt(u64, nonce[nonce.len - 8 ..], .big);
-                    std.mem.writeInt(u64, nonce[nonce.len - 8 ..], operand ^ c.write_seq, .big);
-                    break :nonce nonce;
-                } else nonce: {
-                    const V = @Vector(P.AEAD.nonce_length, u8);
-                    const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
-                    const operand: V = pad ++ @as([8]u8, @bitCast(big(c.write_seq)));
-                    break :nonce @as(V, p.client_iv) ^ operand;
-                };
-                c.write_seq += 1; // TODO send key_update on overflow
-                P.AEAD.encrypt(ciphertext, auth_tag, cleartext, ad, nonce, p.client_key);
-
-                const record = ciphertext_buf[record_start..ciphertext_end];
-                iovecs[iovec_end] = .{
-                    .base = record.ptr,
-                    .len = record.len,
-                };
-                iovec_end += 1;
-            }
+        inline else => |*p| switch (c.tls_version) {
+            .tls_1_3 => {
+                const pv = &p.tls_1_3;
+                const P = @TypeOf(p.*);
+                const overhead_len = tls.record_header_len + P.AEAD.tag_length + 1;
+                const close_notify_alert_reserved = tls.close_notify_alert.len + overhead_len;
+                while (true) {
+                    const encrypted_content_len: u16 = @min(
+                        bytes.len - bytes_i,
+                        tls.max_ciphertext_inner_record_len,
+                        ciphertext_buf.len -|
+                            (close_notify_alert_reserved + overhead_len + ciphertext_end),
+                    );
+                    if (encrypted_content_len == 0) return .{
+                        .iovec_end = iovec_end,
+                        .ciphertext_end = ciphertext_end,
+                        .overhead_len = overhead_len,
+                    };
+
+                    @memcpy(cleartext_buf[0..encrypted_content_len], bytes[bytes_i..][0..encrypted_content_len]);
+                    cleartext_buf[encrypted_content_len] = @intFromEnum(inner_content_type);
+                    bytes_i += encrypted_content_len;
+                    const ciphertext_len = encrypted_content_len + 1;
+                    const cleartext = cleartext_buf[0..ciphertext_len];
+
+                    const record_start = ciphertext_end;
+                    const ad = ciphertext_buf[ciphertext_end..][0..tls.record_header_len];
+                    ad.* = .{@intFromEnum(tls.ContentType.application_data)} ++
+                        int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
+                        int(u16, ciphertext_len + P.AEAD.tag_length);
+                    ciphertext_end += ad.len;
+                    const ciphertext = ciphertext_buf[ciphertext_end..][0..ciphertext_len];
+                    ciphertext_end += ciphertext_len;
+                    const auth_tag = ciphertext_buf[ciphertext_end..][0..P.AEAD.tag_length];
+                    ciphertext_end += auth_tag.len;
+                    const nonce = if (builtin.zig_backend == .stage2_x86_64 and
+                        P.AEAD.nonce_length > comptime std.simd.suggestVectorLength(u8) orelse 1)
+                    nonce: {
+                        var nonce = pv.client_iv;
+                        const operand = std.mem.readInt(u64, nonce[nonce.len - 8 ..], .big);
+                        std.mem.writeInt(u64, nonce[nonce.len - 8 ..], operand ^ c.write_seq, .big);
+                        break :nonce nonce;
+                    } else nonce: {
+                        const V = @Vector(P.AEAD.nonce_length, u8);
+                        const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                        const operand: V = pad ++ std.mem.toBytes(big(c.write_seq));
+                        break :nonce @as(V, pv.client_iv) ^ operand;
+                    };
+                    P.AEAD.encrypt(ciphertext, auth_tag, cleartext, ad, nonce, pv.client_key);
+                    c.write_seq += 1; // TODO send key_update on overflow
+
+                    const record = ciphertext_buf[record_start..ciphertext_end];
+                    iovecs[iovec_end] = .{
+                        .base = record.ptr,
+                        .len = record.len,
+                    };
+                    iovec_end += 1;
+                }
+            },
+            .tls_1_2 => {
+                const pv = &p.tls_1_2;
+                const P = @TypeOf(p.*);
+                const overhead_len = tls.record_header_len + P.record_iv_length + P.mac_length;
+                const close_notify_alert_reserved = tls.close_notify_alert.len + overhead_len;
+                while (true) {
+                    const message_len: u16 = @min(
+                        bytes.len - bytes_i,
+                        tls.max_ciphertext_inner_record_len,
+                        ciphertext_buf.len -|
+                            (close_notify_alert_reserved + overhead_len + ciphertext_end),
+                    );
+                    if (message_len == 0) return .{
+                        .iovec_end = iovec_end,
+                        .ciphertext_end = ciphertext_end,
+                        .overhead_len = overhead_len,
+                    };
+
+                    @memcpy(cleartext_buf[0..message_len], bytes[bytes_i..][0..message_len]);
+                    bytes_i += message_len;
+                    const cleartext = cleartext_buf[0..message_len];
+
+                    const record_start = ciphertext_end;
+                    const record_header = ciphertext_buf[ciphertext_end..][0..tls.record_header_len];
+                    ciphertext_end += tls.record_header_len;
+                    record_header.* = .{@intFromEnum(inner_content_type)} ++
+                        int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++
+                        int(u16, P.record_iv_length + message_len + P.mac_length);
+                    const ad = std.mem.toBytes(big(c.write_seq)) ++ record_header[0 .. 1 + 2] ++ int(u16, message_len);
+                    const record_iv = ciphertext_buf[ciphertext_end..][0..P.record_iv_length];
+                    ciphertext_end += P.record_iv_length;
+                    const nonce: [P.AEAD.nonce_length]u8 = if (builtin.zig_backend == .stage2_x86_64 and
+                        P.AEAD.nonce_length > comptime std.simd.suggestVectorLength(u8) orelse 1)
+                    nonce: {
+                        var nonce = pv.client_write_IV ++ pv.client_salt;
+                        const operand = std.mem.readInt(u64, nonce[nonce.len - 8 ..], .big);
+                        std.mem.writeInt(u64, nonce[nonce.len - 8 ..], operand ^ c.write_seq, .big);
+                        break :nonce nonce;
+                    } else nonce: {
+                        const V = @Vector(P.AEAD.nonce_length, u8);
+                        const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                        const operand: V = pad ++ @as([8]u8, @bitCast(big(c.write_seq)));
+                        break :nonce @as(V, pv.client_write_IV ++ pv.client_salt) ^ operand;
+                    };
+                    record_iv.* = nonce[P.fixed_iv_length..].*;
+                    const ciphertext = ciphertext_buf[ciphertext_end..][0..message_len];
+                    ciphertext_end += message_len;
+                    const auth_tag = ciphertext_buf[ciphertext_end..][0..P.mac_length];
+                    ciphertext_end += P.mac_length;
+                    P.AEAD.encrypt(ciphertext, auth_tag, cleartext, ad, nonce, pv.client_write_key);
+                    c.write_seq += 1; // TODO send key_update on overflow
+
+                    const record = ciphertext_buf[record_start..ciphertext_end];
+                    iovecs[iovec_end] = .{
+                        .base = record.ptr,
+                        .len = record.len,
+                    };
+                    iovec_end += 1;
+                }
+            },
+            else => unreachable,
         },
     }
 }
@@ -990,7 +1249,7 @@ pub fn readvAdvanced(c: *Client, stream: anytype, iovecs: []const std.posix.iove
     // beginning of the buffer will be used for such purposes.
     const cleartext_buf_len = free_size - ciphertext_buf_len;
 
-    // Recoup `partially_read_buffer space`. This is necessary because it is assumed
+    // Recoup `partially_read_buffer` space. This is necessary because it is assumed
     // below that `frag0` is big enough to hold at least one record.
     limitedOverlapCopy(c.partially_read_buffer[0..c.partial_ciphertext_end], c.partial_ciphertext_idx);
     c.partial_ciphertext_end -= c.partial_ciphertext_idx;
@@ -1105,164 +1364,211 @@ pub fn readvAdvanced(c: *Client, stream: anytype, iovecs: []const std.posix.iove
             in = 0;
             continue;
         }
-        switch (ct) {
+        const cleartext, const inner_ct: tls.ContentType = cleartext: switch (c.application_cipher) {
+            inline else => |*p| switch (c.tls_version) {
+                .tls_1_3 => {
+                    const pv = &p.tls_1_3;
+                    const P = @TypeOf(p.*);
+                    const ad = frag[in - tls.record_header_len ..][0..tls.record_header_len];
+                    const ciphertext_len = record_len - P.AEAD.tag_length;
+                    const ciphertext = frag[in..][0..ciphertext_len];
+                    in += ciphertext_len;
+                    const auth_tag = frag[in..][0..P.AEAD.tag_length].*;
+                    const nonce = if (builtin.zig_backend == .stage2_x86_64 and
+                        P.AEAD.nonce_length > comptime std.simd.suggestVectorLength(u8) orelse 1)
+                    nonce: {
+                        var nonce = pv.server_iv;
+                        const operand = std.mem.readInt(u64, nonce[nonce.len - 8 ..], .big);
+                        std.mem.writeInt(u64, nonce[nonce.len - 8 ..], operand ^ c.read_seq, .big);
+                        break :nonce nonce;
+                    } else nonce: {
+                        const V = @Vector(P.AEAD.nonce_length, u8);
+                        const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                        const operand: V = pad ++ std.mem.toBytes(big(c.read_seq));
+                        break :nonce @as(V, pv.server_iv) ^ operand;
+                    };
+                    const out_buf = vp.peek();
+                    const cleartext_buf = if (ciphertext.len <= out_buf.len)
+                        out_buf
+                    else
+                        &cleartext_stack_buffer;
+                    const cleartext = cleartext_buf[0..ciphertext.len];
+                    P.AEAD.decrypt(cleartext, ciphertext, auth_tag, ad, nonce, pv.server_key) catch
+                        return error.TlsBadRecordMac;
+                    const msg = mem.trimRight(u8, cleartext, "\x00");
+                    break :cleartext .{ msg[0 .. msg.len - 1], @enumFromInt(msg[msg.len - 1]) };
+                },
+                .tls_1_2 => {
+                    const pv = &p.tls_1_2;
+                    const P = @TypeOf(p.*);
+                    const message_len: u16 = record_len - P.record_iv_length - P.mac_length;
+                    const ad = std.mem.toBytes(big(c.read_seq)) ++
+                        frag[in - tls.record_header_len ..][0 .. 1 + 2] ++
+                        std.mem.toBytes(big(message_len));
+                    const record_iv = frag[in..][0..P.record_iv_length].*;
+                    in += P.record_iv_length;
+                    const masked_read_seq = c.read_seq &
+                        comptime std.math.shl(u64, std.math.maxInt(u64), 8 * P.record_iv_length);
+                    const nonce: [P.AEAD.nonce_length]u8 = if (builtin.zig_backend == .stage2_x86_64 and
+                        P.AEAD.nonce_length > comptime std.simd.suggestVectorLength(u8) orelse 1)
+                    nonce: {
+                        var nonce = pv.server_write_IV ++ record_iv;
+                        const operand = std.mem.readInt(u64, nonce[nonce.len - 8 ..], .big);
+                        std.mem.writeInt(u64, nonce[nonce.len - 8 ..], operand ^ masked_read_seq, .big);
+                        break :nonce nonce;
+                    } else nonce: {
+                        const V = @Vector(P.AEAD.nonce_length, u8);
+                        const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                        const operand: V = pad ++ @as([8]u8, @bitCast(big(masked_read_seq)));
+                        break :nonce @as(V, pv.server_write_IV ++ record_iv) ^ operand;
+                    };
+                    const ciphertext = frag[in..][0..message_len];
+                    in += message_len;
+                    const auth_tag = frag[in..][0..P.mac_length].*;
+                    in += P.mac_length;
+                    const out_buf = vp.peek();
+                    const cleartext_buf = if (message_len <= out_buf.len)
+                        out_buf
+                    else
+                        &cleartext_stack_buffer;
+                    const cleartext = cleartext_buf[0..ciphertext.len];
+                    P.AEAD.decrypt(cleartext, ciphertext, auth_tag, ad, nonce, pv.server_write_key) catch
+                        return error.TlsBadRecordMac;
+                    break :cleartext .{ cleartext, ct };
+                },
+                else => unreachable,
+            },
+        };
+        c.read_seq = try std.math.add(u64, c.read_seq, 1);
+        switch (inner_ct) {
             .alert => {
-                if (in + 2 > frag.len) return error.TlsDecodeError;
-                const level: tls.AlertLevel = @enumFromInt(frag[in]);
-                const desc: tls.AlertDescription = @enumFromInt(frag[in + 1]);
+                if (cleartext.len != 2) return error.TlsDecodeError;
+                const level: tls.AlertLevel = @enumFromInt(cleartext[0]);
+                const desc: tls.AlertDescription = @enumFromInt(cleartext[1]);
+                if (desc == .close_notify) {
+                    c.received_close_notify = true;
+                    c.partial_ciphertext_end = c.partial_ciphertext_idx;
+                    return vp.total;
+                }
                 _ = level;
 
                 try desc.toError();
                 // TODO: handle server-side closures
                 return error.TlsUnexpectedMessage;
             },
-            .application_data => {
-                const cleartext = switch (c.application_cipher) {
-                    inline else => |*p| c: {
-                        const P = @TypeOf(p.*);
-                        const ad = frag[in - 5 ..][0..5];
-                        const ciphertext_len = record_len - P.AEAD.tag_length;
-                        const ciphertext = frag[in..][0..ciphertext_len];
-                        in += ciphertext_len;
-                        const auth_tag = frag[in..][0..P.AEAD.tag_length].*;
-                        const nonce = if (builtin.zig_backend == .stage2_x86_64 and
-                            P.AEAD.nonce_length > comptime std.simd.suggestVectorLength(u8) orelse 1)
-                        nonce: {
-                            var nonce = p.server_iv;
-                            const operand = std.mem.readInt(u64, nonce[nonce.len - 8 ..], .big);
-                            std.mem.writeInt(u64, nonce[nonce.len - 8 ..], operand ^ c.read_seq, .big);
-                            break :nonce nonce;
-                        } else nonce: {
-                            const V = @Vector(P.AEAD.nonce_length, u8);
-                            const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
-                            const operand: V = pad ++ @as([8]u8, @bitCast(big(c.read_seq)));
-                            break :nonce @as(V, p.server_iv) ^ operand;
-                        };
-                        const out_buf = vp.peek();
-                        const cleartext_buf = if (ciphertext.len <= out_buf.len)
-                            out_buf
-                        else
-                            &cleartext_stack_buffer;
-                        const cleartext = cleartext_buf[0..ciphertext.len];
-                        P.AEAD.decrypt(cleartext, ciphertext, auth_tag, ad, nonce, p.server_key) catch
-                            return error.TlsBadRecordMac;
-                        break :c mem.trimRight(u8, cleartext, "\x00");
-                    },
-                };
-
-                c.read_seq = try std.math.add(u64, c.read_seq, 1);
-
-                const inner_ct: tls.ContentType = @enumFromInt(cleartext[cleartext.len - 1]);
-                switch (inner_ct) {
-                    .alert => {
-                        const level: tls.AlertLevel = @enumFromInt(cleartext[0]);
-                        const desc: tls.AlertDescription = @enumFromInt(cleartext[1]);
-                        if (desc == .close_notify) {
-                            c.received_close_notify = true;
-                            c.partial_ciphertext_end = c.partial_ciphertext_idx;
-                            return vp.total;
-                        }
-                        _ = level;
-
-                        try desc.toError();
-                        // TODO: handle server-side closures
-                        return error.TlsUnexpectedMessage;
-                    },
-                    .handshake => {
-                        var ct_i: usize = 0;
-                        while (true) {
-                            const handshake_type: tls.HandshakeType = @enumFromInt(cleartext[ct_i]);
-                            ct_i += 1;
-                            const handshake_len = mem.readInt(u24, cleartext[ct_i..][0..3], .big);
-                            ct_i += 3;
-                            const next_handshake_i = ct_i + handshake_len;
-                            if (next_handshake_i > cleartext.len - 1)
-                                return error.TlsBadLength;
-                            const handshake = cleartext[ct_i..next_handshake_i];
-                            switch (handshake_type) {
-                                .new_session_ticket => {
-                                    // This client implementation ignores new session tickets.
+            .handshake => {
+                var ct_i: usize = 0;
+                while (true) {
+                    const handshake_type: tls.HandshakeType = @enumFromInt(cleartext[ct_i]);
+                    ct_i += 1;
+                    const handshake_len = mem.readInt(u24, cleartext[ct_i..][0..3], .big);
+                    ct_i += 3;
+                    const next_handshake_i = ct_i + handshake_len;
+                    if (next_handshake_i > cleartext.len)
+                        return error.TlsBadLength;
+                    const handshake = cleartext[ct_i..next_handshake_i];
+                    switch (handshake_type) {
+                        .new_session_ticket => {
+                            // This client implementation ignores new session tickets.
+                        },
+                        .key_update => {
+                            switch (c.application_cipher) {
+                                inline else => |*p| {
+                                    const pv = &p.tls_1_3;
+                                    const P = @TypeOf(p.*);
+                                    const server_secret = hkdfExpandLabel(P.Hkdf, pv.server_secret, "traffic upd", "", P.Hash.digest_length);
+                                    if (c.ssl_key_log) |*key_log| logSecrets(key_log.file, .{
+                                        .counter = key_log.serverCounter(),
+                                        .client_random = &key_log.client_random,
+                                    }, .{
+                                        .SERVER_TRAFFIC_SECRET = &server_secret,
+                                    });
+                                    pv.server_secret = server_secret;
+                                    pv.server_key = hkdfExpandLabel(P.Hkdf, server_secret, "key", "", P.AEAD.key_length);
+                                    pv.server_iv = hkdfExpandLabel(P.Hkdf, server_secret, "iv", "", P.AEAD.nonce_length);
                                 },
-                                .key_update => {
+                            }
+                            c.read_seq = 0;
+
+                            switch (@as(tls.KeyUpdateRequest, @enumFromInt(handshake[0]))) {
+                                .update_requested => {
                                     switch (c.application_cipher) {
                                         inline else => |*p| {
+                                            const pv = &p.tls_1_3;
                                             const P = @TypeOf(p.*);
-                                            const server_secret = hkdfExpandLabel(P.Hkdf, p.server_secret, "traffic upd", "", P.Hash.digest_length);
-                                            p.server_secret = server_secret;
-                                            p.server_key = hkdfExpandLabel(P.Hkdf, server_secret, "key", "", P.AEAD.key_length);
-                                            p.server_iv = hkdfExpandLabel(P.Hkdf, server_secret, "iv", "", P.AEAD.nonce_length);
+                                            const client_secret = hkdfExpandLabel(P.Hkdf, pv.client_secret, "traffic upd", "", P.Hash.digest_length);
+                                            if (c.ssl_key_log) |*key_log| logSecrets(key_log.file, .{
+                                                .counter = key_log.clientCounter(),
+                                                .client_random = &key_log.client_random,
+                                            }, .{
+                                                .CLIENT_TRAFFIC_SECRET = &client_secret,
+                                            });
+                                            pv.client_secret = client_secret;
+                                            pv.client_key = hkdfExpandLabel(P.Hkdf, client_secret, "key", "", P.AEAD.key_length);
+                                            pv.client_iv = hkdfExpandLabel(P.Hkdf, client_secret, "iv", "", P.AEAD.nonce_length);
                                         },
                                     }
-                                    c.read_seq = 0;
-
-                                    switch (@as(tls.KeyUpdateRequest, @enumFromInt(handshake[0]))) {
-                                        .update_requested => {
-                                            switch (c.application_cipher) {
-                                                inline else => |*p| {
-                                                    const P = @TypeOf(p.*);
-                                                    const client_secret = hkdfExpandLabel(P.Hkdf, p.client_secret, "traffic upd", "", P.Hash.digest_length);
-                                                    p.client_secret = client_secret;
-                                                    p.client_key = hkdfExpandLabel(P.Hkdf, client_secret, "key", "", P.AEAD.key_length);
-                                                    p.client_iv = hkdfExpandLabel(P.Hkdf, client_secret, "iv", "", P.AEAD.nonce_length);
-                                                },
-                                            }
-                                            c.write_seq = 0;
-                                        },
-                                        .update_not_requested => {},
-                                        _ => return error.TlsIllegalParameter,
-                                    }
-                                },
-                                else => {
-                                    return error.TlsUnexpectedMessage;
+                                    c.write_seq = 0;
                                 },
+                                .update_not_requested => {},
+                                _ => return error.TlsIllegalParameter,
                             }
-                            ct_i = next_handshake_i;
-                            if (ct_i >= cleartext.len - 1) break;
-                        }
-                    },
-                    .application_data => {
-                        // Determine whether the output buffer or a stack
-                        // buffer was used for storing the cleartext.
-                        if (cleartext.ptr == &cleartext_stack_buffer) {
-                            // Stack buffer was used, so we must copy to the output buffer.
-                            const msg = cleartext[0 .. cleartext.len - 1];
-                            if (c.partial_ciphertext_idx > c.partial_cleartext_idx) {
-                                // We have already run out of room in iovecs. Continue
-                                // appending to `partially_read_buffer`.
-                                @memcpy(
-                                    c.partially_read_buffer[c.partial_ciphertext_idx..][0..msg.len],
-                                    msg,
-                                );
-                                c.partial_ciphertext_idx = @intCast(c.partial_ciphertext_idx + msg.len);
-                            } else {
-                                const amt = vp.put(msg);
-                                if (amt < msg.len) {
-                                    const rest = msg[amt..];
-                                    c.partial_cleartext_idx = 0;
-                                    c.partial_ciphertext_idx = @intCast(rest.len);
-                                    @memcpy(c.partially_read_buffer[0..rest.len], rest);
-                                }
-                            }
-                        } else {
-                            // Output buffer was used directly which means no
-                            // memory copying needs to occur, and we can move
-                            // on to the next ciphertext record.
-                            vp.next(cleartext.len - 1);
-                        }
-                    },
-                    else => {
-                        return error.TlsUnexpectedMessage;
-                    },
+                        },
+                        else => {
+                            return error.TlsUnexpectedMessage;
+                        },
+                    }
+                    ct_i = next_handshake_i;
+                    if (ct_i >= cleartext.len) break;
                 }
             },
-            else => {
-                return error.TlsUnexpectedMessage;
+            .application_data => {
+                // Determine whether the output buffer or a stack
+                // buffer was used for storing the cleartext.
+                if (cleartext.ptr == &cleartext_stack_buffer) {
+                    // Stack buffer was used, so we must copy to the output buffer.
+                    if (c.partial_ciphertext_idx > c.partial_cleartext_idx) {
+                        // We have already run out of room in iovecs. Continue
+                        // appending to `partially_read_buffer`.
+                        @memcpy(
+                            c.partially_read_buffer[c.partial_ciphertext_idx..][0..cleartext.len],
+                            cleartext,
+                        );
+                        c.partial_ciphertext_idx = @intCast(c.partial_ciphertext_idx + cleartext.len);
+                    } else {
+                        const amt = vp.put(cleartext);
+                        if (amt < cleartext.len) {
+                            const rest = cleartext[amt..];
+                            c.partial_cleartext_idx = 0;
+                            c.partial_ciphertext_idx = @intCast(rest.len);
+                            @memcpy(c.partially_read_buffer[0..rest.len], rest);
+                        }
+                    }
+                } else {
+                    // Output buffer was used directly which means no
+                    // memory copying needs to occur, and we can move
+                    // on to the next ciphertext record.
+                    vp.next(cleartext.len);
+                }
             },
+            else => return error.TlsUnexpectedMessage,
         }
         in = end;
     }
 }
 
+fn logSecrets(key_log_file: std.fs.File, context: anytype, secrets: anytype) void {
+    const locked = if (key_log_file.lock(.exclusive)) |_| true else |_| false;
+    defer if (locked) key_log_file.unlock();
+    key_log_file.seekFromEnd(0) catch {};
+    inline for (@typeInfo(@TypeOf(secrets)).@"struct".fields) |field| key_log_file.writer().print("{s}" ++
+        (if (@hasField(@TypeOf(context), "counter")) "_{d}" else "") ++ " {} {}\n", .{field.name} ++
+        (if (@hasField(@TypeOf(context), "counter")) .{context.counter} else .{}) ++ .{
+        std.fmt.fmtSliceHexLower(context.client_random),
+        std.fmt.fmtSliceHexLower(@field(secrets, field.name)),
+    }) catch {};
+}
+
 fn finishRead(c: *Client, frag: []const u8, in: usize, out: usize) usize {
     const saved_buf = frag[in..];
     if (c.partial_ciphertext_idx > c.partial_cleartext_idx) {
@@ -1326,6 +1632,86 @@ inline fn big(x: anytype) @TypeOf(x) {
     };
 }
 
+const KeyShare = struct {
+    ml_kem768_kp: crypto.kem.ml_kem.MLKem768.KeyPair,
+    secp256r1_kp: crypto.sign.ecdsa.EcdsaP256Sha256.KeyPair,
+    secp384r1_kp: crypto.sign.ecdsa.EcdsaP384Sha384.KeyPair,
+    x25519_kp: crypto.dh.X25519.KeyPair,
+    sk_buf: [sk_max_len]u8,
+    sk_len: std.math.IntFittingRange(0, sk_max_len),
+
+    const sk_max_len = @max(
+        crypto.dh.X25519.shared_length + crypto.kem.ml_kem.MLKem768.shared_length,
+        crypto.ecc.P256.scalar.encoded_length,
+        crypto.ecc.P384.scalar.encoded_length,
+        crypto.dh.X25519.shared_length,
+    );
+
+    fn init(seed: [112]u8) error{IdentityElement}!KeyShare {
+        return .{
+            .ml_kem768_kp = try .create(null),
+            .secp256r1_kp = try .create(seed[0..32].*),
+            .secp384r1_kp = try .create(seed[32..80].*),
+            .x25519_kp = try .create(seed[80..112].*),
+            .sk_buf = undefined,
+            .sk_len = 0,
+        };
+    }
+
+    fn exchange(
+        ks: *KeyShare,
+        named_group: tls.NamedGroup,
+        server_pub_key: []const u8,
+    ) error{ TlsIllegalParameter, TlsDecryptFailure }!void {
+        switch (named_group) {
+            .x25519_ml_kem768 => {
+                const hksl = crypto.kem.ml_kem.MLKem768.ciphertext_length;
+                const xksl = hksl + crypto.dh.X25519.public_length;
+                if (server_pub_key.len != xksl) return error.TlsIllegalParameter;
+
+                const hsk = ks.ml_kem768_kp.secret_key.decaps(server_pub_key[0..hksl]) catch
+                    return error.TlsDecryptFailure;
+                const xsk = crypto.dh.X25519.scalarmult(ks.x25519_kp.secret_key, server_pub_key[hksl..xksl].*) catch
+                    return error.TlsDecryptFailure;
+                @memcpy(ks.sk_buf[0..hsk.len], &hsk);
+                @memcpy(ks.sk_buf[hsk.len..][0..xsk.len], &xsk);
+                ks.sk_len = hsk.len + xsk.len;
+            },
+            .secp256r1 => {
+                const PublicKey = crypto.sign.ecdsa.EcdsaP256Sha256.PublicKey;
+                const pk = PublicKey.fromSec1(server_pub_key) catch return error.TlsDecryptFailure;
+                const mul = pk.p.mulPublic(ks.secp256r1_kp.secret_key.bytes, .big) catch
+                    return error.TlsDecryptFailure;
+                const sk = mul.affineCoordinates().x.toBytes(.big);
+                @memcpy(ks.sk_buf[0..sk.len], &sk);
+                ks.sk_len = sk.len;
+            },
+            .secp384r1 => {
+                const PublicKey = crypto.sign.ecdsa.EcdsaP384Sha384.PublicKey;
+                const pk = PublicKey.fromSec1(server_pub_key) catch return error.TlsDecryptFailure;
+                const mul = pk.p.mulPublic(ks.secp384r1_kp.secret_key.bytes, .big) catch
+                    return error.TlsDecryptFailure;
+                const sk = mul.affineCoordinates().x.toBytes(.big);
+                @memcpy(ks.sk_buf[0..sk.len], &sk);
+                ks.sk_len = sk.len;
+            },
+            .x25519 => {
+                const ksl = crypto.dh.X25519.public_length;
+                if (server_pub_key.len != ksl) return error.TlsIllegalParameter;
+                const sk = crypto.dh.X25519.scalarmult(ks.x25519_kp.secret_key, server_pub_key[0..ksl].*) catch
+                    return error.TlsDecryptFailure;
+                @memcpy(ks.sk_buf[0..sk.len], &sk);
+                ks.sk_len = sk.len;
+            },
+            else => return error.TlsIllegalParameter,
+        }
+    }
+
+    fn getSharedSecret(ks: *const KeyShare) ?[]const u8 {
+        return if (ks.sk_len > 0) ks.sk_buf[0..ks.sk_len] else null;
+    }
+};
+
 fn SchemeEcdsa(comptime scheme: tls.SignatureScheme) type {
     return switch (scheme) {
         .ecdsa_secp256r1_sha256 => crypto.sign.ecdsa.EcdsaP256Sha256,
@@ -1334,11 +1720,20 @@ fn SchemeEcdsa(comptime scheme: tls.SignatureScheme) type {
     };
 }
 
-fn SchemeHash(comptime scheme: tls.SignatureScheme) type {
+fn SchemeRsa(comptime scheme: tls.SignatureScheme) type {
     return switch (scheme) {
-        .rsa_pss_rsae_sha256 => crypto.hash.sha2.Sha256,
-        .rsa_pss_rsae_sha384 => crypto.hash.sha2.Sha384,
-        .rsa_pss_rsae_sha512 => crypto.hash.sha2.Sha512,
+        .rsa_pkcs1_sha256,
+        .rsa_pkcs1_sha384,
+        .rsa_pkcs1_sha512,
+        .rsa_pkcs1_sha1,
+        => Certificate.rsa.PKCS1v1_5Signature,
+        .rsa_pss_rsae_sha256,
+        .rsa_pss_rsae_sha384,
+        .rsa_pss_rsae_sha512,
+        .rsa_pss_pss_sha256,
+        .rsa_pss_pss_sha384,
+        .rsa_pss_pss_sha512,
+        => Certificate.rsa.PSSSignature,
         else => @compileError("bad scheme"),
     };
 }
@@ -1350,6 +1745,146 @@ fn SchemeEddsa(comptime scheme: tls.SignatureScheme) type {
     };
 }
 
+fn SchemeHash(comptime scheme: tls.SignatureScheme) type {
+    return switch (scheme) {
+        .rsa_pkcs1_sha256,
+        .ecdsa_secp256r1_sha256,
+        .rsa_pss_rsae_sha256,
+        .rsa_pss_pss_sha256,
+        => crypto.hash.sha2.Sha256,
+        .rsa_pkcs1_sha384,
+        .ecdsa_secp384r1_sha384,
+        .rsa_pss_rsae_sha384,
+        .rsa_pss_pss_sha384,
+        => crypto.hash.sha2.Sha384,
+        .rsa_pkcs1_sha512,
+        .ecdsa_secp521r1_sha512,
+        .rsa_pss_rsae_sha512,
+        .rsa_pss_pss_sha512,
+        => crypto.hash.sha2.Sha512,
+        .rsa_pkcs1_sha1,
+        .ecdsa_sha1,
+        => crypto.hash.Sha1,
+        else => @compileError("bad scheme"),
+    };
+}
+
+const CertificatePublicKey = struct {
+    algo: Certificate.AlgorithmCategory,
+    buf: [600]u8,
+    len: u16,
+
+    fn init(
+        cert_pub_key: *CertificatePublicKey,
+        algo: Certificate.AlgorithmCategory,
+        pub_key: []const u8,
+    ) error{CertificatePublicKeyInvalid}!void {
+        if (pub_key.len > cert_pub_key.buf.len) return error.CertificatePublicKeyInvalid;
+        cert_pub_key.algo = algo;
+        @memcpy(cert_pub_key.buf[0..pub_key.len], pub_key);
+        cert_pub_key.len = @intCast(pub_key.len);
+    }
+
+    const VerifyError = error{ TlsDecodeError, TlsBadSignatureScheme, InvalidEncoding } ||
+        // ecdsa
+        crypto.errors.EncodingError ||
+        crypto.errors.NotSquareError ||
+        crypto.errors.NonCanonicalError ||
+        SchemeEcdsa(.ecdsa_secp256r1_sha256).Signature.VerifyError ||
+        SchemeEcdsa(.ecdsa_secp384r1_sha384).Signature.VerifyError ||
+        // rsa
+        error{TlsBadRsaSignatureBitCount} ||
+        Certificate.rsa.PublicKey.ParseDerError ||
+        Certificate.rsa.PublicKey.FromBytesError ||
+        Certificate.rsa.PSSSignature.VerifyError ||
+        Certificate.rsa.PKCS1v1_5Signature.VerifyError ||
+        // eddsa
+        SchemeEddsa(.ed25519).Signature.VerifyError;
+
+    fn verifySignature(
+        cert_pub_key: *const CertificatePublicKey,
+        sigd: *tls.Decoder,
+        msg: []const []const u8,
+    ) VerifyError!void {
+        const pub_key = cert_pub_key.buf[0..cert_pub_key.len];
+
+        try sigd.ensure(2 + 2);
+        const scheme = sigd.decode(tls.SignatureScheme);
+        const sig_len = sigd.decode(u16);
+        try sigd.ensure(sig_len);
+        const encoded_sig = sigd.slice(sig_len);
+
+        if (cert_pub_key.algo != @as(Certificate.AlgorithmCategory, switch (scheme) {
+            .ecdsa_secp256r1_sha256,
+            .ecdsa_secp384r1_sha384,
+            => .X9_62_id_ecPublicKey,
+            .rsa_pkcs1_sha256,
+            .rsa_pkcs1_sha384,
+            .rsa_pkcs1_sha512,
+            .rsa_pss_rsae_sha256,
+            .rsa_pss_rsae_sha384,
+            .rsa_pss_rsae_sha512,
+            .rsa_pkcs1_sha1,
+            => .rsaEncryption,
+            .rsa_pss_pss_sha256,
+            .rsa_pss_pss_sha384,
+            .rsa_pss_pss_sha512,
+            => .rsassa_pss,
+            else => return error.TlsBadSignatureScheme,
+        })) return error.TlsBadSignatureScheme;
+
+        switch (scheme) {
+            inline .ecdsa_secp256r1_sha256,
+            .ecdsa_secp384r1_sha384,
+            => |comptime_scheme| {
+                const Ecdsa = SchemeEcdsa(comptime_scheme);
+                const sig = try Ecdsa.Signature.fromDer(encoded_sig);
+                const key = try Ecdsa.PublicKey.fromSec1(pub_key);
+                var ver = try sig.verifier(key);
+                for (msg) |part| ver.update(part);
+                try ver.verify();
+            },
+            inline .rsa_pkcs1_sha256,
+            .rsa_pkcs1_sha384,
+            .rsa_pkcs1_sha512,
+            .rsa_pss_rsae_sha256,
+            .rsa_pss_rsae_sha384,
+            .rsa_pss_rsae_sha512,
+            .rsa_pss_pss_sha256,
+            .rsa_pss_pss_sha384,
+            .rsa_pss_pss_sha512,
+            .rsa_pkcs1_sha1,
+            => |comptime_scheme| {
+                const RsaSignature = SchemeRsa(comptime_scheme);
+                const Hash = SchemeHash(comptime_scheme);
+                const PublicKey = Certificate.rsa.PublicKey;
+                const components = try PublicKey.parseDer(pub_key);
+                const exponent = components.exponent;
+                const modulus = components.modulus;
+                switch (modulus.len) {
+                    inline 128, 256, 384, 512 => |modulus_len| {
+                        const key: PublicKey = try .fromBytes(exponent, modulus);
+                        const sig = RsaSignature.fromBytes(modulus_len, encoded_sig);
+                        try RsaSignature.concatVerify(modulus_len, sig, msg, key, Hash);
+                    },
+                    else => return error.TlsBadRsaSignatureBitCount,
+                }
+            },
+            inline .ed25519 => |comptime_scheme| {
+                const Eddsa = SchemeEddsa(comptime_scheme);
+                if (encoded_sig.len != Eddsa.Signature.encoded_length) return error.InvalidEncoding;
+                const sig = Eddsa.Signature.fromBytes(encoded_sig[0..Eddsa.Signature.encoded_length].*);
+                if (pub_key.len != Eddsa.PublicKey.encoded_length) return error.InvalidEncoding;
+                const key = try Eddsa.PublicKey.fromBytes(pub_key[0..Eddsa.PublicKey.encoded_length].*);
+                var ver = try sig.verifier(key);
+                for (msg) |part| ver.update(part);
+                try ver.verify();
+            },
+            else => unreachable,
+        }
+    }
+};
+
 /// Abstraction for sending multiple byte buffers to a slice of iovecs.
 const VecPut = struct {
     iovecs: []const std.posix.iovec,
@@ -1447,20 +1982,26 @@ fn limitVecs(iovecs: []std.posix.iovec, len: usize) []std.posix.iovec {
 ///       aes128-gcm:        138 MiB/s
 ///       aes256-gcm:        120 MiB/s
 const cipher_suites = if (crypto.core.aes.has_hardware_support)
-    enum_array(tls.CipherSuite, &.{
+    array(u16, tls.CipherSuite, .{
         .AEGIS_128L_SHA256,
         .AEGIS_256_SHA512,
         .AES_128_GCM_SHA256,
+        .ECDHE_RSA_WITH_AES_128_GCM_SHA256,
         .AES_256_GCM_SHA384,
+        .ECDHE_RSA_WITH_AES_256_GCM_SHA384,
         .CHACHA20_POLY1305_SHA256,
+        .ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
     })
 else
-    enum_array(tls.CipherSuite, &.{
+    array(u16, tls.CipherSuite, .{
         .CHACHA20_POLY1305_SHA256,
+        .ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
         .AEGIS_128L_SHA256,
         .AEGIS_256_SHA512,
         .AES_128_GCM_SHA256,
+        .ECDHE_RSA_WITH_AES_128_GCM_SHA256,
         .AES_256_GCM_SHA384,
+        .ECDHE_RSA_WITH_AES_256_GCM_SHA384,
     });
 
 test {
diff --git a/zig/lib/std/debug.zig b/zig/lib/std/debug.zig
index 23b005ad49..982e71bc35 100644
--- a/zig/lib/std/debug.zig
+++ b/zig/lib/std/debug.zig
@@ -656,7 +656,7 @@ pub const StackIterator = struct {
         // The implementation of DWARF unwinding on aarch64-macos is not complete. However, Apple mandates that
         // the frame pointer register is always used, so on this platform we can safely use the FP-based unwinder.
         if (builtin.target.isDarwin() and native_arch == .aarch64)
-            return init(first_address, context.mcontext.ss.fp);
+            return init(first_address, @truncate(context.mcontext.ss.fp));
 
         if (SelfInfo.supports_unwinding) {
             var iterator = init(first_address, null);
@@ -1335,7 +1335,11 @@ fn dumpSegfaultInfoPosix(sig: i32, code: i32, addr: usize, ctx_ptr: ?*anyopaque)
         .x86,
         .x86_64,
         .arm,
+        .armeb,
+        .thumb,
+        .thumbeb,
         .aarch64,
+        .aarch64_be,
         => {
             const ctx: *posix.ucontext_t = @ptrCast(@alignCast(ctx_ptr));
             dumpStackTraceFromBase(ctx);
@@ -1344,7 +1348,7 @@ fn dumpSegfaultInfoPosix(sig: i32, code: i32, addr: usize, ctx_ptr: ?*anyopaque)
     }
 }
 
-fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) callconv(windows.WINAPI) c_long {
+fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) callconv(.winapi) c_long {
     switch (info.ExceptionRecord.ExceptionCode) {
         windows.EXCEPTION_DATATYPE_MISALIGNMENT => handleSegfaultWindowsExtra(info, 0, "Unaligned Memory Access"),
         windows.EXCEPTION_ACCESS_VIOLATION => handleSegfaultWindowsExtra(info, 1, null),
diff --git a/zig/lib/std/debug/Dwarf/abi.zig b/zig/lib/std/debug/Dwarf/abi.zig
index b2c4cb9536..e0a2a4858b 100644
--- a/zig/lib/std/debug/Dwarf/abi.zig
+++ b/zig/lib/std/debug/Dwarf/abi.zig
@@ -35,8 +35,8 @@ pub fn ipRegNum(arch: Arch) ?u8 {
     return switch (arch) {
         .x86 => 8,
         .x86_64 => 16,
-        .arm => 15,
-        .aarch64 => 32,
+        .arm, .armeb, .thumb, .thumbeb => 15,
+        .aarch64, .aarch64_be => 32,
         else => null,
     };
 }
@@ -47,8 +47,8 @@ pub fn fpRegNum(arch: Arch, reg_context: RegisterContext) u8 {
         // (only in .eh_frame), and that is now the convention for MachO
         .x86 => if (reg_context.eh_frame and reg_context.is_macho) 4 else 5,
         .x86_64 => 6,
-        .arm => 11,
-        .aarch64 => 29,
+        .arm, .armeb, .thumb, .thumbeb => 11,
+        .aarch64, .aarch64_be => 29,
         else => unreachable,
     };
 }
@@ -57,8 +57,8 @@ pub fn spRegNum(arch: Arch, reg_context: RegisterContext) u8 {
     return switch (arch) {
         .x86 => if (reg_context.eh_frame and reg_context.is_macho) 5 else 4,
         .x86_64 => 7,
-        .arm => 13,
-        .aarch64 => 31,
+        .arm, .armeb, .thumb, .thumbeb => 13,
+        .aarch64, .aarch64_be => 31,
         else => unreachable,
     };
 }
@@ -131,7 +131,7 @@ pub fn regBytes(
                 16 => mem.asBytes(&thread_context_ptr.Rip),
                 else => error.InvalidRegister,
             },
-            .aarch64 => switch (reg_number) {
+            .aarch64, .aarch64_be => switch (reg_number) {
                 0...30 => mem.asBytes(&thread_context_ptr.DUMMYUNIONNAME.X[reg_number]),
                 31 => mem.asBytes(&thread_context_ptr.Sp),
                 32 => mem.asBytes(&thread_context_ptr.Pc),
@@ -269,7 +269,7 @@ pub fn regBytes(
             },
             else => error.UnimplementedOs,
         },
-        .arm => switch (builtin.os.tag) {
+        .arm, .armeb, .thumb, .thumbeb => switch (builtin.os.tag) {
             .linux => switch (reg_number) {
                 0 => mem.asBytes(&ucontext_ptr.mcontext.arm_r0),
                 1 => mem.asBytes(&ucontext_ptr.mcontext.arm_r1),
@@ -292,8 +292,8 @@ pub fn regBytes(
             },
             else => error.UnimplementedOs,
         },
-        .aarch64 => switch (builtin.os.tag) {
-            .macos, .ios => switch (reg_number) {
+        .aarch64, .aarch64_be => switch (builtin.os.tag) {
+            .macos, .ios, .watchos => switch (reg_number) {
                 0...28 => mem.asBytes(&ucontext_ptr.mcontext.ss.regs[reg_number]),
                 29 => mem.asBytes(&ucontext_ptr.mcontext.ss.fp),
                 30 => mem.asBytes(&ucontext_ptr.mcontext.ss.lr),
diff --git a/zig/lib/std/debug/SelfInfo.zig b/zig/lib/std/debug/SelfInfo.zig
index 5e9afc8cfd..544cf0ac6f 100644
--- a/zig/lib/std/debug/SelfInfo.zig
+++ b/zig/lib/std/debug/SelfInfo.zig
@@ -184,10 +184,12 @@ fn lookupModuleDyld(self: *SelfInfo, address: usize) !*Module {
                     }
 
                     for (cmd.getSections()) |sect| {
+                        const sect_addr: usize = @intCast(sect.addr);
+                        const sect_size: usize = @intCast(sect.size);
                         if (mem.eql(u8, "__unwind_info", sect.sectName())) {
-                            unwind_info = @as([*]const u8, @ptrFromInt(sect.addr + vmaddr_slide))[0..sect.size];
+                            unwind_info = @as([*]const u8, @ptrFromInt(sect_addr + vmaddr_slide))[0..sect_size];
                         } else if (mem.eql(u8, "__eh_frame", sect.sectName())) {
-                            eh_frame = @as([*]const u8, @ptrFromInt(sect.addr + vmaddr_slide))[0..sect.size];
+                            eh_frame = @as([*]const u8, @ptrFromInt(sect_addr + vmaddr_slide))[0..sect_size];
                         }
                     }
 
@@ -590,7 +592,7 @@ pub const Module = switch (native_os) {
                 const section_bytes = try Dwarf.chopSlice(mapped_mem, sect.offset, sect.size);
                 sections[section_index.?] = .{
                     .data = section_bytes,
-                    .virtual_address = sect.addr,
+                    .virtual_address = @intCast(sect.addr),
                     .owned = false,
                 };
             }
@@ -1417,7 +1419,7 @@ pub fn unwindFrameMachO(
                 return unwindFrameMachODwarf(context, ma, eh_frame orelse return error.MissingEhFrame, @intCast(encoding.value.x86_64.dwarf));
             },
         },
-        .aarch64 => switch (encoding.mode.arm64) {
+        .aarch64, .aarch64_be => switch (encoding.mode.arm64) {
             .OLD => return error.UnimplementedUnwindEncoding,
             .FRAMELESS => blk: {
                 const sp = (try regValueNative(context.thread_context, spRegNum(reg_context), reg_context)).*;
@@ -1533,7 +1535,7 @@ pub const UnwindContext = struct {
 /// Some platforms use pointer authentication - the upper bits of instruction pointers contain a signature.
 /// This function clears these signature bits to make the pointer usable.
 pub inline fn stripInstructionPtrAuthCode(ptr: usize) usize {
-    if (native_arch == .aarch64) {
+    if (native_arch.isAARCH64()) {
         // `hint 0x07` maps to `xpaclri` (or `nop` if the hardware doesn't support it)
         // The save / restore is because `xpaclri` operates on x30 (LR)
         return asm (
@@ -1785,11 +1787,11 @@ pub fn supportsUnwinding(target: std.Target) bool {
             .linux, .netbsd, .freebsd, .openbsd, .macos, .ios, .solaris, .illumos => true,
             else => false,
         },
-        .arm => switch (target.os.tag) {
+        .arm, .armeb, .thumb, .thumbeb => switch (target.os.tag) {
             .linux => true,
             else => false,
         },
-        .aarch64 => switch (target.os.tag) {
+        .aarch64, .aarch64_be => switch (target.os.tag) {
             .linux, .netbsd, .freebsd, .macos, .ios => true,
             else => false,
         },
@@ -2192,7 +2194,7 @@ pub const VirtualMachine = struct {
 /// the .undefined rule by default, but allows ABI authors to override that.
 fn getRegDefaultValue(reg_number: u8, context: *UnwindContext, out: []u8) !void {
     switch (builtin.cpu.arch) {
-        .aarch64 => {
+        .aarch64, .aarch64_be => {
             // Callee-saved registers are initialized as if they had the .same_value rule
             if (reg_number >= 19 and reg_number <= 28) {
                 const src = try regBytes(context.thread_context, reg_number, context.reg_context);
diff --git a/zig/lib/std/dynamic_library.zig b/zig/lib/std/dynamic_library.zig
index 7fd231aba7..8f07db68da 100644
--- a/zig/lib/std/dynamic_library.zig
+++ b/zig/lib/std/dynamic_library.zig
@@ -141,7 +141,7 @@ pub const ElfDynLib = struct {
     strings: [*:0]u8,
     syms: [*]elf.Sym,
     hashtab: [*]posix.Elf_Symndx,
-    versym: ?[*]u16,
+    versym: ?[*]elf.Versym,
     verdef: ?*elf.Verdef,
     memory: []align(mem.page_size) u8,
 
@@ -319,7 +319,7 @@ pub const ElfDynLib = struct {
         var maybe_strings: ?[*:0]u8 = null;
         var maybe_syms: ?[*]elf.Sym = null;
         var maybe_hashtab: ?[*]posix.Elf_Symndx = null;
-        var maybe_versym: ?[*]u16 = null;
+        var maybe_versym: ?[*]elf.Versym = null;
         var maybe_verdef: ?*elf.Verdef = null;
 
         {
@@ -327,11 +327,11 @@ pub const ElfDynLib = struct {
             while (dynv[i] != 0) : (i += 2) {
                 const p = base + dynv[i + 1];
                 switch (dynv[i]) {
-                    elf.DT_STRTAB => maybe_strings = @as([*:0]u8, @ptrFromInt(p)),
-                    elf.DT_SYMTAB => maybe_syms = @as([*]elf.Sym, @ptrFromInt(p)),
-                    elf.DT_HASH => maybe_hashtab = @as([*]posix.Elf_Symndx, @ptrFromInt(p)),
-                    elf.DT_VERSYM => maybe_versym = @as([*]u16, @ptrFromInt(p)),
-                    elf.DT_VERDEF => maybe_verdef = @as(*elf.Verdef, @ptrFromInt(p)),
+                    elf.DT_STRTAB => maybe_strings = @ptrFromInt(p),
+                    elf.DT_SYMTAB => maybe_syms = @ptrFromInt(p),
+                    elf.DT_HASH => maybe_hashtab = @ptrFromInt(p),
+                    elf.DT_VERSYM => maybe_versym = @ptrFromInt(p),
+                    elf.DT_VERDEF => maybe_verdef = @ptrFromInt(p),
                     else => {},
                 }
             }
@@ -399,18 +399,16 @@ pub const ElfDynLib = struct {
     }
 };
 
-fn checkver(def_arg: *elf.Verdef, vsym_arg: i32, vername: []const u8, strings: [*:0]u8) bool {
+fn checkver(def_arg: *elf.Verdef, vsym_arg: elf.Versym, vername: []const u8, strings: [*:0]u8) bool {
     var def = def_arg;
-    const vsym = @as(u32, @bitCast(vsym_arg)) & 0x7fff;
+    const vsym_index = vsym_arg.VERSION;
     while (true) {
-        if (0 == (def.vd_flags & elf.VER_FLG_BASE) and (def.vd_ndx & 0x7fff) == vsym)
-            break;
-        if (def.vd_next == 0)
-            return false;
-        def = @as(*elf.Verdef, @ptrFromInt(@intFromPtr(def) + def.vd_next));
+        if (0 == (def.flags & elf.VER_FLG_BASE) and @intFromEnum(def.ndx) == vsym_index) break;
+        if (def.next == 0) return false;
+        def = @ptrFromInt(@intFromPtr(def) + def.next);
     }
-    const aux = @as(*elf.Verdaux, @ptrFromInt(@intFromPtr(def) + def.vd_aux));
-    return mem.eql(u8, vername, mem.sliceTo(strings + aux.vda_name, 0));
+    const aux: *elf.Verdaux = @ptrFromInt(@intFromPtr(def) + def.aux);
+    return mem.eql(u8, vername, mem.sliceTo(strings + aux.name, 0));
 }
 
 test "ElfDynLib" {
diff --git a/zig/lib/std/elf.zig b/zig/lib/std/elf.zig
index 792694dffb..f61114b53d 100644
--- a/zig/lib/std/elf.zig
+++ b/zig/lib/std/elf.zig
@@ -258,17 +258,26 @@ pub const DF_1_SINGLETON = 0x02000000;
 pub const DF_1_STUB = 0x04000000;
 pub const DF_1_PIE = 0x08000000;
 
-pub const VERSYM_HIDDEN = 0x8000;
-pub const VERSYM_VERSION = 0x7fff;
-
-/// Symbol is local
-pub const VER_NDX_LOCAL = 0;
-/// Symbol is global
-pub const VER_NDX_GLOBAL = 1;
-/// Beginning of reserved entries
-pub const VER_NDX_LORESERVE = 0xff00;
-/// Symbol is to be eliminated
-pub const VER_NDX_ELIMINATE = 0xff01;
+pub const Versym = packed struct(u16) {
+    VERSION: u15,
+    HIDDEN: bool,
+
+    pub const LOCAL: Versym = @bitCast(@intFromEnum(VER_NDX.LOCAL));
+    pub const GLOBAL: Versym = @bitCast(@intFromEnum(VER_NDX.GLOBAL));
+};
+
+pub const VER_NDX = enum(u16) {
+    /// Symbol is local
+    LOCAL = 0,
+    /// Symbol is global
+    GLOBAL = 1,
+    /// Beginning of reserved entries
+    LORESERVE = 0xff00,
+    /// Symbol is to be eliminated
+    ELIMINATE = 0xff01,
+    UNSPECIFIED = 0xffff,
+    _,
+};
 
 /// Version definition of the file itself
 pub const VER_FLG_BASE = 1;
@@ -698,12 +707,9 @@ pub const EI_PAD = 9;
 
 pub const EI_NIDENT = 16;
 
-pub const Elf32_Half = u16;
-pub const Elf64_Half = u16;
-pub const Elf32_Word = u32;
-pub const Elf32_Sword = i32;
-pub const Elf64_Word = u32;
-pub const Elf64_Sword = i32;
+pub const Half = u16;
+pub const Word = u32;
+pub const Sword = i32;
 pub const Elf32_Xword = u64;
 pub const Elf32_Sxword = i64;
 pub const Elf64_Xword = u64;
@@ -714,53 +720,51 @@ pub const Elf32_Off = u32;
 pub const Elf64_Off = u64;
 pub const Elf32_Section = u16;
 pub const Elf64_Section = u16;
-pub const Elf32_Versym = Elf32_Half;
-pub const Elf64_Versym = Elf64_Half;
 pub const Elf32_Ehdr = extern struct {
     e_ident: [EI_NIDENT]u8,
     e_type: ET,
     e_machine: EM,
-    e_version: Elf32_Word,
+    e_version: Word,
     e_entry: Elf32_Addr,
     e_phoff: Elf32_Off,
     e_shoff: Elf32_Off,
-    e_flags: Elf32_Word,
-    e_ehsize: Elf32_Half,
-    e_phentsize: Elf32_Half,
-    e_phnum: Elf32_Half,
-    e_shentsize: Elf32_Half,
-    e_shnum: Elf32_Half,
-    e_shstrndx: Elf32_Half,
+    e_flags: Word,
+    e_ehsize: Half,
+    e_phentsize: Half,
+    e_phnum: Half,
+    e_shentsize: Half,
+    e_shnum: Half,
+    e_shstrndx: Half,
 };
 pub const Elf64_Ehdr = extern struct {
     e_ident: [EI_NIDENT]u8,
     e_type: ET,
     e_machine: EM,
-    e_version: Elf64_Word,
+    e_version: Word,
     e_entry: Elf64_Addr,
     e_phoff: Elf64_Off,
     e_shoff: Elf64_Off,
-    e_flags: Elf64_Word,
-    e_ehsize: Elf64_Half,
-    e_phentsize: Elf64_Half,
-    e_phnum: Elf64_Half,
-    e_shentsize: Elf64_Half,
-    e_shnum: Elf64_Half,
-    e_shstrndx: Elf64_Half,
+    e_flags: Word,
+    e_ehsize: Half,
+    e_phentsize: Half,
+    e_phnum: Half,
+    e_shentsize: Half,
+    e_shnum: Half,
+    e_shstrndx: Half,
 };
 pub const Elf32_Phdr = extern struct {
-    p_type: Elf32_Word,
+    p_type: Word,
     p_offset: Elf32_Off,
     p_vaddr: Elf32_Addr,
     p_paddr: Elf32_Addr,
-    p_filesz: Elf32_Word,
-    p_memsz: Elf32_Word,
-    p_flags: Elf32_Word,
-    p_align: Elf32_Word,
+    p_filesz: Word,
+    p_memsz: Word,
+    p_flags: Word,
+    p_align: Word,
 };
 pub const Elf64_Phdr = extern struct {
-    p_type: Elf64_Word,
-    p_flags: Elf64_Word,
+    p_type: Word,
+    p_flags: Word,
     p_offset: Elf64_Off,
     p_vaddr: Elf64_Addr,
     p_paddr: Elf64_Addr,
@@ -769,44 +773,44 @@ pub const Elf64_Phdr = extern struct {
     p_align: Elf64_Xword,
 };
 pub const Elf32_Shdr = extern struct {
-    sh_name: Elf32_Word,
-    sh_type: Elf32_Word,
-    sh_flags: Elf32_Word,
+    sh_name: Word,
+    sh_type: Word,
+    sh_flags: Word,
     sh_addr: Elf32_Addr,
     sh_offset: Elf32_Off,
-    sh_size: Elf32_Word,
-    sh_link: Elf32_Word,
-    sh_info: Elf32_Word,
-    sh_addralign: Elf32_Word,
-    sh_entsize: Elf32_Word,
+    sh_size: Word,
+    sh_link: Word,
+    sh_info: Word,
+    sh_addralign: Word,
+    sh_entsize: Word,
 };
 pub const Elf64_Shdr = extern struct {
-    sh_name: Elf64_Word,
-    sh_type: Elf64_Word,
+    sh_name: Word,
+    sh_type: Word,
     sh_flags: Elf64_Xword,
     sh_addr: Elf64_Addr,
     sh_offset: Elf64_Off,
     sh_size: Elf64_Xword,
-    sh_link: Elf64_Word,
-    sh_info: Elf64_Word,
+    sh_link: Word,
+    sh_info: Word,
     sh_addralign: Elf64_Xword,
     sh_entsize: Elf64_Xword,
 };
 pub const Elf32_Chdr = extern struct {
     ch_type: COMPRESS,
-    ch_size: Elf32_Word,
-    ch_addralign: Elf32_Word,
+    ch_size: Word,
+    ch_addralign: Word,
 };
 pub const Elf64_Chdr = extern struct {
     ch_type: COMPRESS,
-    ch_reserved: Elf64_Word = 0,
+    ch_reserved: Word = 0,
     ch_size: Elf64_Xword,
     ch_addralign: Elf64_Xword,
 };
 pub const Elf32_Sym = extern struct {
-    st_name: Elf32_Word,
+    st_name: Word,
     st_value: Elf32_Addr,
-    st_size: Elf32_Word,
+    st_size: Word,
     st_info: u8,
     st_other: u8,
     st_shndx: Elf32_Section,
@@ -819,7 +823,7 @@ pub const Elf32_Sym = extern struct {
     }
 };
 pub const Elf64_Sym = extern struct {
-    st_name: Elf64_Word,
+    st_name: Word,
     st_info: u8,
     st_other: u8,
     st_shndx: Elf64_Section,
@@ -834,16 +838,16 @@ pub const Elf64_Sym = extern struct {
     }
 };
 pub const Elf32_Syminfo = extern struct {
-    si_boundto: Elf32_Half,
-    si_flags: Elf32_Half,
+    si_boundto: Half,
+    si_flags: Half,
 };
 pub const Elf64_Syminfo = extern struct {
-    si_boundto: Elf64_Half,
-    si_flags: Elf64_Half,
+    si_boundto: Half,
+    si_flags: Half,
 };
 pub const Elf32_Rel = extern struct {
     r_offset: Elf32_Addr,
-    r_info: Elf32_Word,
+    r_info: Word,
 
     pub inline fn r_sym(self: @This()) u24 {
         return @truncate(self.r_info >> 8);
@@ -865,8 +869,8 @@ pub const Elf64_Rel = extern struct {
 };
 pub const Elf32_Rela = extern struct {
     r_offset: Elf32_Addr,
-    r_info: Elf32_Word,
-    r_addend: Elf32_Sword,
+    r_info: Word,
+    r_addend: Sword,
 
     pub inline fn r_sym(self: @This()) u24 {
         return @truncate(self.r_info >> 8);
@@ -887,69 +891,49 @@ pub const Elf64_Rela = extern struct {
         return @truncate(self.r_info);
     }
 };
-pub const Elf32_Relr = Elf32_Word;
+pub const Elf32_Relr = Word;
 pub const Elf64_Relr = Elf64_Xword;
 pub const Elf32_Dyn = extern struct {
-    d_tag: Elf32_Sword,
+    d_tag: Sword,
     d_val: Elf32_Addr,
 };
 pub const Elf64_Dyn = extern struct {
     d_tag: Elf64_Sxword,
     d_val: Elf64_Addr,
 };
-pub const Elf32_Verdef = extern struct {
-    vd_version: Elf32_Half,
-    vd_flags: Elf32_Half,
-    vd_ndx: Elf32_Half,
-    vd_cnt: Elf32_Half,
-    vd_hash: Elf32_Word,
-    vd_aux: Elf32_Word,
-    vd_next: Elf32_Word,
-};
-pub const Elf64_Verdef = extern struct {
-    vd_version: Elf64_Half,
-    vd_flags: Elf64_Half,
-    vd_ndx: Elf64_Half,
-    vd_cnt: Elf64_Half,
-    vd_hash: Elf64_Word,
-    vd_aux: Elf64_Word,
-    vd_next: Elf64_Word,
+pub const Verdef = extern struct {
+    version: Half,
+    flags: Half,
+    ndx: VER_NDX,
+    cnt: Half,
+    hash: Word,
+    aux: Word,
+    next: Word,
 };
-pub const Elf32_Verdaux = extern struct {
-    vda_name: Elf32_Word,
-    vda_next: Elf32_Word,
-};
-pub const Elf64_Verdaux = extern struct {
-    vda_name: Elf64_Word,
-    vda_next: Elf64_Word,
+pub const Verdaux = extern struct {
+    name: Word,
+    next: Word,
 };
 pub const Elf32_Verneed = extern struct {
-    vn_version: Elf32_Half,
-    vn_cnt: Elf32_Half,
-    vn_file: Elf32_Word,
-    vn_aux: Elf32_Word,
-    vn_next: Elf32_Word,
+    vn_version: Half,
+    vn_cnt: Half,
+    vn_file: Word,
+    vn_aux: Word,
+    vn_next: Word,
 };
 pub const Elf64_Verneed = extern struct {
-    vn_version: Elf64_Half,
-    vn_cnt: Elf64_Half,
-    vn_file: Elf64_Word,
-    vn_aux: Elf64_Word,
-    vn_next: Elf64_Word,
-};
-pub const Elf32_Vernaux = extern struct {
-    vna_hash: Elf32_Word,
-    vna_flags: Elf32_Half,
-    vna_other: Elf32_Half,
-    vna_name: Elf32_Word,
-    vna_next: Elf32_Word,
+    vn_version: Half,
+    vn_cnt: Half,
+    vn_file: Word,
+    vn_aux: Word,
+    vn_next: Word,
 };
-pub const Elf64_Vernaux = extern struct {
-    vna_hash: Elf64_Word,
-    vna_flags: Elf64_Half,
-    vna_other: Elf64_Half,
-    vna_name: Elf64_Word,
-    vna_next: Elf64_Word,
+pub const Vernaux = extern struct {
+    hash: Word,
+    flags: Half,
+    other: Half,
+    name: Word,
+    next: Word,
 };
 pub const Elf32_auxv_t = extern struct {
     a_type: u32,
@@ -964,81 +948,81 @@ pub const Elf64_auxv_t = extern struct {
     },
 };
 pub const Elf32_Nhdr = extern struct {
-    n_namesz: Elf32_Word,
-    n_descsz: Elf32_Word,
-    n_type: Elf32_Word,
+    n_namesz: Word,
+    n_descsz: Word,
+    n_type: Word,
 };
 pub const Elf64_Nhdr = extern struct {
-    n_namesz: Elf64_Word,
-    n_descsz: Elf64_Word,
-    n_type: Elf64_Word,
+    n_namesz: Word,
+    n_descsz: Word,
+    n_type: Word,
 };
 pub const Elf32_Move = extern struct {
     m_value: Elf32_Xword,
-    m_info: Elf32_Word,
-    m_poffset: Elf32_Word,
-    m_repeat: Elf32_Half,
-    m_stride: Elf32_Half,
+    m_info: Word,
+    m_poffset: Word,
+    m_repeat: Half,
+    m_stride: Half,
 };
 pub const Elf64_Move = extern struct {
     m_value: Elf64_Xword,
     m_info: Elf64_Xword,
     m_poffset: Elf64_Xword,
-    m_repeat: Elf64_Half,
-    m_stride: Elf64_Half,
+    m_repeat: Half,
+    m_stride: Half,
 };
 pub const Elf32_gptab = extern union {
     gt_header: extern struct {
-        gt_current_g_value: Elf32_Word,
-        gt_unused: Elf32_Word,
+        gt_current_g_value: Word,
+        gt_unused: Word,
     },
     gt_entry: extern struct {
-        gt_g_value: Elf32_Word,
-        gt_bytes: Elf32_Word,
+        gt_g_value: Word,
+        gt_bytes: Word,
     },
 };
 pub const Elf32_RegInfo = extern struct {
-    ri_gprmask: Elf32_Word,
-    ri_cprmask: [4]Elf32_Word,
-    ri_gp_value: Elf32_Sword,
+    ri_gprmask: Word,
+    ri_cprmask: [4]Word,
+    ri_gp_value: Sword,
 };
 pub const Elf_Options = extern struct {
     kind: u8,
     size: u8,
     section: Elf32_Section,
-    info: Elf32_Word,
+    info: Word,
 };
 pub const Elf_Options_Hw = extern struct {
-    hwp_flags1: Elf32_Word,
-    hwp_flags2: Elf32_Word,
+    hwp_flags1: Word,
+    hwp_flags2: Word,
 };
 pub const Elf32_Lib = extern struct {
-    l_name: Elf32_Word,
-    l_time_stamp: Elf32_Word,
-    l_checksum: Elf32_Word,
-    l_version: Elf32_Word,
-    l_flags: Elf32_Word,
+    l_name: Word,
+    l_time_stamp: Word,
+    l_checksum: Word,
+    l_version: Word,
+    l_flags: Word,
 };
 pub const Elf64_Lib = extern struct {
-    l_name: Elf64_Word,
-    l_time_stamp: Elf64_Word,
-    l_checksum: Elf64_Word,
-    l_version: Elf64_Word,
-    l_flags: Elf64_Word,
+    l_name: Word,
+    l_time_stamp: Word,
+    l_checksum: Word,
+    l_version: Word,
+    l_flags: Word,
 };
 pub const Elf32_Conflict = Elf32_Addr;
 pub const Elf_MIPS_ABIFlags_v0 = extern struct {
-    version: Elf32_Half,
+    version: Half,
     isa_level: u8,
     isa_rev: u8,
     gpr_size: u8,
     cpr1_size: u8,
     cpr2_size: u8,
     fp_abi: u8,
-    isa_ext: Elf32_Word,
-    ases: Elf32_Word,
-    flags1: Elf32_Word,
-    flags2: Elf32_Word,
+    isa_ext: Word,
+    ases: Word,
+    flags1: Word,
+    flags2: Word,
 };
 
 comptime {
@@ -1102,22 +1086,11 @@ pub const Sym = switch (@sizeOf(usize)) {
     8 => Elf64_Sym,
     else => @compileError("expected pointer size of 32 or 64"),
 };
-pub const Verdef = switch (@sizeOf(usize)) {
-    4 => Elf32_Verdef,
-    8 => Elf64_Verdef,
-    else => @compileError("expected pointer size of 32 or 64"),
-};
-pub const Verdaux = switch (@sizeOf(usize)) {
-    4 => Elf32_Verdaux,
-    8 => Elf64_Verdaux,
-    else => @compileError("expected pointer size of 32 or 64"),
-};
 pub const Addr = switch (@sizeOf(usize)) {
     4 => Elf32_Addr,
     8 => Elf64_Addr,
     else => @compileError("expected pointer size of 32 or 64"),
 };
-pub const Half = u16;
 
 pub const OSABI = enum(u8) {
     /// UNIX System V ABI
diff --git a/zig/lib/std/fmt.zig b/zig/lib/std/fmt.zig
index 123122fd56..8deef118c0 100644
--- a/zig/lib/std/fmt.zig
+++ b/zig/lib/std/fmt.zig
@@ -386,7 +386,7 @@ pub const Parser = struct {
         const original_i = self.iter.i;
         defer self.iter.i = original_i;
 
-        var i = 0;
+        var i: usize = 0;
         var code_point: ?u21 = null;
         while (i <= n) : (i += 1) {
             code_point = self.iter.nextCodepoint();
diff --git a/zig/lib/std/fs.zig b/zig/lib/std/fs.zig
index bac4c42ff8..99936e9abd 100644
--- a/zig/lib/std/fs.zig
+++ b/zig/lib/std/fs.zig
@@ -160,7 +160,7 @@ pub fn makeDirAbsoluteZ(absolute_path_z: [*:0]const u8) !void {
 /// Same as `makeDirAbsolute` except the parameter is a null-terminated WTF-16 LE-encoded string.
 pub fn makeDirAbsoluteW(absolute_path_w: [*:0]const u16) !void {
     assert(path.isAbsoluteWindowsW(absolute_path_w));
-    return posix.mkdirW(absolute_path_w, Dir.default_mode);
+    return posix.mkdirW(mem.span(absolute_path_w), Dir.default_mode);
 }
 
 /// Same as `Dir.deleteDir` except the path is absolute.
@@ -181,7 +181,7 @@ pub fn deleteDirAbsoluteZ(dir_path: [*:0]const u8) !void {
 /// Same as `deleteDirAbsolute` except the path parameter is WTF-16 and target OS is assumed Windows.
 pub fn deleteDirAbsoluteW(dir_path: [*:0]const u16) !void {
     assert(path.isAbsoluteWindowsW(dir_path));
-    return posix.rmdirW(dir_path);
+    return posix.rmdirW(mem.span(dir_path));
 }
 
 /// Same as `Dir.rename` except the paths are absolute.
@@ -221,7 +221,7 @@ pub fn renameZ(old_dir: Dir, old_sub_path_z: [*:0]const u8, new_dir: Dir, new_su
 /// Same as `rename` except the parameters are WTF16LE, NT prefixed.
 /// This function is Windows-only.
 pub fn renameW(old_dir: Dir, old_sub_path_w: []const u16, new_dir: Dir, new_sub_path_w: []const u16) !void {
-    return posix.renameatW(old_dir.fd, old_sub_path_w, new_dir.fd, new_sub_path_w);
+    return posix.renameatW(old_dir.fd, old_sub_path_w, new_dir.fd, new_sub_path_w, windows.TRUE);
 }
 
 /// Returns a handle to the current working directory. It is not opened with iteration capability.
@@ -338,7 +338,7 @@ pub fn createFileAbsoluteZ(absolute_path_c: [*:0]const u8, flags: File.CreateFla
 /// Same as `createFileAbsolute` but the path parameter is WTF-16 encoded.
 pub fn createFileAbsoluteW(absolute_path_w: [*:0]const u16, flags: File.CreateFlags) File.OpenError!File {
     assert(path.isAbsoluteWindowsW(absolute_path_w));
-    return cwd().createFileW(absolute_path_w, flags);
+    return cwd().createFileW(mem.span(absolute_path_w), flags);
 }
 
 /// Delete a file name and possibly the file it refers to, based on an absolute path.
@@ -362,7 +362,7 @@ pub fn deleteFileAbsoluteZ(absolute_path_c: [*:0]const u8) Dir.DeleteFileError!v
 /// Same as `deleteFileAbsolute` except the parameter is WTF-16 encoded.
 pub fn deleteFileAbsoluteW(absolute_path_w: [*:0]const u16) Dir.DeleteFileError!void {
     assert(path.isAbsoluteWindowsW(absolute_path_w));
-    return cwd().deleteFileW(absolute_path_w);
+    return cwd().deleteFileW(mem.span(absolute_path_w));
 }
 
 /// Removes a symlink, file, or directory.
@@ -400,7 +400,7 @@ pub fn readLinkAbsolute(pathname: []const u8, buffer: *[max_path_bytes]u8) ![]u8
 /// encoded.
 pub fn readlinkAbsoluteW(pathname_w: [*:0]const u16, buffer: *[max_path_bytes]u8) ![]u8 {
     assert(path.isAbsoluteWindowsW(pathname_w));
-    return posix.readlinkW(pathname_w, buffer);
+    return posix.readlinkW(mem.span(pathname_w), buffer);
 }
 
 /// Same as `readLink`, except the path parameter is null-terminated.
@@ -437,13 +437,13 @@ pub fn symLinkAbsolute(
 /// like to create a symbolic link to a directory, specify this with `SymLinkFlags{ .is_directory = true }`.
 /// See also `symLinkAbsolute`, `symLinkAbsoluteZ`.
 pub fn symLinkAbsoluteW(
-    target_path_w: []const u16,
-    sym_link_path_w: []const u16,
+    target_path_w: [*:0]const u16,
+    sym_link_path_w: [*:0]const u16,
     flags: Dir.SymLinkFlags,
 ) !void {
-    assert(path.isAbsoluteWindowsWTF16(target_path_w));
-    assert(path.isAbsoluteWindowsWTF16(sym_link_path_w));
-    return windows.CreateSymbolicLink(null, sym_link_path_w, target_path_w, flags.is_directory);
+    assert(path.isAbsoluteWindowsW(target_path_w));
+    assert(path.isAbsoluteWindowsW(sym_link_path_w));
+    return windows.CreateSymbolicLink(null, mem.span(sym_link_path_w), mem.span(target_path_w), flags.is_directory);
 }
 
 /// Same as `symLinkAbsolute` except the parameters are null-terminated pointers.
diff --git a/zig/lib/std/fs/Dir.zig b/zig/lib/std/fs/Dir.zig
index d504ecb0c4..fab9679838 100644
--- a/zig/lib/std/fs/Dir.zig
+++ b/zig/lib/std/fs/Dir.zig
@@ -1134,7 +1134,7 @@ pub fn makeDirZ(self: Dir, sub_path: [*:0]const u8) MakeError!void {
 /// To create multiple directories to make an entire path, see `makePath`.
 /// To operate on only absolute paths, see `makeDirAbsoluteW`.
 pub fn makeDirW(self: Dir, sub_path: [*:0]const u16) MakeError!void {
-    try posix.mkdiratW(self.fd, sub_path, default_mode);
+    try posix.mkdiratW(self.fd, mem.span(sub_path), default_mode);
 }
 
 /// Calls makeDir iteratively to make an entire path
@@ -1763,7 +1763,7 @@ pub fn renameZ(self: Dir, old_sub_path_z: [*:0]const u8, new_sub_path_z: [*:0]co
 /// Same as `rename` except the parameters are WTF16LE, NT prefixed.
 /// This function is Windows-only.
 pub fn renameW(self: Dir, old_sub_path_w: []const u16, new_sub_path_w: []const u16) RenameError!void {
-    return posix.renameatW(self.fd, old_sub_path_w, self.fd, new_sub_path_w);
+    return posix.renameatW(self.fd, old_sub_path_w, self.fd, new_sub_path_w, windows.TRUE);
 }
 
 /// Use with `Dir.symLink`, `Dir.atomicSymLink`, and `symLinkAbsolute` to
diff --git a/zig/lib/std/fs/File.zig b/zig/lib/std/fs/File.zig
index 36e7999bf7..68dc6360a8 100644
--- a/zig/lib/std/fs/File.zig
+++ b/zig/lib/std/fs/File.zig
@@ -1072,7 +1072,7 @@ pub fn metadata(self: File) MetadataError!Metadata {
                     &stx,
                 );
 
-                switch (posix.errno(rc)) {
+                switch (linux.E.init(rc)) {
                     .SUCCESS => {},
                     .ACCES => unreachable,
                     .BADF => unreachable,
diff --git a/zig/lib/std/gpu.zig b/zig/lib/std/gpu.zig
index f3b37eff94..3f33ffee0e 100644
--- a/zig/lib/std/gpu.zig
+++ b/zig/lib/std/gpu.zig
@@ -47,6 +47,17 @@ pub fn vertexIndex(comptime ptr: *addrspace(.input) u32) void {
     );
 }
 
+/// Will make `ptr` contain the index of the instance that is
+/// being processed by the current vertex shader invocation.
+/// `ptr` must be a reference to variable or struct field.
+pub fn instanceIndex(comptime ptr: *addrspace(.input) u32) void {
+    asm volatile (
+        \\OpDecorate %ptr BuiltIn InstanceIndex
+        :
+        : [ptr] "" (ptr),
+    );
+}
+
 /// Output fragment depth from a `Fragment` entrypoint
 /// `ptr` must be a reference to variable or struct field.
 pub fn fragmentCoord(comptime ptr: *addrspace(.input) @Vector(4, f32)) void {
diff --git a/zig/lib/std/heap/WasmPageAllocator.zig b/zig/lib/std/heap/WasmPageAllocator.zig
index 7cb85561d8..ca625e43ed 100644
--- a/zig/lib/std/heap/WasmPageAllocator.zig
+++ b/zig/lib/std/heap/WasmPageAllocator.zig
@@ -28,8 +28,6 @@ const PageStatus = enum(u1) {
 const FreeBlock = struct {
     data: []u128,
 
-    const Io = std.packed_int_array.PackedIntIo(u1, .little);
-
     fn totalPages(self: FreeBlock) usize {
         return self.data.len * 128;
     }
@@ -39,15 +37,15 @@ const FreeBlock = struct {
     }
 
     fn getBit(self: FreeBlock, idx: usize) PageStatus {
-        const bit_offset = 0;
-        return @as(PageStatus, @enumFromInt(Io.get(mem.sliceAsBytes(self.data), idx, bit_offset)));
+        const bit = mem.readPackedInt(u1, mem.sliceAsBytes(self.data), idx, .little);
+        return @as(PageStatus, @enumFromInt(bit));
     }
 
     fn setBits(self: FreeBlock, start_idx: usize, len: usize, val: PageStatus) void {
-        const bit_offset = 0;
         var i: usize = 0;
+        const bytes = mem.sliceAsBytes(self.data);
         while (i < len) : (i += 1) {
-            Io.set(mem.sliceAsBytes(self.data), start_idx + i, bit_offset, @intFromEnum(val));
+            mem.writePackedInt(u1, bytes, start_idx + i, @intFromEnum(val), .little);
         }
     }
 
diff --git a/zig/lib/std/http/Client.zig b/zig/lib/std/http/Client.zig
index 6e95995ee0..9dcf7b5693 100644
--- a/zig/lib/std/http/Client.zig
+++ b/zig/lib/std/http/Client.zig
@@ -388,6 +388,7 @@ pub const Connection = struct {
 
             // try to cleanly close the TLS connection, for any server that cares.
             _ = conn.tls_client.writeEnd(conn.stream, "", true) catch {};
+            if (conn.tls_client.ssl_key_log) |key_log| key_log.file.close();
             allocator.destroy(conn.tls_client);
         }
 
@@ -566,7 +567,7 @@ pub const Response = struct {
             .reason = undefined,
             .version = undefined,
             .keep_alive = false,
-            .parser = proto.HeadersParser.init(&header_buffer),
+            .parser = .init(&header_buffer),
         };
 
         @memcpy(header_buffer[0..response_bytes.len], response_bytes);
@@ -610,7 +611,7 @@ pub const Response = struct {
     }
 
     pub fn iterateHeaders(r: Response) http.HeaderIterator {
-        return http.HeaderIterator.init(r.parser.get());
+        return .init(r.parser.get());
     }
 
     test iterateHeaders {
@@ -628,7 +629,7 @@ pub const Response = struct {
             .reason = undefined,
             .version = undefined,
             .keep_alive = false,
-            .parser = proto.HeadersParser.init(&header_buffer),
+            .parser = .init(&header_buffer),
         };
 
         @memcpy(header_buffer[0..response_bytes.len], response_bytes);
@@ -771,7 +772,7 @@ pub const Request = struct {
         req.client.connection_pool.release(req.client.allocator, req.connection.?);
         req.connection = null;
 
-        var server_header = std.heap.FixedBufferAllocator.init(req.response.parser.header_bytes_buffer);
+        var server_header: std.heap.FixedBufferAllocator = .init(req.response.parser.header_bytes_buffer);
         defer req.response.parser.header_bytes_buffer = server_header.buffer[server_header.end_index..];
         const protocol, const valid_uri = try validateUri(uri, server_header.allocator());
 
@@ -1354,7 +1355,27 @@ pub fn connectTcp(client: *Client, host: []const u8, port: u16, protocol: Connec
         conn.data.tls_client = try client.allocator.create(std.crypto.tls.Client);
         errdefer client.allocator.destroy(conn.data.tls_client);
 
-        conn.data.tls_client.* = std.crypto.tls.Client.init(stream, client.ca_bundle, host) catch return error.TlsInitializationFailed;
+        const ssl_key_log_file: ?std.fs.File = if (std.options.http_enable_ssl_key_log_file) ssl_key_log_file: {
+            const ssl_key_log_path = std.process.getEnvVarOwned(client.allocator, "SSLKEYLOGFILE") catch |err| switch (err) {
+                error.EnvironmentVariableNotFound, error.InvalidWtf8 => break :ssl_key_log_file null,
+                error.OutOfMemory => return error.OutOfMemory,
+            };
+            defer client.allocator.free(ssl_key_log_path);
+            break :ssl_key_log_file std.fs.cwd().createFile(ssl_key_log_path, .{
+                .truncate = false,
+                .mode = switch (builtin.os.tag) {
+                    .windows, .wasi => 0,
+                    else => 0o600,
+                },
+            }) catch null;
+        } else null;
+        errdefer if (ssl_key_log_file) |key_log_file| key_log_file.close();
+
+        conn.data.tls_client.* = std.crypto.tls.Client.init(stream, .{
+            .host = .{ .explicit = host },
+            .ca = .{ .bundle = client.ca_bundle },
+            .ssl_key_log_file = ssl_key_log_file,
+        }) catch return error.TlsInitializationFailed;
         // This is appropriate for HTTPS because the HTTP headers contain
         // the content length which is used to detect truncation attacks.
         conn.data.tls_client.allow_truncation_attacks = true;
@@ -1620,7 +1641,7 @@ pub fn open(
         }
     }
 
-    var server_header = std.heap.FixedBufferAllocator.init(options.server_header_buffer);
+    var server_header: std.heap.FixedBufferAllocator = .init(options.server_header_buffer);
     const protocol, const valid_uri = try validateUri(uri, server_header.allocator());
 
     if (protocol == .tls and @atomicLoad(bool, &client.next_https_rescan_certs, .acquire)) {
@@ -1654,7 +1675,7 @@ pub fn open(
             .status = undefined,
             .reason = undefined,
             .keep_alive = undefined,
-            .parser = proto.HeadersParser.init(server_header.buffer[server_header.end_index..]),
+            .parser = .init(server_header.buffer[server_header.end_index..]),
         },
         .headers = options.headers,
         .extra_headers = options.extra_headers,
diff --git a/zig/lib/std/http/protocol.zig b/zig/lib/std/http/protocol.zig
index 78511f435d..c56d3a24a1 100644
--- a/zig/lib/std/http/protocol.zig
+++ b/zig/lib/std/http/protocol.zig
@@ -172,7 +172,13 @@ pub const HeadersParser = struct {
                     const data_avail = r.next_chunk_length;
 
                     if (skip) {
-                        try conn.fill();
+                        conn.fill() catch |err| switch (err) {
+                            error.EndOfStream => {
+                                r.done = true;
+                                return 0;
+                            },
+                            else => |e| return e,
+                        };
 
                         const nread = @min(conn.peek().len, data_avail);
                         conn.drop(@intCast(nread));
@@ -196,7 +202,13 @@ pub const HeadersParser = struct {
                     }
                 },
                 .chunk_data_suffix, .chunk_data_suffix_r, .chunk_head_size, .chunk_head_ext, .chunk_head_r => {
-                    try conn.fill();
+                    conn.fill() catch |err| switch (err) {
+                        error.EndOfStream => {
+                            r.done = true;
+                            return 0;
+                        },
+                        else => |e| return e,
+                    };
 
                     const i = r.findChunkedLen(conn.peek());
                     conn.drop(@intCast(i));
@@ -226,7 +238,13 @@ pub const HeadersParser = struct {
                     const out_avail = buffer.len - out_index;
 
                     if (skip) {
-                        try conn.fill();
+                        conn.fill() catch |err| switch (err) {
+                            error.EndOfStream => {
+                                r.done = true;
+                                return 0;
+                            },
+                            else => |e| return e,
+                        };
 
                         const nread = @min(conn.peek().len, data_avail);
                         conn.drop(@intCast(nread));
diff --git a/zig/lib/std/io/bit_reader.zig b/zig/lib/std/io/bit_reader.zig
index 6f37ae5d87..7823e47d43 100644
--- a/zig/lib/std/io/bit_reader.zig
+++ b/zig/lib/std/io/bit_reader.zig
@@ -1,176 +1,179 @@
 const std = @import("../std.zig");
-const io = std.io;
-const assert = std.debug.assert;
-const testing = std.testing;
-const meta = std.meta;
-const math = std.math;
-
-/// Creates a stream which allows for reading bit fields from another stream
-pub fn BitReader(comptime endian: std.builtin.Endian, comptime ReaderType: type) type {
+
+//General note on endianess:
+//Big endian is packed starting in the most significant part of the byte and subsequent
+// bytes contain less significant bits. Thus we always take bits from the high
+// end and place them below existing bits in our output.
+//Little endian is packed starting in the least significant part of the byte and
+// subsequent bytes contain more significant bits. Thus we always take bits from
+// the low end and place them above existing bits in our output.
+//Regardless of endianess, within any given byte the bits are always in most
+// to least significant order.
+//Also regardless of endianess, the buffer always aligns bits to the low end
+// of the byte.
+
+/// Creates a bit reader which allows for reading bits from an underlying standard reader
+pub fn BitReader(comptime endian: std.builtin.Endian, comptime Reader: type) type {
     return struct {
-        forward_reader: ReaderType,
-        bit_buffer: u7,
-        bit_count: u3,
-
-        pub const Error = ReaderType.Error;
-        pub const Reader = io.Reader(*Self, Error, read);
-
-        const Self = @This();
-        const u8_bit_count = @bitSizeOf(u8);
-        const u7_bit_count = @bitSizeOf(u7);
-        const u4_bit_count = @bitSizeOf(u4);
-
-        pub fn init(forward_reader: ReaderType) Self {
-            return Self{
-                .forward_reader = forward_reader,
-                .bit_buffer = 0,
-                .bit_count = 0,
+        reader: Reader,
+        bits: u8 = 0,
+        count: u4 = 0,
+
+        const low_bit_mask = [9]u8{
+            0b00000000,
+            0b00000001,
+            0b00000011,
+            0b00000111,
+            0b00001111,
+            0b00011111,
+            0b00111111,
+            0b01111111,
+            0b11111111,
+        };
+
+        fn Bits(comptime T: type) type {
+            return struct {
+                T,
+                u16,
+            };
+        }
+
+        fn initBits(comptime T: type, out: anytype, num: u16) Bits(T) {
+            const UT = std.meta.Int(.unsigned, @bitSizeOf(T));
+            return .{
+                @bitCast(@as(UT, @intCast(out))),
+                num,
             };
         }
 
-        /// Reads `bits` bits from the stream and returns a specified unsigned int type
+        /// Reads `bits` bits from the reader and returns a specified type
         ///  containing them in the least significant end, returning an error if the
         ///  specified number of bits could not be read.
-        pub fn readBitsNoEof(self: *Self, comptime U: type, bits: usize) !U {
-            var n: usize = undefined;
-            const result = try self.readBits(U, bits, &n);
-            if (n < bits) return error.EndOfStream;
-            return result;
+        pub fn readBitsNoEof(self: *@This(), comptime T: type, num: u16) !T {
+            const b, const c = try self.readBitsTuple(T, num);
+            if (c < num) return error.EndOfStream;
+            return b;
         }
 
-        /// Reads `bits` bits from the stream and returns a specified unsigned int type
+        /// Reads `bits` bits from the reader and returns a specified type
         ///  containing them in the least significant end. The number of bits successfully
         ///  read is placed in `out_bits`, as reaching the end of the stream is not an error.
-        pub fn readBits(self: *Self, comptime U: type, bits: usize, out_bits: *usize) Error!U {
-            //by extending the buffer to a minimum of u8 we can cover a number of edge cases
-            // related to shifting and casting.
-            const u_bit_count = @bitSizeOf(U);
-            const buf_bit_count = bc: {
-                assert(u_bit_count >= bits);
-                break :bc if (u_bit_count <= u8_bit_count) u8_bit_count else u_bit_count;
-            };
-            const Buf = std.meta.Int(.unsigned, buf_bit_count);
-            const BufShift = math.Log2Int(Buf);
+        pub fn readBits(self: *@This(), comptime T: type, num: u16, out_bits: *u16) !T {
+            const b, const c = try self.readBitsTuple(T, num);
+            out_bits.* = c;
+            return b;
+        }
 
-            out_bits.* = @as(usize, 0);
-            if (U == u0 or bits == 0) return 0;
-            var out_buffer = @as(Buf, 0);
+        /// Reads `bits` bits from the reader and returns a tuple of the specified type
+        ///  containing them in the least significant end, and the number of bits successfully
+        ///  read. Reaching the end of the stream is not an error.
+        pub fn readBitsTuple(self: *@This(), comptime T: type, num: u16) !Bits(T) {
+            const UT = std.meta.Int(.unsigned, @bitSizeOf(T));
+            const U = if (@bitSizeOf(T) < 8) u8 else UT; //it is a pain to work with <u8
 
-            if (self.bit_count > 0) {
-                const n = if (self.bit_count >= bits) @as(u3, @intCast(bits)) else self.bit_count;
-                const shift = u7_bit_count - n;
-                switch (endian) {
-                    .big => {
-                        out_buffer = @as(Buf, self.bit_buffer >> shift);
-                        if (n >= u7_bit_count)
-                            self.bit_buffer = 0
-                        else
-                            self.bit_buffer <<= n;
-                    },
-                    .little => {
-                        const value = (self.bit_buffer << shift) >> shift;
-                        out_buffer = @as(Buf, value);
-                        if (n >= u7_bit_count)
-                            self.bit_buffer = 0
-                        else
-                            self.bit_buffer >>= n;
-                    },
-                }
-                self.bit_count -= n;
-                out_bits.* = n;
-            }
-            //at this point we know bit_buffer is empty
+            //dump any bits in our buffer first
+            if (num <= self.count) return initBits(T, self.removeBits(@intCast(num)), num);
 
-            //copy bytes until we have enough bits, then leave the rest in bit_buffer
-            while (out_bits.* < bits) {
-                const n = bits - out_bits.*;
-                const next_byte = self.forward_reader.readByte() catch |err| switch (err) {
-                    error.EndOfStream => return @as(U, @intCast(out_buffer)),
+            var out_count: u16 = self.count;
+            var out: U = self.removeBits(self.count);
+
+            //grab all the full bytes we need and put their
+            //bits where they belong
+            const full_bytes_left = (num - out_count) / 8;
+
+            for (0..full_bytes_left) |_| {
+                const byte = self.reader.readByte() catch |err| switch (err) {
+                    error.EndOfStream => return initBits(T, out, out_count),
                     else => |e| return e,
                 };
 
                 switch (endian) {
                     .big => {
-                        if (n >= u8_bit_count) {
-                            out_buffer <<= @as(u3, @intCast(u8_bit_count - 1));
-                            out_buffer <<= 1;
-                            out_buffer |= @as(Buf, next_byte);
-                            out_bits.* += u8_bit_count;
-                            continue;
-                        }
-
-                        const shift = @as(u3, @intCast(u8_bit_count - n));
-                        out_buffer <<= @as(BufShift, @intCast(n));
-                        out_buffer |= @as(Buf, next_byte >> shift);
-                        out_bits.* += n;
-                        self.bit_buffer = @as(u7, @truncate(next_byte << @as(u3, @intCast(n - 1))));
-                        self.bit_count = shift;
+                        if (U == u8) out = 0 else out <<= 8; //shifting u8 by 8 is illegal in Zig
+                        out |= byte;
                     },
                     .little => {
-                        if (n >= u8_bit_count) {
-                            out_buffer |= @as(Buf, next_byte) << @as(BufShift, @intCast(out_bits.*));
-                            out_bits.* += u8_bit_count;
-                            continue;
-                        }
-
-                        const shift = @as(u3, @intCast(u8_bit_count - n));
-                        const value = (next_byte << shift) >> shift;
-                        out_buffer |= @as(Buf, value) << @as(BufShift, @intCast(out_bits.*));
-                        out_bits.* += n;
-                        self.bit_buffer = @as(u7, @truncate(next_byte >> @as(u3, @intCast(n))));
-                        self.bit_count = shift;
+                        const pos = @as(U, byte) << @intCast(out_count);
+                        out |= pos;
                     },
                 }
+                out_count += 8;
             }
 
-            return @as(U, @intCast(out_buffer));
-        }
+            const bits_left = num - out_count;
+            const keep = 8 - bits_left;
+
+            if (bits_left == 0) return initBits(T, out, out_count);
 
-        pub fn alignToByte(self: *Self) void {
-            self.bit_buffer = 0;
-            self.bit_count = 0;
+            const final_byte = self.reader.readByte() catch |err| switch (err) {
+                error.EndOfStream => return initBits(T, out, out_count),
+                else => |e| return e,
+            };
+
+            switch (endian) {
+                .big => {
+                    out <<= @intCast(bits_left);
+                    out |= final_byte >> @intCast(keep);
+                    self.bits = final_byte & low_bit_mask[keep];
+                },
+                .little => {
+                    const pos = @as(U, final_byte & low_bit_mask[bits_left]) << @intCast(out_count);
+                    out |= pos;
+                    self.bits = final_byte >> @intCast(bits_left);
+                },
+            }
+
+            self.count = @intCast(keep);
+            return initBits(T, out, num);
         }
 
-        pub fn read(self: *Self, buffer: []u8) Error!usize {
-            var out_bits: usize = undefined;
-            var out_bits_total = @as(usize, 0);
-            //@NOTE: I'm not sure this is a good idea, maybe alignToByte should be forced
-            if (self.bit_count > 0) {
-                for (buffer) |*b| {
-                    b.* = try self.readBits(u8, u8_bit_count, &out_bits);
-                    out_bits_total += out_bits;
-                }
-                const incomplete_byte = @intFromBool(out_bits_total % u8_bit_count > 0);
-                return (out_bits_total / u8_bit_count) + incomplete_byte;
+        //convenience function for removing bits from
+        //the appropriate part of the buffer based on
+        //endianess.
+        fn removeBits(self: *@This(), num: u4) u8 {
+            if (num == 8) {
+                self.count = 0;
+                return self.bits;
+            }
+
+            const keep = self.count - num;
+            const bits = switch (endian) {
+                .big => self.bits >> @intCast(keep),
+                .little => self.bits & low_bit_mask[num],
+            };
+            switch (endian) {
+                .big => self.bits &= low_bit_mask[keep],
+                .little => self.bits >>= @intCast(num),
             }
 
-            return self.forward_reader.read(buffer);
+            self.count = keep;
+            return bits;
         }
 
-        pub fn reader(self: *Self) Reader {
-            return .{ .context = self };
+        pub fn alignToByte(self: *@This()) void {
+            self.bits = 0;
+            self.count = 0;
         }
     };
 }
 
-pub fn bitReader(
-    comptime endian: std.builtin.Endian,
-    underlying_stream: anytype,
-) BitReader(endian, @TypeOf(underlying_stream)) {
-    return BitReader(endian, @TypeOf(underlying_stream)).init(underlying_stream);
+pub fn bitReader(comptime endian: std.builtin.Endian, reader: anytype) BitReader(endian, @TypeOf(reader)) {
+    return .{ .reader = reader };
 }
 
+///////////////////////////////
+
 test "api coverage" {
     const mem_be = [_]u8{ 0b11001101, 0b00001011 };
     const mem_le = [_]u8{ 0b00011101, 0b10010101 };
 
-    var mem_in_be = io.fixedBufferStream(&mem_be);
+    var mem_in_be = std.io.fixedBufferStream(&mem_be);
     var bit_stream_be = bitReader(.big, mem_in_be.reader());
 
-    var out_bits: usize = undefined;
+    var out_bits: u16 = undefined;
 
-    const expect = testing.expect;
-    const expectError = testing.expectError;
+    const expect = std.testing.expect;
+    const expectError = std.testing.expectError;
 
     try expect(1 == try bit_stream_be.readBits(u2, 1, &out_bits));
     try expect(out_bits == 1);
@@ -186,12 +189,12 @@ test "api coverage" {
     try expect(out_bits == 1);
 
     mem_in_be.pos = 0;
-    bit_stream_be.bit_count = 0;
+    bit_stream_be.count = 0;
     try expect(0b110011010000101 == try bit_stream_be.readBits(u15, 15, &out_bits));
     try expect(out_bits == 15);
 
     mem_in_be.pos = 0;
-    bit_stream_be.bit_count = 0;
+    bit_stream_be.count = 0;
     try expect(0b1100110100001011 == try bit_stream_be.readBits(u16, 16, &out_bits));
     try expect(out_bits == 16);
 
@@ -201,7 +204,7 @@ test "api coverage" {
     try expect(out_bits == 0);
     try expectError(error.EndOfStream, bit_stream_be.readBitsNoEof(u1, 1));
 
-    var mem_in_le = io.fixedBufferStream(&mem_le);
+    var mem_in_le = std.io.fixedBufferStream(&mem_le);
     var bit_stream_le = bitReader(.little, mem_in_le.reader());
 
     try expect(1 == try bit_stream_le.readBits(u2, 1, &out_bits));
@@ -218,12 +221,12 @@ test "api coverage" {
     try expect(out_bits == 1);
 
     mem_in_le.pos = 0;
-    bit_stream_le.bit_count = 0;
+    bit_stream_le.count = 0;
     try expect(0b001010100011101 == try bit_stream_le.readBits(u15, 15, &out_bits));
     try expect(out_bits == 15);
 
     mem_in_le.pos = 0;
-    bit_stream_le.bit_count = 0;
+    bit_stream_le.count = 0;
     try expect(0b1001010100011101 == try bit_stream_le.readBits(u16, 16, &out_bits));
     try expect(out_bits == 16);
 
diff --git a/zig/lib/std/io/bit_writer.zig b/zig/lib/std/io/bit_writer.zig
index b5db45898b..eef0ece81b 100644
--- a/zig/lib/std/io/bit_writer.zig
+++ b/zig/lib/std/io/bit_writer.zig
@@ -1,153 +1,138 @@
 const std = @import("../std.zig");
-const io = std.io;
-const testing = std.testing;
-const assert = std.debug.assert;
-const math = std.math;
 
-/// Creates a stream which allows for writing bit fields to another stream
-pub fn BitWriter(comptime endian: std.builtin.Endian, comptime WriterType: type) type {
+//General note on endianess:
+//Big endian is packed starting in the most significant part of the byte and subsequent
+// bytes contain less significant bits. Thus we write out bits from the high end
+// of our input first.
+//Little endian is packed starting in the least significant part of the byte and
+// subsequent bytes contain more significant bits. Thus we write out bits from
+// the low end of our input first.
+//Regardless of endianess, within any given byte the bits are always in most
+// to least significant order.
+//Also regardless of endianess, the buffer always aligns bits to the low end
+// of the byte.
+
+/// Creates a bit writer which allows for writing bits to an underlying standard writer
+pub fn BitWriter(comptime endian: std.builtin.Endian, comptime Writer: type) type {
     return struct {
-        forward_writer: WriterType,
-        bit_buffer: u8,
-        bit_count: u4,
-
-        pub const Error = WriterType.Error;
-        pub const Writer = io.Writer(*Self, Error, write);
-
-        const Self = @This();
-        const u8_bit_count = @bitSizeOf(u8);
-        const u4_bit_count = @bitSizeOf(u4);
-
-        pub fn init(forward_writer: WriterType) Self {
-            return Self{
-                .forward_writer = forward_writer,
-                .bit_buffer = 0,
-                .bit_count = 0,
-            };
-        }
-
-        /// Write the specified number of bits to the stream from the least significant bits of
-        ///  the specified unsigned int value. Bits will only be written to the stream when there
+        writer: Writer,
+        bits: u8 = 0,
+        count: u4 = 0,
+
+        const low_bit_mask = [9]u8{
+            0b00000000,
+            0b00000001,
+            0b00000011,
+            0b00000111,
+            0b00001111,
+            0b00011111,
+            0b00111111,
+            0b01111111,
+            0b11111111,
+        };
+
+        /// Write the specified number of bits to the writer from the least significant bits of
+        ///  the specified value. Bits will only be written to the writer when there
         ///  are enough to fill a byte.
-        pub fn writeBits(self: *Self, value: anytype, bits: usize) Error!void {
-            if (bits == 0) return;
-
-            const U = @TypeOf(value);
-            comptime assert(@typeInfo(U).int.signedness == .unsigned);
-
-            //by extending the buffer to a minimum of u8 we can cover a number of edge cases
-            // related to shifting and casting.
-            const u_bit_count = @bitSizeOf(U);
-            const buf_bit_count = bc: {
-                assert(u_bit_count >= bits);
-                break :bc if (u_bit_count <= u8_bit_count) u8_bit_count else u_bit_count;
-            };
-            const Buf = std.meta.Int(.unsigned, buf_bit_count);
-            const BufShift = math.Log2Int(Buf);
-
-            const buf_value = @as(Buf, @intCast(value));
-
-            const high_byte_shift = @as(BufShift, @intCast(buf_bit_count - u8_bit_count));
-            var in_buffer = switch (endian) {
-                .big => buf_value << @as(BufShift, @intCast(buf_bit_count - bits)),
-                .little => buf_value,
-            };
-            var in_bits = bits;
-
-            if (self.bit_count > 0) {
-                const bits_remaining = u8_bit_count - self.bit_count;
-                const n = @as(u3, @intCast(if (bits_remaining > bits) bits else bits_remaining));
+        pub fn writeBits(self: *@This(), value: anytype, num: u16) !void {
+            const T = @TypeOf(value);
+            const UT = std.meta.Int(.unsigned, @bitSizeOf(T));
+            const U = if (@bitSizeOf(T) < 8) u8 else UT; //<u8 is a pain to work with
+
+            var in: U = @as(UT, @bitCast(value));
+            var in_count: u16 = num;
+
+            if (self.count > 0) {
+                //if we can't fill the buffer, add what we have
+                const bits_free = 8 - self.count;
+                if (num < bits_free) {
+                    self.addBits(@truncate(in), @intCast(num));
+                    return;
+                }
+
+                //finish filling the buffer and flush it
+                if (num == bits_free) {
+                    self.addBits(@truncate(in), @intCast(num));
+                    return self.flushBits();
+                }
+
                 switch (endian) {
                     .big => {
-                        const shift = @as(BufShift, @intCast(high_byte_shift + self.bit_count));
-                        const v = @as(u8, @intCast(in_buffer >> shift));
-                        self.bit_buffer |= v;
-                        in_buffer <<= n;
+                        const bits = in >> @intCast(in_count - bits_free);
+                        self.addBits(@truncate(bits), bits_free);
                     },
                     .little => {
-                        const v = @as(u8, @truncate(in_buffer)) << @as(u3, @intCast(self.bit_count));
-                        self.bit_buffer |= v;
-                        in_buffer >>= n;
+                        self.addBits(@truncate(in), bits_free);
+                        in >>= @intCast(bits_free);
                     },
                 }
-                self.bit_count += n;
-                in_bits -= n;
-
-                //if we didn't fill the buffer, it's because bits < bits_remaining;
-                if (self.bit_count != u8_bit_count) return;
-                try self.forward_writer.writeByte(self.bit_buffer);
-                self.bit_buffer = 0;
-                self.bit_count = 0;
+                in_count -= bits_free;
+                try self.flushBits();
             }
-            //at this point we know bit_buffer is empty
 
-            //copy bytes until we can't fill one anymore, then leave the rest in bit_buffer
-            while (in_bits >= u8_bit_count) {
+            //write full bytes while we can
+            const full_bytes_left = in_count / 8;
+            for (0..full_bytes_left) |_| {
                 switch (endian) {
                     .big => {
-                        const v = @as(u8, @intCast(in_buffer >> high_byte_shift));
-                        try self.forward_writer.writeByte(v);
-                        in_buffer <<= @as(u3, @intCast(u8_bit_count - 1));
-                        in_buffer <<= 1;
+                        const bits = in >> @intCast(in_count - 8);
+                        try self.writer.writeByte(@truncate(bits));
                     },
                     .little => {
-                        const v = @as(u8, @truncate(in_buffer));
-                        try self.forward_writer.writeByte(v);
-                        in_buffer >>= @as(u3, @intCast(u8_bit_count - 1));
-                        in_buffer >>= 1;
+                        try self.writer.writeByte(@truncate(in));
+                        if (U == u8) in = 0 else in >>= 8;
                     },
                 }
-                in_bits -= u8_bit_count;
+                in_count -= 8;
             }
 
-            if (in_bits > 0) {
-                self.bit_count = @as(u4, @intCast(in_bits));
-                self.bit_buffer = switch (endian) {
-                    .big => @as(u8, @truncate(in_buffer >> high_byte_shift)),
-                    .little => @as(u8, @truncate(in_buffer)),
-                };
-            }
-        }
-
-        /// Flush any remaining bits to the stream.
-        pub fn flushBits(self: *Self) Error!void {
-            if (self.bit_count == 0) return;
-            try self.forward_writer.writeByte(self.bit_buffer);
-            self.bit_buffer = 0;
-            self.bit_count = 0;
+            //save the remaining bits in the buffer
+            self.addBits(@truncate(in), @intCast(in_count));
         }
 
-        pub fn write(self: *Self, buffer: []const u8) Error!usize {
-            // TODO: I'm not sure this is a good idea, maybe flushBits should be forced
-            if (self.bit_count > 0) {
-                for (buffer) |b|
-                    try self.writeBits(b, u8_bit_count);
-                return buffer.len;
+        //convenience funciton for adding bits to the buffer
+        //in the appropriate position based on endianess
+        fn addBits(self: *@This(), bits: u8, num: u4) void {
+            if (num == 8) self.bits = bits else switch (endian) {
+                .big => {
+                    self.bits <<= @intCast(num);
+                    self.bits |= bits & low_bit_mask[num];
+                },
+                .little => {
+                    const pos = bits << @intCast(self.count);
+                    self.bits |= pos;
+                },
             }
-
-            return self.forward_writer.write(buffer);
+            self.count += num;
         }
 
-        pub fn writer(self: *Self) Writer {
-            return .{ .context = self };
+        /// Flush any remaining bits to the writer, filling
+        /// unused bits with 0s.
+        pub fn flushBits(self: *@This()) !void {
+            if (self.count == 0) return;
+            if (endian == .big) self.bits <<= @intCast(8 - self.count);
+            try self.writer.writeByte(self.bits);
+            self.bits = 0;
+            self.count = 0;
         }
     };
 }
 
-pub fn bitWriter(
-    comptime endian: std.builtin.Endian,
-    underlying_stream: anytype,
-) BitWriter(endian, @TypeOf(underlying_stream)) {
-    return BitWriter(endian, @TypeOf(underlying_stream)).init(underlying_stream);
+pub fn bitWriter(comptime endian: std.builtin.Endian, writer: anytype) BitWriter(endian, @TypeOf(writer)) {
+    return .{ .writer = writer };
 }
 
+///////////////////////////////
+
 test "api coverage" {
     var mem_be = [_]u8{0} ** 2;
     var mem_le = [_]u8{0} ** 2;
 
-    var mem_out_be = io.fixedBufferStream(&mem_be);
+    var mem_out_be = std.io.fixedBufferStream(&mem_be);
     var bit_stream_be = bitWriter(.big, mem_out_be.writer());
 
+    const testing = std.testing;
+
     try bit_stream_be.writeBits(@as(u2, 1), 1);
     try bit_stream_be.writeBits(@as(u5, 2), 2);
     try bit_stream_be.writeBits(@as(u128, 3), 3);
@@ -169,7 +154,7 @@ test "api coverage" {
 
     try bit_stream_be.writeBits(@as(u0, 0), 0);
 
-    var mem_out_le = io.fixedBufferStream(&mem_le);
+    var mem_out_le = std.io.fixedBufferStream(&mem_le);
     var bit_stream_le = bitWriter(.little, mem_out_le.writer());
 
     try bit_stream_le.writeBits(@as(u2, 1), 1);
diff --git a/zig/lib/std/io/test.zig b/zig/lib/std/io/test.zig
index 5ac4bb65d2..6505fcd4fa 100644
--- a/zig/lib/std/io/test.zig
+++ b/zig/lib/std/io/test.zig
@@ -82,7 +82,7 @@ test "BitStreams with File Stream" {
 
         var bit_stream = io.bitReader(native_endian, file.reader());
 
-        var out_bits: usize = undefined;
+        var out_bits: u16 = undefined;
 
         try expect(1 == try bit_stream.readBits(u2, 1, &out_bits));
         try expect(out_bits == 1);
diff --git a/zig/lib/std/math/big/int.zig b/zig/lib/std/math/big/int.zig
index 2d38517661..691ae02280 100644
--- a/zig/lib/std/math/big/int.zig
+++ b/zig/lib/std/math/big/int.zig
@@ -795,7 +795,6 @@ pub const Mutable = struct {
         const endian_mask: usize = (@sizeOf(Limb) - 1) << 3;
 
         const bytes = std.mem.sliceAsBytes(r.limbs);
-        var bits = std.packed_int_array.PackedIntSliceEndian(u1, .little).init(bytes, limbs_required * @bitSizeOf(Limb));
 
         var k: usize = 0;
         while (k < ((bit_count + 1) / 2)) : (k += 1) {
@@ -809,17 +808,17 @@ pub const Mutable = struct {
                 rev_i ^= endian_mask;
             }
 
-            const bit_i = bits.get(i);
-            const bit_rev_i = bits.get(rev_i);
-            bits.set(i, bit_rev_i);
-            bits.set(rev_i, bit_i);
+            const bit_i = std.mem.readPackedInt(u1, bytes, i, .little);
+            const bit_rev_i = std.mem.readPackedInt(u1, bytes, rev_i, .little);
+            std.mem.writePackedInt(u1, bytes, i, bit_rev_i, .little);
+            std.mem.writePackedInt(u1, bytes, rev_i, bit_i, .little);
         }
 
         // Calculate signed-magnitude representation for output
         if (signedness == .signed) {
             const last_bit = switch (native_endian) {
-                .little => bits.get(bit_count - 1),
-                .big => bits.get((bit_count - 1) ^ endian_mask),
+                .little => std.mem.readPackedInt(u1, bytes, bit_count - 1, .little),
+                .big => std.mem.readPackedInt(u1, bytes, (bit_count - 1) ^ endian_mask, .little),
             };
             if (last_bit == 1) {
                 r.bitNotWrap(r.toConst(), .unsigned, bit_count); // Bitwise NOT.
diff --git a/zig/lib/std/math/gamma.zig b/zig/lib/std/math/gamma.zig
index 5ac041e195..aad2a104cc 100644
--- a/zig/lib/std/math/gamma.zig
+++ b/zig/lib/std/math/gamma.zig
@@ -263,7 +263,7 @@ test gamma {
 }
 
 test "gamma.special" {
-    if (builtin.cpu.arch.isArmOrThumb() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
+    if (builtin.cpu.arch.isArm() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
 
     inline for (&.{ f32, f64 }) |T| {
         try expect(std.math.isNan(gamma(T, -std.math.nan(T))));
diff --git a/zig/lib/std/math/isnan.zig b/zig/lib/std/math/isnan.zig
index a85100ba90..e05ce452dd 100644
--- a/zig/lib/std/math/isnan.zig
+++ b/zig/lib/std/math/isnan.zig
@@ -32,7 +32,7 @@ test isSignalNan {
         // TODO: Signalling NaN values get converted to quiet NaN values in
         //       some cases where they shouldn't such that this can fail.
         //       See https://github.com/ziglang/zig/issues/14366
-        if (!builtin.cpu.arch.isArmOrThumb() and
+        if (!builtin.cpu.arch.isArm() and
             !builtin.cpu.arch.isAARCH64() and
             !builtin.cpu.arch.isPowerPC() and
             builtin.zig_backend != .stage2_c)
diff --git a/zig/lib/std/mem.zig b/zig/lib/std/mem.zig
index d458e26989..039b9d4324 100644
--- a/zig/lib/std/mem.zig
+++ b/zig/lib/std/mem.zig
@@ -1602,6 +1602,7 @@ test containsAtLeast {
 /// T 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);
     const bits = @typeInfo(ReturnType).int.bits;
     const signedness = @typeInfo(ReturnType).int.signedness;
     const WorkType = std.meta.Int(signedness, @max(16, bits));
@@ -3964,7 +3965,9 @@ fn CopyPtrAttrs(
 }
 
 fn AsBytesReturnType(comptime P: type) type {
-    const size = @sizeOf(std.meta.Child(P));
+    const pointer = @typeInfo(P).pointer;
+    assert(pointer.size == .One);
+    const size = @sizeOf(pointer.child);
     return CopyPtrAttrs(P, .One, [size]u8);
 }
 
diff --git a/zig/lib/std/meta.zig b/zig/lib/std/meta.zig
index ea81c87648..0ea83bb11e 100644
--- a/zig/lib/std/meta.zig
+++ b/zig/lib/std/meta.zig
@@ -1018,7 +1018,7 @@ fn CreateUniqueTuple(comptime N: comptime_int, comptime types: [N]type) type {
             .type = T,
             .default_value = null,
             .is_comptime = false,
-            .alignment = if (@sizeOf(T) > 0) @alignOf(T) else 0,
+            .alignment = 0,
         };
     }
 
diff --git a/zig/lib/std/multi_array_list.zig b/zig/lib/std/multi_array_list.zig
index eedc540db2..71ccb68b99 100644
--- a/zig/lib/std/multi_array_list.zig
+++ b/zig/lib/std/multi_array_list.zig
@@ -23,6 +23,12 @@ pub fn MultiArrayList(comptime T: type) type {
         len: usize = 0,
         capacity: usize = 0,
 
+        pub const empty: Self = .{
+            .bytes = undefined,
+            .len = 0,
+            .capacity = 0,
+        };
+
         const Elem = switch (@typeInfo(T)) {
             .@"struct" => T,
             .@"union" => |u| struct {
@@ -340,11 +346,8 @@ pub fn MultiArrayList(comptime T: type) type {
         /// If `new_len` is greater than zero, this may fail to reduce the capacity,
         /// but the data remains intact and the length is updated to new_len.
         pub fn shrinkAndFree(self: *Self, gpa: Allocator, new_len: usize) void {
-            if (new_len == 0) {
-                gpa.free(self.allocatedBytes());
-                self.* = .{};
-                return;
-            }
+            if (new_len == 0) return clearAndFree(self, gpa);
+
             assert(new_len <= self.capacity);
             assert(new_len <= self.len);
 
@@ -385,6 +388,11 @@ pub fn MultiArrayList(comptime T: type) type {
             self.* = other;
         }
 
+        pub fn clearAndFree(self: *Self, gpa: Allocator) void {
+            gpa.free(self.allocatedBytes());
+            self.* = .{};
+        }
+
         /// Reduce length to `new_len`.
         /// Invalidates pointers to elements `items[new_len..]`.
         /// Keeps capacity the same.
@@ -392,6 +400,11 @@ pub fn MultiArrayList(comptime T: type) type {
             self.len = new_len;
         }
 
+        /// Invalidates all element pointers.
+        pub fn clearRetainingCapacity(self: *Self) void {
+            self.len = 0;
+        }
+
         /// Modify the array so that it can hold at least `new_capacity` items.
         /// Implements super-linear growth to achieve amortized O(1) append operations.
         /// Invalidates pointers if additional memory is needed.
@@ -474,7 +487,7 @@ pub fn MultiArrayList(comptime T: type) type {
                 pub fn swap(sc: @This(), a_index: usize, b_index: usize) void {
                     inline for (fields, 0..) |field_info, i| {
                         if (@sizeOf(field_info.type) != 0) {
-                            const field = @as(Field, @enumFromInt(i));
+                            const field: Field = @enumFromInt(i);
                             const ptr = sc.slice.items(field);
                             mem.swap(field_info.type, &ptr[a_index], &ptr[b_index]);
                         }
@@ -671,6 +684,14 @@ test "basic usage" {
     try testing.expectEqual(@as(u32, 2), list.pop().a);
     try testing.expectEqual(@as(u8, 'a'), list.pop().c);
     try testing.expectEqual(@as(?Foo, null), list.popOrNull());
+
+    list.clearRetainingCapacity();
+    try testing.expectEqual(0, list.len);
+    try testing.expect(list.capacity > 0);
+
+    list.clearAndFree(ally);
+    try testing.expectEqual(0, list.len);
+    try testing.expectEqual(0, list.capacity);
 }
 
 // This was observed to fail on aarch64 with LLVM 11, when the capacityInBytes
diff --git a/zig/lib/std/os/linux.zig b/zig/lib/std/os/linux.zig
index 03eef2bb8e..bf0c3e6371 100644
--- a/zig/lib/std/os/linux.zig
+++ b/zig/lib/std/os/linux.zig
@@ -122,27 +122,30 @@ pub const SECCOMP = @import("linux/seccomp.zig");
 
 pub const syscalls = @import("linux/syscalls.zig");
 pub const SYS = switch (@import("builtin").cpu.arch) {
-    .x86 => syscalls.X86,
-    .x86_64 => syscalls.X64,
-    .aarch64, .aarch64_be => syscalls.Arm64,
     .arc => syscalls.Arc,
     .arm, .armeb, .thumb, .thumbeb => syscalls.Arm,
+    .aarch64, .aarch64_be => syscalls.Arm64,
     .csky => syscalls.CSky,
     .hexagon => syscalls.Hexagon,
+    .loongarch64 => syscalls.LoongArch64,
+    .m68k => syscalls.M68k,
+    .mips, .mipsel => syscalls.MipsO32,
+    .mips64, .mips64el => switch (builtin.abi) {
+        .gnuabin32, .muslabin32 => syscalls.MipsN32,
+        else => syscalls.MipsN64,
+    },
     .riscv32 => syscalls.RiscV32,
     .riscv64 => syscalls.RiscV64,
+    .s390x => syscalls.S390x,
     .sparc => syscalls.Sparc,
     .sparc64 => syscalls.Sparc64,
-    .loongarch64 => syscalls.LoongArch64,
-    .m68k => syscalls.M68k,
-    .mips, .mipsel => syscalls.MipsO32,
-    .mips64, .mips64el => if (builtin.abi == .gnuabin32)
-        syscalls.MipsN32
-    else
-        syscalls.MipsN64,
     .powerpc, .powerpcle => syscalls.PowerPC,
     .powerpc64, .powerpc64le => syscalls.PowerPC64,
-    .s390x => syscalls.S390x,
+    .x86 => syscalls.X86,
+    .x86_64 => switch (builtin.abi) {
+        .gnux32, .muslx32 => syscalls.X32,
+        else => syscalls.X64,
+    },
     .xtensa => syscalls.Xtensa,
     else => @compileError("The Zig Standard Library is missing syscall definitions for the target CPU architecture"),
 };
@@ -506,7 +509,7 @@ fn getauxvalImpl(index: usize) callconv(.C) usize {
 const require_aligned_register_pair =
     builtin.cpu.arch.isPowerPC32() or
     builtin.cpu.arch.isMIPS32() or
-    builtin.cpu.arch.isArmOrThumb();
+    builtin.cpu.arch.isArm();
 
 // Split a 64bit value into a {LSB,MSB} pair.
 // The LE/BE variants specify the endianness to assume.
@@ -2022,8 +2025,8 @@ pub fn llistxattr(path: [*:0]const u8, list: [*]u8, size: usize) usize {
     return syscall3(.llistxattr, @intFromPtr(path), @intFromPtr(list), size);
 }
 
-pub fn flistxattr(fd: usize, list: [*]u8, size: usize) usize {
-    return syscall3(.flistxattr, fd, @intFromPtr(list), size);
+pub fn flistxattr(fd: fd_t, list: [*]u8, size: usize) usize {
+    return syscall3(.flistxattr, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(list), size);
 }
 
 pub fn getxattr(path: [*:0]const u8, name: [*:0]const u8, value: [*]u8, size: usize) usize {
@@ -2034,20 +2037,20 @@ pub fn lgetxattr(path: [*:0]const u8, name: [*:0]const u8, value: [*]u8, size: u
     return syscall4(.lgetxattr, @intFromPtr(path), @intFromPtr(name), @intFromPtr(value), size);
 }
 
-pub fn fgetxattr(fd: usize, name: [*:0]const u8, value: [*]u8, size: usize) usize {
-    return syscall4(.lgetxattr, fd, @intFromPtr(name), @intFromPtr(value), size);
+pub fn fgetxattr(fd: fd_t, name: [*:0]const u8, value: [*]u8, size: usize) usize {
+    return syscall4(.fgetxattr, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(name), @intFromPtr(value), size);
 }
 
-pub fn setxattr(path: [*:0]const u8, name: [*:0]const u8, value: *const void, size: usize, flags: usize) usize {
+pub fn setxattr(path: [*:0]const u8, name: [*:0]const u8, value: [*]const u8, size: usize, flags: usize) usize {
     return syscall5(.setxattr, @intFromPtr(path), @intFromPtr(name), @intFromPtr(value), size, flags);
 }
 
-pub fn lsetxattr(path: [*:0]const u8, name: [*:0]const u8, value: *const void, size: usize, flags: usize) usize {
+pub fn lsetxattr(path: [*:0]const u8, name: [*:0]const u8, value: [*]const u8, size: usize, flags: usize) usize {
     return syscall5(.lsetxattr, @intFromPtr(path), @intFromPtr(name), @intFromPtr(value), size, flags);
 }
 
-pub fn fsetxattr(fd: usize, name: [*:0]const u8, value: *const void, size: usize, flags: usize) usize {
-    return syscall5(.fsetxattr, fd, @intFromPtr(name), @intFromPtr(value), size, flags);
+pub fn fsetxattr(fd: fd_t, name: [*:0]const u8, value: [*]const u8, size: usize, flags: usize) usize {
+    return syscall5(.fsetxattr, @as(usize, @bitCast(@as(isize, fd))), @intFromPtr(name), @intFromPtr(value), size, flags);
 }
 
 pub fn removexattr(path: [*:0]const u8, name: [*:0]const u8) usize {
@@ -2331,7 +2334,7 @@ pub fn process_vm_writev(pid: pid_t, local: []const iovec_const, remote: []const
 }
 
 pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {
-    if (comptime native_arch.isArmOrThumb() or native_arch.isPowerPC32()) {
+    if (comptime native_arch.isArm() or native_arch.isPowerPC32()) {
         // These architectures reorder the arguments so that a register is not skipped to align the
         // register number that `offset` is passed in.
 
@@ -7118,6 +7121,19 @@ pub const SIOCPROTOPRIVATE = 0x89E0;
 
 pub const IFNAMESIZE = 16;
 
+pub const IFF = packed struct(u16) {
+    UP: bool = false,
+    BROADCAST: bool = false,
+    DEBUG: bool = false,
+    LOOPBACK: bool = false,
+    POINTOPOINT: bool = false,
+    NOTRAILERS: bool = false,
+    RUNNING: bool = false,
+    NOARP: bool = false,
+    PROMISC: bool = false,
+    _9: u7 = 0,
+};
+
 pub const ifmap = extern struct {
     mem_start: usize,
     mem_end: usize,
@@ -7137,7 +7153,7 @@ pub const ifreq = extern struct {
         broadaddr: sockaddr,
         netmask: sockaddr,
         hwaddr: sockaddr,
-        flags: i16,
+        flags: IFF,
         ivalue: i32,
         mtu: i32,
         map: ifmap,
@@ -8657,11 +8673,11 @@ pub const AUDIT = struct {
             .mips => .MIPS,
             .mipsel => .MIPSEL,
             .mips64 => switch (native_abi) {
-                .gnuabin32 => .MIPS64N32,
+                .gnuabin32, .muslabin32 => .MIPS64N32,
                 else => .MIPS64,
             },
             .mips64el => switch (native_abi) {
-                .gnuabin32 => .MIPSEL64N32,
+                .gnuabin32, .muslabin32 => .MIPSEL64N32,
                 else => .MIPSEL64,
             },
             .powerpc => .PPC,
diff --git a/zig/lib/std/os/linux/syscalls.zig b/zig/lib/std/os/linux/syscalls.zig
index ef04387ea6..fbf3aada02 100644
--- a/zig/lib/std/os/linux/syscalls.zig
+++ b/zig/lib/std/os/linux/syscalls.zig
@@ -833,6 +833,372 @@ pub const X64 = enum(usize) {
     mseal = 462,
 };
 
+pub const X32 = enum(usize) {
+    read = 0,
+    write = 1,
+    open = 2,
+    close = 3,
+    stat = 4,
+    fstat = 5,
+    lstat = 6,
+    poll = 7,
+    lseek = 8,
+    mmap = 9,
+    mprotect = 10,
+    munmap = 11,
+    brk = 12,
+    rt_sigprocmask = 14,
+    pread64 = 17,
+    pwrite64 = 18,
+    access = 21,
+    pipe = 22,
+    select = 23,
+    sched_yield = 24,
+    mremap = 25,
+    msync = 26,
+    mincore = 27,
+    madvise = 28,
+    shmget = 29,
+    shmat = 30,
+    shmctl = 31,
+    dup = 32,
+    dup2 = 33,
+    pause = 34,
+    nanosleep = 35,
+    getitimer = 36,
+    alarm = 37,
+    setitimer = 38,
+    getpid = 39,
+    sendfile = 40,
+    socket = 41,
+    connect = 42,
+    accept = 43,
+    sendto = 44,
+    shutdown = 48,
+    bind = 49,
+    listen = 50,
+    getsockname = 51,
+    getpeername = 52,
+    socketpair = 53,
+    clone = 56,
+    fork = 57,
+    vfork = 58,
+    exit = 60,
+    wait4 = 61,
+    kill = 62,
+    uname = 63,
+    semget = 64,
+    semop = 65,
+    semctl = 66,
+    shmdt = 67,
+    msgget = 68,
+    msgsnd = 69,
+    msgrcv = 70,
+    msgctl = 71,
+    fcntl = 72,
+    flock = 73,
+    fsync = 74,
+    fdatasync = 75,
+    truncate = 76,
+    ftruncate = 77,
+    getdents = 78,
+    getcwd = 79,
+    chdir = 80,
+    fchdir = 81,
+    rename = 82,
+    mkdir = 83,
+    rmdir = 84,
+    creat = 85,
+    link = 86,
+    unlink = 87,
+    symlink = 88,
+    readlink = 89,
+    chmod = 90,
+    fchmod = 91,
+    chown = 92,
+    fchown = 93,
+    lchown = 94,
+    umask = 95,
+    gettimeofday = 96,
+    getrlimit = 97,
+    getrusage = 98,
+    sysinfo = 99,
+    times = 100,
+    getuid = 102,
+    syslog = 103,
+    getgid = 104,
+    setuid = 105,
+    setgid = 106,
+    geteuid = 107,
+    getegid = 108,
+    setpgid = 109,
+    getppid = 110,
+    getpgrp = 111,
+    setsid = 112,
+    setreuid = 113,
+    setregid = 114,
+    getgroups = 115,
+    setgroups = 116,
+    setresuid = 117,
+    getresuid = 118,
+    setresgid = 119,
+    getresgid = 120,
+    getpgid = 121,
+    setfsuid = 122,
+    setfsgid = 123,
+    getsid = 124,
+    capget = 125,
+    capset = 126,
+    rt_sigsuspend = 130,
+    utime = 132,
+    mknod = 133,
+    personality = 135,
+    ustat = 136,
+    statfs = 137,
+    fstatfs = 138,
+    sysfs = 139,
+    getpriority = 140,
+    setpriority = 141,
+    sched_setparam = 142,
+    sched_getparam = 143,
+    sched_setscheduler = 144,
+    sched_getscheduler = 145,
+    sched_get_priority_max = 146,
+    sched_get_priority_min = 147,
+    sched_rr_get_interval = 148,
+    mlock = 149,
+    munlock = 150,
+    mlockall = 151,
+    munlockall = 152,
+    vhangup = 153,
+    modify_ldt = 154,
+    pivot_root = 155,
+    prctl = 157,
+    arch_prctl = 158,
+    adjtimex = 159,
+    setrlimit = 160,
+    chroot = 161,
+    sync = 162,
+    acct = 163,
+    settimeofday = 164,
+    mount = 165,
+    umount2 = 166,
+    swapon = 167,
+    swapoff = 168,
+    reboot = 169,
+    sethostname = 170,
+    setdomainname = 171,
+    iopl = 172,
+    ioperm = 173,
+    init_module = 175,
+    delete_module = 176,
+    quotactl = 179,
+    getpmsg = 181,
+    putpmsg = 182,
+    afs_syscall = 183,
+    tuxcall = 184,
+    security = 185,
+    gettid = 186,
+    readahead = 187,
+    setxattr = 188,
+    lsetxattr = 189,
+    fsetxattr = 190,
+    getxattr = 191,
+    lgetxattr = 192,
+    fgetxattr = 193,
+    listxattr = 194,
+    llistxattr = 195,
+    flistxattr = 196,
+    removexattr = 197,
+    lremovexattr = 198,
+    fremovexattr = 199,
+    tkill = 200,
+    time = 201,
+    futex = 202,
+    sched_setaffinity = 203,
+    sched_getaffinity = 204,
+    io_destroy = 207,
+    io_getevents = 208,
+    io_cancel = 210,
+    lookup_dcookie = 212,
+    epoll_create = 213,
+    remap_file_pages = 216,
+    getdents64 = 217,
+    set_tid_address = 218,
+    restart_syscall = 219,
+    semtimedop = 220,
+    fadvise64 = 221,
+    timer_settime = 223,
+    timer_gettime = 224,
+    timer_getoverrun = 225,
+    timer_delete = 226,
+    clock_settime = 227,
+    clock_gettime = 228,
+    clock_getres = 229,
+    clock_nanosleep = 230,
+    exit_group = 231,
+    epoll_wait = 232,
+    epoll_ctl = 233,
+    tgkill = 234,
+    utimes = 235,
+    mbind = 237,
+    set_mempolicy = 238,
+    get_mempolicy = 239,
+    mq_open = 240,
+    mq_unlink = 241,
+    mq_timedsend = 242,
+    mq_timedreceive = 243,
+    mq_getsetattr = 245,
+    add_key = 248,
+    request_key = 249,
+    keyctl = 250,
+    ioprio_set = 251,
+    ioprio_get = 252,
+    inotify_init = 253,
+    inotify_add_watch = 254,
+    inotify_rm_watch = 255,
+    migrate_pages = 256,
+    openat = 257,
+    mkdirat = 258,
+    mknodat = 259,
+    fchownat = 260,
+    futimesat = 261,
+    fstatat64 = 262,
+    unlinkat = 263,
+    renameat = 264,
+    linkat = 265,
+    symlinkat = 266,
+    readlinkat = 267,
+    fchmodat = 268,
+    faccessat = 269,
+    pselect6 = 270,
+    ppoll = 271,
+    unshare = 272,
+    splice = 275,
+    tee = 276,
+    sync_file_range = 277,
+    utimensat = 280,
+    epoll_pwait = 281,
+    signalfd = 282,
+    timerfd_create = 283,
+    eventfd = 284,
+    fallocate = 285,
+    timerfd_settime = 286,
+    timerfd_gettime = 287,
+    accept4 = 288,
+    signalfd4 = 289,
+    eventfd2 = 290,
+    epoll_create1 = 291,
+    dup3 = 292,
+    pipe2 = 293,
+    inotify_init1 = 294,
+    perf_event_open = 298,
+    fanotify_init = 300,
+    fanotify_mark = 301,
+    prlimit64 = 302,
+    name_to_handle_at = 303,
+    open_by_handle_at = 304,
+    clock_adjtime = 305,
+    syncfs = 306,
+    setns = 308,
+    getcpu = 309,
+    kcmp = 312,
+    finit_module = 313,
+    sched_setattr = 314,
+    sched_getattr = 315,
+    renameat2 = 316,
+    seccomp = 317,
+    getrandom = 318,
+    memfd_create = 319,
+    kexec_file_load = 320,
+    bpf = 321,
+    userfaultfd = 323,
+    membarrier = 324,
+    mlock2 = 325,
+    copy_file_range = 326,
+    pkey_mprotect = 329,
+    pkey_alloc = 330,
+    pkey_free = 331,
+    statx = 332,
+    io_pgetevents = 333,
+    rseq = 334,
+    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,
+    memfd_secret = 447,
+    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,
+    rt_sigaction = 512,
+    rt_sigreturn = 513,
+    ioctl = 514,
+    readv = 515,
+    writev = 516,
+    recvfrom = 517,
+    sendmsg = 518,
+    recvmsg = 519,
+    execve = 520,
+    ptrace = 521,
+    rt_sigpending = 522,
+    rt_sigtimedwait = 523,
+    rt_sigqueueinfo = 524,
+    sigaltstack = 525,
+    timer_create = 526,
+    mq_notify = 527,
+    kexec_load = 528,
+    waitid = 529,
+    set_robust_list = 530,
+    get_robust_list = 531,
+    vmsplice = 532,
+    move_pages = 533,
+    preadv = 534,
+    pwritev = 535,
+    rt_tgsigqueueinfo = 536,
+    recvmmsg = 537,
+    sendmmsg = 538,
+    process_vm_readv = 539,
+    process_vm_writev = 540,
+    setsockopt = 541,
+    getsockopt = 542,
+    io_setup = 543,
+    io_submit = 544,
+    execveat = 545,
+    preadv2 = 546,
+    pwritev2 = 547,
+};
+
 pub const Arm = enum(usize) {
     const arm_base = 0x0f0000;
 
diff --git a/zig/lib/std/os/linux/vdso.zig b/zig/lib/std/os/linux/vdso.zig
index 4e62679b26..3d418994a6 100644
--- a/zig/lib/std/os/linux/vdso.zig
+++ b/zig/lib/std/os/linux/vdso.zig
@@ -34,10 +34,10 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {
     const dynv = maybe_dynv orelse return 0;
     if (base == maxInt(usize)) return 0;
 
-    var maybe_strings: ?[*]u8 = null;
+    var maybe_strings: ?[*:0]u8 = null;
     var maybe_syms: ?[*]elf.Sym = null;
     var maybe_hashtab: ?[*]linux.Elf_Symndx = null;
-    var maybe_versym: ?[*]u16 = null;
+    var maybe_versym: ?[*]elf.Versym = null;
     var maybe_verdef: ?*elf.Verdef = null;
 
     {
@@ -45,11 +45,11 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {
         while (dynv[i] != 0) : (i += 2) {
             const p = base +% dynv[i + 1];
             switch (dynv[i]) {
-                elf.DT_STRTAB => maybe_strings = @as([*]u8, @ptrFromInt(p)),
-                elf.DT_SYMTAB => maybe_syms = @as([*]elf.Sym, @ptrFromInt(p)),
-                elf.DT_HASH => maybe_hashtab = @as([*]linux.Elf_Symndx, @ptrFromInt(p)),
-                elf.DT_VERSYM => maybe_versym = @as([*]u16, @ptrFromInt(p)),
-                elf.DT_VERDEF => maybe_verdef = @as(*elf.Verdef, @ptrFromInt(p)),
+                elf.DT_STRTAB => maybe_strings = @ptrFromInt(p),
+                elf.DT_SYMTAB => maybe_syms = @ptrFromInt(p),
+                elf.DT_HASH => maybe_hashtab = @ptrFromInt(p),
+                elf.DT_VERSYM => maybe_versym = @ptrFromInt(p),
+                elf.DT_VERDEF => maybe_verdef = @ptrFromInt(p),
                 else => {},
             }
         }
@@ -80,17 +80,14 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {
     return 0;
 }
 
-fn checkver(def_arg: *elf.Verdef, vsym_arg: i32, vername: []const u8, strings: [*]u8) bool {
+fn checkver(def_arg: *elf.Verdef, vsym_arg: elf.Versym, vername: []const u8, strings: [*:0]u8) bool {
     var def = def_arg;
-    const vsym = @as(u32, @bitCast(vsym_arg)) & 0x7fff;
+    const vsym_index = vsym_arg.VERSION;
     while (true) {
-        if (0 == (def.vd_flags & elf.VER_FLG_BASE) and (def.vd_ndx & 0x7fff) == vsym)
-            break;
-        if (def.vd_next == 0)
-            return false;
-        def = @as(*elf.Verdef, @ptrFromInt(@intFromPtr(def) + def.vd_next));
+        if (0 == (def.flags & elf.VER_FLG_BASE) and @intFromEnum(def.ndx) == vsym_index) break;
+        if (def.next == 0) return false;
+        def = @ptrFromInt(@intFromPtr(def) + def.next);
     }
-    const aux = @as(*elf.Verdaux, @ptrFromInt(@intFromPtr(def) + def.vd_aux));
-    const vda_name = @as([*:0]u8, @ptrCast(strings + aux.vda_name));
-    return mem.eql(u8, vername, mem.sliceTo(vda_name, 0));
+    const aux: *elf.Verdaux = @ptrFromInt(@intFromPtr(def) + def.aux);
+    return mem.eql(u8, vername, mem.sliceTo(strings + aux.name, 0));
 }
diff --git a/zig/lib/std/os/uefi.zig b/zig/lib/std/os/uefi.zig
index 165c3df249..91f3678b26 100644
--- a/zig/lib/std/os/uefi.zig
+++ b/zig/lib/std/os/uefi.zig
@@ -26,9 +26,9 @@ pub var system_table: *tables.SystemTable = undefined;
 pub const Event = *opaque {};
 
 /// The calling convention used for all external functions part of the UEFI API.
-pub const cc = switch (@import("builtin").target.cpu.arch) {
-    .x86_64 => .Win64,
-    else => .C,
+pub const cc: std.builtin.CallingConvention = switch (@import("builtin").target.cpu.arch) {
+    .x86_64 => .{ .x86_64_win = .{} },
+    else => .c,
 };
 
 pub const MacAddress = extern struct {
diff --git a/zig/lib/std/os/windows.zig b/zig/lib/std/os/windows.zig
index 7f4d3290dc..8cd54409b2 100644
--- a/zig/lib/std/os/windows.zig
+++ b/zig/lib/std/os/windows.zig
@@ -682,7 +682,7 @@ pub fn WriteFile(
             .OPERATION_ABORTED => return error.OperationAborted,
             .NOT_ENOUGH_QUOTA => return error.SystemResources,
             .IO_PENDING => unreachable,
-            .BROKEN_PIPE => return error.BrokenPipe,
+            .NO_DATA => return error.BrokenPipe,
             .INVALID_HANDLE => return error.NotOpenForWriting,
             .LOCK_VIOLATION => return error.LockViolation,
             .NETNAME_DELETED => return error.ConnectionResetByPeer,
@@ -1110,7 +1110,7 @@ pub fn DeleteFile(sub_path_w: []const u16, options: DeleteFileOptions) DeleteFil
 
 pub const MoveFileError = error{ FileNotFound, AccessDenied, Unexpected };
 
-pub fn MoveFileEx(old_path: []const u8, new_path: []const u8, flags: DWORD) MoveFileError!void {
+pub fn MoveFileEx(old_path: []const u8, new_path: []const u8, flags: DWORD) (MoveFileError || Wtf8ToPrefixedFileWError)!void {
     const old_path_w = try sliceToPrefixedFileW(null, old_path);
     const new_path_w = try sliceToPrefixedFileW(null, new_path);
     return MoveFileExW(old_path_w.span().ptr, new_path_w.span().ptr, flags);
@@ -1518,7 +1518,7 @@ pub const GetFileAttributesError = error{
     Unexpected,
 };
 
-pub fn GetFileAttributes(filename: []const u8) GetFileAttributesError!DWORD {
+pub fn GetFileAttributes(filename: []const u8) (GetFileAttributesError || Wtf8ToPrefixedFileWError)!DWORD {
     const filename_w = try sliceToPrefixedFileW(null, filename);
     return GetFileAttributesW(filename_w.span().ptr);
 }
@@ -1667,7 +1667,7 @@ pub fn getpeername(s: ws2_32.SOCKET, name: *ws2_32.sockaddr, namelen: *ws2_32.so
 
 pub fn sendmsg(
     s: ws2_32.SOCKET,
-    msg: *const ws2_32.WSAMSG,
+    msg: *ws2_32.WSAMSG_const,
     flags: u32,
 ) i32 {
     var bytes_send: DWORD = undefined;
@@ -2101,39 +2101,41 @@ pub fn UnlockFile(
 
 /// This is a workaround for the C backend until zig has the ability to put
 /// C code in inline assembly.
-extern fn zig_x86_windows_teb() callconv(.C) *anyopaque;
-extern fn zig_x86_64_windows_teb() callconv(.C) *anyopaque;
+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) {
-        .x86 => blk: {
-            if (builtin.zig_backend == .stage2_c) {
-                break :blk @ptrCast(@alignCast(zig_x86_windows_teb()));
-            } else {
-                break :blk asm (
-                    \\ movl %%fs:0x18, %[ptr]
-                    : [ptr] "=r" (-> *TEB),
-                );
-            }
-        },
-        .x86_64 => blk: {
-            if (builtin.zig_backend == .stage2_c) {
-                break :blk @ptrCast(@alignCast(zig_x86_64_windows_teb()));
-            } else {
-                break :blk asm (
-                    \\ movq %%gs:0x30, %[ptr]
-                    : [ptr] "=r" (-> *TEB),
-                );
-            }
-        },
-        .thumb => asm (
-            \\ mrc p15, 0, %[ptr], c13, c0, 2
-            : [ptr] "=r" (-> *TEB),
-        ),
-        .aarch64 => asm (
-            \\ mov %[ptr], x18
-            : [ptr] "=r" (-> *TEB),
-        ),
+        .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 (
+                \\ movl %%fs:0x18, %[ptr]
+                : [ptr] "=r" (-> *TEB),
+            ),
+        .x86_64 => if (builtin.zig_backend == .stage2_c)
+            @ptrCast(@alignCast(zig_x86_64_windows_teb()))
+        else
+            asm (
+                \\ movq %%gs:0x30, %[ptr]
+                : [ptr] "=r" (-> *TEB),
+            ),
         else => @compileError("unsupported arch"),
     };
 }
@@ -2824,10 +2826,8 @@ 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 WINAPI: std.builtin.CallingConvention = if (native_arch == .x86)
-    .Stdcall
-else
-    .C;
+/// Deprecated; use `std.builtin.CallingConvention.winapi` instead.
+pub const WINAPI: std.builtin.CallingConvention = .winapi;
 
 pub const BOOL = c_int;
 pub const BOOLEAN = BYTE;
@@ -3570,7 +3570,7 @@ pub const MEM_RESERVE_PLACEHOLDERS = 0x2;
 pub const MEM_DECOMMIT = 0x4000;
 pub const MEM_RELEASE = 0x8000;
 
-pub const PTHREAD_START_ROUTINE = *const fn (LPVOID) callconv(.C) DWORD;
+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 {
@@ -3748,7 +3748,7 @@ pub const IMAGE_TLS_DIRECTORY = extern struct {
 pub const IMAGE_TLS_DIRECTORY64 = IMAGE_TLS_DIRECTORY;
 pub const IMAGE_TLS_DIRECTORY32 = IMAGE_TLS_DIRECTORY;
 
-pub const PIMAGE_TLS_CALLBACK = ?*const fn (PVOID, DWORD, PVOID) callconv(.C) void;
+pub const PIMAGE_TLS_CALLBACK = ?*const fn (PVOID, DWORD, PVOID) callconv(.winapi) void;
 
 pub const PROV_RSA_FULL = 1;
 
@@ -3846,7 +3846,7 @@ pub const RTL_QUERY_REGISTRY_ROUTINE = ?*const fn (
     ULONG,
     ?*anyopaque,
     ?*anyopaque,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 /// Path is a full path
 pub const RTL_REGISTRY_ABSOLUTE = 0;
@@ -3943,7 +3943,7 @@ 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(.C) void;
+pub const LPOVERLAPPED_COMPLETION_ROUTINE = ?*const fn (DWORD, DWORD, *OVERLAPPED) callconv(.winapi) void;
 
 pub const FileNotifyChangeFilter = packed struct(DWORD) {
     file_name: bool = false,
@@ -4006,7 +4006,7 @@ pub const RTL_CRITICAL_SECTION = extern struct {
 pub const CRITICAL_SECTION = RTL_CRITICAL_SECTION;
 pub const INIT_ONCE = RTL_RUN_ONCE;
 pub const INIT_ONCE_STATIC_INIT = RTL_RUN_ONCE_INIT;
-pub const INIT_ONCE_FN = *const fn (InitOnce: *INIT_ONCE, Parameter: ?*anyopaque, Context: ?*anyopaque) callconv(.C) BOOL;
+pub const INIT_ONCE_FN = *const fn (InitOnce: *INIT_ONCE, Parameter: ?*anyopaque, Context: ?*anyopaque) callconv(.winapi) BOOL;
 
 pub const RTL_RUN_ONCE = extern struct {
     Ptr: ?*anyopaque,
@@ -4470,7 +4470,7 @@ pub const EXCEPTION_POINTERS = extern struct {
     ContextRecord: *CONTEXT,
 };
 
-pub const VECTORED_EXCEPTION_HANDLER = *const fn (ExceptionInfo: *EXCEPTION_POINTERS) callconv(WINAPI) c_long;
+pub const VECTORED_EXCEPTION_HANDLER = *const fn (ExceptionInfo: *EXCEPTION_POINTERS) callconv(.winapi) c_long;
 
 pub const EXCEPTION_DISPOSITION = i32;
 pub const EXCEPTION_ROUTINE = *const fn (
@@ -4478,7 +4478,7 @@ pub const EXCEPTION_ROUTINE = *const fn (
     EstablisherFrame: PVOID,
     ContextRecord: *(Self.CONTEXT),
     DispatcherContext: PVOID,
-) callconv(WINAPI) EXCEPTION_DISPOSITION;
+) callconv(.winapi) EXCEPTION_DISPOSITION;
 
 pub const UNWIND_HISTORY_TABLE_SIZE = 12;
 pub const UNWIND_HISTORY_TABLE_ENTRY = extern struct {
@@ -4854,7 +4854,7 @@ pub const RTL_DRIVE_LETTER_CURDIR = extern struct {
     DosPath: UNICODE_STRING,
 };
 
-pub const PPS_POST_PROCESS_INIT_ROUTINE = ?*const fn () callconv(.C) void;
+pub const PPS_POST_PROCESS_INIT_ROUTINE = ?*const fn () callconv(.winapi) void;
 
 pub const FILE_DIRECTORY_INFORMATION = extern struct {
     NextEntryOffset: ULONG,
@@ -4908,7 +4908,7 @@ pub fn FileInformationIterator(comptime FileInformationType: type) type {
     };
 }
 
-pub const IO_APC_ROUTINE = *const fn (PVOID, *IO_STATUS_BLOCK, ULONG) callconv(.C) void;
+pub const IO_APC_ROUTINE = *const fn (PVOID, *IO_STATUS_BLOCK, ULONG) callconv(.winapi) void;
 
 pub const CURDIR = extern struct {
     DosPath: UNICODE_STRING,
@@ -5012,8 +5012,8 @@ pub const ENUM_PAGE_FILE_INFORMATION = extern struct {
     PeakUsage: SIZE_T,
 };
 
-pub const PENUM_PAGE_FILE_CALLBACKW = ?*const fn (?LPVOID, *ENUM_PAGE_FILE_INFORMATION, LPCWSTR) callconv(.C) BOOL;
-pub const PENUM_PAGE_FILE_CALLBACKA = ?*const fn (?LPVOID, *ENUM_PAGE_FILE_INFORMATION, LPCSTR) callconv(.C) BOOL;
+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,
@@ -5125,7 +5125,7 @@ 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;
+pub const HANDLER_ROUTINE = *const fn (dwCtrlType: DWORD) callconv(.winapi) BOOL;
 
 /// Processor feature enumeration.
 pub const PF = enum(DWORD) {
diff --git a/zig/lib/std/os/windows/advapi32.zig b/zig/lib/std/os/windows/advapi32.zig
index 3419fdc95c..bf438e2776 100644
--- a/zig/lib/std/os/windows/advapi32.zig
+++ b/zig/lib/std/os/windows/advapi32.zig
@@ -8,7 +8,6 @@ const LPCWSTR = windows.LPCWSTR;
 const LSTATUS = windows.LSTATUS;
 const REGSAM = windows.REGSAM;
 const ULONG = windows.ULONG;
-const WINAPI = windows.WINAPI;
 
 pub extern "advapi32" fn RegOpenKeyExW(
     hKey: HKEY,
@@ -16,7 +15,7 @@ pub extern "advapi32" fn RegOpenKeyExW(
     ulOptions: DWORD,
     samDesired: REGSAM,
     phkResult: *HKEY,
-) callconv(WINAPI) LSTATUS;
+) callconv(.winapi) LSTATUS;
 
 pub extern "advapi32" fn RegQueryValueExW(
     hKey: HKEY,
@@ -25,13 +24,13 @@ pub extern "advapi32" fn RegQueryValueExW(
     lpType: ?*DWORD,
     lpData: ?*BYTE,
     lpcbData: ?*DWORD,
-) callconv(WINAPI) LSTATUS;
+) callconv(.winapi) LSTATUS;
 
-pub extern "advapi32" fn RegCloseKey(hKey: HKEY) callconv(WINAPI) LSTATUS;
+pub extern "advapi32" fn RegCloseKey(hKey: HKEY) callconv(.winapi) LSTATUS;
 
 // RtlGenRandom is known as SystemFunction036 under advapi32
 // http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx */
-pub extern "advapi32" fn SystemFunction036(output: [*]u8, length: ULONG) callconv(WINAPI) BOOL;
+pub extern "advapi32" fn SystemFunction036(output: [*]u8, length: ULONG) callconv(.winapi) BOOL;
 pub const RtlGenRandom = SystemFunction036;
 
 pub const RRF = struct {
@@ -62,7 +61,7 @@ pub extern "advapi32" fn RegGetValueW(
     pdwType: ?*DWORD,
     pvData: ?*anyopaque,
     pcbData: ?*DWORD,
-) callconv(WINAPI) LSTATUS;
+) callconv(.winapi) LSTATUS;
 
 pub extern "advapi32" fn RegLoadAppKeyW(
     lpFile: LPCWSTR,
@@ -70,4 +69,4 @@ pub extern "advapi32" fn RegLoadAppKeyW(
     samDesired: REGSAM,
     dwOptions: DWORD,
     reserved: DWORD,
-) callconv(WINAPI) LSTATUS;
+) callconv(.winapi) LSTATUS;
diff --git a/zig/lib/std/os/windows/crypt32.zig b/zig/lib/std/os/windows/crypt32.zig
index 9500d4b261..37d8110405 100644
--- a/zig/lib/std/os/windows/crypt32.zig
+++ b/zig/lib/std/os/windows/crypt32.zig
@@ -4,7 +4,6 @@ const BOOL = windows.BOOL;
 const DWORD = windows.DWORD;
 const BYTE = windows.BYTE;
 const LPCWSTR = windows.LPCWSTR;
-const WINAPI = windows.WINAPI;
 
 pub const CERT_INFO = *opaque {};
 pub const HCERTSTORE = *opaque {};
@@ -19,14 +18,14 @@ pub const CERT_CONTEXT = extern struct {
 pub extern "crypt32" fn CertOpenSystemStoreW(
     _: ?*const anyopaque,
     szSubsystemProtocol: LPCWSTR,
-) callconv(WINAPI) ?HCERTSTORE;
+) callconv(.winapi) ?HCERTSTORE;
 
 pub extern "crypt32" fn CertCloseStore(
     hCertStore: HCERTSTORE,
     dwFlags: DWORD,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "crypt32" fn CertEnumCertificatesInStore(
     hCertStore: HCERTSTORE,
     pPrevCertContext: ?*CERT_CONTEXT,
-) callconv(WINAPI) ?*CERT_CONTEXT;
+) callconv(.winapi) ?*CERT_CONTEXT;
diff --git a/zig/lib/std/os/windows/kernel32.zig b/zig/lib/std/os/windows/kernel32.zig
index b8ae72af55..f2da7957a8 100644
--- a/zig/lib/std/os/windows/kernel32.zig
+++ b/zig/lib/std/os/windows/kernel32.zig
@@ -41,7 +41,6 @@ const VECTORED_EXCEPTION_HANDLER = windows.VECTORED_EXCEPTION_HANDLER;
 const WCHAR = windows.WCHAR;
 const WIN32_FIND_DATAW = windows.WIN32_FIND_DATAW;
 const Win32Error = windows.Win32Error;
-const WINAPI = windows.WINAPI;
 const WORD = windows.WORD;
 
 // I/O - Filesystem
@@ -55,18 +54,18 @@ pub extern "kernel32" fn ReadDirectoryChangesW(
     lpBytesReturned: ?*windows.DWORD,
     lpOverlapped: ?*windows.OVERLAPPED,
     lpCompletionRoutine: windows.LPOVERLAPPED_COMPLETION_ROUTINE,
-) callconv(windows.WINAPI) windows.BOOL;
+) callconv(.winapi) windows.BOOL;
 
 // TODO: Wrapper around NtCancelIoFile.
 pub extern "kernel32" fn CancelIo(
     hFile: HANDLE,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around NtCancelIoFileEx.
 pub extern "kernel32" fn CancelIoEx(
     hFile: HANDLE,
     lpOverlapped: ?*OVERLAPPED,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn CreateFileW(
     lpFileName: LPCWSTR,
@@ -76,7 +75,7 @@ pub extern "kernel32" fn CreateFileW(
     dwCreationDisposition: DWORD,
     dwFlagsAndAttributes: DWORD,
     hTemplateFile: ?HANDLE,
-) callconv(WINAPI) HANDLE;
+) callconv(.winapi) HANDLE;
 
 // TODO A bunch of logic around NtCreateNamedPipe
 pub extern "kernel32" fn CreateNamedPipeW(
@@ -88,16 +87,16 @@ pub extern "kernel32" fn CreateNamedPipeW(
     nInBufferSize: DWORD,
     nDefaultTimeOut: DWORD,
     lpSecurityAttributes: ?*const SECURITY_ATTRIBUTES,
-) callconv(WINAPI) HANDLE;
+) callconv(.winapi) HANDLE;
 
 pub extern "kernel32" fn FindFirstFileW(
     lpFileName: LPCWSTR,
     lpFindFileData: *WIN32_FIND_DATAW,
-) callconv(WINAPI) HANDLE;
+) callconv(.winapi) HANDLE;
 
 pub extern "kernel32" fn FindClose(
     hFindFile: HANDLE,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around RtlGetFullPathName_UEx
 pub extern "kernel32" fn GetFullPathNameW(
@@ -105,18 +104,18 @@ pub extern "kernel32" fn GetFullPathNameW(
     nBufferLength: DWORD,
     lpBuffer: LPWSTR,
     lpFilePart: ?*?LPWSTR,
-) callconv(WINAPI) DWORD;
+) callconv(.winapi) DWORD;
 
 // TODO: Matches `STD_*_HANDLE` to peb().ProcessParameters.Standard*
 pub extern "kernel32" fn GetStdHandle(
     nStdHandle: DWORD,
-) callconv(WINAPI) ?HANDLE;
+) callconv(.winapi) ?HANDLE;
 
 pub extern "kernel32" fn MoveFileExW(
     lpExistingFileName: LPCWSTR,
     lpNewFileName: LPCWSTR,
     dwFlags: DWORD,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around NtSetInformationFile + `FILE_POSITION_INFORMATION`.
 //  `FILE_STANDARD_INFORMATION` is also used if dwMoveMethod is `FILE_END`
@@ -125,7 +124,7 @@ pub extern "kernel32" fn SetFilePointerEx(
     liDistanceToMove: LARGE_INTEGER,
     lpNewFilePointer: ?*LARGE_INTEGER,
     dwMoveMethod: DWORD,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around NtSetInformationFile + `FILE_BASIC_INFORMATION`
 pub extern "kernel32" fn SetFileTime(
@@ -133,7 +132,7 @@ pub extern "kernel32" fn SetFileTime(
     lpCreationTime: ?*const FILETIME,
     lpLastAccessTime: ?*const FILETIME,
     lpLastWriteTime: ?*const FILETIME,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn WriteFile(
     in_hFile: HANDLE,
@@ -141,35 +140,35 @@ pub extern "kernel32" fn WriteFile(
     in_nNumberOfBytesToWrite: DWORD,
     out_lpNumberOfBytesWritten: ?*DWORD,
     in_out_lpOverlapped: ?*OVERLAPPED,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: wrapper for NtQueryInformationFile + `FILE_STANDARD_INFORMATION`
 pub extern "kernel32" fn GetFileSizeEx(
     hFile: HANDLE,
     lpFileSize: *LARGE_INTEGER,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around GetStdHandle + NtFlushBuffersFile.
 pub extern "kernel32" fn FlushFileBuffers(
     hFile: HANDLE,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around NtSetInformationFile + `FILE_IO_COMPLETION_NOTIFICATION_INFORMATION`.
 pub extern "kernel32" fn SetFileCompletionNotificationModes(
     FileHandle: HANDLE,
     Flags: UCHAR,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: `RtlGetCurrentDirectory_U(nBufferLength * 2, lpBuffer)`
 pub extern "kernel32" fn GetCurrentDirectoryW(
     nBufferLength: DWORD,
     lpBuffer: ?[*]WCHAR,
-) callconv(WINAPI) DWORD;
+) callconv(.winapi) DWORD;
 
 // TODO: RtlDosPathNameToNtPathNameU_WithStatus + NtQueryAttributesFile.
 pub extern "kernel32" fn GetFileAttributesW(
     lpFileName: LPCWSTR,
-) callconv(WINAPI) DWORD;
+) callconv(.winapi) DWORD;
 
 pub extern "kernel32" fn ReadFile(
     hFile: HANDLE,
@@ -177,12 +176,12 @@ pub extern "kernel32" fn ReadFile(
     nNumberOfBytesToRead: DWORD,
     lpNumberOfBytesRead: ?*DWORD,
     lpOverlapped: ?*OVERLAPPED,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn GetSystemDirectoryW(
     lpBuffer: LPWSTR,
     uSize: UINT,
-) callconv(WINAPI) UINT;
+) callconv(.winapi) UINT;
 
 // I/O - Kernel Objects
 
@@ -192,7 +191,7 @@ pub extern "kernel32" fn CreateEventExW(
     lpName: ?LPCWSTR,
     dwFlags: DWORD,
     dwDesiredAccess: DWORD,
-) callconv(WINAPI) ?HANDLE;
+) callconv(.winapi) ?HANDLE;
 
 // TODO: Wrapper around GetStdHandle + NtDuplicateObject.
 pub extern "kernel32" fn DuplicateHandle(
@@ -203,14 +202,14 @@ pub extern "kernel32" fn DuplicateHandle(
     dwDesiredAccess: DWORD,
     bInheritHandle: BOOL,
     dwOptions: DWORD,
-) callconv(WINAPI) BOOL;
+) 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;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around NtRemoveIoCompletion.
 pub extern "kernel32" fn GetQueuedCompletionStatus(
@@ -219,7 +218,7 @@ pub extern "kernel32" fn GetQueuedCompletionStatus(
     lpCompletionKey: *ULONG_PTR,
     lpOverlapped: *?*OVERLAPPED,
     dwMilliseconds: DWORD,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around NtRemoveIoCompletionEx.
 pub extern "kernel32" fn GetQueuedCompletionStatusEx(
@@ -229,7 +228,7 @@ pub extern "kernel32" fn GetQueuedCompletionStatusEx(
     ulNumEntriesRemoved: *ULONG,
     dwMilliseconds: DWORD,
     fAlertable: BOOL,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around NtSetIoCompletion with `IoStatus = .SUCCESS`.
 pub extern "kernel32" fn PostQueuedCompletionStatus(
@@ -237,7 +236,7 @@ pub extern "kernel32" fn PostQueuedCompletionStatus(
     dwNumberOfBytesTransferred: DWORD,
     dwCompletionKey: ULONG_PTR,
     lpOverlapped: ?*OVERLAPPED,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO:
 // GetOverlappedResultEx with bAlertable=false, which calls: GetStdHandle + WaitForSingleObjectEx.
@@ -247,7 +246,7 @@ pub extern "kernel32" fn GetOverlappedResult(
     lpOverlapped: *OVERLAPPED,
     lpNumberOfBytesTransferred: *DWORD,
     bWait: BOOL,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around NtCreateIoCompletion + NtSetInformationFile with FILE_COMPLETION_INFORMATION.
 // This would be better splitting into two functions.
@@ -256,30 +255,30 @@ pub extern "kernel32" fn CreateIoCompletionPort(
     ExistingCompletionPort: ?HANDLE,
     CompletionKey: ULONG_PTR,
     NumberOfConcurrentThreads: DWORD,
-) callconv(WINAPI) ?HANDLE;
+) callconv(.winapi) ?HANDLE;
 
 // TODO: Forwarder to NtAddVectoredExceptionHandler.
 pub extern "kernel32" fn AddVectoredExceptionHandler(
     First: ULONG,
     Handler: ?VECTORED_EXCEPTION_HANDLER,
-) callconv(WINAPI) ?LPVOID;
+) callconv(.winapi) ?LPVOID;
 
 // TODO: Forwarder to NtRemoveVectoredExceptionHandler.
 pub extern "kernel32" fn RemoveVectoredExceptionHandler(
     Handle: HANDLE,
-) callconv(WINAPI) ULONG;
+) callconv(.winapi) ULONG;
 
 // TODO: Wrapper around RtlReportSilentProcessExit + NtTerminateProcess.
 pub extern "kernel32" fn TerminateProcess(
     hProcess: HANDLE,
     uExitCode: UINT,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: WaitForSingleObjectEx with bAlertable=false.
 pub extern "kernel32" fn WaitForSingleObject(
     hHandle: HANDLE,
     dwMilliseconds: DWORD,
-) callconv(WINAPI) DWORD;
+) callconv(.winapi) DWORD;
 
 // TODO: Wrapper for GetStdHandle + NtWaitForSingleObject.
 // Sets up an activation context before calling NtWaitForSingleObject.
@@ -287,7 +286,7 @@ pub extern "kernel32" fn WaitForSingleObjectEx(
     hHandle: HANDLE,
     dwMilliseconds: DWORD,
     bAlertable: BOOL,
-) callconv(WINAPI) DWORD;
+) callconv(.winapi) DWORD;
 
 // TODO: WaitForMultipleObjectsEx with alertable=false
 pub extern "kernel32" fn WaitForMultipleObjects(
@@ -295,7 +294,7 @@ pub extern "kernel32" fn WaitForMultipleObjects(
     lpHandle: [*]const HANDLE,
     bWaitAll: BOOL,
     dwMilliseconds: DWORD,
-) callconv(WINAPI) DWORD;
+) callconv(.winapi) DWORD;
 
 // TODO: Wrapper around NtWaitForMultipleObjects.
 pub extern "kernel32" fn WaitForMultipleObjectsEx(
@@ -304,7 +303,7 @@ pub extern "kernel32" fn WaitForMultipleObjectsEx(
     bWaitAll: BOOL,
     dwMilliseconds: DWORD,
     bAlertable: BOOL,
-) callconv(WINAPI) DWORD;
+) callconv(.winapi) DWORD;
 
 // Process Management
 
@@ -319,57 +318,57 @@ pub extern "kernel32" fn CreateProcessW(
     lpCurrentDirectory: ?LPCWSTR,
     lpStartupInfo: *STARTUPINFOW,
     lpProcessInformation: *PROCESS_INFORMATION,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Fowarder to RtlExitUserProcess.
 pub extern "kernel32" fn ExitProcess(
     exit_code: UINT,
-) callconv(WINAPI) noreturn;
+) callconv(.winapi) noreturn;
 
 // TODO: SleepEx with bAlertable=false.
 pub extern "kernel32" fn Sleep(
     dwMilliseconds: DWORD,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 // TODO: Wrapper around NtQueryInformationProcess with `PROCESS_BASIC_INFORMATION`.
 pub extern "kernel32" fn GetExitCodeProcess(
     hProcess: HANDLE,
     lpExitCode: *DWORD,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Already a wrapper for this, see `windows.GetCurrentProcess`.
-pub extern "kernel32" fn GetCurrentProcess() callconv(WINAPI) HANDLE;
+pub extern "kernel32" fn GetCurrentProcess() callconv(.winapi) HANDLE;
 
 // TODO: memcpy peb().ProcessParameters.Environment, mem.span(0). Requires locking the PEB.
-pub extern "kernel32" fn GetEnvironmentStringsW() callconv(WINAPI) ?LPWSTR;
+pub extern "kernel32" fn GetEnvironmentStringsW() callconv(.winapi) ?LPWSTR;
 
 // TODO: RtlFreeHeap on the output of GetEnvironmentStringsW.
 pub extern "kernel32" fn FreeEnvironmentStringsW(
     penv: LPWSTR,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around RtlQueryEnvironmentVariable.
 pub extern "kernel32" fn GetEnvironmentVariableW(
     lpName: ?LPCWSTR,
     lpBuffer: ?[*]WCHAR,
     nSize: DWORD,
-) callconv(WINAPI) DWORD;
+) callconv(.winapi) DWORD;
 
 // TODO: Wrapper around RtlSetEnvironmentVar.
 pub extern "kernel32" fn SetEnvironmentVariableW(
     lpName: LPCWSTR,
     lpValue: ?LPCWSTR,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn CreateToolhelp32Snapshot(
     dwFlags: DWORD,
     th32ProcessID: DWORD,
-) callconv(WINAPI) HANDLE;
+) callconv(.winapi) HANDLE;
 
 // Threading
 
 // TODO: Already a wrapper for this, see `windows.GetCurrentThreadId`.
-pub extern "kernel32" fn GetCurrentThreadId() callconv(WINAPI) DWORD;
+pub extern "kernel32" fn GetCurrentThreadId() callconv(.winapi) DWORD;
 
 // TODO: CreateRemoteThread with hProcess=NtCurrentProcess().
 pub extern "kernel32" fn CreateThread(
@@ -379,64 +378,64 @@ pub extern "kernel32" fn CreateThread(
     lpParameter: ?LPVOID,
     dwCreationFlags: DWORD,
     lpThreadId: ?*DWORD,
-) callconv(WINAPI) ?HANDLE;
+) callconv(.winapi) ?HANDLE;
 
 // TODO: Wrapper around RtlDelayExecution.
-pub extern "kernel32" fn SwitchToThread() callconv(WINAPI) BOOL;
+pub extern "kernel32" fn SwitchToThread() callconv(.winapi) BOOL;
 
 // Locks, critical sections, initializers
 
 // TODO: Forwarder to RtlInitializeCriticalSection
 pub extern "kernel32" fn InitializeCriticalSection(
     lpCriticalSection: *CRITICAL_SECTION,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 // TODO: Forwarder to RtlEnterCriticalSection
 pub extern "kernel32" fn EnterCriticalSection(
     lpCriticalSection: *CRITICAL_SECTION,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 // TODO: Forwarder to RtlLeaveCriticalSection
 pub extern "kernel32" fn LeaveCriticalSection(
     lpCriticalSection: *CRITICAL_SECTION,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 // TODO: Forwarder to RtlDeleteCriticalSection
 pub extern "kernel32" fn DeleteCriticalSection(
     lpCriticalSection: *CRITICAL_SECTION,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 // TODO: Forwarder to RtlTryAcquireSRWLockExclusive
 pub extern "kernel32" fn TryAcquireSRWLockExclusive(
     SRWLock: *SRWLOCK,
-) callconv(WINAPI) BOOLEAN;
+) callconv(.winapi) BOOLEAN;
 
 // TODO: Forwarder to RtlAcquireSRWLockExclusive
 pub extern "kernel32" fn AcquireSRWLockExclusive(
     SRWLock: *SRWLOCK,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 // TODO: Forwarder to RtlReleaseSRWLockExclusive
 pub extern "kernel32" fn ReleaseSRWLockExclusive(
     SRWLock: *SRWLOCK,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 pub extern "kernel32" fn InitOnceExecuteOnce(
     InitOnce: *INIT_ONCE,
     InitFn: INIT_ONCE_FN,
     Parameter: ?*anyopaque,
     Context: ?*anyopaque,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Forwarder to RtlWakeConditionVariable
 pub extern "kernel32" fn WakeConditionVariable(
     ConditionVariable: *CONDITION_VARIABLE,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 // TODO: Forwarder to RtlWakeAllConditionVariable
 pub extern "kernel32" fn WakeAllConditionVariable(
     ConditionVariable: *CONDITION_VARIABLE,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 // TODO:
 //  - dwMilliseconds -> LARGE_INTEGER.
@@ -447,40 +446,40 @@ pub extern "kernel32" fn SleepConditionVariableSRW(
     SRWLock: *SRWLOCK,
     dwMilliseconds: DWORD,
     Flags: ULONG,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // Console management
 
 pub extern "kernel32" fn GetConsoleMode(
     hConsoleHandle: HANDLE,
     lpMode: *DWORD,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn SetConsoleMode(
     hConsoleHandle: HANDLE,
     dwMode: DWORD,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn GetConsoleScreenBufferInfo(
     hConsoleOutput: HANDLE,
     lpConsoleScreenBufferInfo: *CONSOLE_SCREEN_BUFFER_INFO,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn SetConsoleTextAttribute(
     hConsoleOutput: HANDLE,
     wAttributes: WORD,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn SetConsoleCtrlHandler(
     HandlerRoutine: ?HANDLER_ROUTINE,
     Add: BOOL,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn SetConsoleOutputCP(
     wCodePageID: UINT,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
-pub extern "kernel32" fn GetConsoleOutputCP() callconv(WINAPI) UINT;
+pub extern "kernel32" fn GetConsoleOutputCP() callconv(.winapi) UINT;
 
 pub extern "kernel32" fn FillConsoleOutputAttribute(
     hConsoleOutput: HANDLE,
@@ -488,7 +487,7 @@ pub extern "kernel32" fn FillConsoleOutputAttribute(
     nLength: DWORD,
     dwWriteCoord: COORD,
     lpNumberOfAttrsWritten: *DWORD,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn FillConsoleOutputCharacterW(
     hConsoleOutput: HANDLE,
@@ -496,12 +495,12 @@ pub extern "kernel32" fn FillConsoleOutputCharacterW(
     nLength: DWORD,
     dwWriteCoord: COORD,
     lpNumberOfCharsWritten: *DWORD,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn SetConsoleCursorPosition(
     hConsoleOutput: HANDLE,
     dwCursorPosition: COORD,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn WriteConsoleW(
     hConsoleOutput: HANDLE,
@@ -509,7 +508,7 @@ pub extern "kernel32" fn WriteConsoleW(
     nNumberOfCharsToWrite: DWORD,
     lpNumberOfCharsWritten: ?*DWORD,
     lpReserved: ?LPVOID,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn ReadConsoleOutputCharacterW(
     hConsoleOutput: HANDLE,
@@ -517,7 +516,7 @@ pub extern "kernel32" fn ReadConsoleOutputCharacterW(
     nLength: DWORD,
     dwReadCoord: COORD,
     lpNumberOfCharsRead: *DWORD,
-) callconv(windows.WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // Memory Mapping/Allocation
 
@@ -526,12 +525,12 @@ pub extern "kernel32" fn HeapCreate(
     flOptions: DWORD,
     dwInitialSize: SIZE_T,
     dwMaximumSize: SIZE_T,
-) callconv(WINAPI) ?HANDLE;
+) callconv(.winapi) ?HANDLE;
 
 // TODO: Wrapper around RtlDestroyHeap (BOOLEAN -> BOOL).
 pub extern "kernel32" fn HeapDestroy(
     hHeap: HANDLE,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Forwarder to RtlReAllocateHeap.
 pub extern "kernel32" fn HeapReAlloc(
@@ -539,28 +538,28 @@ pub extern "kernel32" fn HeapReAlloc(
     dwFlags: DWORD,
     lpMem: *anyopaque,
     dwBytes: SIZE_T,
-) callconv(WINAPI) ?*anyopaque;
+) callconv(.winapi) ?*anyopaque;
 
 // TODO: Fowrarder to RtlAllocateHeap.
 pub extern "kernel32" fn HeapAlloc(
     hHeap: HANDLE,
     dwFlags: DWORD,
     dwBytes: SIZE_T,
-) callconv(WINAPI) ?*anyopaque;
+) callconv(.winapi) ?*anyopaque;
 
 // TODO: Fowrarder to RtlFreeHeap.
 pub extern "kernel32" fn HeapFree(
     hHeap: HANDLE,
     dwFlags: DWORD,
     lpMem: LPVOID,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around RtlValidateHeap (BOOLEAN -> BOOL)
 pub extern "kernel32" fn HeapValidate(
     hHeap: HANDLE,
     dwFlags: DWORD,
     lpMem: ?*const anyopaque,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around NtAllocateVirtualMemory.
 pub extern "kernel32" fn VirtualAlloc(
@@ -568,7 +567,7 @@ pub extern "kernel32" fn VirtualAlloc(
     dwSize: SIZE_T,
     flAllocationType: DWORD,
     flProtect: DWORD,
-) callconv(WINAPI) ?LPVOID;
+) callconv(.winapi) ?LPVOID;
 
 // TODO: Wrapper around NtFreeVirtualMemory.
 // If the return value is .INVALID_PAGE_PROTECTION, calls RtlFlushSecureMemoryCache and try again.
@@ -576,21 +575,21 @@ pub extern "kernel32" fn VirtualFree(
     lpAddress: ?LPVOID,
     dwSize: SIZE_T,
     dwFreeType: DWORD,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // TODO: Wrapper around NtQueryVirtualMemory.
 pub extern "kernel32" fn VirtualQuery(
     lpAddress: ?LPVOID,
     lpBuffer: PMEMORY_BASIC_INFORMATION,
     dwLength: SIZE_T,
-) callconv(WINAPI) SIZE_T;
+) callconv(.winapi) SIZE_T;
 
 pub extern "kernel32" fn LocalFree(
     hMem: HLOCAL,
-) callconv(WINAPI) ?HLOCAL;
+) callconv(.winapi) ?HLOCAL;
 
 // TODO: Getter for peb.ProcessHeap
-pub extern "kernel32" fn GetProcessHeap() callconv(WINAPI) ?HANDLE;
+pub extern "kernel32" fn GetProcessHeap() callconv(.winapi) ?HANDLE;
 
 // Code Libraries/Modules
 
@@ -599,49 +598,49 @@ pub extern "kernel32" fn GetModuleFileNameW(
     hModule: ?HMODULE,
     lpFilename: [*]WCHAR,
     nSize: DWORD,
-) callconv(WINAPI) DWORD;
+) callconv(.winapi) DWORD;
 
 extern "kernel32" fn K32GetModuleFileNameExW(
     hProcess: HANDLE,
     hModule: ?HMODULE,
     lpFilename: LPWSTR,
     nSize: DWORD,
-) callconv(WINAPI) 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;
+) callconv(.winapi) ?HMODULE;
 
 pub extern "kernel32" fn Module32First(
     hSnapshot: HANDLE,
     lpme: *MODULEENTRY32,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn Module32Next(
     hSnapshot: HANDLE,
     lpme: *MODULEENTRY32,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "kernel32" fn LoadLibraryW(
     lpLibFileName: LPCWSTR,
-) callconv(WINAPI) ?HMODULE;
+) callconv(.winapi) ?HMODULE;
 
 pub extern "kernel32" fn LoadLibraryExW(
     lpLibFileName: LPCWSTR,
     hFile: ?HANDLE,
     dwFlags: DWORD,
-) callconv(WINAPI) ?HMODULE;
+) callconv(.winapi) ?HMODULE;
 
 pub extern "kernel32" fn GetProcAddress(
     hModule: HMODULE,
     lpProcName: LPCSTR,
-) callconv(WINAPI) ?FARPROC;
+) callconv(.winapi) ?FARPROC;
 
 pub extern "kernel32" fn FreeLibrary(
     hModule: HMODULE,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 // Error Management
 
@@ -653,15 +652,15 @@ pub extern "kernel32" fn FormatMessageW(
     lpBuffer: LPWSTR,
     nSize: DWORD,
     Arguments: ?*va_list,
-) callconv(WINAPI) DWORD;
+) callconv(.winapi) DWORD;
 
 // TODO: Getter for teb().LastErrorValue.
-pub extern "kernel32" fn GetLastError() callconv(WINAPI) Win32Error;
+pub extern "kernel32" fn GetLastError() callconv(.winapi) Win32Error;
 
 // TODO: Wrapper around RtlSetLastWin32Error.
 pub extern "kernel32" fn SetLastError(
     dwErrCode: Win32Error,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 // Everything Else
 
@@ -670,4 +669,4 @@ pub extern "kernel32" fn SetLastError(
 //  Much better to use NtQuerySystemTime or NtQuerySystemTimePrecise for guaranteed 0.1ns precision.
 pub extern "kernel32" fn GetSystemTimeAsFileTime(
     lpSystemTimeAsFileTime: *FILETIME,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
diff --git a/zig/lib/std/os/windows/ntdll.zig b/zig/lib/std/os/windows/ntdll.zig
index 4683b1e887..b4c33a2e2d 100644
--- a/zig/lib/std/os/windows/ntdll.zig
+++ b/zig/lib/std/os/windows/ntdll.zig
@@ -5,7 +5,6 @@ const BOOL = windows.BOOL;
 const DWORD = windows.DWORD;
 const DWORD64 = windows.DWORD64;
 const ULONG = windows.ULONG;
-const WINAPI = windows.WINAPI;
 const NTSTATUS = windows.NTSTATUS;
 const WORD = windows.WORD;
 const HANDLE = windows.HANDLE;
@@ -44,7 +43,7 @@ pub extern "ntdll" fn NtQueryInformationProcess(
     ProcessInformation: *anyopaque,
     ProcessInformationLength: ULONG,
     ReturnLength: ?*ULONG,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtQueryInformationThread(
     ThreadHandle: HANDLE,
@@ -52,37 +51,37 @@ pub extern "ntdll" fn NtQueryInformationThread(
     ThreadInformation: *anyopaque,
     ThreadInformationLength: ULONG,
     ReturnLength: ?*ULONG,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtQuerySystemInformation(
     SystemInformationClass: SYSTEM_INFORMATION_CLASS,
     SystemInformation: PVOID,
     SystemInformationLength: ULONG,
     ReturnLength: ?*ULONG,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtSetInformationThread(
     ThreadHandle: HANDLE,
     ThreadInformationClass: THREADINFOCLASS,
     ThreadInformation: *const anyopaque,
     ThreadInformationLength: ULONG,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn RtlGetVersion(
     lpVersionInformation: *RTL_OSVERSIONINFOW,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 pub extern "ntdll" fn RtlCaptureStackBackTrace(
     FramesToSkip: DWORD,
     FramesToCapture: DWORD,
     BackTrace: **anyopaque,
     BackTraceHash: ?*DWORD,
-) callconv(WINAPI) WORD;
-pub extern "ntdll" fn RtlCaptureContext(ContextRecord: *CONTEXT) callconv(WINAPI) void;
+) callconv(.winapi) WORD;
+pub extern "ntdll" fn RtlCaptureContext(ContextRecord: *CONTEXT) callconv(.winapi) void;
 pub extern "ntdll" fn RtlLookupFunctionEntry(
     ControlPc: DWORD64,
     ImageBase: *DWORD64,
     HistoryTable: *UNWIND_HISTORY_TABLE,
-) callconv(WINAPI) ?*RUNTIME_FUNCTION;
+) callconv(.winapi) ?*RUNTIME_FUNCTION;
 pub extern "ntdll" fn RtlVirtualUnwind(
     HandlerType: DWORD,
     ImageBase: DWORD64,
@@ -92,33 +91,33 @@ pub extern "ntdll" fn RtlVirtualUnwind(
     HandlerData: *?PVOID,
     EstablisherFrame: *DWORD64,
     ContextPointers: ?*KNONVOLATILE_CONTEXT_POINTERS,
-) callconv(WINAPI) *EXCEPTION_ROUTINE;
+) callconv(.winapi) *EXCEPTION_ROUTINE;
 pub extern "ntdll" fn NtQueryInformationFile(
     FileHandle: HANDLE,
     IoStatusBlock: *IO_STATUS_BLOCK,
     FileInformation: *anyopaque,
     Length: ULONG,
     FileInformationClass: FILE_INFORMATION_CLASS,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 pub extern "ntdll" fn NtSetInformationFile(
     FileHandle: HANDLE,
     IoStatusBlock: *IO_STATUS_BLOCK,
     FileInformation: PVOID,
     Length: ULONG,
     FileInformationClass: FILE_INFORMATION_CLASS,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtQueryAttributesFile(
     ObjectAttributes: *OBJECT_ATTRIBUTES,
     FileAttributes: *FILE_BASIC_INFORMATION,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
-pub extern "ntdll" fn RtlQueryPerformanceCounter(PerformanceCounter: *LARGE_INTEGER) callconv(WINAPI) BOOL;
-pub extern "ntdll" fn RtlQueryPerformanceFrequency(PerformanceFrequency: *LARGE_INTEGER) callconv(WINAPI) BOOL;
+pub extern "ntdll" fn RtlQueryPerformanceCounter(PerformanceCounter: *LARGE_INTEGER) callconv(.winapi) BOOL;
+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;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtCreateFile(
     FileHandle: *HANDLE,
@@ -132,7 +131,7 @@ pub extern "ntdll" fn NtCreateFile(
     CreateOptions: ULONG,
     EaBuffer: ?*anyopaque,
     EaLength: ULONG,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 pub extern "ntdll" fn NtCreateSection(
     SectionHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
@@ -141,7 +140,7 @@ pub extern "ntdll" fn NtCreateSection(
     SectionPageProtection: ULONG,
     AllocationAttributes: ULONG,
     FileHandle: ?HANDLE,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 pub extern "ntdll" fn NtMapViewOfSection(
     SectionHandle: HANDLE,
     ProcessHandle: HANDLE,
@@ -153,11 +152,11 @@ pub extern "ntdll" fn NtMapViewOfSection(
     InheritDispostion: SECTION_INHERIT,
     AllocationType: ULONG,
     Win32Protect: ULONG,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 pub extern "ntdll" fn NtUnmapViewOfSection(
     ProcessHandle: HANDLE,
     BaseAddress: PVOID,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 pub extern "ntdll" fn NtDeviceIoControlFile(
     FileHandle: HANDLE,
     Event: ?HANDLE,
@@ -169,7 +168,7 @@ pub extern "ntdll" fn NtDeviceIoControlFile(
     InputBufferLength: ULONG,
     OutputBuffer: ?PVOID,
     OutputBufferLength: ULONG,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 pub extern "ntdll" fn NtFsControlFile(
     FileHandle: HANDLE,
     Event: ?HANDLE,
@@ -181,15 +180,15 @@ pub extern "ntdll" fn NtFsControlFile(
     InputBufferLength: ULONG,
     OutputBuffer: ?PVOID,
     OutputBufferLength: ULONG,
-) callconv(WINAPI) NTSTATUS;
-pub extern "ntdll" fn NtClose(Handle: HANDLE) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
+pub extern "ntdll" fn NtClose(Handle: HANDLE) callconv(.winapi) NTSTATUS;
 pub extern "ntdll" fn RtlDosPathNameToNtPathName_U(
     DosPathName: [*:0]const u16,
     NtPathName: *UNICODE_STRING,
     NtFileNamePart: ?*?[*:0]const u16,
     DirectoryInfo: ?*CURDIR,
-) callconv(WINAPI) BOOL;
-pub extern "ntdll" fn RtlFreeUnicodeString(UnicodeString: *UNICODE_STRING) callconv(WINAPI) void;
+) callconv(.winapi) BOOL;
+pub extern "ntdll" fn RtlFreeUnicodeString(UnicodeString: *UNICODE_STRING) callconv(.winapi) void;
 
 /// Returns the number of bytes written to `Buffer`.
 /// If the returned count is larger than `BufferByteLength`, the buffer was too small.
@@ -199,7 +198,7 @@ pub extern "ntdll" fn RtlGetFullPathName_U(
     BufferByteLength: ULONG,
     Buffer: [*]u16,
     ShortName: ?*[*:0]const u16,
-) callconv(windows.WINAPI) windows.ULONG;
+) callconv(.winapi) windows.ULONG;
 
 pub extern "ntdll" fn NtQueryDirectoryFile(
     FileHandle: HANDLE,
@@ -213,30 +212,30 @@ pub extern "ntdll" fn NtQueryDirectoryFile(
     ReturnSingleEntry: BOOLEAN,
     FileName: ?*UNICODE_STRING,
     RestartScan: BOOLEAN,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtCreateKeyedEvent(
     KeyedEventHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
     ObjectAttributes: ?PVOID,
     Flags: ULONG,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtReleaseKeyedEvent(
     EventHandle: ?HANDLE,
     Key: ?*const anyopaque,
     Alertable: BOOLEAN,
     Timeout: ?*const LARGE_INTEGER,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtWaitForKeyedEvent(
     EventHandle: ?HANDLE,
     Key: ?*const anyopaque,
     Alertable: BOOLEAN,
     Timeout: ?*const LARGE_INTEGER,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
-pub extern "ntdll" fn RtlSetCurrentDirectory_U(PathName: *UNICODE_STRING) callconv(WINAPI) NTSTATUS;
+pub extern "ntdll" fn RtlSetCurrentDirectory_U(PathName: *UNICODE_STRING) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtQueryObject(
     Handle: HANDLE,
@@ -244,7 +243,7 @@ pub extern "ntdll" fn NtQueryObject(
     ObjectInformation: PVOID,
     ObjectInformationLength: ULONG,
     ReturnLength: ?*ULONG,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtQueryVolumeInformationFile(
     FileHandle: HANDLE,
@@ -252,32 +251,32 @@ pub extern "ntdll" fn NtQueryVolumeInformationFile(
     FsInformation: *anyopaque,
     Length: ULONG,
     FsInformationClass: FS_INFORMATION_CLASS,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn RtlWakeAddressAll(
     Address: ?*const anyopaque,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 pub extern "ntdll" fn RtlWakeAddressSingle(
     Address: ?*const anyopaque,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 pub extern "ntdll" fn RtlWaitOnAddress(
     Address: ?*const anyopaque,
     CompareAddress: ?*const anyopaque,
     AddressSize: SIZE_T,
     Timeout: ?*const LARGE_INTEGER,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn RtlEqualUnicodeString(
     String1: *const UNICODE_STRING,
     String2: *const UNICODE_STRING,
     CaseInSensitive: BOOLEAN,
-) callconv(WINAPI) BOOLEAN;
+) callconv(.winapi) BOOLEAN;
 
 pub extern "ntdll" fn RtlUpcaseUnicodeChar(
     SourceCharacter: u16,
-) callconv(WINAPI) u16;
+) callconv(.winapi) u16;
 
 pub extern "ntdll" fn NtLockFile(
     FileHandle: HANDLE,
@@ -290,7 +289,7 @@ pub extern "ntdll" fn NtLockFile(
     Key: ?*ULONG,
     FailImmediately: BOOLEAN,
     ExclusiveLock: BOOLEAN,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtUnlockFile(
     FileHandle: HANDLE,
@@ -298,13 +297,13 @@ pub extern "ntdll" fn NtUnlockFile(
     ByteOffset: *const LARGE_INTEGER,
     Length: *const LARGE_INTEGER,
     Key: ?*ULONG,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtOpenKey(
     KeyHandle: *HANDLE,
     DesiredAccess: ACCESS_MASK,
     ObjectAttributes: OBJECT_ATTRIBUTES,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn RtlQueryRegistryValues(
     RelativeTo: ULONG,
@@ -312,7 +311,7 @@ pub extern "ntdll" fn RtlQueryRegistryValues(
     QueryTable: [*]RTL_QUERY_REGISTRY_TABLE,
     Context: ?*anyopaque,
     Environment: ?*anyopaque,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtReadVirtualMemory(
     ProcessHandle: HANDLE,
@@ -320,7 +319,7 @@ pub extern "ntdll" fn NtReadVirtualMemory(
     Buffer: LPVOID,
     NumberOfBytesToRead: SIZE_T,
     NumberOfBytesRead: ?*SIZE_T,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtWriteVirtualMemory(
     ProcessHandle: HANDLE,
@@ -328,7 +327,7 @@ pub extern "ntdll" fn NtWriteVirtualMemory(
     Buffer: LPCVOID,
     NumberOfBytesToWrite: SIZE_T,
     NumberOfBytesWritten: ?*SIZE_T,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn NtProtectVirtualMemory(
     ProcessHandle: HANDLE,
@@ -336,11 +335,11 @@ pub extern "ntdll" fn NtProtectVirtualMemory(
     NumberOfBytesToProtect: *SIZE_T,
     NewAccessProtection: ULONG,
     OldAccessProtection: *ULONG,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
 
 pub extern "ntdll" fn RtlExitUserProcess(
     ExitStatus: u32,
-) callconv(WINAPI) noreturn;
+) callconv(.winapi) noreturn;
 
 pub extern "ntdll" fn NtCreateNamedPipeFile(
     FileHandle: *HANDLE,
@@ -357,4 +356,4 @@ pub extern "ntdll" fn NtCreateNamedPipeFile(
     InboundQuota: ULONG,
     OutboundQuota: ULONG,
     DefaultTimeout: *LARGE_INTEGER,
-) callconv(WINAPI) NTSTATUS;
+) callconv(.winapi) NTSTATUS;
diff --git a/zig/lib/std/os/windows/test.zig b/zig/lib/std/os/windows/test.zig
index acaa7d1218..b4cecefbd7 100644
--- a/zig/lib/std/os/windows/test.zig
+++ b/zig/lib/std/os/windows/test.zig
@@ -250,7 +250,7 @@ test "loadWinsockExtensionFunction" {
         SendBufLen: windows.DWORD,
         BytesSent: *windows.DWORD,
         Overlapped: *windows.OVERLAPPED,
-    ) callconv(windows.WINAPI) windows.BOOL;
+    ) callconv(.winapi) windows.BOOL;
 
     _ = windows.loadWinsockExtensionFunction(
         LPFN_CONNECTEX,
diff --git a/zig/lib/std/os/windows/ws2_32.zig b/zig/lib/std/os/windows/ws2_32.zig
index f3a1fdca84..e8375dc2c1 100644
--- a/zig/lib/std/os/windows/ws2_32.zig
+++ b/zig/lib/std/os/windows/ws2_32.zig
@@ -2,7 +2,6 @@ const std = @import("../../std.zig");
 const assert = std.debug.assert;
 const windows = std.os.windows;
 
-const WINAPI = windows.WINAPI;
 const OVERLAPPED = windows.OVERLAPPED;
 const WORD = windows.WORD;
 const DWORD = windows.DWORD;
@@ -958,14 +957,14 @@ pub const LPCONDITIONPROC = *const fn (
     lpCalleeData: *WSABUF,
     g: *u32,
     dwCallbackData: usize,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub const LPWSAOVERLAPPED_COMPLETION_ROUTINE = *const fn (
     dwError: u32,
     cbTransferred: u32,
     lpOverlapped: *OVERLAPPED,
     dwFlags: u32,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 pub const FLOWSPEC = extern struct {
     TokenRate: u32,
@@ -1196,7 +1195,7 @@ pub const LPFN_TRANSMITFILE = *const fn (
     lpOverlapped: ?*OVERLAPPED,
     lpTransmitBuffers: ?*TRANSMIT_FILE_BUFFERS,
     dwReserved: u32,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub const LPFN_ACCEPTEX = *const fn (
     sListenSocket: SOCKET,
@@ -1207,7 +1206,7 @@ pub const LPFN_ACCEPTEX = *const fn (
     dwRemoteAddressLength: u32,
     lpdwBytesReceived: *u32,
     lpOverlapped: *OVERLAPPED,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub const LPFN_GETACCEPTEXSOCKADDRS = *const fn (
     lpOutputBuffer: *anyopaque,
@@ -1218,7 +1217,7 @@ pub const LPFN_GETACCEPTEXSOCKADDRS = *const fn (
     LocalSockaddrLength: *i32,
     RemoteSockaddr: **sockaddr,
     RemoteSockaddrLength: *i32,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 pub const LPFN_WSASENDMSG = *const fn (
     s: SOCKET,
@@ -1227,7 +1226,7 @@ pub const LPFN_WSASENDMSG = *const fn (
     lpNumberOfBytesSent: ?*u32,
     lpOverlapped: ?*OVERLAPPED,
     lpCompletionRoutine: ?LPWSAOVERLAPPED_COMPLETION_ROUTINE,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub const LPFN_WSARECVMSG = *const fn (
     s: SOCKET,
@@ -1235,12 +1234,12 @@ pub const LPFN_WSARECVMSG = *const fn (
     lpdwNumberOfBytesRecv: ?*u32,
     lpOverlapped: ?*OVERLAPPED,
     lpCompletionRoutine: ?LPWSAOVERLAPPED_COMPLETION_ROUTINE,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub const LPSERVICE_CALLBACK_PROC = *const fn (
     lParam: LPARAM,
     hAsyncTaskHandle: HANDLE,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 pub const SERVICE_ASYNC_INFO = extern struct {
     lpServiceCallbackProc: LPSERVICE_CALLBACK_PROC,
@@ -1252,7 +1251,7 @@ pub const LPLOOKUPSERVICE_COMPLETION_ROUTINE = *const fn (
     dwError: u32,
     dwBytes: u32,
     lpOverlapped: *OVERLAPPED,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 pub const fd_set = extern struct {
     fd_count: u32,
@@ -1725,41 +1724,41 @@ pub extern "ws2_32" fn accept(
     s: SOCKET,
     addr: ?*sockaddr,
     addrlen: ?*i32,
-) callconv(WINAPI) SOCKET;
+) callconv(.winapi) SOCKET;
 
 pub extern "ws2_32" fn bind(
     s: SOCKET,
     name: *const sockaddr,
     namelen: i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn closesocket(
     s: SOCKET,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn connect(
     s: SOCKET,
     name: *const sockaddr,
     namelen: i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn ioctlsocket(
     s: SOCKET,
     cmd: i32,
     argp: *u32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn getpeername(
     s: SOCKET,
     name: *sockaddr,
     namelen: *i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn getsockname(
     s: SOCKET,
     name: *sockaddr,
     namelen: *i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn getsockopt(
     s: SOCKET,
@@ -1767,39 +1766,39 @@ pub extern "ws2_32" fn getsockopt(
     optname: i32,
     optval: [*]u8,
     optlen: *i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn htonl(
     hostlong: u32,
-) callconv(WINAPI) u32;
+) callconv(.winapi) u32;
 
 pub extern "ws2_32" fn htons(
     hostshort: u16,
-) callconv(WINAPI) u16;
+) callconv(.winapi) u16;
 
 pub extern "ws2_32" fn inet_addr(
     cp: ?[*]const u8,
-) callconv(WINAPI) u32;
+) callconv(.winapi) u32;
 
 pub extern "ws2_32" fn listen(
     s: SOCKET,
     backlog: i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn ntohl(
     netlong: u32,
-) callconv(WINAPI) u32;
+) callconv(.winapi) u32;
 
 pub extern "ws2_32" fn ntohs(
     netshort: u16,
-) callconv(WINAPI) u16;
+) callconv(.winapi) u16;
 
 pub extern "ws2_32" fn recv(
     s: SOCKET,
     buf: [*]u8,
     len: i32,
     flags: i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn recvfrom(
     s: SOCKET,
@@ -1808,7 +1807,7 @@ pub extern "ws2_32" fn recvfrom(
     flags: i32,
     from: ?*sockaddr,
     fromlen: ?*i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn select(
     nfds: i32,
@@ -1816,14 +1815,14 @@ pub extern "ws2_32" fn select(
     writefds: ?*fd_set,
     exceptfds: ?*fd_set,
     timeout: ?*const timeval,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn send(
     s: SOCKET,
     buf: [*]const u8,
     len: i32,
     flags: u32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn sendto(
     s: SOCKET,
@@ -1832,7 +1831,7 @@ pub extern "ws2_32" fn sendto(
     flags: i32,
     to: *const sockaddr,
     tolen: i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn setsockopt(
     s: SOCKET,
@@ -1840,37 +1839,37 @@ pub extern "ws2_32" fn setsockopt(
     optname: i32,
     optval: ?[*]const u8,
     optlen: i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn shutdown(
     s: SOCKET,
     how: i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn socket(
     af: i32,
     @"type": i32,
     protocol: i32,
-) callconv(WINAPI) SOCKET;
+) callconv(.winapi) SOCKET;
 
 pub extern "ws2_32" fn WSAStartup(
     wVersionRequired: WORD,
     lpWSAData: *WSADATA,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
-pub extern "ws2_32" fn WSACleanup() callconv(WINAPI) i32;
+pub extern "ws2_32" fn WSACleanup() callconv(.winapi) i32;
 
-pub extern "ws2_32" fn WSASetLastError(iError: i32) callconv(WINAPI) void;
+pub extern "ws2_32" fn WSASetLastError(iError: i32) callconv(.winapi) void;
 
-pub extern "ws2_32" fn WSAGetLastError() callconv(WINAPI) WinsockError;
+pub extern "ws2_32" fn WSAGetLastError() callconv(.winapi) WinsockError;
 
-pub extern "ws2_32" fn WSAIsBlocking() callconv(WINAPI) BOOL;
+pub extern "ws2_32" fn WSAIsBlocking() callconv(.winapi) BOOL;
 
-pub extern "ws2_32" fn WSAUnhookBlockingHook() callconv(WINAPI) i32;
+pub extern "ws2_32" fn WSAUnhookBlockingHook() callconv(.winapi) i32;
 
-pub extern "ws2_32" fn WSASetBlockingHook(lpBlockFunc: FARPROC) callconv(WINAPI) FARPROC;
+pub extern "ws2_32" fn WSASetBlockingHook(lpBlockFunc: FARPROC) callconv(.winapi) FARPROC;
 
-pub extern "ws2_32" fn WSACancelBlockingCall() callconv(WINAPI) i32;
+pub extern "ws2_32" fn WSACancelBlockingCall() callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAAsyncGetServByName(
     hWnd: HWND,
@@ -1879,7 +1878,7 @@ pub extern "ws2_32" fn WSAAsyncGetServByName(
     proto: ?[*:0]const u8,
     buf: [*]u8,
     buflen: i32,
-) callconv(WINAPI) HANDLE;
+) callconv(.winapi) HANDLE;
 
 pub extern "ws2_32" fn WSAAsyncGetServByPort(
     hWnd: HWND,
@@ -1888,7 +1887,7 @@ pub extern "ws2_32" fn WSAAsyncGetServByPort(
     proto: ?[*:0]const u8,
     buf: [*]u8,
     buflen: i32,
-) callconv(WINAPI) HANDLE;
+) callconv(.winapi) HANDLE;
 
 pub extern "ws2_32" fn WSAAsyncGetProtoByName(
     hWnd: HWND,
@@ -1896,7 +1895,7 @@ pub extern "ws2_32" fn WSAAsyncGetProtoByName(
     name: [*:0]const u8,
     buf: [*]u8,
     buflen: i32,
-) callconv(WINAPI) HANDLE;
+) callconv(.winapi) HANDLE;
 
 pub extern "ws2_32" fn WSAAsyncGetProtoByNumber(
     hWnd: HWND,
@@ -1904,16 +1903,16 @@ pub extern "ws2_32" fn WSAAsyncGetProtoByNumber(
     number: i32,
     buf: [*]u8,
     buflen: i32,
-) callconv(WINAPI) HANDLE;
+) callconv(.winapi) HANDLE;
 
-pub extern "ws2_32" fn WSACancelAsyncRequest(hAsyncTaskHandle: HANDLE) callconv(WINAPI) i32;
+pub extern "ws2_32" fn WSACancelAsyncRequest(hAsyncTaskHandle: HANDLE) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAAsyncSelect(
     s: SOCKET,
     hWnd: HWND,
     wMsg: u32,
     lEvent: i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAAccept(
     s: SOCKET,
@@ -1921,9 +1920,9 @@ pub extern "ws2_32" fn WSAAccept(
     addrlen: ?*i32,
     lpfnCondition: ?LPCONDITIONPROC,
     dwCallbackData: usize,
-) callconv(WINAPI) SOCKET;
+) callconv(.winapi) SOCKET;
 
-pub extern "ws2_32" fn WSACloseEvent(hEvent: HANDLE) callconv(WINAPI) BOOL;
+pub extern "ws2_32" fn WSACloseEvent(hEvent: HANDLE) callconv(.winapi) BOOL;
 
 pub extern "ws2_32" fn WSAConnect(
     s: SOCKET,
@@ -1933,7 +1932,7 @@ pub extern "ws2_32" fn WSAConnect(
     lpCalleeData: ?*WSABUF,
     lpSQOS: ?*QOS,
     lpGQOS: ?*QOS,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAConnectByNameW(
     s: SOCKET,
@@ -1945,7 +1944,7 @@ pub extern "ws2_32" fn WSAConnectByNameW(
     RemoteAddress: ?*sockaddr,
     timeout: ?*const timeval,
     Reserved: *OVERLAPPED,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "ws2_32" fn WSAConnectByNameA(
     s: SOCKET,
@@ -1957,7 +1956,7 @@ pub extern "ws2_32" fn WSAConnectByNameA(
     RemoteAddress: ?*sockaddr,
     timeout: ?*const timeval,
     Reserved: *OVERLAPPED,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "ws2_32" fn WSAConnectByList(
     s: SOCKET,
@@ -1968,45 +1967,45 @@ pub extern "ws2_32" fn WSAConnectByList(
     RemoteAddress: ?*sockaddr,
     timeout: ?*const timeval,
     Reserved: *OVERLAPPED,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
-pub extern "ws2_32" fn WSACreateEvent() callconv(WINAPI) HANDLE;
+pub extern "ws2_32" fn WSACreateEvent() callconv(.winapi) HANDLE;
 
 pub extern "ws2_32" fn WSADuplicateSocketA(
     s: SOCKET,
     dwProcessId: u32,
     lpProtocolInfo: *WSAPROTOCOL_INFOA,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSADuplicateSocketW(
     s: SOCKET,
     dwProcessId: u32,
     lpProtocolInfo: *WSAPROTOCOL_INFOW,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAEnumNetworkEvents(
     s: SOCKET,
     hEventObject: HANDLE,
     lpNetworkEvents: *WSANETWORKEVENTS,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAEnumProtocolsA(
     lpiProtocols: ?*i32,
     lpProtocolBuffer: ?*WSAPROTOCOL_INFOA,
     lpdwBufferLength: *u32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAEnumProtocolsW(
     lpiProtocols: ?*i32,
     lpProtocolBuffer: ?*WSAPROTOCOL_INFOW,
     lpdwBufferLength: *u32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAEventSelect(
     s: SOCKET,
     hEventObject: HANDLE,
     lNetworkEvents: i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAGetOverlappedResult(
     s: SOCKET,
@@ -2014,25 +2013,25 @@ pub extern "ws2_32" fn WSAGetOverlappedResult(
     lpcbTransfer: *u32,
     fWait: BOOL,
     lpdwFlags: *u32,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "ws2_32" fn WSAGetQOSByName(
     s: SOCKET,
     lpQOSName: *WSABUF,
     lpQOS: *QOS,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "ws2_32" fn WSAHtonl(
     s: SOCKET,
     hostlong: u32,
     lpnetlong: *u32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAHtons(
     s: SOCKET,
     hostshort: u16,
     lpnetshort: *u16,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAIoctl(
     s: SOCKET,
@@ -2044,7 +2043,7 @@ pub extern "ws2_32" fn WSAIoctl(
     lpcbBytesReturned: *u32,
     lpOverlapped: ?*OVERLAPPED,
     lpCompletionRoutine: ?LPWSAOVERLAPPED_COMPLETION_ROUTINE,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAJoinLeaf(
     s: SOCKET,
@@ -2055,19 +2054,19 @@ pub extern "ws2_32" fn WSAJoinLeaf(
     lpSQOS: ?*QOS,
     lpGQOS: ?*QOS,
     dwFlags: u32,
-) callconv(WINAPI) SOCKET;
+) callconv(.winapi) SOCKET;
 
 pub extern "ws2_32" fn WSANtohl(
     s: SOCKET,
     netlong: u32,
     lphostlong: *u32,
-) callconv(WINAPI) u32;
+) callconv(.winapi) u32;
 
 pub extern "ws2_32" fn WSANtohs(
     s: SOCKET,
     netshort: u16,
     lphostshort: *u16,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSARecv(
     s: SOCKET,
@@ -2077,12 +2076,12 @@ pub extern "ws2_32" fn WSARecv(
     lpFlags: *u32,
     lpOverlapped: ?*OVERLAPPED,
     lpCompletionRoutine: ?LPWSAOVERLAPPED_COMPLETION_ROUTINE,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSARecvDisconnect(
     s: SOCKET,
     lpInboundDisconnectData: ?*WSABUF,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSARecvFrom(
     s: SOCKET,
@@ -2094,9 +2093,9 @@ pub extern "ws2_32" fn WSARecvFrom(
     lpFromlen: ?*i32,
     lpOverlapped: ?*OVERLAPPED,
     lpCompletionRoutine: ?LPWSAOVERLAPPED_COMPLETION_ROUTINE,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
-pub extern "ws2_32" fn WSAResetEvent(hEvent: HANDLE) callconv(WINAPI) i32;
+pub extern "ws2_32" fn WSAResetEvent(hEvent: HANDLE) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSASend(
     s: SOCKET,
@@ -2106,7 +2105,7 @@ pub extern "ws2_32" fn WSASend(
     dwFlags: u32,
     lpOverlapped: ?*OVERLAPPED,
     lpCompletionRoutine: ?LPWSAOVERLAPPED_COMPLETION_ROUTINE,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSASendMsg(
     s: SOCKET,
@@ -2115,7 +2114,7 @@ pub extern "ws2_32" fn WSASendMsg(
     lpNumberOfBytesSent: ?*u32,
     lpOverlapped: ?*OVERLAPPED,
     lpCompletionRoutine: ?LPWSAOVERLAPPED_COMPLETION_ROUTINE,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSARecvMsg(
     s: SOCKET,
@@ -2123,12 +2122,12 @@ pub extern "ws2_32" fn WSARecvMsg(
     lpdwNumberOfBytesRecv: ?*u32,
     lpOverlapped: ?*OVERLAPPED,
     lpCompletionRoutine: ?LPWSAOVERLAPPED_COMPLETION_ROUTINE,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSASendDisconnect(
     s: SOCKET,
     lpOutboundDisconnectData: ?*WSABUF,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSASendTo(
     s: SOCKET,
@@ -2140,11 +2139,11 @@ pub extern "ws2_32" fn WSASendTo(
     iToLen: i32,
     lpOverlapped: ?*OVERLAPPED,
     lpCompletionRounte: ?LPWSAOVERLAPPED_COMPLETION_ROUTINE,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSASetEvent(
     hEvent: HANDLE,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "ws2_32" fn WSASocketA(
     af: i32,
@@ -2153,7 +2152,7 @@ pub extern "ws2_32" fn WSASocketA(
     lpProtocolInfo: ?*WSAPROTOCOL_INFOA,
     g: u32,
     dwFlags: u32,
-) callconv(WINAPI) SOCKET;
+) callconv(.winapi) SOCKET;
 
 pub extern "ws2_32" fn WSASocketW(
     af: i32,
@@ -2162,7 +2161,7 @@ pub extern "ws2_32" fn WSASocketW(
     lpProtocolInfo: ?*WSAPROTOCOL_INFOW,
     g: u32,
     dwFlags: u32,
-) callconv(WINAPI) SOCKET;
+) callconv(.winapi) SOCKET;
 
 pub extern "ws2_32" fn WSAWaitForMultipleEvents(
     cEvents: u32,
@@ -2170,7 +2169,7 @@ pub extern "ws2_32" fn WSAWaitForMultipleEvents(
     fWaitAll: BOOL,
     dwTimeout: u32,
     fAlertable: BOOL,
-) callconv(WINAPI) u32;
+) callconv(.winapi) u32;
 
 pub extern "ws2_32" fn WSAAddressToStringA(
     lpsaAddress: *sockaddr,
@@ -2178,7 +2177,7 @@ pub extern "ws2_32" fn WSAAddressToStringA(
     lpProtocolInfo: ?*WSAPROTOCOL_INFOA,
     lpszAddressString: [*]u8,
     lpdwAddressStringLength: *u32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAAddressToStringW(
     lpsaAddress: *sockaddr,
@@ -2186,7 +2185,7 @@ pub extern "ws2_32" fn WSAAddressToStringW(
     lpProtocolInfo: ?*WSAPROTOCOL_INFOW,
     lpszAddressString: [*]u16,
     lpdwAddressStringLength: *u32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAStringToAddressA(
     AddressString: [*:0]const u8,
@@ -2194,7 +2193,7 @@ pub extern "ws2_32" fn WSAStringToAddressA(
     lpProtocolInfo: ?*WSAPROTOCOL_INFOA,
     lpAddress: *sockaddr,
     lpAddressLength: *i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAStringToAddressW(
     AddressString: [*:0]const u16,
@@ -2202,26 +2201,26 @@ pub extern "ws2_32" fn WSAStringToAddressW(
     lpProtocolInfo: ?*WSAPROTOCOL_INFOW,
     lpAddrses: *sockaddr,
     lpAddressLength: *i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAProviderConfigChange(
     lpNotificationHandle: *HANDLE,
     lpOverlapped: ?*OVERLAPPED,
     lpCompletionRoutine: ?LPWSAOVERLAPPED_COMPLETION_ROUTINE,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn WSAPoll(
     fdArray: [*]WSAPOLLFD,
     fds: u32,
     timeout: i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "mswsock" fn WSARecvEx(
     s: SOCKET,
     buf: [*]u8,
     len: i32,
     flags: *i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "mswsock" fn TransmitFile(
     hSocket: SOCKET,
@@ -2231,7 +2230,7 @@ pub extern "mswsock" fn TransmitFile(
     lpOverlapped: ?*OVERLAPPED,
     lpTransmitBuffers: ?*TRANSMIT_FILE_BUFFERS,
     dwReserved: u32,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "mswsock" fn AcceptEx(
     sListenSocket: SOCKET,
@@ -2242,7 +2241,7 @@ pub extern "mswsock" fn AcceptEx(
     dwRemoteAddressLength: u32,
     lpdwBytesReceived: *u32,
     lpOverlapped: *OVERLAPPED,
-) callconv(WINAPI) BOOL;
+) callconv(.winapi) BOOL;
 
 pub extern "mswsock" fn GetAcceptExSockaddrs(
     lpOutputBuffer: *anyopaque,
@@ -2253,24 +2252,24 @@ pub extern "mswsock" fn GetAcceptExSockaddrs(
     LocalSockaddrLength: *i32,
     RemoteSockaddr: **sockaddr,
     RemoteSockaddrLength: *i32,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 pub extern "ws2_32" fn WSAProviderCompleteAsyncCall(
     hAsyncCall: HANDLE,
     iRetCode: i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "mswsock" fn EnumProtocolsA(
     lpiProtocols: ?*i32,
     lpProtocolBuffer: *anyopaque,
     lpdwBufferLength: *u32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "mswsock" fn EnumProtocolsW(
     lpiProtocols: ?*i32,
     lpProtocolBuffer: *anyopaque,
     lpdwBufferLength: *u32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "mswsock" fn GetAddressByNameA(
     dwNameSpace: u32,
@@ -2282,7 +2281,7 @@ pub extern "mswsock" fn GetAddressByNameA(
     lpCsaddrBuffer: *anyopaque,
     lpAliasBuffer: ?[*:0]const u8,
     lpdwAliasBufferLength: *u32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "mswsock" fn GetAddressByNameW(
     dwNameSpace: u32,
@@ -2295,36 +2294,36 @@ pub extern "mswsock" fn GetAddressByNameW(
     ldwBufferLEngth: *u32,
     lpAliasBuffer: ?[*:0]u16,
     lpdwAliasBufferLength: *u32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "mswsock" fn GetTypeByNameA(
     lpServiceName: [*:0]u8,
     lpServiceType: *GUID,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "mswsock" fn GetTypeByNameW(
     lpServiceName: [*:0]u16,
     lpServiceType: *GUID,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "mswsock" fn GetNameByTypeA(
     lpServiceType: *GUID,
     lpServiceName: [*:0]u8,
     dwNameLength: u32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "mswsock" fn GetNameByTypeW(
     lpServiceType: *GUID,
     lpServiceName: [*:0]u16,
     dwNameLength: u32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn getaddrinfo(
     pNodeName: ?[*:0]const u8,
     pServiceName: ?[*:0]const u8,
     pHints: ?*const addrinfoa,
     ppResult: *?*addrinfoa,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn GetAddrInfoExA(
     pName: ?[*:0]const u8,
@@ -2336,23 +2335,23 @@ pub extern "ws2_32" fn GetAddrInfoExA(
     timeout: ?*timeval,
     lpOverlapped: ?*OVERLAPPED,
     lpCompletionRoutine: ?LPLOOKUPSERVICE_COMPLETION_ROUTINE,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn GetAddrInfoExCancel(
     lpHandle: *HANDLE,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn GetAddrInfoExOverlappedResult(
     lpOverlapped: *OVERLAPPED,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "ws2_32" fn freeaddrinfo(
     pAddrInfo: ?*addrinfoa,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 pub extern "ws2_32" fn FreeAddrInfoEx(
     pAddrInfoEx: ?*addrinfoexA,
-) callconv(WINAPI) void;
+) callconv(.winapi) void;
 
 pub extern "ws2_32" fn getnameinfo(
     pSockaddr: *const sockaddr,
@@ -2362,8 +2361,8 @@ pub extern "ws2_32" fn getnameinfo(
     pServiceBuffer: ?[*]u8,
     ServiceBufferName: u32,
     Flags: i32,
-) callconv(WINAPI) i32;
+) callconv(.winapi) i32;
 
 pub extern "iphlpapi" fn if_nametoindex(
     InterfaceName: [*:0]const u8,
-) callconv(WINAPI) u32;
+) callconv(.winapi) u32;
diff --git a/zig/lib/std/packed_int_array.zig b/zig/lib/std/packed_int_array.zig
deleted file mode 100644
index df8768856a..0000000000
--- a/zig/lib/std/packed_int_array.zig
+++ /dev/null
@@ -1,697 +0,0 @@
-//! A set of array and slice types that bit-pack integer elements. A normal [12]u3
-//! takes up 12 bytes of memory since u3's alignment is 1. PackedArray(u3, 12) only
-//! takes up 4 bytes of memory.
-
-const std = @import("std");
-const builtin = @import("builtin");
-const debug = std.debug;
-const testing = std.testing;
-const native_endian = builtin.target.cpu.arch.endian();
-const Endian = std.builtin.Endian;
-
-/// Provides a set of functions for reading and writing packed integers from a
-/// slice of bytes.
-pub fn PackedIntIo(comptime Int: type, comptime endian: Endian) type {
-    // The general technique employed here is to cast bytes in the array to a container
-    // integer (having bits % 8 == 0) large enough to contain the number of bits we want,
-    // then we can retrieve or store the new value with a relative minimum of masking
-    // and shifting. In this worst case, this means that we'll need an integer that's
-    // actually 1 byte larger than the minimum required to store the bits, because it
-    // is possible that the bits start at the end of the first byte, continue through
-    // zero or more, then end in the beginning of the last. But, if we try to access
-    // a value in the very last byte of memory with that integer size, that extra byte
-    // will be out of bounds. Depending on the circumstances of the memory, that might
-    // mean the OS fatally kills the program. Thus, we use a larger container (MaxIo)
-    // most of the time, but a smaller container (MinIo) when touching the last byte
-    // of the memory.
-    const int_bits = @bitSizeOf(Int);
-
-    // In the best case, this is the number of bytes we need to touch
-    // to read or write a value, as bits.
-    const min_io_bits = ((int_bits + 7) / 8) * 8;
-
-    // In the worst case, this is the number of bytes we need to touch
-    // to read or write a value, as bits. To calculate for int_bits > 1,
-    // set aside 2 bits to touch the first and last bytes, then divide
-    // by 8 to see how many bytes can be filled up in between.
-    const max_io_bits = switch (int_bits) {
-        0 => 0,
-        1 => 8,
-        else => ((int_bits - 2) / 8 + 2) * 8,
-    };
-
-    // We bitcast the desired Int type to an unsigned version of itself
-    // to avoid issues with shifting signed ints.
-    const UnInt = std.meta.Int(.unsigned, int_bits);
-
-    // The maximum container int type
-    const MinIo = std.meta.Int(.unsigned, min_io_bits);
-
-    // The minimum container int type
-    const MaxIo = std.meta.Int(.unsigned, max_io_bits);
-
-    return struct {
-        /// Retrieves the integer at `index` from the packed data beginning at `bit_offset`
-        /// within `bytes`.
-        pub fn get(bytes: []const u8, index: usize, bit_offset: u7) Int {
-            if (int_bits == 0) return 0;
-
-            const bit_index = (index * int_bits) + bit_offset;
-            const max_end_byte = (bit_index + max_io_bits) / 8;
-
-            //using the larger container size will potentially read out of bounds
-            if (max_end_byte > bytes.len) return getBits(bytes, MinIo, bit_index);
-            return getBits(bytes, MaxIo, bit_index);
-        }
-
-        fn getBits(bytes: []const u8, comptime Container: type, bit_index: usize) Int {
-            const container_bits = @bitSizeOf(Container);
-
-            const start_byte = bit_index / 8;
-            const head_keep_bits = bit_index - (start_byte * 8);
-            const tail_keep_bits = container_bits - (int_bits + head_keep_bits);
-
-            //read bytes as container
-            const value_ptr: *align(1) const Container = @ptrCast(&bytes[start_byte]);
-            var value = value_ptr.*;
-
-            if (endian != native_endian) value = @byteSwap(value);
-
-            switch (endian) {
-                .big => {
-                    value <<= @intCast(head_keep_bits);
-                    value >>= @intCast(head_keep_bits);
-                    value >>= @intCast(tail_keep_bits);
-                },
-                .little => {
-                    value <<= @intCast(tail_keep_bits);
-                    value >>= @intCast(tail_keep_bits);
-                    value >>= @intCast(head_keep_bits);
-                },
-            }
-
-            return @bitCast(@as(UnInt, @truncate(value)));
-        }
-
-        /// Sets the integer at `index` to `val` within the packed data beginning
-        /// at `bit_offset` into `bytes`.
-        pub fn set(bytes: []u8, index: usize, bit_offset: u3, int: Int) void {
-            if (int_bits == 0) return;
-
-            const bit_index = (index * int_bits) + bit_offset;
-            const max_end_byte = (bit_index + max_io_bits) / 8;
-
-            //using the larger container size will potentially write out of bounds
-            if (max_end_byte > bytes.len) return setBits(bytes, MinIo, bit_index, int);
-            setBits(bytes, MaxIo, bit_index, int);
-        }
-
-        fn setBits(bytes: []u8, comptime Container: type, bit_index: usize, int: Int) void {
-            const container_bits = @bitSizeOf(Container);
-            const Shift = std.math.Log2Int(Container);
-
-            const start_byte = bit_index / 8;
-            const head_keep_bits = bit_index - (start_byte * 8);
-            const tail_keep_bits = container_bits - (int_bits + head_keep_bits);
-            const keep_shift: Shift = switch (endian) {
-                .big => @intCast(tail_keep_bits),
-                .little => @intCast(head_keep_bits),
-            };
-
-            //position the bits where they need to be in the container
-            const value = @as(Container, @intCast(@as(UnInt, @bitCast(int)))) << keep_shift;
-
-            //read existing bytes
-            const target_ptr: *align(1) Container = @ptrCast(&bytes[start_byte]);
-            var target = target_ptr.*;
-
-            if (endian != native_endian) target = @byteSwap(target);
-
-            //zero the bits we want to replace in the existing bytes
-            const inv_mask = @as(Container, @intCast(std.math.maxInt(UnInt))) << keep_shift;
-            const mask = ~inv_mask;
-            target &= mask;
-
-            //merge the new value
-            target |= value;
-
-            if (endian != native_endian) target = @byteSwap(target);
-
-            //save it back
-            target_ptr.* = target;
-        }
-
-        /// Provides a PackedIntSlice of the packed integers in `bytes` (which begins at `bit_offset`)
-        /// from the element specified by `start` to the element specified by `end`.
-        pub fn slice(bytes: []u8, bit_offset: u3, start: usize, end: usize) PackedIntSliceEndian(Int, endian) {
-            debug.assert(end >= start);
-
-            const length = end - start;
-            const bit_index = (start * int_bits) + bit_offset;
-            const start_byte = bit_index / 8;
-            const end_byte = (bit_index + (length * int_bits) + 7) / 8;
-            const new_bytes = bytes[start_byte..end_byte];
-
-            if (length == 0) return PackedIntSliceEndian(Int, endian).init(new_bytes[0..0], 0);
-
-            var new_slice = PackedIntSliceEndian(Int, endian).init(new_bytes, length);
-            new_slice.bit_offset = @intCast((bit_index - (start_byte * 8)));
-            return new_slice;
-        }
-
-        /// Recasts a packed slice to a version with elements of type `NewInt` and endianness `new_endian`.
-        /// Slice will begin at `bit_offset` within `bytes` and the new length will be automatically
-        /// calculated from `old_len` using the sizes of the current integer type and `NewInt`.
-        pub fn sliceCast(bytes: []u8, comptime NewInt: type, comptime new_endian: Endian, bit_offset: u3, old_len: usize) PackedIntSliceEndian(NewInt, new_endian) {
-            const new_int_bits = @bitSizeOf(NewInt);
-            const New = PackedIntSliceEndian(NewInt, new_endian);
-
-            const total_bits = (old_len * int_bits);
-            const new_int_count = total_bits / new_int_bits;
-
-            debug.assert(total_bits == new_int_count * new_int_bits);
-
-            var new = New.init(bytes, new_int_count);
-            new.bit_offset = bit_offset;
-
-            return new;
-        }
-    };
-}
-
-/// Creates a bit-packed array of `Int`. Non-byte-multiple integers
-/// will take up less memory in PackedIntArray than in a normal array.
-/// Elements are packed using native endianness and without storing any
-/// meta data. PackedArray(i3, 8) will occupy exactly 3 bytes
-/// of memory.
-pub fn PackedIntArray(comptime Int: type, comptime int_count: usize) type {
-    return PackedIntArrayEndian(Int, native_endian, int_count);
-}
-
-/// Creates a bit-packed array of `Int` with bit order specified by `endian`.
-/// Non-byte-multiple integers will take up less memory in PackedIntArrayEndian
-/// than in a normal array. Elements are packed without storing any meta data.
-/// PackedIntArrayEndian(i3, 8) will occupy exactly 3 bytes of memory.
-pub fn PackedIntArrayEndian(comptime Int: type, comptime endian: Endian, comptime int_count: usize) type {
-    const int_bits = @bitSizeOf(Int);
-    const total_bits = int_bits * int_count;
-    const total_bytes = (total_bits + 7) / 8;
-
-    const Io = PackedIntIo(Int, endian);
-
-    return struct {
-        const Self = @This();
-
-        /// The byte buffer containing the packed data.
-        bytes: [total_bytes]u8,
-        /// The number of elements in the packed array.
-        comptime len: usize = int_count,
-
-        /// The integer type of the packed array.
-        pub const Child = Int;
-
-        /// Initialize a packed array using an unpacked array
-        /// or, more likely, an array literal.
-        pub fn init(ints: [int_count]Int) Self {
-            var self: Self = undefined;
-            for (ints, 0..) |int, i| self.set(i, int);
-            return self;
-        }
-
-        /// Initialize all entries of a packed array to the same value.
-        pub fn initAllTo(int: Int) Self {
-            var self: Self = undefined;
-            self.setAll(int);
-            return self;
-        }
-
-        /// Return the integer stored at `index`.
-        pub fn get(self: Self, index: usize) Int {
-            debug.assert(index < int_count);
-            return Io.get(&self.bytes, index, 0);
-        }
-
-        /// Copy the value of `int` into the array at `index`.
-        pub fn set(self: *Self, index: usize, int: Int) void {
-            debug.assert(index < int_count);
-            return Io.set(&self.bytes, index, 0, int);
-        }
-
-        /// Set all entries of a packed array to the value of `int`.
-        pub fn setAll(self: *Self, int: Int) void {
-            var i: usize = 0;
-            while (i < int_count) : (i += 1) {
-                self.set(i, int);
-            }
-        }
-
-        /// Create a PackedIntSlice of the array from `start` to `end`.
-        pub fn slice(self: *Self, start: usize, end: usize) PackedIntSliceEndian(Int, endian) {
-            debug.assert(start < int_count);
-            debug.assert(end <= int_count);
-            return Io.slice(&self.bytes, 0, start, end);
-        }
-
-        /// Create a PackedIntSlice of the array using `NewInt` as the integer type.
-        /// `NewInt`'s bit width must fit evenly within the array's `Int`'s total bits.
-        pub fn sliceCast(self: *Self, comptime NewInt: type) PackedIntSlice(NewInt) {
-            return self.sliceCastEndian(NewInt, endian);
-        }
-
-        /// Create a PackedIntSliceEndian of the array using `NewInt` as the integer type
-        /// and `new_endian` as the new endianness. `NewInt`'s bit width must fit evenly
-        /// within the array's `Int`'s total bits.
-        pub fn sliceCastEndian(self: *Self, comptime NewInt: type, comptime new_endian: Endian) PackedIntSliceEndian(NewInt, new_endian) {
-            return Io.sliceCast(&self.bytes, NewInt, new_endian, 0, int_count);
-        }
-    };
-}
-
-/// A type representing a sub range of a PackedIntArray.
-pub fn PackedIntSlice(comptime Int: type) type {
-    return PackedIntSliceEndian(Int, native_endian);
-}
-
-/// A type representing a sub range of a PackedIntArrayEndian.
-pub fn PackedIntSliceEndian(comptime Int: type, comptime endian: Endian) type {
-    const int_bits = @bitSizeOf(Int);
-    const Io = PackedIntIo(Int, endian);
-
-    return struct {
-        const Self = @This();
-
-        bytes: []u8,
-        bit_offset: u3,
-        len: usize,
-
-        /// The integer type of the packed slice.
-        pub const Child = Int;
-
-        /// Calculates the number of bytes required to store a desired count
-        /// of `Int`s.
-        pub fn bytesRequired(int_count: usize) usize {
-            const total_bits = int_bits * int_count;
-            const total_bytes = (total_bits + 7) / 8;
-            return total_bytes;
-        }
-
-        /// Initialize a packed slice using the memory at `bytes`, with `int_count`
-        /// elements. `bytes` must be large enough to accommodate the requested
-        /// count.
-        pub fn init(bytes: []u8, int_count: usize) Self {
-            debug.assert(bytes.len >= bytesRequired(int_count));
-
-            return Self{
-                .bytes = bytes,
-                .len = int_count,
-                .bit_offset = 0,
-            };
-        }
-
-        /// Return the integer stored at `index`.
-        pub fn get(self: Self, index: usize) Int {
-            debug.assert(index < self.len);
-            return Io.get(self.bytes, index, self.bit_offset);
-        }
-
-        /// Copy `int` into the slice at `index`.
-        pub fn set(self: *Self, index: usize, int: Int) void {
-            debug.assert(index < self.len);
-            return Io.set(self.bytes, index, self.bit_offset, int);
-        }
-
-        /// Create a PackedIntSlice of this slice from `start` to `end`.
-        pub fn slice(self: Self, start: usize, end: usize) PackedIntSliceEndian(Int, endian) {
-            debug.assert(start < self.len);
-            debug.assert(end <= self.len);
-            return Io.slice(self.bytes, self.bit_offset, start, end);
-        }
-
-        /// Create a PackedIntSlice of the sclice using `NewInt` as the integer type.
-        /// `NewInt`'s bit width must fit evenly within the slice's `Int`'s total bits.
-        pub fn sliceCast(self: Self, comptime NewInt: type) PackedIntSliceEndian(NewInt, endian) {
-            return self.sliceCastEndian(NewInt, endian);
-        }
-
-        /// Create a PackedIntSliceEndian of the slice using `NewInt` as the integer type
-        /// and `new_endian` as the new endianness. `NewInt`'s bit width must fit evenly
-        /// within the slice's `Int`'s total bits.
-        pub fn sliceCastEndian(self: Self, comptime NewInt: type, comptime new_endian: Endian) PackedIntSliceEndian(NewInt, new_endian) {
-            return Io.sliceCast(self.bytes, NewInt, new_endian, self.bit_offset, self.len);
-        }
-    };
-}
-
-test "PackedIntArray" {
-    // TODO @setEvalBranchQuota generates panics in wasm32. Investigate.
-    if (builtin.target.cpu.arch == .wasm32) return error.SkipZigTest;
-
-    // TODO: enable this test
-    if (true) return error.SkipZigTest;
-
-    @setEvalBranchQuota(10000);
-    const max_bits = 256;
-    const int_count = 19;
-
-    comptime var bits = 0;
-    inline while (bits <= max_bits) : (bits += 1) {
-        //alternate unsigned and signed
-        const sign: std.builtin.Signedness = if (bits % 2 == 0) .signed else .unsigned;
-        const I = std.meta.Int(sign, bits);
-
-        const PackedArray = PackedIntArray(I, int_count);
-        const expected_bytes = ((bits * int_count) + 7) / 8;
-        try testing.expect(@sizeOf(PackedArray) == expected_bytes);
-
-        var data: PackedArray = undefined;
-
-        //write values, counting up
-        var i: usize = 0;
-        var count: I = 0;
-        while (i < data.len) : (i += 1) {
-            data.set(i, count);
-            if (bits > 0) count +%= 1;
-        }
-
-        //read and verify values
-        i = 0;
-        count = 0;
-        while (i < data.len) : (i += 1) {
-            const val = data.get(i);
-            try testing.expect(val == count);
-            if (bits > 0) count +%= 1;
-        }
-    }
-}
-
-test "PackedIntIo" {
-    const bytes = [_]u8{ 0b01101_000, 0b01011_110, 0b00011_101 };
-    try testing.expectEqual(@as(u15, 0x2bcd), PackedIntIo(u15, .little).get(&bytes, 0, 3));
-    try testing.expectEqual(@as(u16, 0xabcd), PackedIntIo(u16, .little).get(&bytes, 0, 3));
-    try testing.expectEqual(@as(u17, 0x1abcd), PackedIntIo(u17, .little).get(&bytes, 0, 3));
-    try testing.expectEqual(@as(u18, 0x3abcd), PackedIntIo(u18, .little).get(&bytes, 0, 3));
-}
-
-test "PackedIntArray init" {
-    const S = struct {
-        fn doTheTest() !void {
-            const PackedArray = PackedIntArray(u3, 8);
-            var packed_array = PackedArray.init([_]u3{ 0, 1, 2, 3, 4, 5, 6, 7 });
-            var i: usize = 0;
-            while (i < packed_array.len) : (i += 1) try testing.expectEqual(@as(u3, @intCast(i)), packed_array.get(i));
-        }
-    };
-    try S.doTheTest();
-    try comptime S.doTheTest();
-}
-
-test "PackedIntArray initAllTo" {
-    const S = struct {
-        fn doTheTest() !void {
-            const PackedArray = PackedIntArray(u3, 8);
-            var packed_array = PackedArray.initAllTo(5);
-            var i: usize = 0;
-            while (i < packed_array.len) : (i += 1) try testing.expectEqual(@as(u3, 5), packed_array.get(i));
-        }
-    };
-    try S.doTheTest();
-    try comptime S.doTheTest();
-}
-
-test "PackedIntSlice" {
-    // TODO @setEvalBranchQuota generates panics in wasm32. Investigate.
-    if (builtin.target.cpu.arch == .wasm32) return error.SkipZigTest;
-
-    // TODO enable this test
-    if (true) return error.SkipZigTest;
-
-    @setEvalBranchQuota(10000);
-    const max_bits = 256;
-    const int_count = 19;
-    const total_bits = max_bits * int_count;
-    const total_bytes = (total_bits + 7) / 8;
-
-    var buffer: [total_bytes]u8 = undefined;
-
-    comptime var bits = 0;
-    inline while (bits <= max_bits) : (bits += 1) {
-        //alternate unsigned and signed
-        const sign: std.builtin.Signedness = if (bits % 2 == 0) .signed else .unsigned;
-        const I = std.meta.Int(sign, bits);
-        const P = PackedIntSlice(I);
-
-        var data = P.init(&buffer, int_count);
-
-        //write values, counting up
-        var i: usize = 0;
-        var count: I = 0;
-        while (i < data.len) : (i += 1) {
-            data.set(i, count);
-            if (bits > 0) count +%= 1;
-        }
-
-        //read and verify values
-        i = 0;
-        count = 0;
-        while (i < data.len) : (i += 1) {
-            const val = data.get(i);
-            try testing.expect(val == count);
-            if (bits > 0) count +%= 1;
-        }
-    }
-}
-
-test "PackedIntSlice of PackedInt(Array/Slice)" {
-    // TODO enable this test
-    if (true) return error.SkipZigTest;
-
-    const max_bits = 16;
-    const int_count = 19;
-
-    comptime var bits = 0;
-    inline while (bits <= max_bits) : (bits += 1) {
-        const Int = std.meta.Int(.unsigned, bits);
-
-        const PackedArray = PackedIntArray(Int, int_count);
-        var packed_array: PackedArray = undefined;
-
-        const limit = (1 << bits);
-
-        var i: usize = 0;
-        while (i < packed_array.len) : (i += 1) {
-            packed_array.set(i, @intCast(i % limit));
-        }
-
-        //slice of array
-        var packed_slice = packed_array.slice(2, 5);
-        try testing.expect(packed_slice.len == 3);
-        const ps_bit_count = (bits * packed_slice.len) + packed_slice.bit_offset;
-        const ps_expected_bytes = (ps_bit_count + 7) / 8;
-        try testing.expect(packed_slice.bytes.len == ps_expected_bytes);
-        try testing.expect(packed_slice.get(0) == 2 % limit);
-        try testing.expect(packed_slice.get(1) == 3 % limit);
-        try testing.expect(packed_slice.get(2) == 4 % limit);
-        packed_slice.set(1, 7 % limit);
-        try testing.expect(packed_slice.get(1) == 7 % limit);
-
-        //write through slice
-        try testing.expect(packed_array.get(3) == 7 % limit);
-
-        //slice of a slice
-        const packed_slice_two = packed_slice.slice(0, 3);
-        try testing.expect(packed_slice_two.len == 3);
-        const ps2_bit_count = (bits * packed_slice_two.len) + packed_slice_two.bit_offset;
-        const ps2_expected_bytes = (ps2_bit_count + 7) / 8;
-        try testing.expect(packed_slice_two.bytes.len == ps2_expected_bytes);
-        try testing.expect(packed_slice_two.get(1) == 7 % limit);
-        try testing.expect(packed_slice_two.get(2) == 4 % limit);
-
-        //size one case
-        const packed_slice_three = packed_slice_two.slice(1, 2);
-        try testing.expect(packed_slice_three.len == 1);
-        const ps3_bit_count = (bits * packed_slice_three.len) + packed_slice_three.bit_offset;
-        const ps3_expected_bytes = (ps3_bit_count + 7) / 8;
-        try testing.expect(packed_slice_three.bytes.len == ps3_expected_bytes);
-        try testing.expect(packed_slice_three.get(0) == 7 % limit);
-
-        //empty slice case
-        const packed_slice_empty = packed_slice.slice(0, 0);
-        try testing.expect(packed_slice_empty.len == 0);
-        try testing.expect(packed_slice_empty.bytes.len == 0);
-
-        //slicing at byte boundaries
-        const packed_slice_edge = packed_array.slice(8, 16);
-        try testing.expect(packed_slice_edge.len == 8);
-        const pse_bit_count = (bits * packed_slice_edge.len) + packed_slice_edge.bit_offset;
-        const pse_expected_bytes = (pse_bit_count + 7) / 8;
-        try testing.expect(packed_slice_edge.bytes.len == pse_expected_bytes);
-        try testing.expect(packed_slice_edge.bit_offset == 0);
-    }
-}
-
-test "PackedIntSlice accumulating bit offsets" {
-    //bit_offset is u3, so standard debugging asserts should catch
-    // anything
-    {
-        const PackedArray = PackedIntArray(u3, 16);
-        var packed_array: PackedArray = undefined;
-
-        var packed_slice = packed_array.slice(0, packed_array.len);
-        var i: usize = 0;
-        while (i < packed_array.len - 1) : (i += 1) {
-            packed_slice = packed_slice.slice(1, packed_slice.len);
-        }
-    }
-    {
-        const PackedArray = PackedIntArray(u11, 88);
-        var packed_array: PackedArray = undefined;
-
-        var packed_slice = packed_array.slice(0, packed_array.len);
-        var i: usize = 0;
-        while (i < packed_array.len - 1) : (i += 1) {
-            packed_slice = packed_slice.slice(1, packed_slice.len);
-        }
-    }
-}
-
-test "PackedInt(Array/Slice) sliceCast" {
-    const PackedArray = PackedIntArray(u1, 16);
-    var packed_array = PackedArray.init([_]u1{ 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 });
-    const packed_slice_cast_2 = packed_array.sliceCast(u2);
-    const packed_slice_cast_4 = packed_slice_cast_2.sliceCast(u4);
-    var packed_slice_cast_9 = packed_array.slice(0, (packed_array.len / 9) * 9).sliceCast(u9);
-    const packed_slice_cast_3 = packed_slice_cast_9.sliceCast(u3);
-
-    var i: usize = 0;
-    while (i < packed_slice_cast_2.len) : (i += 1) {
-        const val = switch (native_endian) {
-            .big => 0b01,
-            .little => 0b10,
-        };
-        try testing.expect(packed_slice_cast_2.get(i) == val);
-    }
-    i = 0;
-    while (i < packed_slice_cast_4.len) : (i += 1) {
-        const val = switch (native_endian) {
-            .big => 0b0101,
-            .little => 0b1010,
-        };
-        try testing.expect(packed_slice_cast_4.get(i) == val);
-    }
-    i = 0;
-    while (i < packed_slice_cast_9.len) : (i += 1) {
-        const val = 0b010101010;
-        try testing.expect(packed_slice_cast_9.get(i) == val);
-        packed_slice_cast_9.set(i, 0b111000111);
-    }
-    i = 0;
-    while (i < packed_slice_cast_3.len) : (i += 1) {
-        const val: u3 = switch (native_endian) {
-            .big => if (i % 2 == 0) 0b111 else 0b000,
-            .little => if (i % 2 == 0) 0b111 else 0b000,
-        };
-        try testing.expect(packed_slice_cast_3.get(i) == val);
-    }
-}
-
-test "PackedInt(Array/Slice)Endian" {
-    {
-        const PackedArrayBe = PackedIntArrayEndian(u4, .big, 8);
-        var packed_array_be = PackedArrayBe.init([_]u4{ 0, 1, 2, 3, 4, 5, 6, 7 });
-        try testing.expect(packed_array_be.bytes[0] == 0b00000001);
-        try testing.expect(packed_array_be.bytes[1] == 0b00100011);
-
-        var i: usize = 0;
-        while (i < packed_array_be.len) : (i += 1) {
-            try testing.expect(packed_array_be.get(i) == i);
-        }
-
-        var packed_slice_le = packed_array_be.sliceCastEndian(u4, .little);
-        i = 0;
-        while (i < packed_slice_le.len) : (i += 1) {
-            const val = if (i % 2 == 0) i + 1 else i - 1;
-            try testing.expect(packed_slice_le.get(i) == val);
-        }
-
-        var packed_slice_le_shift = packed_array_be.slice(1, 5).sliceCastEndian(u4, .little);
-        i = 0;
-        while (i < packed_slice_le_shift.len) : (i += 1) {
-            const val = if (i % 2 == 0) i else i + 2;
-            try testing.expect(packed_slice_le_shift.get(i) == val);
-        }
-    }
-
-    {
-        const PackedArrayBe = PackedIntArrayEndian(u11, .big, 8);
-        var packed_array_be = PackedArrayBe.init([_]u11{ 0, 1, 2, 3, 4, 5, 6, 7 });
-        try testing.expect(packed_array_be.bytes[0] == 0b00000000);
-        try testing.expect(packed_array_be.bytes[1] == 0b00000000);
-        try testing.expect(packed_array_be.bytes[2] == 0b00000100);
-        try testing.expect(packed_array_be.bytes[3] == 0b00000001);
-        try testing.expect(packed_array_be.bytes[4] == 0b00000000);
-
-        var i: usize = 0;
-        while (i < packed_array_be.len) : (i += 1) {
-            try testing.expect(packed_array_be.get(i) == i);
-        }
-
-        var packed_slice_le = packed_array_be.sliceCastEndian(u11, .little);
-        try testing.expect(packed_slice_le.get(0) == 0b00000000000);
-        try testing.expect(packed_slice_le.get(1) == 0b00010000000);
-        try testing.expect(packed_slice_le.get(2) == 0b00000000100);
-        try testing.expect(packed_slice_le.get(3) == 0b00000000000);
-        try testing.expect(packed_slice_le.get(4) == 0b00010000011);
-        try testing.expect(packed_slice_le.get(5) == 0b00000000010);
-        try testing.expect(packed_slice_le.get(6) == 0b10000010000);
-        try testing.expect(packed_slice_le.get(7) == 0b00000111001);
-
-        var packed_slice_le_shift = packed_array_be.slice(1, 5).sliceCastEndian(u11, .little);
-        try testing.expect(packed_slice_le_shift.get(0) == 0b00010000000);
-        try testing.expect(packed_slice_le_shift.get(1) == 0b00000000100);
-        try testing.expect(packed_slice_le_shift.get(2) == 0b00000000000);
-        try testing.expect(packed_slice_le_shift.get(3) == 0b00010000011);
-    }
-}
-
-//@NOTE: Need to manually update this list as more posix os's get
-// added to DirectAllocator.
-
-// These tests prove we aren't accidentally accessing memory past
-// the end of the array/slice by placing it at the end of a page
-// and reading the last element. The assumption is that the page
-// after this one is not mapped and will cause a segfault if we
-// don't account for the bounds.
-test "PackedIntArray at end of available memory" {
-    switch (builtin.target.os.tag) {
-        .linux, .macos, .ios, .freebsd, .netbsd, .openbsd, .windows => {},
-        else => return,
-    }
-    const PackedArray = PackedIntArray(u3, 8);
-
-    const Padded = struct {
-        _: [std.mem.page_size - @sizeOf(PackedArray)]u8,
-        p: PackedArray,
-    };
-
-    const allocator = std.testing.allocator;
-
-    var pad = try allocator.create(Padded);
-    defer allocator.destroy(pad);
-    pad.p.set(7, std.math.maxInt(u3));
-}
-
-test "PackedIntSlice at end of available memory" {
-    switch (builtin.target.os.tag) {
-        .linux, .macos, .ios, .freebsd, .netbsd, .openbsd, .windows => {},
-        else => return,
-    }
-    const PackedSlice = PackedIntSlice(u11);
-
-    const allocator = std.testing.allocator;
-
-    var page = try allocator.alloc(u8, std.mem.page_size);
-    defer allocator.free(page);
-
-    var p = PackedSlice.init(page[std.mem.page_size - 2 ..], 1);
-    p.set(0, std.math.maxInt(u11));
-}
diff --git a/zig/lib/std/posix.zig b/zig/lib/std/posix.zig
index bb21a79690..d46307dbdf 100644
--- a/zig/lib/std/posix.zig
+++ b/zig/lib/std/posix.zig
@@ -104,6 +104,7 @@ pub const SIOCGIFINDEX = system.SIOCGIFINDEX;
 pub const SO = system.SO;
 pub const SOCK = system.SOCK;
 pub const SOL = system.SOL;
+pub const IFF = system.IFF;
 pub const STDERR_FILENO = system.STDERR_FILENO;
 pub const STDIN_FILENO = system.STDIN_FILENO;
 pub const STDOUT_FILENO = system.STDOUT_FILENO;
@@ -154,7 +155,6 @@ pub const socklen_t = system.socklen_t;
 pub const stack_t = system.stack_t;
 pub const time_t = system.time_t;
 pub const timespec = system.timespec;
-pub const timestamp_t = system.timestamp_t;
 pub const timeval = system.timeval;
 pub const timezone = system.timezone;
 pub const ucontext_t = system.ucontext_t;
@@ -5614,7 +5614,7 @@ pub const ClockGetTimeError = error{UnsupportedClock} || UnexpectedError;
 /// TODO: change this to return the timespec as a return value
 pub fn clock_gettime(clock_id: clockid_t, tp: *timespec) ClockGetTimeError!void {
     if (native_os == .wasi and !builtin.link_libc) {
-        var ts: timestamp_t = undefined;
+        var ts: wasi.timestamp_t = undefined;
         switch (system.clock_time_get(clock_id, 1, &ts)) {
             .SUCCESS => {
                 tp.* = .{
@@ -5655,7 +5655,7 @@ pub fn clock_gettime(clock_id: clockid_t, tp: *timespec) ClockGetTimeError!void
 
 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;
+        var ts: wasi.timestamp_t = undefined;
         switch (system.clock_res_get(@bitCast(clock_id), &ts)) {
             .SUCCESS => res.* = .{
                 .sec = @intCast(ts / std.time.ns_per_s),
diff --git a/zig/lib/std/simd.zig b/zig/lib/std/simd.zig
index 6817c7e082..b02298622d 100644
--- a/zig/lib/std/simd.zig
+++ b/zig/lib/std/simd.zig
@@ -18,7 +18,7 @@ pub fn suggestVectorLengthForCpu(comptime T: type, comptime cpu: std.Target.Cpu)
             if (std.Target.x86.featureSetHasAny(cpu.features, .{ .prefer_256_bit, .avx2 }) and !std.Target.x86.featureSetHas(cpu.features, .prefer_128_bit)) break :blk 256;
             if (std.Target.x86.featureSetHas(cpu.features, .sse)) break :blk 128;
             if (std.Target.x86.featureSetHasAny(cpu.features, .{ .mmx, .@"3dnow" })) break :blk 64;
-        } else if (cpu.arch.isArmOrThumb()) {
+        } else if (cpu.arch.isArm()) {
             if (std.Target.arm.featureSetHas(cpu.features, .neon)) break :blk 128;
         } else if (cpu.arch.isAARCH64()) {
             // SVE allows up to 2048 bits in the specification, as of 2022 the most powerful machine has implemented 512-bit
@@ -90,7 +90,7 @@ pub fn suggestVectorLength(comptime T: type) ?comptime_int {
 }
 
 test "suggestVectorLengthForCpu works with signed and unsigned values" {
-    comptime var cpu = std.Target.Cpu.baseline(std.Target.Cpu.Arch.x86_64);
+    comptime var cpu = std.Target.Cpu.baseline(std.Target.Cpu.Arch.x86_64, builtin.os);
     comptime cpu.features.addFeature(@intFromEnum(std.Target.x86.Feature.avx512f));
     comptime cpu.features.populateDependencies(&std.Target.x86.all_features);
     const expected_len: usize = switch (builtin.zig_backend) {
@@ -462,6 +462,7 @@ pub fn prefixScan(comptime op: std.builtin.ReduceOp, comptime hop: isize, vec: a
 
 test "vector prefix scan" {
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+    if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21893
 
     if (comptime builtin.cpu.arch.isMIPS()) {
         return error.SkipZigTest;
diff --git a/zig/lib/std/start.zig b/zig/lib/std/start.zig
index 01a33522d0..0ded8ea625 100644
--- a/zig/lib/std/start.zig
+++ b/zig/lib/std/start.zig
@@ -19,8 +19,7 @@ pub const simplified_logic =
     builtin.zig_backend == .stage2_aarch64 or
     builtin.zig_backend == .stage2_arm or
     builtin.zig_backend == .stage2_sparc64 or
-    builtin.cpu.arch == .spirv32 or
-    builtin.cpu.arch == .spirv64;
+    builtin.zig_backend == .stage2_spirv64;
 
 comptime {
     // No matter what, we import the root file, so that any export, test, comptime
@@ -30,14 +29,14 @@ comptime {
     if (simplified_logic) {
         if (builtin.output_mode == .Exe) {
             if ((builtin.link_libc or builtin.object_format == .c) and @hasDecl(root, "main")) {
-                if (@typeInfo(@TypeOf(root.main)).@"fn".calling_convention != .C) {
+                if (!@typeInfo(@TypeOf(root.main)).@"fn".calling_convention.eql(.c)) {
                     @export(&main2, .{ .name = "main" });
                 }
             } else if (builtin.os.tag == .windows) {
                 if (!@hasDecl(root, "wWinMainCRTStartup") and !@hasDecl(root, "mainCRTStartup")) {
                     @export(&wWinMainCRTStartup2, .{ .name = "wWinMainCRTStartup" });
                 }
-            } else if (builtin.os.tag == .opencl) {
+            } else if (builtin.os.tag == .opencl or builtin.os.tag == .vulkan) {
                 if (@hasDecl(root, "main"))
                     @export(&spirvMain2, .{ .name = "main" });
             } else {
@@ -55,7 +54,7 @@ comptime {
             if (builtin.link_libc and @hasDecl(root, "main")) {
                 if (native_arch.isWasm()) {
                     @export(&mainWithoutEnv, .{ .name = "main" });
-                } else if (@typeInfo(@TypeOf(root.main)).@"fn".calling_convention != .C) {
+                } else if (!@typeInfo(@TypeOf(root.main)).@"fn".calling_convention.eql(.c)) {
                     @export(&main, .{ .name = "main" });
                 }
             } else if (native_os == .windows) {
@@ -97,26 +96,25 @@ comptime {
 
 // Simplified start code for stage2 until it supports more language features ///
 
-fn main2() callconv(.C) c_int {
+fn main2() callconv(.c) c_int {
     root.main();
     return 0;
 }
 
-fn _start2() callconv(.C) noreturn {
+fn _start2() callconv(.withStackAlign(.c, 1)) noreturn {
     callMain2();
 }
 
 fn callMain2() noreturn {
-    @setAlignStack(16);
     root.main();
     exit2(0);
 }
 
-fn spirvMain2() callconv(.Kernel) void {
+fn spirvMain2() callconv(.kernel) void {
     root.main();
 }
 
-fn wWinMainCRTStartup2() callconv(.C) noreturn {
+fn wWinMainCRTStartup2() callconv(.c) noreturn {
     root.main();
     exit2(0);
 }
@@ -174,7 +172,7 @@ fn _DllMainCRTStartup(
     hinstDLL: std.os.windows.HINSTANCE,
     fdwReason: std.os.windows.DWORD,
     lpReserved: std.os.windows.LPVOID,
-) callconv(std.os.windows.WINAPI) std.os.windows.BOOL {
+) callconv(.winapi) std.os.windows.BOOL {
     if (!builtin.single_threaded and !builtin.link_libc) {
         _ = @import("os/windows/tls.zig");
     }
@@ -186,13 +184,13 @@ fn _DllMainCRTStartup(
     return std.os.windows.TRUE;
 }
 
-fn wasm_freestanding_start() callconv(.C) void {
+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, .{});
 }
 
-fn wasi_start() callconv(.C) void {
+fn wasi_start() 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) {
@@ -201,7 +199,7 @@ fn wasi_start() callconv(.C) void {
     }
 }
 
-fn EfiMain(handle: uefi.Handle, system_table: *uefi.tables.SystemTable) callconv(.C) usize {
+fn EfiMain(handle: uefi.Handle, system_table: *uefi.tables.SystemTable) callconv(.c) usize {
     uefi.handle = handle;
     uefi.system_table = system_table;
 
@@ -223,7 +221,7 @@ fn EfiMain(handle: uefi.Handle, system_table: *uefi.tables.SystemTable) callconv
     }
 }
 
-fn _start() callconv(.Naked) noreturn {
+fn _start() callconv(.naked) noreturn {
     // TODO set Top of Stack on non x86_64-plan9
     if (native_os == .plan9 and native_arch == .x86_64) {
         // from /sys/src/libc/amd64/main9.s
@@ -428,8 +426,7 @@ fn _start() callconv(.Naked) noreturn {
     );
 }
 
-fn WinStartup() callconv(std.os.windows.WINAPI) noreturn {
-    @setAlignStack(16);
+fn WinStartup() callconv(.withStackAlign(.c, 1)) noreturn {
     if (!builtin.single_threaded and !builtin.link_libc) {
         _ = @import("os/windows/tls.zig");
     }
@@ -439,8 +436,7 @@ fn WinStartup() callconv(std.os.windows.WINAPI) noreturn {
     std.os.windows.ntdll.RtlExitUserProcess(callMain());
 }
 
-fn wWinMainCRTStartup() callconv(std.os.windows.WINAPI) noreturn {
-    @setAlignStack(16);
+fn wWinMainCRTStartup() callconv(.withStackAlign(.c, 1)) noreturn {
     if (!builtin.single_threaded and !builtin.link_libc) {
         _ = @import("os/windows/tls.zig");
     }
@@ -451,7 +447,7 @@ fn wWinMainCRTStartup() callconv(std.os.windows.WINAPI) noreturn {
     std.os.windows.ntdll.RtlExitUserProcess(@as(std.os.windows.UINT, @bitCast(result)));
 }
 
-fn posixCallMainAndExit(argc_argv_ptr: [*]usize) callconv(.C) noreturn {
+fn posixCallMainAndExit(argc_argv_ptr: [*]usize) callconv(.c) noreturn {
     // We're not ready to panic until thread local storage is initialized.
     @setRuntimeSafety(false);
     // Code coverage instrumentation might try to use thread local variables.
@@ -499,7 +495,7 @@ fn posixCallMainAndExit(argc_argv_ptr: [*]usize) callconv(.C) noreturn {
             // ARMv6 targets (and earlier) have no support for TLS in hardware.
             // FIXME: Elide the check for targets >= ARMv7 when the target feature API
             // becomes less verbose (and more usable).
-            if (comptime native_arch.isArmOrThumb()) {
+            if (comptime native_arch.isArm()) {
                 if (at_hwcap & std.os.linux.HWCAP.TLS == 0) {
                     // FIXME: Make __aeabi_read_tp call the kernel helper kuser_get_tls
                     // For the time being use a simple trap instead of a @panic call to
@@ -518,11 +514,11 @@ fn posixCallMainAndExit(argc_argv_ptr: [*]usize) callconv(.C) noreturn {
         // to ask for more stack space.
         expandStackSize(phdrs);
 
-        const opt_init_array_start = @extern([*]*const fn () callconv(.C) void, .{
+        const opt_init_array_start = @extern([*]*const fn () callconv(.c) void, .{
             .name = "__init_array_start",
             .linkage = .weak,
         });
-        const opt_init_array_end = @extern([*]*const fn () callconv(.C) void, .{
+        const opt_init_array_end = @extern([*]*const fn () callconv(.c) void, .{
             .name = "__init_array_end",
             .linkage = .weak,
         });
@@ -581,7 +577,7 @@ inline fn callMainWithArgs(argc: usize, argv: [*][*:0]u8, envp: [][*:0]u8) u8 {
     return callMain();
 }
 
-fn main(c_argc: c_int, c_argv: [*][*:0]c_char, c_envp: [*:null]?[*:0]c_char) callconv(.C) c_int {
+fn main(c_argc: c_int, c_argv: [*][*:0]c_char, c_envp: [*:null]?[*:0]c_char) callconv(.c) c_int {
     var env_count: usize = 0;
     while (c_envp[env_count] != null) : (env_count += 1) {}
     const envp = @as([*][*:0]u8, @ptrCast(c_envp))[0..env_count];
@@ -596,7 +592,7 @@ fn main(c_argc: c_int, c_argv: [*][*:0]c_char, c_envp: [*:null]?[*:0]c_char) cal
     return callMainWithArgs(@as(usize, @intCast(c_argc)), @as([*][*:0]u8, @ptrCast(c_argv)), envp);
 }
 
-fn mainWithoutEnv(c_argc: c_int, c_argv: [*][*:0]c_char) callconv(.C) c_int {
+fn mainWithoutEnv(c_argc: c_int, c_argv: [*][*:0]c_char) callconv(.c) c_int {
     std.os.argv = @as([*][*:0]u8, @ptrCast(c_argv))[0..@as(usize, @intCast(c_argc))];
     return callMain();
 }
@@ -706,4 +702,4 @@ fn maybeIgnoreSigpipe() void {
     }
 }
 
-fn noopSigHandler(_: i32) callconv(.C) void {}
+fn noopSigHandler(_: i32) callconv(.c) void {}
diff --git a/zig/lib/std/std.zig b/zig/lib/std/std.zig
index e4ec655680..cc61111746 100644
--- a/zig/lib/std/std.zig
+++ b/zig/lib/std/std.zig
@@ -26,10 +26,6 @@ pub const EnumSet = enums.EnumSet;
 pub const HashMap = hash_map.HashMap;
 pub const HashMapUnmanaged = hash_map.HashMapUnmanaged;
 pub const MultiArrayList = @import("multi_array_list.zig").MultiArrayList;
-pub const PackedIntArray = @import("packed_int_array.zig").PackedIntArray;
-pub const PackedIntArrayEndian = @import("packed_int_array.zig").PackedIntArrayEndian;
-pub const PackedIntSlice = @import("packed_int_array.zig").PackedIntSlice;
-pub const PackedIntSliceEndian = @import("packed_int_array.zig").PackedIntSliceEndian;
 pub const PriorityQueue = @import("priority_queue.zig").PriorityQueue;
 pub const PriorityDequeue = @import("priority_dequeue.zig").PriorityDequeue;
 pub const Progress = @import("Progress.zig");
@@ -82,7 +78,6 @@ pub const meta = @import("meta.zig");
 pub const net = @import("net.zig");
 pub const os = @import("os.zig");
 pub const once = @import("once.zig").once;
-pub const packed_int_array = @import("packed_int_array.zig");
 pub const pdb = @import("pdb.zig");
 pub const posix = @import("posix.zig");
 pub const process = @import("process.zig");
@@ -151,6 +146,11 @@ pub const Options = struct {
     /// make a HTTPS connection.
     http_disable_tls: bool = false,
 
+    /// This enables `std.http.Client` to log ssl secrets to the file specified by the SSLKEYLOGFILE
+    /// env var.  Creating such a log file allows other programs with access to that file to decrypt
+    /// all `std.http.Client` traffic made by this program.
+    http_enable_ssl_key_log_file: bool = @import("builtin").mode == .Debug,
+
     side_channels_mitigations: crypto.SideChannelsMitigations = crypto.default_side_channels_mitigations,
 };
 
diff --git a/zig/lib/std/testing.zig b/zig/lib/std/testing.zig
index 91caa7d922..fb75672fbd 100644
--- a/zig/lib/std/testing.zig
+++ b/zig/lib/std/testing.zig
@@ -41,14 +41,14 @@ fn print(comptime fmt: []const u8, args: anytype) void {
 pub fn expectError(expected_error: anyerror, actual_error_union: anytype) !void {
     if (actual_error_union) |actual_payload| {
         print("expected error.{s}, found {any}\n", .{ @errorName(expected_error), actual_payload });
-        return error.TestUnexpectedError;
+        return error.TestExpectedError;
     } else |actual_error| {
         if (expected_error != actual_error) {
             print("expected error.{s}, found error.{s}\n", .{
                 @errorName(expected_error),
                 @errorName(actual_error),
             });
-            return error.TestExpectedError;
+            return error.TestUnexpectedError;
         }
     }
 }
diff --git a/zig/lib/std/valgrind.zig b/zig/lib/std/valgrind.zig
index 241f4c732a..30170aa6ed 100644
--- a/zig/lib/std/valgrind.zig
+++ b/zig/lib/std/valgrind.zig
@@ -7,50 +7,96 @@ pub fn doClientRequest(default: usize, request: usize, a1: usize, a2: usize, a3:
         return default;
     }
 
-    switch (builtin.target.cpu.arch) {
-        .x86 => {
-            return asm volatile (
-                \\ roll $3,  %%edi ; roll $13, %%edi
-                \\ roll $29, %%edi ; roll $19, %%edi
-                \\ xchgl %%ebx,%%ebx
-                : [_] "={edx}" (-> usize),
-                : [_] "{eax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }),
-                  [_] "0" (default),
-                : "cc", "memory"
-            );
-        },
-        .x86_64 => {
-            return asm volatile (
-                \\ rolq $3,  %%rdi ; rolq $13, %%rdi
-                \\ rolq $61, %%rdi ; rolq $51, %%rdi
-                \\ xchgq %%rbx,%%rbx
-                : [_] "={rdx}" (-> usize),
-                : [_] "{rax}" (&[_]usize{ request, a1, a2, a3, a4, a5 }),
-                  [_] "0" (default),
-                : "cc", "memory"
-            );
-        },
-        .aarch64 => {
-            return asm volatile (
-                \\ ror x12, x12, #3  ;  ror x12, x12, #13
-                \\ ror x12, x12, #51 ;  ror x12, x12, #61
-                \\ orr x10, x10, x10
-                : [_] "={x3}" (-> usize),
-                : [_] "{x4}" (&[_]usize{ request, a1, a2, a3, a4, a5 }),
-                  [_] "0" (default),
-                : "cc", "memory"
-            );
-        },
-        // ppc32
-        // ppc64
-        // arm
-        // s390x
-        // mips32
-        // mips64
-        else => {
-            return default;
-        },
-    }
+    const args = &[_]usize{ request, a1, a2, a3, a4, a5 };
+
+    return switch (builtin.cpu.arch) {
+        .arm, .armeb, .thumb, .thumbeb => asm volatile (
+            \\ mov r12, r12, ror #3  ; mov r12, r12, ror #13
+            \\ mov r12, r12, ror #29 ; mov r12, r12, ror #19
+            \\ orr r10, r10, r10
+            : [_] "={r3}" (-> usize),
+            : [_] "{r4}" (args),
+              [_] "{r3}" (default),
+            : "cc", "memory"
+        ),
+        .aarch64, .aarch64_be => asm volatile (
+            \\ ror x12, x12, #3  ; ror x12, x12, #13
+            \\ ror x12, x12, #51 ; ror x12, x12, #61
+            \\ orr x10, x10, x10
+            : [_] "={x3}" (-> usize),
+            : [_] "{x4}" (args),
+              [_] "{x3}" (default),
+            : "cc", "memory"
+        ),
+        .mips, .mipsel => asm volatile (
+            \\ srl $0,  $0,  13
+            \\ srl $0,  $0,  29
+            \\ srl $0,  $0,  3
+            \\ srl $0,  $0,  19
+            \\ or  $13, $13, $13
+            : [_] "={$11}" (-> usize),
+            : [_] "{$12}" (args),
+              [_] "{$11}" (default),
+            : "memory"
+        ),
+        .mips64, .mips64el => asm volatile (
+            \\ dsll $0,  $0,  3   ; dsll $0, $0, 13
+            \\ dsll $0,  $0,  29  ; dsll $0, $0, 19
+            \\ or   $13, $13, $13
+            : [_] "={$11}" (-> usize),
+            : [_] "{$12}" (args),
+              [_] "{$11}" (default),
+            : "memory"
+        ),
+        .powerpc, .powerpcle => asm volatile (
+            \\ rlwinm 0, 0, 3,  0, 31 ; rlwinm 0, 0, 13, 0, 31
+            \\ rlwinm 0, 0, 29, 0, 31 ; rlwinm 0, 0, 19, 0, 31
+            \\ or     1, 1, 1
+            : [_] "={r3}" (-> usize),
+            : [_] "{r4}" (args),
+              [_] "{r3}" (default),
+            : "cc", "memory"
+        ),
+        .powerpc64, .powerpc64le => asm volatile (
+            \\ rotldi 0, 0, 3  ; rotldi 0, 0, 13
+            \\ rotldi 0, 0, 61 ; rotldi 0, 0, 51
+            \\ or     1, 1, 1
+            : [_] "={r3}" (-> usize),
+            : [_] "{r4}" (args),
+              [_] "{r3}" (default),
+            : "cc", "memory"
+        ),
+        .s390x => asm volatile (
+            \\ lr %%r15, %%r15
+            \\ lr %%r1,  %%r1
+            \\ lr %%r2,  %%r2
+            \\ lr %%r3,  %%r3
+            \\ lr %%r2,  %%r2
+            : [_] "={r3}" (-> usize),
+            : [_] "{r2}" (args),
+              [_] "{r3}" (default),
+            : "cc", "memory"
+        ),
+        .x86 => asm volatile (
+            \\ roll  $3,    %%edi ; roll $13, %%edi
+            \\ roll  $29,   %%edi ; roll $19, %%edi
+            \\ xchgl %%ebx, %%ebx
+            : [_] "={edx}" (-> usize),
+            : [_] "{eax}" (args),
+              [_] "{edx}" (default),
+            : "cc", "memory"
+        ),
+        .x86_64 => asm volatile (
+            \\ rolq  $3,    %%rdi ; rolq $13, %%rdi
+            \\ rolq  $61,   %%rdi ; rolq $51, %%rdi
+            \\ xchgq %%rbx, %%rbx
+            : [_] "={rdx}" (-> usize),
+            : [_] "{rax}" (args),
+              [_] "{rdx}" (default),
+            : "cc", "memory"
+        ),
+        else => default,
+    };
 }
 
 pub const ClientRequest = enum(u32) {
@@ -121,7 +167,7 @@ pub fn discardTranslations(qzz: []const u8) void {
 }
 
 pub fn innerThreads(qzz: [*]u8) void {
-    doClientRequestStmt(.InnerThreads, qzz, 0, 0, 0, 0);
+    doClientRequestStmt(.InnerThreads, @intFromPtr(qzz), 0, 0, 0, 0);
 }
 
 pub fn nonSimdCall0(func: fn (usize) usize) usize {
@@ -273,7 +319,7 @@ pub fn enableErrorReporting() void {
 /// If no connection is opened, output will go to the log output.
 /// Returns 1 if command not recognised, 0 otherwise.
 pub fn monitorCommand(command: [*]u8) bool {
-    return doClientRequestExpr(0, .GdbMonitorCommand, @intFromPtr(command.ptr), 0, 0, 0, 0) != 0;
+    return doClientRequestExpr(0, .GdbMonitorCommand, @intFromPtr(command), 0, 0, 0, 0) != 0;
 }
 
 pub const memcheck = @import("valgrind/memcheck.zig");
diff --git a/zig/lib/std/valgrind/memcheck.zig b/zig/lib/std/valgrind/memcheck.zig
index 950026afc5..d0e0f0bd8c 100644
--- a/zig/lib/std/valgrind/memcheck.zig
+++ b/zig/lib/std/valgrind/memcheck.zig
@@ -90,26 +90,26 @@ pub fn checkMemIsDefined(qzz: []const u8) usize {
 
 /// Do a full memory leak check (like --leak-check=full) mid-execution.
 pub fn doLeakCheck() void {
-    doClientRequestStmt(.DO_LEAK_CHECK, 0, 0, 0, 0, 0);
+    doClientRequestStmt(.DoLeakCheck, 0, 0, 0, 0, 0);
 }
 
 /// Same as doLeakCheck() but only showing the entries for
 /// which there was an increase in leaked bytes or leaked nr of blocks
 /// since the previous leak search.
 pub fn doAddedLeakCheck() void {
-    doClientRequestStmt(.DO_LEAK_CHECK, 0, 1, 0, 0, 0);
+    doClientRequestStmt(.DoLeakCheck, 0, 1, 0, 0, 0);
 }
 
 /// Same as doAddedLeakCheck() but showing entries with
 /// increased or decreased leaked bytes/blocks since previous leak
 /// search.
 pub fn doChangedLeakCheck() void {
-    doClientRequestStmt(.DO_LEAK_CHECK, 0, 2, 0, 0, 0);
+    doClientRequestStmt(.DoLeakCheck, 0, 2, 0, 0, 0);
 }
 
 /// Do a summary memory leak check (like --leak-check=summary) mid-execution.
 pub fn doQuickLeakCheck() void {
-    doClientRequestStmt(.DO_LEAK_CHECK, 1, 0, 0, 0, 0);
+    doClientRequestStmt(.DoLeakCheck, 1, 0, 0, 0, 0);
 }
 
 /// Return number of leaked, dubious, reachable and suppressed bytes found by
@@ -191,7 +191,7 @@ test countLeakBlocks {
 /// impossible to segfault your system by using this call.
 pub fn getVbits(zza: []u8, zzvbits: []u8) u2 {
     std.debug.assert(zzvbits.len >= zza.len / 8);
-    return @as(u2, @intCast(doClientRequestExpr(0, .GetVbits, @intFromPtr(zza.ptr), @intFromPtr(zzvbits), zza.len, 0, 0)));
+    return @as(u2, @intCast(doClientRequestExpr(0, .GetVbits, @intFromPtr(zza.ptr), @intFromPtr(zzvbits.ptr), zza.len, 0, 0)));
 }
 
 /// Set the validity data for addresses zza, copying it
@@ -204,7 +204,7 @@ pub fn getVbits(zza: []u8, zzvbits: []u8) u2 {
 /// impossible to segfault your system by using this call.
 pub fn setVbits(zzvbits: []u8, zza: []u8) u2 {
     std.debug.assert(zzvbits.len >= zza.len / 8);
-    return @as(u2, @intCast(doClientRequestExpr(0, .SetVbits, @intFromPtr(zza.ptr), @intFromPtr(zzvbits), zza.len, 0, 0)));
+    return @as(u2, @intCast(doClientRequestExpr(0, .SetVbits, @intFromPtr(zza.ptr), @intFromPtr(zzvbits.ptr), zza.len, 0, 0)));
 }
 
 /// Disable and re-enable reporting of addressing errors in the
diff --git a/zig/lib/std/zig.zig b/zig/lib/std/zig.zig
index c3ce106634..0ef03c24a4 100644
--- a/zig/lib/std/zig.zig
+++ b/zig/lib/std/zig.zig
@@ -660,6 +660,17 @@ pub fn parseTargetQueryOrReportFatalError(
             }
             fatal("unknown object format: '{s}'", .{opts.object_format.?});
         },
+        error.UnknownArchitecture => {
+            help: {
+                var help_text = std.ArrayList(u8).init(allocator);
+                defer help_text.deinit();
+                inline for (@typeInfo(std.Target.Cpu.Arch).@"enum".fields) |field| {
+                    help_text.writer().print(" {s}\n", .{field.name}) catch break :help;
+                }
+                std.log.info("available architectures:\n{s} native\n", .{help_text.items});
+            }
+            fatal("unknown architecture: '{s}'", .{diags.unknown_architecture_name.?});
+        },
         else => |e| fatal("unable to parse target query '{s}': {s}", .{
             opts.arch_os_abi, @errorName(e),
         }),
diff --git a/zig/lib/std/zig/AstGen.zig b/zig/lib/std/zig/AstGen.zig
index 7e11f8d44b..abec1f354a 100644
--- a/zig/lib/std/zig/AstGen.zig
+++ b/zig/lib/std/zig/AstGen.zig
@@ -1711,7 +1711,7 @@ fn structInitExpr(
                     return rvalue(gz, ri, val, node);
                 },
                 .none, .ref, .inferred_ptr => {
-                    return rvalue(gz, ri, .empty_struct, node);
+                    return rvalue(gz, ri, .empty_tuple, node);
                 },
                 .destructure => |destructure| {
                     return astgen.failNodeNotes(node, "empty initializer cannot be destructured", .{}, &.{
@@ -1888,6 +1888,8 @@ fn structInitExprAnon(
     const tree = astgen.tree;
 
     const payload_index = try addExtra(astgen, Zir.Inst.StructInitAnon{
+        .abs_node = node,
+        .abs_line = astgen.source_line,
         .fields_len = @intCast(struct_init.ast.fields.len),
     });
     const field_size = @typeInfo(Zir.Inst.StructInitAnon.Item).@"struct".fields.len;
@@ -1919,6 +1921,8 @@ fn structInitExprTyped(
     const tree = astgen.tree;
 
     const payload_index = try addExtra(astgen, Zir.Inst.StructInit{
+        .abs_node = node,
+        .abs_line = astgen.source_line,
         .fields_len = @intCast(struct_init.ast.fields.len),
     });
     const field_size = @typeInfo(Zir.Inst.StructInit.Item).@"struct".fields.len;
@@ -2431,6 +2435,7 @@ fn blockExpr(
         if (!block_scope.endsWithNoReturn()) {
             // As our last action before the break, "pop" the error trace if needed
             _ = try gz.addRestoreErrRetIndex(.{ .block = block_inst }, .always, block_node);
+            // No `rvalue` call here, as the block result is always `void`, so we do that below.
             _ = try block_scope.addBreak(.@"break", block_inst, .void_value);
         }
 
@@ -2527,7 +2532,8 @@ fn labeledBlockExpr(
     if (!block_scope.endsWithNoReturn()) {
         // As our last action before the return, "pop" the error trace if needed
         _ = try gz.addRestoreErrRetIndex(.{ .block = block_inst }, .always, block_node);
-        _ = try block_scope.addBreak(.@"break", block_inst, .void_value);
+        const result = try rvalue(gz, block_scope.break_result_info, .void_value, block_node);
+        _ = try block_scope.addBreak(.@"break", block_inst, result);
     }
 
     if (!block_scope.label.?.used) {
@@ -2902,7 +2908,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
                 .breakpoint,
                 .disable_instrumentation,
                 .set_float_mode,
-                .set_align_stack,
                 .branch_hint,
                 => break :b true,
                 else => break :b false,
@@ -5008,6 +5013,25 @@ fn structDeclInner(
     layout: std.builtin.Type.ContainerLayout,
     backing_int_node: Ast.Node.Index,
 ) InnerError!Zir.Inst.Ref {
+    const astgen = gz.astgen;
+    const gpa = astgen.gpa;
+    const tree = astgen.tree;
+
+    {
+        const is_tuple = for (container_decl.ast.members) |member_node| {
+            const container_field = tree.fullContainerField(member_node) orelse continue;
+            if (container_field.ast.tuple_like) break true;
+        } else false;
+
+        if (is_tuple) {
+            if (node == 0) {
+                return astgen.failTok(0, "file cannot be a tuple", .{});
+            } else {
+                return tupleDecl(gz, scope, node, container_decl, layout, backing_int_node);
+            }
+        }
+    }
+
     const decl_inst = try gz.reserveInstructionIndex();
 
     if (container_decl.ast.members.len == 0 and backing_int_node == 0) {
@@ -5020,7 +5044,6 @@ fn structDeclInner(
             .has_backing_int = false,
             .known_non_opv = false,
             .known_comptime_only = false,
-            .is_tuple = false,
             .any_comptime_fields = false,
             .any_default_inits = false,
             .any_aligned_fields = false,
@@ -5029,10 +5052,6 @@ fn structDeclInner(
         return decl_inst.toRef();
     }
 
-    const astgen = gz.astgen;
-    const gpa = astgen.gpa;
-    const tree = astgen.tree;
-
     var namespace: Scope.Namespace = .{
         .parent = scope,
         .node = node,
@@ -5107,46 +5126,6 @@ fn structDeclInner(
     // No defer needed here because it is handled by `wip_members.deinit()` above.
     const bodies_start = astgen.scratch.items.len;
 
-    const node_tags = tree.nodes.items(.tag);
-    const is_tuple = for (container_decl.ast.members) |member_node| {
-        const container_field = tree.fullContainerField(member_node) orelse continue;
-        if (container_field.ast.tuple_like) break true;
-    } else false;
-
-    if (is_tuple) switch (layout) {
-        .auto => {},
-        .@"extern" => return astgen.failNode(node, "extern tuples are not supported", .{}),
-        .@"packed" => return astgen.failNode(node, "packed tuples are not supported", .{}),
-    };
-
-    if (is_tuple) for (container_decl.ast.members) |member_node| {
-        switch (node_tags[member_node]) {
-            .container_field_init,
-            .container_field_align,
-            .container_field,
-            .@"comptime",
-            .test_decl,
-            => continue,
-            else => {
-                const tuple_member = for (container_decl.ast.members) |maybe_tuple| switch (node_tags[maybe_tuple]) {
-                    .container_field_init,
-                    .container_field_align,
-                    .container_field,
-                    => break maybe_tuple,
-                    else => {},
-                } else unreachable;
-                return astgen.failNodeNotes(
-                    member_node,
-                    "tuple declarations cannot contain declarations",
-                    .{},
-                    &[_]u32{
-                        try astgen.errNoteNode(tuple_member, "tuple field here", .{}),
-                    },
-                );
-            },
-        }
-    };
-
     const old_hasher = astgen.src_hasher;
     defer astgen.src_hasher = old_hasher;
     astgen.src_hasher = std.zig.SrcHasher.init(.{});
@@ -5168,16 +5147,10 @@ fn structDeclInner(
 
         astgen.src_hasher.update(tree.getNodeSource(member_node));
 
-        if (!is_tuple) {
-            const field_name = try astgen.identAsString(member.ast.main_token);
-
-            member.convertToNonTupleLike(astgen.tree.nodes);
-            assert(!member.ast.tuple_like);
-
-            wip_members.appendToField(@intFromEnum(field_name));
-        } else if (!member.ast.tuple_like) {
-            return astgen.failTok(member.ast.main_token, "tuple field has a name", .{});
-        }
+        const field_name = try astgen.identAsString(member.ast.main_token);
+        member.convertToNonTupleLike(astgen.tree.nodes);
+        assert(!member.ast.tuple_like);
+        wip_members.appendToField(@intFromEnum(field_name));
 
         const doc_comment_index = try astgen.docCommentAsString(member.firstToken());
         wip_members.appendToField(@intFromEnum(doc_comment_index));
@@ -5271,7 +5244,6 @@ fn structDeclInner(
         .has_backing_int = backing_int_ref != .none,
         .known_non_opv = known_non_opv,
         .known_comptime_only = known_comptime_only,
-        .is_tuple = is_tuple,
         .any_comptime_fields = any_comptime_fields,
         .any_default_inits = any_default_inits,
         .any_aligned_fields = any_aligned_fields,
@@ -5301,6 +5273,106 @@ fn structDeclInner(
     return decl_inst.toRef();
 }
 
+fn tupleDecl(
+    gz: *GenZir,
+    scope: *Scope,
+    node: Ast.Node.Index,
+    container_decl: Ast.full.ContainerDecl,
+    layout: std.builtin.Type.ContainerLayout,
+    backing_int_node: Ast.Node.Index,
+) InnerError!Zir.Inst.Ref {
+    const astgen = gz.astgen;
+    const gpa = astgen.gpa;
+    const tree = astgen.tree;
+
+    const node_tags = tree.nodes.items(.tag);
+
+    switch (layout) {
+        .auto => {},
+        .@"extern" => return astgen.failNode(node, "extern tuples are not supported", .{}),
+        .@"packed" => return astgen.failNode(node, "packed tuples are not supported", .{}),
+    }
+
+    if (backing_int_node != 0) {
+        return astgen.failNode(backing_int_node, "tuple does not support backing integer type", .{});
+    }
+
+    // We will use the scratch buffer, starting here, for the field data:
+    // 1. fields: { // for every `fields_len` (stored in `extended.small`)
+    //        type: Inst.Ref,
+    //        init: Inst.Ref, // `.none` for non-`comptime` fields
+    //    }
+    const fields_start = astgen.scratch.items.len;
+    defer astgen.scratch.items.len = fields_start;
+
+    try astgen.scratch.ensureUnusedCapacity(gpa, container_decl.ast.members.len * 2);
+
+    for (container_decl.ast.members) |member_node| {
+        const field = tree.fullContainerField(member_node) orelse {
+            const tuple_member = for (container_decl.ast.members) |maybe_tuple| switch (node_tags[maybe_tuple]) {
+                .container_field_init,
+                .container_field_align,
+                .container_field,
+                => break maybe_tuple,
+                else => {},
+            } else unreachable;
+            return astgen.failNodeNotes(
+                member_node,
+                "tuple declarations cannot contain declarations",
+                .{},
+                &.{try astgen.errNoteNode(tuple_member, "tuple field here", .{})},
+            );
+        };
+
+        if (!field.ast.tuple_like) {
+            return astgen.failTok(field.ast.main_token, "tuple field has a name", .{});
+        }
+
+        if (field.ast.align_expr != 0) {
+            return astgen.failTok(field.ast.main_token, "tuple field has alignment", .{});
+        }
+
+        if (field.ast.value_expr != 0 and field.comptime_token == null) {
+            return astgen.failTok(field.ast.main_token, "non-comptime tuple field has default initialization value", .{});
+        }
+
+        if (field.ast.value_expr == 0 and field.comptime_token != null) {
+            return astgen.failTok(field.comptime_token.?, "comptime field without default initialization value", .{});
+        }
+
+        const field_type_ref = try typeExpr(gz, scope, field.ast.type_expr);
+        astgen.scratch.appendAssumeCapacity(@intFromEnum(field_type_ref));
+
+        if (field.ast.value_expr != 0) {
+            const field_init_ref = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = field_type_ref } }, field.ast.value_expr);
+            astgen.scratch.appendAssumeCapacity(@intFromEnum(field_init_ref));
+        } else {
+            astgen.scratch.appendAssumeCapacity(@intFromEnum(Zir.Inst.Ref.none));
+        }
+    }
+
+    const fields_len = std.math.cast(u16, container_decl.ast.members.len) orelse {
+        return astgen.failNode(node, "this compiler implementation only supports 65535 tuple fields", .{});
+    };
+
+    const extra_trail = astgen.scratch.items[fields_start..];
+    assert(extra_trail.len == fields_len * 2);
+    try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.TupleDecl).@"struct".fields.len + extra_trail.len);
+    const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.TupleDecl{
+        .src_node = gz.nodeIndexToRelative(node),
+    });
+    astgen.extra.appendSliceAssumeCapacity(extra_trail);
+
+    return gz.add(.{
+        .tag = .extended,
+        .data = .{ .extended = .{
+            .opcode = .tuple_decl,
+            .small = fields_len,
+            .operand = payload_index,
+        } },
+    });
+}
+
 fn unionDeclInner(
     gz: *GenZir,
     scope: *Scope,
@@ -9274,6 +9346,15 @@ fn builtinCall(
             });
             return rvalue(gz, ri, result, node);
         },
+        .FieldType => {
+            const ty_inst = try typeExpr(gz, scope, params[0]);
+            const name_inst = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, params[1]);
+            const result = try gz.addPlNode(.field_type_ref, node, Zir.Inst.FieldTypeRef{
+                .container_type = ty_inst,
+                .field_name = name_inst,
+            });
+            return rvalue(gz, ri, result, node);
+        },
 
         // zig fmt: off
         .as         => return as(       gz, scope, ri, node, params[0], params[1]),
@@ -9315,14 +9396,6 @@ fn builtinCall(
             });
             return rvalue(gz, ri, .void_value, node);
         },
-        .set_align_stack => {
-            const order = try expr(gz, scope, coerced_align_ri, params[0]);
-            _ = try gz.addExtendedPayload(.set_align_stack, Zir.Inst.UnNode{
-                .node = gz.nodeIndexToRelative(node),
-                .operand = order,
-            });
-            return rvalue(gz, ri, .void_value, node);
-        },
 
         .src => {
             // Incorporate the source location into the source hash, so that
@@ -11172,7 +11245,7 @@ fn rvalueInner(
                 as_ty | @intFromEnum(Zir.Inst.Ref.slice_const_u8_sentinel_0_type),
                 as_ty | @intFromEnum(Zir.Inst.Ref.anyerror_void_error_union_type),
                 as_ty | @intFromEnum(Zir.Inst.Ref.generic_poison_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.empty_struct_type),
+                as_ty | @intFromEnum(Zir.Inst.Ref.empty_tuple_type),
                 as_comptime_int | @intFromEnum(Zir.Inst.Ref.zero),
                 as_comptime_int | @intFromEnum(Zir.Inst.Ref.one),
                 as_comptime_int | @intFromEnum(Zir.Inst.Ref.negative_one),
@@ -13173,7 +13246,6 @@ const GenZir = struct {
         layout: std.builtin.Type.ContainerLayout,
         known_non_opv: bool,
         known_comptime_only: bool,
-        is_tuple: bool,
         any_comptime_fields: bool,
         any_default_inits: bool,
         any_aligned_fields: bool,
@@ -13217,7 +13289,6 @@ const GenZir = struct {
                     .has_backing_int = args.has_backing_int,
                     .known_non_opv = args.known_non_opv,
                     .known_comptime_only = args.known_comptime_only,
-                    .is_tuple = args.is_tuple,
                     .name_strategy = gz.anon_name_strategy,
                     .layout = args.layout,
                     .any_comptime_fields = args.any_comptime_fields,
diff --git a/zig/lib/std/zig/AstRlAnnotate.zig b/zig/lib/std/zig/AstRlAnnotate.zig
index 104cea1154..e790612505 100644
--- a/zig/lib/std/zig/AstRlAnnotate.zig
+++ b/zig/lib/std/zig/AstRlAnnotate.zig
@@ -909,12 +909,10 @@ fn builtinCall(astrl: *AstRlAnnotate, block: ?*Block, ri: ResultInfo, node: Ast.
         .wasm_memory_size,
         .splat,
         .set_float_mode,
-        .set_align_stack,
         .type_info,
         .work_item_id,
         .work_group_size,
         .work_group_id,
-        .field_parent_ptr,
         => {
             _ = try astrl.expr(args[0], block, ResultInfo.type_only);
             return false;
@@ -983,11 +981,17 @@ fn builtinCall(astrl: *AstRlAnnotate, block: ?*Block, ri: ResultInfo, node: Ast.
         .has_decl,
         .has_field,
         .field,
+        .FieldType,
         => {
             _ = try astrl.expr(args[0], block, ResultInfo.type_only);
             _ = try astrl.expr(args[1], block, ResultInfo.type_only);
             return false;
         },
+        .field_parent_ptr => {
+            _ = try astrl.expr(args[0], block, ResultInfo.type_only);
+            _ = try astrl.expr(args[1], block, ResultInfo.none);
+            return false;
+        },
         .wasm_memory_grow => {
             _ = try astrl.expr(args[0], block, ResultInfo.type_only);
             _ = try astrl.expr(args[1], block, ResultInfo.type_only);
diff --git a/zig/lib/std/zig/BuiltinFn.zig b/zig/lib/std/zig/BuiltinFn.zig
index 6b0d0cc0a2..7ad5bb1a87 100644
--- a/zig/lib/std/zig/BuiltinFn.zig
+++ b/zig/lib/std/zig/BuiltinFn.zig
@@ -1,5 +1,3 @@
-const std = @import("std");
-
 pub const Tag = enum {
     add_with_overflow,
     addrspace_cast,
@@ -50,6 +48,7 @@ pub const Tag = enum {
     @"extern",
     field,
     field_parent_ptr,
+    FieldType,
     float_cast,
     int_from_float,
     frame,
@@ -81,7 +80,6 @@ pub const Tag = enum {
     rem,
     return_address,
     select,
-    set_align_stack,
     set_eval_branch_quota,
     set_float_mode,
     set_runtime_safety,
@@ -124,17 +122,6 @@ pub const Tag = enum {
     work_group_id,
 };
 
-pub const MemLocRequirement = enum {
-    /// The builtin never needs a memory location.
-    never,
-    /// The builtin always needs a memory location.
-    always,
-    /// The builtin forwards the question to argument at index 0.
-    forward0,
-    /// The builtin forwards the question to argument at index 1.
-    forward1,
-};
-
 pub const EvalToError = enum {
     /// The builtin cannot possibly evaluate to an error.
     never,
@@ -146,8 +133,6 @@ pub const EvalToError = enum {
 
 tag: Tag,
 
-/// Info about the builtin call's ability to take advantage of a result location pointer.
-needs_mem_loc: MemLocRequirement = .never,
 /// Info about the builtin call's possibility of returning an error.
 eval_to_error: EvalToError = .never,
 /// `true` if the builtin call can be the left-hand side of an expression (assigned to).
@@ -160,7 +145,7 @@ param_count: ?u8,
 
 pub const list = list: {
     @setEvalBranchQuota(3000);
-    break :list std.StaticStringMap(@This()).initComptime(.{
+    break :list std.StaticStringMap(BuiltinFn).initComptime([_]struct { []const u8, BuiltinFn }{
         .{
             "@addWithOverflow",
             .{
@@ -193,7 +178,6 @@ pub const list = list: {
             "@as",
             .{
                 .tag = .as,
-                .needs_mem_loc = .forward1,
                 .eval_to_error = .maybe,
                 .param_count = 2,
             },
@@ -230,7 +214,6 @@ pub const list = list: {
             "@bitCast",
             .{
                 .tag = .bit_cast,
-                .needs_mem_loc = .forward0,
                 .param_count = 1,
             },
         },
@@ -311,7 +294,6 @@ pub const list = list: {
             "@call",
             .{
                 .tag = .call,
-                .needs_mem_loc = .always,
                 .eval_to_error = .maybe,
                 .param_count = 3,
             },
@@ -503,7 +485,6 @@ pub const list = list: {
             "@field",
             .{
                 .tag = .field,
-                .needs_mem_loc = .always,
                 .eval_to_error = .maybe,
                 .param_count = 2,
                 .allows_lvalue = true,
@@ -516,6 +497,13 @@ pub const list = list: {
                 .param_count = 2,
             },
         },
+        .{
+            "@FieldType",
+            .{
+                .tag = .FieldType,
+                .param_count = 2,
+            },
+        },
         .{
             "@floatCast",
             .{
@@ -736,14 +724,6 @@ pub const list = list: {
                 .param_count = 4,
             },
         },
-        .{
-            "@setAlignStack",
-            .{
-                .tag = .set_align_stack,
-                .param_count = 1,
-                .illegal_outside_function = true,
-            },
-        },
         .{
             "@setEvalBranchQuota",
             .{
@@ -818,7 +798,6 @@ pub const list = list: {
             "@src",
             .{
                 .tag = .src,
-                .needs_mem_loc = .always,
                 .param_count = 0,
                 .illegal_outside_function = true,
             },
@@ -988,7 +967,6 @@ pub const list = list: {
             "@unionInit",
             .{
                 .tag = .union_init,
-                .needs_mem_loc = .always,
                 .param_count = 3,
             },
         },
@@ -1031,3 +1009,6 @@ pub const list = list: {
         },
     });
 };
+
+const std = @import("std");
+const BuiltinFn = @This();
diff --git a/zig/lib/std/zig/LibCDirs.zig b/zig/lib/std/zig/LibCDirs.zig
index 8b8a3a8d42..43c4c5d28f 100644
--- a/zig/lib/std/zig/LibCDirs.zig
+++ b/zig/lib/std/zig/LibCDirs.zig
@@ -167,21 +167,16 @@ pub fn detectFromBuilding(
     }
 
     const generic_name = libCGenericName(target);
-    // Some architectures are handled by the same set of headers.
+    // Some architecture families are handled by the same set of headers.
     const arch_name = if (target.abi.isMusl())
         std.zig.target.muslArchNameHeaders(target.cpu.arch)
-    else if (target.cpu.arch.isThumb())
-        // ARM headers are valid for Thumb too.
-        switch (target.cpu.arch) {
-            .thumb => "arm",
-            .thumbeb => "armeb",
-            else => unreachable,
-        }
     else
         @tagName(target.cpu.arch);
     const os_name = @tagName(target.os.tag);
-    // Musl's headers are ABI-agnostic and so they all have the "musl" ABI name.
-    const abi_name = if (target.abi.isMusl()) "musl" else @tagName(target.abi);
+    const abi_name = if (target.abi.isMusl())
+        std.zig.target.muslAbiNameHeaders(target.abi)
+    else
+        @tagName(target.abi);
     const arch_include_dir = try std.fmt.allocPrint(
         arena,
         "{s}" ++ s ++ "libc" ++ s ++ "include" ++ s ++ "{s}-{s}-{s}",
@@ -237,6 +232,8 @@ fn libCGenericName(target: std.Target) [:0]const u8 {
         .gnuilp32,
         => return "glibc",
         .musl,
+        .muslabin32,
+        .muslabi64,
         .musleabi,
         .musleabihf,
         .muslx32,
diff --git a/zig/lib/std/zig/Zir.zig b/zig/lib/std/zig/Zir.zig
index 9c76f72663..00a48e21f7 100644
--- a/zig/lib/std/zig/Zir.zig
+++ b/zig/lib/std/zig/Zir.zig
@@ -1887,6 +1887,10 @@ pub const Inst = struct {
         /// `operand` is payload index to `OpaqueDecl`.
         /// `small` is `OpaqueDecl.Small`.
         opaque_decl,
+        /// A tuple type. Note that tuples are not namespace/container types.
+        /// `operand` is payload index to `TupleDecl`.
+        /// `small` is `fields_len: u16`.
+        tuple_decl,
         /// Implements the `@This` builtin.
         /// `operand` is `src_node: i32`.
         this,
@@ -1982,9 +1986,6 @@ pub const Inst = struct {
         /// Implement builtin `@setFloatMode`.
         /// `operand` is payload index to `UnNode`.
         set_float_mode,
-        /// Implement builtin `@setAlignStack`.
-        /// `operand` is payload index to `UnNode`.
-        set_align_stack,
         /// Implements the `@errorCast` builtin.
         /// `operand` is payload index to `BinNode`. `lhs` is dest type, `rhs` is operand.
         error_cast,
@@ -2190,7 +2191,7 @@ pub const Inst = struct {
         anyerror_void_error_union_type,
         adhoc_inferred_error_set_type,
         generic_poison_type,
-        empty_struct_type,
+        empty_tuple_type,
         undef,
         zero,
         zero_usize,
@@ -2205,7 +2206,7 @@ pub const Inst = struct {
         null_value,
         bool_true,
         bool_false,
-        empty_struct,
+        empty_tuple,
         generic_poison,
 
         /// This Ref does not correspond to any ZIR instruction or constant
@@ -3044,7 +3045,7 @@ pub const Inst = struct {
     ///      0b0X00: whether corresponding field is comptime
     ///      0bX000: whether corresponding field has a type expression
     /// 9. fields: { // for every fields_len
-    ///        field_name: u32, // if !is_tuple
+    ///        field_name: u32,
     ///        doc_comment: NullTerminatedString, // .empty if no doc comment
     ///        field_type: Ref, // if corresponding bit is not set. none means anytype.
     ///        field_type_body_len: u32, // if corresponding bit is set
@@ -3074,13 +3075,12 @@ pub const Inst = struct {
             has_backing_int: bool,
             known_non_opv: bool,
             known_comptime_only: bool,
-            is_tuple: bool,
             name_strategy: NameStrategy,
             layout: std.builtin.Type.ContainerLayout,
             any_default_inits: bool,
             any_comptime_fields: bool,
             any_aligned_fields: bool,
-            _: u2 = undefined,
+            _: u3 = undefined,
         };
     };
 
@@ -3305,6 +3305,15 @@ pub const Inst = struct {
         };
     };
 
+    /// Trailing:
+    /// 1. fields: { // for every `fields_len` (stored in `extended.small`)
+    ///        type: Inst.Ref,
+    ///        init: Inst.Ref, // `.none` for non-`comptime` fields
+    ///    }
+    pub const TupleDecl = struct {
+        src_node: i32, // relative
+    };
+
     /// Trailing:
     /// { // for every fields_len
     ///      field_name: NullTerminatedString // null terminated string index
@@ -3332,6 +3341,11 @@ pub const Inst = struct {
 
     /// Trailing is an item per field.
     pub const StructInit = struct {
+        /// If this is an anonymous initialization (the operand is poison), this instruction becomes the owner of a type.
+        /// To resolve source locations, we need an absolute source node.
+        abs_node: Ast.Node.Index,
+        /// Likewise, we need an absolute line number.
+        abs_line: u32,
         fields_len: u32,
 
         pub const Item = struct {
@@ -3347,6 +3361,11 @@ pub const Inst = struct {
     /// TODO make this instead array of inits followed by array of names because
     /// it will be simpler Sema code and better for CPU cache.
     pub const StructInitAnon = struct {
+        /// This is an anonymous initialization, meaning this instruction becomes the owner of a type.
+        /// To resolve source locations, we need an absolute source node.
+        abs_node: Ast.Node.Index,
+        /// Likewise, we need an absolute line number.
+        abs_line: u32,
         fields_len: u32,
 
         pub const Item = struct {
@@ -3744,6 +3763,8 @@ fn findDeclsInner(
     defers: *std.AutoHashMapUnmanaged(u32, void),
     inst: Inst.Index,
 ) Allocator.Error!void {
+    comptime assert(Zir.inst_tracking_version == 0);
+
     const tags = zir.instructions.items(.tag);
     const datas = zir.instructions.items(.data);
 
@@ -3887,9 +3908,6 @@ fn findDeclsInner(
         .struct_init_empty,
         .struct_init_empty_result,
         .struct_init_empty_ref_result,
-        .struct_init_anon,
-        .struct_init,
-        .struct_init_ref,
         .validate_struct_init_ty,
         .validate_struct_init_result_ty,
         .validate_ptr_struct_init,
@@ -3981,6 +3999,12 @@ fn findDeclsInner(
         .restore_err_ret_index_fn_entry,
         => return,
 
+        // Struct initializations need tracking, as they may create anonymous struct types.
+        .struct_init,
+        .struct_init_ref,
+        .struct_init_anon,
+        => return list.append(gpa, inst),
+
         .extended => {
             const extended = datas[@intFromEnum(inst)].extended;
             switch (extended.opcode) {
@@ -4012,7 +4036,6 @@ fn findDeclsInner(
                 .wasm_memory_grow,
                 .prefetch,
                 .set_float_mode,
-                .set_align_stack,
                 .error_cast,
                 .await_nosuspend,
                 .breakpoint,
@@ -4038,6 +4061,7 @@ fn findDeclsInner(
                 .builtin_value,
                 .branch_hint,
                 .inplace_arith_result_ty,
+                .tuple_decl,
                 => return,
 
                 // `@TypeOf` has a body.
@@ -4114,8 +4138,7 @@ fn findDeclsInner(
                         const has_type_body = @as(u1, @truncate(cur_bit_bag)) != 0;
                         cur_bit_bag >>= 1;
 
-                        fields_extra_index += @intFromBool(!small.is_tuple); // field_name
-                        fields_extra_index += 1; // doc_comment
+                        fields_extra_index += 2; // field_name, doc_comment
 
                         if (has_type_body) {
                             const field_type_body_len = zir.extra[fields_extra_index];
@@ -4740,3 +4763,35 @@ pub fn getAssociatedSrcHash(zir: Zir, inst: Zir.Inst.Index) ?std.zig.SrcHash {
         else => return null,
     }
 }
+
+/// When the ZIR update tracking logic must be modified to consider new instructions,
+/// change this constant to trigger compile errors at all relevant locations.
+pub const inst_tracking_version = 0;
+
+/// Asserts that a ZIR instruction is tracked across incremental updates, and
+/// thus may be given an `InternPool.TrackedInst`.
+pub fn assertTrackable(zir: Zir, inst_idx: Zir.Inst.Index) void {
+    comptime assert(Zir.inst_tracking_version == 0);
+    const inst = zir.instructions.get(@intFromEnum(inst_idx));
+    switch (inst.tag) {
+        .struct_init,
+        .struct_init_ref,
+        .struct_init_anon,
+        => {}, // tracked in order, as the owner instructions of anonymous struct types
+        .func,
+        .func_inferred,
+        .func_fancy,
+        => {}, // tracked in order, as the owner instructions of function bodies
+        .declaration => {}, // tracked by correlating names in the namespace of the parent container
+        .extended => switch (inst.data.extended.opcode) {
+            .struct_decl,
+            .union_decl,
+            .enum_decl,
+            .opaque_decl,
+            .reify,
+            => {}, // tracked in order, as the owner instructions of explicit container types
+            else => unreachable, // assertion failure; not trackable
+        },
+        else => unreachable, // assertion failure; not trackable
+    }
+}
diff --git a/zig/lib/std/zig/c_builtins.zig b/zig/lib/std/zig/c_builtins.zig
index e2b4c4302b..2f6c2e8aa5 100644
--- a/zig/lib/std/zig/c_builtins.zig
+++ b/zig/lib/std/zig/c_builtins.zig
@@ -265,4 +265,4 @@ pub fn __builtin_mul_overflow(a: anytype, b: anytype, result: *@TypeOf(a, b)) c_
 // It is used in a run-translated-c test and a test-translate-c test to ensure that non-implemented
 // builtins are correctly demoted. If you implement __builtin_alloca_with_align, please update the
 // run-translated-c test and the test-translate-c test to use a different non-implemented builtin.
-// pub fn __builtin_alloca_with_align(size: usize, alignment: usize) callconv(.Inline) *anyopaque {}
+// pub inline fn __builtin_alloca_with_align(size: usize, alignment: usize) *anyopaque {}
diff --git a/zig/lib/std/zig/parser_test.zig b/zig/lib/std/zig/parser_test.zig
index e2c9b034ed..5261816544 100644
--- a/zig/lib/std/zig/parser_test.zig
+++ b/zig/lib/std/zig/parser_test.zig
@@ -107,15 +107,15 @@ test "zig fmt: respect line breaks before functions" {
     );
 }
 
-test "zig fmt: rewrite callconv(.Inline) to the inline keyword" {
+test "zig fmt: rewrite callconv(.@\"inline\") to the inline keyword" {
     try testTransform(
-        \\fn foo() callconv(.Inline) void {}
-        \\const bar = .Inline;
+        \\fn foo() callconv(.@"inline") void {}
+        \\const bar: @import("std").builtin.CallingConvention = .@"inline";
         \\fn foo() callconv(bar) void {}
         \\
     ,
         \\inline fn foo() void {}
-        \\const bar = .Inline;
+        \\const bar: @import("std").builtin.CallingConvention = .@"inline";
         \\fn foo() callconv(bar) void {}
         \\
     );
@@ -3062,7 +3062,7 @@ test "zig fmt: functions" {
         \\pub export fn puts(s: *const u8) align(2 + 2) c_int;
         \\pub inline fn puts(s: *const u8) align(2 + 2) c_int;
         \\pub noinline fn puts(s: *const u8) align(2 + 2) c_int;
-        \\pub fn callInlineFn(func: fn () callconv(.Inline) void) void {
+        \\pub fn callInlineFn(func: fn () callconv(.@"inline") void) void {
         \\    func();
         \\}
         \\
diff --git a/zig/lib/std/zig/render.zig b/zig/lib/std/zig/render.zig
index c78a8cb07d..b71c94e71f 100644
--- a/zig/lib/std/zig/render.zig
+++ b/zig/lib/std/zig/render.zig
@@ -184,8 +184,9 @@ fn renderMember(
                         tree.extraData(datas[fn_proto].lhs, Ast.Node.FnProtoOne).callconv_expr
                     else
                         tree.extraData(datas[fn_proto].lhs, Ast.Node.FnProto).callconv_expr;
+                    // Keep in sync with logic in `renderFnProto`. Search this file for the marker PROMOTE_CALLCONV_INLINE
                     if (callconv_expr != 0 and tree.nodes.items(.tag)[callconv_expr] == .enum_literal) {
-                        if (mem.eql(u8, "Inline", tree.tokenSlice(main_tokens[callconv_expr]))) {
+                        if (mem.eql(u8, "@\"inline\"", tree.tokenSlice(main_tokens[callconv_expr]))) {
                             try ais.writer().writeAll("inline ");
                         }
                     }
@@ -1839,7 +1840,8 @@ fn renderFnProto(r: *Render, fn_proto: Ast.full.FnProto, space: Space) Error!voi
         try renderToken(r, section_rparen, .space); // )
     }
 
-    const is_callconv_inline = mem.eql(u8, "Inline", tree.tokenSlice(tree.nodes.items(.main_token)[fn_proto.ast.callconv_expr]));
+    // Keep in sync with logic in `renderMember`. Search this file for the marker PROMOTE_CALLCONV_INLINE
+    const is_callconv_inline = mem.eql(u8, "@\"inline\"", tree.tokenSlice(tree.nodes.items(.main_token)[fn_proto.ast.callconv_expr]));
     const is_declaration = fn_proto.name_token != null;
     if (fn_proto.ast.callconv_expr != 0 and !(is_declaration and is_callconv_inline)) {
         const callconv_lparen = tree.firstToken(fn_proto.ast.callconv_expr) - 1;
diff --git a/zig/lib/std/zig/system.zig b/zig/lib/std/zig/system.zig
index 5feb08ab28..d4eb76dc3d 100644
--- a/zig/lib/std/zig/system.zig
+++ b/zig/lib/std/zig/system.zig
@@ -91,16 +91,16 @@ pub fn getExternalExecutor(
             .mips => Executor{ .qemu = "qemu-mips" },
             .mipsel => Executor{ .qemu = "qemu-mipsel" },
             .mips64 => Executor{
-                .qemu = if (candidate.abi == .gnuabin32)
-                    "qemu-mipsn32"
-                else
-                    "qemu-mips64",
+                .qemu = switch (candidate.abi) {
+                    .gnuabin32, .muslabin32 => "qemu-mipsn32",
+                    else => "qemu-mips64",
+                },
             },
             .mips64el => Executor{
-                .qemu = if (candidate.abi == .gnuabin32)
-                    "qemu-mipsn32el"
-                else
-                    "qemu-mips64el",
+                .qemu = switch (candidate.abi) {
+                    .gnuabin32, .muslabin32 => "qemu-mipsn32el",
+                    else => "qemu-mips64el",
+                },
             },
             .powerpc => Executor{ .qemu = "qemu-ppc" },
             .powerpc64 => Executor{ .qemu = "qemu-ppc64" },
@@ -331,20 +331,24 @@ pub fn resolveTargetQuery(query: Target.Query) DetectError!Target {
         os.version_range.linux.glibc = glibc;
     }
 
+    if (query.android_api_level) |android| {
+        os.version_range.linux.android = android;
+    }
+
     // Until https://github.com/ziglang/zig/issues/4592 is implemented (support detecting the
     // native CPU architecture as being different than the current target), we use this:
     const cpu_arch = query.cpu_arch orelse builtin.cpu.arch;
 
     const cpu = switch (query.cpu_model) {
         .native => detectNativeCpuAndFeatures(cpu_arch, os, query),
-        .baseline => Target.Cpu.baseline(cpu_arch),
-        .determined_by_cpu_arch => if (query.cpu_arch == null)
+        .baseline => Target.Cpu.baseline(cpu_arch, os),
+        .determined_by_arch_os => if (query.cpu_arch == null)
             detectNativeCpuAndFeatures(cpu_arch, os, query)
         else
-            Target.Cpu.baseline(cpu_arch),
+            Target.Cpu.baseline(cpu_arch, os),
         .explicit => |model| model.toCpu(cpu_arch),
     } orelse backup_cpu_detection: {
-        break :backup_cpu_detection Target.Cpu.baseline(cpu_arch);
+        break :backup_cpu_detection Target.Cpu.baseline(cpu_arch, os);
     };
     var result = try detectAbiAndDynamicLinker(cpu, os, query);
     // For x86, we need to populate some CPU feature flags depending on architecture
@@ -397,7 +401,7 @@ pub fn resolveTargetQuery(query: Target.Query) DetectError!Target {
     }
 
     // https://github.com/llvm/llvm-project/issues/105978
-    if (result.cpu.arch.isArmOrThumb() and result.floatAbi() == .soft) {
+    if (result.cpu.arch.isArm() and result.floatAbi() == .soft) {
         result.cpu.features.removeFeature(@intFromEnum(Target.arm.Feature.vfp2));
     }
 
@@ -963,14 +967,15 @@ fn detectAbiAndDynamicLinker(
     os: Target.Os,
     query: Target.Query,
 ) DetectError!Target {
-    const native_target_has_ld = comptime builtin.target.hasDynamicLinker();
+    const native_target_has_ld = comptime Target.DynamicLinker.kind(builtin.os.tag) != .none;
     const is_linux = builtin.target.os.tag == .linux;
     const is_solarish = builtin.target.os.tag.isSolarish();
+    const is_darwin = builtin.target.os.tag.isDarwin();
     const have_all_info = query.dynamic_linker.get() != null and
         query.abi != null and (!is_linux or query.abi.?.isGnu());
     const os_is_non_native = query.os_tag != null;
     // The Solaris/illumos environment is always the same.
-    if (!native_target_has_ld or have_all_info or os_is_non_native or is_solarish) {
+    if (!native_target_has_ld or have_all_info or os_is_non_native or is_solarish or is_darwin) {
         return defaultAbiAndDynamicLinker(cpu, os, query);
     }
     if (query.abi) |abi| {
@@ -995,26 +1000,33 @@ fn detectAbiAndDynamicLinker(
     };
     var ld_info_list_buffer: [all_abis.len]LdInfo = undefined;
     var ld_info_list_len: usize = 0;
-    const ofmt = query.ofmt orelse Target.ObjectFormat.default(os.tag, cpu.arch);
-
-    for (all_abis) |abi| {
-        // This may be a nonsensical parameter. We detect this with
-        // error.UnknownDynamicLinkerPath and skip adding it to `ld_info_list`.
-        const target: Target = .{
-            .cpu = cpu,
-            .os = os,
-            .abi = abi,
-            .ofmt = ofmt,
-        };
-        const ld = target.standardDynamicLinkerPath();
-        if (ld.get() == null) continue;
 
-        ld_info_list_buffer[ld_info_list_len] = .{
-            .ld = ld,
-            .abi = abi,
-        };
-        ld_info_list_len += 1;
+    switch (Target.DynamicLinker.kind(os.tag)) {
+        // The OS has no dynamic linker. Leave the list empty and rely on `Abi.default()` to pick
+        // something sensible in `abiAndDynamicLinkerFromFile()`.
+        .none => {},
+        // The OS has a system-wide dynamic linker. Unfortunately, this implies that there's no
+        // useful ABI information that we can glean from it merely being present. That means the
+        // best we can do for this case (for now) is also `Abi.default()`.
+        .arch_os => {},
+        // The OS can have different dynamic linker paths depending on libc/ABI. In this case, we
+        // need to gather all the valid arch/OS/ABI combinations. `abiAndDynamicLinkerFromFile()`
+        // will then look for a dynamic linker with a matching path on the system and pick the ABI
+        // we associated it with here.
+        .arch_os_abi => for (all_abis) |abi| {
+            const ld = Target.DynamicLinker.standard(cpu, os, abi);
+
+            // Does the generated target triple actually have a standard dynamic linker path?
+            if (ld.get() == null) continue;
+
+            ld_info_list_buffer[ld_info_list_len] = .{
+                .ld = ld,
+                .abi = abi,
+            };
+            ld_info_list_len += 1;
+        },
     }
+
     const ld_info_list = ld_info_list_buffer[0..ld_info_list_len];
 
     // Best case scenario: the executable is dynamically linked, and we can iterate
diff --git a/zig/lib/std/zig/system/darwin/macos.zig b/zig/lib/std/zig/system/darwin/macos.zig
index 3201f102b6..f5f413cb4e 100644
--- a/zig/lib/std/zig/system/darwin/macos.zig
+++ b/zig/lib/std/zig/system/darwin/macos.zig
@@ -277,7 +277,7 @@ const SystemVersionTokenizer = struct {
 };
 
 test "detect" {
-    const cases = .{
+    const cases: [5]struct { []const u8, std.SemanticVersion } = .{
         .{
             \\<?xml version="1.0" encoding="UTF-8"?>
             \\<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -388,8 +388,8 @@ test "detect" {
 
     inline for (cases) |case| {
         const ver0 = try parseSystemVersion(case[0]);
-        const ver1: std.SemanticVersion = case[1];
-        try testing.expectEqual(@as(std.math.Order, .eq), ver0.order(ver1));
+        const ver1 = case[1];
+        try testing.expectEqual(std.math.Order.eq, ver0.order(ver1));
     }
 }
 
diff --git a/zig/lib/std/zig/target.zig b/zig/lib/std/zig/target.zig
index 59fccc582c..c72b221936 100644
--- a/zig/lib/std/zig/target.zig
+++ b/zig/lib/std/zig/target.zig
@@ -9,58 +9,57 @@ pub const ArchOsAbi = struct {
 };
 
 pub const available_libcs = [_]ArchOsAbi{
-    .{ .arch = .aarch64_be, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 17, .patch = 0 } },
-    .{ .arch = .aarch64_be, .os = .linux, .abi = .musl },
-    .{ .arch = .aarch64, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 17, .patch = 0 } },
-    .{ .arch = .aarch64, .os = .linux, .abi = .musl },
-    .{ .arch = .aarch64, .os = .windows, .abi = .gnu },
-    .{ .arch = .aarch64, .os = .macos, .abi = .none, .os_ver = .{ .major = 11, .minor = 0, .patch = 0 } },
     .{ .arch = .arc, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 32, .patch = 0 } },
-    .{ .arch = .armeb, .os = .linux, .abi = .gnueabi },
-    .{ .arch = .armeb, .os = .linux, .abi = .gnueabihf },
-    .{ .arch = .armeb, .os = .linux, .abi = .musleabi },
-    .{ .arch = .armeb, .os = .linux, .abi = .musleabihf },
     .{ .arch = .arm, .os = .linux, .abi = .gnueabi },
     .{ .arch = .arm, .os = .linux, .abi = .gnueabihf },
     .{ .arch = .arm, .os = .linux, .abi = .musleabi },
     .{ .arch = .arm, .os = .linux, .abi = .musleabihf },
+    .{ .arch = .armeb, .os = .linux, .abi = .gnueabi },
+    .{ .arch = .armeb, .os = .linux, .abi = .gnueabihf },
+    .{ .arch = .armeb, .os = .linux, .abi = .musleabi },
+    .{ .arch = .armeb, .os = .linux, .abi = .musleabihf },
     .{ .arch = .thumb, .os = .linux, .abi = .musleabi },
     .{ .arch = .thumb, .os = .linux, .abi = .musleabihf },
+    .{ .arch = .thumb, .os = .windows, .abi = .gnu },
     .{ .arch = .thumbeb, .os = .linux, .abi = .musleabi },
     .{ .arch = .thumbeb, .os = .linux, .abi = .musleabihf },
-    .{ .arch = .thumb, .os = .windows, .abi = .gnu },
+    .{ .arch = .aarch64, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 17, .patch = 0 } },
+    .{ .arch = .aarch64, .os = .linux, .abi = .musl },
+    .{ .arch = .aarch64, .os = .macos, .abi = .none, .os_ver = .{ .major = 11, .minor = 0, .patch = 0 } },
+    .{ .arch = .aarch64, .os = .windows, .abi = .gnu },
+    .{ .arch = .aarch64_be, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 17, .patch = 0 } },
+    .{ .arch = .aarch64_be, .os = .linux, .abi = .musl },
     .{ .arch = .csky, .os = .linux, .abi = .gnueabi, .glibc_min = .{ .major = 2, .minor = 29, .patch = 0 } },
     .{ .arch = .csky, .os = .linux, .abi = .gnueabihf, .glibc_min = .{ .major = 2, .minor = 29, .patch = 0 } },
-    .{ .arch = .x86, .os = .linux, .abi = .gnu },
-    .{ .arch = .x86, .os = .linux, .abi = .musl },
-    .{ .arch = .x86, .os = .windows, .abi = .gnu },
     .{ .arch = .loongarch64, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 } },
     .{ .arch = .loongarch64, .os = .linux, .abi = .gnusf, .glibc_min = .{ .major = 2, .minor = 36, .patch = 0 } },
     .{ .arch = .loongarch64, .os = .linux, .abi = .musl },
     .{ .arch = .m68k, .os = .linux, .abi = .gnu },
     .{ .arch = .m68k, .os = .linux, .abi = .musl },
-    .{ .arch = .mips64el, .os = .linux, .abi = .gnuabi64 },
-    .{ .arch = .mips64el, .os = .linux, .abi = .gnuabin32 },
-    .{ .arch = .mips64el, .os = .linux, .abi = .musl },
-    .{ .arch = .mips64, .os = .linux, .abi = .gnuabi64 },
-    .{ .arch = .mips64, .os = .linux, .abi = .gnuabin32 },
-    .{ .arch = .mips64, .os = .linux, .abi = .musl },
-    .{ .arch = .mipsel, .os = .linux, .abi = .gnueabi },
-    .{ .arch = .mipsel, .os = .linux, .abi = .gnueabihf },
-    .{ .arch = .mipsel, .os = .linux, .abi = .musleabi },
-    .{ .arch = .mipsel, .os = .linux, .abi = .musleabihf },
     .{ .arch = .mips, .os = .linux, .abi = .gnueabi },
     .{ .arch = .mips, .os = .linux, .abi = .gnueabihf },
     .{ .arch = .mips, .os = .linux, .abi = .musleabi },
     .{ .arch = .mips, .os = .linux, .abi = .musleabihf },
-    .{ .arch = .powerpc64le, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 19, .patch = 0 } },
-    .{ .arch = .powerpc64le, .os = .linux, .abi = .musl },
-    .{ .arch = .powerpc64, .os = .linux, .abi = .gnu },
-    .{ .arch = .powerpc64, .os = .linux, .abi = .musl },
+    .{ .arch = .mipsel, .os = .linux, .abi = .gnueabi },
+    .{ .arch = .mipsel, .os = .linux, .abi = .gnueabihf },
+    .{ .arch = .mipsel, .os = .linux, .abi = .musleabi },
+    .{ .arch = .mipsel, .os = .linux, .abi = .musleabihf },
+    .{ .arch = .mips64, .os = .linux, .abi = .gnuabi64 },
+    .{ .arch = .mips64, .os = .linux, .abi = .gnuabin32 },
+    .{ .arch = .mips64, .os = .linux, .abi = .muslabi64 },
+    .{ .arch = .mips64, .os = .linux, .abi = .muslabin32 },
+    .{ .arch = .mips64el, .os = .linux, .abi = .gnuabi64 },
+    .{ .arch = .mips64el, .os = .linux, .abi = .gnuabin32 },
+    .{ .arch = .mips64el, .os = .linux, .abi = .muslabi64 },
+    .{ .arch = .mips64el, .os = .linux, .abi = .muslabin32 },
     .{ .arch = .powerpc, .os = .linux, .abi = .gnueabi },
     .{ .arch = .powerpc, .os = .linux, .abi = .gnueabihf },
     .{ .arch = .powerpc, .os = .linux, .abi = .musleabi },
     .{ .arch = .powerpc, .os = .linux, .abi = .musleabihf },
+    .{ .arch = .powerpc64, .os = .linux, .abi = .gnu },
+    .{ .arch = .powerpc64, .os = .linux, .abi = .musl },
+    .{ .arch = .powerpc64le, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 19, .patch = 0 } },
+    .{ .arch = .powerpc64le, .os = .linux, .abi = .musl },
     .{ .arch = .riscv32, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 33, .patch = 0 } },
     .{ .arch = .riscv32, .os = .linux, .abi = .musl },
     .{ .arch = .riscv64, .os = .linux, .abi = .gnu, .glibc_min = .{ .major = 2, .minor = 27, .patch = 0 } },
@@ -71,11 +70,15 @@ pub const available_libcs = [_]ArchOsAbi{
     .{ .arch = .sparc64, .os = .linux, .abi = .gnu },
     .{ .arch = .wasm32, .os = .freestanding, .abi = .musl },
     .{ .arch = .wasm32, .os = .wasi, .abi = .musl },
+    .{ .arch = .x86, .os = .linux, .abi = .gnu },
+    .{ .arch = .x86, .os = .linux, .abi = .musl },
+    .{ .arch = .x86, .os = .windows, .abi = .gnu },
     .{ .arch = .x86_64, .os = .linux, .abi = .gnu },
     .{ .arch = .x86_64, .os = .linux, .abi = .gnux32 },
     .{ .arch = .x86_64, .os = .linux, .abi = .musl },
-    .{ .arch = .x86_64, .os = .windows, .abi = .gnu },
+    .{ .arch = .x86_64, .os = .linux, .abi = .muslx32 },
     .{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 10, .minor = 7, .patch = 0 } },
+    .{ .arch = .x86_64, .os = .windows, .abi = .gnu },
 };
 
 pub fn canBuildLibC(target: std.Target) bool {
@@ -97,30 +100,177 @@ pub fn canBuildLibC(target: std.Target) bool {
     return false;
 }
 
+pub fn muslArchName(arch: std.Target.Cpu.Arch, abi: std.Target.Abi) [:0]const u8 {
+    return switch (abi) {
+        .muslabin32 => "mipsn32",
+        .muslx32 => "x32",
+        else => switch (arch) {
+            .arm, .armeb, .thumb, .thumbeb => "arm",
+            .aarch64, .aarch64_be => "aarch64",
+            .loongarch64 => "loongarch64",
+            .m68k => "m68k",
+            .mips, .mipsel => "mips",
+            .mips64el, .mips64 => "mips64",
+            .powerpc => "powerpc",
+            .powerpc64, .powerpc64le => "powerpc64",
+            .riscv32 => "riscv32",
+            .riscv64 => "riscv64",
+            .s390x => "s390x",
+            .wasm32, .wasm64 => "wasm",
+            .x86 => "i386",
+            .x86_64 => "x86_64",
+            else => unreachable,
+        },
+    };
+}
+
 pub fn muslArchNameHeaders(arch: std.Target.Cpu.Arch) [:0]const u8 {
     return switch (arch) {
-        .x86 => return "x86",
-        else => muslArchName(arch),
+        .x86 => "x86",
+        else => muslArchName(arch, .musl),
+    };
+}
+
+pub fn muslAbiNameHeaders(abi: std.Target.Abi) [:0]const u8 {
+    return switch (abi) {
+        .muslabin32 => "muslabin32",
+        .muslx32 => "muslx32",
+        else => "musl",
     };
 }
 
-pub fn muslArchName(arch: std.Target.Cpu.Arch) [:0]const u8 {
-    switch (arch) {
-        .aarch64, .aarch64_be => return "aarch64",
-        .arm, .armeb, .thumb, .thumbeb => return "arm",
-        .x86 => return "i386",
-        .loongarch64 => return "loongarch64",
-        .m68k => return "m68k",
-        .mips, .mipsel => return "mips",
-        .mips64el, .mips64 => return "mips64",
-        .powerpc => return "powerpc",
-        .powerpc64, .powerpc64le => return "powerpc64",
-        .riscv32 => return "riscv32",
-        .riscv64 => return "riscv64",
-        .s390x => return "s390x",
-        .wasm32, .wasm64 => return "wasm",
-        .x86_64 => return "x86_64",
-        else => unreachable,
+pub fn isLibCLibName(target: std.Target, name: []const u8) bool {
+    const ignore_case = target.os.tag.isDarwin() or target.os.tag == .windows;
+
+    if (eqlIgnoreCase(ignore_case, name, "c"))
+        return true;
+
+    if (target.isMinGW()) {
+        if (eqlIgnoreCase(ignore_case, name, "m"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "mingw32"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "msvcrt-os"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "mingwex"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "uuid"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "bits"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "dmoguids"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "dxerr8"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "dxerr9"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "mfuuid"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "msxml2"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "msxml6"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "amstrmid"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "wbemuuid"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "wmcodecdspuuid"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "dxguid"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "ksguid"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "locationapi"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "portabledeviceguids"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "mfuuid"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "dloadhelper"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "strmiids"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "mfuuid"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "adsiid"))
+            return true;
+
+        return false;
+    }
+
+    if (target.abi.isGnu() or target.abi.isMusl()) {
+        if (eqlIgnoreCase(ignore_case, name, "m"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "rt"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "pthread"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "util"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "resolv"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "dl"))
+            return true;
+    }
+
+    if (target.abi.isMusl()) {
+        if (eqlIgnoreCase(ignore_case, name, "crypt"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "xnet"))
+            return true;
+    }
+
+    if (target.os.tag.isDarwin()) {
+        if (eqlIgnoreCase(ignore_case, name, "System"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "c"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "dbm"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "dl"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "info"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "m"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "poll"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "proc"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "pthread"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "rpcsvc"))
+            return true;
+    }
+
+    if (target.os.isAtLeast(.macos, .{ .major = 10, .minor = 8, .patch = 0 }) orelse false) {
+        if (eqlIgnoreCase(ignore_case, name, "mx"))
+            return true;
+    }
+
+    if (target.os.tag == .haiku) {
+        if (eqlIgnoreCase(ignore_case, name, "root"))
+            return true;
+        if (eqlIgnoreCase(ignore_case, name, "network"))
+            return true;
+    }
+
+    return false;
+}
+
+pub fn isLibCxxLibName(target: std.Target, name: []const u8) bool {
+    const ignore_case = target.os.tag.isDarwin() or target.os.tag == .windows;
+
+    return eqlIgnoreCase(ignore_case, name, "c++") or
+        eqlIgnoreCase(ignore_case, name, "stdc++") or
+        eqlIgnoreCase(ignore_case, name, "c++abi");
+}
+
+fn eqlIgnoreCase(ignore_case: bool, a: []const u8, b: []const u8) bool {
+    if (ignore_case) {
+        return std.ascii.eqlIgnoreCase(a, b);
+    } else {
+        return std.mem.eql(u8, a, b);
     }
 }
 
diff --git a/zig/lib/zig.h b/zig/lib/zig.h
index 2f2575fdcf..248bb8641c 100644
--- a/zig/lib/zig.h
+++ b/zig/lib/zig.h
@@ -3926,28 +3926,52 @@ static inline void zig_msvc_atomic_store_i128(zig_i128 volatile* obj, zig_i128 a
 
 /* ======================== Special Case Intrinsics ========================= */
 
-#if (_MSC_VER && _M_X64) || defined(__x86_64__)
+#if defined(_M_ARM) || defined(__thumb__)
 
-static inline void* zig_x86_64_windows_teb(void) {
-#if _MSC_VER
-    return (void*)__readgsqword(0x30);
-#else
-    void* teb;
-    __asm volatile(" movq %%gs:0x30, %[ptr]": [ptr]"=r"(teb)::);
+static inline void* zig_thumb_windows_teb(void) {
+    void* teb = 0;
+#if defined(_MSC_VER)
+    teb = (void*)_MoveFromCoprocessor(15, 0, 13, 0, 2);
+#elif defined(__GNUC__)
+    __asm__ ("mrc p15, 0, %[ptr], c13, c0, 2" : [ptr] "=r" (teb));
+#endif
     return teb;
+}
+
+#elif defined(_M_ARM64) || defined(__arch64__)
+
+static inline void* zig_aarch64_windows_teb(void) {
+    void* teb = 0;
+#if defined(_MSC_VER)
+    teb = (void*)__readx18qword(0x0);
+#elif defined(__GNUC__)
+    __asm__ ("mov %[ptr], x18" : [ptr] "=r" (teb));
 #endif
+    return teb;
 }
 
-#elif (_MSC_VER && _M_IX86) || defined(__i386__) || defined(__X86__)
+#elif defined(_M_IX86) || defined(__i386__)
 
 static inline void* zig_x86_windows_teb(void) {
-#if _MSC_VER
-    return (void*)__readfsdword(0x18);
-#else
-    void* teb;
-    __asm volatile(" movl %%fs:0x18, %[ptr]": [ptr]"=r"(teb)::);
+    void* teb = 0;
+#if defined(_MSC_VER)
+    teb = (void*)__readfsdword(0x18);
+#elif defined(__GNUC__)
+    __asm__ ("movl %%fs:0x18, %[ptr]" : [ptr] "=r" (teb));
+#endif
     return teb;
+}
+
+#elif defined(_M_X64) || defined(__x86_64__)
+
+static inline void* zig_x86_64_windows_teb(void) {
+    void* teb = 0;
+#if defined(_MSC_VER)
+    teb = (void*)__readgsqword(0x30);
+#elif defined(__GNUC__)
+    __asm__ ("movq %%gs:0x30, %[ptr]" : [ptr] "=r" (teb));
 #endif
+    return teb;
 }
 
 #endif
diff --git a/zig/src/Air.zig b/zig/src/Air.zig
index c58020daaa..3aa5f317c0 100644
--- a/zig/src/Air.zig
+++ b/zig/src/Air.zig
@@ -962,7 +962,7 @@ pub const Inst = struct {
         anyerror_void_error_union_type = @intFromEnum(InternPool.Index.anyerror_void_error_union_type),
         adhoc_inferred_error_set_type = @intFromEnum(InternPool.Index.adhoc_inferred_error_set_type),
         generic_poison_type = @intFromEnum(InternPool.Index.generic_poison_type),
-        empty_struct_type = @intFromEnum(InternPool.Index.empty_struct_type),
+        empty_tuple_type = @intFromEnum(InternPool.Index.empty_tuple_type),
         undef = @intFromEnum(InternPool.Index.undef),
         zero = @intFromEnum(InternPool.Index.zero),
         zero_usize = @intFromEnum(InternPool.Index.zero_usize),
@@ -977,7 +977,7 @@ pub const Inst = struct {
         null_value = @intFromEnum(InternPool.Index.null_value),
         bool_true = @intFromEnum(InternPool.Index.bool_true),
         bool_false = @intFromEnum(InternPool.Index.bool_false),
-        empty_struct = @intFromEnum(InternPool.Index.empty_struct),
+        empty_tuple = @intFromEnum(InternPool.Index.empty_tuple),
         generic_poison = @intFromEnum(InternPool.Index.generic_poison),
 
         /// This Ref does not correspond to any AIR instruction or constant
diff --git a/zig/src/Air/types_resolved.zig b/zig/src/Air/types_resolved.zig
index 5a149b08d2..098cb29b22 100644
--- a/zig/src/Air/types_resolved.zig
+++ b/zig/src/Air/types_resolved.zig
@@ -501,7 +501,7 @@ pub fn checkType(ty: Type, zcu: *Zcu) bool {
                     .auto, .@"extern" => struct_obj.flagsUnordered(ip).fully_resolved,
                 };
             },
-            .anon_struct_type => |tuple| {
+            .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/zig/src/Builtin.zig b/zig/src/Builtin.zig
index 58abcb7a4b..f3018d3023 100644
--- a/zig/src/Builtin.zig
+++ b/zig/src/Builtin.zig
@@ -80,7 +80,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
         .{std.zig.fmtId(@tagName(target.os.tag))},
     );
 
-    switch (target.os.getVersionRange()) {
+    switch (target.os.versionRange()) {
         .none => try buffer.appendSlice(" .none = {} },\n"),
         .semver => |semver| try buffer.writer().print(
             \\ .semver = .{{
@@ -124,6 +124,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
             \\            .minor = {},
             \\            .patch = {},
             \\        }},
+            \\        .android = {},
             \\    }}}},
             \\
         , .{
@@ -138,6 +139,8 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
             linux.glibc.major,
             linux.glibc.minor,
             linux.glibc.patch,
+
+            linux.android,
         }),
         .windows => |windows| try buffer.writer().print(
             \\ .windows = .{{
diff --git a/zig/src/Compilation.zig b/zig/src/Compilation.zig
index 8d276980ea..a228d61257 100644
--- a/zig/src/Compilation.zig
+++ b/zig/src/Compilation.zig
@@ -10,6 +10,7 @@ const Target = std.Target;
 const ThreadPool = std.Thread.Pool;
 const WaitGroup = std.Thread.WaitGroup;
 const ErrorBundle = std.zig.ErrorBundle;
+const Path = Cache.Path;
 
 const Value = @import("Value.zig");
 const Type = @import("Type.zig");
@@ -39,15 +40,17 @@ const Air = @import("Air.zig");
 const Builtin = @import("Builtin.zig");
 const LlvmObject = @import("codegen/llvm.zig").Object;
 const dev = @import("dev.zig");
-pub const Directory = Cache.Directory;
-const Path = Cache.Path;
+const ThreadSafeQueue = @import("ThreadSafeQueue.zig").ThreadSafeQueue;
 
+pub const Directory = Cache.Directory;
 pub const Config = @import("Compilation/Config.zig");
 
 /// General-purpose allocator. Used for both temporary and long-term storage.
 gpa: Allocator,
 /// Arena-allocated memory, mostly used during initialization. However, it can
 /// be used for other things requiring the same lifetime as the `Compilation`.
+/// Not thread-safe - lock `mutex` if potentially accessing from multiple
+/// threads at once.
 arena: Allocator,
 /// Not every Compilation compiles .zig code! For example you could do `zig build-exe foo.o`.
 zcu: ?*Zcu,
@@ -76,16 +79,16 @@ implib_emit: ?Path,
 docs_emit: ?Path,
 root_name: [:0]const u8,
 include_compiler_rt: bool,
-objects: []Compilation.LinkObject,
+/// Resolved into known paths, any GNU ld scripts already resolved.
+link_inputs: []const link.Input,
 /// Needed only for passing -F args to clang.
 framework_dirs: []const []const u8,
-/// These are *always* dynamically linked. Static libraries will be
-/// provided as positional arguments.
-system_libs: std.StringArrayHashMapUnmanaged(SystemLib),
+/// 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),
 version: ?std.SemanticVersion,
 libc_installation: ?*const LibCInstallation,
 skip_linker_dependencies: bool,
-no_builtin: bool,
 function_sections: bool,
 data_sections: bool,
 link_eh_frame_hdr: bool,
@@ -106,10 +109,10 @@ win32_resource_table: if (dev.env.supports(.win32_resource)) std.AutoArrayHashMa
     pub fn deinit(_: @This(), _: Allocator) void {}
 } = .{},
 
-link_errors: std.ArrayListUnmanaged(link.File.ErrorMsg) = .empty,
-link_errors_mutex: std.Thread.Mutex = .{},
-link_error_flags: link.File.ErrorFlags = .{},
-lld_errors: std.ArrayListUnmanaged(LldError) = .empty,
+link_diags: link.Diags,
+link_task_queue: ThreadSafeQueue(link.Task) = .empty,
+/// Ensure only 1 simultaneous call to `flushTaskQueue`.
+link_task_queue_safety: std.debug.SafetyLock = .{},
 
 work_queues: [
     len: {
@@ -121,14 +124,6 @@ work_queues: [
     }
 ]std.fifo.LinearFifo(Job, .Dynamic),
 
-codegen_work: if (InternPool.single_threaded) void else struct {
-    mutex: std.Thread.Mutex,
-    cond: std.Thread.Condition,
-    queue: std.fifo.LinearFifo(CodegenJob, .Dynamic),
-    job_error: ?JobError,
-    done: bool,
-},
-
 /// These jobs are to invoke the Clang compiler to create an object file, which
 /// gets linked with the Compilation.
 c_object_work_queue: std.fifo.LinearFifo(*CObject, .Dynamic),
@@ -265,6 +260,9 @@ emit_asm: ?EmitLoc,
 emit_llvm_ir: ?EmitLoc,
 emit_llvm_bc: ?EmitLoc,
 
+link_task_wait_group: WaitGroup = .{},
+work_queue_progress_node: std.Progress.Node = .none,
+
 llvm_opt_bisect_limit: c_int,
 
 file_system_inputs: ?*std.ArrayListUnmanaged(u8),
@@ -342,16 +340,14 @@ pub const RcIncludes = enum {
 };
 
 const Job = union(enum) {
-    /// Write the constant value for a Decl to the output file.
+    /// Corresponds to the task in `link.Task`.
+    /// Only needed for backends that haven't yet been updated to not race against Sema.
     codegen_nav: InternPool.Nav.Index,
-    /// Write the machine code for a function to the output file.
-    codegen_func: struct {
-        /// This will either be a non-generic `func_decl` or a `func_instance`.
-        func: InternPool.Index,
-        /// This `Air` is owned by the `Job` and allocated with `gpa`.
-        /// It must be deinited when the job is processed.
-        air: Air,
-    },
+    /// Corresponds to the task in `link.Task`.
+    /// Only needed for backends that haven't yet been updated to not race against Sema.
+    codegen_func: link.Task.CodegenFunc,
+    /// Corresponds to the task in `link.Task`.
+    /// Only needed for backends that haven't yet been updated to not race against Sema.
     codegen_type: InternPool.Index,
     /// The `Cau` must be semantically analyzed (and possibly export itself).
     /// This may be its first time being analyzed, or it may be outdated.
@@ -360,9 +356,6 @@ const Job = union(enum) {
     /// After analysis, a `codegen_func` job will be queued.
     /// These must be separate jobs to ensure any needed type resolution occurs *before* codegen.
     analyze_func: InternPool.Index,
-    /// The source file containing the Decl has been updated, and so the
-    /// Decl may need its line number information updated in the debug info.
-    update_line_number: void, // TODO
     /// The main source file for the module needs to be analyzed.
     analyze_mod: *Package.Module,
     /// Fully resolve the given `struct` or `union` type.
@@ -376,6 +369,7 @@ const Job = union(enum) {
     musl_crt_file: musl.CrtFile,
     /// one of the mingw-w64 static objects
     mingw_crt_file: mingw.CrtFile,
+
     /// libunwind.a, usually needed when linking libc
     libunwind: void,
     libcxx: void,
@@ -387,7 +381,7 @@ const Job = union(enum) {
     /// one of WASI libc static objects
     wasi_libc_crt_file: wasi_libc.CrtFile,
 
-    /// The value is the index into `system_libs`.
+    /// The value is the index into `windows_libs`.
     windows_import_lib: usize,
 
     const Tag = @typeInfo(Job).@"union".tag_type.?;
@@ -405,17 +399,6 @@ const Job = union(enum) {
     }
 };
 
-const CodegenJob = union(enum) {
-    nav: InternPool.Nav.Index,
-    func: struct {
-        func: InternPool.Index,
-        /// This `Air` is owned by the `Job` and allocated with `gpa`.
-        /// It must be deinited when the job is processed.
-        air: Air,
-    },
-    type: InternPool.Index,
-};
-
 pub const CObject = struct {
     /// Relative to cwd. Owned by arena.
     src: CSourceFile,
@@ -842,21 +825,6 @@ pub const MiscError = struct {
     }
 };
 
-pub const LldError = struct {
-    /// Allocated with gpa.
-    msg: []const u8,
-    context_lines: []const []const u8 = &.{},
-
-    pub fn deinit(self: *LldError, gpa: Allocator) void {
-        for (self.context_lines) |line| {
-            gpa.free(line);
-        }
-
-        gpa.free(self.context_lines);
-        gpa.free(self.msg);
-    }
-};
-
 pub const EmitLoc = struct {
     /// If this is `null` it means the file will be output to the cache directory.
     /// When provided, both the open file handle and the path name must outlive the `Compilation`.
@@ -883,6 +851,7 @@ pub const cache_helpers = struct {
         hh.add(mod.fuzz);
         hh.add(mod.unwind_tables);
         hh.add(mod.structured_cfg);
+        hh.add(mod.no_builtin);
         hh.addListOfBytes(mod.cc_argv);
     }
 
@@ -895,7 +864,7 @@ pub const cache_helpers = struct {
         hh.addBytes(target.cpu.model.name);
         hh.add(target.cpu.features.ints);
         hh.add(target.os.tag);
-        hh.add(target.os.getVersionRange());
+        hh.add(target.os.versionRange());
         hh.add(target.abi);
         hh.add(target.ofmt);
         hh.add(resolved_target.is_native_os);
@@ -1017,23 +986,6 @@ const CacheUse = union(CacheMode) {
     }
 };
 
-pub const LinkObject = struct {
-    path: Path,
-    must_link: bool = false,
-    // When the library is passed via a positional argument, it will be
-    // added as a full path. If it's `-l<lib>`, then just the basename.
-    //
-    // Consistent with `withLOption` variable name in lld ELF driver.
-    loption: bool = false,
-
-    pub fn isObject(lo: LinkObject) bool {
-        return switch (classifyFileExt(lo.path.sub_path)) {
-            .object => true,
-            else => false,
-        };
-    }
-};
-
 pub const CreateOptions = struct {
     zig_lib_directory: Directory,
     local_cache_directory: Directory,
@@ -1078,18 +1030,20 @@ pub const CreateOptions = struct {
     /// this flag would be set to disable this machinery to avoid false positives.
     disable_lld_caching: bool = false,
     cache_mode: CacheMode = .incremental,
-    lib_dirs: []const []const u8 = &[0][]const u8{},
+    /// This field is intended to be removed.
+    /// The ELF implementation no longer uses this data, however the MachO and COFF
+    /// implementations still do.
+    lib_directories: []const Directory = &.{},
     rpath_list: []const []const u8 = &[0][]const u8{},
     symbol_wrap_set: std.StringArrayHashMapUnmanaged(void) = .empty,
     c_source_files: []const CSourceFile = &.{},
     rc_source_files: []const RcSourceFile = &.{},
     manifest_file: ?[]const u8 = null,
     rc_includes: RcIncludes = .any,
-    link_objects: []LinkObject = &[0]LinkObject{},
+    link_inputs: []const link.Input = &.{},
     framework_dirs: []const []const u8 = &[0][]const u8{},
     frameworks: []const Framework = &.{},
-    system_lib_names: []const []const u8 = &.{},
-    system_lib_infos: []const SystemLib = &.{},
+    windows_lib_names: []const []const u8 = &.{},
     /// These correspond to the WASI libc emulated subcomponents including:
     /// * process clocks
     /// * getpid
@@ -1103,7 +1057,6 @@ pub const CreateOptions = struct {
     want_lto: ?bool = null,
     function_sections: bool = false,
     data_sections: bool = false,
-    no_builtin: bool = false,
     time_report: bool = false,
     stack_report: bool = false,
     link_eh_frame_hdr: bool = false,
@@ -1345,7 +1298,11 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
                 },
                 .fully_qualified_name = "compiler_rt",
                 .cc_argv = &.{},
-                .inherited = .{},
+                .inherited = .{
+                    .stack_check = false,
+                    .stack_protector = 0,
+                    .no_builtin = true,
+                },
                 .global = options.config,
                 .parent = options.root_mod,
                 .builtin_mod = options.root_mod.getBuiltinDependency(),
@@ -1399,7 +1356,6 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
         cache.hash.add(options.config.link_mode);
         cache.hash.add(options.function_sections);
         cache.hash.add(options.data_sections);
-        cache.hash.add(options.no_builtin);
         cache.hash.add(link_libc);
         cache.hash.add(options.config.link_libcpp);
         cache.hash.add(options.config.link_libunwind);
@@ -1472,12 +1428,8 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
         };
         errdefer if (opt_zcu) |zcu| zcu.deinit();
 
-        var system_libs = try std.StringArrayHashMapUnmanaged(SystemLib).init(
-            gpa,
-            options.system_lib_names,
-            options.system_lib_infos,
-        );
-        errdefer system_libs.deinit(gpa);
+        var windows_libs = try std.StringArrayHashMapUnmanaged(void).init(gpa, options.windows_lib_names, &.{});
+        errdefer windows_libs.deinit(gpa);
 
         comp.* = .{
             .gpa = gpa,
@@ -1496,13 +1448,6 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
             .emit_llvm_ir = options.emit_llvm_ir,
             .emit_llvm_bc = options.emit_llvm_bc,
             .work_queues = .{std.fifo.LinearFifo(Job, .Dynamic).init(gpa)} ** @typeInfo(std.meta.FieldType(Compilation, .work_queues)).array.len,
-            .codegen_work = if (InternPool.single_threaded) {} else .{
-                .mutex = .{},
-                .cond = .{},
-                .queue = std.fifo.LinearFifo(CodegenJob, .Dynamic).init(gpa),
-                .job_error = null,
-                .done = false,
-            },
             .c_object_work_queue = std.fifo.LinearFifo(*CObject, .Dynamic).init(gpa),
             .win32_resource_work_queue = if (dev.env.supports(.win32_resource)) std.fifo.LinearFifo(*Win32Resource, .Dynamic).init(gpa) else .{},
             .astgen_work_queue = std.fifo.LinearFifo(Zcu.File.Index, .Dynamic).init(gpa),
@@ -1539,15 +1484,14 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
             .libcxx_abi_version = options.libcxx_abi_version,
             .root_name = root_name,
             .sysroot = sysroot,
-            .system_libs = system_libs,
+            .windows_libs = windows_libs,
             .version = options.version,
             .libc_installation = libc_dirs.libc_installation,
             .include_compiler_rt = include_compiler_rt,
-            .objects = options.link_objects,
+            .link_inputs = options.link_inputs,
             .framework_dirs = options.framework_dirs,
             .llvm_opt_bisect_limit = options.llvm_opt_bisect_limit,
             .skip_linker_dependencies = options.skip_linker_dependencies,
-            .no_builtin = options.no_builtin,
             .job_queued_update_builtin_zig = have_zcu,
             .function_sections = options.function_sections,
             .data_sections = options.data_sections,
@@ -1558,6 +1502,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
             .global_cc_argv = options.global_cc_argv,
             .file_system_inputs = options.file_system_inputs,
             .parent_whole_cache = options.parent_whole_cache,
+            .link_diags = .init(gpa),
         };
 
         // Prevent some footguns by making the "any" fields of config reflect
@@ -1580,7 +1525,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
             .z_max_page_size = options.linker_z_max_page_size,
             .darwin_sdk_layout = libc_dirs.darwin_sdk_layout,
             .frameworks = options.frameworks,
-            .lib_dirs = options.lib_dirs,
+            .lib_directories = options.lib_directories,
             .framework_dirs = options.framework_dirs,
             .rpath_list = options.rpath_list,
             .symbol_wrap_set = options.symbol_wrap_set,
@@ -1792,157 +1737,175 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
         .incremental => comp.bin_file != null,
     };
 
-    if (have_bin_emit and !comp.skip_linker_dependencies and target.ofmt != .c) {
-        if (target.isDarwin()) {
-            switch (target.abi) {
-                .none,
-                .simulator,
-                .macabi,
-                => {},
-                else => return error.LibCUnavailable,
-            }
-        }
-        // If we need to build glibc for the target, add work items for it.
-        // We go through the work queue so that building can be done in parallel.
-        if (comp.wantBuildGLibCFromSource()) {
-            if (!std.zig.target.canBuildLibC(target)) return error.LibCUnavailable;
-
-            if (glibc.needsCrtiCrtn(target)) {
-                try comp.queueJobs(&[_]Job{
-                    .{ .glibc_crt_file = .crti_o },
-                    .{ .glibc_crt_file = .crtn_o },
-                });
-            }
-            try comp.queueJobs(&[_]Job{
-                .{ .glibc_crt_file = .scrt1_o },
-                .{ .glibc_crt_file = .libc_nonshared_a },
-                .{ .glibc_shared_objects = {} },
-            });
-        }
-        if (comp.wantBuildMuslFromSource()) {
-            if (!std.zig.target.canBuildLibC(target)) return error.LibCUnavailable;
-
-            if (musl.needsCrtiCrtn(target)) {
-                try comp.queueJobs(&[_]Job{
-                    .{ .musl_crt_file = .crti_o },
-                    .{ .musl_crt_file = .crtn_o },
-                });
-            }
-            try comp.queueJobs(&[_]Job{
-                .{ .musl_crt_file = .crt1_o },
-                .{ .musl_crt_file = .scrt1_o },
-                .{ .musl_crt_file = .rcrt1_o },
-                switch (comp.config.link_mode) {
-                    .static => .{ .musl_crt_file = .libc_a },
-                    .dynamic => .{ .musl_crt_file = .libc_so },
-                },
-            });
-        }
+    if (have_bin_emit and target.ofmt != .c) {
+        if (!comp.skip_linker_dependencies) {
+            // If we need to build libc for the target, add work items for it.
+            // We go through the work queue so that building can be done in parallel.
+            // If linking against host libc installation, instead queue up jobs
+            // for loading those files in the linker.
+            if (comp.config.link_libc and is_exe_or_dyn_lib) {
+                // If the "is darwin" check is moved below the libc_installation check below,
+                // error.LibCInstallationMissingCrtDir is returned from lci.resolveCrtPaths().
+                if (target.isDarwin()) {
+                    switch (target.abi) {
+                        .none, .simulator, .macabi => {},
+                        else => return error.LibCUnavailable,
+                    }
+                    // TODO delete logic from MachO flush() and queue up tasks here instead.
+                } else if (comp.libc_installation) |lci| {
+                    const basenames = LibCInstallation.CrtBasenames.get(.{
+                        .target = target,
+                        .link_libc = comp.config.link_libc,
+                        .output_mode = comp.config.output_mode,
+                        .link_mode = comp.config.link_mode,
+                        .pie = comp.config.pie,
+                    });
+                    const paths = try lci.resolveCrtPaths(arena, basenames, target);
 
-        if (comp.wantBuildWasiLibcFromSource()) {
-            if (!std.zig.target.canBuildLibC(target)) return error.LibCUnavailable;
+                    const fields = @typeInfo(@TypeOf(paths)).@"struct".fields;
+                    try comp.link_task_queue.shared.ensureUnusedCapacity(gpa, fields.len + 1);
+                    inline for (fields) |field| {
+                        if (@field(paths, field.name)) |path| {
+                            comp.link_task_queue.shared.appendAssumeCapacity(.{ .load_object = path });
+                        }
+                    }
+                    // Loads the libraries provided by `target_util.libcFullLinkFlags(target)`.
+                    comp.link_task_queue.shared.appendAssumeCapacity(.load_host_libc);
+                } else if (target.isMusl() and !target.isWasm()) {
+                    if (!std.zig.target.canBuildLibC(target)) return error.LibCUnavailable;
+
+                    if (musl.needsCrtiCrtn(target)) {
+                        try comp.queueJobs(&[_]Job{
+                            .{ .musl_crt_file = .crti_o },
+                            .{ .musl_crt_file = .crtn_o },
+                        });
+                    }
+                    if (musl.needsCrt0(comp.config.output_mode, comp.config.link_mode, comp.config.pie)) |f| {
+                        try comp.queueJobs(&.{.{ .musl_crt_file = f }});
+                    }
+                    try comp.queueJobs(&.{.{ .musl_crt_file = switch (comp.config.link_mode) {
+                        .static => .libc_a,
+                        .dynamic => .libc_so,
+                    } }});
+                } else if (target.isGnuLibC()) {
+                    if (!std.zig.target.canBuildLibC(target)) return error.LibCUnavailable;
+
+                    if (glibc.needsCrtiCrtn(target)) {
+                        try comp.queueJobs(&[_]Job{
+                            .{ .glibc_crt_file = .crti_o },
+                            .{ .glibc_crt_file = .crtn_o },
+                        });
+                    }
+                    if (glibc.needsCrt0(comp.config.output_mode)) |f| {
+                        try comp.queueJobs(&.{.{ .glibc_crt_file = f }});
+                    }
+                    try comp.queueJobs(&[_]Job{
+                        .{ .glibc_shared_objects = {} },
+                        .{ .glibc_crt_file = .libc_nonshared_a },
+                    });
+                } else if (target.isWasm() and target.os.tag == .wasi) {
+                    if (!std.zig.target.canBuildLibC(target)) return error.LibCUnavailable;
 
-            for (comp.wasi_emulated_libs) |crt_file| {
-                try comp.queueJob(.{
-                    .wasi_libc_crt_file = crt_file,
-                });
-            }
-            try comp.queueJobs(&[_]Job{
-                .{ .wasi_libc_crt_file = wasi_libc.execModelCrtFile(comp.config.wasi_exec_model) },
-                .{ .wasi_libc_crt_file = .libc_a },
-            });
-        }
+                    for (comp.wasi_emulated_libs) |crt_file| {
+                        try comp.queueJob(.{
+                            .wasi_libc_crt_file = crt_file,
+                        });
+                    }
+                    try comp.queueJobs(&[_]Job{
+                        .{ .wasi_libc_crt_file = wasi_libc.execModelCrtFile(comp.config.wasi_exec_model) },
+                        .{ .wasi_libc_crt_file = .libc_a },
+                    });
+                } else if (target.isMinGW()) {
+                    if (!std.zig.target.canBuildLibC(target)) return error.LibCUnavailable;
 
-        if (comp.wantBuildMinGWFromSource()) {
-            if (!std.zig.target.canBuildLibC(target)) return error.LibCUnavailable;
+                    const crt_job: Job = .{ .mingw_crt_file = if (is_dyn_lib) .dllcrt2_o else .crt2_o };
+                    try comp.queueJobs(&.{
+                        .{ .mingw_crt_file = .mingw32_lib },
+                        crt_job,
+                    });
 
-            const crt_job: Job = .{ .mingw_crt_file = if (is_dyn_lib) .dllcrt2_o else .crt2_o };
-            try comp.queueJobs(&.{
-                .{ .mingw_crt_file = .mingw32_lib },
-                crt_job,
-            });
+                    // When linking mingw-w64 there are some import libs we always need.
+                    try comp.windows_libs.ensureUnusedCapacity(gpa, mingw.always_link_libs.len);
+                    for (mingw.always_link_libs) |name| comp.windows_libs.putAssumeCapacity(name, {});
+                } else if (target.isDarwin()) {
+                    switch (target.abi) {
+                        .none, .simulator, .macabi => {},
+                        else => return error.LibCUnavailable,
+                    }
+                } else if (target.os.tag == .freestanding and capable_of_building_zig_libc) {
+                    try comp.queueJob(.{ .zig_libc = {} });
+                } else {
+                    return error.LibCUnavailable;
+                }
+            }
 
-            // When linking mingw-w64 there are some import libs we always need.
-            for (mingw.always_link_libs) |name| {
-                try comp.system_libs.put(comp.gpa, name, .{
-                    .needed = false,
-                    .weak = false,
-                    .path = null,
-                });
+            // 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 });
+                }
             }
-        }
-        // Generate Windows import libs.
-        if (target.os.tag == .windows) {
-            const count = comp.system_libs.count();
-            for (0..count) |i| {
-                try comp.queueJob(.{ .windows_import_lib = i });
+            if (comp.wantBuildLibUnwindFromSource()) {
+                try comp.queueJob(.{ .libunwind = {} });
+            }
+            if (build_options.have_llvm and is_exe_or_dyn_lib and comp.config.link_libcpp) {
+                try comp.queueJob(.libcxx);
+                try comp.queueJob(.libcxxabi);
+            }
+            if (build_options.have_llvm and is_exe_or_dyn_lib and comp.config.any_sanitize_thread) {
+                try comp.queueJob(.libtsan);
             }
-        }
-        if (comp.wantBuildLibUnwindFromSource()) {
-            try comp.queueJob(.{ .libunwind = {} });
-        }
-        if (build_options.have_llvm and is_exe_or_dyn_lib and comp.config.link_libcpp) {
-            try comp.queueJob(.libcxx);
-            try comp.queueJob(.libcxxabi);
-        }
-        if (build_options.have_llvm and comp.config.any_sanitize_thread) {
-            try comp.queueJob(.libtsan);
-        }
 
-        if (target.isMinGW() and comp.config.any_non_single_threaded) {
-            // LLD might drop some symbols as unused during LTO and GCing, therefore,
-            // we force mark them for resolution here.
+            if (target.isMinGW() and comp.config.any_non_single_threaded) {
+                // LLD might drop some symbols as unused during LTO and GCing, therefore,
+                // we force mark them for resolution here.
 
-            const tls_index_sym = switch (target.cpu.arch) {
-                .x86 => "__tls_index",
-                else => "_tls_index",
-            };
+                const tls_index_sym = switch (target.cpu.arch) {
+                    .x86 => "__tls_index",
+                    else => "_tls_index",
+                };
 
-            try comp.force_undefined_symbols.put(comp.gpa, tls_index_sym, {});
-        }
+                try comp.force_undefined_symbols.put(comp.gpa, tls_index_sym, {});
+            }
 
-        if (comp.include_compiler_rt and capable_of_building_compiler_rt) {
-            if (is_exe_or_dyn_lib) {
-                log.debug("queuing a job to build compiler_rt_lib", .{});
-                comp.job_queued_compiler_rt_lib = true;
-            } else if (output_mode != .Obj) {
-                log.debug("queuing a job to build compiler_rt_obj", .{});
-                // In this case we are making a static library, so we ask
-                // for a compiler-rt object to put in it.
-                comp.job_queued_compiler_rt_obj = true;
+            if (comp.include_compiler_rt and capable_of_building_compiler_rt) {
+                if (is_exe_or_dyn_lib) {
+                    log.debug("queuing a job to build compiler_rt_lib", .{});
+                    comp.job_queued_compiler_rt_lib = true;
+                } else if (output_mode != .Obj) {
+                    log.debug("queuing a job to build compiler_rt_obj", .{});
+                    // In this case we are making a static library, so we ask
+                    // for a compiler-rt object to put in it.
+                    comp.job_queued_compiler_rt_obj = true;
+                }
             }
-        }
 
-        if (comp.config.any_fuzz and capable_of_building_compiler_rt) {
-            if (is_exe_or_dyn_lib) {
+            if (is_exe_or_dyn_lib and comp.config.any_fuzz and capable_of_building_compiler_rt) {
                 log.debug("queuing a job to build libfuzzer", .{});
                 comp.job_queued_fuzzer_lib = true;
             }
         }
 
-        if (!comp.skip_linker_dependencies and is_exe_or_dyn_lib and
-            !comp.config.link_libc and capable_of_building_zig_libc)
-        {
-            try comp.queueJob(.{ .zig_libc = {} });
-        }
+        try comp.link_task_queue.shared.append(gpa, .load_explicitly_provided);
     }
 
     return comp;
 }
 
 pub fn destroy(comp: *Compilation) void {
+    const gpa = comp.gpa;
+
     if (comp.bin_file) |lf| lf.destroy();
     if (comp.zcu) |zcu| zcu.deinit();
     comp.cache_use.deinit();
     for (comp.work_queues) |work_queue| work_queue.deinit();
-    if (!InternPool.single_threaded) comp.codegen_work.queue.deinit();
     comp.c_object_work_queue.deinit();
     comp.win32_resource_work_queue.deinit();
     comp.astgen_work_queue.deinit();
     comp.embed_file_work_queue.deinit();
 
-    const gpa = comp.gpa;
-    comp.system_libs.deinit(gpa);
+    comp.windows_libs.deinit(gpa);
 
     {
         var it = comp.crt_files.iterator();
@@ -1999,13 +1962,8 @@ pub fn destroy(comp: *Compilation) void {
     }
     comp.failed_win32_resources.deinit(gpa);
 
-    for (comp.link_errors.items) |*item| item.deinit(gpa);
-    comp.link_errors.deinit(gpa);
-
-    for (comp.lld_errors.items) |*lld_error| {
-        lld_error.deinit(gpa);
-    }
-    comp.lld_errors.deinit(gpa);
+    comp.link_diags.deinit();
+    comp.link_task_queue.deinit(gpa);
 
     comp.clearMiscFailures();
 
@@ -2124,7 +2082,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
             log.debug("CacheMode.whole cache miss for {s}", .{comp.root_name});
 
             // Compile the artifacts to a temporary directory.
-            const tmp_artifact_directory = d: {
+            const tmp_artifact_directory: Directory = d: {
                 const s = std.fs.path.sep_str;
                 tmp_dir_rand_int = std.crypto.random.int(u64);
                 const tmp_dir_sub_path = "tmp" ++ s ++ std.fmt.hex(tmp_dir_rand_int);
@@ -2304,7 +2262,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
 
     if (anyErrors(comp)) {
         // Skip flushing and keep source files loaded for error reporting.
-        comp.link_error_flags = .{};
+        comp.link_diags.flags = .{};
         return;
     }
 
@@ -2451,7 +2409,7 @@ fn flush(
     if (comp.bin_file) |lf| {
         // This is needed before reading the error flags.
         lf.flush(arena, tid, prog_node) catch |err| switch (err) {
-            error.FlushFailure, error.LinkFailure => {}, // error reported through link_error_flags
+            error.FlushFailure, error.LinkFailure => {}, // error reported through link_diags.flags
             error.LLDReportedFailure => {}, // error reported via lockAndParseLldStderr
             else => |e| return e,
         };
@@ -2581,11 +2539,7 @@ fn addNonIncrementalStuffToCacheManifest(
         cache_helpers.addModule(&man.hash, comp.root_mod);
     }
 
-    for (comp.objects) |obj| {
-        _ = try man.addFilePath(obj.path, null);
-        man.hash.add(obj.must_link);
-        man.hash.add(obj.loption);
-    }
+    try link.hashInputs(man, comp.link_inputs);
 
     for (comp.c_object_table.keys()) |key| {
         _ = try man.addFile(key.src.src_path, null);
@@ -2622,7 +2576,7 @@ fn addNonIncrementalStuffToCacheManifest(
     man.hash.add(comp.rc_includes);
     man.hash.addListOfBytes(comp.force_undefined_symbols.keys());
     man.hash.addListOfBytes(comp.framework_dirs);
-    try link.hashAddSystemLibs(man, comp.system_libs);
+    man.hash.addListOfBytes(comp.windows_libs.keys());
 
     cache_helpers.addOptionalEmitLoc(&man.hash, comp.emit_asm);
     cache_helpers.addOptionalEmitLoc(&man.hash, comp.emit_llvm_ir);
@@ -2641,12 +2595,16 @@ fn addNonIncrementalStuffToCacheManifest(
     man.hash.addOptional(opts.image_base);
     man.hash.addOptional(opts.gc_sections);
     man.hash.add(opts.emit_relocs);
-    man.hash.addListOfBytes(opts.lib_dirs);
+    const target = comp.root_mod.resolved_target.result;
+    if (target.ofmt == .macho or target.ofmt == .coff) {
+        // TODO remove this, libraries need to be resolved by the frontend. this is already
+        // done by ELF.
+        for (opts.lib_directories) |lib_directory| man.hash.addOptionalBytes(lib_directory.path);
+    }
     man.hash.addListOfBytes(opts.rpath_list);
     man.hash.addListOfBytes(opts.symbol_wrap_set.keys());
     if (comp.config.link_libc) {
         man.hash.add(comp.libc_installation != null);
-        const target = comp.root_mod.resolved_target.result;
         if (comp.libc_installation) |libc_installation| {
             man.hash.addOptionalBytes(libc_installation.crt_dir);
             if (target.abi == .msvc or target.abi == .itanium) {
@@ -2922,6 +2880,7 @@ pub fn makeBinFileWritable(comp: *Compilation) !void {
 const Header = extern struct {
     intern_pool: extern struct {
         thread_count: u32,
+        file_deps_len: u32,
         src_hash_deps_len: u32,
         nav_val_deps_len: u32,
         namespace_deps_len: u32,
@@ -2964,6 +2923,7 @@ pub fn saveState(comp: *Compilation) !void {
         const header: Header = .{
             .intern_pool = .{
                 .thread_count = @intCast(ip.locals.len),
+                .file_deps_len = @intCast(ip.file_deps.count()),
                 .src_hash_deps_len = @intCast(ip.src_hash_deps.count()),
                 .nav_val_deps_len = @intCast(ip.nav_val_deps.count()),
                 .namespace_deps_len = @intCast(ip.namespace_deps.count()),
@@ -2990,6 +2950,8 @@ pub fn saveState(comp: *Compilation) !void {
         addBuf(&bufs, mem.asBytes(&header));
         addBuf(&bufs, mem.sliceAsBytes(pt_headers.items));
 
+        addBuf(&bufs, mem.sliceAsBytes(ip.file_deps.keys()));
+        addBuf(&bufs, mem.sliceAsBytes(ip.file_deps.values()));
         addBuf(&bufs, mem.sliceAsBytes(ip.src_hash_deps.keys()));
         addBuf(&bufs, mem.sliceAsBytes(ip.src_hash_deps.values()));
         addBuf(&bufs, mem.sliceAsBytes(ip.nav_val_deps.keys()));
@@ -3070,7 +3032,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
         try bundle.addBundleAsRoots(error_bundle);
     }
 
-    for (comp.lld_errors.items) |lld_error| {
+    for (comp.link_diags.lld.items) |lld_error| {
         const notes_len = @as(u32, @intCast(lld_error.context_lines.len));
 
         try bundle.addRootErrorMessage(.{
@@ -3091,21 +3053,18 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
         });
         if (value.children) |b| try bundle.addBundleAsNotes(b);
     }
-    if (comp.alloc_failure_occurred) {
+    if (comp.alloc_failure_occurred or comp.link_diags.flags.alloc_failure_occurred) {
         try bundle.addRootErrorMessage(.{
             .msg = try bundle.addString("memory allocation failure"),
         });
     }
 
-    var all_references: ?std.AutoHashMapUnmanaged(InternPool.AnalUnit, ?Zcu.ResolvedReference) = null;
-    defer if (all_references) |*a| a.deinit(gpa);
-
     if (comp.zcu) |zcu| {
         const ip = &zcu.intern_pool;
 
         for (zcu.failed_files.keys(), zcu.failed_files.values()) |file, error_msg| {
             if (error_msg) |msg| {
-                try addModuleErrorMsg(zcu, &bundle, msg.*, &all_references);
+                try addModuleErrorMsg(zcu, &bundle, msg.*);
             } else {
                 // Must be ZIR errors. Note that this may include AST errors.
                 // addZirErrorMessages asserts that the tree is loaded.
@@ -3114,7 +3073,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
             }
         }
         for (zcu.failed_embed_files.values()) |error_msg| {
-            try addModuleErrorMsg(zcu, &bundle, error_msg.*, &all_references);
+            try addModuleErrorMsg(zcu, &bundle, error_msg.*);
         }
         {
             const SortOrder = struct {
@@ -3157,10 +3116,8 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
         }
         for (zcu.failed_analysis.keys(), zcu.failed_analysis.values()) |anal_unit, error_msg| {
             if (comp.incremental) {
-                if (all_references == null) {
-                    all_references = try zcu.resolveReferences();
-                }
-                if (!all_references.?.contains(anal_unit)) continue;
+                const refs = try zcu.resolveReferences();
+                if (!refs.contains(anal_unit)) continue;
             }
 
             const file_index = switch (anal_unit.unwrap()) {
@@ -3172,7 +3129,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
             // We'll try again once parsing succeeds.
             if (!zcu.fileByIndex(file_index).okToReportErrors()) continue;
 
-            try addModuleErrorMsg(zcu, &bundle, error_msg.*, &all_references);
+            try addModuleErrorMsg(zcu, &bundle, error_msg.*);
             if (zcu.cimport_errors.get(anal_unit)) |errors| {
                 for (errors.getMessages()) |err_msg_index| {
                     const err_msg = errors.getErrorMessage(err_msg_index);
@@ -3196,10 +3153,10 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
         }
         for (zcu.failed_codegen.keys(), zcu.failed_codegen.values()) |nav, error_msg| {
             if (!zcu.navFileScope(nav).okToReportErrors()) continue;
-            try addModuleErrorMsg(zcu, &bundle, error_msg.*, &all_references);
+            try addModuleErrorMsg(zcu, &bundle, error_msg.*);
         }
         for (zcu.failed_exports.values()) |value| {
-            try addModuleErrorMsg(zcu, &bundle, value.*, &all_references);
+            try addModuleErrorMsg(zcu, &bundle, value.*);
         }
 
         const actual_error_count = zcu.intern_pool.global_error_set.getNamesFromMainThread().len;
@@ -3220,14 +3177,14 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
     }
 
     if (bundle.root_list.items.len == 0) {
-        if (comp.link_error_flags.no_entry_point_found) {
+        if (comp.link_diags.flags.no_entry_point_found) {
             try bundle.addRootErrorMessage(.{
                 .msg = try bundle.addString("no entry point found"),
             });
         }
     }
 
-    if (comp.link_error_flags.missing_libc) {
+    if (comp.link_diags.flags.missing_libc) {
         try bundle.addRootErrorMessage(.{
             .msg = try bundle.addString("libc not available"),
             .notes_len = 2,
@@ -3241,18 +3198,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
         }));
     }
 
-    for (comp.link_errors.items) |link_err| {
-        try bundle.addRootErrorMessage(.{
-            .msg = try bundle.addString(link_err.msg),
-            .notes_len = @intCast(link_err.notes.len),
-        });
-        const notes_start = try bundle.reserveNotes(@intCast(link_err.notes.len));
-        for (link_err.notes, 0..) |note, i| {
-            bundle.extra.items[notes_start + i] = @intFromEnum(try bundle.addErrorMessage(.{
-                .msg = try bundle.addString(note.msg),
-            }));
-        }
-    }
+    try comp.link_diags.addMessagesToBundle(&bundle);
 
     if (comp.zcu) |zcu| {
         if (bundle.root_list.items.len == 0 and zcu.compile_log_sources.count() != 0) {
@@ -3273,17 +3219,15 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
                 };
             }
 
-            try addModuleErrorMsg(zcu, &bundle, err_msg, &all_references);
+            try addModuleErrorMsg(zcu, &bundle, err_msg);
         }
     }
 
     if (comp.zcu) |zcu| {
         if (comp.incremental and bundle.root_list.items.len == 0) {
             const should_have_error = for (zcu.transitive_failed_analysis.keys()) |failed_unit| {
-                if (all_references == null) {
-                    all_references = try zcu.resolveReferences();
-                }
-                if (all_references.?.contains(failed_unit)) break true;
+                const refs = try zcu.resolveReferences();
+                if (refs.contains(failed_unit)) break true;
             } else false;
             if (should_have_error) {
                 @panic("referenced transitive analysis errors, but none actually emitted");
@@ -3352,14 +3296,13 @@ pub const ErrorNoteHashContext = struct {
 };
 
 pub fn addModuleErrorMsg(
-    mod: *Zcu,
+    zcu: *Zcu,
     eb: *ErrorBundle.Wip,
     module_err_msg: Zcu.ErrorMsg,
-    all_references: *?std.AutoHashMapUnmanaged(InternPool.AnalUnit, ?Zcu.ResolvedReference),
 ) !void {
     const gpa = eb.gpa;
-    const ip = &mod.intern_pool;
-    const err_src_loc = module_err_msg.src_loc.upgrade(mod);
+    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(gpa) catch |err| {
         const file_path = try err_src_loc.file_scope.fullPath(gpa);
         defer gpa.free(file_path);
@@ -3379,22 +3322,20 @@ pub fn addModuleErrorMsg(
     defer ref_traces.deinit(gpa);
 
     if (module_err_msg.reference_trace_root.unwrap()) |rt_root| {
-        if (all_references.* == null) {
-            all_references.* = try mod.resolveReferences();
-        }
+        const all_references = try zcu.resolveReferences();
 
         var seen: std.AutoHashMapUnmanaged(InternPool.AnalUnit, void) = .empty;
         defer seen.deinit(gpa);
 
-        const max_references = mod.comp.reference_trace orelse Sema.default_reference_trace_len;
+        const max_references = zcu.comp.reference_trace orelse Sema.default_reference_trace_len;
 
         var referenced_by = rt_root;
-        while (all_references.*.?.get(referenced_by)) |maybe_ref| {
+        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) {
-                const src = ref.src.upgrade(mod);
+                const src = ref.src.upgrade(zcu);
                 const source = try src.file_scope.getSource(gpa);
                 const span = try src.span(gpa);
                 const loc = std.zig.findLineColumn(source.bytes, span.main);
@@ -3406,7 +3347,7 @@ pub fn addModuleErrorMsg(
                         .type => |ty| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),
                         .none => "comptime",
                     },
-                    .func => |f| ip.getNav(mod.funcInfo(f).owner_nav).name.toSlice(ip),
+                    .func => |f| ip.getNav(zcu.funcInfo(f).owner_nav).name.toSlice(ip),
                 };
                 try ref_traces.append(gpa, .{
                     .decl_name = try eb.addString(name),
@@ -3456,7 +3397,7 @@ pub fn addModuleErrorMsg(
     defer notes.deinit(gpa);
 
     for (module_err_msg.notes) |module_note| {
-        const note_src_loc = module_note.src_loc.upgrade(mod);
+        const note_src_loc = module_note.src_loc.upgrade(zcu);
         const source = try note_src_loc.file_scope.getSource(gpa);
         const span = try note_src_loc.span(gpa);
         const loc = std.zig.findLineColumn(source.bytes, span.main);
@@ -3509,16 +3450,18 @@ pub fn performAllTheWork(
     comp: *Compilation,
     main_progress_node: std.Progress.Node,
 ) JobError!void {
-    defer if (comp.zcu) |mod| {
-        mod.sema_prog_node.end();
-        mod.sema_prog_node = std.Progress.Node.none;
-        mod.codegen_prog_node.end();
-        mod.codegen_prog_node = std.Progress.Node.none;
+    comp.work_queue_progress_node = main_progress_node;
+    defer comp.work_queue_progress_node = .none;
 
-        mod.generation += 1;
+    defer if (comp.zcu) |zcu| {
+        zcu.sema_prog_node.end();
+        zcu.sema_prog_node = std.Progress.Node.none;
+        zcu.codegen_prog_node.end();
+        zcu.codegen_prog_node = std.Progress.Node.none;
+
+        zcu.generation += 1;
     };
     try comp.performAllTheWorkInner(main_progress_node);
-    if (!InternPool.single_threaded) if (comp.codegen_work.job_error) |job_error| return job_error;
 }
 
 fn performAllTheWorkInner(
@@ -3533,12 +3476,34 @@ fn performAllTheWorkInner(
     var work_queue_wait_group: WaitGroup = .{};
     defer work_queue_wait_group.wait();
 
+    comp.link_task_wait_group.reset();
+    defer comp.link_task_wait_group.wait();
+
+    if (comp.link_task_queue.start()) {
+        comp.thread_pool.spawnWgId(&comp.link_task_wait_group, link.flushTaskQueue, .{comp});
+    }
+
     if (comp.docs_emit != null) {
         dev.check(.docs_emit);
         comp.thread_pool.spawnWg(&work_queue_wait_group, workerDocsCopy, .{comp});
         work_queue_wait_group.spawnManager(workerDocsWasm, .{ comp, main_progress_node });
     }
 
+    if (comp.job_queued_compiler_rt_lib) {
+        comp.job_queued_compiler_rt_lib = false;
+        comp.link_task_wait_group.spawnManager(buildRt, .{ comp, "compiler_rt.zig", .compiler_rt, .Lib, &comp.compiler_rt_lib, main_progress_node });
+    }
+
+    if (comp.job_queued_compiler_rt_obj) {
+        comp.job_queued_compiler_rt_obj = false;
+        comp.link_task_wait_group.spawnManager(buildRt, .{ comp, "compiler_rt.zig", .compiler_rt, .Obj, &comp.compiler_rt_obj, main_progress_node });
+    }
+
+    if (comp.job_queued_fuzzer_lib) {
+        comp.job_queued_fuzzer_lib = false;
+        comp.link_task_wait_group.spawnManager(buildRt, .{ comp, "fuzzer.zig", .libfuzzer, .Lib, &comp.fuzzer_lib, main_progress_node });
+    }
+
     {
         const astgen_frame = tracy.namedFrame("astgen");
         defer astgen_frame.end();
@@ -3601,22 +3566,18 @@ fn performAllTheWorkInner(
         }
 
         while (comp.c_object_work_queue.readItem()) |c_object| {
-            comp.thread_pool.spawnWg(&work_queue_wait_group, workerUpdateCObject, .{
+            comp.thread_pool.spawnWg(&comp.link_task_wait_group, workerUpdateCObject, .{
                 comp, c_object, main_progress_node,
             });
         }
 
         while (comp.win32_resource_work_queue.readItem()) |win32_resource| {
-            comp.thread_pool.spawnWg(&work_queue_wait_group, workerUpdateWin32Resource, .{
+            comp.thread_pool.spawnWg(&comp.link_task_wait_group, workerUpdateWin32Resource, .{
                 comp, win32_resource, main_progress_node,
             });
         }
     }
 
-    if (comp.job_queued_compiler_rt_lib) work_queue_wait_group.spawnManager(buildRt, .{ comp, "compiler_rt.zig", .compiler_rt, .Lib, &comp.compiler_rt_lib, main_progress_node });
-    if (comp.job_queued_compiler_rt_obj) work_queue_wait_group.spawnManager(buildRt, .{ comp, "compiler_rt.zig", .compiler_rt, .Obj, &comp.compiler_rt_obj, main_progress_node });
-    if (comp.job_queued_fuzzer_lib) work_queue_wait_group.spawnManager(buildRt, .{ comp, "fuzzer.zig", .libfuzzer, .Lib, &comp.fuzzer_lib, main_progress_node });
-
     if (comp.zcu) |zcu| {
         const pt: Zcu.PerThread = .{ .zcu = zcu, .tid = .main };
         if (comp.incremental) {
@@ -3631,18 +3592,12 @@ fn performAllTheWorkInner(
         zcu.codegen_prog_node = main_progress_node.start("Code Generation", 0);
     }
 
-    if (!InternPool.single_threaded) {
-        comp.codegen_work.done = false; // may be `true` from a prior update
-        comp.thread_pool.spawnWgId(&work_queue_wait_group, codegenThread, .{comp});
+    if (!comp.separateCodegenThreadOk()) {
+        // Waits until all input files have been parsed.
+        comp.link_task_wait_group.wait();
+        comp.link_task_wait_group.reset();
+        std.log.scoped(.link).debug("finished waiting for link_task_wait_group", .{});
     }
-    defer if (!InternPool.single_threaded) {
-        {
-            comp.codegen_work.mutex.lock();
-            defer comp.codegen_work.mutex.unlock();
-            comp.codegen_work.done = true;
-        }
-        comp.codegen_work.cond.signal();
-    };
 
     work: while (true) {
         for (&comp.work_queues) |*work_queue| if (work_queue.readItem()) |job| {
@@ -3686,16 +3641,14 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
                 }
             }
             assert(nav.status == .resolved);
-            try comp.queueCodegenJob(tid, .{ .nav = nav_index });
+            comp.dispatchCodegenTask(tid, .{ .codegen_nav = nav_index });
         },
         .codegen_func => |func| {
-            // This call takes ownership of `func.air`.
-            try comp.queueCodegenJob(tid, .{ .func = .{
-                .func = func.func,
-                .air = func.air,
-            } });
+            comp.dispatchCodegenTask(tid, .{ .codegen_func = func });
+        },
+        .codegen_type => |ty| {
+            comp.dispatchCodegenTask(tid, .{ .codegen_type = ty });
         },
-        .codegen_type => |ty| try comp.queueCodegenJob(tid, .{ .type = ty }),
         .analyze_func => |func| {
             const named_frame = tracy.namedFrame("analyze_func");
             defer named_frame.end();
@@ -3742,31 +3695,6 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
                 error.AnalysisFail => return,
             };
         },
-        .update_line_number => |decl_index| {
-            const named_frame = tracy.namedFrame("update_line_number");
-            defer named_frame.end();
-
-            if (true) @panic("TODO: update_line_number");
-
-            const gpa = comp.gpa;
-            const pt: Zcu.PerThread = .{ .zcu = comp.zcu.?, .tid = @enumFromInt(tid) };
-            const decl = pt.zcu.declPtr(decl_index);
-            const lf = comp.bin_file.?;
-            lf.updateDeclLineNumber(pt, decl_index) catch |err| {
-                try pt.zcu.failed_analysis.ensureUnusedCapacity(gpa, 1);
-                pt.zcu.failed_analysis.putAssumeCapacityNoClobber(
-                    InternPool.AnalUnit.wrap(.{ .decl = decl_index }),
-                    try Zcu.ErrorMsg.create(
-                        gpa,
-                        decl.navSrcLoc(pt.zcu),
-                        "unable to update line number: {s}",
-                        .{@errorName(err)},
-                    ),
-                );
-                decl.analysis = .codegen_failure;
-                try pt.zcu.retryable_failures.append(gpa, InternPool.AnalUnit.wrap(.{ .decl = decl_index }));
-            };
-        },
         .analyze_mod => |mod| {
             const named_frame = tracy.namedFrame("analyze_mod");
             defer named_frame.end();
@@ -3831,7 +3759,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
             const named_frame = tracy.namedFrame("windows_import_lib");
             defer named_frame.end();
 
-            const link_lib = comp.system_libs.keys()[index];
+            const link_lib = comp.windows_libs.keys()[index];
             mingw.buildImportLib(comp, link_lib) catch |err| {
                 // TODO Surface more error details.
                 comp.lockAndSetMiscFailure(
@@ -3933,66 +3861,20 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
     }
 }
 
-fn queueCodegenJob(comp: *Compilation, tid: usize, codegen_job: CodegenJob) !void {
-    if (InternPool.single_threaded or
-        !comp.zcu.?.backendSupportsFeature(.separate_thread))
-        return processOneCodegenJob(tid, comp, codegen_job);
-
-    {
-        comp.codegen_work.mutex.lock();
-        defer comp.codegen_work.mutex.unlock();
-        try comp.codegen_work.queue.writeItem(codegen_job);
-    }
-    comp.codegen_work.cond.signal();
-}
-
-fn codegenThread(tid: usize, comp: *Compilation) void {
-    comp.codegen_work.mutex.lock();
-    defer comp.codegen_work.mutex.unlock();
-
-    while (true) {
-        if (comp.codegen_work.queue.readItem()) |codegen_job| {
-            comp.codegen_work.mutex.unlock();
-            defer comp.codegen_work.mutex.lock();
-
-            processOneCodegenJob(tid, comp, codegen_job) catch |job_error| {
-                comp.codegen_work.job_error = job_error;
-                break;
-            };
-            continue;
-        }
-
-        if (comp.codegen_work.done) break;
-
-        comp.codegen_work.cond.wait(&comp.codegen_work.mutex);
+/// The reason for the double-queue here is that the first queue ensures any
+/// resolve_type_fully tasks are complete before this dispatch function is called.
+fn dispatchCodegenTask(comp: *Compilation, tid: usize, link_task: link.Task) void {
+    if (comp.separateCodegenThreadOk()) {
+        comp.queueLinkTasks(&.{link_task});
+    } else {
+        link.doTask(comp, tid, link_task);
     }
 }
 
-fn processOneCodegenJob(tid: usize, comp: *Compilation, codegen_job: CodegenJob) JobError!void {
-    switch (codegen_job) {
-        .nav => |nav_index| {
-            const named_frame = tracy.namedFrame("codegen_nav");
-            defer named_frame.end();
-
-            const pt: Zcu.PerThread = .{ .zcu = comp.zcu.?, .tid = @enumFromInt(tid) };
-            try pt.linkerUpdateNav(nav_index);
-        },
-        .func => |func| {
-            const named_frame = tracy.namedFrame("codegen_func");
-            defer named_frame.end();
-
-            const pt: Zcu.PerThread = .{ .zcu = comp.zcu.?, .tid = @enumFromInt(tid) };
-            // This call takes ownership of `func.air`.
-            try pt.linkerUpdateFunc(func.func, func.air);
-        },
-        .type => |ty| {
-            const named_frame = tracy.namedFrame("codegen_type");
-            defer named_frame.end();
-
-            const pt: Zcu.PerThread = .{ .zcu = comp.zcu.?, .tid = @enumFromInt(tid) };
-            try pt.linkerUpdateContainerType(ty);
-        },
-    }
+fn separateCodegenThreadOk(comp: *const Compilation) bool {
+    if (InternPool.single_threaded) return false;
+    const zcu = comp.zcu orelse return true;
+    return zcu.backendSupportsFeature(.separate_thread);
 }
 
 fn workerDocsCopy(comp: *Compilation) void {
@@ -4744,7 +4626,7 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr
     // file and building an object we need to link them together, but with just one it should go
     // directly to the output file.
     const direct_o = comp.c_source_files.len == 1 and comp.zcu == null and
-        comp.config.output_mode == .Obj and comp.objects.len == 0;
+        comp.config.output_mode == .Obj and !link.anyObjectInputs(comp.link_inputs);
     const o_basename_noext = if (direct_o)
         comp.root_name
     else
@@ -4983,7 +4865,9 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr
         // the contents were the same, we hit the cache but the manifest is dirty and we need to update
         // it to prevent doing a full file content comparison the next time around.
         man.writeManifest() catch |err| {
-            log.warn("failed to write cache manifest when compiling '{s}': {s}", .{ c_object.src.src_path, @errorName(err) });
+            log.warn("failed to write cache manifest when compiling '{s}': {s}", .{
+                c_object.src.src_path, @errorName(err),
+            });
         };
     }
 
@@ -4998,6 +4882,8 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr
             .lock = man.toOwnedLock(),
         },
     };
+
+    comp.queueLinkTasks(&.{.{ .load_object = c_object.status.success.object_path }});
 }
 
 fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32_resource_prog_node: std.Progress.Node) !void {
@@ -5376,7 +5262,7 @@ pub fn addCCArgs(
         try argv.append("-fdata-sections");
     }
 
-    if (comp.no_builtin) {
+    if (mod.no_builtin) {
         try argv.append("-fno-builtin");
     }
 
@@ -5439,7 +5325,7 @@ pub fn addCCArgs(
 
             switch (ext) {
                 .c, .cpp, .m, .mm, .h, .hpp, .hm, .hmm, .cu, .rc, .assembly, .assembly_with_cpp => {
-                    const minver: u16 = @truncate(@intFromEnum(target.os.getVersionRange().windows.min) >> 16);
+                    const minver: u16 = @truncate(@intFromEnum(target.os.versionRange().windows.min) >> 16);
                     try argv.append(
                         try std.fmt.allocPrint(arena, "-D_WIN32_WINNT=0x{x:0>4}", .{minver}),
                     );
@@ -5486,10 +5372,12 @@ pub fn addCCArgs(
                 try argv.append(include_dir);
             }
 
-            if (target.cpu.model.llvm_name) |llvm_name| {
-                try argv.appendSlice(&[_][]const u8{
-                    "-Xclang", "-target-cpu", "-Xclang", llvm_name,
-                });
+            if (target_util.clangSupportsTargetCpuArg(target)) {
+                if (target.cpu.model.llvm_name) |llvm_name| {
+                    try argv.appendSlice(&[_][]const u8{
+                        "-Xclang", "-target-cpu", "-Xclang", llvm_name,
+                    });
+                }
             }
 
             // It would be really nice if there was a more compact way to communicate this info to Clang.
@@ -5737,12 +5625,16 @@ pub fn addCCArgs(
         },
     }
 
+    if (comp.mingw_unicode_entry_point) {
+        try argv.append("-municode");
+    }
+
     if (target.cpu.arch.isThumb()) {
         try argv.append("-mthumb");
     }
 
-    if (target_util.supports_fpic(target) and mod.pic) {
-        try argv.append("-fPIC");
+    if (target_util.supports_fpic(target)) {
+        try argv.append(if (mod.pic) "-fPIC" else "-fno-PIC");
     }
 
     try argv.ensureUnusedCapacity(2);
@@ -6102,8 +5994,8 @@ test "classifyFileExt" {
     try std.testing.expectEqual(FileExt.zig, classifyFileExt("foo.zig"));
 }
 
-pub fn get_libc_crt_file(comp: *Compilation, arena: Allocator, basename: []const u8) !Path {
-    return (try crtFilePath(comp, basename)) orelse {
+fn get_libc_crt_file(comp: *Compilation, arena: Allocator, basename: []const u8) !Path {
+    return (try crtFilePath(&comp.crt_files, basename)) orelse {
         const lci = comp.libc_installation orelse return error.LibCInstallationNotAvailable;
         const crt_dir_path = lci.crt_dir orelse return error.LibCInstallationMissingCrtDir;
         const full_path = try std.fs.path.join(arena, &[_][]const u8{ crt_dir_path, basename });
@@ -6116,40 +6008,11 @@ pub fn crtFileAsString(comp: *Compilation, arena: Allocator, basename: []const u
     return path.toString(arena);
 }
 
-pub fn crtFilePath(comp: *Compilation, basename: []const u8) Allocator.Error!?Path {
-    const crt_file = comp.crt_files.get(basename) orelse return null;
+fn crtFilePath(crt_files: *std.StringHashMapUnmanaged(CrtFile), basename: []const u8) Allocator.Error!?Path {
+    const crt_file = crt_files.get(basename) orelse return null;
     return crt_file.full_object_path;
 }
 
-fn wantBuildLibCFromSource(comp: Compilation) bool {
-    const is_exe_or_dyn_lib = switch (comp.config.output_mode) {
-        .Obj => false,
-        .Lib => comp.config.link_mode == .dynamic,
-        .Exe => true,
-    };
-    const ofmt = comp.root_mod.resolved_target.result.ofmt;
-    return comp.config.link_libc and is_exe_or_dyn_lib and
-        comp.libc_installation == null and ofmt != .c;
-}
-
-fn wantBuildGLibCFromSource(comp: Compilation) bool {
-    return comp.wantBuildLibCFromSource() and comp.getTarget().isGnuLibC();
-}
-
-fn wantBuildMuslFromSource(comp: Compilation) bool {
-    return comp.wantBuildLibCFromSource() and comp.getTarget().isMusl() and
-        !comp.getTarget().isWasm();
-}
-
-fn wantBuildWasiLibcFromSource(comp: Compilation) bool {
-    return comp.wantBuildLibCFromSource() and comp.getTarget().isWasm() and
-        comp.getTarget().os.tag == .wasi;
-}
-
-fn wantBuildMinGWFromSource(comp: Compilation) bool {
-    return comp.wantBuildLibCFromSource() and comp.getTarget().isMinGW();
-}
-
 fn wantBuildLibUnwindFromSource(comp: *Compilation) bool {
     const is_exe_or_dyn_lib = switch (comp.config.output_mode) {
         .Obj => false,
@@ -6160,7 +6023,8 @@ fn wantBuildLibUnwindFromSource(comp: *Compilation) bool {
     return is_exe_or_dyn_lib and comp.config.link_libunwind and ofmt != .c;
 }
 
-fn setAllocFailure(comp: *Compilation) void {
+pub fn setAllocFailure(comp: *Compilation) void {
+    @branchHint(.cold);
     log.debug("memory allocation failure", .{});
     comp.alloc_failure_occurred = true;
 }
@@ -6195,54 +6059,6 @@ pub fn lockAndSetMiscFailure(
     return setMiscFailure(comp, tag, format, args);
 }
 
-fn parseLldStderr(comp: *Compilation, prefix: []const u8, stderr: []const u8) Allocator.Error!void {
-    var context_lines = std.ArrayList([]const u8).init(comp.gpa);
-    defer context_lines.deinit();
-
-    var current_err: ?*LldError = null;
-    var lines = mem.splitSequence(u8, stderr, if (builtin.os.tag == .windows) "\r\n" else "\n");
-    while (lines.next()) |line| {
-        if (line.len > prefix.len + ":".len and
-            mem.eql(u8, line[0..prefix.len], prefix) and line[prefix.len] == ':')
-        {
-            if (current_err) |err| {
-                err.context_lines = try context_lines.toOwnedSlice();
-            }
-
-            var split = mem.splitSequence(u8, line, "error: ");
-            _ = split.first();
-
-            const duped_msg = try std.fmt.allocPrint(comp.gpa, "{s}: {s}", .{ prefix, split.rest() });
-            errdefer comp.gpa.free(duped_msg);
-
-            current_err = try comp.lld_errors.addOne(comp.gpa);
-            current_err.?.* = .{ .msg = duped_msg };
-        } else if (current_err != null) {
-            const context_prefix = ">>> ";
-            var trimmed = mem.trimRight(u8, line, &std.ascii.whitespace);
-            if (mem.startsWith(u8, trimmed, context_prefix)) {
-                trimmed = trimmed[context_prefix.len..];
-            }
-
-            if (trimmed.len > 0) {
-                const duped_line = try comp.gpa.dupe(u8, trimmed);
-                try context_lines.append(duped_line);
-            }
-        }
-    }
-
-    if (current_err) |err| {
-        err.context_lines = try context_lines.toOwnedSlice();
-    }
-}
-
-pub fn lockAndParseLldStderr(comp: *Compilation, prefix: []const u8, stderr: []const u8) void {
-    comp.mutex.lock();
-    defer comp.mutex.unlock();
-
-    comp.parseLldStderr(prefix, stderr) catch comp.setAllocFailure();
-}
-
 pub fn dump_argv(argv: []const []const u8) void {
     std.debug.lockStdErr();
     defer std.debug.unlockStdErr();
@@ -6343,7 +6159,6 @@ fn buildOutputFromZig(
 
     assert(output_mode != .Exe);
 
-    const unwind_tables = comp.link_eh_frame_hdr;
     const strip = comp.compilerRtStrip();
     const optimize_mode = comp.compilerRtOptMode();
 
@@ -6357,7 +6172,6 @@ fn buildOutputFromZig(
         .root_optimize_mode = optimize_mode,
         .root_strip = strip,
         .link_libc = comp.config.link_libc,
-        .any_unwind_tables = unwind_tables,
     });
 
     const root_mod = try Package.Module.create(arena, .{
@@ -6374,10 +6188,11 @@ fn buildOutputFromZig(
             .stack_protector = 0,
             .red_zone = comp.root_mod.red_zone,
             .omit_frame_pointer = comp.root_mod.omit_frame_pointer,
-            .unwind_tables = unwind_tables,
+            .unwind_tables = comp.root_mod.unwind_tables,
             .pic = comp.root_mod.pic,
             .optimize_mode = optimize_mode,
             .structured_cfg = comp.root_mod.structured_cfg,
+            .no_builtin = true,
             .code_model = comp.root_mod.code_model,
         },
         .global = config,
@@ -6426,7 +6241,6 @@ fn buildOutputFromZig(
         },
         .function_sections = true,
         .data_sections = true,
-        .no_builtin = true,
         .emit_h = null,
         .verbose_cc = comp.verbose_cc,
         .verbose_link = comp.verbose_link,
@@ -6444,11 +6258,21 @@ fn buildOutputFromZig(
 
     try comp.updateSubCompilation(sub_compilation, misc_task_tag, prog_node);
 
-    // Under incremental compilation, `out` may already be populated from a prior update.
-    assert(out.* == null or comp.incremental);
-    out.* = try sub_compilation.toCrtFile();
+    const crt_file = try sub_compilation.toCrtFile();
+    assert(out.* == null);
+    out.* = crt_file;
+
+    comp.queueLinkTaskMode(crt_file.full_object_path, output_mode);
 }
 
+pub const CrtFileOptions = struct {
+    function_sections: ?bool = null,
+    data_sections: ?bool = null,
+    omit_frame_pointer: ?bool = null,
+    pic: ?bool = null,
+    no_builtin: ?bool = null,
+};
+
 pub fn build_crt_file(
     comp: *Compilation,
     root_name: []const u8,
@@ -6458,6 +6282,7 @@ pub fn build_crt_file(
     /// These elements have to get mutated to add the owner module after it is
     /// created within this function.
     c_source_files: []CSourceFile,
+    options: CrtFileOptions,
 ) !void {
     const tracy_trace = trace(@src());
     defer tracy_trace.end();
@@ -6502,12 +6327,16 @@ pub fn build_crt_file(
             .sanitize_c = false,
             .sanitize_thread = false,
             .red_zone = comp.root_mod.red_zone,
-            .omit_frame_pointer = comp.root_mod.omit_frame_pointer,
+            // Some libcs (e.g. musl) are opinionated about -fomit-frame-pointer.
+            .omit_frame_pointer = options.omit_frame_pointer orelse comp.root_mod.omit_frame_pointer,
             .valgrind = false,
             .unwind_tables = false,
-            .pic = comp.root_mod.pic,
+            // Some CRT objects (e.g. musl's rcrt1.o and Scrt1.o) are opinionated about PIC.
+            .pic = options.pic orelse comp.root_mod.pic,
             .optimize_mode = comp.compilerRtOptMode(),
             .structured_cfg = comp.root_mod.structured_cfg,
+            // Some libcs (e.g. musl) are opinionated about -fno-builtin.
+            .no_builtin = options.no_builtin orelse comp.root_mod.no_builtin,
         },
         .global = config,
         .cc_argv = &.{},
@@ -6535,6 +6364,8 @@ pub fn build_crt_file(
             .directory = null, // Put it in the cache directory.
             .basename = basename,
         },
+        .function_sections = options.function_sections orelse false,
+        .data_sections = options.data_sections orelse false,
         .emit_h = null,
         .c_source_files = c_source_files,
         .verbose_cc = comp.verbose_cc,
@@ -6553,8 +6384,33 @@ pub fn build_crt_file(
 
     try comp.updateSubCompilation(sub_compilation, misc_task_tag, prog_node);
 
-    try comp.crt_files.ensureUnusedCapacity(gpa, 1);
-    comp.crt_files.putAssumeCapacityNoClobber(basename, try sub_compilation.toCrtFile());
+    const crt_file = try sub_compilation.toCrtFile();
+    comp.queueLinkTaskMode(crt_file.full_object_path, output_mode);
+
+    {
+        comp.mutex.lock();
+        defer comp.mutex.unlock();
+        try comp.crt_files.ensureUnusedCapacity(gpa, 1);
+        comp.crt_files.putAssumeCapacityNoClobber(basename, crt_file);
+    }
+}
+
+pub fn queueLinkTaskMode(comp: *Compilation, path: Path, output_mode: std.builtin.OutputMode) void {
+    comp.queueLinkTasks(switch (output_mode) {
+        .Exe => unreachable,
+        .Obj => &.{.{ .load_object = path }},
+        .Lib => &.{.{ .load_archive = path }},
+    });
+}
+
+/// Only valid to call during `update`. Automatically handles queuing up a
+/// linker worker task if there is not already one.
+pub fn queueLinkTasks(comp: *Compilation, tasks: []const link.Task) void {
+    if (comp.link_task_queue.enqueue(comp.gpa, tasks) catch |err| switch (err) {
+        error.OutOfMemory => return comp.setAllocFailure(),
+    }) {
+        comp.thread_pool.spawnWgId(&comp.link_task_wait_group, link.flushTaskQueue, .{comp});
+    }
 }
 
 pub fn toCrtFile(comp: *Compilation) Allocator.Error!CrtFile {
@@ -6572,21 +6428,31 @@ pub fn getCrtPaths(
     arena: Allocator,
 ) error{ OutOfMemory, LibCInstallationMissingCrtDir }!LibCInstallation.CrtPaths {
     const target = comp.root_mod.resolved_target.result;
+    return getCrtPathsInner(arena, target, comp.config, comp.libc_installation, &comp.crt_files);
+}
+
+fn getCrtPathsInner(
+    arena: Allocator,
+    target: std.Target,
+    config: Config,
+    libc_installation: ?*const LibCInstallation,
+    crt_files: *std.StringHashMapUnmanaged(CrtFile),
+) error{ OutOfMemory, LibCInstallationMissingCrtDir }!LibCInstallation.CrtPaths {
     const basenames = LibCInstallation.CrtBasenames.get(.{
         .target = target,
-        .link_libc = comp.config.link_libc,
-        .output_mode = comp.config.output_mode,
-        .link_mode = comp.config.link_mode,
-        .pie = comp.config.pie,
+        .link_libc = config.link_libc,
+        .output_mode = config.output_mode,
+        .link_mode = config.link_mode,
+        .pie = config.pie,
     });
-    if (comp.libc_installation) |lci| return lci.resolveCrtPaths(arena, basenames, target);
+    if (libc_installation) |lci| return lci.resolveCrtPaths(arena, basenames, target);
 
     return .{
-        .crt0 = if (basenames.crt0) |basename| try comp.crtFilePath(basename) else null,
-        .crti = if (basenames.crti) |basename| try comp.crtFilePath(basename) else null,
-        .crtbegin = if (basenames.crtbegin) |basename| try comp.crtFilePath(basename) else null,
-        .crtend = if (basenames.crtend) |basename| try comp.crtFilePath(basename) else null,
-        .crtn = if (basenames.crtn) |basename| try comp.crtFilePath(basename) else null,
+        .crt0 = if (basenames.crt0) |basename| try crtFilePath(crt_files, basename) else null,
+        .crti = if (basenames.crti) |basename| try crtFilePath(crt_files, basename) else null,
+        .crtbegin = if (basenames.crtbegin) |basename| try crtFilePath(crt_files, basename) else null,
+        .crtend = if (basenames.crtend) |basename| try crtFilePath(crt_files, basename) else null,
+        .crtn = if (basenames.crtn) |basename| try crtFilePath(crt_files, basename) else null,
     };
 }
 
@@ -6596,24 +6462,14 @@ pub fn addLinkLib(comp: *Compilation, lib_name: []const u8) !void {
     // then when we create a sub-Compilation for zig libc, it also tries to
     // build kernel32.lib.
     if (comp.skip_linker_dependencies) return;
+    const target = comp.root_mod.resolved_target.result;
+    if (target.os.tag != .windows or target.ofmt == .c) return;
 
     // This happens when an `extern "foo"` function is referenced.
     // 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.system_libs.getOrPut(comp.gpa, lib_name);
-    if (!gop.found_existing) {
-        gop.value_ptr.* = .{
-            .needed = true,
-            .weak = false,
-            .path = null,
-        };
-        const target = comp.root_mod.resolved_target.result;
-        if (target.os.tag == .windows and target.ofmt != .c) {
-            try comp.queueJob(.{
-                .windows_import_lib = comp.system_libs.count() - 1,
-            });
-        }
-    }
+    const gop = try comp.windows_libs.getOrPut(comp.gpa, lib_name);
+    if (!gop.found_existing) try comp.queueJob(.{ .windows_import_lib = comp.windows_libs.count() - 1 });
 }
 
 /// This decides the optimization mode for all zig-provided libraries, including
diff --git a/zig/src/InternPool.zig b/zig/src/InternPool.zig
index f41f780e0a..59db85681a 100644
--- a/zig/src/InternPool.zig
+++ b/zig/src/InternPool.zig
@@ -17,6 +17,13 @@ tid_shift_31: if (single_threaded) u0 else std.math.Log2Int(u32),
 /// Cached shift amount to put a `tid` in the top bits of a 32-bit value.
 tid_shift_32: if (single_threaded) u0 else std.math.Log2Int(u32),
 
+/// Dependencies on whether an entire file gets past AstGen.
+/// These are triggered by `@import`, so that:
+/// * if a file initially fails AstGen, triggering a transitive failure, when a future update
+///   causes it to succeed AstGen, the `@import` is re-analyzed, allowing analysis to proceed
+/// * if a file initially succeds AstGen, but a future update causes the file to fail it,
+///   the `@import` is re-analyzed, registering a transitive failure
+file_deps: std.AutoArrayHashMapUnmanaged(FileIndex, DepEntry.Index),
 /// Dependencies on the source code hash associated with a ZIR instruction.
 /// * For a `declaration`, this is the entire declaration body.
 /// * For a `struct_decl`, `union_decl`, etc, this is the source of the fields (but not declarations).
@@ -70,6 +77,7 @@ pub const empty: InternPool = .{
     .tid_shift_30 = if (single_threaded) 0 else 31,
     .tid_shift_31 = if (single_threaded) 0 else 31,
     .tid_shift_32 = if (single_threaded) 0 else 31,
+    .file_deps = .empty,
     .src_hash_deps = .empty,
     .nav_val_deps = .empty,
     .interned_deps = .empty,
@@ -656,6 +664,7 @@ pub const Nav = struct {
 };
 
 pub const Dependee = union(enum) {
+    file: FileIndex,
     src_hash: TrackedInst.Index,
     nav_val: Nav.Index,
     interned: Index,
@@ -704,6 +713,7 @@ pub const DependencyIterator = struct {
 
 pub fn dependencyIterator(ip: *const InternPool, dependee: Dependee) DependencyIterator {
     const first_entry = switch (dependee) {
+        .file => |x| ip.file_deps.get(x),
         .src_hash => |x| ip.src_hash_deps.get(x),
         .nav_val => |x| ip.nav_val_deps.get(x),
         .interned => |x| ip.interned_deps.get(x),
@@ -740,6 +750,7 @@ pub fn addDependency(ip: *InternPool, gpa: Allocator, depender: AnalUnit, depend
     const new_index: DepEntry.Index = switch (dependee) {
         inline else => |dependee_payload, tag| new_index: {
             const gop = try switch (tag) {
+                .file => ip.file_deps,
                 .src_hash => ip.src_hash_deps,
                 .nav_val => ip.nav_val_deps,
                 .interned => ip.interned_deps,
@@ -1776,10 +1787,11 @@ pub const Key = union(enum) {
     /// or was created with `@Type`. It is unique and based on a declaration.
     /// It may be a tuple, if declared like this: `struct {A, B, C}`.
     struct_type: NamespaceType,
-    /// This is an anonymous struct or tuple type which has no corresponding
-    /// declaration. It is used for types that have no `struct` keyword in the
-    /// source code, and were not created via `@Type`.
-    anon_struct_type: AnonStructType,
+    /// 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,
@@ -1908,27 +1920,10 @@ pub const Key = union(enum) {
         child: Index,
     };
 
-    pub const AnonStructType = struct {
+    pub const TupleType = struct {
         types: Index.Slice,
-        /// This may be empty, indicating this is a tuple.
-        names: NullTerminatedString.Slice,
         /// These elements may be `none`, indicating runtime-known.
         values: Index.Slice,
-
-        pub fn isTuple(self: AnonStructType) bool {
-            return self.names.len == 0;
-        }
-
-        pub fn fieldName(
-            self: AnonStructType,
-            ip: *const InternPool,
-            index: usize,
-        ) OptionalNullTerminatedString {
-            if (self.names.len == 0)
-                return .none;
-
-            return self.names.get(ip)[index].toOptional();
-        }
     };
 
     /// This is the hashmap key. To fetch other data associated with the type, see:
@@ -1954,18 +1949,15 @@ pub const Key = union(enum) {
             /// The union for which this is a tag type.
             union_type: Index,
         },
-        /// This type originates from a reification via `@Type`.
-        /// It is hased based on its ZIR instruction index and fields, attributes, etc.
+        /// This type originates from a reification via `@Type`, 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 hased by Sema.
         reified: struct {
-            /// A `reify` instruction.
+            /// A `reify`, `struct_init`, `struct_init_ref`, or `struct_init_anon` instruction.
             zir_index: TrackedInst.Index,
             /// A hash of this type's attributes, fields, etc, generated by Sema.
             type_hash: u64,
         },
-        /// This type is `@TypeOf(.{})`.
-        /// TODO: can we change the language spec to not special-case this type?
-        empty_struct: void,
     };
 
     pub const FuncType = struct {
@@ -2000,10 +1992,10 @@ pub const Key = union(enum) {
                 a.return_type == b.return_type and
                 a.comptime_bits == b.comptime_bits and
                 a.noalias_bits == b.noalias_bits and
-                a.cc == b.cc and
                 a.is_var_args == b.is_var_args and
                 a.is_generic == b.is_generic and
-                a.is_noinline == b.is_noinline;
+                a.is_noinline == b.is_noinline and
+                std.meta.eql(a.cc, b.cc);
         }
 
         pub fn hash(self: FuncType, hasher: *Hash, ip: *const InternPool) void {
@@ -2043,6 +2035,7 @@ pub const Key = union(enum) {
         is_const: bool,
         is_threadlocal: bool,
         is_weak_linkage: bool,
+        is_dll_import: bool,
         alignment: Alignment,
         @"addrspace": std.builtin.AddressSpace,
         /// The ZIR instruction which created this extern; used only for source locations.
@@ -2485,7 +2478,6 @@ pub const Key = union(enum) {
                         std.hash.autoHash(&hasher, reified.zir_index);
                         std.hash.autoHash(&hasher, reified.type_hash);
                     },
-                    .empty_struct => {},
                 }
                 return hasher.final();
             },
@@ -2558,7 +2550,7 @@ pub const Key = union(enum) {
                 const child = switch (ip.indexToKey(aggregate.ty)) {
                     .array_type => |array_type| array_type.child,
                     .vector_type => |vector_type| vector_type.child,
-                    .anon_struct_type, .struct_type => .none,
+                    .tuple_type, .struct_type => .none,
                     else => unreachable,
                 };
 
@@ -2613,11 +2605,10 @@ pub const Key = union(enum) {
 
             .error_set_type => |x| Hash.hash(seed, std.mem.sliceAsBytes(x.names.get(ip))),
 
-            .anon_struct_type => |anon_struct_type| {
+            .tuple_type => |tuple_type| {
                 var hasher = Hash.init(seed);
-                for (anon_struct_type.types.get(ip)) |elem| std.hash.autoHash(&hasher, elem);
-                for (anon_struct_type.values.get(ip)) |elem| std.hash.autoHash(&hasher, elem);
-                for (anon_struct_type.names.get(ip)) |elem| std.hash.autoHash(&hasher, elem);
+                for (tuple_type.types.get(ip)) |elem| std.hash.autoHash(&hasher, elem);
+                for (tuple_type.values.get(ip)) |elem| std.hash.autoHash(&hasher, elem);
                 return hasher.final();
             },
 
@@ -2664,7 +2655,8 @@ pub const Key = union(enum) {
                 asBytes(&e.ty) ++ asBytes(&e.lib_name) ++
                 asBytes(&e.is_const) ++ asBytes(&e.is_threadlocal) ++
                 asBytes(&e.is_weak_linkage) ++ asBytes(&e.alignment) ++
-                asBytes(&e.@"addrspace") ++ asBytes(&e.zir_index)),
+                asBytes(&e.is_dll_import) ++ asBytes(&e.@"addrspace") ++
+                asBytes(&e.zir_index)),
         };
     }
 
@@ -2760,6 +2752,7 @@ pub const Key = union(enum) {
                     a_info.is_const == b_info.is_const and
                     a_info.is_threadlocal == b_info.is_threadlocal and
                     a_info.is_weak_linkage == b_info.is_weak_linkage and
+                    a_info.is_dll_import == b_info.is_dll_import and
                     a_info.alignment == b_info.alignment and
                     a_info.@"addrspace" == b_info.@"addrspace" and
                     a_info.zir_index == b_info.zir_index;
@@ -2915,7 +2908,6 @@ pub const Key = union(enum) {
                         return a_r.zir_index == b_r.zir_index and
                             a_r.type_hash == b_r.type_hash;
                     },
-                    .empty_struct => return true,
                 }
             },
             .aggregate => |a_info| {
@@ -2967,11 +2959,10 @@ pub const Key = union(enum) {
                     },
                 }
             },
-            .anon_struct_type => |a_info| {
-                const b_info = b.anon_struct_type;
+            .tuple_type => |a_info| {
+                const b_info = b.tuple_type;
                 return std.mem.eql(Index, a_info.types.get(ip), b_info.types.get(ip)) and
-                    std.mem.eql(Index, a_info.values.get(ip), b_info.values.get(ip)) and
-                    std.mem.eql(NullTerminatedString, a_info.names.get(ip), b_info.names.get(ip));
+                    std.mem.eql(Index, a_info.values.get(ip), b_info.values.get(ip));
             },
             .error_set_type => |a_info| {
                 const b_info = b.error_set_type;
@@ -3011,7 +3002,7 @@ pub const Key = union(enum) {
             .union_type,
             .opaque_type,
             .enum_type,
-            .anon_struct_type,
+            .tuple_type,
             .func_type,
             => .type_type,
 
@@ -3040,7 +3031,7 @@ pub const Key = union(enum) {
                 .void => .void_type,
                 .null => .null_type,
                 .false, .true => .bool_type,
-                .empty_struct => .empty_struct_type,
+                .empty_tuple => .empty_tuple_type,
                 .@"unreachable" => .noreturn_type,
                 .generic_poison => .generic_poison_type,
             },
@@ -3397,13 +3388,11 @@ pub const LoadedStructType = struct {
     // TODO: the non-fqn will be needed by the new dwarf structure
     /// The name of this struct type.
     name: NullTerminatedString,
-    /// The `Cau` within which type resolution occurs. `none` when the struct is `@TypeOf(.{})`.
-    cau: Cau.Index.Optional,
-    /// `none` when the struct is `@TypeOf(.{})`.
-    namespace: OptionalNamespaceIndex,
+    /// The `Cau` within which type resolution occurs.
+    cau: Cau.Index,
+    namespace: NamespaceIndex,
     /// Index of the `struct_decl` or `reify` ZIR instruction.
-    /// Only `none` when the struct is `@TypeOf(.{})`.
-    zir_index: TrackedInst.Index.Optional,
+    zir_index: TrackedInst.Index,
     layout: std.builtin.Type.ContainerLayout,
     field_names: NullTerminatedString.Slice,
     field_types: Index.Slice,
@@ -3899,10 +3888,6 @@ pub const LoadedStructType = struct {
         @atomicStore(Tag.TypeStruct.Flags, flags_ptr, flags, .release);
     }
 
-    pub fn isTuple(s: LoadedStructType, ip: *InternPool) bool {
-        return s.layout != .@"packed" and s.flagsUnordered(ip).is_tuple;
-    }
-
     pub fn hasReorderedFields(s: LoadedStructType) bool {
         return s.layout == .auto;
     }
@@ -3994,24 +3979,6 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
     const item = unwrapped_index.getItem(ip);
     switch (item.tag) {
         .type_struct => {
-            if (item.data == 0) return .{
-                .tid = .main,
-                .extra_index = 0,
-                .name = .empty,
-                .cau = .none,
-                .namespace = .none,
-                .zir_index = .none,
-                .layout = .auto,
-                .field_names = NullTerminatedString.Slice.empty,
-                .field_types = Index.Slice.empty,
-                .field_inits = Index.Slice.empty,
-                .field_aligns = Alignment.Slice.empty,
-                .runtime_order = LoadedStructType.RuntimeOrder.Slice.empty,
-                .comptime_bits = LoadedStructType.ComptimeBits.empty,
-                .offsets = LoadedStructType.Offsets.empty,
-                .names_map = .none,
-                .captures = CaptureValue.Slice.empty,
-            };
             const name: NullTerminatedString = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "name").?]);
             const cau: Cau.Index = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "cau").?]);
             const namespace: NamespaceIndex = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "namespace").?]);
@@ -4031,7 +3998,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
             };
             extra_index += captures_len;
             if (flags.is_reified) {
-                extra_index += 2; // PackedU64
+                extra_index += 2; // type_hash: PackedU64
             }
             const field_types: Index.Slice = .{
                 .tid = unwrapped_index.tid,
@@ -4039,7 +4006,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 .len = fields_len,
             };
             extra_index += fields_len;
-            const names_map: OptionalMapIndex, const names = if (!flags.is_tuple) n: {
+            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 = .{
@@ -4049,7 +4016,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 };
                 extra_index += fields_len;
                 break :n .{ names_map, names };
-            } else .{ .none, NullTerminatedString.Slice.empty };
+            };
             const inits: Index.Slice = if (flags.any_default_inits) i: {
                 const inits: Index.Slice = .{
                     .tid = unwrapped_index.tid,
@@ -4100,9 +4067,9 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 .tid = unwrapped_index.tid,
                 .extra_index = item.data,
                 .name = name,
-                .cau = cau.toOptional(),
-                .namespace = namespace.toOptional(),
-                .zir_index = zir_index.toOptional(),
+                .cau = cau,
+                .namespace = namespace,
+                .zir_index = zir_index,
                 .layout = if (flags.is_extern) .@"extern" else .auto,
                 .field_names = names,
                 .field_types = field_types,
@@ -4164,9 +4131,9 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 .tid = unwrapped_index.tid,
                 .extra_index = item.data,
                 .name = name,
-                .cau = cau.toOptional(),
-                .namespace = namespace.toOptional(),
-                .zir_index = zir_index.toOptional(),
+                .cau = cau,
+                .namespace = namespace,
+                .zir_index = zir_index,
                 .layout = .@"packed",
                 .field_names = field_names,
                 .field_types = field_types,
@@ -4393,9 +4360,9 @@ pub const Item = struct {
 /// `primitives` in AstGen.zig.
 pub const Index = enum(u32) {
     pub const first_type: Index = .u0_type;
-    pub const last_type: Index = .empty_struct_type;
+    pub const last_type: Index = .empty_tuple_type;
     pub const first_value: Index = .undef;
-    pub const last_value: Index = .empty_struct;
+    pub const last_value: Index = .empty_tuple;
 
     u0_type,
     i0_type,
@@ -4452,8 +4419,9 @@ pub const Index = enum(u32) {
     /// Used for the inferred error set of inline/comptime function calls.
     adhoc_inferred_error_set_type,
     generic_poison_type,
-    /// `@TypeOf(.{})`
-    empty_struct_type,
+    /// `@TypeOf(.{})`; a tuple with zero elements.
+    /// This is not the same as `struct {}`, since that is a struct rather than a tuple.
+    empty_tuple_type,
 
     /// `undefined` (untyped)
     undef,
@@ -4483,8 +4451,8 @@ pub const Index = enum(u32) {
     bool_true,
     /// `false`
     bool_false,
-    /// `.{}` (untyped)
-    empty_struct,
+    /// `.{}`
+    empty_tuple,
 
     /// Used for generic parameters where the type and value
     /// is not known until generic function instantiation.
@@ -4592,16 +4560,14 @@ pub const Index = enum(u32) {
                 values: []Index,
             },
         };
-        const DataIsExtraIndexOfTypeStructAnon = struct {
+        const DataIsExtraIndexOfTypeTuple = struct {
             const @"data.fields_len" = opaque {};
-            data: *TypeStructAnon,
+            data: *TypeTuple,
             @"trailing.types.len": *@"data.fields_len",
             @"trailing.values.len": *@"data.fields_len",
-            @"trailing.names.len": *@"data.fields_len",
             trailing: struct {
                 types: []Index,
                 values: []Index,
-                names: []NullTerminatedString,
             },
         };
 
@@ -4635,10 +4601,9 @@ pub const Index = enum(u32) {
         simple_type: void,
         type_opaque: struct { data: *Tag.TypeOpaque },
         type_struct: struct { data: *Tag.TypeStruct },
-        type_struct_anon: DataIsExtraIndexOfTypeStructAnon,
         type_struct_packed: struct { data: *Tag.TypeStructPacked },
         type_struct_packed_inits: struct { data: *Tag.TypeStructPacked },
-        type_tuple_anon: DataIsExtraIndexOfTypeStructAnon,
+        type_tuple: DataIsExtraIndexOfTypeTuple,
         type_union: struct { data: *Tag.TypeUnion },
         type_function: struct {
             const @"data.flags.has_comptime_bits" = opaque {};
@@ -4922,11 +4887,10 @@ pub const static_keys = [_]Key{
     // generic_poison_type
     .{ .simple_type = .generic_poison },
 
-    // empty_struct_type
-    .{ .anon_struct_type = .{
-        .types = Index.Slice.empty,
-        .names = NullTerminatedString.Slice.empty,
-        .values = Index.Slice.empty,
+    // empty_tuple_type
+    .{ .tuple_type = .{
+        .types = .empty,
+        .values = .empty,
     } },
 
     .{ .simple_value = .undefined },
@@ -4977,7 +4941,7 @@ pub const static_keys = [_]Key{
     .{ .simple_value = .null },
     .{ .simple_value = .true },
     .{ .simple_value = .false },
-    .{ .simple_value = .empty_struct },
+    .{ .simple_value = .empty_tuple },
     .{ .simple_value = .generic_poison },
 };
 
@@ -5057,20 +5021,16 @@ pub const Tag = enum(u8) {
     type_opaque,
     /// A non-packed struct type.
     /// data is 0 or extra index of `TypeStruct`.
-    /// data == 0 represents `@TypeOf(.{})`.
     type_struct,
-    /// An AnonStructType which stores types, names, and values for fields.
-    /// data is extra index of `TypeStructAnon`.
-    type_struct_anon,
     /// 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,
-    /// An AnonStructType which has only types and values for fields.
-    /// data is extra index of `TypeStructAnon`.
-    type_tuple_anon,
+    /// A `TupleType`.
+    /// data is extra index of `TypeTuple`.
+    type_tuple,
     /// A union type.
     /// `data` is extra index of `TypeUnion`.
     type_union,
@@ -5285,9 +5245,8 @@ pub const Tag = enum(u8) {
             .simple_type => unreachable,
             .type_opaque => TypeOpaque,
             .type_struct => TypeStruct,
-            .type_struct_anon => TypeStructAnon,
             .type_struct_packed, .type_struct_packed_inits => TypeStructPacked,
-            .type_tuple_anon => TypeStructAnon,
+            .type_tuple => TypeTuple,
             .type_union => TypeUnion,
             .type_function => TypeFunction,
 
@@ -5359,7 +5318,8 @@ pub const Tag = enum(u8) {
             is_const: bool,
             is_threadlocal: bool,
             is_weak_linkage: bool,
-            _: u29 = 0,
+            is_dll_import: bool,
+            _: u28 = 0,
         };
     };
 
@@ -5433,7 +5393,7 @@ pub const Tag = enum(u8) {
         flags: Flags,
 
         pub const Flags = packed struct(u32) {
-            cc: std.builtin.CallingConvention,
+            cc: PackedCallingConvention,
             is_var_args: bool,
             is_generic: bool,
             has_comptime_bits: bool,
@@ -5442,7 +5402,7 @@ pub const Tag = enum(u8) {
             cc_is_generic: bool,
             section_is_generic: bool,
             addrspace_is_generic: bool,
-            _: u16 = 0,
+            _: u6 = 0,
         };
     };
 
@@ -5531,18 +5491,15 @@ pub const Tag = enum(u8) {
     /// 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 not is_tuple:
-    ///    names_map: MapIndex,
-    ///    name: NullTerminatedString // for each field in declared order
-    /// 5. if any_default_inits:
+    /// 4. if any_default_inits:
     ///    init: Index // for each field in declared order
-    /// 6. if any_aligned_fields:
+    /// 5. if any_aligned_fields:
     ///    align: Alignment // for each field in declared order
-    /// 7. if any_comptime_fields:
+    /// 6. if any_comptime_fields:
     ///    field_is_comptime_bits: u32 // minimal number of u32s needed, LSB is field 0
-    /// 8. if not is_extern:
+    /// 7. if not is_extern:
     ///    field_index: RuntimeOrder // for each field in runtime order
-    /// 9. field_offset: u32 // for each field in declared order, undef until layout_resolved
+    /// 8. field_offset: u32 // for each field in declared order, undef until layout_resolved
     pub const TypeStruct = struct {
         name: NullTerminatedString,
         cau: Cau.Index,
@@ -5557,7 +5514,6 @@ pub const Tag = enum(u8) {
             is_extern: bool = false,
             known_non_opv: bool = false,
             requires_comptime: RequiresComptime = @enumFromInt(0),
-            is_tuple: bool = false,
             assumed_runtime_bits: bool = false,
             assumed_pointer_aligned: bool = false,
             any_comptime_fields: bool = false,
@@ -5582,7 +5538,7 @@ pub const Tag = enum(u8) {
             // which `layout_resolved` does not ensure.
             fully_resolved: bool = false,
             is_reified: bool = false,
-            _: u7 = 0,
+            _: u8 = 0,
         };
     };
 
@@ -5607,12 +5563,11 @@ pub const FuncAnalysis = packed struct(u32) {
     branch_hint: std.builtin.BranchHint,
     is_noinline: bool,
     calls_or_awaits_errorable_fn: bool,
-    stack_alignment: Alignment,
     /// True if this function has an inferred error set.
     inferred_error_set: bool,
     disable_instrumentation: bool,
 
-    _: u17 = 0,
+    _: u23 = 0,
 
     pub const State = enum(u2) {
         /// The runtime function has never been referenced.
@@ -5645,9 +5600,7 @@ pub const Repeated = struct {
 /// Trailing:
 /// 0. type: Index for each fields_len
 /// 1. value: Index for each fields_len
-/// 2. name: NullTerminatedString for each fields_len
-/// The set of field names is omitted when the `Tag` is `type_tuple_anon`.
-pub const TypeStructAnon = struct {
+pub const TypeTuple = struct {
     fields_len: u32,
 };
 
@@ -5694,8 +5647,8 @@ 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 literal: `.{}`
-    empty_struct = @intFromEnum(Index.empty_struct),
+    /// 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),
@@ -6252,11 +6205,10 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void {
     // This inserts all the statically-known values into the intern pool in the
     // order expected.
     for (&static_keys, 0..) |key, key_index| switch (@as(Index, @enumFromInt(key_index))) {
-        .empty_struct_type => assert(try ip.getAnonStructType(gpa, .main, .{
+        .empty_tuple_type => assert(try ip.getTupleType(gpa, .main, .{
             .types = &.{},
-            .names = &.{},
             .values = &.{},
-        }) == .empty_struct_type),
+        }) == .empty_tuple_type),
         else => |expected_index| assert(try ip.get(gpa, .main, key) == expected_index),
     };
 
@@ -6268,6 +6220,7 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void {
 }
 
 pub fn deinit(ip: *InternPool, gpa: Allocator) void {
+    ip.file_deps.deinit(gpa);
     ip.src_hash_deps.deinit(gpa);
     ip.nav_val_deps.deinit(gpa);
     ip.interned_deps.deinit(gpa);
@@ -6397,7 +6350,6 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         } },
 
         .type_struct => .{ .struct_type = ns: {
-            if (data == 0) break :ns .empty_struct;
             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").?]);
@@ -6442,8 +6394,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 } else CaptureValue.Slice.empty },
             } };
         } },
-        .type_struct_anon => .{ .anon_struct_type = extraTypeStructAnon(unwrapped_index.tid, unwrapped_index.getExtra(ip), data) },
-        .type_tuple_anon => .{ .anon_struct_type = extraTypeTupleAnon(unwrapped_index.tid, unwrapped_index.getExtra(ip), data) },
+        .type_tuple => .{ .tuple_type = extraTypeTuple(unwrapped_index.tid, unwrapped_index.getExtra(ip), data) },
         .type_union => .{ .union_type = ns: {
             const extra_list = unwrapped_index.getExtra(ip);
             const extra = extraDataTrail(extra_list, Tag.TypeUnion, data);
@@ -6703,6 +6654,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 .is_const = extra.flags.is_const,
                 .is_threadlocal = extra.flags.is_threadlocal,
                 .is_weak_linkage = extra.flags.is_weak_linkage,
+                .is_dll_import = extra.flags.is_dll_import,
                 .alignment = nav.status.resolved.alignment,
                 .@"addrspace" = nav.status.resolved.@"addrspace",
                 .zir_index = extra.zir_index,
@@ -6748,10 +6700,10 @@ 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_anon, .type_tuple_anon => {
-                    const type_struct_anon = extraDataTrail(ty_extra, TypeStructAnon, ty_item.data);
-                    const fields_len = type_struct_anon.data.fields_len;
-                    const values = ty_extra.view().items(.@"0")[type_struct_anon.end + fields_len ..][0..fields_len];
+                .type_tuple => {
+                    const type_tuple = extraDataTrail(ty_extra, TypeTuple, ty_item.data);
+                    const fields_len = type_tuple.data.fields_len;
+                    const values = ty_extra.view().items(.@"0")[type_tuple.end + fields_len ..][0..fields_len];
                     return .{ .aggregate = .{
                         .ty = ty,
                         .storage = .{ .elems = @ptrCast(values) },
@@ -6834,47 +6786,20 @@ fn extraErrorSet(tid: Zcu.PerThread.Id, extra: Local.Extra, extra_index: u32) Ke
     };
 }
 
-fn extraTypeStructAnon(tid: Zcu.PerThread.Id, extra: Local.Extra, extra_index: u32) Key.AnonStructType {
-    const type_struct_anon = extraDataTrail(extra, TypeStructAnon, extra_index);
-    const fields_len = type_struct_anon.data.fields_len;
-    return .{
-        .types = .{
-            .tid = tid,
-            .start = type_struct_anon.end,
-            .len = fields_len,
-        },
-        .values = .{
-            .tid = tid,
-            .start = type_struct_anon.end + fields_len,
-            .len = fields_len,
-        },
-        .names = .{
-            .tid = tid,
-            .start = type_struct_anon.end + fields_len + fields_len,
-            .len = fields_len,
-        },
-    };
-}
-
-fn extraTypeTupleAnon(tid: Zcu.PerThread.Id, extra: Local.Extra, extra_index: u32) Key.AnonStructType {
-    const type_struct_anon = extraDataTrail(extra, TypeStructAnon, extra_index);
-    const fields_len = type_struct_anon.data.fields_len;
+fn extraTypeTuple(tid: Zcu.PerThread.Id, extra: Local.Extra, extra_index: u32) Key.TupleType {
+    const type_tuple = extraDataTrail(extra, TypeTuple, extra_index);
+    const fields_len = type_tuple.data.fields_len;
     return .{
         .types = .{
             .tid = tid,
-            .start = type_struct_anon.end,
+            .start = type_tuple.end,
             .len = fields_len,
         },
         .values = .{
             .tid = tid,
-            .start = type_struct_anon.end + fields_len,
+            .start = type_tuple.end + fields_len,
             .len = fields_len,
         },
-        .names = .{
-            .tid = tid,
-            .start = 0,
-            .len = 0,
-        },
     };
 }
 
@@ -6900,7 +6825,7 @@ fn extraFuncType(tid: Zcu.PerThread.Id, extra: Local.Extra, extra_index: u32) Ke
         .return_type = type_function.data.return_type,
         .comptime_bits = comptime_bits,
         .noalias_bits = noalias_bits,
-        .cc = type_function.data.flags.cc,
+        .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,
         .cc_is_generic = type_function.data.flags.cc_is_generic,
@@ -7345,7 +7270,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All
         },
 
         .struct_type => unreachable, // use getStructType() instead
-        .anon_struct_type => unreachable, // use getAnonStructType() instead
+        .tuple_type => unreachable, // use getTupleType() instead
         .union_type => unreachable, // use getUnionType() instead
         .opaque_type => unreachable, // use getOpaqueType() instead
 
@@ -7369,6 +7294,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All
                         .is_const = false,
                         .is_threadlocal = variable.is_threadlocal,
                         .is_weak_linkage = variable.is_weak_linkage,
+                        .is_dll_import = false,
                     },
                 }),
             });
@@ -7452,9 +7378,9 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All
                         .field => {
                             assert(base_ptr_type.flags.size == .One);
                             switch (ip.indexToKey(base_ptr_type.child)) {
-                                .anon_struct_type => |anon_struct_type| {
+                                .tuple_type => |tuple_type| {
                                     assert(ptr.base_addr == .field);
-                                    assert(base_index.index < anon_struct_type.types.len);
+                                    assert(base_index.index < tuple_type.types.len);
                                 },
                                 .struct_type => {
                                     assert(ptr.base_addr == .field);
@@ -7791,12 +7717,12 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All
             const child = switch (ty_key) {
                 .array_type => |array_type| array_type.child,
                 .vector_type => |vector_type| vector_type.child,
-                .anon_struct_type, .struct_type => .none,
+                .tuple_type, .struct_type => .none,
                 else => unreachable,
             };
             const sentinel = switch (ty_key) {
                 .array_type => |array_type| array_type.sentinel,
-                .vector_type, .anon_struct_type, .struct_type => .none,
+                .vector_type, .tuple_type, .struct_type => .none,
                 else => unreachable,
             };
             const len_including_sentinel = len + @intFromBool(sentinel != .none);
@@ -7828,8 +7754,8 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All
                         assert(ip.typeOf(elem) == field_ty);
                     }
                 },
-                .anon_struct_type => |anon_struct_type| {
-                    for (aggregate.storage.values(), anon_struct_type.types.get(ip)) |elem, ty| {
+                .tuple_type => |tuple_type| {
+                    for (aggregate.storage.values(), tuple_type.types.get(ip)) |elem, ty| {
                         assert(ip.typeOf(elem) == ty);
                     }
                 },
@@ -7845,9 +7771,9 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All
             }
 
             switch (ty_key) {
-                .anon_struct_type => |anon_struct_type| opv: {
+                .tuple_type => |tuple_type| opv: {
                     switch (aggregate.storage) {
-                        .bytes => |bytes| for (anon_struct_type.values.get(ip), bytes.at(0, ip)..) |value, byte| {
+                        .bytes => |bytes| for (tuple_type.values.get(ip), bytes.at(0, ip)..) |value, byte| {
                             if (value == .none) break :opv;
                             switch (ip.indexToKey(value)) {
                                 .undef => break :opv,
@@ -7860,10 +7786,10 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All
                         },
                         .elems => |elems| if (!std.mem.eql(
                             Index,
-                            anon_struct_type.values.get(ip),
+                            tuple_type.values.get(ip),
                             elems,
                         )) break :opv,
-                        .repeated_elem => |elem| for (anon_struct_type.values.get(ip)) |value| {
+                        .repeated_elem => |elem| for (tuple_type.values.get(ip)) |value| {
                             if (value != elem) break :opv;
                         },
                     }
@@ -8227,7 +8153,6 @@ pub const StructTypeInit = struct {
     fields_len: u32,
     known_non_opv: bool,
     requires_comptime: RequiresComptime,
-    is_tuple: bool,
     any_comptime_fields: bool,
     any_default_inits: bool,
     inits_resolved: bool,
@@ -8387,7 +8312,6 @@ pub fn getStructType(
             .is_extern = is_extern,
             .known_non_opv = ini.known_non_opv,
             .requires_comptime = ini.requires_comptime,
-            .is_tuple = ini.is_tuple,
             .assumed_runtime_bits = false,
             .assumed_pointer_aligned = false,
             .any_comptime_fields = ini.any_comptime_fields,
@@ -8425,10 +8349,8 @@ pub fn getStructType(
         },
     }
     extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len);
-    if (!ini.is_tuple) {
-        extra.appendAssumeCapacity(.{@intFromEnum(names_map)});
-        extra.appendNTimesAssumeCapacity(.{@intFromEnum(OptionalNullTerminatedString.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);
     }
@@ -8451,19 +8373,17 @@ pub fn getStructType(
     } };
 }
 
-pub const AnonStructTypeInit = struct {
+pub const TupleTypeInit = struct {
     types: []const Index,
-    /// This may be empty, indicating this is a tuple.
-    names: []const NullTerminatedString,
     /// These elements may be `none`, indicating runtime-known.
     values: []const Index,
 };
 
-pub fn getAnonStructType(
+pub fn getTupleType(
     ip: *InternPool,
     gpa: Allocator,
     tid: Zcu.PerThread.Id,
-    ini: AnonStructTypeInit,
+    ini: TupleTypeInit,
 ) Allocator.Error!Index {
     assert(ini.types.len == ini.values.len);
     for (ini.types) |elem| assert(elem != .none);
@@ -8477,23 +8397,17 @@ pub fn getAnonStructType(
 
     try items.ensureUnusedCapacity(1);
     try extra.ensureUnusedCapacity(
-        @typeInfo(TypeStructAnon).@"struct".fields.len + (fields_len * 3),
+        @typeInfo(TypeTuple).@"struct".fields.len + (fields_len * 3),
     );
 
-    const extra_index = addExtraAssumeCapacity(extra, TypeStructAnon{
+    const extra_index = addExtraAssumeCapacity(extra, TypeTuple{
         .fields_len = fields_len,
     });
     extra.appendSliceAssumeCapacity(.{@ptrCast(ini.types)});
     extra.appendSliceAssumeCapacity(.{@ptrCast(ini.values)});
     errdefer extra.mutate.len = prev_extra_len;
 
-    var gop = try ip.getOrPutKey(gpa, tid, .{
-        .anon_struct_type = if (ini.names.len == 0) extraTypeTupleAnon(tid, extra.list.*, extra_index) else k: {
-            assert(ini.names.len == ini.types.len);
-            extra.appendSliceAssumeCapacity(.{@ptrCast(ini.names)});
-            break :k extraTypeStructAnon(tid, extra.list.*, extra_index);
-        },
-    });
+    var gop = try ip.getOrPutKey(gpa, tid, .{ .tuple_type = extraTypeTuple(tid, extra.list.*, extra_index) });
     defer gop.deinit();
     if (gop == .existing) {
         extra.mutate.len = prev_extra_len;
@@ -8501,7 +8415,7 @@ pub fn getAnonStructType(
     }
 
     items.appendAssumeCapacity(.{
-        .tag = if (ini.names.len == 0) .type_tuple_anon else .type_struct_anon,
+        .tag = .type_tuple,
         .data = extra_index,
     });
     return gop.put();
@@ -8514,7 +8428,7 @@ pub const GetFuncTypeKey = struct {
     comptime_bits: u32 = 0,
     noalias_bits: u32 = 0,
     /// `null` means generic.
-    cc: ?std.builtin.CallingConvention = .Unspecified,
+    cc: ?std.builtin.CallingConvention = .auto,
     is_var_args: bool = false,
     is_generic: bool = false,
     is_noinline: bool = false,
@@ -8552,7 +8466,7 @@ pub fn getFuncType(
         .params_len = params_len,
         .return_type = key.return_type,
         .flags = .{
-            .cc = key.cc orelse .Unspecified,
+            .cc = .pack(key.cc orelse .auto),
             .is_var_args = key.is_var_args,
             .has_comptime_bits = key.comptime_bits != 0,
             .has_noalias_bits = key.noalias_bits != 0,
@@ -8632,6 +8546,7 @@ pub fn getExtern(
             .is_const = key.is_const,
             .is_threadlocal = key.is_threadlocal,
             .is_weak_linkage = key.is_weak_linkage,
+            .is_dll_import = key.is_dll_import,
         },
         .zir_index = key.zir_index,
         .owner_nav = owner_nav,
@@ -8684,7 +8599,6 @@ pub fn getFuncDecl(
             .branch_hint = .none,
             .is_noinline = key.is_noinline,
             .calls_or_awaits_errorable_fn = false,
-            .stack_alignment = .none,
             .inferred_error_set = false,
             .disable_instrumentation = false,
         },
@@ -8788,7 +8702,6 @@ pub fn getFuncDeclIes(
             .branch_hint = .none,
             .is_noinline = key.is_noinline,
             .calls_or_awaits_errorable_fn = false,
-            .stack_alignment = .none,
             .inferred_error_set = true,
             .disable_instrumentation = false,
         },
@@ -8806,7 +8719,7 @@ pub fn getFuncDeclIes(
         .params_len = params_len,
         .return_type = error_union_type,
         .flags = .{
-            .cc = key.cc orelse .Unspecified,
+            .cc = .pack(key.cc orelse .auto),
             .is_var_args = key.is_var_args,
             .has_comptime_bits = key.comptime_bits != 0,
             .has_noalias_bits = key.noalias_bits != 0,
@@ -8980,7 +8893,6 @@ pub fn getFuncInstance(
             .branch_hint = .none,
             .is_noinline = arg.is_noinline,
             .calls_or_awaits_errorable_fn = false,
-            .stack_alignment = .none,
             .inferred_error_set = false,
             .disable_instrumentation = false,
         },
@@ -9080,7 +8992,6 @@ pub fn getFuncInstanceIes(
             .branch_hint = .none,
             .is_noinline = arg.is_noinline,
             .calls_or_awaits_errorable_fn = false,
-            .stack_alignment = .none,
             .inferred_error_set = true,
             .disable_instrumentation = false,
         },
@@ -9098,7 +9009,7 @@ pub fn getFuncInstanceIes(
         .params_len = params_len,
         .return_type = error_union_type,
         .flags = .{
-            .cc = arg.cc,
+            .cc = .pack(arg.cc),
             .is_var_args = false,
             .has_comptime_bits = false,
             .has_noalias_bits = arg.noalias_bits != 0,
@@ -10167,12 +10078,12 @@ pub fn getCoerced(
             direct: {
                 const old_ty_child = switch (ip.indexToKey(old_ty)) {
                     inline .array_type, .vector_type => |seq_type| seq_type.child,
-                    .anon_struct_type, .struct_type => break :direct,
+                    .tuple_type, .struct_type => break :direct,
                     else => unreachable,
                 };
                 const new_ty_child = switch (ip.indexToKey(new_ty)) {
                     inline .array_type, .vector_type => |seq_type| seq_type.child,
-                    .anon_struct_type, .struct_type => break :direct,
+                    .tuple_type, .struct_type => break :direct,
                     else => unreachable,
                 };
                 if (old_ty_child != new_ty_child) break :direct;
@@ -10221,7 +10132,7 @@ pub fn getCoerced(
             for (agg_elems, 0..) |*elem, i| {
                 const new_elem_ty = switch (ip.indexToKey(new_ty)) {
                     inline .array_type, .vector_type => |seq_type| seq_type.child,
-                    .anon_struct_type => |anon_struct_type| anon_struct_type.types.get(ip)[i],
+                    .tuple_type => |tuple_type| tuple_type.types.get(ip)[i],
                     .struct_type => ip.loadStructType(new_ty).field_types.get(ip)[i],
                     else => unreachable,
                 };
@@ -10411,7 +10322,7 @@ pub fn isErrorUnionType(ip: *const InternPool, ty: Index) bool {
 
 pub fn isAggregateType(ip: *const InternPool, ty: Index) bool {
     return switch (ip.indexToKey(ty)) {
-        .array_type, .vector_type, .anon_struct_type, .struct_type => true,
+        .array_type, .vector_type, .tuple_type, .struct_type => true,
         else => false,
     };
 }
@@ -10535,7 +10446,6 @@ fn dumpStatsFallible(ip: *const InternPool, arena: Allocator) anyerror!void {
                     break :b @sizeOf(u32) * ints;
                 },
                 .type_struct => b: {
-                    if (data == 0) break :b 0;
                     const extra = extraDataTrail(extra_list, Tag.TypeStruct, data);
                     const info = extra.data;
                     var ints: usize = @typeInfo(Tag.TypeStruct).@"struct".fields.len;
@@ -10544,10 +10454,8 @@ fn dumpStatsFallible(ip: *const InternPool, arena: Allocator) anyerror!void {
                         ints += 1 + captures_len;
                     }
                     ints += info.fields_len; // types
-                    if (!info.flags.is_tuple) {
-                        ints += 1; // names_map
-                        ints += info.fields_len; // names
-                    }
+                    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)
@@ -10559,10 +10467,6 @@ fn dumpStatsFallible(ip: *const InternPool, arena: Allocator) anyerror!void {
                     ints += info.fields_len; // offsets
                     break :b @sizeOf(u32) * ints;
                 },
-                .type_struct_anon => b: {
-                    const info = extraData(extra_list, TypeStructAnon, data);
-                    break :b @sizeOf(TypeStructAnon) + (@sizeOf(u32) * 3 * info.fields_len);
-                },
                 .type_struct_packed => b: {
                     const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, data);
                     const captures_len = if (extra.data.flags.any_captures)
@@ -10583,9 +10487,9 @@ fn dumpStatsFallible(ip: *const InternPool, arena: Allocator) anyerror!void {
                         @intFromBool(extra.data.flags.any_captures) + captures_len +
                         extra.data.fields_len * 3);
                 },
-                .type_tuple_anon => b: {
-                    const info = extraData(extra_list, TypeStructAnon, data);
-                    break :b @sizeOf(TypeStructAnon) + (@sizeOf(u32) * 2 * info.fields_len);
+                .type_tuple => b: {
+                    const info = extraData(extra_list, TypeTuple, data);
+                    break :b @sizeOf(TypeTuple) + (@sizeOf(u32) * 2 * info.fields_len);
                 },
 
                 .type_union => b: {
@@ -10746,10 +10650,9 @@ fn dumpAllFallible(ip: *const InternPool) anyerror!void {
                 .type_enum_auto,
                 .type_opaque,
                 .type_struct,
-                .type_struct_anon,
                 .type_struct_packed,
                 .type_struct_packed_inits,
-                .type_tuple_anon,
+                .type_tuple,
                 .type_union,
                 .type_function,
                 .undef,
@@ -11382,7 +11285,7 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
         .anyerror_void_error_union_type,
         .adhoc_inferred_error_set_type,
         .generic_poison_type,
-        .empty_struct_type,
+        .empty_tuple_type,
         => .type_type,
 
         .undef => .undefined_type,
@@ -11393,7 +11296,7 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
         .unreachable_value => .noreturn_type,
         .null_value => .null_type,
         .bool_true, .bool_false => .bool_type,
-        .empty_struct => .empty_struct_type,
+        .empty_tuple => .empty_tuple_type,
         .generic_poison => .generic_poison_type,
 
         // This optimization on tags is needed so that indexToKey can call
@@ -11422,10 +11325,9 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
                 .type_enum_nonexhaustive,
                 .type_opaque,
                 .type_struct,
-                .type_struct_anon,
                 .type_struct_packed,
                 .type_struct_packed_inits,
-                .type_tuple_anon,
+                .type_tuple,
                 .type_union,
                 .type_function,
                 => .type_type,
@@ -11519,7 +11421,7 @@ pub fn toEnum(ip: *const InternPool, comptime E: type, i: Index) E {
 pub fn aggregateTypeLen(ip: *const InternPool, ty: Index) u64 {
     return switch (ip.indexToKey(ty)) {
         .struct_type => ip.loadStructType(ty).field_types.len,
-        .anon_struct_type => |anon_struct_type| anon_struct_type.types.len,
+        .tuple_type => |tuple_type| tuple_type.types.len,
         .array_type => |array_type| array_type.len,
         .vector_type => |vector_type| vector_type.len,
         else => unreachable,
@@ -11529,7 +11431,7 @@ pub fn aggregateTypeLen(ip: *const InternPool, ty: Index) u64 {
 pub fn aggregateTypeLenIncludingSentinel(ip: *const InternPool, ty: Index) u64 {
     return switch (ip.indexToKey(ty)) {
         .struct_type => ip.loadStructType(ty).field_types.len,
-        .anon_struct_type => |anon_struct_type| anon_struct_type.types.len,
+        .tuple_type => |tuple_type| tuple_type.types.len,
         .array_type => |array_type| array_type.lenIncludingSentinel(),
         .vector_type => |vector_type| vector_type.len,
         else => unreachable,
@@ -11694,7 +11596,7 @@ pub fn zigTypeTagOrPoison(ip: *const InternPool, index: Index) error{GenericPois
 
         .optional_noreturn_type => .optional,
         .anyerror_void_error_union_type => .error_union,
-        .empty_struct_type => .@"struct",
+        .empty_tuple_type => .@"struct",
 
         .generic_poison_type => return error.GenericPoison,
 
@@ -11713,7 +11615,7 @@ pub fn zigTypeTagOrPoison(ip: *const InternPool, index: Index) error{GenericPois
         .null_value => unreachable,
         .bool_true => unreachable,
         .bool_false => unreachable,
-        .empty_struct => unreachable,
+        .empty_tuple => unreachable,
         .generic_poison => unreachable,
 
         _ => switch (index.unwrap(ip).getTag(ip)) {
@@ -11754,10 +11656,9 @@ pub fn zigTypeTagOrPoison(ip: *const InternPool, index: Index) error{GenericPois
             .type_opaque => .@"opaque",
 
             .type_struct,
-            .type_struct_anon,
             .type_struct_packed,
             .type_struct_packed_inits,
-            .type_tuple_anon,
+            .type_tuple,
             => .@"struct",
 
             .type_union => .@"union",
@@ -11859,21 +11760,6 @@ pub fn funcAnalysisUnordered(ip: *const InternPool, func: Index) FuncAnalysis {
     return @atomicLoad(FuncAnalysis, @constCast(ip).funcAnalysisPtr(func), .unordered);
 }
 
-pub fn funcMaxStackAlignment(ip: *InternPool, func: Index, new_stack_alignment: Alignment) void {
-    const unwrapped_func = func.unwrap(ip);
-    const extra_mutex = &ip.getLocal(unwrapped_func.tid).mutate.extra.mutex;
-    extra_mutex.lock();
-    defer extra_mutex.unlock();
-
-    const analysis_ptr = ip.funcAnalysisPtr(func);
-    var analysis = analysis_ptr.*;
-    analysis.stack_alignment = switch (analysis.stack_alignment) {
-        .none => new_stack_alignment,
-        else => |old_stack_alignment| old_stack_alignment.maxStrict(new_stack_alignment),
-    };
-    @atomicStore(FuncAnalysis, analysis_ptr, analysis, .release);
-}
-
 pub fn funcSetCallsOrAwaitsErrorableFn(ip: *InternPool, func: Index) void {
     const unwrapped_func = func.unwrap(ip);
     const extra_mutex = &ip.getLocal(unwrapped_func.tid).mutate.extra.mutex;
@@ -12014,14 +11900,6 @@ pub fn unwrapCoercedFunc(ip: *const InternPool, index: Index) Index {
     };
 }
 
-pub fn anonStructFieldTypes(ip: *const InternPool, i: Index) []const Index {
-    return ip.indexToKey(i).anon_struct_type.types;
-}
-
-pub fn anonStructFieldsLen(ip: *const InternPool, i: Index) u32 {
-    return @intCast(ip.indexToKey(i).anon_struct_type.types.len);
-}
-
 /// Returns the already-existing field with the same name, if any.
 pub fn addFieldName(
     ip: *InternPool,
@@ -12212,3 +12090,81 @@ pub fn getErrorValue(
 pub fn getErrorValueIfExists(ip: *const InternPool, name: NullTerminatedString) ?Zcu.ErrorInt {
     return @intFromEnum(ip.global_error_set.getErrorValueIfExists(name) orelse return null);
 }
+
+const PackedCallingConvention = packed struct(u18) {
+    tag: std.builtin.CallingConvention.Tag,
+    /// May be ignored depending on `tag`.
+    incoming_stack_alignment: Alignment,
+    /// Interpretation depends on `tag`.
+    extra: u4,
+
+    fn pack(cc: std.builtin.CallingConvention) PackedCallingConvention {
+        return switch (cc) {
+            inline else => |pl, tag| switch (@TypeOf(pl)) {
+                void => .{
+                    .tag = tag,
+                    .incoming_stack_alignment = .none, // unused
+                    .extra = 0, // unused
+                },
+                std.builtin.CallingConvention.CommonOptions => .{
+                    .tag = tag,
+                    .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0),
+                    .extra = 0, // unused
+                },
+                std.builtin.CallingConvention.X86RegparmOptions => .{
+                    .tag = tag,
+                    .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0),
+                    .extra = pl.register_params,
+                },
+                std.builtin.CallingConvention.ArmInterruptOptions => .{
+                    .tag = tag,
+                    .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0),
+                    .extra = @intFromEnum(pl.type),
+                },
+                std.builtin.CallingConvention.MipsInterruptOptions => .{
+                    .tag = tag,
+                    .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0),
+                    .extra = @intFromEnum(pl.mode),
+                },
+                std.builtin.CallingConvention.RiscvInterruptOptions => .{
+                    .tag = tag,
+                    .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0),
+                    .extra = @intFromEnum(pl.mode),
+                },
+                else => comptime unreachable,
+            },
+        };
+    }
+
+    fn unpack(cc: PackedCallingConvention) std.builtin.CallingConvention {
+        return switch (cc.tag) {
+            inline else => |tag| @unionInit(
+                std.builtin.CallingConvention,
+                @tagName(tag),
+                switch (@FieldType(std.builtin.CallingConvention, @tagName(tag))) {
+                    void => {},
+                    std.builtin.CallingConvention.CommonOptions => .{
+                        .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(),
+                    },
+                    std.builtin.CallingConvention.X86RegparmOptions => .{
+                        .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(),
+                        .register_params = @intCast(cc.extra),
+                    },
+                    std.builtin.CallingConvention.ArmInterruptOptions => .{
+                        .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(),
+                        .type = @enumFromInt(cc.extra),
+                    },
+                    std.builtin.CallingConvention.MipsInterruptOptions => .{
+                        .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(),
+                        .mode = @enumFromInt(cc.extra),
+                    },
+                    std.builtin.CallingConvention.RiscvInterruptOptions => .{
+                        .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(),
+                        .mode = @enumFromInt(cc.extra),
+                    },
+                    else => comptime unreachable,
+                },
+            ),
+        };
+    }
+};
diff --git a/zig/src/Package/Fetch.zig b/zig/src/Package/Fetch.zig
index 6e7469425b..6017a234e4 100644
--- a/zig/src/Package/Fetch.zig
+++ b/zig/src/Package/Fetch.zig
@@ -662,6 +662,9 @@ fn queueJobsForDeps(f: *Fetch) RunError!void {
         // * path-based location is used without a hash.
         //   - Hash is added to the table based on the path alone before
         //     calling run(); no need to add it again.
+        //
+        // If we add a dep as lazy and then later try to add the same dep as eager,
+        // eagerness takes precedence and the existing entry is updated.
 
         for (dep_names, deps) |dep_name, dep| {
             const new_fetch = &new_fetches[new_fetch_index];
@@ -673,7 +676,12 @@ fn queueJobsForDeps(f: *Fetch) RunError!void {
                         const digest_len = @typeInfo(Manifest.MultiHashHexDigest).array.len;
                         const multihash_digest = h[0..digest_len].*;
                         const gop = f.job_queue.table.getOrPutAssumeCapacity(multihash_digest);
-                        if (gop.found_existing) continue;
+                        if (gop.found_existing) {
+                            if (!dep.lazy) {
+                                gop.value_ptr.*.lazy_status = .eager;
+                            }
+                            continue;
+                        }
                         gop.value_ptr.* = new_fetch;
                         break :h multihash_digest;
                     },
@@ -684,7 +692,12 @@ fn queueJobsForDeps(f: *Fetch) RunError!void {
                     const new_root = try f.package_root.resolvePosix(parent_arena, rel_path);
                     const multihash_digest = relativePathDigest(new_root, cache_root);
                     const gop = f.job_queue.table.getOrPutAssumeCapacity(multihash_digest);
-                    if (gop.found_existing) continue;
+                    if (gop.found_existing) {
+                        if (!dep.lazy) {
+                            gop.value_ptr.*.lazy_status = .eager;
+                        }
+                        continue;
+                    }
                     gop.value_ptr.* = new_fetch;
                     break :l .{ .relative_path = new_root };
                 },
diff --git a/zig/src/Package/Module.zig b/zig/src/Package/Module.zig
index 02d9921016..0e777145d9 100644
--- a/zig/src/Package/Module.zig
+++ b/zig/src/Package/Module.zig
@@ -31,6 +31,7 @@ unwind_tables: bool,
 cc_argv: []const []const u8,
 /// (SPIR-V) whether to generate a structured control flow graph or not
 structured_cfg: bool,
+no_builtin: bool,
 
 /// If the module is an `@import("builtin")` module, this is the `File` that
 /// is preallocated for it. Otherwise this field is null.
@@ -95,6 +96,7 @@ pub const CreateOptions = struct {
         sanitize_thread: ?bool = null,
         fuzz: ?bool = null,
         structured_cfg: ?bool = null,
+        no_builtin: ?bool = null,
     };
 };
 
@@ -298,6 +300,13 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {
         };
     };
 
+    const no_builtin = b: {
+        if (options.inherited.no_builtin) |x| break :b x;
+        if (options.parent) |p| break :b p.no_builtin;
+
+        break :b target.cpu.arch.isBpf();
+    };
+
     const llvm_cpu_features: ?[*:0]const u8 = b: {
         if (resolved_target.llvm_cpu_features) |x| break :b x;
         if (!options.global.use_llvm) break :b null;
@@ -350,6 +359,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {
         .unwind_tables = unwind_tables,
         .cc_argv = options.cc_argv,
         .structured_cfg = structured_cfg,
+        .no_builtin = no_builtin,
         .builtin_file = null,
     };
 
@@ -442,6 +452,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {
             .unwind_tables = unwind_tables,
             .cc_argv = &.{},
             .structured_cfg = structured_cfg,
+            .no_builtin = no_builtin,
             .builtin_file = new_file,
         };
         new_file.* = .{
@@ -454,6 +465,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {
             .tree = undefined,
             .zir = undefined,
             .status = .never_loaded,
+            .prev_status = .never_loaded,
             .mod = new,
         };
         break :b new;
@@ -501,6 +513,7 @@ pub fn createLimited(gpa: Allocator, options: LimitedOptions) Allocator.Error!*P
         .unwind_tables = undefined,
         .cc_argv = undefined,
         .structured_cfg = undefined,
+        .no_builtin = undefined,
         .builtin_file = null,
     };
     return mod;
diff --git a/zig/src/Sema.zig b/zig/src/Sema.zig
index 1de0d73808..b99852fb0a 100644
--- a/zig/src/Sema.zig
+++ b/zig/src/Sema.zig
@@ -26,7 +26,7 @@ owner: AnalUnit,
 /// in the case of an inline or comptime function call.
 /// This could be `none`, a `func_decl`, or a `func_instance`.
 func_index: InternPool.Index,
-/// Whether the type of func_index has a calling convention of `.Naked`.
+/// Whether the type of func_index has a calling convention of `.naked`.
 func_is_naked: bool,
 /// Used to restore the error return trace when returning a non-error from a function.
 error_return_trace_index_on_fn_entry: Air.Inst.Ref = .none,
@@ -844,6 +844,7 @@ pub const Block = struct {
 
     fn trackZir(block: *Block, inst: Zir.Inst.Index) Allocator.Error!InternPool.TrackedInst.Index {
         const pt = block.sema.pt;
+        block.sema.code.assertTrackable(inst);
         return pt.zcu.intern_pool.trackZir(pt.zcu.gpa, pt.tid, .{
             .file = block.getFileScopeIndex(pt.zcu),
             .inst = inst,
@@ -876,6 +877,7 @@ const InferredAlloc = struct {
 
 const NeededComptimeReason = struct {
     needed_comptime_reason: []const u8,
+    value_comptime_reason: ?[]const u8 = null,
     block_comptime_reason: ?*const Block.ComptimeReason = null,
 };
 
@@ -1042,7 +1044,7 @@ fn analyzeBodyInner(
             }, inst });
         }
 
-        const air_inst: Air.Inst.Ref = switch (tags[@intFromEnum(inst)]) {
+        const air_inst: Air.Inst.Ref = inst: switch (tags[@intFromEnum(inst)]) {
             // zig fmt: off
             .alloc                        => try sema.zirAlloc(block, inst),
             .alloc_inferred               => try sema.zirAllocInferred(block, true),
@@ -1276,6 +1278,7 @@ fn analyzeBodyInner(
                     .enum_decl          => try sema.zirEnumDecl(          block, extended, inst),
                     .union_decl         => try sema.zirUnionDecl(         block, extended, inst),
                     .opaque_decl        => try sema.zirOpaqueDecl(        block, extended, inst),
+                    .tuple_decl         => try sema.zirTupleDecl(         block, extended),
                     .this               => try sema.zirThis(              block, extended),
                     .ret_addr           => try sema.zirRetAddr(           block, extended),
                     .builtin_src        => try sema.zirBuiltinSrc(        block, extended),
@@ -1326,11 +1329,6 @@ fn analyzeBodyInner(
                         i += 1;
                         continue;
                     },
-                    .set_align_stack => {
-                        try sema.zirSetAlignStack(block, extended);
-                        i += 1;
-                        continue;
-                    },
                     .breakpoint => {
                         if (!block.is_comptime) {
                             _ = try block.addNoOp(.breakpoint);
@@ -1355,7 +1353,7 @@ fn analyzeBodyInner(
                     },
                     .value_placeholder => unreachable, // never appears in a body
                     .field_parent_ptr => try sema.zirFieldParentPtr(block, extended),
-                    .builtin_value => try sema.zirBuiltinValue(extended),
+                    .builtin_value => try sema.zirBuiltinValue(block, extended),
                     .inplace_arith_result_ty => try sema.zirInplaceArithResultTy(extended),
                 };
             },
@@ -1595,56 +1593,19 @@ fn analyzeBodyInner(
                 try sema.zirSwitchContinue(block, inst);
                 break;
             },
-            .loop => blk: {
-                if (!block.is_comptime) break :blk try sema.zirLoop(block, inst);
-                // Same as `block_inline`. TODO https://github.com/ziglang/zig/issues/8220
-                const inst_data = datas[@intFromEnum(inst)].pl_node;
-                const extra = sema.code.extraData(Zir.Inst.Block, inst_data.payload_index);
-                const inline_body = sema.code.bodySlice(extra.end, extra.data.body_len);
-
-                // Create a temporary child block so that this loop is properly
-                // labeled for any .restore_err_ret_index instructions
-                var child_block = block.makeSubBlock();
-
-                var label: Block.Label = .{
-                    .zir_block = inst,
-                    .merges = undefined,
-                };
-                child_block.label = &label;
-
-                // Write these instructions directly into the parent block
-                child_block.instructions = block.instructions;
-                defer block.instructions = child_block.instructions;
-
-                const result = try sema.analyzeInlineBody(&child_block, inline_body, inst) orelse break;
-                break :blk result;
-            },
-            .block, .block_comptime => blk: {
-                if (!block.is_comptime) {
-                    break :blk try sema.zirBlock(block, inst, tags[@intFromEnum(inst)] == .block_comptime);
-                }
-                // Same as `block_inline`. TODO https://github.com/ziglang/zig/issues/8220
-                const inst_data = datas[@intFromEnum(inst)].pl_node;
-                const extra = sema.code.extraData(Zir.Inst.Block, inst_data.payload_index);
-                const inline_body = sema.code.bodySlice(extra.end, extra.data.body_len);
 
-                // Create a temporary child block so that this block is properly
-                // labeled for any .restore_err_ret_index instructions
-                var child_block = block.makeSubBlock();
+            .loop => if (block.is_comptime) {
+                continue :inst .block_inline;
+            } else try sema.zirLoop(block, inst),
 
-                var label: Block.Label = .{
-                    .zir_block = inst,
-                    .merges = undefined,
-                };
-                child_block.label = &label;
+            .block => if (block.is_comptime) {
+                continue :inst .block_inline;
+            } else try sema.zirBlock(block, inst, false),
 
-                // Write these instructions directly into the parent block
-                child_block.instructions = block.instructions;
-                defer block.instructions = child_block.instructions;
+            .block_comptime => if (block.is_comptime) {
+                continue :inst .block_inline;
+            } else try sema.zirBlock(block, inst, true),
 
-                const result = try sema.analyzeInlineBody(&child_block, inline_body, inst) orelse break;
-                break :blk result;
-            },
             .block_inline => blk: {
                 // Directly analyze the block body without introducing a new block.
                 // However, in the case of a corresponding break_inline which reaches
@@ -1753,32 +1714,13 @@ fn analyzeBodyInner(
                     return error.ComptimeBreak;
                 }
             },
-            .condbr => blk: {
-                if (!block.is_comptime) {
-                    try sema.zirCondbr(block, inst);
-                    break;
-                }
-                // Same as condbr_inline. TODO https://github.com/ziglang/zig/issues/8220
-                const inst_data = datas[@intFromEnum(inst)].pl_node;
-                const cond_src = block.src(.{ .node_offset_if_cond = inst_data.src_node });
-                const extra = sema.code.extraData(Zir.Inst.CondBr, inst_data.payload_index);
-                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 cond = try sema.resolveInstConst(block, cond_src, extra.data.condition, .{
-                    .needed_comptime_reason = "condition in comptime branch must be comptime-known",
-                    .block_comptime_reason = block.comptime_reason,
-                });
-                const inline_body = if (cond.toBool()) then_body else else_body;
-
-                try sema.maybeErrorUnwrapCondbr(block, inline_body, extra.data.condition, cond_src);
-
-                const result = try sema.analyzeInlineBody(block, inline_body, inst) orelse break;
-                break :blk result;
+            .condbr => if (block.is_comptime) {
+                continue :inst .condbr_inline;
+            } else {
+                try sema.zirCondbr(block, inst);
+                break;
             },
-            .condbr_inline => blk: {
+            .condbr_inline => {
                 const inst_data = datas[@intFromEnum(inst)].pl_node;
                 const cond_src = block.src(.{ .node_offset_if_cond = inst_data.src_node });
                 const extra = sema.code.extraData(Zir.Inst.CondBr, inst_data.payload_index);
@@ -1787,18 +1729,20 @@ fn analyzeBodyInner(
                     extra.end + then_body.len,
                     extra.data.else_body_len,
                 );
-                const cond = try sema.resolveInstConst(block, cond_src, extra.data.condition, .{
+                const uncasted_cond = try sema.resolveInst(extra.data.condition);
+                const cond = try sema.coerce(block, Type.bool, uncasted_cond, cond_src);
+                const cond_val = try sema.resolveConstDefinedValue(block, cond_src, cond, .{
                     .needed_comptime_reason = "condition in comptime branch must be comptime-known",
                     .block_comptime_reason = block.comptime_reason,
                 });
-                const inline_body = if (cond.toBool()) then_body else else_body;
+                const inline_body = if (cond_val.toBool()) then_body else else_body;
 
                 try sema.maybeErrorUnwrapCondbr(block, inline_body, extra.data.condition, cond_src);
                 const old_runtime_index = block.runtime_index;
                 defer block.runtime_index = old_runtime_index;
 
                 const result = try sema.analyzeInlineBody(block, inline_body, inst) orelse break;
-                break :blk result;
+                break :inst result;
             },
             .@"try" => blk: {
                 if (!block.is_comptime) break :blk try sema.zirTry(block, inst);
@@ -2251,22 +2195,10 @@ fn resolveValueAllowVariables(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Val
         }
     };
     const val = Value.fromInterned(ip_index);
-    if (val.isPtrToThreadLocal(pt.zcu)) return null;
+    if (val.isPtrRuntimeValue(pt.zcu)) return null;
     return val;
 }
 
-/// Returns a compile error if the value has tag `variable`.
-fn resolveInstConst(
-    sema: *Sema,
-    block: *Block,
-    src: LazySrcLoc,
-    zir_ref: Zir.Inst.Ref,
-    reason: NeededComptimeReason,
-) CompileError!Value {
-    const air_ref = try sema.resolveInst(zir_ref);
-    return sema.resolveConstDefinedValue(block, src, air_ref, reason);
-}
-
 /// Value Tag may be `undef` or `variable`.
 pub fn resolveFinalDeclValue(
     sema: *Sema,
@@ -2277,8 +2209,14 @@ pub fn resolveFinalDeclValue(
     const zcu = sema.pt.zcu;
 
     const val = try sema.resolveValueAllowVariables(air_ref) orelse {
+        const value_comptime_reason: ?[]const u8 = if (air_ref.toInterned()) |_|
+            "thread local and dll imported variables have runtime-known addresses"
+        else
+            null;
+
         return sema.failWithNeededComptime(block, src, .{
             .needed_comptime_reason = "global variable initializer must be comptime-known",
+            .value_comptime_reason = value_comptime_reason,
         });
     };
     if (val.isGenericPoison()) return error.GenericPoison;
@@ -2296,6 +2234,9 @@ fn failWithNeededComptime(sema: *Sema, block: *Block, src: LazySrcLoc, reason: N
         const msg = try sema.errMsg(src, "unable to resolve comptime value", .{});
         errdefer msg.destroy(sema.gpa);
         try sema.errNote(src, msg, "{s}", .{reason.needed_comptime_reason});
+        if (reason.value_comptime_reason) |value_comptime_reason| {
+            try sema.errNote(src, msg, "{s}", .{value_comptime_reason});
+        }
 
         if (reason.block_comptime_reason) |block_comptime_reason| {
             try block_comptime_reason.explain(sema, msg);
@@ -2399,7 +2340,7 @@ fn failWithInvalidComptimeFieldStore(sema: *Sema, block: *Block, init_src: LazyS
 
         const struct_type = zcu.typeToStruct(container_ty) orelse break :msg msg;
         try sema.errNote(.{
-            .base_node_inst = struct_type.zir_index.unwrap().?,
+            .base_node_inst = struct_type.zir_index,
             .offset = .{ .container_field_value = @intCast(field_index) },
         }, msg, "default value set here", .{});
         break :msg msg;
@@ -2559,10 +2500,9 @@ pub fn failWithOwnedErrorMsg(sema: *Sema, block: ?*Block, err_msg: *Zcu.ErrorMsg
     const zcu = sema.pt.zcu;
 
     if (build_options.enable_debug_extensions and zcu.comp.debug_compile_errors) {
-        var all_references: ?std.AutoHashMapUnmanaged(AnalUnit, ?Zcu.ResolvedReference) = null;
         var wip_errors: std.zig.ErrorBundle.Wip = undefined;
         wip_errors.init(gpa) catch @panic("out of memory");
-        Compilation.addModuleErrorMsg(zcu, &wip_errors, err_msg.*, &all_references) catch @panic("out of memory");
+        Compilation.addModuleErrorMsg(zcu, &wip_errors, err_msg.*) catch @panic("out of memory");
         std.debug.print("compile error during Sema:\n", .{});
         var error_bundle = wip_errors.toOwnedBundle("") catch @panic("out of memory");
         error_bundle.renderToStdErr(.{ .ttyconf = .no_color });
@@ -2699,6 +2639,108 @@ fn analyzeAsInt(
     return try val.toUnsignedIntSema(sema.pt);
 }
 
+fn analyzeValueAsCallconv(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    unresolved_val: Value,
+) !std.builtin.CallingConvention {
+    const resolved_val = try sema.resolveLazyValue(unresolved_val);
+    return resolved_val.interpret(std.builtin.CallingConvention, sema.pt) catch |err| switch (err) {
+        error.OutOfMemory => |e| return e,
+        error.UndefinedValue => return sema.failWithUseOfUndef(block, src),
+        error.TypeMismatch => @panic("std.builtin is corrupt"),
+    };
+}
+
+fn zirTupleDecl(
+    sema: *Sema,
+    block: *Block,
+    extended: Zir.Inst.Extended.InstData,
+) CompileError!Air.Inst.Ref {
+    const gpa = sema.gpa;
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const fields_len = extended.small;
+    const extra = sema.code.extraData(Zir.Inst.TupleDecl, extended.operand);
+    var extra_index = extra.end;
+
+    const types = try sema.arena.alloc(InternPool.Index, fields_len);
+    const inits = try sema.arena.alloc(InternPool.Index, fields_len);
+
+    const extra_as_refs: []const Zir.Inst.Ref = @ptrCast(sema.code.extra);
+
+    for (types, inits, 0..) |*field_ty, *field_init, field_index| {
+        const zir_field_ty, const zir_field_init = extra_as_refs[extra_index..][0..2].*;
+        extra_index += 2;
+
+        const type_src = block.src(.{ .tuple_field_type = .{
+            .tuple_decl_node_offset = extra.data.src_node,
+            .elem_index = @intCast(field_index),
+        } });
+        const init_src = block.src(.{ .tuple_field_init = .{
+            .tuple_decl_node_offset = extra.data.src_node,
+            .elem_index = @intCast(field_index),
+        } });
+
+        const uncoerced_field_ty = try sema.resolveInst(zir_field_ty);
+        const field_type = try sema.analyzeAsType(block, type_src, uncoerced_field_ty);
+        try sema.validateTupleFieldType(block, field_type, type_src);
+
+        field_ty.* = field_type.toIntern();
+        field_init.* = init: {
+            if (zir_field_init != .none) {
+                const uncoerced_field_init = try 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, .{
+                    .needed_comptime_reason = "tuple field default value must be comptime-known",
+                });
+                if (field_init_val.canMutateComptimeVarState(zcu)) {
+                    return sema.fail(block, init_src, "field default value contains reference to comptime-mutable memory", .{});
+                }
+                break :init field_init_val.toIntern();
+            }
+            if (try sema.typeHasOnePossibleValue(field_type)) |opv| {
+                break :init opv.toIntern();
+            }
+            break :init .none;
+        };
+    }
+
+    return Air.internedToRef(try zcu.intern_pool.getTupleType(gpa, pt.tid, .{
+        .types = types,
+        .values = inits,
+    }));
+}
+
+fn validateTupleFieldType(
+    sema: *Sema,
+    block: *Block,
+    field_ty: Type,
+    field_ty_src: LazySrcLoc,
+) CompileError!void {
+    const gpa = sema.gpa;
+    const zcu = sema.pt.zcu;
+    if (field_ty.zigTypeTag(zcu) == .@"opaque") {
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(field_ty_src, "opaque types have unknown size and therefore cannot be directly embedded in tuples", .{});
+            errdefer msg.destroy(gpa);
+
+            try sema.addDeclaredHereNote(msg, field_ty);
+            break :msg msg;
+        });
+    }
+    if (field_ty.zigTypeTag(zcu) == .noreturn) {
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(field_ty_src, "tuple fields cannot be 'noreturn'", .{});
+            errdefer msg.destroy(gpa);
+
+            try sema.addDeclaredHereNote(msg, field_ty);
+            break :msg msg;
+        });
+    }
+}
+
 /// 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 {
@@ -2822,7 +2864,6 @@ fn zirStructDecl(
         .fields_len = fields_len,
         .known_non_opv = small.known_non_opv,
         .requires_comptime = if (small.known_comptime_only) .yes else .unknown,
-        .is_tuple = small.is_tuple,
         .any_comptime_fields = small.any_comptime_fields,
         .any_default_inits = small.any_default_inits,
         .inits_resolved = false,
@@ -2881,6 +2922,7 @@ fn zirStructDecl(
     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.
         try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     try sema.declareDependency(.{ .interned = wip_ty.index });
@@ -3131,6 +3173,7 @@ fn zirEnumDecl(
     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.
         try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     return Air.internedToRef(wip_ty.index);
@@ -3254,6 +3297,7 @@ fn zirUnionDecl(
     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.
         try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     try sema.declareDependency(.{ .interned = wip_ty.index });
@@ -3339,6 +3383,7 @@ fn zirOpaqueDecl(
     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.
         try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     try sema.addTypeReferenceEntry(src, wip_ty.index);
@@ -4956,7 +5001,7 @@ fn validateStructInit(
             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), field_src, struct_ty, true);
+                try sema.structFieldPtrByIndex(block, init_src, struct_ptr, @intCast(i), struct_ty);
             const init = Air.internedToRef(default_val.toIntern());
             try sema.storePtr2(block, init_src, default_field_ptr, init_src, init, field_src, .store);
         }
@@ -5148,7 +5193,7 @@ fn validateStructInit(
         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), field_src, struct_ty, true);
+            try sema.structFieldPtrByIndex(block, init_src, struct_ptr, @intCast(i), struct_ty);
         try sema.checkKnownAllocPtr(block, struct_ptr, default_field_ptr);
         const init = Air.internedToRef(field_values[i]);
         try sema.storePtr2(block, init_src, default_field_ptr, init_src, init, field_src, .store);
@@ -5466,7 +5511,7 @@ fn failWithBadMemberAccess(
         else => unreachable,
     };
     if (agg_ty.typeDeclInst(zcu)) |inst| if ((inst.resolve(ip) orelse return error.AnalysisFail) == .main_struct_inst) {
-        return sema.fail(block, field_src, "root struct of file '{}' has no member named '{}'", .{
+        return sema.fail(block, field_src, "root source file struct '{}' has no member named '{}'", .{
             agg_ty.fmt(pt), field_name.fmt(ip),
         });
     };
@@ -6025,9 +6070,7 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
     pt.astGenFile(result.file, path_digest) catch |err|
         return sema.fail(&child_block, src, "C import failed: {s}", .{@errorName(err)});
 
-    // TODO: register some kind of dependency on the file.
-    // That way, if this returns `error.AnalysisFail`, we have the dependency banked ready to
-    // trigger re-analysis later.
+    try sema.declareDependency(.{ .file = result.file_index });
     try pt.ensureFileAnalyzed(result.file_index);
     const ty = zcu.fileRootType(result.file_index);
     try sema.declareDependency(.{ .interned = ty });
@@ -6299,6 +6342,9 @@ fn resolveAnalyzedBlock(
     for (merges.results.items, merges.src_locs.items) |merge_inst, merge_src| {
         try sema.validateRuntimeValue(child_block, merge_src orelse src, merge_inst);
     }
+
+    try sema.checkMergeAllowed(child_block, type_src, resolved_ty);
+
     const ty_inst = Air.internedToRef(resolved_ty.toIntern());
     switch (block_tag) {
         .block => {
@@ -6499,35 +6545,6 @@ pub fn analyzeExport(
     });
 }
 
-fn zirSetAlignStack(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
-    const operand_src = block.builtinCallArgSrc(extra.node, 0);
-    const src = block.nodeOffset(extra.node);
-    const alignment = try sema.resolveAlign(block, operand_src, extra.operand);
-
-    const func = switch (sema.owner.unwrap()) {
-        .func => |func| func,
-        .cau => return sema.fail(block, src, "@setAlignStack outside of function scope", .{}),
-    };
-
-    if (alignment.order(Alignment.fromNonzeroByteUnits(256)).compare(.gt)) {
-        return sema.fail(block, src, "attempt to @setAlignStack({d}); maximum is 256", .{
-            alignment.toByteUnits().?,
-        });
-    }
-
-    switch (Value.fromInterned(func).typeOf(zcu).fnCallingConvention(zcu)) {
-        .Naked => return sema.fail(block, src, "@setAlignStack in naked function", .{}),
-        .Inline => return sema.fail(block, src, "@setAlignStack in inline function", .{}),
-        else => {},
-    }
-
-    zcu.intern_pool.funcMaxStackAlignment(sema.func_index, alignment);
-    sema.allow_memoize = false;
-}
-
 fn zirDisableInstrumentation(sema: *Sema) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
@@ -7557,13 +7574,13 @@ fn analyzeCall(
     if (try sema.resolveValue(func)) |func_val|
         if (func_val.isUndef(zcu))
             return sema.failWithUseOfUndef(block, call_src);
-    if (cc == .Naked) {
+    if (!callConvIsCallable(cc)) {
         const maybe_func_inst = try sema.funcDeclSrcInst(func);
         const msg = msg: {
             const msg = try sema.errMsg(
                 func_src,
-                "unable to call function with naked calling convention",
-                .{},
+                "unable to call function with calling convention '{s}'",
+                .{@tagName(cc)},
             );
             errdefer msg.destroy(sema.gpa);
 
@@ -7590,7 +7607,7 @@ fn analyzeCall(
         .async_kw => return sema.failWithUseOfAsync(block, call_src),
     };
 
-    if (modifier == .never_inline and func_ty_info.cc == .Inline) {
+    if (modifier == .never_inline and func_ty_info.cc == .@"inline") {
         return sema.fail(block, call_src, "'never_inline' call of inline function", .{});
     }
     if (modifier == .always_inline and func_ty_info.is_noinline) {
@@ -7601,7 +7618,7 @@ fn analyzeCall(
 
     const is_generic_call = func_ty_info.is_generic;
     var is_comptime_call = block.is_comptime or modifier == .compile_time;
-    var is_inline_call = is_comptime_call or modifier == .always_inline or func_ty_info.cc == .Inline;
+    var is_inline_call = is_comptime_call or modifier == .always_inline or func_ty_info.cc == .@"inline";
     var comptime_reason: ?*const Block.ComptimeReason = null;
     if (!is_inline_call and !is_comptime_call) {
         if (try Type.fromInterned(func_ty_info.return_type).comptimeOnlySema(pt)) {
@@ -8458,7 +8475,7 @@ fn instantiateGenericCall(
     }
     // Similarly, if the call evaluated to a generic type we need to instead
     // call it inline.
-    if (func_ty_info.is_generic or func_ty_info.cc == .Inline) {
+    if (func_ty_info.is_generic or func_ty_info.cc == .@"inline") {
         return error.GenericPoison;
     }
 
@@ -8502,22 +8519,6 @@ fn instantiateGenericCall(
     return result;
 }
 
-fn resolveTupleLazyValues(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) CompileError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-    const tuple = switch (ip.indexToKey(ty.toIntern())) {
-        .anon_struct_type => |tuple| tuple,
-        else => return,
-    };
-    for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, field_val| {
-        try sema.resolveTupleLazyValues(block, src, Type.fromInterned(field_ty));
-        if (field_val == .none) continue;
-        // TODO: mutate in intern pool
-        _ = try sema.resolveLazyValue(Value.fromInterned(field_val));
-    }
-}
-
 fn zirIntType(sema: *Sema, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const int_type = sema.code.instructions.items(.data)[@intFromEnum(inst)].int_type;
     const ty = try sema.pt.intType(int_type.signedness, int_type.bit_count);
@@ -9508,7 +9509,7 @@ fn zirFunc(
 
     // If this instruction has a body, then it's a function declaration, and we decide
     // the callconv based on whether it is exported. Otherwise, the callconv defaults
-    // to `.Unspecified`.
+    // to `.auto`.
     const cc: std.builtin.CallingConvention = if (has_body) cc: {
         const func_decl_cau = if (sema.generic_owner != .none) cau: {
             const generic_owner_fn = zcu.funcInfo(sema.generic_owner);
@@ -9521,8 +9522,26 @@ fn zirFunc(
             const zir_decl = sema.code.getDeclaration(decl_inst)[0];
             break :exported zir_decl.flags.is_export;
         };
-        break :cc if (fn_is_exported) .C else .Unspecified;
-    } else .Unspecified;
+        if (fn_is_exported) {
+            break :cc target.cCallingConvention() orelse {
+                // This target has no default C calling convention. We sometimes trigger a similar
+                // error by trying to evaluate `std.builtin.CallingConvention.c`, so for consistency,
+                // let's eval that now and just get the transitive error. (It's guaranteed to error
+                // because it does the exact `cCallingConvention` call we just did.)
+                const cc_type = try sema.getBuiltinType("CallingConvention");
+                _ = try sema.namespaceLookupVal(
+                    block,
+                    LazySrcLoc.unneeded,
+                    cc_type.getNamespaceIndex(zcu),
+                    try ip.getOrPutString(sema.gpa, pt.tid, "c", .no_embedded_nulls),
+                );
+                // The above should have errored.
+                @panic("std.builtin is corrupt");
+            };
+        } else {
+            break :cc .auto;
+        }
+    } else .auto;
 
     return sema.funcCommon(
         block,
@@ -9590,7 +9609,7 @@ fn resolveGenericBody(
 }
 
 /// Given a library name, examines if the library name should end up in
-/// `link.File.Options.system_libs` table (for example, libc is always
+/// `link.File.Options.windows_libs` table (for example, libc is always
 /// specified via dedicated flag `link_libc` instead),
 /// and puts it there if it doesn't exist.
 /// It also dupes the library name which can then be saved as part of the
@@ -9609,7 +9628,7 @@ fn handleExternLibName(
         const comp = zcu.comp;
         const target = zcu.getTarget();
         log.debug("extern fn symbol expected in lib '{s}'", .{lib_name});
-        if (target.is_libc_lib_name(lib_name)) {
+        if (std.zig.target.isLibCLibName(target, lib_name)) {
             if (!comp.config.link_libc) {
                 return sema.fail(
                     block,
@@ -9620,7 +9639,7 @@ fn handleExternLibName(
             }
             break :blk;
         }
-        if (target.is_libcpp_lib_name(lib_name)) {
+        if (std.zig.target.isLibCxxLibName(target, lib_name)) {
             if (!comp.config.link_libcpp) return sema.fail(
                 block,
                 src_loc,
@@ -9657,36 +9676,152 @@ fn handleExternLibName(
 /// These are calling conventions that are confirmed to work with variadic functions.
 /// Any calling conventions not included here are either not yet verified to work with variadic
 /// functions or there are no more other calling conventions that support variadic functions.
-const calling_conventions_supporting_var_args = [_]std.builtin.CallingConvention{
-    .C,
+const calling_conventions_supporting_var_args = [_]std.builtin.CallingConvention.Tag{
+    .x86_64_sysv,
+    .x86_64_win,
+    .x86_sysv,
+    .x86_win,
+    .aarch64_aapcs,
+    .aarch64_aapcs_darwin,
+    .aarch64_aapcs_win,
+    .aarch64_vfabi,
+    .aarch64_vfabi_sve,
+    .arm_apcs,
+    .arm_aapcs,
+    .arm_aapcs_vfp,
+    .arm_aapcs16_vfp,
+    .mips64_n64,
+    .mips64_n32,
+    .mips_o32,
+    .riscv64_lp64,
+    .riscv64_lp64_v,
+    .riscv32_ilp32,
+    .riscv32_ilp32_v,
+    .sparc64_sysv,
+    .sparc_sysv,
+    .powerpc64_elf,
+    .powerpc64_elf_altivec,
+    .powerpc64_elf_v2,
+    .powerpc_sysv,
+    .powerpc_sysv_altivec,
+    .powerpc_aix,
+    .powerpc_aix_altivec,
+    .wasm_watc,
+    .arc_sysv,
+    .avr_gnu,
+    .bpf_std,
+    .csky_sysv,
+    .hexagon_sysv,
+    .hexagon_sysv_hvx,
+    .lanai_sysv,
+    .loongarch64_lp64,
+    .loongarch32_ilp32,
+    .m68k_sysv,
+    .m68k_gnu,
+    .m68k_rtd,
+    .msp430_eabi,
+    .s390x_sysv,
+    .s390x_sysv_vx,
+    .ve_sysv,
+    .xcore_xs1,
+    .xcore_xs2,
+    .xtensa_call0,
+    .xtensa_windowed,
 };
-fn callConvSupportsVarArgs(cc: std.builtin.CallingConvention) bool {
+fn callConvSupportsVarArgs(cc: std.builtin.CallingConvention.Tag) bool {
     return for (calling_conventions_supporting_var_args) |supported_cc| {
         if (cc == supported_cc) return true;
     } else false;
 }
-fn checkCallConvSupportsVarArgs(sema: *Sema, block: *Block, src: LazySrcLoc, cc: std.builtin.CallingConvention) CompileError!void {
+fn checkCallConvSupportsVarArgs(sema: *Sema, block: *Block, src: LazySrcLoc, cc: std.builtin.CallingConvention.Tag) CompileError!void {
     const CallingConventionsSupportingVarArgsList = struct {
-        pub fn format(_: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+        arch: std.Target.Cpu.Arch,
+        pub fn format(ctx: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
             _ = fmt;
             _ = options;
-            for (calling_conventions_supporting_var_args, 0..) |cc_inner, i| {
-                if (i != 0)
+            var first = true;
+            for (calling_conventions_supporting_var_args) |cc_inner| {
+                for (std.Target.Cpu.Arch.fromCallingConvention(cc_inner)) |supported_arch| {
+                    if (supported_arch == ctx.arch) break;
+                } else continue; // callconv not supported by this arch
+                if (!first) {
                     try writer.writeAll(", ");
-                try writer.print("'.{s}'", .{@tagName(cc_inner)});
+                }
+                first = false;
+                try writer.print("'{s}'", .{@tagName(cc_inner)});
             }
         }
     };
 
     if (!callConvSupportsVarArgs(cc)) {
-        const msg = msg: {
-            const msg = try sema.errMsg(src, "variadic function does not support '.{s}' calling convention", .{@tagName(cc)});
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(src, "variadic function does not support '{s}' calling convention", .{@tagName(cc)});
             errdefer msg.destroy(sema.gpa);
-            try sema.errNote(src, msg, "supported calling conventions: {}", .{CallingConventionsSupportingVarArgsList{}});
+            const target = sema.pt.zcu.getTarget();
+            try sema.errNote(src, msg, "supported calling conventions: {}", .{CallingConventionsSupportingVarArgsList{ .arch = target.cpu.arch }});
             break :msg msg;
-        };
-        return sema.failWithOwnedErrorMsg(block, msg);
+        });
+    }
+}
+
+fn callConvIsCallable(cc: std.builtin.CallingConvention.Tag) bool {
+    return switch (cc) {
+        .naked,
+
+        .arm_interrupt,
+        .avr_interrupt,
+        .avr_signal,
+        .csky_interrupt,
+        .m68k_interrupt,
+        .mips_interrupt,
+        .mips64_interrupt,
+        .riscv32_interrupt,
+        .riscv64_interrupt,
+        .x86_interrupt,
+        .x86_64_interrupt,
+
+        .amdgcn_kernel,
+        .nvptx_kernel,
+        .spirv_kernel,
+        .spirv_fragment,
+        .spirv_vertex,
+        => false,
+
+        else => true,
+    };
+}
+
+fn checkMergeAllowed(sema: *Sema, block: *Block, src: LazySrcLoc, peer_ty: Type) !void {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const target = zcu.getTarget();
+
+    if (!peer_ty.isPtrAtRuntime(zcu)) {
+        return;
     }
+
+    const as = peer_ty.ptrAddressSpace(zcu);
+    if (!target_util.arePointersLogical(target, as)) {
+        return;
+    }
+
+    return sema.failWithOwnedErrorMsg(block, msg: {
+        const msg = try sema.errMsg(src, "value with non-mergable pointer type '{}' depends on runtime control flow", .{peer_ty.fmt(pt)});
+        errdefer msg.destroy(sema.gpa);
+
+        const runtime_src = block.runtime_cond orelse block.runtime_loop.?;
+        try sema.errNote(runtime_src, msg, "runtime control flow here", .{});
+
+        const backend = target_util.zigBackend(target, zcu.comp.config.use_llvm);
+        try sema.errNote(src, msg, "pointers with address space '{s}' cannot be returned from a branch on target {s}-{s} by compiler backend {s}", .{
+            @tagName(as),
+            target.cpu.arch.genericName(),
+            @tagName(target.os.tag),
+            @tagName(backend),
+        });
+
+        break :msg msg;
+    });
 }
 
 const Section = union(enum) {
@@ -9746,7 +9881,7 @@ fn funcCommon(
     // default values which are only meaningful for the generic function, *not*
     // the instantiation, which can depend on comptime parameters.
     // Related proposal: https://github.com/ziglang/zig/issues/11834
-    const cc_resolved = cc orelse .Unspecified;
+    const cc_resolved = cc orelse .auto;
     var comptime_bits: u32 = 0;
     for (block.params.items(.ty), block.params.items(.is_comptime), 0..) |param_ty_ip, param_is_comptime, i| {
         const param_ty = Type.fromInterned(param_ty_ip);
@@ -9764,10 +9899,10 @@ fn funcCommon(
         }
         const this_generic = param_ty.isGenericPoison();
         is_generic = is_generic or this_generic;
-        if (param_is_comptime and !target_util.fnCallConvAllowsZigTypes(target, cc_resolved)) {
+        if (param_is_comptime and !target_util.fnCallConvAllowsZigTypes(cc_resolved)) {
             return sema.fail(block, param_src, "comptime parameters not allowed in function with calling convention '{s}'", .{@tagName(cc_resolved)});
         }
-        if (this_generic and !sema.no_partial_func_ty and !target_util.fnCallConvAllowsZigTypes(target, cc_resolved)) {
+        if (this_generic and !sema.no_partial_func_ty and !target_util.fnCallConvAllowsZigTypes(cc_resolved)) {
             return sema.fail(block, param_src, "generic parameters not allowed in function with calling convention '{s}'", .{@tagName(cc_resolved)});
         }
         if (!param_ty.isValidParamType(zcu)) {
@@ -9776,7 +9911,7 @@ fn funcCommon(
                 opaque_str, param_ty.fmt(pt),
             });
         }
-        if (!this_generic and !target_util.fnCallConvAllowsZigTypes(target, cc_resolved) and !try sema.validateExternType(param_ty, .param_ty)) {
+        if (!this_generic and !target_util.fnCallConvAllowsZigTypes(cc_resolved) and !try sema.validateExternType(param_ty, .param_ty)) {
             const msg = msg: {
                 const msg = try sema.errMsg(param_src, "parameter of type '{}' not allowed in function with calling convention '{s}'", .{
                     param_ty.fmt(pt), @tagName(cc_resolved),
@@ -9810,15 +9945,24 @@ fn funcCommon(
             return sema.fail(block, param_src, "non-pointer parameter declared noalias", .{});
         }
         switch (cc_resolved) {
-            .Interrupt => if (target.cpu.arch.isX86()) {
+            .x86_64_interrupt, .x86_interrupt => {
                 const err_code_size = target.ptrBitWidth();
                 switch (i) {
-                    0 => if (param_ty.zigTypeTag(zcu) != .pointer) return sema.fail(block, param_src, "first parameter of function with 'Interrupt' calling convention must be a pointer type", .{}),
-                    1 => if (param_ty.bitSize(zcu) != err_code_size) return sema.fail(block, param_src, "second parameter of function with 'Interrupt' calling convention must be a {d}-bit integer", .{err_code_size}),
-                    else => return sema.fail(block, param_src, "'Interrupt' calling convention supports up to 2 parameters, found {d}", .{i + 1}),
-                }
-            } else return sema.fail(block, param_src, "parameters are not allowed with 'Interrupt' calling convention", .{}),
-            .Signal => return sema.fail(block, param_src, "parameters are not allowed with 'Signal' calling convention", .{}),
+                    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_resolved)}),
+                    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_resolved), err_code_size }),
+                    else => return sema.fail(block, param_src, "'{s}' calling convention supports up to 2 parameters, found {d}", .{ @tagName(cc_resolved), i + 1 }),
+                }
+            },
+            .arm_interrupt,
+            .mips64_interrupt,
+            .mips_interrupt,
+            .riscv64_interrupt,
+            .riscv32_interrupt,
+            .avr_interrupt,
+            .csky_interrupt,
+            .m68k_interrupt,
+            .avr_signal,
+            => return sema.fail(block, param_src, "parameters are not allowed with '{s}' calling convention", .{@tagName(cc_resolved)}),
             else => {},
         }
     }
@@ -9963,6 +10107,7 @@ fn funcCommon(
             .is_const = true,
             .is_threadlocal = false,
             .is_weak_linkage = false,
+            .is_dll_import = false,
             .alignment = alignment orelse .none,
             .@"addrspace" = address_space orelse .generic,
             .zir_index = sema.getOwnerCauDeclInst(), // `declaration` instruction
@@ -10067,7 +10212,6 @@ fn finishFunc(
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const gpa = sema.gpa;
-    const target = zcu.getTarget();
 
     const return_type: Type = if (opt_func_index == .none or ret_poison)
         bare_return_type
@@ -10080,7 +10224,7 @@ fn finishFunc(
             opaque_str, return_type.fmt(pt),
         });
     }
-    if (!ret_poison and !target_util.fnCallConvAllowsZigTypes(target, cc_resolved) and
+    if (!ret_poison and !target_util.fnCallConvAllowsZigTypes(cc_resolved) and
         !try sema.validateExternType(return_type, .ret_ty))
     {
         const msg = msg: {
@@ -10136,57 +10280,63 @@ fn finishFunc(
         return sema.failWithOwnedErrorMsg(block, msg);
     }
 
+    validate_incoming_stack_align: {
+        const a: u64 = switch (cc_resolved) {
+            inline else => |payload| if (@TypeOf(payload) != void and @hasField(@TypeOf(payload), "incoming_stack_alignment"))
+                payload.incoming_stack_alignment orelse break :validate_incoming_stack_align
+            else
+                break :validate_incoming_stack_align,
+        };
+        if (!std.math.isPowerOfTwo(a)) {
+            return sema.fail(block, cc_src, "calling convention incoming stack alignment '{d}' is not a power of two", .{a});
+        }
+    }
+
     switch (cc_resolved) {
-        .Interrupt, .Signal => if (return_type.zigTypeTag(zcu) != .void and return_type.zigTypeTag(zcu) != .noreturn) {
+        .x86_64_interrupt,
+        .x86_interrupt,
+        .arm_interrupt,
+        .mips64_interrupt,
+        .mips_interrupt,
+        .riscv64_interrupt,
+        .riscv32_interrupt,
+        .avr_interrupt,
+        .csky_interrupt,
+        .m68k_interrupt,
+        .avr_signal,
+        => if (return_type.zigTypeTag(zcu) != .void and return_type.zigTypeTag(zcu) != .noreturn) {
             return sema.fail(block, ret_ty_src, "function with calling convention '{s}' must return 'void' or 'noreturn'", .{@tagName(cc_resolved)});
         },
-        .Inline => if (is_noinline) {
-            return sema.fail(block, cc_src, "'noinline' function cannot have callconv 'Inline'", .{});
+        .@"inline" => if (is_noinline) {
+            return sema.fail(block, cc_src, "'noinline' function cannot have calling convention 'inline'", .{});
         },
         else => {},
     }
 
-    const arch = target.cpu.arch;
-    if (@as(?[]const u8, switch (cc_resolved) {
-        .Unspecified, .C, .Naked, .Async, .Inline => null,
-        .Interrupt => switch (arch) {
-            .x86, .x86_64, .avr, .msp430 => null,
-            else => "x86, x86_64, AVR, and MSP430",
-        },
-        .Signal => switch (arch) {
-            .avr => null,
-            else => "AVR",
-        },
-        .Stdcall, .Fastcall, .Thiscall => switch (arch) {
-            .x86 => null,
-            else => "x86",
-        },
-        .Vectorcall => switch (arch) {
-            .x86, .aarch64, .aarch64_be => null,
-            else => "x86 and AArch64",
-        },
-        .APCS, .AAPCS, .AAPCSVFP => switch (arch) {
-            .arm, .armeb, .aarch64, .aarch64_be, .thumb, .thumbeb => null,
-            else => "ARM",
-        },
-        .SysV, .Win64 => switch (arch) {
-            .x86_64 => null,
-            else => "x86_64",
-        },
-        .Kernel => switch (arch) {
-            .nvptx, .nvptx64, .amdgcn, .spirv, .spirv32, .spirv64 => null,
-            else => "nvptx, amdgcn and SPIR-V",
-        },
-        .Fragment, .Vertex => switch (arch) {
-            .spirv, .spirv32, .spirv64 => null,
-            else => "SPIR-V",
-        },
-    })) |allowed_platform| {
-        return sema.fail(block, cc_src, "callconv '{s}' is only available on {s}, not {s}", .{
+    switch (zcu.callconvSupported(cc_resolved)) {
+        .ok => {},
+        .bad_arch => |allowed_archs| {
+            const ArchListFormatter = struct {
+                archs: []const std.Target.Cpu.Arch,
+                pub fn format(formatter: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+                    _ = fmt;
+                    _ = options;
+                    for (formatter.archs, 0..) |arch, i| {
+                        if (i != 0)
+                            try writer.writeAll(", ");
+                        try writer.print("'{s}'", .{@tagName(arch)});
+                    }
+                }
+            };
+            return sema.fail(block, cc_src, "calling convention '{s}' only available on architectures {}", .{
+                @tagName(cc_resolved),
+                ArchListFormatter{ .archs = allowed_archs },
+            });
+        },
+        .bad_backend => |bad_backend| return sema.fail(block, cc_src, "calling convention '{s}' not supported by compiler backend '{s}'", .{
             @tagName(cc_resolved),
-            allowed_platform,
-            @tagName(arch),
-        });
+            @tagName(bad_backend),
+        }),
     }
 
     if (is_generic and sema.no_partial_func_ty) return error.GenericPoison;
@@ -14271,13 +14421,9 @@ fn zirHasField(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                 },
                 else => {},
             },
-            .anon_struct_type => |anon_struct| {
-                if (anon_struct.names.len != 0) {
-                    break :hf mem.indexOfScalar(InternPool.NullTerminatedString, anon_struct.names.get(ip), field_name) != null;
-                } else {
-                    const field_index = field_name.toUnsigned(ip) orelse break :hf false;
-                    break :hf field_index < ty.structFieldCount(zcu);
-                }
+            .tuple_type => |tuple| {
+                const field_index = field_name.toUnsigned(ip) orelse break :hf false;
+                break :hf field_index < tuple.types.len;
             },
             .struct_type => {
                 break :hf ip.loadStructType(ty.toIntern()).nameIndex(ip, field_name) != null;
@@ -14348,9 +14494,7 @@ fn zirImport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
             return sema.fail(block, operand_src, "unable to open '{s}': {s}", .{ operand, @errorName(err) });
         },
     };
-    // TODO: register some kind of dependency on the file.
-    // That way, if this returns `error.AnalysisFail`, we have the dependency banked ready to
-    // trigger re-analysis later.
+    try sema.declareDependency(.{ .file = result.file_index });
     try pt.ensureFileAnalyzed(result.file_index);
     const ty = zcu.fileRootType(result.file_index);
     try sema.declareDependency(.{ .interned = ty });
@@ -14834,7 +14978,7 @@ fn analyzeTupleCat(
     const dest_fields = lhs_len + rhs_len;
 
     if (dest_fields == 0) {
-        return Air.internedToRef(Value.empty_struct.toIntern());
+        return .empty_tuple;
     }
     if (lhs_len == 0) {
         return rhs;
@@ -14880,10 +15024,9 @@ fn analyzeTupleCat(
         break :rs runtime_src;
     };
 
-    const tuple_ty = try zcu.intern_pool.getAnonStructType(zcu.gpa, pt.tid, .{
+    const tuple_ty = try zcu.intern_pool.getTupleType(zcu.gpa, pt.tid, .{
         .types = types,
         .values = values,
-        .names = &.{},
     });
 
     const runtime_src = opt_runtime_src orelse {
@@ -15215,7 +15358,7 @@ fn analyzeTupleMul(
         return sema.fail(block, len_src, "operation results in overflow", .{});
 
     if (final_len == 0) {
-        return Air.internedToRef(Value.empty_struct.toIntern());
+        return .empty_tuple;
     }
     const types = try sema.arena.alloc(InternPool.Index, final_len);
     const values = try sema.arena.alloc(InternPool.Index, final_len);
@@ -15241,10 +15384,9 @@ fn analyzeTupleMul(
         break :rs runtime_src;
     };
 
-    const tuple_ty = try zcu.intern_pool.getAnonStructType(zcu.gpa, pt.tid, .{
+    const tuple_ty = try zcu.intern_pool.getTupleType(zcu.gpa, pt.tid, .{
         .types = types,
         .values = values,
-        .names = &.{},
     });
 
     const runtime_src = opt_runtime_src orelse {
@@ -16641,7 +16783,7 @@ fn zirOverflowArithmetic(
     const maybe_rhs_val = try sema.resolveValue(rhs);
 
     const tuple_ty = try sema.overflowArithmeticTupleType(dest_ty);
-    const overflow_ty = Type.fromInterned(ip.indexToKey(tuple_ty.toIntern()).anon_struct_type.types.get(ip)[1]);
+    const overflow_ty = Type.fromInterned(ip.indexToKey(tuple_ty.toIntern()).tuple_type.types.get(ip)[1]);
 
     var result: struct {
         inst: Air.Inst.Ref = .none,
@@ -16825,10 +16967,9 @@ fn overflowArithmeticTupleType(sema: *Sema, ty: Type) !Type {
 
     const types = [2]InternPool.Index{ ty.toIntern(), ov_ty.toIntern() };
     const values = [2]InternPool.Index{ .none, .none };
-    const tuple_ty = try ip.getAnonStructType(zcu.gpa, pt.tid, .{
+    const tuple_ty = try ip.getTupleType(zcu.gpa, pt.tid, .{
         .types = &types,
         .values = &values,
-        .names = &.{},
     });
     return Type.fromInterned(tuple_ty);
 }
@@ -17465,6 +17606,25 @@ fn analyzePtrArithmetic(
     };
 
     try sema.requireRuntimeBlock(block, op_src, runtime_src);
+
+    const target = zcu.getTarget();
+    if (target_util.arePointersLogical(target, ptr_info.flags.address_space)) {
+        return sema.failWithOwnedErrorMsg(block, msg: {
+            const msg = try sema.errMsg(op_src, "illegal pointer arithmetic on pointer of type '{}'", .{ptr_ty.fmt(pt)});
+            errdefer msg.destroy(sema.gpa);
+
+            const backend = target_util.zigBackend(target, zcu.comp.config.use_llvm);
+            try sema.errNote(op_src, msg, "arithmetic cannot be performed on pointers with address space '{s}' on target {s}-{s} by compiler backend {s}", .{
+                @tagName(ptr_info.flags.address_space),
+                target.cpu.arch.genericName(),
+                @tagName(target.os.tag),
+                @tagName(backend),
+            });
+
+            break :msg msg;
+        });
+    }
+
     return block.addInst(.{
         .tag = air_tag,
         .data = .{ .ty_pl = .{
@@ -18347,10 +18507,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             } });
 
             const callconv_ty = try sema.getBuiltinType("CallingConvention");
+            const callconv_val = Value.uninterpret(func_ty_info.cc, callconv_ty, pt) catch |err| switch (err) {
+                error.TypeMismatch => @panic("std.builtin is corrupt"),
+                error.OutOfMemory => |e| return e,
+            };
 
-            const field_values = .{
+            const field_values: [5]InternPool.Index = .{
                 // calling_convention: CallingConvention,
-                (try pt.enumValueFieldIndex(callconv_ty, @intFromEnum(func_ty_info.cc))).toIntern(),
+                callconv_val.toIntern(),
                 // is_generic: bool,
                 Value.makeBool(func_ty_info.is_generic).toIntern(),
                 // is_var_args: bool,
@@ -18856,16 +19020,13 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             defer gpa.free(struct_field_vals);
             fv: {
                 const struct_type = switch (ip.indexToKey(ty.toIntern())) {
-                    .anon_struct_type => |anon_struct_type| {
-                        struct_field_vals = try gpa.alloc(InternPool.Index, anon_struct_type.types.len);
+                    .tuple_type => |tuple_type| {
+                        struct_field_vals = try gpa.alloc(InternPool.Index, tuple_type.types.len);
                         for (struct_field_vals, 0..) |*struct_field_val, field_index| {
-                            const field_ty = anon_struct_type.types.get(ip)[field_index];
-                            const field_val = anon_struct_type.values.get(ip)[field_index];
+                            const field_ty = tuple_type.types.get(ip)[field_index];
+                            const field_val = tuple_type.values.get(ip)[field_index];
                             const name_val = v: {
-                                const field_name = if (anon_struct_type.names.len != 0)
-                                    anon_struct_type.names.get(ip)[field_index]
-                                else
-                                    try ip.getOrPutStringFmt(gpa, pt.tid, "{d}", .{field_index}, .no_embedded_nulls);
+                                const field_name = try ip.getOrPutStringFmt(gpa, pt.tid, "{d}", .{field_index}, .no_embedded_nulls);
                                 const field_name_len = field_name.length(ip);
                                 const new_decl_ty = try pt.arrayType(.{
                                     .len = field_name_len,
@@ -20457,8 +20618,8 @@ fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const src = block.nodeOffset(inst_data.src_node);
     const ty_operand = sema.resolveType(block, src, inst_data.operand) catch |err| switch (err) {
-        // Generic poison means this is an untyped anonymous empty struct init
-        error.GenericPoison => return .empty_struct,
+        // Generic poison means this is an untyped anonymous empty struct/array init
+        error.GenericPoison => return .empty_tuple,
         else => |e| return e,
     };
     const init_ty = if (is_byref) ty: {
@@ -20619,7 +20780,7 @@ fn zirStructInit(
     const result_ty = sema.resolveType(block, src, first_field_type_extra.container_type) catch |err| switch (err) {
         error.GenericPoison => {
             // The type wasn't actually known, so treat this as an anon struct init.
-            return sema.structInitAnon(block, src, .typed_init, extra.data, extra.end, is_ref);
+            return sema.structInitAnon(block, src, inst, .typed_init, extra.data, extra.end, is_ref);
         },
         else => |e| return e,
     };
@@ -20785,39 +20946,28 @@ fn finishStructInit(
     errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
 
     switch (ip.indexToKey(struct_ty.toIntern())) {
-        .anon_struct_type => |anon_struct| {
+        .tuple_type => |tuple| {
             // We can't get the slices, as the coercion may invalidate them.
-            for (0..anon_struct.types.len) |i| {
+            for (0..tuple.types.len) |i| {
                 if (field_inits[i] != .none) {
                     // Coerce the init value to the field type.
                     const field_src = block.src(.{ .init_elem = .{
                         .init_node_offset = init_src.offset.node_offset.x,
                         .elem_index = @intCast(i),
                     } });
-                    const field_ty = Type.fromInterned(anon_struct.types.get(ip)[i]);
+                    const field_ty = Type.fromInterned(tuple.types.get(ip)[i]);
                     field_inits[i] = try sema.coerce(block, field_ty, field_inits[i], field_src);
                     continue;
                 }
 
-                const default_val = anon_struct.values.get(ip)[i];
+                const default_val = tuple.values.get(ip)[i];
 
                 if (default_val == .none) {
-                    if (anon_struct.names.len == 0) {
-                        const template = "missing tuple field with index {d}";
-                        if (root_msg) |msg| {
-                            try sema.errNote(init_src, msg, template, .{i});
-                        } else {
-                            root_msg = try sema.errMsg(init_src, template, .{i});
-                        }
+                    const template = "missing tuple field with index {d}";
+                    if (root_msg) |msg| {
+                        try sema.errNote(init_src, msg, template, .{i});
                     } else {
-                        const field_name = anon_struct.names.get(ip)[i];
-                        const template = "missing struct field: {}";
-                        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);
-                        }
+                        root_msg = try sema.errMsg(init_src, template, .{i});
                     }
                 } else {
                     field_inits[i] = Air.internedToRef(default_val);
@@ -20842,22 +20992,13 @@ fn finishStructInit(
 
                 const field_init = struct_type.fieldInit(ip, i);
                 if (field_init == .none) {
-                    if (!struct_type.isTuple(ip)) {
-                        const field_name = struct_type.field_names.get(ip)[i];
-                        const template = "missing struct field: {}";
-                        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_name = struct_type.field_names.get(ip)[i];
+                    const template = "missing struct field: {}";
+                    const args = .{field_name.fmt(ip)};
+                    if (root_msg) |msg| {
+                        try sema.errNote(init_src, msg, template, args);
                     } else {
-                        const template = "missing tuple field with index {d}";
-                        if (root_msg) |msg| {
-                            try sema.errNote(init_src, msg, template, .{i});
-                        } else {
-                            root_msg = try sema.errMsg(init_src, template, .{i});
-                        }
+                        root_msg = try sema.errMsg(init_src, template, args);
                     }
                 } else {
                     field_inits[i] = Air.internedToRef(field_init);
@@ -20918,8 +21059,7 @@ fn finishStructInit(
         const base_ptr = try sema.optEuBasePtrInit(block, alloc, init_src);
         for (field_inits, 0..) |field_init, i_usize| {
             const i: u32 = @intCast(i_usize);
-            const field_src = dest_src;
-            const field_ptr = try sema.structFieldPtrByIndex(block, dest_src, base_ptr, i, field_src, struct_ty, true);
+            const field_ptr = try sema.structFieldPtrByIndex(block, dest_src, base_ptr, i, struct_ty);
             try sema.storePtr(block, dest_src, field_ptr, field_init);
         }
 
@@ -20943,13 +21083,14 @@ fn zirStructInitAnon(
     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.StructInitAnon, inst_data.payload_index);
-    return sema.structInitAnon(block, src, .anon_init, extra.data, extra.end, false);
+    return sema.structInitAnon(block, src, inst, .anon_init, extra.data, extra.end, false);
 }
 
 fn structInitAnon(
     sema: *Sema,
     block: *Block,
     src: LazySrcLoc,
+    inst: Zir.Inst.Index,
     /// It is possible for a typed struct_init to be downgraded to an anonymous init due to a
     /// generic poison type. In this case, we need to know to interpret the extra data differently.
     comptime kind: enum { anon_init, typed_init },
@@ -20970,6 +21111,8 @@ fn structInitAnon(
     const values = try sema.arena.alloc(InternPool.Index, types.len);
     const names = try sema.arena.alloc(InternPool.NullTerminatedString, types.len);
 
+    var any_values = false;
+
     // Find which field forces the expression to be runtime, if any.
     const opt_runtime_index = rs: {
         var runtime_index: ?usize = null;
@@ -21011,6 +21154,7 @@ fn structInitAnon(
             }
             if (try sema.resolveValue(init)) |init_val| {
                 field_val.* = init_val.toIntern();
+                any_values = true;
             } else {
                 field_val.* = .none;
                 runtime_index = @intCast(i_usize);
@@ -21019,18 +21163,76 @@ fn structInitAnon(
         break :rs runtime_index;
     };
 
-    const tuple_ty = try ip.getAnonStructType(gpa, pt.tid, .{
-        .names = names,
-        .types = types,
-        .values = values,
-    });
+    // 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.
+    const type_hash: u64 = hash: {
+        var hasher = std.hash.Wyhash.init(0);
+        hasher.update(std.mem.sliceAsBytes(types));
+        hasher.update(std.mem.sliceAsBytes(values));
+        hasher.update(std.mem.sliceAsBytes(names));
+        break :hash hasher.final();
+    };
+    const tracked_inst = try block.trackZir(inst);
+    const struct_ty = switch (try ip.getStructType(gpa, pt.tid, .{
+        .layout = .auto,
+        .fields_len = extra_data.fields_len,
+        .known_non_opv = false,
+        .requires_comptime = .unknown,
+        .any_comptime_fields = any_values,
+        .any_default_inits = any_values,
+        .inits_resolved = true,
+        .any_aligned_fields = false,
+        .key = .{ .reified = .{
+            .zir_index = tracked_inst,
+            .type_hash = type_hash,
+        } },
+    }, false)) {
+        .wip => |wip| ty: {
+            errdefer wip.cancel(ip, pt.tid);
+            wip.setName(ip, try sema.createTypeName(block, .anon, "struct", inst, wip.index));
+
+            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);
+            }
+
+            @memcpy(struct_type.field_types.get(ip), types);
+            if (any_values) {
+                @memcpy(struct_type.field_inits.get(ip), values);
+            }
+
+            const new_namespace_index = try pt.createNamespace(.{
+                .parent = block.namespace.toOptional(),
+                .owner_type = wip.index,
+                .file_scope = block.getFileScopeIndex(zcu),
+                .generation = zcu.generation,
+            });
+            const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index, wip.index);
+            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;
+                try zcu.comp.queueJob(.{ .codegen_type = wip.index });
+            }
+            break :ty wip.finish(ip, new_cau_index.toOptional(), new_namespace_index);
+        },
+        .existing => |ty| ty,
+    };
+    try sema.declareDependency(.{ .interned = struct_ty });
+    try sema.addTypeReferenceEntry(src, struct_ty);
 
     const runtime_index = opt_runtime_index orelse {
-        const tuple_val = try pt.intern(.{ .aggregate = .{
-            .ty = tuple_ty,
+        const struct_val = try pt.intern(.{ .aggregate = .{
+            .ty = struct_ty,
             .storage = .{ .elems = values },
         } });
-        return sema.addConstantMaybeRef(tuple_val, is_ref);
+        return sema.addConstantMaybeRef(struct_val, is_ref);
     };
 
     try sema.requireRuntimeBlock(block, LazySrcLoc.unneeded, block.src(.{ .init_elem = .{
@@ -21041,7 +21243,7 @@ fn structInitAnon(
     if (is_ref) {
         const target = zcu.getTarget();
         const alloc_ty = try pt.ptrTypeSema(.{
-            .child = tuple_ty,
+            .child = struct_ty,
             .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
         });
         const alloc = try block.addTy(.alloc, alloc_ty);
@@ -21079,7 +21281,7 @@ fn structInitAnon(
         element_refs[i] = try sema.resolveInst(item.data.init);
     }
 
-    return block.addAggregateInit(Type.fromInterned(tuple_ty), element_refs);
+    return block.addAggregateInit(Type.fromInterned(struct_ty), element_refs);
 }
 
 fn zirArrayInit(
@@ -21288,10 +21490,9 @@ fn arrayInitAnon(
         break :rs runtime_src;
     };
 
-    const tuple_ty = try ip.getAnonStructType(gpa, pt.tid, .{
+    const tuple_ty = try ip.getTupleType(gpa, pt.tid, .{
         .types = types,
         .values = values,
-        .names = &.{},
     });
 
     const runtime_src = opt_runtime_src orelse {
@@ -21388,12 +21589,9 @@ fn fieldType(
         try cur_ty.resolveFields(pt);
         switch (cur_ty.zigTypeTag(zcu)) {
             .@"struct" => switch (ip.indexToKey(cur_ty.toIntern())) {
-                .anon_struct_type => |anon_struct| {
-                    const field_index = if (anon_struct.names.len == 0)
-                        try sema.tupleFieldIndex(block, cur_ty, field_name, field_src)
-                    else
-                        try sema.anonStructFieldIndex(block, cur_ty, field_name, field_src);
-                    return Air.internedToRef(anon_struct.types.get(ip)[field_index]);
+                .tuple_type => |tuple| {
+                    const field_index = try sema.tupleFieldIndex(block, cur_ty, field_name, field_src);
+                    return Air.internedToRef(tuple.types.get(ip)[field_index]);
                 },
                 .struct_type => {
                     const struct_type = ip.loadStructType(cur_ty.toIntern());
@@ -22043,7 +22241,16 @@ fn zirReify(
                 .needed_comptime_reason = "struct fields must be comptime-known",
             });
 
-            return try sema.reifyStruct(block, inst, src, layout, backing_integer_val, fields_arr, name_strategy, is_tuple_val.toBool());
+            if (is_tuple_val.toBool()) {
+                switch (layout) {
+                    .@"extern" => return sema.fail(block, src, "extern tuples are not supported", .{}),
+                    .@"packed" => return sema.fail(block, src, "packed tuples are not supported", .{}),
+                    .auto => {},
+                }
+                return sema.reifyTuple(block, src, fields_arr);
+            } else {
+                return sema.reifyStruct(block, inst, src, layout, backing_integer_val, fields_arr, name_strategy);
+            }
         },
         .@"enum" => {
             const struct_type = ip.loadStructType(ip.typeOf(union_val.val));
@@ -22176,7 +22383,7 @@ fn zirReify(
             }
 
             const is_var_args = is_var_args_val.toBool();
-            const cc = zcu.toEnum(std.builtin.CallingConvention, calling_convention_val);
+            const cc = try sema.analyzeValueAsCallconv(block, src, calling_convention_val);
             if (is_var_args) {
                 try sema.checkCallConvSupportsVarArgs(block, src, cc);
             }
@@ -22378,6 +22585,7 @@ fn reifyEnum(
     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.
         try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     return Air.internedToRef(wip_ty.index);
@@ -22635,6 +22843,7 @@ fn reifyUnion(
     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.
         try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     try sema.declareDependency(.{ .interned = wip_ty.index });
@@ -22642,6 +22851,104 @@ fn reifyUnion(
     return Air.internedToRef(wip_ty.finish(ip, new_cau_index.toOptional(), new_namespace_index));
 }
 
+fn reifyTuple(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    fields_val: Value,
+) CompileError!Air.Inst.Ref {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const gpa = sema.gpa;
+    const ip = &zcu.intern_pool;
+
+    const fields_len: u32 = @intCast(fields_val.typeOf(zcu).arrayLen(zcu));
+
+    const types = try sema.arena.alloc(InternPool.Index, fields_len);
+    const inits = try sema.arena.alloc(InternPool.Index, fields_len);
+
+    for (types, inits, 0..) |*field_ty, *field_init, field_idx| {
+        const field_info = try fields_val.elemValue(pt, field_idx);
+
+        const field_name_val = try field_info.fieldValue(pt, 0);
+        const field_type_val = try field_info.fieldValue(pt, 1);
+        const field_default_value_val = try field_info.fieldValue(pt, 2);
+        const field_is_comptime_val = try field_info.fieldValue(pt, 3);
+        const field_alignment_val = try sema.resolveLazyValue(try field_info.fieldValue(pt, 4));
+
+        const field_name = try sema.sliceToIpString(block, src, field_name_val, .{
+            .needed_comptime_reason = "tuple field name must be comptime-known",
+        });
+        const field_type = field_type_val.toType();
+        const field_default_value: InternPool.Index = if (field_default_value_val.optionalValue(zcu)) |ptr_val| d: {
+            const ptr_ty = try pt.singleConstPtrType(field_type_val.toType());
+            // We need to do this deref here, so we won't check for this error case later on.
+            const val = try sema.pointerDeref(block, src, ptr_val, ptr_ty) orelse return sema.failWithNeededComptime(
+                block,
+                src,
+                .{ .needed_comptime_reason = "tuple field default value must be comptime-known" },
+            );
+            // Resolve the value so that lazy values do not create distinct types.
+            break :d (try sema.resolveLazyValue(val)).toIntern();
+        } else .none;
+
+        const field_name_index = field_name.toUnsigned(ip) orelse return sema.fail(
+            block,
+            src,
+            "tuple cannot have non-numeric field '{}'",
+            .{field_name.fmt(ip)},
+        );
+        if (field_name_index != field_idx) {
+            return sema.fail(
+                block,
+                src,
+                "tuple field name '{}' does not match field index {}",
+                .{ field_name_index, field_idx },
+            );
+        }
+
+        try sema.validateTupleFieldType(block, field_type, src);
+
+        {
+            const alignment_ok = ok: {
+                if (field_alignment_val.toIntern() == .zero) break :ok true;
+                const given_align = try field_alignment_val.getUnsignedIntSema(pt) orelse break :ok false;
+                const abi_align = (try field_type.abiAlignmentSema(pt)).toByteUnits() orelse 0;
+                break :ok abi_align == given_align;
+            };
+            if (!alignment_ok) {
+                return sema.fail(block, src, "tuple fields cannot specify alignment", .{});
+            }
+        }
+
+        if (field_is_comptime_val.toBool() and field_default_value == .none) {
+            return sema.fail(block, src, "comptime field without default initialization value", .{});
+        }
+
+        if (!field_is_comptime_val.toBool() and field_default_value != .none) {
+            return sema.fail(block, src, "non-comptime tuple fields cannot specify default initialization value", .{});
+        }
+
+        const default_or_opv: InternPool.Index = default: {
+            if (field_default_value != .none) {
+                break :default field_default_value;
+            }
+            if (try sema.typeHasOnePossibleValue(field_type)) |opv| {
+                break :default opv.toIntern();
+            }
+            break :default .none;
+        };
+
+        field_ty.* = field_type.toIntern();
+        field_init.* = default_or_opv;
+    }
+
+    return Air.internedToRef(try zcu.intern_pool.getTupleType(gpa, pt.tid, .{
+        .types = types,
+        .values = inits,
+    }));
+}
+
 fn reifyStruct(
     sema: *Sema,
     block: *Block,
@@ -22651,7 +22958,6 @@ fn reifyStruct(
     opt_backing_int_val: Value,
     fields_val: Value,
     name_strategy: Zir.Inst.NameStrategy,
-    is_tuple: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
@@ -22671,7 +22977,6 @@ fn reifyStruct(
     var hasher = std.hash.Wyhash.init(0);
     std.hash.autoHash(&hasher, layout);
     std.hash.autoHash(&hasher, opt_backing_int_val.toIntern());
-    std.hash.autoHash(&hasher, is_tuple);
     std.hash.autoHash(&hasher, fields_len);
 
     var any_comptime_fields = false;
@@ -22727,7 +23032,6 @@ fn reifyStruct(
         .fields_len = fields_len,
         .known_non_opv = false,
         .requires_comptime = .unknown,
-        .is_tuple = is_tuple,
         .any_comptime_fields = any_comptime_fields,
         .any_default_inits = any_default_inits,
         .any_aligned_fields = any_aligned_fields,
@@ -22746,12 +23050,6 @@ fn reifyStruct(
     };
     errdefer wip_ty.cancel(ip, pt.tid);
 
-    if (is_tuple) switch (layout) {
-        .@"extern" => return sema.fail(block, src, "extern tuples are not supported", .{}),
-        .@"packed" => return sema.fail(block, src, "packed tuples are not supported", .{}),
-        .auto => {},
-    };
-
     wip_ty.setName(ip, try sema.createTypeName(
         block,
         name_strategy,
@@ -22774,22 +23072,7 @@ fn reifyStruct(
         const field_ty = field_type_val.toType();
         // Don't pass a reason; first loop acts as an assertion that this is valid.
         const field_name = try sema.sliceToIpString(block, src, field_name_val, undefined);
-        if (is_tuple) {
-            const field_name_index = field_name.toUnsigned(ip) orelse return sema.fail(
-                block,
-                src,
-                "tuple cannot have non-numeric field '{}'",
-                .{field_name.fmt(ip)},
-            );
-            if (field_name_index != field_idx) {
-                return sema.fail(
-                    block,
-                    src,
-                    "tuple field name '{}' does not match field index {}",
-                    .{ field_name_index, field_idx },
-                );
-            }
-        } else if (struct_type.addFieldName(ip, field_name)) |prev_index| {
+        if (struct_type.addFieldName(ip, field_name)) |prev_index| {
             _ = prev_index; // TODO: better source location
             return sema.fail(block, src, "duplicate struct field name {}", .{field_name.fmt(ip)});
         }
@@ -22919,6 +23202,7 @@ fn reifyStruct(
     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.
         try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     try sema.declareDependency(.{ .interned = wip_ty.index });
@@ -25524,7 +25808,7 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const args = try sema.resolveInst(extra.args);
 
     const args_ty = sema.typeOf(args);
-    if (!args_ty.isTuple(zcu) and args_ty.toIntern() != .empty_struct_type) {
+    if (!args_ty.isTuple(zcu)) {
         return sema.fail(block, args_src, "expected a tuple, found '{}'", .{args_ty.fmt(pt)});
     }
 
@@ -26510,6 +26794,7 @@ fn zirVarExtended(
             .is_const = small.is_const,
             .is_threadlocal = small.is_threadlocal,
             .is_weak_linkage = false,
+            .is_dll_import = false,
             .alignment = alignment,
             .@"addrspace" = @"addrspace",
             .zir_index = sema.getOwnerCauDeclInst(), // `declaration` instruction
@@ -26533,6 +26818,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
 
     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 extra = sema.code.extraData(Zir.Inst.FuncFancy, inst_data.payload_index);
     const target = zcu.getTarget();
@@ -26572,9 +26858,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         if (val.isGenericPoison()) {
             break :blk null;
         }
-        const alignment = try sema.validateAlignAllowZero(block, align_src, try val.toUnsignedIntSema(pt));
-        const default = target_util.defaultFunctionAlignment(target);
-        break :blk if (alignment == default) .none else alignment;
+        break :blk try sema.validateAlignAllowZero(block, align_src, try val.toUnsignedIntSema(pt));
     } else if (extra.data.bits.has_align_ref) blk: {
         const align_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
         extra_index += 1;
@@ -26592,9 +26876,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
             error.GenericPoison => break :blk null,
             else => |e| return e,
         };
-        const alignment = try sema.validateAlignAllowZero(block, align_src, try align_val.toUnsignedIntSema(pt));
-        const default = target_util.defaultFunctionAlignment(target);
-        break :blk if (alignment == default) .none else alignment;
+        break :blk try sema.validateAlignAllowZero(block, align_src, try align_val.toUnsignedIntSema(pt));
     } else .none;
 
     const @"addrspace": ?std.builtin.AddressSpace = if (extra.data.bits.has_addrspace_body) blk: {
@@ -26675,7 +26957,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         if (val.isGenericPoison()) {
             break :blk null;
         }
-        break :blk zcu.toEnum(std.builtin.CallingConvention, val);
+        break :blk try sema.analyzeValueAsCallconv(block, cc_src, val);
     } else if (extra.data.bits.has_cc_ref) blk: {
         const cc_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
         extra_index += 1;
@@ -26694,7 +26976,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
             error.GenericPoison => break :blk null,
             else => |e| return e,
         };
-        break :blk zcu.toEnum(std.builtin.CallingConvention, cc_val);
+        break :blk try sema.analyzeValueAsCallconv(block, cc_src, cc_val);
     } else cc: {
         if (has_body) {
             const decl_inst = if (sema.generic_owner != .none) decl_inst: {
@@ -26707,10 +26989,24 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
 
             const zir_decl = sema.code.getDeclaration(decl_inst.resolve(&zcu.intern_pool) orelse return error.AnalysisFail)[0];
             if (zir_decl.flags.is_export) {
-                break :cc .C;
+                break :cc target.cCallingConvention() orelse {
+                    // This target has no default C calling convention. We sometimes trigger a similar
+                    // error by trying to evaluate `std.builtin.CallingConvention.c`, so for consistency,
+                    // let's eval that now and just get the transitive error. (It's guaranteed to error
+                    // because it does the exact `cCallingConvention` call we just did.)
+                    const cc_type = try sema.getBuiltinType("CallingConvention");
+                    _ = try sema.namespaceLookupVal(
+                        block,
+                        LazySrcLoc.unneeded,
+                        cc_type.getNamespaceIndex(zcu),
+                        try ip.getOrPutString(sema.gpa, pt.tid, "c", .no_embedded_nulls),
+                    );
+                    // The above should have errored.
+                    @panic("std.builtin is corrupt");
+                };
             }
         }
-        break :cc .Unspecified;
+        break :cc .auto;
     };
 
     const ret_ty: Type = if (extra.data.bits.has_ret_ty_body) blk: {
@@ -26727,12 +27023,14 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     } else if (extra.data.bits.has_ret_ty_ref) blk: {
         const ret_ty_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
         extra_index += 1;
-        const ret_ty_val = sema.resolveInstConst(block, ret_src, ret_ty_ref, .{
+        const ret_ty_air_ref = sema.resolveInst(ret_ty_ref) catch |err| switch (err) {
+            error.GenericPoison => break :blk Type.generic_poison,
+            else => |e| return e,
+        };
+        const ret_ty_val = sema.resolveConstDefinedValue(block, ret_src, ret_ty_air_ref, .{
             .needed_comptime_reason = "return type must be comptime-known",
         }) catch |err| switch (err) {
-            error.GenericPoison => {
-                break :blk Type.generic_poison;
-            },
+            error.GenericPoison => break :blk Type.generic_poison,
             else => |e| return e,
         };
         break :blk ret_ty_val.toType();
@@ -26963,6 +27261,7 @@ fn resolveExternOptions(
     library_name: InternPool.OptionalNullTerminatedString = .none,
     linkage: std.builtin.GlobalLinkage = .strong,
     is_thread_local: bool = false,
+    is_dll_import: bool = false,
 } {
     const pt = sema.pt;
     const zcu = pt.zcu;
@@ -26976,6 +27275,7 @@ fn resolveExternOptions(
     const library_src = block.src(.{ .init_field_library = src.offset.node_offset_builtin_call_arg.builtin_call_node });
     const linkage_src = block.src(.{ .init_field_linkage = src.offset.node_offset_builtin_call_arg.builtin_call_node });
     const thread_local_src = block.src(.{ .init_field_thread_local = src.offset.node_offset_builtin_call_arg.builtin_call_node });
+    const dll_import_src = block.src(.{ .init_field_dll_import = src.offset.node_offset_builtin_call_arg.builtin_call_node });
 
     const name_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "name", .no_embedded_nulls), name_src);
     const name = try sema.toConstString(block, name_src, name_ref, .{
@@ -27009,6 +27309,11 @@ fn resolveExternOptions(
         break :library_name library_name;
     } else null;
 
+    const is_dll_import_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "is_dll_import", .no_embedded_nulls), dll_import_src);
+    const is_dll_import_val = try sema.resolveConstDefinedValue(block, dll_import_src, is_dll_import_ref, .{
+        .needed_comptime_reason = "it must be comptime-known if the symbol is imported from a dll",
+    });
+
     if (name.len == 0) {
         return sema.fail(block, name_src, "extern symbol name cannot be empty", .{});
     }
@@ -27022,6 +27327,7 @@ fn resolveExternOptions(
         .library_name = try ip.getOrPutStringOpt(gpa, pt.tid, library_name, .no_embedded_nulls),
         .linkage = linkage,
         .is_thread_local = is_thread_local_val.toBool(),
+        .is_dll_import = is_dll_import_val.toBool(),
     };
 }
 
@@ -27067,6 +27373,7 @@ fn zirBuiltinExtern(
         .is_const = ptr_info.flags.is_const,
         .is_threadlocal = options.is_thread_local,
         .is_weak_linkage = options.linkage == .weak,
+        .is_dll_import = options.is_dll_import,
         .alignment = ptr_info.flags.alignment,
         .@"addrspace" = ptr_info.flags.address_space,
         // This instruction is just for source locations.
@@ -27137,9 +27444,15 @@ fn zirInComptime(
     return if (block.is_comptime) .bool_true else .bool_false;
 }
 
-fn zirBuiltinValue(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
+fn zirBuiltinValue(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
+    const zcu = pt.zcu;
+    const gpa = zcu.gpa;
+    const ip = &zcu.intern_pool;
+
+    const src = block.nodeOffset(@bitCast(extended.operand));
     const value: Zir.Inst.BuiltinValue = @enumFromInt(extended.small);
+
     const type_name = switch (value) {
         .atomic_order => "AtomicOrder",
         .atomic_rmw_op => "AtomicRmwOp",
@@ -27157,21 +27470,25 @@ fn zirBuiltinValue(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileErr
         // Values are handled here.
         .calling_convention_c => {
             const callconv_ty = try sema.getBuiltinType("CallingConvention");
-            comptime assert(@intFromEnum(std.builtin.CallingConvention.C) == 1);
-            const val = try pt.intern(.{ .enum_tag = .{
-                .ty = callconv_ty.toIntern(),
-                .int = .one_u8,
-            } });
-            return Air.internedToRef(val);
+            return try sema.namespaceLookupVal(
+                block,
+                src,
+                callconv_ty.getNamespaceIndex(zcu),
+                try ip.getOrPutString(gpa, pt.tid, "c", .no_embedded_nulls),
+            ) 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("CallingConvention");
-            comptime assert(@intFromEnum(std.builtin.CallingConvention.Inline) == 4);
-            const val = try pt.intern(.{ .enum_tag = .{
-                .ty = callconv_ty.toIntern(),
-                .int = .four_u8,
-            } });
-            return Air.internedToRef(val);
+            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(
+                    Type.u8,
+                    @intFromEnum(std.builtin.CallingConvention.@"inline"),
+                )).toIntern(),
+            );
+            return sema.coerce(block, callconv_ty, Air.internedToRef(inline_tag_val.toIntern()), src);
         },
     };
     const ty = try sema.getBuiltinType(type_name);
@@ -27358,7 +27675,7 @@ fn explainWhyTypeIsComptimeInner(
                     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", .{}),
+                    .@"inline" => try sema.errNote(src_loc, msg, "function has inline calling convention", .{}),
                     else => {},
                 }
                 if (Type.fromInterned(fn_info.return_type).comptimeOnly(zcu)) {
@@ -27383,7 +27700,7 @@ fn explainWhyTypeIsComptimeInner(
                 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.unwrap().?,
+                        .base_node_inst = struct_type.zir_index,
                         .offset = .{ .container_field_type = @intCast(i) },
                     };
 
@@ -27466,13 +27783,12 @@ fn validateExternType(
         },
         .@"fn" => {
             if (position != .other) return false;
-            const target = zcu.getTarget();
             // 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) == .Kernel and (target.cpu.arch == .nvptx or target.cpu.arch == .nvptx64)) {
+            if (ty.fnCallingConvention(zcu) == .nvptx_kernel) {
                 return true;
             }
-            return !target_util.fnCallConvAllowsZigTypes(target, ty.fnCallingConvention(zcu));
+            return !target_util.fnCallConvAllowsZigTypes(ty.fnCallingConvention(zcu));
         },
         .@"enum" => {
             return sema.validateExternType(ty.intTagType(zcu), position);
@@ -27552,9 +27868,9 @@ fn explainWhyTypeIsNotExtern(
                 return;
             }
             switch (ty.fnCallingConvention(zcu)) {
-                .Unspecified => 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", .{}),
+                .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,
             }
         },
@@ -28149,11 +28465,10 @@ fn fieldVal(
                     return Air.internedToRef(enum_val.toIntern());
                 },
                 .@"struct", .@"opaque" => {
-                    switch (child_type.toIntern()) {
-                        .empty_struct_type, .anyopaque_type => {}, // no namespace
-                        else => if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
+                    if (!child_type.isTuple(zcu) and child_type.toIntern() != .anyopaque_type) {
+                        if (try sema.namespaceLookupVal(block, src, child_type.getNamespaceIndex(zcu), field_name)) |inst| {
                             return inst;
-                        },
+                        }
                     }
                     return sema.failWithBadMemberAccess(block, child_type, src, field_name);
                 },
@@ -28701,9 +29016,6 @@ fn structFieldPtr(
         }
         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);
-    } else if (struct_ty.isAnonStruct(zcu)) {
-        const field_index = try sema.anonStructFieldIndex(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).?;
@@ -28711,7 +29023,7 @@ fn structFieldPtr(
     const 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, field_name_src, struct_ty, initializing);
+    return sema.structFieldPtrByIndex(block, src, struct_ptr, field_index, struct_ty);
 }
 
 fn structFieldPtrByIndex(
@@ -28720,16 +29032,11 @@ fn structFieldPtrByIndex(
     src: LazySrcLoc,
     struct_ptr: Air.Inst.Ref,
     field_index: u32,
-    field_src: LazySrcLoc,
     struct_ty: Type,
-    initializing: bool,
 ) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    if (struct_ty.isAnonStruct(zcu)) {
-        return sema.tupleFieldPtr(block, src, struct_ptr, field_src, field_index, initializing);
-    }
 
     if (try sema.resolveDefinedValue(block, src, struct_ptr)) |struct_ptr_val| {
         const val = try struct_ptr_val.ptrField(field_index, pt);
@@ -28822,8 +29129,6 @@ fn structFieldVal(
     switch (ip.indexToKey(struct_ty.toIntern())) {
         .struct_type => {
             const struct_type = ip.loadStructType(struct_ty.toIntern());
-            if (struct_type.isTuple(ip))
-                return sema.tupleFieldVal(block, src, struct_byval, field_name, field_name_src, 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);
@@ -28848,13 +29153,8 @@ fn structFieldVal(
             try field_ty.resolveLayout(pt);
             return block.addStructFieldVal(struct_byval, field_index, field_ty);
         },
-        .anon_struct_type => |anon_struct| {
-            if (anon_struct.names.len == 0) {
-                return sema.tupleFieldVal(block, src, struct_byval, field_name, field_name_src, struct_ty);
-            } else {
-                const field_index = try sema.anonStructFieldIndex(block, struct_ty, field_name, field_name_src);
-                return sema.tupleFieldValByIndex(block, src, struct_byval, field_index, struct_ty);
-            }
+        .tuple_type => {
+            return sema.tupleFieldVal(block, src, struct_byval, field_name, field_name_src, struct_ty);
         },
         else => unreachable,
     }
@@ -29732,6 +30032,7 @@ fn coerceExtra(
     if (dest_ty.isGenericPoison()) return inst;
     const pt = sema.pt;
     const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
     const dest_ty_src = inst_src; // TODO better source location
     try dest_ty.resolveFields(pt);
     const inst_ty = sema.typeOf(inst);
@@ -29999,39 +30300,7 @@ fn coerceExtra(
                     },
                     else => {},
                 },
-                .One => switch (Type.fromInterned(dest_info.child).zigTypeTag(zcu)) {
-                    .@"union" => {
-                        // pointer to anonymous struct to pointer to union
-                        if (inst_ty.isSinglePointer(zcu) and
-                            inst_ty.childType(zcu).isAnonStruct(zcu) and
-                            sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result))
-                        {
-                            return sema.coerceAnonStructToUnionPtrs(block, dest_ty, dest_ty_src, inst, inst_src);
-                        }
-                    },
-                    .@"struct" => {
-                        // pointer to anonymous struct to pointer to struct
-                        if (inst_ty.isSinglePointer(zcu) and
-                            inst_ty.childType(zcu).isAnonStruct(zcu) and
-                            sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result))
-                        {
-                            return sema.coerceAnonStructToStructPtrs(block, dest_ty, dest_ty_src, inst, inst_src) catch |err| switch (err) {
-                                error.NotCoercible => break :pointer,
-                                else => |e| return e,
-                            };
-                        }
-                    },
-                    .array => {
-                        // pointer to tuple to pointer to array
-                        if (inst_ty.isSinglePointer(zcu) and
-                            inst_ty.childType(zcu).isTuple(zcu) and
-                            sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result))
-                        {
-                            return sema.coerceTupleToArrayPtrs(block, dest_ty, dest_ty_src, inst, inst_src);
-                        }
-                    },
-                    else => {},
-                },
+                .One => {},
                 .Slice => to_slice: {
                     if (inst_ty.zigTypeTag(zcu) == .array) {
                         return sema.fail(
@@ -30280,11 +30549,6 @@ fn coerceExtra(
         },
         .@"union" => switch (inst_ty.zigTypeTag(zcu)) {
             .@"enum", .enum_literal => return sema.coerceEnumToUnion(block, dest_ty, dest_ty_src, inst, inst_src),
-            .@"struct" => {
-                if (inst_ty.isAnonStruct(zcu)) {
-                    return sema.coerceAnonStructToUnion(block, dest_ty, dest_ty_src, inst, inst_src);
-                }
-            },
             else => {},
         },
         .array => switch (inst_ty.zigTypeTag(zcu)) {
@@ -30314,9 +30578,6 @@ fn coerceExtra(
             },
             .vector => return sema.coerceArrayLike(block, dest_ty, dest_ty_src, inst, inst_src),
             .@"struct" => {
-                if (inst == .empty_struct) {
-                    return sema.arrayInitEmpty(block, inst_src, dest_ty);
-                }
                 if (inst_ty.isTuple(zcu)) {
                     return sema.coerceTupleToArray(block, dest_ty, dest_ty_src, inst, inst_src);
                 }
@@ -30333,10 +30594,7 @@ fn coerceExtra(
             else => {},
         },
         .@"struct" => blk: {
-            if (inst == .empty_struct) {
-                return sema.structInitEmpty(block, dest_ty, dest_ty_src, inst_src);
-            }
-            if (inst_ty.isTupleOrAnonStruct(zcu)) {
+            if (inst_ty.isTuple(zcu)) {
                 return sema.coerceTupleToStruct(block, dest_ty, inst, inst_src) catch |err| switch (err) {
                     error.NotCoercible => break :blk,
                     else => |e| return e,
@@ -30346,11 +30604,6 @@ fn coerceExtra(
         else => {},
     }
 
-    // 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);
-
     if (!opts.report_err) return error.NotCoercible;
 
     if (opts.is_ret and dest_ty.zigTypeTag(zcu) == .noreturn) {
@@ -30359,7 +30612,7 @@ fn coerceExtra(
             errdefer msg.destroy(sema.gpa);
 
             const ret_ty_src: LazySrcLoc = .{
-                .base_node_inst = sema.getOwnerFuncDeclInst(),
+                .base_node_inst = ip.getNav(zcu.funcInfo(sema.func_index).owner_nav).srcInst(ip),
                 .offset = .{ .node_offset_fn_type_ret_ty = 0 },
             };
             try sema.errNote(ret_ty_src, msg, "'noreturn' declared here", .{});
@@ -30368,6 +30621,11 @@ fn coerceExtra(
         return sema.failWithOwnedErrorMsg(block, msg);
     }
 
+    // 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);
+
     const msg = msg: {
         const msg = try sema.errMsg(inst_src, "expected type '{}', found '{}'", .{ dest_ty.fmt(pt), inst_ty.fmt(pt) });
         errdefer msg.destroy(sema.gpa);
@@ -30392,10 +30650,10 @@ fn coerceExtra(
 
         // Add notes about function return type
         if (opts.is_ret and
-            !zcu.test_functions.contains(zcu.funcInfo(sema.owner.unwrap().func).owner_nav))
+            !zcu.test_functions.contains(zcu.funcInfo(sema.func_index).owner_nav))
         {
             const ret_ty_src: LazySrcLoc = .{
-                .base_node_inst = sema.getOwnerFuncDeclInst(),
+                .base_node_inst = ip.getNav(zcu.funcInfo(sema.func_index).owner_nav).srcInst(ip),
                 .offset = .{ .node_offset_fn_type_ret_ty = 0 },
             };
             if (inst_ty.isError(zcu) and !dest_ty.isError(zcu)) {
@@ -31181,8 +31439,8 @@ fn coerceInMemoryAllowedFns(
             return InMemoryCoercionResult{ .fn_generic = dest_info.is_generic };
         }
 
-        if (dest_info.cc != src_info.cc) {
-            return InMemoryCoercionResult{ .fn_cc = .{
+        if (!callconvCoerceAllowed(target, src_info.cc, dest_info.cc)) {
+            return .{ .fn_cc = .{
                 .actual = src_info.cc,
                 .wanted = dest_info.cc,
             } };
@@ -31255,6 +31513,44 @@ fn coerceInMemoryAllowedFns(
     return .ok;
 }
 
+fn callconvCoerceAllowed(
+    target: std.Target,
+    src_cc: std.builtin.CallingConvention,
+    dest_cc: std.builtin.CallingConvention,
+) bool {
+    const Tag = std.builtin.CallingConvention.Tag;
+    if (@as(Tag, src_cc) != @as(Tag, dest_cc)) return false;
+
+    switch (src_cc) {
+        inline else => |src_data, tag| {
+            const dest_data = @field(dest_cc, @tagName(tag));
+            if (@TypeOf(src_data) != void) {
+                const default_stack_align = target.stackAlignment();
+                const src_stack_align = src_data.incoming_stack_alignment orelse default_stack_align;
+                const dest_stack_align = src_data.incoming_stack_alignment orelse default_stack_align;
+                if (dest_stack_align < src_stack_align) return false;
+            }
+            switch (@TypeOf(src_data)) {
+                void, std.builtin.CallingConvention.CommonOptions => {},
+                std.builtin.CallingConvention.X86RegparmOptions => {
+                    if (src_data.register_params != dest_data.register_params) return false;
+                },
+                std.builtin.CallingConvention.ArmInterruptOptions => {
+                    if (src_data.type != dest_data.type) return false;
+                },
+                std.builtin.CallingConvention.MipsInterruptOptions => {
+                    if (src_data.mode != dest_data.mode) return false;
+                },
+                std.builtin.CallingConvention.RiscvInterruptOptions => {
+                    if (src_data.mode != dest_data.mode) return false;
+                },
+                else => comptime unreachable,
+            }
+        },
+    }
+    return true;
+}
+
 fn coerceInMemoryAllowedPtrs(
     sema: *Sema,
     block: *Block,
@@ -32082,97 +32378,6 @@ fn coerceEnumToUnion(
     return sema.failWithOwnedErrorMsg(block, msg);
 }
 
-fn coerceAnonStructToUnion(
-    sema: *Sema,
-    block: *Block,
-    union_ty: Type,
-    union_ty_src: LazySrcLoc,
-    inst: Air.Inst.Ref,
-    inst_src: LazySrcLoc,
-) !Air.Inst.Ref {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-    const inst_ty = sema.typeOf(inst);
-    const field_info: union(enum) {
-        name: InternPool.NullTerminatedString,
-        count: usize,
-    } = switch (ip.indexToKey(inst_ty.toIntern())) {
-        .anon_struct_type => |anon_struct_type| if (anon_struct_type.names.len == 1)
-            .{ .name = anon_struct_type.names.get(ip)[0] }
-        else
-            .{ .count = anon_struct_type.names.len },
-        .struct_type => name: {
-            const field_names = ip.loadStructType(inst_ty.toIntern()).field_names.get(ip);
-            break :name if (field_names.len == 1)
-                .{ .name = field_names[0] }
-            else
-                .{ .count = field_names.len };
-        },
-        else => unreachable,
-    };
-    switch (field_info) {
-        .name => |field_name| {
-            const init = try sema.structFieldVal(block, inst_src, inst, field_name, inst_src, inst_ty);
-            return sema.unionInit(block, init, inst_src, union_ty, union_ty_src, field_name, inst_src);
-        },
-        .count => |field_count| {
-            assert(field_count != 1);
-            const msg = msg: {
-                const msg = if (field_count > 1) try sema.errMsg(
-                    inst_src,
-                    "cannot initialize multiple union fields at once; unions can only have one active field",
-                    .{},
-                ) else try sema.errMsg(
-                    inst_src,
-                    "union initializer must initialize one field",
-                    .{},
-                );
-                errdefer msg.destroy(sema.gpa);
-
-                // TODO add notes for where the anon struct was created to point out
-                // the extra fields.
-
-                try sema.addDeclaredHereNote(msg, union_ty);
-                break :msg msg;
-            };
-            return sema.failWithOwnedErrorMsg(block, msg);
-        },
-    }
-}
-
-fn coerceAnonStructToUnionPtrs(
-    sema: *Sema,
-    block: *Block,
-    ptr_union_ty: Type,
-    union_ty_src: LazySrcLoc,
-    ptr_anon_struct: Air.Inst.Ref,
-    anon_struct_src: LazySrcLoc,
-) !Air.Inst.Ref {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const union_ty = ptr_union_ty.childType(zcu);
-    const anon_struct = try sema.analyzeLoad(block, anon_struct_src, ptr_anon_struct, anon_struct_src);
-    const union_inst = try sema.coerceAnonStructToUnion(block, union_ty, union_ty_src, anon_struct, anon_struct_src);
-    return sema.analyzeRef(block, union_ty_src, union_inst);
-}
-
-fn coerceAnonStructToStructPtrs(
-    sema: *Sema,
-    block: *Block,
-    ptr_struct_ty: Type,
-    struct_ty_src: LazySrcLoc,
-    ptr_anon_struct: Air.Inst.Ref,
-    anon_struct_src: LazySrcLoc,
-) !Air.Inst.Ref {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const struct_ty = ptr_struct_ty.childType(zcu);
-    const anon_struct = try sema.analyzeLoad(block, anon_struct_src, ptr_anon_struct, anon_struct_src);
-    const struct_inst = try sema.coerceTupleToStruct(block, struct_ty, anon_struct, anon_struct_src);
-    return sema.analyzeRef(block, struct_ty_src, struct_inst);
-}
-
 /// If the lengths match, coerces element-wise.
 fn coerceArrayLike(
     sema: *Sema,
@@ -32404,7 +32609,7 @@ fn coerceTupleToStruct(
     try struct_ty.resolveFields(pt);
     try struct_ty.resolveStructFieldInits(pt);
 
-    if (struct_ty.isTupleOrAnonStruct(zcu)) {
+    if (struct_ty.isTuple(zcu)) {
         return sema.coerceTupleToTuple(block, struct_ty, inst, inst_src);
     }
 
@@ -32416,7 +32621,7 @@ fn coerceTupleToStruct(
     const inst_ty = sema.typeOf(inst);
     var runtime_src: ?LazySrcLoc = null;
     const field_count = switch (ip.indexToKey(inst_ty.toIntern())) {
-        .anon_struct_type => |anon_struct_type| anon_struct_type.types.len,
+        .tuple_type => |tuple| tuple.types.len,
         .struct_type => ip.loadStructType(inst_ty.toIntern()).field_types.len,
         else => unreachable,
     };
@@ -32431,7 +32636,7 @@ fn coerceTupleToStruct(
         const coerced = try sema.coerce(block, struct_field_ty, elem_ref, field_src);
         field_refs[struct_field_index] = coerced;
         if (struct_type.fieldIsComptime(ip, struct_field_index)) {
-            const init_val = (try sema.resolveValue(coerced)) orelse {
+            const init_val = try sema.resolveValue(coerced) orelse {
                 return sema.failWithNeededComptime(block, field_src, .{
                     .needed_comptime_reason = "value stored in comptime field must be comptime-known",
                 });
@@ -32510,8 +32715,7 @@ fn coerceTupleToTuple(
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const dest_field_count = switch (ip.indexToKey(tuple_ty.toIntern())) {
-        .anon_struct_type => |anon_struct_type| anon_struct_type.types.len,
-        .struct_type => ip.loadStructType(tuple_ty.toIntern()).field_types.len,
+        .tuple_type => |tuple_type| tuple_type.types.len,
         else => unreachable,
     };
     const field_vals = try sema.arena.alloc(InternPool.Index, dest_field_count);
@@ -32520,8 +32724,7 @@ fn coerceTupleToTuple(
 
     const inst_ty = sema.typeOf(inst);
     const src_field_count = switch (ip.indexToKey(inst_ty.toIntern())) {
-        .anon_struct_type => |anon_struct_type| anon_struct_type.types.len,
-        .struct_type => ip.loadStructType(inst_ty.toIntern()).field_types.len,
+        .tuple_type => |tuple_type| tuple_type.types.len,
         else => unreachable,
     };
     if (src_field_count > dest_field_count) return error.NotCoercible;
@@ -32530,24 +32733,19 @@ fn coerceTupleToTuple(
     for (0..dest_field_count) |field_index_usize| {
         const field_i: u32 = @intCast(field_index_usize);
         const field_src = inst_src; // TODO better source location
-        const field_name = inst_ty.structFieldName(field_index_usize, zcu).unwrap() orelse
-            try ip.getOrPutStringFmt(sema.gpa, pt.tid, "{d}", .{field_index_usize}, .no_embedded_nulls);
-
-        if (field_name.eqlSlice("len", ip))
-            return sema.fail(block, field_src, "cannot assign to 'len' field of tuple", .{});
 
         const field_ty = switch (ip.indexToKey(tuple_ty.toIntern())) {
-            .anon_struct_type => |anon_struct_type| anon_struct_type.types.get(ip)[field_index_usize],
+            .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())) {
-            .anon_struct_type => |anon_struct_type| anon_struct_type.values.get(ip)[field_index_usize],
+            .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 = try sema.tupleFieldIndex(block, tuple_ty, field_name, field_src);
+        const field_index: u32 = @intCast(field_index_usize);
 
         const elem_ref = try sema.tupleField(block, inst_src, inst, field_src, field_i);
         const coerced = try sema.coerce(block, Type.fromInterned(field_ty), elem_ref, field_src);
@@ -32581,28 +32779,18 @@ fn coerceTupleToTuple(
         if (field_ref.* != .none) continue;
 
         const default_val = switch (ip.indexToKey(tuple_ty.toIntern())) {
-            .anon_struct_type => |anon_struct_type| anon_struct_type.values.get(ip)[i],
+            .tuple_type => |tuple_type| tuple_type.values.get(ip)[i],
             .struct_type => ip.loadStructType(tuple_ty.toIntern()).fieldInit(ip, i),
             else => unreachable,
         };
 
         const field_src = inst_src; // TODO better source location
         if (default_val == .none) {
-            const field_name = tuple_ty.structFieldName(i, zcu).unwrap() orelse {
-                const template = "missing tuple field: {d}";
-                if (root_msg) |msg| {
-                    try sema.errNote(field_src, msg, template, .{i});
-                } else {
-                    root_msg = try sema.errMsg(field_src, template, .{i});
-                }
-                continue;
-            };
-            const template = "missing struct field: {}";
-            const args = .{field_name.fmt(ip)};
+            const template = "missing tuple field: {d}";
             if (root_msg) |msg| {
-                try sema.errNote(field_src, msg, template, args);
+                try sema.errNote(field_src, msg, template, .{i});
             } else {
-                root_msg = try sema.errMsg(field_src, template, args);
+                root_msg = try sema.errMsg(field_src, template, .{i});
             }
             continue;
         }
@@ -34139,8 +34327,8 @@ const PeerResolveStrategy = enum {
     fixed_int,
     /// The type must be some fixed-width float type.
     fixed_float,
-    /// The type must be a struct literal or tuple type.
-    coercible_struct,
+    /// The type must be a tuple.
+    tuple,
     /// The peers must all be of the same type.
     exact,
 
@@ -34224,9 +34412,9 @@ const PeerResolveStrategy = enum {
                 .fixed_float => .{ .either, .fixed_float },
                 else => .{ .all_s1, s1 }, // doesn't override anything later
             },
-            .coercible_struct => switch (s1) {
+            .tuple => switch (s1) {
                 .exact => .{ .all_s1, .exact },
-                else => .{ .all_s0, .coercible_struct },
+                else => .{ .all_s0, .tuple },
             },
             .exact => .{ .all_s0, .exact },
         };
@@ -34267,7 +34455,7 @@ const PeerResolveStrategy = enum {
             .error_set => .error_set,
             .error_union => .error_union,
             .enum_literal, .@"enum", .@"union" => .enum_or_union,
-            .@"struct" => if (ty.isTupleOrAnonStruct(zcu)) .coercible_struct else .exact,
+            .@"struct" => if (ty.isTuple(zcu)) .tuple else .exact,
             .@"fn" => .func,
         };
     }
@@ -35375,19 +35563,17 @@ fn resolvePeerTypesInner(
             return .{ .success = opt_cur_ty.? };
         },
 
-        .coercible_struct => {
-            // First, check that every peer has the same approximate structure (field count and names)
+        .tuple => {
+            // First, check that every peer has the same approximate structure (field count)
 
             var opt_first_idx: ?usize = null;
             var is_tuple: bool = undefined;
             var field_count: usize = undefined;
-            // Only defined for non-tuples.
-            var field_names: []InternPool.NullTerminatedString = undefined;
 
             for (peer_tys, 0..) |opt_ty, i| {
                 const ty = opt_ty orelse continue;
 
-                if (!ty.isTupleOrAnonStruct(zcu)) {
+                if (!ty.isTuple(zcu)) {
                     return .{ .conflict = .{
                         .peer_idx_a = strat_reason,
                         .peer_idx_b = i,
@@ -35398,31 +35584,15 @@ fn resolvePeerTypesInner(
                     opt_first_idx = i;
                     is_tuple = ty.isTuple(zcu);
                     field_count = ty.structFieldCount(zcu);
-                    if (!is_tuple) {
-                        const names = ip.indexToKey(ty.toIntern()).anon_struct_type.names.get(ip);
-                        field_names = try sema.arena.dupe(InternPool.NullTerminatedString, names);
-                    }
                     continue;
                 };
 
-                if (ty.isTuple(zcu) != is_tuple or ty.structFieldCount(zcu) != field_count) {
+                if (ty.structFieldCount(zcu) != field_count) {
                     return .{ .conflict = .{
                         .peer_idx_a = first_idx,
                         .peer_idx_b = i,
                     } };
                 }
-
-                if (!is_tuple) {
-                    for (field_names, 0..) |expected, field_index_usize| {
-                        const field_index: u32 = @intCast(field_index_usize);
-                        const actual = ty.structFieldName(field_index, zcu).unwrap().?;
-                        if (actual == expected) continue;
-                        return .{ .conflict = .{
-                            .peer_idx_a = first_idx,
-                            .peer_idx_b = i,
-                        } };
-                    }
-                }
             }
 
             assert(opt_first_idx != null);
@@ -35452,10 +35622,7 @@ fn resolvePeerTypesInner(
                     else => |result| {
                         const result_buf = try sema.arena.create(PeerResolveResult);
                         result_buf.* = result;
-                        const field_name = if (is_tuple)
-                            try ip.getOrPutStringFmt(sema.gpa, pt.tid, "{d}", .{field_index}, .no_embedded_nulls)
-                        else
-                            field_names[field_index];
+                        const field_name = try ip.getOrPutStringFmt(sema.gpa, pt.tid, "{d}", .{field_index}, .no_embedded_nulls);
 
                         // The error info needs the field types, but we can't reuse sub_peer_tys
                         // since the recursive call may have clobbered it.
@@ -35510,9 +35677,8 @@ fn resolvePeerTypesInner(
                 field_val.* = if (comptime_val) |v| v.toIntern() else .none;
             }
 
-            const final_ty = try ip.getAnonStructType(zcu.gpa, pt.tid, .{
+            const final_ty = try ip.getTupleType(zcu.gpa, pt.tid, .{
                 .types = field_types,
-                .names = if (is_tuple) &.{} else field_names,
                 .values = field_vals,
             });
 
@@ -35652,7 +35818,7 @@ pub fn resolveStructAlignment(
     const ip = &zcu.intern_pool;
     const target = zcu.getTarget();
 
-    assert(sema.owner.unwrap().cau == struct_type.cau.unwrap().?);
+    assert(sema.owner.unwrap().cau == struct_type.cau);
 
     assert(struct_type.layout != .@"packed");
     assert(struct_type.flagsUnordered(ip).alignment == .none);
@@ -35695,7 +35861,7 @@ pub fn resolveStructLayout(sema: *Sema, ty: Type) SemaError!void {
     const ip = &zcu.intern_pool;
     const struct_type = zcu.typeToStruct(ty) orelse return;
 
-    assert(sema.owner.unwrap().cau == struct_type.cau.unwrap().?);
+    assert(sema.owner.unwrap().cau == struct_type.cau);
 
     if (struct_type.haveLayout(ip))
         return;
@@ -35795,12 +35961,14 @@ pub fn resolveStructLayout(sema: *Sema, ty: Type) SemaError!void {
                 return a_align.compare(.gt, b_align);
             }
         };
-        if (struct_type.isTuple(ip) or !zcu.backendSupportsFeature(.field_reordering)) {
-            // TODO: don't handle tuples differently. This logic exists only because it
-            // uncovers latent bugs if removed. Fix the latent bugs and remove this logic!
-            // Likewise, implement field reordering support in all the backends!
+        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 tuples.
+            // 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) {
@@ -35840,7 +36008,7 @@ fn backingIntType(
     const gpa = zcu.gpa;
     const ip = &zcu.intern_pool;
 
-    const cau_index = struct_type.cau.unwrap().?;
+    const cau_index = struct_type.cau;
 
     var analysis_arena = std.heap.ArenaAllocator.init(gpa);
     defer analysis_arena.deinit();
@@ -35852,7 +36020,7 @@ fn backingIntType(
         .instructions = .{},
         .inlining = null,
         .is_comptime = true,
-        .src_base_inst = struct_type.zir_index.unwrap().?,
+        .src_base_inst = struct_type.zir_index,
         .type_name_ctx = struct_type.name,
     };
     defer assert(block.instructions.items.len == 0);
@@ -35866,8 +36034,8 @@ fn backingIntType(
         break :blk accumulator;
     };
 
-    const zir = zcu.namespacePtr(struct_type.namespace.unwrap().?).fileScope(zcu).zir;
-    const zir_index = struct_type.zir_index.unwrap().?.resolve(ip) orelse return error.AnalysisFail;
+    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);
@@ -35888,7 +36056,7 @@ fn backingIntType(
         extra_index += 1;
 
         const backing_int_src: LazySrcLoc = .{
-            .base_node_inst = struct_type.zir_index.unwrap().?,
+            .base_node_inst = struct_type.zir_index,
             .offset = .{ .node_offset_container_tag = 0 },
         };
         const backing_int_ty = blk: {
@@ -36135,7 +36303,7 @@ pub fn resolveStructFully(sema: *Sema, ty: Type) SemaError!void {
     const ip = &zcu.intern_pool;
     const struct_type = zcu.typeToStruct(ty).?;
 
-    assert(sema.owner.unwrap().cau == struct_type.cau.unwrap().?);
+    assert(sema.owner.unwrap().cau == struct_type.cau);
 
     if (struct_type.setFullyResolved(ip)) return;
     errdefer struct_type.clearFullyResolved(ip);
@@ -36193,7 +36361,7 @@ pub fn resolveStructFieldTypes(
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
 
-    assert(sema.owner.unwrap().cau == struct_type.cau.unwrap().?);
+    assert(sema.owner.unwrap().cau == struct_type.cau);
 
     if (struct_type.haveFieldTypes(ip)) return;
 
@@ -36219,7 +36387,7 @@ pub fn resolveStructFieldInits(sema: *Sema, ty: Type) SemaError!void {
     const ip = &zcu.intern_pool;
     const struct_type = zcu.typeToStruct(ty) orelse return;
 
-    assert(sema.owner.unwrap().cau == struct_type.cau.unwrap().?);
+    assert(sema.owner.unwrap().cau == struct_type.cau);
 
     // Inits can start as resolved
     if (struct_type.haveFieldInits(ip)) return;
@@ -36311,7 +36479,7 @@ fn resolveInferredErrorSet(
     // 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);
+        assert(ies_func_info.cc == .@"inline");
     } else if (ip.errorUnionSet(ies_func_info.return_type) == ies_index) {
         if (ies_func_info.is_generic) {
             return sema.failWithOwnedErrorMsg(block, msg: {
@@ -36481,12 +36649,12 @@ fn structFields(
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
     const ip = &zcu.intern_pool;
-    const cau_index = struct_type.cau.unwrap().?;
+    const cau_index = struct_type.cau;
     const namespace_index = ip.getCau(cau_index).namespace;
     const zir = zcu.namespacePtr(namespace_index).fileScope(zcu).zir;
-    const zir_index = struct_type.zir_index.unwrap().?.resolve(ip) orelse return error.AnalysisFail;
+    const zir_index = struct_type.zir_index.resolve(ip) orelse return error.AnalysisFail;
 
-    const fields_len, const small, var extra_index = structZirInfo(zir, zir_index);
+    const fields_len, _, var extra_index = structZirInfo(zir, zir_index);
 
     if (fields_len == 0) switch (struct_type.layout) {
         .@"packed" => {
@@ -36506,7 +36674,7 @@ fn structFields(
         .instructions = .{},
         .inlining = null,
         .is_comptime = true,
-        .src_base_inst = struct_type.zir_index.unwrap().?,
+        .src_base_inst = struct_type.zir_index,
         .type_name_ctx = struct_type.name,
     };
     defer assert(block_scope.instructions.items.len == 0);
@@ -36547,12 +36715,8 @@ fn structFields(
 
             if (is_comptime) struct_type.setFieldComptime(ip, field_i);
 
-            var opt_field_name_zir: ?[:0]const u8 = null;
-            if (!small.is_tuple) {
-                opt_field_name_zir = zir.nullTerminatedString(@enumFromInt(zir.extra[extra_index]));
-                extra_index += 1;
-            }
-            extra_index += 1; // doc_comment
+            const field_name_zir: [:0]const u8 = zir.nullTerminatedString(@enumFromInt(zir.extra[extra_index]));
+            extra_index += 2; // field_name, doc_comment
 
             fields[field_i] = .{};
 
@@ -36564,10 +36728,8 @@ fn structFields(
             extra_index += 1;
 
             // This string needs to outlive the ZIR code.
-            if (opt_field_name_zir) |field_name_zir| {
-                const field_name = try ip.getOrPutString(gpa, pt.tid, field_name_zir, .no_embedded_nulls);
-                assert(struct_type.addFieldName(ip, field_name) == null);
-            }
+            const field_name = try ip.getOrPutString(gpa, 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];
@@ -36587,7 +36749,7 @@ fn structFields(
 
     for (fields, 0..) |zir_field, field_i| {
         const ty_src: LazySrcLoc = .{
-            .base_node_inst = struct_type.zir_index.unwrap().?,
+            .base_node_inst = struct_type.zir_index,
             .offset = .{ .container_field_type = @intCast(field_i) },
         };
         const field_ty: Type = ty: {
@@ -36659,7 +36821,7 @@ fn structFields(
             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.unwrap().?,
+                .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);
@@ -36686,11 +36848,11 @@ fn structFieldInits(
 
     assert(!struct_type.haveFieldInits(ip));
 
-    const cau_index = struct_type.cau.unwrap().?;
+    const cau_index = struct_type.cau;
     const namespace_index = ip.getCau(cau_index).namespace;
     const zir = zcu.namespacePtr(namespace_index).fileScope(zcu).zir;
-    const zir_index = struct_type.zir_index.unwrap().?.resolve(ip) orelse return error.AnalysisFail;
-    const fields_len, const small, var extra_index = structZirInfo(zir, zir_index);
+    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,
@@ -36699,7 +36861,7 @@ fn structFieldInits(
         .instructions = .{},
         .inlining = null,
         .is_comptime = true,
-        .src_base_inst = struct_type.zir_index.unwrap().?,
+        .src_base_inst = struct_type.zir_index,
         .type_name_ctx = struct_type.name,
     };
     defer assert(block_scope.instructions.items.len == 0);
@@ -36734,10 +36896,7 @@ fn structFieldInits(
             const has_type_body = @as(u1, @truncate(cur_bit_bag)) != 0;
             cur_bit_bag >>= 1;
 
-            if (!small.is_tuple) {
-                extra_index += 1;
-            }
-            extra_index += 1; // doc_comment
+            extra_index += 2; // field_name, doc_comment
 
             fields[field_i] = .{};
 
@@ -36775,7 +36934,7 @@ fn structFieldInits(
             sema.inst_map.putAssumeCapacity(zir_index, type_ref);
 
             const init_src: LazySrcLoc = .{
-                .base_node_inst = struct_type.zir_index.unwrap().?,
+                .base_node_inst = struct_type.zir_index,
                 .offset = .{ .container_field_value = @intCast(field_i) },
             };
 
@@ -37304,7 +37463,7 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
         .undefined_type => Value.undef,
         .optional_noreturn_type => try pt.nullValue(ty),
         .generic_poison_type => error.GenericPoison,
-        .empty_struct_type => Value.empty_struct,
+        .empty_tuple_type => Value.empty_tuple,
         // values, not types
         .undef,
         .zero,
@@ -37320,7 +37479,7 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
         .null_value,
         .bool_true,
         .bool_false,
-        .empty_struct,
+        .empty_tuple,
         .generic_poison,
         // invalid
         .none,
@@ -37406,10 +37565,9 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
             .type_enum_explicit,
             .type_enum_nonexhaustive,
             .type_struct,
-            .type_struct_anon,
             .type_struct_packed,
             .type_struct_packed_inits,
-            .type_tuple_anon,
+            .type_tuple,
             .type_union,
             => switch (ip.indexToKey(ty.toIntern())) {
                 inline .array_type, .vector_type => |seq_type, seq_tag| {
@@ -37468,7 +37626,7 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
                     } }));
                 },
 
-                .anon_struct_type => |tuple| {
+                .tuple_type => |tuple| {
                     for (tuple.values.get(ip)) |val| {
                         if (val == .none) return null;
                     }
@@ -37694,7 +37852,7 @@ pub fn analyzeAsAddressSpace(
         .gs, .fs, .ss => (arch == .x86 or arch == .x86_64) and ctx == .pointer,
         // TODO: check that .shared and .local are left uninitialized
         .param => is_nv,
-        .input, .output, .uniform => is_spirv,
+        .input, .output, .uniform, .push_constant, .storage_buffer => is_spirv,
         .global, .shared, .local => is_gpu,
         .constant => is_gpu and (ctx == .constant),
         // TODO this should also check how many flash banks the cpu has
@@ -37839,35 +37997,9 @@ fn structFieldIndex(
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     try struct_ty.resolveFields(pt);
-    if (struct_ty.isAnonStruct(zcu)) {
-        return sema.anonStructFieldIndex(block, struct_ty, field_name, field_src);
-    } else {
-        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);
-    }
-}
-
-fn anonStructFieldIndex(
-    sema: *Sema,
-    block: *Block,
-    struct_ty: Type,
-    field_name: InternPool.NullTerminatedString,
-    field_src: LazySrcLoc,
-) !u32 {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const ip = &zcu.intern_pool;
-    switch (ip.indexToKey(struct_ty.toIntern())) {
-        .anon_struct_type => |anon_struct_type| for (anon_struct_type.names.get(ip), 0..) |name, i| {
-            if (name == field_name) return @intCast(i);
-        },
-        .struct_type => if (ip.loadStructType(struct_ty.toIntern()).nameIndex(ip, field_name)) |i| return i,
-        else => unreachable,
-    }
-    return sema.fail(block, field_src, "no field named '{}' in anonymous struct '{}'", .{
-        field_name.fmt(ip), struct_ty.fmt(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);
 }
 
 /// If the value overflowed the type, returns a comptime_int (or vector thereof) instead, setting
diff --git a/zig/src/Sema/bitcast.zig b/zig/src/Sema/bitcast.zig
index 25955b113f..8fcc40c67c 100644
--- a/zig/src/Sema/bitcast.zig
+++ b/zig/src/Sema/bitcast.zig
@@ -246,7 +246,7 @@ const UnpackValueBits = struct {
             .error_union_type,
             .simple_type,
             .struct_type,
-            .anon_struct_type,
+            .tuple_type,
             .union_type,
             .opaque_type,
             .enum_type,
diff --git a/zig/src/ThreadSafeQueue.zig b/zig/src/ThreadSafeQueue.zig
new file mode 100644
index 0000000000..74bbdc418f
--- /dev/null
+++ b/zig/src/ThreadSafeQueue.zig
@@ -0,0 +1,72 @@
+const std = @import("std");
+const assert = std.debug.assert;
+const Allocator = std.mem.Allocator;
+
+pub fn ThreadSafeQueue(comptime T: type) type {
+    return struct {
+        worker_owned: std.ArrayListUnmanaged(T),
+        /// Protected by `mutex`.
+        shared: std.ArrayListUnmanaged(T),
+        mutex: std.Thread.Mutex,
+        state: State,
+
+        const Self = @This();
+
+        pub const State = enum { wait, run };
+
+        pub const empty: Self = .{
+            .worker_owned = .empty,
+            .shared = .empty,
+            .mutex = .{},
+            .state = .wait,
+        };
+
+        pub fn deinit(self: *Self, gpa: Allocator) void {
+            self.worker_owned.deinit(gpa);
+            self.shared.deinit(gpa);
+            self.* = undefined;
+        }
+
+        /// Must be called from the worker thread.
+        pub fn check(self: *Self) ?[]T {
+            assert(self.worker_owned.items.len == 0);
+            {
+                self.mutex.lock();
+                defer self.mutex.unlock();
+                assert(self.state == .run);
+                if (self.shared.items.len == 0) {
+                    self.state = .wait;
+                    return null;
+                }
+                std.mem.swap(std.ArrayListUnmanaged(T), &self.worker_owned, &self.shared);
+            }
+            const result = self.worker_owned.items;
+            self.worker_owned.clearRetainingCapacity();
+            return result;
+        }
+
+        /// Adds items to the queue, returning true if and only if the worker
+        /// thread is waiting. Thread-safe.
+        /// Not safe to call from the worker thread.
+        pub fn enqueue(self: *Self, gpa: Allocator, items: []const T) error{OutOfMemory}!bool {
+            self.mutex.lock();
+            defer self.mutex.unlock();
+            try self.shared.appendSlice(gpa, items);
+            return switch (self.state) {
+                .run => false,
+                .wait => {
+                    self.state = .run;
+                    return true;
+                },
+            };
+        }
+
+        /// Safe only to call exactly once when initially starting the worker.
+        pub fn start(self: *Self) bool {
+            assert(self.state == .wait);
+            if (self.shared.items.len == 0) return false;
+            self.state = .run;
+            return true;
+        }
+    };
+}
diff --git a/zig/src/Type.zig b/zig/src/Type.zig
index 808c8cfdb3..9548a4e5ef 100644
--- a/zig/src/Type.zig
+++ b/zig/src/Type.zig
@@ -39,6 +39,7 @@ pub fn baseZigTypeTag(self: Type, mod: *Zcu) std.builtin.TypeId {
     };
 }
 
+/// Asserts the type is resolved.
 pub fn isSelfComparable(ty: Type, zcu: *const Zcu, is_equality_cmp: bool) bool {
     return switch (ty.zigTypeTag(zcu)) {
         .int,
@@ -62,7 +63,6 @@ pub fn isSelfComparable(ty: Type, zcu: *const Zcu, is_equality_cmp: bool) bool {
 
         .noreturn,
         .array,
-        .@"struct",
         .undefined,
         .null,
         .error_union,
@@ -70,6 +70,7 @@ pub fn isSelfComparable(ty: Type, zcu: *const Zcu, is_equality_cmp: bool) bool {
         .frame,
         => false,
 
+        .@"struct" => is_equality_cmp and ty.containerLayout(zcu) == .@"packed",
         .pointer => !ty.isSlice(zcu) and (is_equality_cmp or ty.isCPtr(zcu)),
         .optional => {
             if (!is_equality_cmp) return false;
@@ -319,33 +320,20 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
         },
         .struct_type => {
             const name = ip.loadStructType(ty.toIntern()).name;
-            if (name == .empty) {
-                try writer.writeAll("@TypeOf(.{})");
-            } else {
-                try writer.print("{}", .{name.fmt(ip)});
-            }
+            try writer.print("{}", .{name.fmt(ip)});
         },
-        .anon_struct_type => |anon_struct| {
-            if (anon_struct.types.len == 0) {
+        .tuple_type => |tuple| {
+            if (tuple.types.len == 0) {
                 return writer.writeAll("@TypeOf(.{})");
             }
-            try writer.writeAll("struct{");
-            for (anon_struct.types.get(ip), anon_struct.values.get(ip), 0..) |field_ty, val, i| {
-                if (i != 0) try writer.writeAll(", ");
-                if (val != .none) {
-                    try writer.writeAll("comptime ");
-                }
-                if (anon_struct.names.len != 0) {
-                    try writer.print("{}: ", .{anon_struct.names.get(ip)[i].fmt(&zcu.intern_pool)});
-                }
-
+            try writer.writeAll("struct {");
+            for (tuple.types.get(ip), tuple.values.get(ip), 0..) |field_ty, val, i| {
+                try writer.writeAll(if (i == 0) " " else ", ");
+                if (val != .none) try writer.writeAll("comptime ");
                 try print(Type.fromInterned(field_ty), writer, pt);
-
-                if (val != .none) {
-                    try writer.print(" = {}", .{Value.fromInterned(val).fmtValue(pt)});
-                }
+                if (val != .none) try writer.print(" = {}", .{Value.fromInterned(val).fmtValue(pt)});
             }
-            try writer.writeAll("}");
+            try writer.writeAll(" }");
         },
 
         .union_type => {
@@ -389,10 +377,17 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
                 try writer.writeAll("...");
             }
             try writer.writeAll(") ");
-            if (fn_info.cc != .Unspecified) {
-                try writer.writeAll("callconv(.");
-                try writer.writeAll(@tagName(fn_info.cc));
-                try writer.writeAll(") ");
+            if (fn_info.cc != .auto) print_cc: {
+                if (zcu.getTarget().cCallingConvention()) |ccc| {
+                    if (fn_info.cc.eql(ccc)) {
+                        try writer.writeAll("callconv(.c) ");
+                        break :print_cc;
+                    }
+                }
+                switch (fn_info.cc) {
+                    .auto, .@"async", .naked, .@"inline" => try writer.print("callconv(.{}) ", .{std.zig.fmtId(@tagName(fn_info.cc))}),
+                    else => try writer.print("callconv({any}) ", .{fn_info.cc}),
+                }
             }
             if (fn_info.return_type == .generic_poison_type) {
                 try writer.writeAll("anytype");
@@ -481,8 +476,7 @@ pub fn hasRuntimeBitsInner(
 ) RuntimeBitsError!bool {
     const ip = &zcu.intern_pool;
     return switch (ty.toIntern()) {
-        // False because it is a comptime-only type.
-        .empty_struct_type => false,
+        .empty_tuple_type => false,
         else => switch (ip.indexToKey(ty.toIntern())) {
             .int_type => |int_type| int_type.bits != 0,
             .ptr_type => {
@@ -585,7 +579,7 @@ pub fn hasRuntimeBitsInner(
                     return false;
                 }
             },
-            .anon_struct_type => |tuple| {
+            .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(
@@ -683,7 +677,7 @@ pub fn hasWellDefinedLayout(ty: Type, zcu: *const Zcu) bool {
         .error_union_type,
         .error_set_type,
         .inferred_error_set_type,
-        .anon_struct_type,
+        .tuple_type,
         .opaque_type,
         .anyframe_type,
         // These are function bodies, not function pointers.
@@ -790,7 +784,7 @@ pub fn fnHasRuntimeBitsInner(
     const fn_info = zcu.typeToFunc(ty).?;
     if (fn_info.is_generic) return false;
     if (fn_info.is_var_args) return true;
-    if (fn_info.cc == .Inline) return false;
+    if (fn_info.cc == .@"inline") return false;
     return !try Type.fromInterned(fn_info.return_type).comptimeOnlyInner(strat, zcu, tid);
 }
 
@@ -958,7 +952,7 @@ pub fn abiAlignmentInner(
     const ip = &zcu.intern_pool;
 
     switch (ty.toIntern()) {
-        .empty_struct_type => return .{ .scalar = .@"1" },
+        .empty_tuple_type => return .{ .scalar = .@"1" },
         else => switch (ip.indexToKey(ty.toIntern())) {
             .int_type => |int_type| {
                 if (int_type.bits == 0) return .{ .scalar = .@"1" };
@@ -1019,7 +1013,7 @@ pub fn abiAlignmentInner(
             },
 
             // represents machine code; not a pointer
-            .func_type => return .{ .scalar = target_util.defaultFunctionAlignment(target) },
+            .func_type => return .{ .scalar = target_util.minFunctionAlignment(target) },
 
             .simple_type => |t| switch (t) {
                 .bool,
@@ -1101,7 +1095,7 @@ pub fn abiAlignmentInner(
 
                 return .{ .scalar = struct_type.flagsUnordered(ip).alignment };
             },
-            .anon_struct_type => |tuple| {
+            .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
@@ -1287,7 +1281,7 @@ pub fn abiSizeInner(
     const ip = &zcu.intern_pool;
 
     switch (ty.toIntern()) {
-        .empty_struct_type => return .{ .scalar = 0 },
+        .empty_tuple_type => return .{ .scalar = 0 },
 
         else => switch (ip.indexToKey(ty.toIntern())) {
             .int_type => |int_type| {
@@ -1490,7 +1484,7 @@ pub fn abiSizeInner(
                     },
                 }
             },
-            .anon_struct_type => |tuple| {
+            .tuple_type => |tuple| {
                 switch (strat) {
                     .sema => try ty.resolveLayout(strat.pt(zcu, tid)),
                     .lazy, .eager => {},
@@ -1823,8 +1817,7 @@ pub fn bitSizeInner(
             return (try ty.abiSizeInner(strat_lazy, zcu, tid)).scalar * 8;
         },
 
-        .anon_struct_type => {
-            if (strat == .sema) try ty.resolveFields(strat.pt(zcu, tid));
+        .tuple_type => {
             return (try ty.abiSizeInner(strat_lazy, zcu, tid)).scalar * 8;
         },
 
@@ -2168,7 +2161,7 @@ pub fn containerLayout(ty: Type, zcu: *const Zcu) std.builtin.Type.ContainerLayo
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
         .struct_type => ip.loadStructType(ty.toIntern()).layout,
-        .anon_struct_type => .auto,
+        .tuple_type => .auto,
         .union_type => ip.loadUnionType(ty.toIntern()).flagsUnordered(ip).layout,
         else => unreachable,
     };
@@ -2287,7 +2280,7 @@ pub fn arrayLenIncludingSentinel(ty: Type, zcu: *const Zcu) u64 {
 pub fn vectorLen(ty: Type, zcu: *const Zcu) u32 {
     return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
         .vector_type => |vector_type| vector_type.len,
-        .anon_struct_type => |tuple| @intCast(tuple.types.len),
+        .tuple_type => |tuple| @intCast(tuple.types.len),
         else => unreachable,
     };
 }
@@ -2297,7 +2290,7 @@ pub fn sentinel(ty: Type, zcu: *const Zcu) ?Value {
     return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
         .vector_type,
         .struct_type,
-        .anon_struct_type,
+        .tuple_type,
         => null,
 
         .array_type => |t| if (t.sentinel != .none) Value.fromInterned(t.sentinel) else null,
@@ -2378,7 +2371,7 @@ pub fn intInfo(starting_ty: Type, zcu: *const Zcu) InternPool.Key.IntType {
                 return .{ .signedness = .unsigned, .bits = zcu.errorSetBits() };
             },
 
-            .anon_struct_type => unreachable,
+            .tuple_type => unreachable,
 
             .ptr_type => unreachable,
             .anyframe_type => unreachable,
@@ -2548,7 +2541,7 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
     var ty = starting_type;
     const ip = &zcu.intern_pool;
     while (true) switch (ty.toIntern()) {
-        .empty_struct_type => return Value.empty_struct,
+        .empty_tuple_type => return Value.empty_tuple,
 
         else => switch (ip.indexToKey(ty.toIntern())) {
             .int_type => |int_type| {
@@ -2652,7 +2645,7 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
                 } }));
             },
 
-            .anon_struct_type => |tuple| {
+            .tuple_type => |tuple| {
                 for (tuple.values.get(ip)) |val| {
                     if (val == .none) return null;
                 }
@@ -2775,7 +2768,7 @@ pub fn comptimeOnlyInner(
 ) SemaError!bool {
     const ip = &zcu.intern_pool;
     return switch (ty.toIntern()) {
-        .empty_struct_type => false,
+        .empty_tuple_type => false,
 
         else => switch (ip.indexToKey(ty.toIntern())) {
             .int_type => false,
@@ -2883,7 +2876,7 @@ pub fn comptimeOnlyInner(
                 };
             },
 
-            .anon_struct_type => |tuple| {
+            .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;
@@ -3014,7 +3007,7 @@ pub fn getNamespace(ty: Type, zcu: *Zcu) InternPool.OptionalNamespaceIndex {
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
         .opaque_type => ip.loadOpaqueType(ty.toIntern()).namespace.toOptional(),
-        .struct_type => ip.loadStructType(ty.toIntern()).namespace,
+        .struct_type => ip.loadStructType(ty.toIntern()).namespace.toOptional(),
         .union_type => ip.loadUnionType(ty.toIntern()).namespace.toOptional(),
         .enum_type => ip.loadEnumType(ty.toIntern()).namespace.toOptional(),
         else => .none,
@@ -3173,7 +3166,7 @@ pub fn structFieldName(ty: Type, index: usize, zcu: *const Zcu) InternPool.Optio
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
         .struct_type => ip.loadStructType(ty.toIntern()).fieldName(ip, index),
-        .anon_struct_type => |anon_struct| anon_struct.fieldName(ip, index),
+        .tuple_type => .none,
         else => unreachable,
     };
 }
@@ -3182,7 +3175,7 @@ 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,
-        .anon_struct_type => |anon_struct| anon_struct.types.len,
+        .tuple_type => |tuple| tuple.types.len,
         else => unreachable,
     };
 }
@@ -3196,7 +3189,7 @@ pub fn fieldType(ty: Type, index: usize, zcu: *const Zcu) Type {
             const union_obj = ip.loadUnionType(ty.toIntern());
             return Type.fromInterned(union_obj.field_types.get(ip)[index]);
         },
-        .anon_struct_type => |anon_struct| Type.fromInterned(anon_struct.types.get(ip)[index]),
+        .tuple_type => |tuple| Type.fromInterned(tuple.types.get(ip)[index]),
         else => unreachable,
     };
 }
@@ -3230,8 +3223,8 @@ pub fn fieldAlignmentInner(
             const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[index]);
             return field_ty.structFieldAlignmentInner(explicit_align, struct_type.layout, strat, zcu, tid);
         },
-        .anon_struct_type => |anon_struct| {
-            return (try Type.fromInterned(anon_struct.types.get(ip)[index]).abiAlignmentInner(
+        .tuple_type => |tuple| {
+            return (try Type.fromInterned(tuple.types.get(ip)[index]).abiAlignmentInner(
                 strat.toLazy(),
                 zcu,
                 tid,
@@ -3353,8 +3346,8 @@ pub fn structFieldDefaultValue(ty: Type, index: usize, zcu: *const Zcu) Value {
             if (val == .none) return Value.@"unreachable";
             return Value.fromInterned(val);
         },
-        .anon_struct_type => |anon_struct| {
-            const val = anon_struct.values.get(ip)[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);
@@ -3376,7 +3369,7 @@ pub fn structFieldValueComptime(ty: Type, pt: Zcu.PerThread, index: usize) !?Val
                 return Type.fromInterned(struct_type.field_types.get(ip)[index]).onePossibleValue(pt);
             }
         },
-        .anon_struct_type => |tuple| {
+        .tuple_type => |tuple| {
             const val = tuple.values.get(ip)[index];
             if (val == .none) {
                 return Type.fromInterned(tuple.types.get(ip)[index]).onePossibleValue(pt);
@@ -3392,7 +3385,7 @@ 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),
-        .anon_struct_type => |anon_struct| anon_struct.values.get(ip)[index] != .none,
+        .tuple_type => |tuple| tuple.values.get(ip)[index] != .none,
         else => unreachable,
     };
 }
@@ -3417,7 +3410,7 @@ pub fn structFieldOffset(
             return struct_type.offsets.get(ip)[index];
         },
 
-        .anon_struct_type => |tuple| {
+        .tuple_type => |tuple| {
             var offset: u64 = 0;
             var big_align: Alignment = .none;
 
@@ -3464,7 +3457,6 @@ pub fn srcLocOrNull(ty: Type, zcu: *Zcu) ?Zcu.LazySrcLoc {
                 .declared => |d| d.zir_index,
                 .reified => |r| r.zir_index,
                 .generated_tag => |gt| ip.loadUnionType(gt.union_type).zir_index,
-                .empty_struct => return null,
             },
             else => return null,
         },
@@ -3483,49 +3475,7 @@ pub fn isGenericPoison(ty: Type) bool {
 pub fn isTuple(ty: Type, zcu: *const Zcu) bool {
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => {
-            const struct_type = ip.loadStructType(ty.toIntern());
-            if (struct_type.layout == .@"packed") return false;
-            if (struct_type.cau == .none) return false;
-            return struct_type.flagsUnordered(ip).is_tuple;
-        },
-        .anon_struct_type => |anon_struct| anon_struct.names.len == 0,
-        else => false,
-    };
-}
-
-pub fn isAnonStruct(ty: Type, zcu: *const Zcu) bool {
-    if (ty.toIntern() == .empty_struct_type) return true;
-    return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
-        .anon_struct_type => |anon_struct_type| anon_struct_type.names.len > 0,
-        else => false,
-    };
-}
-
-pub fn isTupleOrAnonStruct(ty: Type, zcu: *const Zcu) bool {
-    const ip = &zcu.intern_pool;
-    return switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => {
-            const struct_type = ip.loadStructType(ty.toIntern());
-            if (struct_type.layout == .@"packed") return false;
-            if (struct_type.cau == .none) return false;
-            return struct_type.flagsUnordered(ip).is_tuple;
-        },
-        .anon_struct_type => true,
-        else => false,
-    };
-}
-
-pub fn isSimpleTuple(ty: Type, zcu: *const Zcu) bool {
-    return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
-        .anon_struct_type => |anon_struct_type| anon_struct_type.names.len == 0,
-        else => false,
-    };
-}
-
-pub fn isSimpleTupleOrAnonStruct(ty: Type, zcu: *const Zcu) bool {
-    return switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
-        .anon_struct_type => true,
+        .tuple_type => true,
         else => false,
     };
 }
@@ -3556,7 +3506,7 @@ pub fn toUnsigned(ty: Type, pt: Zcu.PerThread) !Type {
 pub fn typeDeclInst(ty: Type, zcu: *const Zcu) ?InternPool.TrackedInst.Index {
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => ip.loadStructType(ty.toIntern()).zir_index.unwrap(),
+        .struct_type => ip.loadStructType(ty.toIntern()).zir_index,
         .union_type => ip.loadUnionType(ty.toIntern()).zir_index,
         .enum_type => ip.loadEnumType(ty.toIntern()).zir_index.unwrap(),
         .opaque_type => ip.loadOpaqueType(ty.toIntern()).zir_index,
@@ -3567,12 +3517,11 @@ pub fn typeDeclInst(ty: Type, zcu: *const Zcu) ?InternPool.TrackedInst.Index {
 pub fn typeDeclInstAllowGeneratedTag(ty: Type, zcu: *const Zcu) ?InternPool.TrackedInst.Index {
     const ip = &zcu.intern_pool;
     return switch (ip.indexToKey(ty.toIntern())) {
-        .struct_type => ip.loadStructType(ty.toIntern()).zir_index.unwrap(),
+        .struct_type => ip.loadStructType(ty.toIntern()).zir_index,
         .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,
-            .empty_struct => unreachable,
         },
         .opaque_type => ip.loadOpaqueType(ty.toIntern()).zir_index,
         else => null,
@@ -3580,13 +3529,16 @@ pub fn typeDeclInstAllowGeneratedTag(ty: Type, zcu: *const Zcu) ?InternPool.Trac
 }
 
 pub fn typeDeclSrcLine(ty: Type, zcu: *Zcu) ?u32 {
+    // 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 ip = &zcu.intern_pool;
     const tracked = switch (ip.indexToKey(ty.toIntern())) {
         .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,
-            .empty_struct => return null,
         },
         else => return null,
     };
@@ -3595,13 +3547,17 @@ pub fn typeDeclSrcLine(ty: Type, zcu: *Zcu) ?u32 {
     assert(file.zir_loaded);
     const zir = file.zir;
     const inst = zir.instructions.get(@intFromEnum(info.inst));
-    assert(inst.tag == .extended);
-    return 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,
-        .reify => zir.extraData(Zir.Inst.Reify, inst.data.extended.operand).data.src_line,
+    return switch (inst.tag) {
+        .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,
+            .reify => zir.extraData(Zir.Inst.Reify, inst.data.extended.operand).data.src_line,
+            else => unreachable,
+        },
         else => unreachable,
     };
 }
@@ -3689,8 +3645,8 @@ pub fn resolveLayout(ty: Type, pt: Zcu.PerThread) SemaError!void {
     const ip = &zcu.intern_pool;
     switch (ty.zigTypeTag(zcu)) {
         .@"struct" => switch (ip.indexToKey(ty.toIntern())) {
-            .anon_struct_type => |anon_struct_type| for (0..anon_struct_type.types.len) |i| {
-                const field_ty = Type.fromInterned(anon_struct_type.types.get(ip)[i]);
+            .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),
@@ -3788,7 +3744,7 @@ pub fn resolveFields(ty: Type, pt: Zcu.PerThread) SemaError!void {
         .optional_noreturn_type,
         .anyerror_void_error_union_type,
         .generic_poison_type,
-        .empty_struct_type,
+        .empty_tuple_type,
         => {},
 
         .undef => unreachable,
@@ -3805,7 +3761,7 @@ pub fn resolveFields(ty: Type, pt: Zcu.PerThread) SemaError!void {
         .null_value => unreachable,
         .bool_true => unreachable,
         .bool_false => unreachable,
-        .empty_struct => unreachable,
+        .empty_tuple => unreachable,
         .generic_poison => unreachable,
 
         else => switch (ty_ip.unwrap(ip).getTag(ip)) {
@@ -3860,8 +3816,8 @@ pub fn resolveFully(ty: Type, pt: Zcu.PerThread) SemaError!void {
         },
 
         .@"struct" => switch (ip.indexToKey(ty.toIntern())) {
-            .anon_struct_type => |anon_struct_type| for (0..anon_struct_type.types.len) |i| {
-                const field_ty = Type.fromInterned(anon_struct_type.types.get(ip)[i]);
+            .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),
@@ -3895,7 +3851,7 @@ fn resolveStructInner(
     const gpa = zcu.gpa;
 
     const struct_obj = zcu.typeToStruct(ty).?;
-    const owner = InternPool.AnalUnit.wrap(.{ .cau = struct_obj.cau.unwrap() orelse return });
+    const owner = InternPool.AnalUnit.wrap(.{ .cau = struct_obj.cau });
 
     if (zcu.failed_analysis.contains(owner) or zcu.transitive_failed_analysis.contains(owner)) {
         return error.AnalysisFail;
@@ -3907,7 +3863,7 @@ fn resolveStructInner(
     var comptime_err_ret_trace = std.ArrayList(Zcu.LazySrcLoc).init(gpa);
     defer comptime_err_ret_trace.deinit();
 
-    const zir = zcu.namespacePtr(struct_obj.namespace.unwrap().?).fileScope(zcu).zir;
+    const zir = zcu.namespacePtr(struct_obj.namespace).fileScope(zcu).zir;
     var sema: Sema = .{
         .pt = pt,
         .gpa = gpa,
@@ -4188,7 +4144,7 @@ pub const single_const_pointer_to_comptime_int: Type = .{
     .ip_index = .single_const_pointer_to_comptime_int_type,
 };
 pub const slice_const_u8_sentinel_0: Type = .{ .ip_index = .slice_const_u8_sentinel_0_type };
-pub const empty_struct_literal: Type = .{ .ip_index = .empty_struct_type };
+pub const empty_tuple_type: Type = .{ .ip_index = .empty_tuple_type };
 
 pub const generic_poison: Type = .{ .ip_index = .generic_poison_type };
 
diff --git a/zig/src/Value.zig b/zig/src/Value.zig
index 157f47bc7e..dd27aaced2 100644
--- a/zig/src/Value.zig
+++ b/zig/src/Value.zig
@@ -1340,11 +1340,11 @@ pub fn isLazySize(val: Value, zcu: *Zcu) bool {
     };
 }
 
-pub fn isPtrToThreadLocal(val: Value, zcu: *Zcu) bool {
+pub fn isPtrRuntimeValue(val: Value, zcu: *Zcu) bool {
     const ip = &zcu.intern_pool;
     const nav = ip.getBackingNav(val.toIntern()).unwrap() orelse return false;
     return switch (ip.indexToKey(ip.getNav(nav).status.resolved.val)) {
-        .@"extern" => |e| e.is_threadlocal,
+        .@"extern" => |e| e.is_threadlocal or e.is_dll_import,
         .variable => |v| v.is_threadlocal,
         else => false,
     };
@@ -3704,7 +3704,7 @@ pub const @"unreachable": Value = .{ .ip_index = .unreachable_value };
 
 pub const generic_poison: Value = .{ .ip_index = .generic_poison };
 pub const generic_poison_type: Value = .{ .ip_index = .generic_poison_type };
-pub const empty_struct: Value = .{ .ip_index = .empty_struct };
+pub const empty_tuple: Value = .{ .ip_index = .empty_tuple };
 
 pub fn makeBool(x: bool) Value {
     return if (x) Value.true else Value.false;
@@ -4490,3 +4490,159 @@ pub fn resolveLazy(
         else => return val,
     }
 }
+
+/// 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 ip = &zcu.intern_pool;
+    const ty = val.typeOf(zcu);
+    if (ty.zigTypeTag(zcu) != @typeInfo(T)) return error.TypeMismatch;
+    if (val.isUndef(zcu)) return error.UndefinedValue;
+
+    return switch (@typeInfo(T)) {
+        .type,
+        .noreturn,
+        .comptime_float,
+        .comptime_int,
+        .undefined,
+        .null,
+        .@"fn",
+        .@"opaque",
+        .enum_literal,
+        => comptime unreachable, // comptime-only or otherwise impossible
+
+        .pointer,
+        .array,
+        .error_union,
+        .error_set,
+        .frame,
+        .@"anyframe",
+        .vector,
+        => comptime unreachable, // unsupported
+
+        .void => {},
+
+        .bool => switch (val.toIntern()) {
+            .bool_false => false,
+            .bool_true => true,
+            else => unreachable,
+        },
+
+        .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.to(T) catch return error.TypeMismatch,
+        },
+
+        .float => val.toFloat(T, zcu),
+
+        .optional => |opt| if (val.optionalValue(zcu)) |unwrapped|
+            try unwrapped.interpret(opt.child, pt)
+        else
+            null,
+
+        .@"enum" => zcu.toEnum(T, val),
+
+        .@"union" => |@"union"| {
+            const union_obj = zcu.typeToUnion(ty) orelse return error.TypeMismatch;
+            if (union_obj.field_types.len != @"union".fields.len) return error.TypeMismatch;
+            const tag_val = val.unionTag(zcu) orelse return error.TypeMismatch;
+            const tag = try tag_val.interpret(@"union".tag_type.?, pt);
+            return switch (tag) {
+                inline else => |tag_comptime| @unionInit(
+                    T,
+                    @tagName(tag_comptime),
+                    try val.unionValue(zcu).interpret(@FieldType(T, @tagName(tag_comptime)), pt),
+                ),
+            };
+        },
+
+        .@"struct" => |@"struct"| {
+            if (ty.structFieldCount(zcu) != @"struct".fields.len) return error.TypeMismatch;
+            var result: T = undefined;
+            inline for (@"struct".fields, 0..) |field, field_idx| {
+                const field_val = try val.fieldValue(pt, field_idx);
+                @field(result, field.name) = try field_val.interpret(field.type, pt);
+            }
+            return result;
+        },
+    };
+}
+
+/// Given any `val` and a `Type` corresponding `@TypeOf(val)`, construct a `Value` representing it which can be used
+/// within the compilation. This is useful for passing `std.builtin` structures in the compiler back to the compilation.
+/// This is the inverse of `interpret`.
+pub fn uninterpret(val: anytype, ty: Type, pt: Zcu.PerThread) error{ OutOfMemory, TypeMismatch }!Value {
+    const T = @TypeOf(val);
+
+    const zcu = pt.zcu;
+    if (ty.zigTypeTag(zcu) != @typeInfo(T)) return error.TypeMismatch;
+
+    return switch (@typeInfo(T)) {
+        .type,
+        .noreturn,
+        .comptime_float,
+        .comptime_int,
+        .undefined,
+        .null,
+        .@"fn",
+        .@"opaque",
+        .enum_literal,
+        => comptime unreachable, // comptime-only or otherwise impossible
+
+        .pointer,
+        .array,
+        .error_union,
+        .error_set,
+        .frame,
+        .@"anyframe",
+        .vector,
+        => comptime unreachable, // unsupported
+
+        .void => .void,
+
+        .bool => if (val) .true else .false,
+
+        .int => try pt.intValue(ty, val),
+
+        .float => try pt.floatValue(ty, val),
+
+        .optional => if (val) |some|
+            .fromInterned(try pt.intern(.{ .opt = .{
+                .ty = ty.toIntern(),
+                .val = (try uninterpret(some, ty.optionalChild(zcu), pt)).toIntern(),
+            } }))
+        else
+            try pt.nullValue(ty),
+
+        .@"enum" => try pt.enumValue(ty, (try uninterpret(@intFromEnum(val), ty.intTagType(zcu), pt)).toIntern()),
+
+        .@"union" => |@"union"| {
+            const tag: @"union".tag_type.? = val;
+            const tag_val = try uninterpret(tag, ty.unionTagType(zcu).?, pt);
+            const field_ty = ty.unionFieldType(tag_val, zcu) orelse return error.TypeMismatch;
+            return switch (val) {
+                inline else => |payload| try pt.unionValue(
+                    ty,
+                    tag_val,
+                    try uninterpret(payload, field_ty, pt),
+                ),
+            };
+        },
+
+        .@"struct" => |@"struct"| {
+            if (ty.structFieldCount(zcu) != @"struct".fields.len) return error.TypeMismatch;
+            var field_vals: [@"struct".fields.len]InternPool.Index = undefined;
+            inline for (&field_vals, @"struct".fields, 0..) |*field_val, field, field_idx| {
+                const field_ty = ty.fieldType(field_idx, zcu);
+                field_val.* = (try uninterpret(@field(val, field.name), field_ty, pt)).toIntern();
+            }
+            return .fromInterned(try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = &field_vals },
+            } }));
+        },
+    };
+}
diff --git a/zig/src/Zcu.zig b/zig/src/Zcu.zig
index 641c7fc880..d03eb4cc9a 100644
--- a/zig/src/Zcu.zig
+++ b/zig/src/Zcu.zig
@@ -173,6 +173,10 @@ retryable_failures: std.ArrayListUnmanaged(AnalUnit) = .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: std.BoundedArray(*Package.Module, 3) = .{},
+/// 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).
+/// Allocated into `gpa`.
+resolved_references: ?std.AutoHashMapUnmanaged(AnalUnit, ?ResolvedReference) = null,
 
 stage1_flags: packed struct {
     have_winmain: bool = false,
@@ -420,13 +424,8 @@ pub const Namespace = struct {
 };
 
 pub const File = struct {
-    status: enum {
-        never_loaded,
-        retryable_failure,
-        parse_failure,
-        astgen_failure,
-        success_zir,
-    },
+    status: Status,
+    prev_status: Status,
     source_loaded: bool,
     tree_loaded: bool,
     zir_loaded: bool,
@@ -454,6 +453,14 @@ pub const File = struct {
     /// successful, this field is unloaded.
     prev_zir: ?*Zir = null,
 
+    pub const Status = enum {
+        never_loaded,
+        retryable_failure,
+        parse_failure,
+        astgen_failure,
+        success_zir,
+    };
+
     /// A single reference to a file.
     pub const Reference = union(enum) {
         /// The file is imported directly (i.e. not as a package) with @import.
@@ -1490,6 +1497,20 @@ pub const SrcLoc = struct {
                     }
                 } else unreachable;
             },
+            .tuple_field_type, .tuple_field_init => |field_info| {
+                const tree = try src_loc.file_scope.getTree(gpa);
+                const node = src_loc.relativeToNodeIndex(0);
+                var buf: [2]Ast.Node.Index = undefined;
+                const container_decl = tree.fullContainerDecl(&buf, node) orelse
+                    return tree.nodeToSpan(node);
+
+                const field = tree.fullContainerField(container_decl.ast.members[field_info.elem_index]).?;
+                return tree.nodeToSpan(switch (src_loc.lazy) {
+                    .tuple_field_type => field.ast.type_expr,
+                    .tuple_field_init => field.ast.value_expr,
+                    else => unreachable,
+                });
+            },
             .init_elem => |init_elem| {
                 const tree = try src_loc.file_scope.getTree(gpa);
                 const init_node = src_loc.relativeToNodeIndex(init_elem.init_node_offset);
@@ -1515,6 +1536,7 @@ pub const SrcLoc = struct {
             .init_field_cache,
             .init_field_library,
             .init_field_thread_local,
+            .init_field_dll_import,
             => |builtin_call_node| {
                 const wanted = switch (src_loc.lazy) {
                     .init_field_name => "name",
@@ -1526,6 +1548,7 @@ pub const SrcLoc = struct {
                     .init_field_cache => "cache",
                     .init_field_library => "library",
                     .init_field_thread_local => "thread_local",
+                    .init_field_dll_import => "dll_import",
                     else => unreachable,
                 };
                 const tree = try src_loc.file_scope.getTree(gpa);
@@ -1930,6 +1953,12 @@ pub const LazySrcLoc = struct {
         container_field_type: u32,
         /// Like `continer_field_name`, but points at the field's alignment.
         container_field_align: u32,
+        /// The source location points to the type of the field at the given index
+        /// of the tuple type declaration at `tuple_decl_node_offset`.
+        tuple_field_type: TupleField,
+        /// The source location points to the default init of the field at the given index
+        /// of the tuple type declaration at `tuple_decl_node_offset`.
+        tuple_field_init: TupleField,
         /// The source location points to the given element/field of a struct or
         /// array initialization expression.
         init_elem: struct {
@@ -1952,6 +1981,7 @@ pub const LazySrcLoc = struct {
         init_field_cache: i32,
         init_field_library: i32,
         init_field_thread_local: i32,
+        init_field_dll_import: i32,
         /// The source location points to the value of an item in a specific
         /// case of a `switch`.
         switch_case_item: SwitchItem,
@@ -2006,13 +2036,20 @@ pub const LazySrcLoc = struct {
             index: u31,
         };
 
-        const ArrayCat = struct {
+        pub const ArrayCat = struct {
             /// Points to the array concat AST node.
             array_cat_offset: i32,
             /// The index of the element the source location points to.
             elem_index: u32,
         };
 
+        pub const TupleField = struct {
+            /// Points to the AST node of the tuple type decaration.
+            tuple_decl_node_offset: i32,
+            /// The index of the tuple field the source location points to.
+            elem_index: u32,
+        };
+
         pub const nodeOffset = if (TracedOffset.want_tracing) nodeOffsetDebug else nodeOffsetRelease;
 
         noinline fn nodeOffsetDebug(node_offset: i32) Offset {
@@ -2042,6 +2079,8 @@ pub const LazySrcLoc = struct {
 
     /// Returns `null` if the ZIR instruction has been lost across incremental updates.
     pub fn resolveBaseNode(base_node_inst: InternPool.TrackedInst.Index, zcu: *Zcu) ?struct { *File, Ast.Node.Index } {
+        comptime assert(Zir.inst_tracking_version == 0);
+
         const ip = &zcu.intern_pool;
         const file_index, const zir_inst = inst: {
             const info = base_node_inst.resolveFull(ip) orelse return null;
@@ -2054,6 +2093,8 @@ pub const LazySrcLoc = struct {
         const inst = zir.instructions.get(@intFromEnum(zir_inst));
         const base_node: Ast.Node.Index = switch (inst.tag) {
             .declaration => inst.data.declaration.src_node,
+            .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,
@@ -2192,6 +2233,8 @@ pub fn deinit(zcu: *Zcu) void {
     zcu.all_type_references.deinit(gpa);
     zcu.free_type_references.deinit(gpa);
 
+    if (zcu.resolved_references) |*r| r.deinit(gpa);
+
     zcu.intern_pool.deinit(gpa);
 }
 
@@ -2760,6 +2803,8 @@ pub fn deleteUnitExports(zcu: *Zcu, anal_unit: AnalUnit) void {
 pub fn deleteUnitReferences(zcu: *Zcu, anal_unit: AnalUnit) void {
     const gpa = zcu.gpa;
 
+    zcu.clearCachedResolvedReferences();
+
     unit_refs: {
         const kv = zcu.reference_table.fetchSwapRemove(anal_unit) orelse break :unit_refs;
         var idx = kv.value;
@@ -2792,6 +2837,8 @@ pub fn deleteUnitReferences(zcu: *Zcu, anal_unit: AnalUnit) void {
 pub fn addUnitReference(zcu: *Zcu, src_unit: AnalUnit, referenced_unit: AnalUnit, ref_src: LazySrcLoc) Allocator.Error!void {
     const gpa = zcu.gpa;
 
+    zcu.clearCachedResolvedReferences();
+
     try zcu.reference_table.ensureUnusedCapacity(gpa, 1);
 
     const ref_idx = zcu.free_references.popOrNull() orelse idx: {
@@ -2815,6 +2862,8 @@ pub fn addUnitReference(zcu: *Zcu, src_unit: AnalUnit, referenced_unit: AnalUnit
 pub fn addTypeReference(zcu: *Zcu, src_unit: AnalUnit, referenced_type: InternPool.Index, ref_src: LazySrcLoc) Allocator.Error!void {
     const gpa = zcu.gpa;
 
+    zcu.clearCachedResolvedReferences();
+
     try zcu.type_reference_table.ensureUnusedCapacity(gpa, 1);
 
     const ref_idx = zcu.free_type_references.popOrNull() orelse idx: {
@@ -2835,6 +2884,11 @@ pub fn addTypeReference(zcu: *Zcu, src_unit: AnalUnit, referenced_type: InternPo
     gop.value_ptr.* = @intCast(ref_idx);
 }
 
+fn clearCachedResolvedReferences(zcu: *Zcu) void {
+    if (zcu.resolved_references) |*r| r.deinit(zcu.gpa);
+    zcu.resolved_references = null;
+}
+
 pub fn errorSetBits(zcu: *const Zcu) u16 {
     if (zcu.error_limit == 0) return 0;
     return @as(u16, std.math.log2_int(ErrorInt, zcu.error_limit)) + 1;
@@ -3138,7 +3192,15 @@ pub const ResolvedReference = struct {
 /// Returns a mapping from an `AnalUnit` to where it is referenced.
 /// If the value is `null`, the `AnalUnit` is a root of analysis.
 /// If an `AnalUnit` is not in the returned map, it is unreferenced.
-pub fn resolveReferences(zcu: *Zcu) !std.AutoHashMapUnmanaged(AnalUnit, ?ResolvedReference) {
+/// 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.AutoHashMapUnmanaged(AnalUnit, ?ResolvedReference) {
+    if (zcu.resolved_references == null) {
+        zcu.resolved_references = try zcu.resolveReferencesInner();
+    }
+    return &zcu.resolved_references.?;
+}
+fn resolveReferencesInner(zcu: *Zcu) !std.AutoHashMapUnmanaged(AnalUnit, ?ResolvedReference) {
     const gpa = zcu.gpa;
     const comp = zcu.comp;
     const ip = &zcu.intern_pool;
@@ -3184,7 +3246,7 @@ pub fn resolveReferences(zcu: *Zcu) !std.AutoHashMapUnmanaged(AnalUnit, ?Resolve
 
             // If this type has a `Cau` for resolution, it's automatically referenced.
             const resolution_cau: InternPool.Cau.Index.Optional = switch (ip.indexToKey(ty)) {
-                .struct_type => ip.loadStructType(ty).cau,
+                .struct_type => ip.loadStructType(ty).cau.toOptional(),
                 .union_type => ip.loadUnionType(ty).cau.toOptional(),
                 .enum_type => ip.loadEnumType(ty).cau,
                 .opaque_type => .none,
@@ -3449,6 +3511,10 @@ fn formatDependee(data: struct { dependee: InternPool.Dependee, zcu: *Zcu }, com
     const zcu = data.zcu;
     const ip = &zcu.intern_pool;
     switch (data.dependee) {
+        .file => |file| {
+            const file_path = zcu.fileByIndex(file).sub_file_path;
+            return writer.print("file('{s}')", .{file_path});
+        },
         .src_hash => |ti| {
             const info = ti.resolveFull(ip) orelse {
                 return writer.writeAll("inst(<lost>)");
@@ -3507,3 +3573,131 @@ pub fn maybeUnresolveIes(zcu: *Zcu, func_index: InternPool.Index) !void {
         zcu.intern_pool.funcSetIesResolved(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
+    bad_backend: std.builtin.CompilerBackend, // value is current backend
+} {
+    const target = zcu.getTarget();
+    const backend = target_util.zigBackend(target, zcu.comp.config.use_llvm);
+    switch (cc) {
+        .auto, .@"inline" => return .ok,
+        .@"async" => return .{ .bad_backend = backend }, // nothing supports async currently
+        .naked => {}, // depends only on backend
+        else => for (cc.archs()) |allowed_arch| {
+            if (allowed_arch == target.cpu.arch) break;
+        } else return .{ .bad_arch = cc.archs() },
+    }
+    const backend_ok = switch (backend) {
+        .stage1 => unreachable,
+        .other => unreachable,
+        _ => unreachable,
+
+        .stage2_llvm => @import("codegen/llvm.zig").toLlvmCallConv(cc, target) != null,
+        .stage2_c => ok: {
+            if (target.cCallingConvention()) |default_c| {
+                if (cc.eql(default_c)) {
+                    break :ok true;
+                }
+            }
+            break :ok switch (cc) {
+                .x86_64_sysv,
+                .x86_64_win,
+                .x86_64_vectorcall,
+                .x86_64_regcall_v3_sysv,
+                .x86_64_regcall_v4_win,
+                .x86_64_interrupt,
+                .x86_fastcall,
+                .x86_thiscall,
+                .x86_vectorcall,
+                .x86_regcall_v3,
+                .x86_regcall_v4_win,
+                .x86_interrupt,
+                .aarch64_vfabi,
+                .aarch64_vfabi_sve,
+                .arm_aapcs,
+                .csky_interrupt,
+                .riscv64_lp64_v,
+                .riscv32_ilp32_v,
+                .m68k_rtd,
+                .m68k_interrupt,
+                => |opts| opts.incoming_stack_alignment == null,
+
+                .arm_aapcs_vfp,
+                => |opts| opts.incoming_stack_alignment == null and target.os.tag != .watchos,
+                .arm_aapcs16_vfp,
+                => |opts| opts.incoming_stack_alignment == null and target.os.tag == .watchos,
+
+                .arm_interrupt,
+                => |opts| opts.incoming_stack_alignment == null,
+
+                .mips_interrupt,
+                .mips64_interrupt,
+                => |opts| opts.incoming_stack_alignment == null,
+
+                .riscv32_interrupt,
+                .riscv64_interrupt,
+                => |opts| opts.incoming_stack_alignment == null,
+
+                .x86_sysv,
+                .x86_win,
+                .x86_stdcall,
+                => |opts| opts.incoming_stack_alignment == null and opts.register_params == 0,
+
+                .avr_interrupt,
+                .avr_signal,
+                => true,
+
+                .naked => true,
+
+                else => false,
+            };
+        },
+        .stage2_wasm => switch (cc) {
+            .wasm_watc => |opts| opts.incoming_stack_alignment == null,
+            else => false,
+        },
+        .stage2_arm => switch (cc) {
+            .arm_aapcs => |opts| opts.incoming_stack_alignment == null,
+            .naked => true,
+            else => false,
+        },
+        .stage2_x86_64 => switch (cc) {
+            .x86_64_sysv, .x86_64_win, .naked => true, // incoming stack alignment supported
+            else => false,
+        },
+        .stage2_aarch64 => switch (cc) {
+            .aarch64_aapcs,
+            .aarch64_aapcs_darwin,
+            .aarch64_aapcs_win,
+            => |opts| opts.incoming_stack_alignment == null,
+            .naked => true,
+            else => false,
+        },
+        .stage2_x86 => switch (cc) {
+            .x86_sysv,
+            .x86_win,
+            => |opts| opts.incoming_stack_alignment == null and opts.register_params == 0,
+            .naked => true,
+            else => false,
+        },
+        .stage2_riscv64 => switch (cc) {
+            .riscv64_lp64 => |opts| opts.incoming_stack_alignment == null,
+            .naked => true,
+            else => false,
+        },
+        .stage2_sparc64 => switch (cc) {
+            .sparc64_sysv => |opts| opts.incoming_stack_alignment == null,
+            .naked => true,
+            else => false,
+        },
+        .stage2_spirv64 => switch (cc) {
+            .spirv_device, .spirv_kernel => true,
+            .spirv_fragment, .spirv_vertex => target.os.tag == .vulkan,
+            else => false,
+        },
+    };
+    if (!backend_ok) return .{ .bad_backend = backend };
+    return .ok;
+}
diff --git a/zig/src/Zcu/PerThread.zig b/zig/src/Zcu/PerThread.zig
index 8cc72dc4d9..29b9716152 100644
--- a/zig/src/Zcu/PerThread.zig
+++ b/zig/src/Zcu/PerThread.zig
@@ -179,10 +179,10 @@ pub fn astGenFile(
                 .inode = header.stat_inode,
                 .mtime = header.stat_mtime,
             };
+            file.prev_status = file.status;
             file.status = .success_zir;
             log.debug("AstGen cached success: {s}", .{file.sub_file_path});
 
-            // TODO don't report compile errors until Sema @importFile
             if (file.zir.hasCompileErrors()) {
                 {
                     comp.mutex.lock();
@@ -258,6 +258,7 @@ pub fn astGenFile(
     // Any potential AST errors are converted to ZIR errors here.
     file.zir = try AstGen.generate(gpa, file.tree);
     file.zir_loaded = true;
+    file.prev_status = file.status;
     file.status = .success_zir;
     log.debug("AstGen fresh success: {s}", .{file.sub_file_path});
 
@@ -350,6 +351,9 @@ pub fn updateZirRefs(pt: Zcu.PerThread) Allocator.Error!void {
     defer cleanupUpdatedFiles(gpa, &updated_files);
     for (zcu.import_table.values()) |file_index| {
         const file = zcu.fileByIndex(file_index);
+        if (file.prev_status != file.status and file.prev_status != .never_loaded) {
+            try zcu.markDependeeOutdated(.not_marked_po, .{ .file = file_index });
+        }
         const old_zir = file.prev_zir orelse continue;
         const new_zir = file.zir;
         const gop = try updated_files.getOrPut(gpa, file_index);
@@ -551,11 +555,13 @@ pub fn ensureCauAnalyzed(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) Zcu
     const cau_outdated = zcu.outdated.swapRemove(anal_unit) or
         zcu.potentially_outdated.swapRemove(anal_unit);
 
+    const prev_failed = zcu.failed_analysis.contains(anal_unit) or zcu.transitive_failed_analysis.contains(anal_unit);
+
     if (cau_outdated) {
         _ = zcu.outdated_ready.swapRemove(anal_unit);
     } else {
         // We can trust the current information about this `Cau`.
-        if (zcu.failed_analysis.contains(anal_unit) or zcu.transitive_failed_analysis.contains(anal_unit)) {
+        if (prev_failed) {
             return error.AnalysisFail;
         }
         // If it wasn't failed and wasn't marked outdated, then either...
@@ -578,9 +584,13 @@ pub fn ensureCauAnalyzed(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) Zcu
                 // Since it does not, this must be a transitive failure.
                 try zcu.transitive_failed_analysis.put(gpa, anal_unit, {});
             }
-            // We treat errors as up-to-date, since those uses would just trigger a transitive error.
-            // The exception is types, since type declarations may require re-analysis if the type, e.g. its captures, changed.
-            const outdated = cau.owner.unwrap() == .type;
+            // We consider this `Cau` to be outdated if:
+            // * Previous analysis succeeded; in this case, we need to re-analyze dependants to ensure
+            //   they hit a transitive error here, rather than reporting a different error later (which
+            //   may now be invalid).
+            // * The `Cau` is a type; in this case, the declaration site may require re-analysis to
+            //   construct a valid type.
+            const outdated = !prev_failed or cau.owner.unwrap() == .type;
             break :res .{ .{
                 .invalidate_decl_val = outdated,
                 .invalidate_decl_ref = outdated,
@@ -597,10 +607,9 @@ pub fn ensureCauAnalyzed(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) Zcu
             );
             zcu.retryable_failures.appendAssumeCapacity(anal_unit);
             zcu.failed_analysis.putAssumeCapacityNoClobber(anal_unit, msg);
-            // We treat errors as up-to-date, since those uses would just trigger a transitive error
             break :res .{ .{
-                .invalidate_decl_val = false,
-                .invalidate_decl_ref = false,
+                .invalidate_decl_val = true,
+                .invalidate_decl_ref = true,
             }, true };
         },
     };
@@ -707,11 +716,13 @@ pub fn ensureFuncBodyAnalyzed(pt: Zcu.PerThread, maybe_coerced_func_index: Inter
     const func_outdated = zcu.outdated.swapRemove(anal_unit) or
         zcu.potentially_outdated.swapRemove(anal_unit);
 
+    const prev_failed = zcu.failed_analysis.contains(anal_unit) or zcu.transitive_failed_analysis.contains(anal_unit);
+
     if (func_outdated) {
         _ = zcu.outdated_ready.swapRemove(anal_unit);
     } else {
         // We can trust the current information about this function.
-        if (zcu.failed_analysis.contains(anal_unit) or zcu.transitive_failed_analysis.contains(anal_unit)) {
+        if (prev_failed) {
             return error.AnalysisFail;
         }
         switch (func.analysisUnordered(ip).state) {
@@ -730,7 +741,10 @@ pub fn ensureFuncBodyAnalyzed(pt: Zcu.PerThread, maybe_coerced_func_index: Inter
                 // Since it does not, this must be a transitive failure.
                 try zcu.transitive_failed_analysis.put(gpa, anal_unit, {});
             }
-            break :res .{ false, true }; // we treat errors as up-to-date IES, since those uses would just trigger a transitive error
+            // We consider the IES to be outdated if the function previously succeeded analysis; in this case,
+            // we need to re-analyze dependants to ensure they hit a transitive error here, rather than reporting
+            // a different error later (which may now be invalid).
+            break :res .{ !prev_failed, true };
         },
         error.OutOfMemory => return error.OutOfMemory, // TODO: graceful handling like `ensureCauAnalyzed`
     };
@@ -831,6 +845,7 @@ fn ensureFuncBodyAnalyzedInner(
         return .{ .ies_outdated = ies_outdated };
     }
 
+    // This job depends on any resolve_type_fully jobs queued up before it.
     try comp.queueJob(.{ .codegen_func = .{
         .func = func_index,
         .air = air,
@@ -970,7 +985,6 @@ fn createFileRootStruct(
         .fields_len = fields_len,
         .known_non_opv = small.known_non_opv,
         .requires_comptime = if (small.known_comptime_only) .yes else .unknown,
-        .is_tuple = small.is_tuple,
         .any_comptime_fields = small.any_comptime_fields,
         .any_default_inits = small.any_default_inits,
         .inits_resolved = false,
@@ -1002,6 +1016,7 @@ fn createFileRootStruct(
     codegen_type: {
         if (zcu.comp.config.use_llvm) break :codegen_type;
         if (file.mod.strip) break :codegen_type;
+        // This job depends on any resolve_type_fully jobs queued up before it.
         try zcu.comp.queueJob(.{ .codegen_type = wip_ty.index });
     }
     zcu.setFileRootType(file_index, wip_ty.index);
@@ -1348,6 +1363,7 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {
             if (file.mod.strip) break :queue_codegen;
         }
 
+        // This job depends on any resolve_type_fully jobs queued up before it.
         try zcu.comp.queueJob(.{ .codegen_nav = nav_index });
     }
 
@@ -1445,6 +1461,7 @@ pub fn importPkg(pt: Zcu.PerThread, mod: *Module) !Zcu.ImportFileResult {
         .tree = undefined,
         .zir = undefined,
         .status = .never_loaded,
+        .prev_status = .never_loaded,
         .mod = mod,
     };
 
@@ -1555,6 +1572,7 @@ pub fn importFile(
         .tree = undefined,
         .zir = undefined,
         .status = .never_loaded,
+        .prev_status = .never_loaded,
         .mod = mod,
     };
 
@@ -2074,7 +2092,7 @@ fn analyzeFnBody(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaError!
         .code = zir,
         .owner = anal_unit,
         .func_index = func_index,
-        .func_is_naked = fn_ty_info.cc == .Naked,
+        .func_is_naked = fn_ty_info.cc == .naked,
         .fn_ret_ty = Type.fromInterned(fn_ty_info.return_type),
         .fn_ret_ty_ies = null,
         .branch_quota = @max(func.branchQuotaUnordered(ip), Sema.default_branch_quota),
@@ -2577,7 +2595,7 @@ pub fn populateTestFunctions(
     }
 }
 
-pub fn linkerUpdateNav(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) !void {
+pub fn linkerUpdateNav(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) error{OutOfMemory}!void {
     const zcu = pt.zcu;
     const comp = zcu.comp;
     const ip = &zcu.intern_pool;
@@ -2747,6 +2765,7 @@ pub fn getCoerced(pt: Zcu.PerThread, val: Value, new_ty: Type) Allocator.Error!V
                 .is_const = e.is_const,
                 .is_threadlocal = e.is_threadlocal,
                 .is_weak_linkage = e.is_weak_linkage,
+                .is_dll_import = e.is_dll_import,
                 .alignment = e.alignment,
                 .@"addrspace" = e.@"addrspace",
                 .zir_index = e.zir_index,
@@ -3146,6 +3165,7 @@ pub fn navPtrType(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) Allocator.
 pub fn getExtern(pt: Zcu.PerThread, key: InternPool.Key.Extern) Allocator.Error!InternPool.Index {
     const result = try pt.zcu.intern_pool.getExtern(pt.zcu.gpa, pt.tid, key);
     if (result.new_nav.unwrap()) |nav| {
+        // This job depends on any resolve_type_fully jobs queued up before it.
         try pt.zcu.comp.queueJob(.{ .codegen_nav = nav });
     }
     return result.index;
@@ -3170,7 +3190,7 @@ pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index, already_updat
         .struct_type => |key| {
             const struct_obj = ip.loadStructType(ty);
             const outdated = already_updating or o: {
-                const anal_unit = AnalUnit.wrap(.{ .cau = struct_obj.cau.unwrap().? });
+                const anal_unit = AnalUnit.wrap(.{ .cau = struct_obj.cau });
                 const o = zcu.outdated.swapRemove(anal_unit) or
                     zcu.potentially_outdated.swapRemove(anal_unit);
                 if (o) {
@@ -3231,7 +3251,6 @@ fn recreateStructType(
 
     const key = switch (full_key) {
         .reified => unreachable, // never outdated
-        .empty_struct => unreachable, // never outdated
         .generated_tag => unreachable, // not a struct
         .declared => |d| d,
     };
@@ -3262,16 +3281,13 @@ fn recreateStructType(
     if (captures_len != key.captures.owned.len) return error.AnalysisFail;
 
     // The old type will be unused, so drop its dependency information.
-    ip.removeDependenciesForDepender(gpa, AnalUnit.wrap(.{ .cau = struct_obj.cau.unwrap().? }));
-
-    const namespace_index = struct_obj.namespace.unwrap().?;
+    ip.removeDependenciesForDepender(gpa, AnalUnit.wrap(.{ .cau = struct_obj.cau }));
 
     const wip_ty = switch (try ip.getStructType(gpa, 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,
-        .is_tuple = small.is_tuple,
         .any_comptime_fields = small.any_comptime_fields,
         .any_default_inits = small.any_default_inits,
         .inits_resolved = false,
@@ -3287,17 +3303,17 @@ fn recreateStructType(
     errdefer wip_ty.cancel(ip, pt.tid);
 
     wip_ty.setName(ip, struct_obj.name);
-    const new_cau_index = try ip.createTypeCau(gpa, pt.tid, key.zir_index, namespace_index, wip_ty.index);
+    const new_cau_index = try ip.createTypeCau(gpa, pt.tid, key.zir_index, struct_obj.namespace, wip_ty.index);
     try ip.addDependency(
         gpa,
         AnalUnit.wrap(.{ .cau = new_cau_index }),
         .{ .src_hash = key.zir_index },
     );
-    zcu.namespacePtr(namespace_index).owner_type = wip_ty.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 });
 
-    const new_ty = wip_ty.finish(ip, new_cau_index.toOptional(), namespace_index);
+    const new_ty = wip_ty.finish(ip, new_cau_index.toOptional(), 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);
@@ -3316,7 +3332,6 @@ fn recreateUnionType(
 
     const key = switch (full_key) {
         .reified => unreachable, // never outdated
-        .empty_struct => unreachable, // never outdated
         .generated_tag => unreachable, // not a union
         .declared => |d| d,
     };
@@ -3408,9 +3423,7 @@ fn recreateEnumType(
     const ip = &zcu.intern_pool;
 
     const key = switch (full_key) {
-        .reified => unreachable, // never outdated
-        .empty_struct => unreachable, // never outdated
-        .generated_tag => unreachable, // never outdated
+        .reified, .generated_tag => unreachable, // never outdated
         .declared => |d| d,
     };
 
@@ -3554,7 +3567,7 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace
     };
 
     const key = switch (full_key) {
-        .reified, .empty_struct, .generated_tag => {
+        .reified, .generated_tag => {
             // Namespace always empty, so up-to-date.
             namespace.generation = zcu.generation;
             return;
diff --git a/zig/src/arch/aarch64/CodeGen.zig b/zig/src/arch/aarch64/CodeGen.zig
index 012de69bd1..6371cf92f3 100644
--- a/zig/src/arch/aarch64/CodeGen.zig
+++ b/zig/src/arch/aarch64/CodeGen.zig
@@ -468,7 +468,7 @@ fn gen(self: *Self) !void {
     const pt = self.pt;
     const zcu = pt.zcu;
     const cc = self.fn_type.fnCallingConvention(zcu);
-    if (cc != .Naked) {
+    if (cc != .naked) {
         // stp fp, lr, [sp, #-16]!
         _ = try self.addInst(.{
             .tag = .stp,
@@ -6229,14 +6229,14 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
     const ret_ty = fn_ty.fnReturnType(zcu);
 
     switch (cc) {
-        .Naked => {
+        .naked => {
             assert(result.args.len == 0);
             result.return_value = .{ .unreach = {} };
             result.stack_byte_count = 0;
             result.stack_align = 1;
             return result;
         },
-        .C => {
+        .aarch64_aapcs, .aarch64_aapcs_darwin, .aarch64_aapcs_win => {
             // ARM64 Procedure Call Standard
             var ncrn: usize = 0; // Next Core Register Number
             var nsaa: u32 = 0; // Next stacked argument address
@@ -6266,7 +6266,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
 
                 // We round up NCRN only for non-Apple platforms which allow the 16-byte aligned
                 // values to spread across odd-numbered registers.
-                if (Type.fromInterned(ty).abiAlignment(zcu) == .@"16" and !self.target.isDarwin()) {
+                if (Type.fromInterned(ty).abiAlignment(zcu) == .@"16" and cc != .aarch64_aapcs_darwin) {
                     // Round up NCRN to the next even number
                     ncrn += ncrn % 2;
                 }
@@ -6298,7 +6298,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
             result.stack_byte_count = nsaa;
             result.stack_align = 16;
         },
-        .Unspecified => {
+        .auto => {
             if (ret_ty.zigTypeTag(zcu) == .noreturn) {
                 result.return_value = .{ .unreach = {} };
             } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu) and !ret_ty.isError(zcu)) {
diff --git a/zig/src/arch/aarch64/Emit.zig b/zig/src/arch/aarch64/Emit.zig
index f6b6564f58..e053b42f41 100644
--- a/zig/src/arch/aarch64/Emit.zig
+++ b/zig/src/arch/aarch64/Emit.zig
@@ -942,7 +942,7 @@ fn mirLoadMemoryPie(emit: *Emit, inst: Mir.Inst.Index) !void {
             .load_memory_import => coff_file.getGlobalByIndex(data.sym_index),
             else => unreachable,
         };
-        try link.File.Coff.Atom.addRelocation(coff_file, atom_index, .{
+        try coff_file.addRelocation(atom_index, .{
             .target = target,
             .offset = offset,
             .addend = 0,
@@ -959,7 +959,7 @@ fn mirLoadMemoryPie(emit: *Emit, inst: Mir.Inst.Index) !void {
                 else => unreachable,
             },
         });
-        try link.File.Coff.Atom.addRelocation(coff_file, atom_index, .{
+        try coff_file.addRelocation(atom_index, .{
             .target = target,
             .offset = offset + 4,
             .addend = 0,
diff --git a/zig/src/arch/arm/CodeGen.zig b/zig/src/arch/arm/CodeGen.zig
index 1eb01f365a..9966648759 100644
--- a/zig/src/arch/arm/CodeGen.zig
+++ b/zig/src/arch/arm/CodeGen.zig
@@ -475,7 +475,7 @@ fn gen(self: *Self) !void {
     const pt = self.pt;
     const zcu = pt.zcu;
     const cc = self.fn_type.fnCallingConvention(zcu);
-    if (cc != .Naked) {
+    if (cc != .naked) {
         // push {fp, lr}
         const push_reloc = try self.addNop();
 
@@ -6196,14 +6196,14 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
     const ret_ty = fn_ty.fnReturnType(zcu);
 
     switch (cc) {
-        .Naked => {
+        .naked => {
             assert(result.args.len == 0);
             result.return_value = .{ .unreach = {} };
             result.stack_byte_count = 0;
             result.stack_align = 1;
             return result;
         },
-        .C => {
+        .arm_aapcs => {
             // ARM Procedure Call Standard, Chapter 6.5
             var ncrn: usize = 0; // Next Core Register Number
             var nsaa: u32 = 0; // Next stacked argument address
@@ -6254,7 +6254,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
             result.stack_byte_count = nsaa;
             result.stack_align = 8;
         },
-        .Unspecified => {
+        .auto => {
             if (ret_ty.zigTypeTag(zcu) == .noreturn) {
                 result.return_value = .{ .unreach = {} };
             } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(zcu) and !ret_ty.isError(zcu)) {
diff --git a/zig/src/arch/riscv64/CodeGen.zig b/zig/src/arch/riscv64/CodeGen.zig
index 7309160488..24497defa2 100644
--- a/zig/src/arch/riscv64/CodeGen.zig
+++ b/zig/src/arch/riscv64/CodeGen.zig
@@ -18,6 +18,7 @@ const Zcu = @import("../../Zcu.zig");
 const Package = @import("../../Package.zig");
 const InternPool = @import("../../InternPool.zig");
 const Compilation = @import("../../Compilation.zig");
+const target_util = @import("../../target.zig");
 const trace = @import("../../tracy.zig").trace;
 const codegen = @import("../../codegen.zig");
 
@@ -132,7 +133,7 @@ const Owner = union(enum) {
         switch (owner) {
             .nav_index => |nav_index| {
                 const elf_file = func.bin_file.cast(.elf).?;
-                return elf_file.zigObjectPtr().?.getOrCreateMetadataForNav(elf_file, nav_index);
+                return elf_file.zigObjectPtr().?.getOrCreateMetadataForNav(pt.zcu, nav_index);
             },
             .lazy_sym => |lazy_sym| {
                 const elf_file = func.bin_file.cast(.elf).?;
@@ -819,10 +820,7 @@ pub fn generate(
     try function.frame_allocs.resize(gpa, FrameIndex.named_count);
     function.frame_allocs.set(
         @intFromEnum(FrameIndex.stack_frame),
-        FrameAlloc.init(.{
-            .size = 0,
-            .alignment = func.analysisUnordered(ip).stack_alignment.max(.@"1"),
-        }),
+        FrameAlloc.init(.{ .size = 0, .alignment = .@"1" }),
     );
     function.frame_allocs.set(
         @intFromEnum(FrameIndex.call_frame),
@@ -977,7 +975,7 @@ pub fn generateLazy(
             .pt = pt,
             .allocator = gpa,
             .mir = mir,
-            .cc = .Unspecified,
+            .cc = .auto,
             .src_loc = src_loc,
             .output_mode = comp.config.output_mode,
             .link_mode = comp.config.link_mode,
@@ -1036,7 +1034,7 @@ fn formatWipMir(
             .instructions = data.func.mir_instructions.slice(),
             .frame_locs = data.func.frame_locs.slice(),
         },
-        .cc = .Unspecified,
+        .cc = .auto,
         .src_loc = data.func.src_loc,
         .output_mode = comp.config.output_mode,
         .link_mode = comp.config.link_mode,
@@ -1238,7 +1236,7 @@ fn gen(func: *Func) !void {
         }
     }
 
-    if (fn_info.cc != .Naked) {
+    if (fn_info.cc != .naked) {
         _ = try func.addPseudo(.pseudo_dbg_prologue_end);
 
         const backpatch_stack_alloc = try func.addPseudo(.pseudo_dead);
@@ -4894,7 +4892,7 @@ fn genCall(
         .lib => |lib| try pt.funcType(.{
             .param_types = lib.param_types,
             .return_type = lib.return_type,
-            .cc = .C,
+            .cc = func.target.cCallingConvention().?,
         }),
     };
 
@@ -5004,7 +5002,7 @@ fn genCall(
                     .func => |func_val| {
                         if (func.bin_file.cast(.elf)) |elf_file| {
                             const zo = elf_file.zigObjectPtr().?;
-                            const sym_index = try zo.getOrCreateMetadataForNav(elf_file, func_val.owner_nav);
+                            const sym_index = try zo.getOrCreateMetadataForNav(zcu, func_val.owner_nav);
 
                             if (func.mod.pic) {
                                 return func.fail("TODO: genCall pic", .{});
@@ -5162,6 +5160,7 @@ 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);
@@ -5173,6 +5172,7 @@ fn airCmp(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
             .pointer,
             .error_set,
             .optional,
+            .@"struct",
             => {
                 const int_ty = switch (lhs_ty.zigTypeTag(zcu)) {
                     .@"enum" => lhs_ty.intTagType(zcu),
@@ -5190,6 +5190,12 @@ fn airCmp(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
                             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);
+                    },
                     else => unreachable,
                 };
 
@@ -8281,12 +8287,12 @@ fn resolveCallingConventionValues(
     const ret_ty = Type.fromInterned(fn_info.return_type);
 
     switch (cc) {
-        .Naked => {
+        .naked => {
             assert(result.args.len == 0);
             result.return_value = InstTracking.init(.unreach);
             result.stack_align = .@"8";
         },
-        .C, .Unspecified => {
+        .riscv64_lp64, .auto => {
             if (result.args.len > 8) {
                 return func.fail("RISC-V calling convention does not support more than 8 arguments", .{});
             }
@@ -8351,7 +8357,7 @@ fn resolveCallingConventionValues(
 
             for (param_types, result.args) |ty, *arg| {
                 if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-                    assert(cc == .Unspecified);
+                    assert(cc == .auto);
                     arg.* = .none;
                     continue;
                 }
diff --git a/zig/src/arch/sparc64/CodeGen.zig b/zig/src/arch/sparc64/CodeGen.zig
index 5006ebc4f6..a1bef1f4cd 100644
--- a/zig/src/arch/sparc64/CodeGen.zig
+++ b/zig/src/arch/sparc64/CodeGen.zig
@@ -366,7 +366,7 @@ fn gen(self: *Self) !void {
     const pt = self.pt;
     const zcu = pt.zcu;
     const cc = self.fn_type.fnCallingConvention(zcu);
-    if (cc != .Naked) {
+    if (cc != .naked) {
         // TODO Finish function prologue and epilogue for sparc64.
 
         // save %sp, stack_reserved_area, %sp
@@ -3114,7 +3114,7 @@ fn binOpImmediate(
         const reg = try self.register_manager.allocReg(track_inst, gp);
 
         if (track_inst) |inst| {
-            const mcv = .{ .register = reg };
+            const mcv: MCValue = .{ .register = reg };
             log.debug("binOpRegister move lhs %{d} to register: {} -> {}", .{ inst, lhs, mcv });
             branch.inst_table.putAssumeCapacity(inst, mcv);
 
@@ -3252,7 +3252,7 @@ fn binOpRegister(
 
         const reg = try self.register_manager.allocReg(track_inst, gp);
         if (track_inst) |inst| {
-            const mcv = .{ .register = reg };
+            const mcv: MCValue = .{ .register = reg };
             log.debug("binOpRegister move lhs %{d} to register: {} -> {}", .{ inst, lhs, mcv });
             branch.inst_table.putAssumeCapacity(inst, mcv);
 
@@ -3276,7 +3276,7 @@ fn binOpRegister(
 
         const reg = try self.register_manager.allocReg(track_inst, gp);
         if (track_inst) |inst| {
-            const mcv = .{ .register = reg };
+            const mcv: MCValue = .{ .register = reg };
             log.debug("binOpRegister move rhs %{d} to register: {} -> {}", .{ inst, rhs, mcv });
             branch.inst_table.putAssumeCapacity(inst, mcv);
 
@@ -3650,7 +3650,6 @@ fn genLoad(self: *Self, value_reg: Register, addr_reg: Register, comptime off_ty
     assert(off_type == Register or off_type == i13);
 
     const is_imm = (off_type == i13);
-    const rs2_or_imm = if (is_imm) .{ .imm = off } else .{ .rs2 = off };
 
     switch (abi_size) {
         1, 2, 4, 8 => {
@@ -3669,7 +3668,7 @@ fn genLoad(self: *Self, value_reg: Register, addr_reg: Register, comptime off_ty
                         .is_imm = is_imm,
                         .rd = value_reg,
                         .rs1 = addr_reg,
-                        .rs2_or_imm = rs2_or_imm,
+                        .rs2_or_imm = if (is_imm) .{ .imm = off } else .{ .rs2 = off },
                     },
                 },
             });
@@ -4037,7 +4036,6 @@ fn genStore(self: *Self, value_reg: Register, addr_reg: Register, comptime off_t
     assert(off_type == Register or off_type == i13);
 
     const is_imm = (off_type == i13);
-    const rs2_or_imm = if (is_imm) .{ .imm = off } else .{ .rs2 = off };
 
     switch (abi_size) {
         1, 2, 4, 8 => {
@@ -4056,7 +4054,7 @@ fn genStore(self: *Self, value_reg: Register, addr_reg: Register, comptime off_t
                         .is_imm = is_imm,
                         .rd = value_reg,
                         .rs1 = addr_reg,
-                        .rs2_or_imm = rs2_or_imm,
+                        .rs2_or_imm = if (is_imm) .{ .imm = off } else .{ .rs2 = off },
                     },
                 },
             });
@@ -4441,14 +4439,14 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type, role: RegisterView)
     const ret_ty = fn_ty.fnReturnType(zcu);
 
     switch (cc) {
-        .Naked => {
+        .naked => {
             assert(result.args.len == 0);
             result.return_value = .{ .unreach = {} };
             result.stack_byte_count = 0;
             result.stack_align = .@"1";
             return result;
         },
-        .Unspecified, .C => {
+        .auto, .sparc64_sysv => {
             // SPARC Compliance Definition 2.4.1, Chapter 3
             // Low-Level System Information (64-bit psABI) - Function Calling Sequence
 
diff --git a/zig/src/arch/wasm/CodeGen.zig b/zig/src/arch/wasm/CodeGen.zig
index c78fc1584f..50a8869282 100644
--- a/zig/src/arch/wasm/CodeGen.zig
+++ b/zig/src/arch/wasm/CodeGen.zig
@@ -710,7 +710,7 @@ stack_size: u32 = 0,
 /// The stack alignment, which is 16 bytes by default. This is specified by the
 /// tool-conventions: https://github.com/WebAssembly/tool-conventions/blob/main/BasicCABI.md
 /// and also what the llvm backend will emit.
-/// However, local variables or the usage of `@setAlignStack` can overwrite this default.
+/// However, local variables or the usage of `incoming_stack_alignment` in a `CallingConvention` can overwrite this default.
 stack_alignment: Alignment = .@"16",
 
 // For each individual Wasm valtype we store a seperate free list which
@@ -1160,7 +1160,7 @@ fn genFunctype(
     if (firstParamSRet(cc, return_type, pt, target)) {
         try temp_params.append(.i32); // memory address is always a 32-bit handle
     } else if (return_type.hasRuntimeBitsIgnoreComptime(zcu)) {
-        if (cc == .C) {
+        if (cc == .wasm_watc) {
             const res_classes = abi.classifyType(return_type, zcu);
             assert(res_classes[0] == .direct and res_classes[1] == .none);
             const scalar_type = abi.scalarType(return_type, zcu);
@@ -1178,7 +1178,7 @@ fn genFunctype(
         if (!param_type.hasRuntimeBitsIgnoreComptime(zcu)) continue;
 
         switch (cc) {
-            .C => {
+            .wasm_watc => {
                 const param_classes = abi.classifyType(param_type, zcu);
                 if (param_classes[1] == .none) {
                     if (param_classes[0] == .direct) {
@@ -1291,7 +1291,7 @@ fn genFunc(func: *CodeGen) InnerError!void {
         var prologue = std.ArrayList(Mir.Inst).init(func.gpa);
         defer prologue.deinit();
 
-        const sp = @intFromEnum(func.bin_file.zigObjectPtr().?.stack_pointer_sym);
+        const sp = @intFromEnum(func.bin_file.zig_object.?.stack_pointer_sym);
         // load stack pointer
         try prologue.append(.{ .tag = .global_get, .data = .{ .label = sp } });
         // store stack pointer so we can restore it when we return from the function
@@ -1367,7 +1367,7 @@ fn resolveCallingConventionValues(func: *CodeGen, fn_ty: Type) InnerError!CallWV
         .args = &.{},
         .return_value = .none,
     };
-    if (cc == .Naked) return result;
+    if (cc == .naked) return result;
 
     var args = std.ArrayList(WValue).init(func.gpa);
     defer args.deinit();
@@ -1382,7 +1382,7 @@ fn resolveCallingConventionValues(func: *CodeGen, fn_ty: Type) InnerError!CallWV
     }
 
     switch (cc) {
-        .Unspecified => {
+        .auto => {
             for (fn_info.param_types.get(ip)) |ty| {
                 if (!Type.fromInterned(ty).hasRuntimeBitsIgnoreComptime(zcu)) {
                     continue;
@@ -1392,7 +1392,7 @@ fn resolveCallingConventionValues(func: *CodeGen, fn_ty: Type) InnerError!CallWV
                 func.local_index += 1;
             }
         },
-        .C => {
+        .wasm_watc => {
             for (fn_info.param_types.get(ip)) |ty| {
                 const ty_classes = abi.classifyType(Type.fromInterned(ty), zcu);
                 for (ty_classes) |class| {
@@ -1410,8 +1410,9 @@ fn resolveCallingConventionValues(func: *CodeGen, fn_ty: Type) InnerError!CallWV
 
 fn firstParamSRet(cc: std.builtin.CallingConvention, return_type: Type, pt: Zcu.PerThread, target: std.Target) bool {
     switch (cc) {
-        .Unspecified, .Inline => return isByRef(return_type, pt, target),
-        .C => {
+        .@"inline" => unreachable,
+        .auto => return isByRef(return_type, pt, target),
+        .wasm_watc => {
             const ty_classes = abi.classifyType(return_type, pt.zcu);
             if (ty_classes[0] == .indirect) return true;
             if (ty_classes[0] == .direct and ty_classes[1] == .direct) return true;
@@ -1424,7 +1425,7 @@ fn firstParamSRet(cc: std.builtin.CallingConvention, return_type: Type, pt: Zcu.
 /// Lowers a Zig type and its value based on a given calling convention to ensure
 /// it matches the ABI.
 fn lowerArg(func: *CodeGen, cc: std.builtin.CallingConvention, ty: Type, value: WValue) !void {
-    if (cc != .C) {
+    if (cc != .wasm_watc) {
         return func.lowerToStack(value);
     }
 
@@ -1510,7 +1511,7 @@ fn restoreStackPointer(func: *CodeGen) !void {
     try func.emitWValue(func.initial_stack_value);
 
     // save its value in the global stack pointer
-    try func.addLabel(.global_set, @intFromEnum(func.bin_file.zigObjectPtr().?.stack_pointer_sym));
+    try func.addLabel(.global_set, @intFromEnum(func.bin_file.zig_object.?.stack_pointer_sym));
 }
 
 /// From a given type, will create space on the virtual stack to store the value of such type.
@@ -2108,7 +2109,7 @@ fn airRet(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     // to the stack instead
     if (func.return_value != .none) {
         try func.store(func.return_value, operand, ret_ty, 0);
-    } else if (fn_info.cc == .C and ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
+    } else if (fn_info.cc == .wasm_watc and ret_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
         switch (ret_ty.zigTypeTag(zcu)) {
             // Aggregate types can be lowered as a singular value
             .@"struct", .@"union" => {
@@ -2261,7 +2262,7 @@ fn airCall(func: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModif
     }
 
     if (callee) |direct| {
-        const atom_index = func.bin_file.zigObjectPtr().?.navs.get(direct).?.atom;
+        const atom_index = func.bin_file.zig_object.?.navs.get(direct).?.atom;
         try func.addLabel(.call, @intFromEnum(func.bin_file.getAtom(atom_index).sym_index));
     } else {
         // in this case we call a function pointer
@@ -2273,7 +2274,7 @@ fn airCall(func: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModif
         var fn_type = try genFunctype(func.gpa, fn_info.cc, fn_info.param_types.get(ip), Type.fromInterned(fn_info.return_type), pt, func.target.*);
         defer fn_type.deinit(func.gpa);
 
-        const fn_type_index = try func.bin_file.zigObjectPtr().?.putOrGetFuncType(func.gpa, fn_type);
+        const fn_type_index = try func.bin_file.zig_object.?.putOrGetFuncType(func.gpa, fn_type);
         try func.addLabel(.call_indirect, fn_type_index);
     }
 
@@ -2286,7 +2287,7 @@ fn airCall(func: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModif
         } else if (first_param_sret) {
             break :result_value sret;
             // TODO: Make this less fragile and optimize
-        } else if (zcu.typeToFunc(fn_ty).?.cc == .C and ret_ty.zigTypeTag(zcu) == .@"struct" or ret_ty.zigTypeTag(zcu) == .@"union") {
+        } else if (zcu.typeToFunc(fn_ty).?.cc == .wasm_watc and ret_ty.zigTypeTag(zcu) == .@"struct" or ret_ty.zigTypeTag(zcu) == .@"union") {
             const result_local = try func.allocLocal(ret_ty);
             try func.addLabel(.local_set, result_local.local.value);
             const scalar_type = abi.scalarType(ret_ty, zcu);
@@ -2565,7 +2566,7 @@ fn airArg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const arg = func.args[arg_index];
     const cc = zcu.typeToFunc(zcu.navValue(func.owner_nav).typeOf(zcu)).?.cc;
     const arg_ty = func.typeOfIndex(inst);
-    if (cc == .C) {
+    if (cc == .wasm_watc) {
         const arg_classes = abi.classifyType(arg_ty, zcu);
         for (arg_classes) |class| {
             if (class != .none) {
@@ -3258,7 +3259,7 @@ fn lowerConstant(func: *CodeGen, val: Value, ty: Type) InnerError!WValue {
         .error_union_type,
         .simple_type,
         .struct_type,
-        .anon_struct_type,
+        .tuple_type,
         .union_type,
         .opaque_type,
         .enum_type,
@@ -3272,7 +3273,7 @@ fn lowerConstant(func: *CodeGen, val: Value, ty: Type) InnerError!WValue {
             .undefined,
             .void,
             .null,
-            .empty_struct,
+            .empty_tuple,
             .@"unreachable",
             .generic_poison,
             => unreachable, // non-runtime values
@@ -3707,7 +3708,7 @@ fn airCmpLtErrorsLen(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const operand = try func.resolveInst(un_op);
     const sym_index = try func.bin_file.getGlobalSymbol("__zig_errors_len", null);
-    const errors_len = .{ .memory = @intFromEnum(sym_index) };
+    const errors_len: WValue = .{ .memory = @intFromEnum(sym_index) };
 
     try func.emitWValue(operand);
     const pt = func.pt;
@@ -7175,12 +7176,12 @@ fn callIntrinsic(
     // Always pass over C-ABI
     const pt = func.pt;
     const zcu = pt.zcu;
-    var func_type = try genFunctype(func.gpa, .C, param_types, return_type, pt, func.target.*);
+    var func_type = try genFunctype(func.gpa, .{ .wasm_watc = .{} }, param_types, return_type, pt, func.target.*);
     defer func_type.deinit(func.gpa);
-    const func_type_index = try func.bin_file.zigObjectPtr().?.putOrGetFuncType(func.gpa, func_type);
+    const func_type_index = try func.bin_file.zig_object.?.putOrGetFuncType(func.gpa, func_type);
     try func.bin_file.addOrUpdateImport(name, symbol_index, null, func_type_index);
 
-    const want_sret_param = firstParamSRet(.C, return_type, pt, func.target.*);
+    const want_sret_param = firstParamSRet(.{ .wasm_watc = .{} }, return_type, pt, func.target.*);
     // if we want return as first param, we allocate a pointer to stack,
     // and emit it as our first argument
     const sret = if (want_sret_param) blk: {
@@ -7193,7 +7194,7 @@ fn callIntrinsic(
     for (args, 0..) |arg, arg_i| {
         assert(!(want_sret_param and arg == .stack));
         assert(Type.fromInterned(param_types[arg_i]).hasRuntimeBitsIgnoreComptime(zcu));
-        try func.lowerArg(.C, Type.fromInterned(param_types[arg_i]), arg);
+        try func.lowerArg(.{ .wasm_watc = .{} }, Type.fromInterned(param_types[arg_i]), arg);
     }
 
     // Actually call our intrinsic
diff --git a/zig/src/arch/wasm/Emit.zig b/zig/src/arch/wasm/Emit.zig
index 648af47153..cd744cd53e 100644
--- a/zig/src/arch/wasm/Emit.zig
+++ b/zig/src/arch/wasm/Emit.zig
@@ -310,7 +310,7 @@ fn emitGlobal(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void {
     const global_offset = emit.offset();
     try emit.code.appendSlice(&buf);
 
-    const atom_index = emit.bin_file.zigObjectPtr().?.navs.get(emit.owner_nav).?.atom;
+    const atom_index = emit.bin_file.zig_object.?.navs.get(emit.owner_nav).?.atom;
     const atom = emit.bin_file.getAtomPtr(atom_index);
     try atom.relocs.append(gpa, .{
         .index = label,
@@ -370,7 +370,7 @@ fn emitCall(emit: *Emit, inst: Mir.Inst.Index) !void {
     try emit.code.appendSlice(&buf);
 
     if (label != 0) {
-        const atom_index = emit.bin_file.zigObjectPtr().?.navs.get(emit.owner_nav).?.atom;
+        const atom_index = emit.bin_file.zig_object.?.navs.get(emit.owner_nav).?.atom;
         const atom = emit.bin_file.getAtomPtr(atom_index);
         try atom.relocs.append(gpa, .{
             .offset = call_offset,
@@ -390,7 +390,7 @@ fn emitCallIndirect(emit: *Emit, inst: Mir.Inst.Index) !void {
     leb128.writeUnsignedFixed(5, &buf, type_index);
     try emit.code.appendSlice(&buf);
     if (type_index != 0) {
-        const atom_index = emit.bin_file.zigObjectPtr().?.navs.get(emit.owner_nav).?.atom;
+        const atom_index = emit.bin_file.zig_object.?.navs.get(emit.owner_nav).?.atom;
         const atom = emit.bin_file.getAtomPtr(atom_index);
         try atom.relocs.append(emit.bin_file.base.comp.gpa, .{
             .offset = call_offset,
@@ -412,7 +412,7 @@ fn emitFunctionIndex(emit: *Emit, inst: Mir.Inst.Index) !void {
     try emit.code.appendSlice(&buf);
 
     if (symbol_index != 0) {
-        const atom_index = emit.bin_file.zigObjectPtr().?.navs.get(emit.owner_nav).?.atom;
+        const atom_index = emit.bin_file.zig_object.?.navs.get(emit.owner_nav).?.atom;
         const atom = emit.bin_file.getAtomPtr(atom_index);
         try atom.relocs.append(gpa, .{
             .offset = index_offset,
@@ -443,7 +443,7 @@ fn emitMemAddress(emit: *Emit, inst: Mir.Inst.Index) !void {
     }
 
     if (mem.pointer != 0) {
-        const atom_index = emit.bin_file.zigObjectPtr().?.navs.get(emit.owner_nav).?.atom;
+        const atom_index = emit.bin_file.zig_object.?.navs.get(emit.owner_nav).?.atom;
         const atom = emit.bin_file.getAtomPtr(atom_index);
         try atom.relocs.append(gpa, .{
             .offset = mem_offset,
diff --git a/zig/src/arch/x86_64/CodeGen.zig b/zig/src/arch/x86_64/CodeGen.zig
index 3e272a43f2..06ae399f25 100644
--- a/zig/src/arch/x86_64/CodeGen.zig
+++ b/zig/src/arch/x86_64/CodeGen.zig
@@ -11,6 +11,7 @@ const verbose_tracking_log = std.log.scoped(.verbose_tracking);
 const wip_mir_log = std.log.scoped(.wip_mir);
 const math = std.math;
 const mem = std.mem;
+const target_util = @import("../../target.zig");
 const trace = @import("../../tracy.zig").trace;
 
 const Air = @import("../../Air.zig");
@@ -125,7 +126,7 @@ const Owner = union(enum) {
         const pt = ctx.pt;
         switch (owner) {
             .nav_index => |nav_index| if (ctx.bin_file.cast(.elf)) |elf_file| {
-                return elf_file.zigObjectPtr().?.getOrCreateMetadataForNav(elf_file, nav_index);
+                return elf_file.zigObjectPtr().?.getOrCreateMetadataForNav(pt.zcu, nav_index);
             } else if (ctx.bin_file.cast(.macho)) |macho_file| {
                 return macho_file.getZigObject().?.getOrCreateMetadataForNav(macho_file, nav_index);
             } else if (ctx.bin_file.cast(.coff)) |coff_file| {
@@ -870,10 +871,7 @@ pub fn generate(
     try function.frame_allocs.resize(gpa, FrameIndex.named_count);
     function.frame_allocs.set(
         @intFromEnum(FrameIndex.stack_frame),
-        FrameAlloc.init(.{
-            .size = 0,
-            .alignment = func.analysisUnordered(ip).stack_alignment.max(.@"1"),
-        }),
+        FrameAlloc.init(.{ .size = 0, .alignment = .@"1" }),
     );
     function.frame_allocs.set(
         @intFromEnum(FrameIndex.call_frame),
@@ -918,13 +916,13 @@ pub fn generate(
     );
     function.va_info = switch (cc) {
         else => undefined,
-        .SysV => .{ .sysv = .{
+        .x86_64_sysv => .{ .sysv = .{
             .gp_count = call_info.gp_count,
             .fp_count = call_info.fp_count,
             .overflow_arg_area = .{ .index = .args_frame, .off = call_info.stack_byte_count },
             .reg_save_area = undefined,
         } },
-        .Win64 => .{ .win64 = .{} },
+        .x86_64_win => .{ .win64 = .{} },
     };
 
     function.gen() catch |err| switch (err) {
@@ -1053,7 +1051,7 @@ pub fn generateLazy(
             .bin_file = bin_file,
             .allocator = gpa,
             .mir = mir,
-            .cc = abi.resolveCallingConvention(.Unspecified, function.target.*),
+            .cc = abi.resolveCallingConvention(.auto, function.target.*),
             .src_loc = src_loc,
             .output_mode = comp.config.output_mode,
             .link_mode = comp.config.link_mode,
@@ -1159,7 +1157,7 @@ fn formatWipMir(
             .extra = data.self.mir_extra.items,
             .frame_locs = (std.MultiArrayList(Mir.FrameLoc){}).slice(),
         },
-        .cc = .Unspecified,
+        .cc = .auto,
         .src_loc = data.self.src_loc,
         .output_mode = comp.config.output_mode,
         .link_mode = comp.config.link_mode,
@@ -2023,7 +2021,7 @@ fn gen(self: *Self) InnerError!void {
     const zcu = pt.zcu;
     const fn_info = zcu.typeToFunc(self.fn_type).?;
     const cc = abi.resolveCallingConvention(fn_info.cc, self.target.*);
-    if (cc != .Naked) {
+    if (cc != .naked) {
         try self.asmRegister(.{ ._, .push }, .rbp);
         try self.asmPseudoImmediate(.pseudo_cfi_adjust_cfa_offset_i_s, Immediate.s(8));
         try self.asmPseudoRegisterImmediate(.pseudo_cfi_rel_offset_ri_s, .rbp, Immediate.s(0));
@@ -2056,7 +2054,7 @@ fn gen(self: *Self) InnerError!void {
         }
 
         if (fn_info.is_var_args) switch (cc) {
-            .SysV => {
+            .x86_64_sysv => {
                 const info = &self.va_info.sysv;
                 const reg_save_area_fi = try self.allocFrameIndex(FrameAlloc.init(.{
                     .size = abi.SysV.c_abi_int_param_regs.len * 8 +
@@ -2089,7 +2087,7 @@ fn gen(self: *Self) InnerError!void {
 
                 self.performReloc(skip_sse_reloc);
             },
-            .Win64 => return self.fail("TODO implement gen var arg function for Win64", .{}),
+            .x86_64_win => return self.fail("TODO implement gen var arg function for Win64", .{}),
             else => unreachable,
         };
 
@@ -2541,7 +2539,7 @@ fn genLazy(self: *Self, lazy_sym: link.File.LazySymbol) InnerError!void {
             const enum_ty = Type.fromInterned(lazy_sym.ty);
             wip_mir_log.debug("{}.@tagName:", .{enum_ty.fmt(pt)});
 
-            const resolved_cc = abi.resolveCallingConvention(.Unspecified, self.target.*);
+            const resolved_cc = abi.resolveCallingConvention(.auto, self.target.*);
             const param_regs = abi.getCAbiIntParamRegs(resolved_cc);
             const param_locks = self.register_manager.lockRegsAssumeUnused(2, param_regs[0..2].*);
             defer for (param_locks) |lock| self.register_manager.unlockReg(lock);
@@ -3008,9 +3006,8 @@ pub fn spillEflagsIfOccupied(self: *Self) !void {
 
 pub fn spillCallerPreservedRegs(self: *Self, cc: std.builtin.CallingConvention) !void {
     switch (cc) {
-        inline .SysV, .Win64 => |known_cc| try self.spillRegisters(
-            comptime abi.getCallerPreservedRegs(known_cc),
-        ),
+        .x86_64_sysv => try self.spillRegisters(abi.getCallerPreservedRegs(.{ .x86_64_sysv = .{} })),
+        .x86_64_win => try self.spillRegisters(abi.getCallerPreservedRegs(.{ .x86_64_win = .{} })),
         else => unreachable,
     }
 }
@@ -12384,7 +12381,7 @@ fn genCall(self: *Self, info: union(enum) {
         .lib => |lib| try pt.funcType(.{
             .param_types = lib.param_types,
             .return_type = lib.return_type,
-            .cc = .C,
+            .cc = self.target.cCallingConvention().?,
         }),
     };
     const fn_info = zcu.typeToFunc(fn_ty).?;
@@ -12543,7 +12540,7 @@ fn genCall(self: *Self, info: union(enum) {
                     src_arg,
                     .{},
                 ),
-                .C, .SysV, .Win64 => {
+                .x86_64_sysv, .x86_64_win => {
                     const promoted_ty = self.promoteInt(arg_ty);
                     const promoted_abi_size: u32 = @intCast(promoted_ty.abiSize(zcu));
                     const dst_alias = registerAlias(dst_reg, promoted_abi_size);
@@ -12608,7 +12605,7 @@ fn genCall(self: *Self, info: union(enum) {
                 .func => |func| {
                     if (self.bin_file.cast(.elf)) |elf_file| {
                         const zo = elf_file.zigObjectPtr().?;
-                        const sym_index = try zo.getOrCreateMetadataForNav(elf_file, func.owner_nav);
+                        const sym_index = try zo.getOrCreateMetadataForNav(zcu, func.owner_nav);
                         try self.asmImmediate(.{ ._, .call }, Immediate.rel(.{ .sym_index = sym_index }));
                     } else if (self.bin_file.cast(.coff)) |coff_file| {
                         const atom = try coff_file.getOrCreateAtomForNav(func.owner_nav);
@@ -13686,7 +13683,7 @@ fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
     const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const operand = try self.resolveInst(un_op);
     const ty = self.typeOf(un_op);
-    const result = switch (try self.isNullPtr(inst, ty, operand)) {
+    const result: MCValue = switch (try self.isNullPtr(inst, ty, operand)) {
         .eflags => |cc| .{ .eflags = cc.negate() },
         else => unreachable,
     };
@@ -16822,7 +16819,7 @@ fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
     const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op;
     const inst_ty = self.typeOfIndex(inst);
     const enum_ty = self.typeOf(un_op);
-    const resolved_cc = abi.resolveCallingConvention(.Unspecified, self.target.*);
+    const resolved_cc = abi.resolveCallingConvention(.auto, self.target.*);
 
     // We need a properly aligned and sized call frame to be able to call this function.
     {
@@ -18915,7 +18912,7 @@ fn airVaStart(self: *Self, inst: Air.Inst.Index) !void {
         self.fn_type.fnCallingConvention(zcu),
         self.target.*,
     )) {
-        .SysV => result: {
+        .x86_64_sysv => result: {
             const info = self.va_info.sysv;
             const dst_fi = try self.allocFrameIndex(FrameAlloc.initSpill(va_list_ty, zcu));
             var field_off: u31 = 0;
@@ -18957,7 +18954,7 @@ fn airVaStart(self: *Self, inst: Air.Inst.Index) !void {
             field_off += @intCast(ptr_anyopaque_ty.abiSize(zcu));
             break :result .{ .load_frame = .{ .index = dst_fi } };
         },
-        .Win64 => return self.fail("TODO implement c_va_start for Win64", .{}),
+        .x86_64_win => return self.fail("TODO implement c_va_start for Win64", .{}),
         else => unreachable,
     };
     return self.finishAir(inst, result, .{ .none, .none, .none });
@@ -18976,7 +18973,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
         self.fn_type.fnCallingConvention(zcu),
         self.target.*,
     )) {
-        .SysV => result: {
+        .x86_64_sysv => result: {
             try self.spillEflagsIfOccupied();
 
             const tmp_regs =
@@ -19155,7 +19152,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
             );
             break :result promote_mcv;
         },
-        .Win64 => return self.fail("TODO implement c_va_arg for Win64", .{}),
+        .x86_64_win => return self.fail("TODO implement c_va_arg for Win64", .{}),
         else => unreachable,
     };
     return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
@@ -19324,21 +19321,21 @@ fn resolveCallingConventionValues(
 
     const resolved_cc = abi.resolveCallingConvention(cc, self.target.*);
     switch (cc) {
-        .Naked => {
+        .naked => {
             assert(result.args.len == 0);
             result.return_value = InstTracking.init(.unreach);
             result.stack_align = .@"8";
         },
-        .C, .SysV, .Win64 => {
+        .x86_64_sysv, .x86_64_win => |cc_opts| {
             var ret_int_reg_i: u32 = 0;
             var ret_sse_reg_i: u32 = 0;
             var param_int_reg_i: u32 = 0;
             var param_sse_reg_i: u32 = 0;
-            result.stack_align = .@"16";
+            result.stack_align = .fromByteUnits(cc_opts.incoming_stack_alignment orelse 16);
 
             switch (resolved_cc) {
-                .SysV => {},
-                .Win64 => {
+                .x86_64_sysv => {},
+                .x86_64_win => {
                     // Align the stack to 16bytes before allocating shadow stack space (if any).
                     result.stack_byte_count += @intCast(4 * Type.usize.abiSize(zcu));
                 },
@@ -19356,8 +19353,8 @@ fn resolveCallingConventionValues(
                 var ret_tracking_i: usize = 0;
 
                 const classes = switch (resolved_cc) {
-                    .SysV => mem.sliceTo(&abi.classifySystemV(ret_ty, zcu, self.target.*, .ret), .none),
-                    .Win64 => &.{abi.classifyWindows(ret_ty, zcu)},
+                    .x86_64_sysv => mem.sliceTo(&abi.classifySystemV(ret_ty, zcu, self.target.*, .ret), .none),
+                    .x86_64_win => &.{abi.classifyWindows(ret_ty, zcu)},
                     else => unreachable,
                 };
                 for (classes) |class| switch (class) {
@@ -19419,8 +19416,8 @@ fn resolveCallingConventionValues(
             for (param_types, result.args) |ty, *arg| {
                 assert(ty.hasRuntimeBitsIgnoreComptime(zcu));
                 switch (resolved_cc) {
-                    .SysV => {},
-                    .Win64 => {
+                    .x86_64_sysv => {},
+                    .x86_64_win => {
                         param_int_reg_i = @max(param_int_reg_i, param_sse_reg_i);
                         param_sse_reg_i = param_int_reg_i;
                     },
@@ -19431,8 +19428,8 @@ fn resolveCallingConventionValues(
                 var arg_mcv_i: usize = 0;
 
                 const classes = switch (resolved_cc) {
-                    .SysV => mem.sliceTo(&abi.classifySystemV(ty, zcu, self.target.*, .arg), .none),
-                    .Win64 => &.{abi.classifyWindows(ty, zcu)},
+                    .x86_64_sysv => mem.sliceTo(&abi.classifySystemV(ty, zcu, self.target.*, .arg), .none),
+                    .x86_64_win => &.{abi.classifyWindows(ty, zcu)},
                     else => unreachable,
                 };
                 for (classes) |class| switch (class) {
@@ -19464,11 +19461,11 @@ fn resolveCallingConventionValues(
                     },
                     .sseup => assert(arg_mcv[arg_mcv_i - 1].register.class() == .sse),
                     .x87, .x87up, .complex_x87, .memory, .win_i128 => switch (resolved_cc) {
-                        .SysV => switch (class) {
+                        .x86_64_sysv => switch (class) {
                             .x87, .x87up, .complex_x87, .memory => break,
                             else => unreachable,
                         },
-                        .Win64 => if (ty.abiSize(zcu) > 8) {
+                        .x86_64_win => if (ty.abiSize(zcu) > 8) {
                             const param_int_reg =
                                 abi.getCAbiIntParamRegs(resolved_cc)[param_int_reg_i].to64();
                             param_int_reg_i += 1;
@@ -19515,10 +19512,13 @@ fn resolveCallingConventionValues(
                 }
 
                 const param_size: u31 = @intCast(ty.abiSize(zcu));
-                const param_align: u31 =
-                    @intCast(@max(ty.abiAlignment(zcu).toByteUnits().?, 8));
-                result.stack_byte_count =
-                    mem.alignForward(u31, result.stack_byte_count, param_align);
+                const param_align = ty.abiAlignment(zcu).max(.@"8");
+                result.stack_byte_count = mem.alignForward(
+                    u31,
+                    result.stack_byte_count,
+                    @intCast(param_align.toByteUnits().?),
+                );
+                result.stack_align = result.stack_align.max(param_align);
                 arg.* = .{ .load_frame = .{
                     .index = stack_frame_base,
                     .off = result.stack_byte_count,
@@ -19530,7 +19530,7 @@ fn resolveCallingConventionValues(
             assert(param_sse_reg_i <= 16);
             result.fp_count = param_sse_reg_i;
         },
-        .Unspecified => {
+        .auto => {
             result.stack_align = .@"16";
 
             // Return values
@@ -19560,9 +19560,13 @@ fn resolveCallingConventionValues(
                     continue;
                 }
                 const param_size: u31 = @intCast(ty.abiSize(zcu));
-                const param_align: u31 = @intCast(ty.abiAlignment(zcu).toByteUnits().?);
-                result.stack_byte_count =
-                    mem.alignForward(u31, result.stack_byte_count, param_align);
+                const param_align = ty.abiAlignment(zcu);
+                result.stack_byte_count = mem.alignForward(
+                    u31,
+                    result.stack_byte_count,
+                    @intCast(param_align.toByteUnits().?),
+                );
+                result.stack_align = result.stack_align.max(param_align);
                 arg.* = .{ .load_frame = .{
                     .index = stack_frame_base,
                     .off = result.stack_byte_count,
diff --git a/zig/src/arch/x86_64/Emit.zig b/zig/src/arch/x86_64/Emit.zig
index 354960d6ee..0395b7a43b 100644
--- a/zig/src/arch/x86_64/Emit.zig
+++ b/zig/src/arch/x86_64/Emit.zig
@@ -132,7 +132,7 @@ pub fn emitMir(emit: *Emit) Error!void {
                         coff_file.getGlobalByIndex(link.File.Coff.global_symbol_mask & sym_index)
                     else
                         link.File.Coff.SymbolWithLoc{ .sym_index = sym_index, .file = null };
-                    try link.File.Coff.Atom.addRelocation(coff_file, atom_index, .{
+                    try coff_file.addRelocation(atom_index, .{
                         .type = .direct,
                         .target = target,
                         .offset = end_offset - 4,
@@ -230,7 +230,7 @@ pub fn emitMir(emit: *Emit) Error!void {
                         coff_file.getGlobalByIndex(link.File.Coff.global_symbol_mask & sym_index)
                     else
                         link.File.Coff.SymbolWithLoc{ .sym_index = sym_index, .file = null };
-                    try link.File.Coff.Atom.addRelocation(coff_file, atom_index, .{
+                    try coff_file.addRelocation(atom_index, .{
                         .type = switch (lowered_relocs[0].target) {
                             .linker_got => .got,
                             .linker_direct => .direct,
diff --git a/zig/src/arch/x86_64/Lower.zig b/zig/src/arch/x86_64/Lower.zig
index 058201c2d7..6ac79378c1 100644
--- a/zig/src/arch/x86_64/Lower.zig
+++ b/zig/src/arch/x86_64/Lower.zig
@@ -532,6 +532,8 @@ fn emit(lower: *Lower, prefix: Prefix, mnemonic: Mnemonic, ops: []const Operand)
                             },
                             else => unreachable,
                         };
+                    } else {
+                        return lower.fail("TODO: bin format '{s}'", .{@tagName(lower.bin_file.tag)});
                     }
                 },
             },
diff --git a/zig/src/arch/x86_64/abi.zig b/zig/src/arch/x86_64/abi.zig
index 2e411e0381..fac6b6ce6d 100644
--- a/zig/src/arch/x86_64/abi.zig
+++ b/zig/src/arch/x86_64/abi.zig
@@ -440,9 +440,9 @@ pub fn resolveCallingConvention(
     target: std.Target,
 ) std.builtin.CallingConvention {
     return switch (cc) {
-        .Unspecified, .C => switch (target.os.tag) {
-            else => .SysV,
-            .windows => .Win64,
+        .auto => switch (target.os.tag) {
+            else => .{ .x86_64_sysv = .{} },
+            .windows => .{ .x86_64_win = .{} },
         },
         else => cc,
     };
@@ -450,48 +450,48 @@ pub fn resolveCallingConvention(
 
 pub fn getCalleePreservedRegs(cc: std.builtin.CallingConvention) []const Register {
     return switch (cc) {
-        .SysV => &SysV.callee_preserved_regs,
-        .Win64 => &Win64.callee_preserved_regs,
+        .x86_64_sysv => &SysV.callee_preserved_regs,
+        .x86_64_win => &Win64.callee_preserved_regs,
         else => unreachable,
     };
 }
 
 pub fn getCallerPreservedRegs(cc: std.builtin.CallingConvention) []const Register {
     return switch (cc) {
-        .SysV => &SysV.caller_preserved_regs,
-        .Win64 => &Win64.caller_preserved_regs,
+        .x86_64_sysv => &SysV.caller_preserved_regs,
+        .x86_64_win => &Win64.caller_preserved_regs,
         else => unreachable,
     };
 }
 
 pub fn getCAbiIntParamRegs(cc: std.builtin.CallingConvention) []const Register {
     return switch (cc) {
-        .SysV => &SysV.c_abi_int_param_regs,
-        .Win64 => &Win64.c_abi_int_param_regs,
+        .x86_64_sysv => &SysV.c_abi_int_param_regs,
+        .x86_64_win => &Win64.c_abi_int_param_regs,
         else => unreachable,
     };
 }
 
 pub fn getCAbiSseParamRegs(cc: std.builtin.CallingConvention) []const Register {
     return switch (cc) {
-        .SysV => &SysV.c_abi_sse_param_regs,
-        .Win64 => &Win64.c_abi_sse_param_regs,
+        .x86_64_sysv => &SysV.c_abi_sse_param_regs,
+        .x86_64_win => &Win64.c_abi_sse_param_regs,
         else => unreachable,
     };
 }
 
 pub fn getCAbiIntReturnRegs(cc: std.builtin.CallingConvention) []const Register {
     return switch (cc) {
-        .SysV => &SysV.c_abi_int_return_regs,
-        .Win64 => &Win64.c_abi_int_return_regs,
+        .x86_64_sysv => &SysV.c_abi_int_return_regs,
+        .x86_64_win => &Win64.c_abi_int_return_regs,
         else => unreachable,
     };
 }
 
 pub fn getCAbiSseReturnRegs(cc: std.builtin.CallingConvention) []const Register {
     return switch (cc) {
-        .SysV => &SysV.c_abi_sse_return_regs,
-        .Win64 => &Win64.c_abi_sse_return_regs,
+        .x86_64_sysv => &SysV.c_abi_sse_return_regs,
+        .x86_64_win => &Win64.c_abi_sse_return_regs,
         else => unreachable,
     };
 }
diff --git a/zig/src/codegen.zig b/zig/src/codegen.zig
index b41fa3c2ef..2b179979f0 100644
--- a/zig/src/codegen.zig
+++ b/zig/src/codegen.zig
@@ -216,7 +216,7 @@ pub fn generateSymbol(
         .error_union_type,
         .simple_type,
         .struct_type,
-        .anon_struct_type,
+        .tuple_type,
         .union_type,
         .opaque_type,
         .enum_type,
@@ -230,7 +230,7 @@ pub fn generateSymbol(
             .undefined,
             .void,
             .null,
-            .empty_struct,
+            .empty_tuple,
             .@"unreachable",
             .generic_poison,
             => unreachable, // non-runtime values
@@ -456,7 +456,7 @@ pub fn generateSymbol(
                     if (padding > 0) try code.appendNTimes(0, padding);
                 }
             },
-            .anon_struct_type => |tuple| {
+            .tuple_type => |tuple| {
                 const struct_begin = code.items.len;
                 for (
                     tuple.types.get(ip),
@@ -866,7 +866,7 @@ fn genNavRef(
             zo.symbol(sym_index).flags.is_extern_ptr = true;
             return .{ .mcv = .{ .lea_symbol = sym_index } };
         }
-        const sym_index = try zo.getOrCreateMetadataForNav(elf_file, nav_index);
+        const sym_index = try zo.getOrCreateMetadataForNav(zcu, nav_index);
         if (!single_threaded and is_threadlocal) {
             return .{ .mcv = .{ .load_tlv = sym_index } };
         }
diff --git a/zig/src/codegen/c.zig b/zig/src/codegen/c.zig
index 98c3c42deb..0410023588 100644
--- a/zig/src/codegen/c.zig
+++ b/zig/src/codegen/c.zig
@@ -891,7 +891,7 @@ pub const DeclGen = struct {
             .error_union_type,
             .simple_type,
             .struct_type,
-            .anon_struct_type,
+            .tuple_type,
             .union_type,
             .opaque_type,
             .enum_type,
@@ -908,7 +908,7 @@ pub const DeclGen = struct {
                 .undefined => unreachable,
                 .void => unreachable,
                 .null => unreachable,
-                .empty_struct => unreachable,
+                .empty_tuple => unreachable,
                 .@"unreachable" => unreachable,
                 .generic_poison => unreachable,
 
@@ -1194,7 +1194,7 @@ pub const DeclGen = struct {
                         try writer.writeByte('}');
                     }
                 },
-                .anon_struct_type => |tuple| {
+                .tuple_type => |tuple| {
                     if (!location.isInitializer()) {
                         try writer.writeByte('(');
                         try dg.renderCType(writer, ctype);
@@ -1605,7 +1605,7 @@ pub const DeclGen = struct {
                         }),
                     }
                 },
-                .anon_struct_type => |anon_struct_info| {
+                .tuple_type => |tuple_info| {
                     if (!location.isInitializer()) {
                         try writer.writeByte('(');
                         try dg.renderCType(writer, ctype);
@@ -1614,9 +1614,9 @@ pub const DeclGen = struct {
 
                     try writer.writeByte('{');
                     var need_comma = false;
-                    for (0..anon_struct_info.types.len) |field_index| {
-                        if (anon_struct_info.values.get(ip)[field_index] != .none) continue;
-                        const field_ty = Type.fromInterned(anon_struct_info.types.get(ip)[field_index]);
+                    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 (need_comma) try writer.writeByte(',');
@@ -1783,7 +1783,7 @@ pub const DeclGen = struct {
         const fn_ctype = try dg.ctypeFromType(fn_ty, kind);
 
         const fn_info = zcu.typeToFunc(fn_ty).?;
-        if (fn_info.cc == .Naked) {
+        if (fn_info.cc == .naked) {
             switch (kind) {
                 .forward => try w.writeAll("zig_naked_decl "),
                 .complete => try w.writeAll("zig_naked "),
@@ -1796,7 +1796,7 @@ pub const DeclGen = struct {
 
         var trailing = try renderTypePrefix(dg.pass, &dg.ctype_pool, zcu, w, fn_ctype, .suffix, .{});
 
-        if (toCallingConvention(fn_info.cc)) |call_conv| {
+        if (toCallingConvention(fn_info.cc, zcu)) |call_conv| {
             try w.print("{}zig_callconv({s})", .{ trailing, call_conv });
             trailing = .maybe_space;
         }
@@ -5190,7 +5190,7 @@ fn asmInputNeedsLocal(f: *Function, constraint: []const u8, value: CValue) bool
     return switch (constraint[0]) {
         '{' => true,
         'i', 'r' => false,
-        'I' => !target.cpu.arch.isArmOrThumb(),
+        'I' => !target.cpu.arch.isArm(),
         else => switch (value) {
             .constant => |val| switch (dg.pt.zcu.intern_pool.indexToKey(val.toIntern())) {
                 .ptr => |ptr| if (ptr.byte_offset == 0) switch (ptr.base_addr) {
@@ -5411,9 +5411,9 @@ fn airAsm(f: *Function, inst: Air.Inst.Index) !CValue {
             const input_val = try f.resolveInst(input);
             try writer.print("{s}(", .{fmtStringLiteral(if (is_reg) "r" else constraint, null)});
             try f.writeCValue(writer, if (asmInputNeedsLocal(f, constraint, input_val)) local: {
-                const input_local = .{ .local = locals_index };
+                const input_local_idx = locals_index;
                 locals_index += 1;
-                break :local input_local;
+                break :local .{ .local = input_local_idx };
             } else input_val, .Other);
             try writer.writeByte(')');
         }
@@ -5651,15 +5651,12 @@ fn fieldLocation(
                     .begin,
             };
         },
-        .anon_struct_type => |anon_struct_info| return if (!container_ty.hasRuntimeBitsIgnoreComptime(zcu))
+        .tuple_type => return if (!container_ty.hasRuntimeBitsIgnoreComptime(zcu))
             .begin
         else if (!field_ptr_ty.childType(zcu).hasRuntimeBitsIgnoreComptime(zcu))
             .{ .byte_offset = container_ty.structFieldOffset(field_index, zcu) }
         else
-            .{ .field = if (anon_struct_info.fieldName(ip, field_index).unwrap()) |field_name|
-                .{ .identifier = field_name.toSlice(ip) }
-            else
-                .{ .field = field_index } },
+            .{ .field = .{ .field = field_index } },
         .union_type => {
             const loaded_union = ip.loadUnionType(container_ty.toIntern());
             switch (loaded_union.flagsUnordered(ip).layout) {
@@ -5892,10 +5889,7 @@ fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
                 },
             }
         },
-        .anon_struct_type => |anon_struct_info| if (anon_struct_info.fieldName(ip, extra.field_index).unwrap()) |field_name|
-            .{ .identifier = field_name.toSlice(ip) }
-        else
-            .{ .field = extra.field_index },
+        .tuple_type => .{ .field = extra.field_index },
         .union_type => field_name: {
             const loaded_union = ip.loadUnionType(struct_ty.toIntern());
             switch (loaded_union.flagsUnordered(ip).layout) {
@@ -7366,16 +7360,13 @@ fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue {
                 },
             }
         },
-        .anon_struct_type => |anon_struct_info| for (0..anon_struct_info.types.len) |field_index| {
-            if (anon_struct_info.values.get(ip)[field_index] != .none) continue;
-            const field_ty = Type.fromInterned(anon_struct_info.types.get(ip)[field_index]);
+        .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;
 
             const a = try Assignment.start(f, writer, try f.ctypeFromType(field_ty, .complete));
-            try f.writeCValueMember(writer, local, if (anon_struct_info.fieldName(ip, field_index).unwrap()) |field_name|
-                .{ .identifier = field_name.toSlice(ip) }
-            else
-                .{ .field = field_index });
+            try f.writeCValueMember(writer, local, .{ .field = field_index });
             try a.assign(f, writer);
             try f.writeCValue(writer, resolved_elements[field_index], .Other);
             try a.end(f, writer);
@@ -7604,12 +7595,72 @@ fn writeMemoryOrder(w: anytype, order: std.builtin.AtomicOrder) !void {
     return w.writeAll(toMemoryOrder(order));
 }
 
-fn toCallingConvention(call_conv: std.builtin.CallingConvention) ?[]const u8 {
-    return switch (call_conv) {
-        .Stdcall => "stdcall",
-        .Fastcall => "fastcall",
-        .Vectorcall => "vectorcall",
-        else => null,
+fn toCallingConvention(cc: std.builtin.CallingConvention, zcu: *Zcu) ?[]const u8 {
+    if (zcu.getTarget().cCallingConvention()) |ccc| {
+        if (cc.eql(ccc)) {
+            return null;
+        }
+    }
+    return switch (cc) {
+        .auto, .naked => null,
+
+        .x86_64_sysv, .x86_sysv => "sysv_abi",
+        .x86_64_win, .x86_win => "ms_abi",
+        .x86_stdcall => "stdcall",
+        .x86_fastcall => "fastcall",
+        .x86_thiscall => "thiscall",
+
+        .x86_vectorcall,
+        .x86_64_vectorcall,
+        => "vectorcall",
+
+        .x86_64_regcall_v3_sysv,
+        .x86_64_regcall_v4_win,
+        .x86_regcall_v3,
+        .x86_regcall_v4_win,
+        => "regcall",
+
+        .aarch64_vfabi => "aarch64_vector_pcs",
+        .aarch64_vfabi_sve => "aarch64_sve_pcs",
+
+        .arm_aapcs => "pcs(\"aapcs\")",
+        .arm_aapcs_vfp, .arm_aapcs16_vfp => "pcs(\"aapcs-vfp\")",
+
+        .arm_interrupt => |opts| switch (opts.type) {
+            .generic => "interrupt",
+            .irq => "interrupt(\"IRQ\")",
+            .fiq => "interrupt(\"FIQ\")",
+            .swi => "interrupt(\"SWI\")",
+            .abort => "interrupt(\"ABORT\")",
+            .undef => "interrupt(\"UNDEF\")",
+        },
+
+        .avr_signal => "signal",
+
+        .mips_interrupt,
+        .mips64_interrupt,
+        => |opts| switch (opts.mode) {
+            inline else => |m| "interrupt(\"" ++ @tagName(m) ++ "\")",
+        },
+
+        .riscv64_lp64_v, .riscv32_ilp32_v => "riscv_vector_cc",
+
+        .riscv32_interrupt,
+        .riscv64_interrupt,
+        => |opts| switch (opts.mode) {
+            inline else => |m| "interrupt(\"" ++ @tagName(m) ++ "\")",
+        },
+
+        .m68k_rtd => "m68k_rtd",
+
+        .avr_interrupt,
+        .csky_interrupt,
+        .m68k_interrupt,
+        .x86_interrupt,
+        .x86_64_interrupt,
+        => "interrupt",
+
+        else => unreachable, // `Zcu.callconvSupported`
     };
 }
 
diff --git a/zig/src/codegen/c/Type.zig b/zig/src/codegen/c/Type.zig
index 1e0c23a96b..31daa75a13 100644
--- a/zig/src/codegen/c/Type.zig
+++ b/zig/src/codegen/c/Type.zig
@@ -1350,7 +1350,7 @@ pub const Pool = struct {
             .i0_type,
             .anyopaque_type,
             .void_type,
-            .empty_struct_type,
+            .empty_tuple_type,
             .type_type,
             .comptime_int_type,
             .comptime_float_type,
@@ -1450,7 +1450,7 @@ pub const Pool = struct {
             .null_value,
             .bool_true,
             .bool_false,
-            .empty_struct,
+            .empty_tuple,
             .generic_poison,
             .none,
             => unreachable,
@@ -1730,16 +1730,16 @@ pub const Pool = struct {
                         ),
                     }
                 },
-                .anon_struct_type => |anon_struct_info| {
+                .tuple_type => |tuple_info| {
                     const scratch_top = scratch.items.len;
                     defer scratch.shrinkRetainingCapacity(scratch_top);
-                    try scratch.ensureUnusedCapacity(allocator, anon_struct_info.types.len *
+                    try scratch.ensureUnusedCapacity(allocator, tuple_info.types.len *
                         @typeInfo(Field).@"struct".fields.len);
                     var hasher = Hasher.init;
-                    for (0..anon_struct_info.types.len) |field_index| {
-                        if (anon_struct_info.values.get(ip)[field_index] != .none) continue;
+                    for (0..tuple_info.types.len) |field_index| {
+                        if (tuple_info.values.get(ip)[field_index] != .none) continue;
                         const field_type = Type.fromInterned(
-                            anon_struct_info.types.get(ip)[field_index],
+                            tuple_info.types.get(ip)[field_index],
                         );
                         const field_ctype = try pool.fromType(
                             allocator,
@@ -1750,11 +1750,7 @@ pub const Pool = struct {
                             kind.noParameter(),
                         );
                         if (field_ctype.index == .void) continue;
-                        const field_name = if (anon_struct_info.fieldName(ip, @intCast(field_index))
-                            .unwrap()) |field_name|
-                            try pool.string(allocator, field_name.toSlice(ip))
-                        else
-                            try pool.fmt(allocator, "f{d}", .{field_index});
+                        const field_name = try pool.fmt(allocator, "f{d}", .{field_index});
                         pool.addHashedExtraAssumeCapacityTo(scratch, &hasher, Field, .{
                             .name = field_name.index,
                             .ctype = field_ctype.index,
diff --git a/zig/src/codegen/llvm.zig b/zig/src/codegen/llvm.zig
index 623aa995d4..fb20d4d622 100644
--- a/zig/src/codegen/llvm.zig
+++ b/zig/src/codegen/llvm.zig
@@ -118,9 +118,6 @@ pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 {
             .{ .v6kz, "v6kz" },
             .{ .v6m, "v6m" },
             .{ .v6t2, "v6t2" },
-            // v7k and v7s imply v7a so they have to be tested first.
-            .{ .v7k, "v7k" },
-            .{ .v7s, "v7s" },
             .{ .v7a, "v7a" },
             .{ .v7em, "v7em" },
             .{ .v7m, "v7m" },
@@ -164,14 +161,34 @@ pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 {
     };
 
     if (llvm_sub_arch) |sub| try llvm_triple.appendSlice(sub);
+    try llvm_triple.append('-');
 
-    // Unlike CPU backends, GPU backends actually care about the vendor tag.
-    try llvm_triple.appendSlice(switch (target.cpu.arch) {
-        .amdgcn => if (target.os.tag == .mesa3d) "-mesa-" else "-amd-",
-        .nvptx, .nvptx64 => "-nvidia-",
-        .spirv64 => if (target.os.tag == .amdhsa) "-amd-" else "-unknown-",
-        else => "-unknown-",
+    try llvm_triple.appendSlice(switch (target.os.tag) {
+        .aix,
+        .zos,
+        => "ibm",
+        .bridgeos,
+        .driverkit,
+        .ios,
+        .macos,
+        .tvos,
+        .visionos,
+        .watchos,
+        => "apple",
+        .ps4,
+        .ps5,
+        => "scei",
+        .amdhsa,
+        .amdpal,
+        => "amd",
+        .cuda,
+        .nvcl,
+        => "nvidia",
+        .mesa3d,
+        => "mesa",
+        else => "unknown",
     });
+    try llvm_triple.append('-');
 
     const llvm_os = switch (target.os.tag) {
         .freestanding => "unknown",
@@ -219,13 +236,20 @@ pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 {
     };
     try llvm_triple.appendSlice(llvm_os);
 
-    if (target.os.tag.isDarwin()) {
-        const min_version = target.os.version_range.semver.min;
-        try llvm_triple.writer().print("{d}.{d}.{d}", .{
-            min_version.major,
-            min_version.minor,
-            min_version.patch,
-        });
+    switch (target.os.versionRange()) {
+        .none,
+        .windows,
+        => {},
+        .semver => |ver| try llvm_triple.writer().print("{d}.{d}.{d}", .{
+            ver.min.major,
+            ver.min.minor,
+            ver.min.patch,
+        }),
+        .linux => |ver| try llvm_triple.writer().print("{d}.{d}.{d}", .{
+            ver.range.min.major,
+            ver.range.min.minor,
+            ver.range.min.patch,
+        }),
     }
     try llvm_triple.append('-');
 
@@ -239,13 +263,15 @@ pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 {
         .gnuf32 => "gnuf32",
         .gnusf => "gnusf",
         .gnux32 => "gnux32",
-        .gnuilp32 => "gnuilp32",
+        .gnuilp32 => "gnu_ilp32",
         .code16 => "code16",
         .eabi => "eabi",
         .eabihf => "eabihf",
         .android => "android",
         .androideabi => "androideabi",
         .musl => "musl",
+        .muslabin32 => "musl", // Should be muslabin32 in LLVM 20.
+        .muslabi64 => "musl", // Should be muslabi64 in LLVM 20.
         .musleabi => "musleabi",
         .musleabihf => "musleabihf",
         .muslx32 => "muslx32",
@@ -259,6 +285,18 @@ pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 {
     };
     try llvm_triple.appendSlice(llvm_abi);
 
+    switch (target.os.versionRange()) {
+        .none,
+        .semver,
+        .windows,
+        => {},
+        .linux => |ver| if (target.abi.isGnu()) try llvm_triple.writer().print("{d}.{d}.{d}", .{
+            ver.glibc.major,
+            ver.glibc.minor,
+            ver.glibc.patch,
+        }) else if (target.abi.isAndroid()) try llvm_triple.writer().print("{d}", .{ver.android}),
+    }
+
     return llvm_triple.toOwnedSlice();
 }
 
@@ -458,10 +496,15 @@ const DataLayoutBuilder = struct {
                 if (idx != size) try writer.print(":{d}", .{idx});
             }
         }
-        if (self.target.cpu.arch.isArmOrThumb()) try writer.writeAll("-Fi8") // for thumb interwork
+        if (self.target.cpu.arch.isArm())
+            try writer.writeAll("-Fi8") // for thumb interwork
         else if (self.target.cpu.arch == .powerpc64 and
-            self.target.os.tag != .freebsd and self.target.abi != .musl)
+            self.target.os.tag != .freebsd and
+            self.target.os.tag != .openbsd and
+            !self.target.abi.isMusl())
             try writer.writeAll("-Fi64")
+        else if (self.target.cpu.arch.isPowerPC() and self.target.os.tag == .aix)
+            try writer.writeAll(if (self.target.cpu.arch.isPowerPC64()) "-Fi64" else "-Fi32")
         else if (self.target.cpu.arch.isPowerPC())
             try writer.writeAll("-Fn32");
         if (self.target.cpu.arch != .hexagon) {
@@ -520,6 +563,7 @@ const DataLayoutBuilder = struct {
             .arm,
             .armeb,
             .csky,
+            .loongarch32,
             .mips,
             .mipsel,
             .powerpc,
@@ -535,6 +579,7 @@ const DataLayoutBuilder = struct {
             .amdgcn,
             .bpfeb,
             .bpfel,
+            .loongarch64,
             .mips64,
             .mips64el,
             .powerpc64,
@@ -554,7 +599,6 @@ const DataLayoutBuilder = struct {
             .nvptx64,
             => &.{ 16, 32, 64 },
             .x86_64 => &.{ 8, 16, 32, 64 },
-            .loongarch64 => &.{64},
             else => &.{},
         }), 0..) |natural, index| switch (index) {
             0 => try writer.print("-n{d}", .{natural}),
@@ -573,6 +617,8 @@ const DataLayoutBuilder = struct {
             self.target.os.tag == .uefi or self.target.os.tag == .windows or
             self.target.cpu.arch == .riscv32)
             try writer.print("-S{d}", .{stack_abi});
+        if (self.target.cpu.arch.isAARCH64())
+            try writer.writeAll("-Fn32");
         switch (self.target.cpu.arch) {
             .hexagon, .ve => {
                 try self.typeAlignment(.vector, 32, 128, 128, true, writer);
@@ -717,7 +763,7 @@ const DataLayoutBuilder = struct {
                     else => {},
                 }
             },
-            .vector => if (self.target.cpu.arch.isArmOrThumb()) {
+            .vector => if (self.target.cpu.arch.isArm()) {
                 switch (size) {
                     128 => abi = 64,
                     else => {},
@@ -783,7 +829,7 @@ const DataLayoutBuilder = struct {
                 else => {},
             },
             .aggregate => if (self.target.os.tag == .uefi or self.target.os.tag == .windows or
-                self.target.cpu.arch.isArmOrThumb())
+                self.target.cpu.arch.isArm())
             {
                 pref = @min(pref, self.target.ptrBitWidth());
             } else switch (self.target.cpu.arch) {
@@ -1158,7 +1204,7 @@ pub const Object = struct {
         }
 
         {
-            var module_flags = try std.ArrayList(Builder.Metadata).initCapacity(o.gpa, 6);
+            var module_flags = try std.ArrayList(Builder.Metadata).initCapacity(o.gpa, 7);
             defer module_flags.deinit();
 
             const behavior_error = try o.builder.metadataConstant(try o.builder.intConst(.i32, 1));
@@ -1232,6 +1278,18 @@ pub const Object = struct {
                 }
             }
 
+            const target = comp.root_mod.resolved_target.result;
+            if (target.os.tag == .windows and (target.cpu.arch == .x86_64 or target.cpu.arch == .x86)) {
+                // Add the "RegCallv4" flag so that any functions using `x86_regcallcc` use regcall
+                // v4, which is essentially a requirement on Windows. See corresponding logic in
+                // `toLlvmCallConvTag`.
+                module_flags.appendAssumeCapacity(try o.builder.metadataModuleFlag(
+                    behavior_max,
+                    try o.builder.metadataString("RegCallv4"),
+                    try o.builder.metadataConstant(.@"1"),
+                ));
+            }
+
             try o.builder.metadataNamed(try o.builder.metadataString("llvm.module.flags"), module_flags.items);
         }
 
@@ -1343,7 +1401,10 @@ pub const Object = struct {
             .large => .Large,
         };
 
-        const float_abi: llvm.ABIType = if (comp.root_mod.resolved_target.result.floatAbi() == .hard) .Hard else .Soft;
+        const float_abi: llvm.TargetMachine.FloatABI = if (comp.root_mod.resolved_target.result.floatAbi() == .hard)
+            .Hard
+        else
+            .Soft;
 
         var target_machine = llvm.TargetMachine.create(
             target,
@@ -1466,14 +1527,6 @@ pub const Object = struct {
             _ = try attributes.removeFnAttr(.@"noinline");
         }
 
-        const stack_alignment = func.analysisUnordered(ip).stack_alignment;
-        if (stack_alignment != .none) {
-            try attributes.addFnAttr(.{ .alignstack = stack_alignment.toLlvm() }, &o.builder);
-            try attributes.addFnAttr(.@"noinline", &o.builder);
-        } else {
-            _ = try attributes.removeFnAttr(.alignstack);
-        }
-
         if (func_analysis.branch_hint == .cold) {
             try attributes.addFnAttr(.cold, &o.builder);
         } else {
@@ -1485,7 +1538,7 @@ pub const Object = struct {
         } else {
             _ = try attributes.removeFnAttr(.sanitize_thread);
         }
-        const is_naked = fn_info.cc == .Naked;
+        const is_naked = fn_info.cc == .naked;
         if (owner_mod.fuzz and !func_analysis.disable_instrumentation and !is_naked) {
             try attributes.addFnAttr(.optforfuzzing, &o.builder);
             _ = try attributes.removeFnAttr(.skipprofile);
@@ -1687,12 +1740,6 @@ pub const Object = struct {
                         else
                             try wip.load(.normal, param_llvm_ty, arg_ptr, param_alignment, ""));
                     },
-                    .as_u16 => {
-                        assert(!it.byval_attr);
-                        const param = wip.arg(llvm_arg_i);
-                        llvm_arg_i += 1;
-                        args.appendAssumeCapacity(try wip.cast(.bitcast, param, .half, ""));
-                    },
                     .float_array => {
                         const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[it.zig_index - 1]);
                         const param_llvm_ty = try o.lowerType(param_ty);
@@ -1789,7 +1836,7 @@ pub const Object = struct {
             .liveness = liveness,
             .ng = &ng,
             .wip = wip,
-            .is_naked = fn_info.cc == .Naked,
+            .is_naked = fn_info.cc == .naked,
             .fuzz = fuzz,
             .ret_ptr = ret_ptr,
             .args = args.items,
@@ -2554,7 +2601,7 @@ pub const Object = struct {
                 }
 
                 switch (ip.indexToKey(ty.toIntern())) {
-                    .anon_struct_type => |tuple| {
+                    .tuple_type => |tuple| {
                         var fields: std.ArrayListUnmanaged(Builder.Metadata) = .empty;
                         defer fields.deinit(gpa);
 
@@ -2573,11 +2620,8 @@ pub const Object = struct {
                             const field_offset = field_align.forward(offset);
                             offset = field_offset + field_size;
 
-                            const field_name = if (tuple.names.len != 0)
-                                tuple.names.get(ip)[i].toSlice(ip)
-                            else
-                                try std.fmt.allocPrintZ(gpa, "{d}", .{i});
-                            defer if (tuple.names.len == 0) gpa.free(field_name);
+                            var name_buf: [32]u8 = undefined;
+                            const field_name = std.fmt.bufPrint(&name_buf, "{d}", .{i}) catch unreachable;
 
                             fields.appendAssumeCapacity(try o.builder.debugMemberType(
                                 try o.builder.metadataString(field_name),
@@ -3043,14 +3087,77 @@ pub const Object = struct {
             llvm_arg_i += 1;
         }
 
-        switch (fn_info.cc) {
-            .Unspecified, .Inline => function_index.setCallConv(.fastcc, &o.builder),
-            .Naked => try attributes.addFnAttr(.naked, &o.builder),
-            .Async => {
-                function_index.setCallConv(.fastcc, &o.builder);
-                @panic("TODO: LLVM backend lower async function");
-            },
-            else => function_index.setCallConv(toLlvmCallConv(fn_info.cc, target), &o.builder),
+        if (fn_info.cc == .@"async") {
+            @panic("TODO: LLVM backend lower async function");
+        }
+
+        {
+            const cc_info = toLlvmCallConv(fn_info.cc, target).?;
+
+            function_index.setCallConv(cc_info.llvm_cc, &o.builder);
+
+            if (cc_info.align_stack) {
+                try attributes.addFnAttr(.{ .alignstack = .fromByteUnits(target.stackAlignment()) }, &o.builder);
+            } else {
+                _ = try attributes.removeFnAttr(.alignstack);
+            }
+
+            if (cc_info.naked) {
+                try attributes.addFnAttr(.naked, &o.builder);
+            } else {
+                _ = try attributes.removeFnAttr(.naked);
+            }
+
+            for (0..cc_info.inreg_param_count) |param_idx| {
+                try attributes.addParamAttr(param_idx, .inreg, &o.builder);
+            }
+            for (cc_info.inreg_param_count..std.math.maxInt(u2)) |param_idx| {
+                _ = try attributes.removeParamAttr(param_idx, .inreg);
+            }
+
+            switch (fn_info.cc) {
+                inline .riscv64_interrupt,
+                .riscv32_interrupt,
+                .mips_interrupt,
+                .mips64_interrupt,
+                => |info| {
+                    try attributes.addFnAttr(.{ .string = .{
+                        .kind = try o.builder.string("interrupt"),
+                        .value = try o.builder.string(@tagName(info.mode)),
+                    } }, &o.builder);
+                },
+                .arm_interrupt,
+                => |info| {
+                    try attributes.addFnAttr(.{ .string = .{
+                        .kind = try o.builder.string("interrupt"),
+                        .value = try o.builder.string(switch (info.type) {
+                            .generic => "",
+                            .irq => "IRQ",
+                            .fiq => "FIQ",
+                            .swi => "SWI",
+                            .abort => "ABORT",
+                            .undef => "UNDEF",
+                        }),
+                    } }, &o.builder);
+                },
+                // these function attributes serve as a backup against any mistakes LLVM makes.
+                // clang sets both the function's calling convention and the function attributes
+                // in its backend, so future patches to the AVR backend could end up checking only one,
+                // possibly breaking our support. it's safer to just emit both.
+                .avr_interrupt, .avr_signal, .csky_interrupt => {
+                    try attributes.addFnAttr(.{ .string = .{
+                        .kind = try o.builder.string(switch (fn_info.cc) {
+                            .avr_interrupt,
+                            .csky_interrupt,
+                            => "interrupt",
+                            .avr_signal => "signal",
+                            else => unreachable,
+                        }),
+                        .value = .empty,
+                    } }, &o.builder);
+                },
+                else => {},
+            }
         }
 
         if (resolved.alignment != .none)
@@ -3066,7 +3173,7 @@ pub const Object = struct {
             // suppress generation of the prologue and epilogue, and the prologue is where the
             // frame pointer normally gets set up. At time of writing, this is the case for at
             // least x86 and RISC-V.
-            owner_mod.omit_frame_pointer or fn_info.cc == .Naked,
+            owner_mod.omit_frame_pointer or fn_info.cc == .naked,
         );
 
         if (fn_info.return_type == .noreturn_type) try attributes.addFnAttr(.noreturn, &o.builder);
@@ -3095,7 +3202,6 @@ pub const Object = struct {
                 .no_bits,
                 .abi_sized_int,
                 .multiple_llvm_types,
-                .as_u16,
                 .float_array,
                 .i32_array,
                 .i64_array,
@@ -3116,8 +3222,6 @@ pub const Object = struct {
         owner_mod: *Package.Module,
         omit_frame_pointer: bool,
     ) Allocator.Error!void {
-        const comp = o.pt.zcu.comp;
-
         if (!owner_mod.red_zone) {
             try attributes.addFnAttr(.noredzone, &o.builder);
         }
@@ -3136,13 +3240,16 @@ pub const Object = struct {
         if (owner_mod.unwind_tables) {
             try attributes.addFnAttr(.{ .uwtable = Builder.Attribute.UwTable.default }, &o.builder);
         }
-        if (comp.skip_linker_dependencies or comp.no_builtin) {
+        if (owner_mod.no_builtin) {
             // The intent here is for compiler-rt and libc functions to not generate
             // infinite recursion. For example, if we are compiling the memcpy function,
             // and llvm detects that the body is equivalent to memcpy, it may replace the
             // body of memcpy with a call to memcpy, which would then cause a stack
             // overflow instead of performing memcpy.
-            try attributes.addFnAttr(.nobuiltin, &o.builder);
+            try attributes.addFnAttr(.{ .string = .{
+                .kind = try o.builder.string("no-builtins"),
+                .value = .empty,
+            } }, &o.builder);
         }
         if (owner_mod.optimize_mode == .ReleaseSmall) {
             try attributes.addFnAttr(.minsize, &o.builder);
@@ -3161,12 +3268,6 @@ pub const Object = struct {
                 .value = try o.builder.string(std.mem.span(s)),
             } }, &o.builder);
         }
-        if (target.cpu.arch.isBpf()) {
-            try attributes.addFnAttr(.{ .string = .{
-                .kind = try o.builder.string("no-builtins"),
-                .value = .empty,
-            } }, &o.builder);
-        }
         if (target.floatAbi() == .soft) {
             // `use-soft-float` means "use software routines for floating point computations". In
             // other words, it configures how LLVM lowers basic float instructions like `fcmp`,
@@ -3243,10 +3344,10 @@ pub const Object = struct {
         const ip = &zcu.intern_pool;
         const nav = ip.getNav(nav_index);
         const resolved = nav.status.resolved;
-        const is_extern, const is_threadlocal, const is_weak_linkage = switch (ip.indexToKey(resolved.val)) {
-            .variable => |variable| .{ false, variable.is_threadlocal, variable.is_weak_linkage },
-            .@"extern" => |@"extern"| .{ true, @"extern".is_threadlocal, @"extern".is_weak_linkage },
-            else => .{ false, false, false },
+        const is_extern, const is_threadlocal, const is_weak_linkage, const is_dll_import = switch (ip.indexToKey(resolved.val)) {
+            .variable => |variable| .{ false, variable.is_threadlocal, variable.is_weak_linkage, false },
+            .@"extern" => |@"extern"| .{ true, @"extern".is_threadlocal, @"extern".is_weak_linkage, @"extern".is_dll_import },
+            else => .{ false, false, false, false },
         };
 
         const variable_index = try o.builder.addVariable(
@@ -3263,6 +3364,7 @@ pub const Object = struct {
             if (is_threadlocal and !zcu.navFileScope(nav_index).mod.single_threaded)
                 variable_index.setThreadLocal(.generaldynamic, &o.builder);
             if (is_weak_linkage) variable_index.setLinkage(.extern_weak, &o.builder);
+            if (is_dll_import) variable_index.setDllStorageClass(.dllimport, &o.builder);
         } else {
             variable_index.setLinkage(.internal, &o.builder);
             variable_index.setUnnamedAddr(.unnamed_addr, &o.builder);
@@ -3354,7 +3456,7 @@ pub const Object = struct {
             .adhoc_inferred_error_set_type,
             => try o.errorIntType(),
             .generic_poison_type,
-            .empty_struct_type,
+            .empty_tuple_type,
             => unreachable,
             // values, not types
             .undef,
@@ -3371,7 +3473,7 @@ pub const Object = struct {
             .null_value,
             .bool_true,
             .bool_false,
-            .empty_struct,
+            .empty_tuple,
             .generic_poison,
             .none,
             => unreachable,
@@ -3538,13 +3640,13 @@ pub const Object = struct {
                     );
                     return ty;
                 },
-                .anon_struct_type => |anon_struct_type| {
+                .tuple_type => |tuple_type| {
                     var llvm_field_types: std.ArrayListUnmanaged(Builder.Type) = .empty;
                     defer llvm_field_types.deinit(o.gpa);
                     // Although we can estimate how much capacity to add, these cannot be
                     // relied upon because of the recursive calls to lowerType below.
-                    try llvm_field_types.ensureUnusedCapacity(o.gpa, anon_struct_type.types.len);
-                    try o.struct_field_map.ensureUnusedCapacity(o.gpa, anon_struct_type.types.len);
+                    try llvm_field_types.ensureUnusedCapacity(o.gpa, tuple_type.types.len);
+                    try o.struct_field_map.ensureUnusedCapacity(o.gpa, tuple_type.types.len);
 
                     comptime assert(struct_layout_version == 2);
                     var offset: u64 = 0;
@@ -3553,8 +3655,8 @@ pub const Object = struct {
                     const struct_size = t.abiSize(zcu);
 
                     for (
-                        anon_struct_type.types.get(ip),
-                        anon_struct_type.values.get(ip),
+                        tuple_type.types.get(ip),
+                        tuple_type.values.get(ip),
                         0..,
                     ) |field_ty, field_val, field_index| {
                         if (field_val != .none) continue;
@@ -3770,9 +3872,6 @@ pub const Object = struct {
             .multiple_llvm_types => {
                 try llvm_params.appendSlice(o.gpa, it.types_buffer[0..it.types_len]);
             },
-            .as_u16 => {
-                try llvm_params.append(o.gpa, .i16);
-            },
             .float_array => |count| {
                 const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[it.zig_index - 1]);
                 const float_ty = try o.lowerType(aarch64_c_abi.getFloatArrayType(param_ty, zcu).?);
@@ -3910,7 +4009,7 @@ pub const Object = struct {
             .error_union_type,
             .simple_type,
             .struct_type,
-            .anon_struct_type,
+            .tuple_type,
             .union_type,
             .opaque_type,
             .enum_type,
@@ -3924,7 +4023,7 @@ pub const Object = struct {
                 .undefined => unreachable, // non-runtime value
                 .void => unreachable, // non-runtime value
                 .null => unreachable, // non-runtime value
-                .empty_struct => unreachable, // non-runtime value
+                .empty_tuple => unreachable, // non-runtime value
                 .@"unreachable" => unreachable, // non-runtime value
                 .generic_poison => unreachable, // non-runtime value
 
@@ -4163,7 +4262,7 @@ pub const Object = struct {
                         ),
                     }
                 },
-                .anon_struct_type => |tuple| {
+                .tuple_type => |tuple| {
                     const struct_ty = try o.lowerType(ty);
                     const llvm_len = struct_ty.aggregateLen(&o.builder);
 
@@ -4627,9 +4726,14 @@ pub const Object = struct {
             if (!param_ty.isPtrLikeOptional(zcu) and !ptr_info.flags.is_allowzero) {
                 try attributes.addParamAttr(llvm_arg_i, .nonnull, &o.builder);
             }
-            if (fn_info.cc == .Interrupt) {
-                const child_type = try lowerType(o, Type.fromInterned(ptr_info.child));
-                try attributes.addParamAttr(llvm_arg_i, .{ .byval = child_type }, &o.builder);
+            switch (fn_info.cc) {
+                else => {},
+                .x86_64_interrupt,
+                .x86_interrupt,
+                => {
+                    const child_type = try lowerType(o, Type.fromInterned(ptr_info.child));
+                    try attributes.addParamAttr(llvm_arg_i, .{ .byval = child_type }, &o.builder);
+                },
             }
             if (ptr_info.flags.is_const) {
                 try attributes.addParamAttr(llvm_arg_i, .readonly, &o.builder);
@@ -4791,10 +4895,10 @@ pub const NavGen = struct {
         const nav = ip.getNav(nav_index);
         const resolved = nav.status.resolved;
 
-        const is_extern, const lib_name, const is_threadlocal, const is_weak_linkage, const is_const, const init_val, const owner_nav = switch (ip.indexToKey(resolved.val)) {
-            .variable => |variable| .{ false, variable.lib_name, variable.is_threadlocal, variable.is_weak_linkage, false, variable.init, variable.owner_nav },
-            .@"extern" => |@"extern"| .{ true, @"extern".lib_name, @"extern".is_threadlocal, @"extern".is_weak_linkage, @"extern".is_const, .none, @"extern".owner_nav },
-            else => .{ false, .none, false, false, true, resolved.val, nav_index },
+        const is_extern, const lib_name, const is_threadlocal, const is_weak_linkage, const is_dll_import, const is_const, const init_val, const owner_nav = switch (ip.indexToKey(resolved.val)) {
+            .variable => |variable| .{ false, variable.lib_name, variable.is_threadlocal, variable.is_weak_linkage, false, false, variable.init, variable.owner_nav },
+            .@"extern" => |@"extern"| .{ true, @"extern".lib_name, @"extern".is_threadlocal, @"extern".is_weak_linkage, @"extern".is_dll_import, @"extern".is_const, .none, @"extern".owner_nav },
+            else => .{ false, .none, false, false, false, true, resolved.val, nav_index },
         };
         const ty = Type.fromInterned(nav.typeOf(ip));
 
@@ -4869,8 +4973,11 @@ pub const NavGen = struct {
             try global_index.rename(decl_name, &o.builder);
             global_index.setLinkage(.external, &o.builder);
             global_index.setUnnamedAddr(.default, &o.builder);
-            if (zcu.comp.config.dll_export_fns)
+            if (is_dll_import) {
+                global_index.setDllStorageClass(.dllimport, &o.builder);
+            } else if (zcu.comp.config.dll_export_fns) {
                 global_index.setDllStorageClass(.default, &o.builder);
+            }
 
             if (is_weak_linkage) global_index.setLinkage(.extern_weak, &o.builder);
         }
@@ -5469,6 +5576,10 @@ pub const FuncGen = struct {
         var attributes: Builder.FunctionAttributes.Wip = .{};
         defer attributes.deinit(&o.builder);
 
+        if (self.ng.ownerModule().no_builtin) {
+            try attributes.addFnAttr(.nobuiltin, &o.builder);
+        }
+
         switch (modifier) {
             .auto, .never_tail, .always_tail => {},
             .never_inline => try attributes.addFnAttr(.@"noinline", &o.builder),
@@ -5587,12 +5698,6 @@ pub const FuncGen = struct {
                     llvm_args.appendAssumeCapacity(loaded);
                 }
             },
-            .as_u16 => {
-                const arg = args[it.zig_index - 1];
-                const llvm_arg = try self.resolveInst(arg);
-                const casted = try self.wip.cast(.bitcast, llvm_arg, .i16, "");
-                try llvm_args.append(casted);
-            },
             .float_array => |count| {
                 const arg = args[it.zig_index - 1];
                 const arg_ty = self.typeOf(arg);
@@ -5654,7 +5759,6 @@ pub const FuncGen = struct {
                 .no_bits,
                 .abi_sized_int,
                 .multiple_llvm_types,
-                .as_u16,
                 .float_array,
                 .i32_array,
                 .i64_array,
@@ -5693,7 +5797,7 @@ pub const FuncGen = struct {
                 .always_tail => .musttail,
                 .async_kw, .no_async, .always_inline, .compile_time => unreachable,
             },
-            toLlvmCallConv(fn_info.cc, target),
+            toLlvmCallConvTag(fn_info.cc, target).?,
             try attributes.finish(&o.builder),
             try o.lowerType(zig_fn_ty),
             llvm_fn,
@@ -5772,7 +5876,7 @@ pub const FuncGen = struct {
         _ = try fg.wip.callIntrinsicAssumeCold();
         _ = try fg.wip.call(
             .normal,
-            toLlvmCallConv(fn_info.cc, target),
+            toLlvmCallConvTag(fn_info.cc, target).?,
             .none,
             panic_global.typeOf(&o.builder),
             panic_global.toValue(&o.builder),
@@ -6032,6 +6136,7 @@ pub const FuncGen = struct {
         const o = self.ng.object;
         const pt = o.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),
@@ -6110,6 +6215,12 @@ 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);
+            },
             else => unreachable,
         };
         const is_signed = int_ty.isSignedInt(zcu);
@@ -11483,29 +11594,81 @@ pub const FuncGen = struct {
             template: [:0]const u8,
             constraints: [:0]const u8,
         } = switch (target.cpu.arch) {
-            .x86 => .{
+            .arm, .armeb, .thumb, .thumbeb => .{
                 .template =
-                \\roll $$3,  %edi ; roll $$13, %edi
-                \\roll $$61, %edi ; roll $$51, %edi
-                \\xchgl %ebx,%ebx
+                \\ mov r12, r12, ror #3  ; mov r12, r12, ror #13
+                \\ mov r12, r12, ror #29 ; mov r12, r12, ror #19
+                \\ orr r10, r10, r10
                 ,
-                .constraints = "={edx},{eax},0,~{cc},~{memory}",
+                .constraints = "={r3},{r4},{r3},~{cc},~{memory}",
             },
-            .x86_64 => .{
+            .aarch64, .aarch64_be => .{
                 .template =
-                \\rolq $$3,  %rdi ; rolq $$13, %rdi
-                \\rolq $$61, %rdi ; rolq $$51, %rdi
-                \\xchgq %rbx,%rbx
+                \\ ror x12, x12, #3  ; ror x12, x12, #13
+                \\ ror x12, x12, #51 ; ror x12, x12, #61
+                \\ orr x10, x10, x10
                 ,
-                .constraints = "={rdx},{rax},0,~{cc},~{memory}",
+                .constraints = "={x3},{x4},{x3},~{cc},~{memory}",
             },
-            .aarch64, .aarch64_be => .{
+            .mips, .mipsel => .{
+                .template =
+                \\ srl $$0,  $$0,  13
+                \\ srl $$0,  $$0,  29
+                \\ srl $$0,  $$0,  3
+                \\ srl $$0,  $$0,  19
+                \\ or  $$13, $$13, $$13
+                ,
+                .constraints = "={$11},{$12},{$11},~{memory}",
+            },
+            .mips64, .mips64el => .{
+                .template =
+                \\ dsll $$0,  $$0,  3    ; dsll $$0, $$0, 13
+                \\ dsll $$0,  $$0,  29   ; dsll $$0, $$0, 19
+                \\ or   $$13, $$13, $$13
+                ,
+                .constraints = "={$11},{$12},{$11},~{memory}",
+            },
+            .powerpc, .powerpcle => .{
+                .template =
+                \\ rlwinm 0, 0, 3,  0, 31 ; rlwinm 0, 0, 13, 0, 31
+                \\ rlwinm 0, 0, 29, 0, 31 ; rlwinm 0, 0, 19, 0, 31
+                \\ or     1, 1, 1
+                ,
+                .constraints = "={r3},{r4},{r3},~{cc},~{memory}",
+            },
+            .powerpc64, .powerpc64le => .{
+                .template =
+                \\ rotldi 0, 0, 3  ; rotldi 0, 0, 13
+                \\ rotldi 0, 0, 61 ; rotldi 0, 0, 51
+                \\ or     1, 1, 1
+                ,
+                .constraints = "={r3},{r4},{r3},~{cc},~{memory}",
+            },
+            .s390x => .{
                 .template =
-                \\ror x12, x12, #3  ;  ror x12, x12, #13
-                \\ror x12, x12, #51 ;  ror x12, x12, #61
-                \\orr x10, x10, x10
+                \\ lr %r15, %r15
+                \\ lr %r1,  %r1
+                \\ lr %r2,  %r2
+                \\ lr %r3,  %r3
+                \\ lr %r2,  %r2
                 ,
-                .constraints = "={x3},{x4},0,~{cc},~{memory}",
+                .constraints = "={r3},{r2},{r3},~{cc},~{memory}",
+            },
+            .x86 => .{
+                .template =
+                \\ roll  $$3,  %edi ; roll $$13, %edi
+                \\ roll  $$61, %edi ; roll $$51, %edi
+                \\ xchgl %ebx, %ebx
+                ,
+                .constraints = "={edx},{eax},{edx},~{cc},~{memory}",
+            },
+            .x86_64 => .{
+                .template =
+                \\ rolq  $$3,  %rdi ; rolq $$13, %rdi
+                \\ rolq  $$61, %rdi ; rolq $$51, %rdi
+                \\ xchgq %rbx, %rbx
+                ,
+                .constraints = "={rdx},{rax},{edx},~{cc},~{memory}",
             },
             else => unreachable,
         };
@@ -11563,36 +11726,159 @@ fn toLlvmAtomicRmwBinOp(
     };
 }
 
-fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: std.Target) Builder.CallConv {
-    return switch (cc) {
-        .Unspecified, .Inline, .Async => .fastcc,
-        .C, .Naked => .ccc,
-        .Stdcall => .x86_stdcallcc,
-        .Fastcall => .x86_fastcallcc,
-        .Vectorcall => return switch (target.cpu.arch) {
-            .x86, .x86_64 => .x86_vectorcallcc,
-            .aarch64, .aarch64_be => .aarch64_vector_pcs,
-            else => unreachable,
-        },
-        .Thiscall => .x86_thiscallcc,
-        .APCS => .arm_apcscc,
-        .AAPCS => .arm_aapcscc,
-        .AAPCSVFP => .arm_aapcs_vfpcc,
-        .Interrupt => return switch (target.cpu.arch) {
-            .x86, .x86_64 => .x86_intrcc,
-            .avr => .avr_intrcc,
-            .msp430 => .msp430_intrcc,
-            else => unreachable,
-        },
-        .Signal => .avr_signalcc,
-        .SysV => .x86_64_sysvcc,
-        .Win64 => .win64cc,
-        .Kernel => return switch (target.cpu.arch) {
-            .nvptx, .nvptx64 => .ptx_kernel,
-            .amdgcn => .amdgpu_kernel,
-            else => unreachable,
+const CallingConventionInfo = struct {
+    /// The LLVM calling convention to use.
+    llvm_cc: Builder.CallConv,
+    /// Whether to use an `alignstack` attribute to forcibly re-align the stack pointer in the function's prologue.
+    align_stack: bool,
+    /// Whether the function needs a `naked` attribute.
+    naked: bool,
+    /// How many leading parameters to apply the `inreg` attribute to.
+    inreg_param_count: u2 = 0,
+};
+
+pub fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: std.Target) ?CallingConventionInfo {
+    const llvm_cc = toLlvmCallConvTag(cc, target) orelse return null;
+    const incoming_stack_alignment: ?u64, const register_params: u2 = switch (cc) {
+        inline else => |pl| switch (@TypeOf(pl)) {
+            void => .{ null, 0 },
+            std.builtin.CallingConvention.ArmInterruptOptions,
+            std.builtin.CallingConvention.RiscvInterruptOptions,
+            std.builtin.CallingConvention.MipsInterruptOptions,
+            std.builtin.CallingConvention.CommonOptions,
+            => .{ pl.incoming_stack_alignment, 0 },
+            std.builtin.CallingConvention.X86RegparmOptions => .{ pl.incoming_stack_alignment, pl.register_params },
+            else => @compileError("TODO: toLlvmCallConv" ++ @tagName(pl)),
         },
-        .Vertex, .Fragment => unreachable,
+    };
+    return .{
+        .llvm_cc = llvm_cc,
+        .align_stack = if (incoming_stack_alignment) |a| need_align: {
+            const normal_stack_align = target.stackAlignment();
+            break :need_align a < normal_stack_align;
+        } else false,
+        .naked = cc == .naked,
+        .inreg_param_count = register_params,
+    };
+}
+fn toLlvmCallConvTag(cc_tag: std.builtin.CallingConvention.Tag, target: std.Target) ?Builder.CallConv {
+    if (target.cCallingConvention()) |default_c| {
+        if (cc_tag == default_c) {
+            return .ccc;
+        }
+    }
+    return switch (cc_tag) {
+        .@"inline" => unreachable,
+        .auto, .@"async" => .fastcc,
+        .naked => .ccc,
+        .x86_64_sysv => .x86_64_sysvcc,
+        .x86_64_win => .win64cc,
+        .x86_64_regcall_v3_sysv => if (target.cpu.arch == .x86_64 and target.os.tag != .windows)
+            .x86_regcallcc
+        else
+            null,
+        .x86_64_regcall_v4_win => if (target.cpu.arch == .x86_64 and target.os.tag == .windows)
+            .x86_regcallcc // we use the "RegCallv4" module flag to make this correct
+        else
+            null,
+        .x86_64_vectorcall => .x86_vectorcallcc,
+        .x86_64_interrupt => .x86_intrcc,
+        .x86_stdcall => .x86_stdcallcc,
+        .x86_fastcall => .x86_fastcallcc,
+        .x86_thiscall => .x86_thiscallcc,
+        .x86_regcall_v3 => if (target.cpu.arch == .x86 and target.os.tag != .windows)
+            .x86_regcallcc
+        else
+            null,
+        .x86_regcall_v4_win => if (target.cpu.arch == .x86 and target.os.tag == .windows)
+            .x86_regcallcc // we use the "RegCallv4" module flag to make this correct
+        else
+            null,
+        .x86_vectorcall => .x86_vectorcallcc,
+        .x86_interrupt => .x86_intrcc,
+        .aarch64_vfabi => .aarch64_vector_pcs,
+        .aarch64_vfabi_sve => .aarch64_sve_vector_pcs,
+        .arm_apcs => .arm_apcscc,
+        .arm_aapcs => .arm_aapcscc,
+        .arm_aapcs_vfp => if (target.os.tag != .watchos)
+            .arm_aapcs_vfpcc
+        else
+            null,
+        .arm_aapcs16_vfp => if (target.os.tag == .watchos)
+            .arm_aapcs_vfpcc
+        else
+            null,
+        .riscv64_lp64_v => .riscv_vectorcallcc,
+        .riscv32_ilp32_v => .riscv_vectorcallcc,
+        .avr_builtin => .avr_builtincc,
+        .avr_signal => .avr_signalcc,
+        .avr_interrupt => .avr_intrcc,
+        .m68k_rtd => .m68k_rtdcc,
+        .m68k_interrupt => .m68k_intrcc,
+        .amdgcn_kernel => .amdgpu_kernel,
+        .amdgcn_cs => .amdgpu_cs,
+        .nvptx_device => .ptx_device,
+        .nvptx_kernel => .ptx_kernel,
+
+        // Calling conventions which LLVM uses function attributes for.
+        .riscv64_interrupt,
+        .riscv32_interrupt,
+        .arm_interrupt,
+        .mips64_interrupt,
+        .mips_interrupt,
+        .csky_interrupt,
+        => .ccc,
+
+        // All the calling conventions which LLVM does not have a general representation for.
+        // Note that these are often still supported through the `cCallingConvention` path above via `ccc`.
+        .x86_sysv,
+        .x86_win,
+        .x86_thiscall_mingw,
+        .aarch64_aapcs,
+        .aarch64_aapcs_darwin,
+        .aarch64_aapcs_win,
+        .mips64_n64,
+        .mips64_n32,
+        .mips_o32,
+        .riscv64_lp64,
+        .riscv32_ilp32,
+        .sparc64_sysv,
+        .sparc_sysv,
+        .powerpc64_elf,
+        .powerpc64_elf_altivec,
+        .powerpc64_elf_v2,
+        .powerpc_sysv,
+        .powerpc_sysv_altivec,
+        .powerpc_aix,
+        .powerpc_aix_altivec,
+        .wasm_watc,
+        .arc_sysv,
+        .avr_gnu,
+        .bpf_std,
+        .csky_sysv,
+        .hexagon_sysv,
+        .hexagon_sysv_hvx,
+        .lanai_sysv,
+        .loongarch64_lp64,
+        .loongarch32_ilp32,
+        .m68k_sysv,
+        .m68k_gnu,
+        .msp430_eabi,
+        .propeller1_sysv,
+        .propeller2_sysv,
+        .s390x_sysv,
+        .s390x_sysv_vx,
+        .ve_sysv,
+        .xcore_xs1,
+        .xcore_xs2,
+        .xtensa_call0,
+        .xtensa_windowed,
+        .amdgcn_device,
+        .spirv_device,
+        .spirv_kernel,
+        .spirv_fragment,
+        .spirv_vertex,
+        => null,
     };
 }
 
@@ -11624,7 +11910,7 @@ fn llvmAddrSpaceInfo(target: std.Target) []const AddrSpaceInfo {
             .{ .zig = null, .llvm = Builder.AddrSpace.x86.ptr64, .size = 64, .abi = 64, .force_in_data_layout = true },
         },
         .nvptx, .nvptx64 => &.{
-            .{ .zig = .generic, .llvm = .default },
+            .{ .zig = .generic, .llvm = Builder.AddrSpace.nvptx.generic },
             .{ .zig = .global, .llvm = Builder.AddrSpace.nvptx.global },
             .{ .zig = .constant, .llvm = Builder.AddrSpace.nvptx.constant },
             .{ .zig = .param, .llvm = Builder.AddrSpace.nvptx.param },
@@ -11641,9 +11927,27 @@ fn llvmAddrSpaceInfo(target: std.Target) []const AddrSpaceInfo {
             .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_32bit, .size = 32, .abi = 32 },
             .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.buffer_fat_pointer, .non_integral = true, .size = 160, .abi = 256, .idx = 32 },
             .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.buffer_resource, .non_integral = true, .size = 128, .abi = 128 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.buffer_strided_pointer, .non_integral = true, .size = 192, .abi = 256, .idx = 32 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_0 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_1 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_2 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_3 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_4 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_5 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_6 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_7 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_8 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_9 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_10 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_11 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_12 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_13 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_14 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.constant_buffer_15 },
+            .{ .zig = null, .llvm = Builder.AddrSpace.amdgpu.streamout_register },
         },
         .avr => &.{
-            .{ .zig = .generic, .llvm = .default, .abi = 8 },
+            .{ .zig = .generic, .llvm = Builder.AddrSpace.avr.data, .abi = 8 },
             .{ .zig = .flash, .llvm = Builder.AddrSpace.avr.program, .abi = 8 },
             .{ .zig = .flash1, .llvm = Builder.AddrSpace.avr.program1, .abi = 8 },
             .{ .zig = .flash2, .llvm = Builder.AddrSpace.avr.program2, .abi = 8 },
@@ -11652,7 +11956,7 @@ fn llvmAddrSpaceInfo(target: std.Target) []const AddrSpaceInfo {
             .{ .zig = .flash5, .llvm = Builder.AddrSpace.avr.program5, .abi = 8 },
         },
         .wasm32, .wasm64 => &.{
-            .{ .zig = .generic, .llvm = .default, .force_in_data_layout = true },
+            .{ .zig = .generic, .llvm = Builder.AddrSpace.wasm.default, .force_in_data_layout = true },
             .{ .zig = null, .llvm = Builder.AddrSpace.wasm.variable, .non_integral = true },
             .{ .zig = null, .llvm = Builder.AddrSpace.wasm.externref, .non_integral = true, .size = 8, .abi = 8 },
             .{ .zig = null, .llvm = Builder.AddrSpace.wasm.funcref, .non_integral = true, .size = 8, .abi = 8 },
@@ -11720,31 +12024,27 @@ fn firstParamSRet(fn_info: InternPool.Key.FuncType, zcu: *Zcu, target: std.Targe
     if (!return_type.hasRuntimeBitsIgnoreComptime(zcu)) return false;
 
     return switch (fn_info.cc) {
-        .Unspecified, .Inline => returnTypeByRef(zcu, target, return_type),
-        .C => switch (target.cpu.arch) {
-            .mips, .mipsel => switch (mips_c_abi.classifyType(return_type, zcu, .ret)) {
-                .memory, .i32_array => true,
-                .byval => false,
-            },
-            .x86 => isByRef(return_type, zcu),
-            .x86_64 => switch (target.os.tag) {
-                .windows => x86_64_abi.classifyWindows(return_type, zcu) == .memory,
-                else => firstParamSRetSystemV(return_type, zcu, target),
-            },
-            .wasm32 => wasm_c_abi.classifyType(return_type, zcu)[0] == .indirect,
-            .aarch64, .aarch64_be => aarch64_c_abi.classifyType(return_type, zcu) == .memory,
-            .arm, .armeb => switch (arm_c_abi.classifyType(return_type, zcu, .ret)) {
-                .memory, .i64_array => true,
-                .i32_array => |size| size != 1,
-                .byval => false,
-            },
-            .riscv32, .riscv64 => riscv_c_abi.classifyType(return_type, zcu) == .memory,
-            else => false, // TODO investigate C ABI for other architectures
+        .auto => returnTypeByRef(zcu, target, return_type),
+        .x86_64_sysv => firstParamSRetSystemV(return_type, zcu, target),
+        .x86_64_win => x86_64_abi.classifyWindows(return_type, zcu) == .memory,
+        .x86_sysv, .x86_win => isByRef(return_type, zcu),
+        .x86_stdcall => !isScalar(zcu, return_type),
+        .wasm_watc => wasm_c_abi.classifyType(return_type, zcu)[0] == .indirect,
+        .aarch64_aapcs,
+        .aarch64_aapcs_darwin,
+        .aarch64_aapcs_win,
+        => aarch64_c_abi.classifyType(return_type, zcu) == .memory,
+        .arm_aapcs, .arm_aapcs_vfp, .arm_aapcs16_vfp => switch (arm_c_abi.classifyType(return_type, zcu, .ret)) {
+            .memory, .i64_array => true,
+            .i32_array => |size| size != 1,
+            .byval => false,
         },
-        .SysV => firstParamSRetSystemV(return_type, zcu, target),
-        .Win64 => x86_64_abi.classifyWindows(return_type, zcu) == .memory,
-        .Stdcall => !isScalar(zcu, return_type),
-        else => false,
+        .riscv64_lp64, .riscv32_ilp32 => riscv_c_abi.classifyType(return_type, zcu) == .memory,
+        .mips_o32 => switch (mips_c_abi.classifyType(return_type, zcu, .ret)) {
+            .memory, .i32_array => true,
+            .byval => false,
+        },
+        else => false, // TODO: investigate other targets/callconvs
     };
 }
 
@@ -11770,82 +12070,64 @@ fn lowerFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Error!Bu
     }
     const target = zcu.getTarget();
     switch (fn_info.cc) {
-        .Unspecified,
-        .Inline,
-        => return if (returnTypeByRef(zcu, target, return_type)) .void else o.lowerType(return_type),
-
-        .C => {
-            switch (target.cpu.arch) {
-                .mips, .mipsel => {
-                    switch (mips_c_abi.classifyType(return_type, zcu, .ret)) {
-                        .memory, .i32_array => return .void,
-                        .byval => return o.lowerType(return_type),
-                    }
-                },
-                .x86 => return if (isByRef(return_type, zcu)) .void else o.lowerType(return_type),
-                .x86_64 => switch (target.os.tag) {
-                    .windows => return lowerWin64FnRetTy(o, fn_info),
-                    else => return lowerSystemVFnRetTy(o, fn_info),
-                },
-                .wasm32 => {
-                    if (isScalar(zcu, return_type)) {
-                        return o.lowerType(return_type);
-                    }
-                    const classes = wasm_c_abi.classifyType(return_type, zcu);
-                    if (classes[0] == .indirect or classes[0] == .none) {
-                        return .void;
-                    }
-
-                    assert(classes[0] == .direct and classes[1] == .none);
-                    const scalar_type = wasm_c_abi.scalarType(return_type, zcu);
-                    return o.builder.intType(@intCast(scalar_type.abiSize(zcu) * 8));
-                },
-                .aarch64, .aarch64_be => {
-                    switch (aarch64_c_abi.classifyType(return_type, zcu)) {
-                        .memory => return .void,
-                        .float_array => return o.lowerType(return_type),
-                        .byval => return o.lowerType(return_type),
-                        .integer => return o.builder.intType(@intCast(return_type.bitSize(zcu))),
-                        .double_integer => return o.builder.arrayType(2, .i64),
-                    }
-                },
-                .arm, .armeb => {
-                    switch (arm_c_abi.classifyType(return_type, zcu, .ret)) {
-                        .memory, .i64_array => return .void,
-                        .i32_array => |len| return if (len == 1) .i32 else .void,
-                        .byval => return o.lowerType(return_type),
-                    }
-                },
-                .riscv32, .riscv64 => {
-                    switch (riscv_c_abi.classifyType(return_type, zcu)) {
-                        .memory => return .void,
-                        .integer => {
-                            return o.builder.intType(@intCast(return_type.bitSize(zcu)));
-                        },
-                        .double_integer => {
-                            return o.builder.structType(.normal, &.{ .i64, .i64 });
-                        },
-                        .byval => return o.lowerType(return_type),
-                        .fields => {
-                            var types_len: usize = 0;
-                            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;
-                                types[types_len] = try o.lowerType(field_ty);
-                                types_len += 1;
-                            }
-                            return o.builder.structType(.normal, types[0..types_len]);
-                        },
-                    }
-                },
-                // TODO investigate C ABI for other architectures
-                else => return o.lowerType(return_type),
+        .@"inline" => unreachable,
+        .auto => return if (returnTypeByRef(zcu, target, return_type)) .void else o.lowerType(return_type),
+
+        .x86_64_sysv => return lowerSystemVFnRetTy(o, fn_info),
+        .x86_64_win => return lowerWin64FnRetTy(o, fn_info),
+        .x86_stdcall => return if (isScalar(zcu, return_type)) o.lowerType(return_type) else .void,
+        .x86_sysv, .x86_win => return if (isByRef(return_type, zcu)) .void else o.lowerType(return_type),
+        .aarch64_aapcs, .aarch64_aapcs_darwin, .aarch64_aapcs_win => switch (aarch64_c_abi.classifyType(return_type, zcu)) {
+            .memory => return .void,
+            .float_array => return o.lowerType(return_type),
+            .byval => return o.lowerType(return_type),
+            .integer => return o.builder.intType(@intCast(return_type.bitSize(zcu))),
+            .double_integer => return o.builder.arrayType(2, .i64),
+        },
+        .arm_aapcs, .arm_aapcs_vfp, .arm_aapcs16_vfp => switch (arm_c_abi.classifyType(return_type, zcu, .ret)) {
+            .memory, .i64_array => return .void,
+            .i32_array => |len| return if (len == 1) .i32 else .void,
+            .byval => return o.lowerType(return_type),
+        },
+        .mips_o32 => switch (mips_c_abi.classifyType(return_type, zcu, .ret)) {
+            .memory, .i32_array => return .void,
+            .byval => return o.lowerType(return_type),
+        },
+        .riscv64_lp64, .riscv32_ilp32 => switch (riscv_c_abi.classifyType(return_type, zcu)) {
+            .memory => return .void,
+            .integer => {
+                return o.builder.intType(@intCast(return_type.bitSize(zcu)));
+            },
+            .double_integer => {
+                return o.builder.structType(.normal, &.{ .i64, .i64 });
+            },
+            .byval => return o.lowerType(return_type),
+            .fields => {
+                var types_len: usize = 0;
+                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;
+                    types[types_len] = try o.lowerType(field_ty);
+                    types_len += 1;
+                }
+                return o.builder.structType(.normal, types[0..types_len]);
+            },
+        },
+        .wasm_watc => {
+            if (isScalar(zcu, return_type)) {
+                return o.lowerType(return_type);
             }
+            const classes = wasm_c_abi.classifyType(return_type, zcu);
+            if (classes[0] == .indirect or classes[0] == .none) {
+                return .void;
+            }
+
+            assert(classes[0] == .direct and classes[1] == .none);
+            const scalar_type = wasm_c_abi.scalarType(return_type, zcu);
+            return o.builder.intType(@intCast(scalar_type.abiSize(zcu) * 8));
         },
-        .Win64 => return lowerWin64FnRetTy(o, fn_info),
-        .SysV => return lowerSystemVFnRetTy(o, fn_info),
-        .Stdcall => return if (isScalar(zcu, return_type)) o.lowerType(return_type) else .void,
+        // TODO investigate other callconvs
         else => return o.lowerType(return_type),
     }
 }
@@ -11961,7 +12243,6 @@ const ParamTypeIterator = struct {
         abi_sized_int,
         multiple_llvm_types,
         slice,
-        as_u16,
         float_array: u8,
         i32_array: u8,
         i64_array: u8,
@@ -11999,7 +12280,8 @@ const ParamTypeIterator = struct {
             return .no_bits;
         }
         switch (it.fn_info.cc) {
-            .Unspecified, .Inline => {
+            .@"inline" => unreachable,
+            .auto => {
                 it.zig_index += 1;
                 it.llvm_index += 1;
                 if (ty.isSlice(zcu) or
@@ -12020,99 +12302,12 @@ const ParamTypeIterator = struct {
                     return .byval;
                 }
             },
-            .Async => {
+            .@"async" => {
                 @panic("TODO implement async function lowering in the LLVM backend");
             },
-            .C => switch (target.cpu.arch) {
-                .mips, .mipsel => {
-                    it.zig_index += 1;
-                    it.llvm_index += 1;
-                    switch (mips_c_abi.classifyType(ty, zcu, .arg)) {
-                        .memory => {
-                            it.byval_attr = true;
-                            return .byref;
-                        },
-                        .byval => return .byval,
-                        .i32_array => |size| return Lowering{ .i32_array = size },
-                    }
-                },
-                .x86_64 => switch (target.os.tag) {
-                    .windows => return it.nextWin64(ty),
-                    else => return it.nextSystemV(ty),
-                },
-                .wasm32 => {
-                    it.zig_index += 1;
-                    it.llvm_index += 1;
-                    if (isScalar(zcu, ty)) {
-                        return .byval;
-                    }
-                    const classes = wasm_c_abi.classifyType(ty, zcu);
-                    if (classes[0] == .indirect) {
-                        return .byref;
-                    }
-                    return .abi_sized_int;
-                },
-                .aarch64, .aarch64_be => {
-                    it.zig_index += 1;
-                    it.llvm_index += 1;
-                    switch (aarch64_c_abi.classifyType(ty, zcu)) {
-                        .memory => return .byref_mut,
-                        .float_array => |len| return Lowering{ .float_array = len },
-                        .byval => return .byval,
-                        .integer => {
-                            it.types_len = 1;
-                            it.types_buffer[0] = .i64;
-                            return .multiple_llvm_types;
-                        },
-                        .double_integer => return Lowering{ .i64_array = 2 },
-                    }
-                },
-                .arm, .armeb => {
-                    it.zig_index += 1;
-                    it.llvm_index += 1;
-                    switch (arm_c_abi.classifyType(ty, zcu, .arg)) {
-                        .memory => {
-                            it.byval_attr = true;
-                            return .byref;
-                        },
-                        .byval => return .byval,
-                        .i32_array => |size| return Lowering{ .i32_array = size },
-                        .i64_array => |size| return Lowering{ .i64_array = size },
-                    }
-                },
-                .riscv32, .riscv64 => {
-                    it.zig_index += 1;
-                    it.llvm_index += 1;
-                    if (ty.toIntern() == .f16_type and
-                        !std.Target.riscv.featureSetHas(target.cpu.features, .d)) return .as_u16;
-                    switch (riscv_c_abi.classifyType(ty, zcu)) {
-                        .memory => return .byref_mut,
-                        .byval => return .byval,
-                        .integer => return .abi_sized_int,
-                        .double_integer => return Lowering{ .i64_array = 2 },
-                        .fields => {
-                            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;
-                                it.types_buffer[it.types_len] = try it.object.lowerType(field_ty);
-                                it.types_len += 1;
-                            }
-                            it.llvm_index += it.types_len - 1;
-                            return .multiple_llvm_types;
-                        },
-                    }
-                },
-                // TODO investigate C ABI for other architectures
-                else => {
-                    it.zig_index += 1;
-                    it.llvm_index += 1;
-                    return .byval;
-                },
-            },
-            .Win64 => return it.nextWin64(ty),
-            .SysV => return it.nextSystemV(ty),
-            .Stdcall => {
+            .x86_64_sysv => return it.nextSystemV(ty),
+            .x86_64_win => return it.nextWin64(ty),
+            .x86_stdcall => {
                 it.zig_index += 1;
                 it.llvm_index += 1;
 
@@ -12123,6 +12318,80 @@ const ParamTypeIterator = struct {
                     return .byref;
                 }
             },
+            .aarch64_aapcs, .aarch64_aapcs_darwin, .aarch64_aapcs_win => {
+                it.zig_index += 1;
+                it.llvm_index += 1;
+                switch (aarch64_c_abi.classifyType(ty, zcu)) {
+                    .memory => return .byref_mut,
+                    .float_array => |len| return Lowering{ .float_array = len },
+                    .byval => return .byval,
+                    .integer => {
+                        it.types_len = 1;
+                        it.types_buffer[0] = .i64;
+                        return .multiple_llvm_types;
+                    },
+                    .double_integer => return Lowering{ .i64_array = 2 },
+                }
+            },
+            .arm_aapcs, .arm_aapcs_vfp, .arm_aapcs16_vfp => {
+                it.zig_index += 1;
+                it.llvm_index += 1;
+                switch (arm_c_abi.classifyType(ty, zcu, .arg)) {
+                    .memory => {
+                        it.byval_attr = true;
+                        return .byref;
+                    },
+                    .byval => return .byval,
+                    .i32_array => |size| return Lowering{ .i32_array = size },
+                    .i64_array => |size| return Lowering{ .i64_array = size },
+                }
+            },
+            .mips_o32 => {
+                it.zig_index += 1;
+                it.llvm_index += 1;
+                switch (mips_c_abi.classifyType(ty, zcu, .arg)) {
+                    .memory => {
+                        it.byval_attr = true;
+                        return .byref;
+                    },
+                    .byval => return .byval,
+                    .i32_array => |size| return Lowering{ .i32_array = size },
+                }
+            },
+            .riscv64_lp64, .riscv32_ilp32 => {
+                it.zig_index += 1;
+                it.llvm_index += 1;
+                switch (riscv_c_abi.classifyType(ty, zcu)) {
+                    .memory => return .byref_mut,
+                    .byval => return .byval,
+                    .integer => return .abi_sized_int,
+                    .double_integer => return Lowering{ .i64_array = 2 },
+                    .fields => {
+                        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;
+                            it.types_buffer[it.types_len] = try it.object.lowerType(field_ty);
+                            it.types_len += 1;
+                        }
+                        it.llvm_index += it.types_len - 1;
+                        return .multiple_llvm_types;
+                    },
+                }
+            },
+            .wasm_watc => {
+                it.zig_index += 1;
+                it.llvm_index += 1;
+                if (isScalar(zcu, ty)) {
+                    return .byval;
+                }
+                const classes = wasm_c_abi.classifyType(ty, zcu);
+                if (classes[0] == .indirect) {
+                    return .byref;
+                }
+                return .abi_sized_int;
+            },
+            // TODO investigate other callconvs
             else => {
                 it.zig_index += 1;
                 it.llvm_index += 1;
@@ -12281,7 +12550,7 @@ fn ccAbiPromoteInt(
 ) ?std.builtin.Signedness {
     const target = zcu.getTarget();
     switch (cc) {
-        .Unspecified, .Inline, .Async => return null,
+        .auto, .@"inline", .@"async" => return null,
         else => {},
     }
     const int_info = switch (ty.zigTypeTag(zcu)) {
@@ -12357,7 +12626,7 @@ fn isByRef(ty: Type, zcu: *Zcu) bool {
         .array, .frame => return ty.hasRuntimeBits(zcu),
         .@"struct" => {
             const struct_type = switch (ip.indexToKey(ty.toIntern())) {
-                .anon_struct_type => |tuple| {
+                .tuple_type => |tuple| {
                     var count: usize = 0;
                     for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, field_val| {
                         if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(zcu)) continue;
@@ -12432,7 +12701,8 @@ fn isScalar(zcu: *Zcu, ty: Type) bool {
 }
 
 /// This function returns true if we expect LLVM to lower x86_fp80 correctly
-/// and false if we expect LLVM to crash if it counters an x86_fp80 type.
+/// and false if we expect LLVM to crash if it encounters an x86_fp80 type,
+/// or if it produces miscompilations.
 fn backendSupportsF80(target: std.Target) bool {
     return switch (target.cpu.arch) {
         .x86_64, .x86 => !std.Target.x86.featureSetHas(target.cpu.features, .soft_float),
@@ -12441,10 +12711,13 @@ fn backendSupportsF80(target: std.Target) bool {
 }
 
 /// This function returns true if we expect LLVM to lower f16 correctly
-/// and false if we expect LLVM to crash if it counters an f16 type or
-/// if it produces miscompilations.
+/// and false if we expect LLVM to crash if it encounters an f16 type,
+/// or if it produces miscompilations.
 fn backendSupportsF16(target: std.Target) bool {
     return switch (target.cpu.arch) {
+        // LoongArch can be removed from this list with LLVM 20.
+        .loongarch32,
+        .loongarch64,
         .hexagon,
         .powerpc,
         .powerpcle,
@@ -12456,8 +12729,9 @@ fn backendSupportsF16(target: std.Target) bool {
         .mipsel,
         .mips64,
         .mips64el,
-        .riscv32,
         .s390x,
+        .sparc,
+        .sparc64,
         => false,
         .arm,
         .armeb,
@@ -12472,7 +12746,7 @@ fn backendSupportsF16(target: std.Target) bool {
 }
 
 /// This function returns true if we expect LLVM to lower f128 correctly,
-/// and false if we expect LLVm to crash if it encounters and f128 type
+/// and false if we expect LLVM to crash if it encounters an f128 type,
 /// or if it produces miscompilations.
 fn backendSupportsF128(target: std.Target) bool {
     return switch (target.cpu.arch) {
@@ -12499,7 +12773,7 @@ fn backendSupportsF128(target: std.Target) bool {
 }
 
 /// LLVM does not support all relevant intrinsics for all targets, so we
-/// may need to manually generate a libc call
+/// may need to manually generate a compiler-rt call.
 fn intrinsicsAllowed(scalar_ty: Type, target: std.Target) bool {
     return switch (scalar_ty.toIntern()) {
         .f16_type => backendSupportsF16(target),
diff --git a/zig/src/codegen/llvm/Builder.zig b/zig/src/codegen/llvm/Builder.zig
index d3aa6e34c4..3c687b5e3c 100644
--- a/zig/src/codegen/llvm/Builder.zig
+++ b/zig/src/codegen/llvm/Builder.zig
@@ -1932,6 +1932,7 @@ pub const AddrSpace = enum(u24) {
         pub const constant_32bit: AddrSpace = @enumFromInt(6);
         pub const buffer_fat_pointer: AddrSpace = @enumFromInt(7);
         pub const buffer_resource: AddrSpace = @enumFromInt(8);
+        pub const buffer_strided_pointer: AddrSpace = @enumFromInt(9);
         pub const param_d: AddrSpace = @enumFromInt(6);
         pub const param_i: AddrSpace = @enumFromInt(7);
         pub const constant_buffer_0: AddrSpace = @enumFromInt(8);
@@ -1950,10 +1951,23 @@ pub const AddrSpace = enum(u24) {
         pub const constant_buffer_13: AddrSpace = @enumFromInt(21);
         pub const constant_buffer_14: AddrSpace = @enumFromInt(22);
         pub const constant_buffer_15: AddrSpace = @enumFromInt(23);
+        pub const streamout_register: AddrSpace = @enumFromInt(128);
+    };
+
+    pub const spirv = struct {
+        pub const function: AddrSpace = @enumFromInt(0);
+        pub const cross_workgroup: AddrSpace = @enumFromInt(1);
+        pub const uniform_constant: AddrSpace = @enumFromInt(2);
+        pub const workgroup: AddrSpace = @enumFromInt(3);
+        pub const generic: AddrSpace = @enumFromInt(4);
+        pub const device_only_intel: AddrSpace = @enumFromInt(5);
+        pub const host_only_intel: AddrSpace = @enumFromInt(6);
+        pub const input: AddrSpace = @enumFromInt(7);
     };
 
     // See llvm/include/llvm/CodeGen/WasmAddressSpaces.h
     pub const wasm = struct {
+        pub const default: AddrSpace = @enumFromInt(0);
         pub const variable: AddrSpace = @enumFromInt(1);
         pub const externref: AddrSpace = @enumFromInt(10);
         pub const funcref: AddrSpace = @enumFromInt(20);
@@ -2052,6 +2066,7 @@ pub const CallConv = enum(u10) {
     x86_intrcc,
     avr_intrcc,
     avr_signalcc,
+    avr_builtincc,
 
     amdgpu_vs = 87,
     amdgpu_gs,
@@ -2060,6 +2075,7 @@ pub const CallConv = enum(u10) {
     amdgpu_kernel,
     x86_regcallcc,
     amdgpu_hs,
+    msp430_builtincc,
 
     amdgpu_ls = 95,
     amdgpu_es,
@@ -2068,9 +2084,15 @@ pub const CallConv = enum(u10) {
 
     amdgpu_gfx = 100,
 
+    m68k_intrcc,
+
     aarch64_sme_preservemost_from_x0 = 102,
     aarch64_sme_preservemost_from_x2,
 
+    m68k_rtdcc = 106,
+
+    riscv_vectorcallcc = 110,
+
     _,
 
     pub const default = CallConv.ccc;
@@ -2115,6 +2137,7 @@ pub const CallConv = enum(u10) {
             .x86_intrcc,
             .avr_intrcc,
             .avr_signalcc,
+            .avr_builtincc,
             .amdgpu_vs,
             .amdgpu_gs,
             .amdgpu_ps,
@@ -2122,13 +2145,17 @@ pub const CallConv = enum(u10) {
             .amdgpu_kernel,
             .x86_regcallcc,
             .amdgpu_hs,
+            .msp430_builtincc,
             .amdgpu_ls,
             .amdgpu_es,
             .aarch64_vector_pcs,
             .aarch64_sve_vector_pcs,
             .amdgpu_gfx,
+            .m68k_intrcc,
             .aarch64_sme_preservemost_from_x0,
             .aarch64_sme_preservemost_from_x2,
+            .m68k_rtdcc,
+            .riscv_vectorcallcc,
             => try writer.print(" {s}", .{@tagName(self)}),
             _ => try writer.print(" cc{d}", .{@intFromEnum(self)}),
         }
@@ -2528,6 +2555,10 @@ pub const Variable = struct {
             return self.ptrConst(builder).global.setLinkage(linkage, builder);
         }
 
+        pub fn setDllStorageClass(self: Index, class: DllStorageClass, builder: *Builder) void {
+            return self.ptrConst(builder).global.setDllStorageClass(class, builder);
+        }
+
         pub fn setUnnamedAddr(self: Index, unnamed_addr: UnnamedAddr, builder: *Builder) void {
             return self.ptrConst(builder).global.setUnnamedAddr(unnamed_addr, builder);
         }
@@ -9800,9 +9831,9 @@ pub fn printUnbuffered(
                         });
                         switch (extra.weights) {
                             .none => {},
-                            .unpredictable => try writer.writeAll(", !unpredictable !{}"),
+                            .unpredictable => try writer.writeAll("!unpredictable !{}"),
                             _ => try writer.print("{}", .{
-                                try metadata_formatter.fmt(", !prof ", @as(Metadata, @enumFromInt(@intFromEnum(extra.weights)))),
+                                try metadata_formatter.fmt("!prof ", @as(Metadata, @enumFromInt(@intFromEnum(extra.weights)))),
                             }),
                         }
                     },
@@ -10081,9 +10112,9 @@ pub fn printUnbuffered(
                         try writer.writeAll("  ]");
                         switch (extra.data.weights) {
                             .none => {},
-                            .unpredictable => try writer.writeAll(", !unpredictable !{}"),
+                            .unpredictable => try writer.writeAll("!unpredictable !{}"),
                             _ => try writer.print("{}", .{
-                                try metadata_formatter.fmt(", !prof ", @as(Metadata, @enumFromInt(@intFromEnum(extra.data.weights)))),
+                                try metadata_formatter.fmt("!prof ", @as(Metadata, @enumFromInt(@intFromEnum(extra.data.weights)))),
                             }),
                         }
                     },
diff --git a/zig/src/codegen/llvm/bindings.zig b/zig/src/codegen/llvm/bindings.zig
index 07183b994f..a146e2a883 100644
--- a/zig/src/codegen/llvm/bindings.zig
+++ b/zig/src/codegen/llvm/bindings.zig
@@ -57,6 +57,15 @@ pub const disposeMessage = LLVMDisposeMessage;
 extern fn LLVMDisposeMessage(Message: [*:0]const u8) void;
 
 pub const TargetMachine = opaque {
+    pub const FloatABI = enum(c_int) {
+        /// Target-specific (either soft or hard depending on triple, etc).
+        Default,
+        /// Soft float.
+        Soft,
+        // Hard float.
+        Hard,
+    };
+
     pub const create = ZigLLVMCreateTargetMachine;
     extern fn ZigLLVMCreateTargetMachine(
         T: *Target,
@@ -68,7 +77,7 @@ pub const TargetMachine = opaque {
         CodeModel: CodeModel,
         function_sections: bool,
         data_sections: bool,
-        float_abi: ABIType,
+        float_abi: FloatABI,
         abi_name: ?[*:0]const u8,
     ) *TargetMachine;
 
@@ -108,7 +117,7 @@ pub const TargetMachine = opaque {
             TraceStores: bool,
             CollectControlFlow: bool,
 
-            pub const Type = enum(c_uint) {
+            pub const Type = enum(c_int) {
                 None = 0,
                 Function,
                 BB,
@@ -166,15 +175,6 @@ pub const RelocMode = enum(c_int) {
     ROPI_RWPI,
 };
 
-pub const ABIType = enum(c_int) {
-    /// Target-specific (either soft or hard depending on triple, etc).
-    Default,
-    /// Soft float.
-    Soft,
-    // Hard float.
-    Hard,
-};
-
 pub const Target = opaque {
     pub const getFromTriple = LLVMGetTargetFromTriple;
     extern fn LLVMGetTargetFromTriple(Triple: [*:0]const u8, T: **Target, ErrorMessage: *[*:0]const u8) Bool;
@@ -303,16 +303,14 @@ pub const LinkCOFF = ZigLLDLinkCOFF;
 pub const LinkELF = ZigLLDLinkELF;
 pub const LinkWasm = ZigLLDLinkWasm;
 
-pub const ObjectFormatType = enum(c_int) {
-    Unknown,
+pub const ArchiveKind = enum(c_int) {
+    GNU,
+    GNU64,
+    BSD,
+    DARWIN,
+    DARWIN64,
     COFF,
-    DXContainer,
-    ELF,
-    GOFF,
-    MachO,
-    SPIRV,
-    Wasm,
-    XCOFF,
+    AIXBIG,
 };
 
 pub const WriteArchive = ZigLLVMWriteArchive;
@@ -320,125 +318,16 @@ extern fn ZigLLVMWriteArchive(
     archive_name: [*:0]const u8,
     file_names_ptr: [*]const [*:0]const u8,
     file_names_len: usize,
-    os_type: OSType,
+    archive_kind: ArchiveKind,
 ) bool;
 
-pub const OSType = enum(c_int) {
-    UnknownOS,
-    Darwin,
-    DragonFly,
-    FreeBSD,
-    Fuchsia,
-    IOS,
-    KFreeBSD,
-    Linux,
-    Lv2,
-    MacOSX,
-    NetBSD,
-    OpenBSD,
-    Solaris,
-    UEFI,
-    Win32,
-    ZOS,
-    Haiku,
-    RTEMS,
-    NaCl,
-    AIX,
-    CUDA,
-    NVCL,
-    AMDHSA,
-    PS4,
-    PS5,
-    ELFIAMCU,
-    TvOS,
-    WatchOS,
-    BridgeOS,
-    DriverKit,
-    XROS,
-    Mesa3D,
-    AMDPAL,
-    HermitCore,
-    Hurd,
-    WASI,
-    Emscripten,
-    ShaderModel,
-    LiteOS,
-    Serenity,
-    Vulkan,
-};
-
-pub const ArchType = enum(c_int) {
-    UnknownArch,
-    arm,
-    armeb,
-    aarch64,
-    aarch64_be,
-    aarch64_32,
-    arc,
-    avr,
-    bpfel,
-    bpfeb,
-    csky,
-    dxil,
-    hexagon,
-    loongarch32,
-    loongarch64,
-    m68k,
-    mips,
-    mipsel,
-    mips64,
-    mips64el,
-    msp430,
-    ppc,
-    ppcle,
-    ppc64,
-    ppc64le,
-    r600,
-    amdgcn,
-    riscv32,
-    riscv64,
-    sparc,
-    sparcv9,
-    sparcel,
-    systemz,
-    tce,
-    tcele,
-    thumb,
-    thumbeb,
-    x86,
-    x86_64,
-    xcore,
-    xtensa,
-    nvptx,
-    nvptx64,
-    le32,
-    le64,
-    amdil,
-    amdil64,
-    hsail,
-    hsail64,
-    spir,
-    spir64,
-    spirv,
-    spirv32,
-    spirv64,
-    kalimba,
-    shave,
-    lanai,
-    wasm32,
-    wasm64,
-    renderscript32,
-    renderscript64,
-    ve,
-};
-
 pub const ParseCommandLineOptions = ZigLLVMParseCommandLineOptions;
 extern fn ZigLLVMParseCommandLineOptions(argc: usize, argv: [*]const [*:0]const u8) void;
 
 pub const WriteImportLibrary = ZigLLVMWriteImportLibrary;
 extern fn ZigLLVMWriteImportLibrary(
     def_path: [*:0]const u8,
-    arch: ArchType,
+    coff_machine: c_uint,
     output_lib_path: [*:0]const u8,
     kill_at: bool,
 ) bool;
diff --git a/zig/src/codegen/spirv.zig b/zig/src/codegen/spirv.zig
index 164367207a..16b4a6dfbd 100644
--- a/zig/src/codegen/spirv.zig
+++ b/zig/src/codegen/spirv.zig
@@ -169,6 +169,13 @@ pub const Object = struct {
     ///   via the usual `intern_map` mechanism.
     ptr_types: PtrTypeMap = .{},
 
+    /// For test declarations for Vulkan, we have to add a push constant with a pointer to a
+    /// buffer that we can use. We only need to generate this once, this holds the link information
+    /// related to that.
+    error_push_constant: ?struct {
+        push_constant_ptr: SpvModule.Decl.Index,
+    } = null,
+
     pub fn init(gpa: Allocator) Object {
         return .{
             .gpa = gpa,
@@ -190,6 +197,7 @@ pub const Object = struct {
         nav_index: InternPool.Nav.Index,
         air: Air,
         liveness: Liveness,
+        do_codegen: bool,
     ) !void {
         const zcu = pt.zcu;
         const gpa = zcu.gpa;
@@ -214,7 +222,7 @@ pub const Object = struct {
         };
         defer nav_gen.deinit();
 
-        nav_gen.genNav() catch |err| switch (err) {
+        nav_gen.genNav(do_codegen) catch |err| switch (err) {
             error.CodegenFail => {
                 try zcu.failed_codegen.put(gpa, nav_index, nav_gen.error_msg.?);
             },
@@ -239,7 +247,7 @@ pub const Object = struct {
     ) !void {
         const nav = pt.zcu.funcInfo(func_index).owner_nav;
         // TODO: Separate types for generating decls and functions?
-        try self.genNav(pt, nav, air, liveness);
+        try self.genNav(pt, nav, air, liveness, true);
     }
 
     pub fn updateNav(
@@ -247,7 +255,7 @@ pub const Object = struct {
         pt: Zcu.PerThread,
         nav: InternPool.Nav.Index,
     ) !void {
-        try self.genNav(pt, nav, undefined, undefined);
+        try self.genNav(pt, nav, undefined, undefined, false);
     }
 
     /// Fetch or allocate a result id for nav index. This function also marks the nav as alive.
@@ -723,13 +731,15 @@ const NavGen = struct {
             .direct => {
                 const result_ty_id = try self.resolveType(Type.bool, .direct);
                 const result_id = self.spv.allocId();
-                const operands = .{
-                    .id_result_type = result_ty_id,
-                    .id_result = result_id,
-                };
                 switch (value) {
-                    true => try section.emit(self.spv.gpa, .OpConstantTrue, operands),
-                    false => try section.emit(self.spv.gpa, .OpConstantFalse, operands),
+                    inline else => |val_ct| try section.emit(
+                        self.spv.gpa,
+                        if (val_ct) .OpConstantTrue else .OpConstantFalse,
+                        .{
+                            .id_result_type = result_ty_id,
+                            .id_result = result_id,
+                        },
+                    ),
                 }
                 return result_id;
             },
@@ -889,7 +899,7 @@ const NavGen = struct {
         const result_ty_id = try self.resolveType(ty, repr);
         const ip = &zcu.intern_pool;
 
-        log.debug("lowering constant: ty = {}, val = {}", .{ ty.fmt(pt), val.fmtValue(pt) });
+        log.debug("lowering constant: ty = {}, val = {}, key = {s}", .{ ty.fmt(pt), val.fmtValue(pt), @tagName(ip.indexToKey(val.toIntern())) });
         if (val.isUndefDeep(zcu)) {
             return self.spv.constUndef(result_ty_id);
         }
@@ -907,7 +917,7 @@ const NavGen = struct {
                 .error_union_type,
                 .simple_type,
                 .struct_type,
-                .anon_struct_type,
+                .tuple_type,
                 .union_type,
                 .opaque_type,
                 .enum_type,
@@ -929,7 +939,7 @@ const NavGen = struct {
                     .undefined,
                     .void,
                     .null,
-                    .empty_struct,
+                    .empty_tuple,
                     .@"unreachable",
                     .generic_poison,
                     => unreachable, // non-runtime values
@@ -1117,7 +1127,7 @@ const NavGen = struct {
 
                         return try self.constructStruct(ty, types.items, constituents.items);
                     },
-                    .anon_struct_type => unreachable, // TODO
+                    .tuple_type => unreachable, // TODO
                     else => unreachable,
                 },
                 .un => |un| {
@@ -1159,7 +1169,6 @@ const NavGen = struct {
 
     fn derivePtr(self: *NavGen, derivation: Value.PointerDeriveStep) Error!IdRef {
         const pt = self.pt;
-        const zcu = pt.zcu;
         switch (derivation) {
             .comptime_alloc_ptr, .comptime_field_ptr => unreachable,
             .int => |int| {
@@ -1203,10 +1212,6 @@ const NavGen = struct {
                     if (oac.byte_offset != 0) break :disallow;
                     // Allow changing the pointer type child only to restructure arrays.
                     // e.g. [3][2]T to T is fine, as is [2]T -> [2][1]T.
-                    const src_base_ty = parent_ptr_ty.arrayBase(zcu)[0];
-                    const dest_base_ty = oac.new_ptr_ty.arrayBase(zcu)[0];
-                    if (self.getTarget().os.tag == .vulkan and src_base_ty.toIntern() != dest_base_ty.toIntern()) break :disallow;
-
                     const result_ty_id = try self.resolveType(oac.new_ptr_ty, .direct);
                     const result_ptr_id = self.spv.allocId();
                     try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
@@ -1216,7 +1221,7 @@ const NavGen = struct {
                     });
                     return result_ptr_id;
                 }
-                return self.fail("Cannot perform pointer cast: '{}' to '{}'", .{
+                return self.fail("cannot perform pointer cast: '{}' to '{}'", .{
                     parent_ptr_ty.fmt(pt),
                     oac.new_ptr_ty.fmt(pt),
                 });
@@ -1300,12 +1305,12 @@ const NavGen = struct {
             .global, .invocation_global => spv_decl.result_id,
         };
 
-        const final_storage_class = self.spvStorageClass(nav.status.resolved.@"addrspace");
-        try self.addFunctionDep(spv_decl_index, final_storage_class);
+        const storage_class = self.spvStorageClass(nav.status.resolved.@"addrspace");
+        try self.addFunctionDep(spv_decl_index, storage_class);
 
-        const decl_ptr_ty_id = try self.ptrType(nav_ty, final_storage_class);
+        const decl_ptr_ty_id = try self.ptrType(nav_ty, storage_class);
 
-        const ptr_id = switch (final_storage_class) {
+        const ptr_id = switch (storage_class) {
             .Generic => try self.castToGeneric(decl_ptr_ty_id, decl_id),
             else => decl_id,
         };
@@ -1495,10 +1500,13 @@ const NavGen = struct {
             member_names[layout.padding_index] = "(padding)";
         }
 
-        const result_id = try self.spv.structType(member_types[0..layout.total_fields], member_names[0..layout.total_fields]);
+        const result_id = self.spv.allocId();
+        try self.spv.structType(result_id, member_types[0..layout.total_fields], member_names[0..layout.total_fields]);
+
         const type_name = try self.resolveTypeName(ty);
         defer self.gpa.free(type_name);
         try self.spv.debugName(result_id, type_name);
+
         return result_id;
     }
 
@@ -1630,7 +1638,13 @@ const NavGen = struct {
                     // can be lowered to ptrAccessChain instead of manually performing the math.
                     return try self.arrayType(1, elem_ty_id);
                 } else {
-                    return try self.arrayType(total_len, elem_ty_id);
+                    const result_id = try self.arrayType(total_len, elem_ty_id);
+                    if (target.os.tag == .vulkan) {
+                        try self.spv.decorate(result_id, .{ .ArrayStride = .{
+                            .array_stride = @intCast(elem_ty.abiSize(zcu)),
+                        } });
+                    }
+                    return result_id;
                 }
             },
             .@"fn" => switch (repr) {
@@ -1639,13 +1653,18 @@ const NavGen = struct {
 
                     comptime assert(zig_call_abi_ver == 3);
                     switch (fn_info.cc) {
-                        .Unspecified, .Kernel, .Fragment, .Vertex, .C => {},
-                        else => unreachable, // TODO
+                        .auto,
+                        .spirv_kernel,
+                        .spirv_fragment,
+                        .spirv_vertex,
+                        .spirv_device,
+                        => {},
+                        else => unreachable,
                     }
 
-                    // TODO: Put this somewhere in Sema.zig
-                    if (fn_info.is_var_args)
-                        return self.fail("VarArgs functions are unsupported for SPIR-V", .{});
+                    // Guaranteed by callConvSupportsVarArgs, there are no SPIR-V CCs which support
+                    // varargs.
+                    assert(!fn_info.is_var_args);
 
                     // Note: Logic is different from functionType().
                     const param_ty_ids = try self.gpa.alloc(IdRef, fn_info.param_types.len);
@@ -1679,18 +1698,28 @@ const NavGen = struct {
             .pointer => {
                 const ptr_info = ty.ptrInfo(zcu);
 
+                const child_ty = Type.fromInterned(ptr_info.child);
                 const storage_class = self.spvStorageClass(ptr_info.flags.address_space);
-                const ptr_ty_id = try self.ptrType(Type.fromInterned(ptr_info.child), storage_class);
+                const ptr_ty_id = try self.ptrType(child_ty, storage_class);
+
+                if (target.os.tag == .vulkan and ptr_info.flags.size == .Many) {
+                    try self.spv.decorate(ptr_ty_id, .{ .ArrayStride = .{
+                        .array_stride = @intCast(child_ty.abiSize(zcu)),
+                    } });
+                }
 
                 if (ptr_info.flags.size != .Slice) {
                     return ptr_ty_id;
                 }
 
                 const size_ty_id = try self.resolveType(Type.usize, .direct);
-                return self.spv.structType(
+                const result_id = self.spv.allocId();
+                try self.spv.structType(
+                    result_id,
                     &.{ ptr_ty_id, size_ty_id },
                     &.{ "ptr", "len" },
                 );
+                return result_id;
             },
             .vector => {
                 const elem_ty = ty.childType(zcu);
@@ -1705,7 +1734,7 @@ const NavGen = struct {
             },
             .@"struct" => {
                 const struct_type = switch (ip.indexToKey(ty.toIntern())) {
-                    .anon_struct_type => |tuple| {
+                    .tuple_type => |tuple| {
                         const member_types = try self.gpa.alloc(IdRef, tuple.values.len);
                         defer self.gpa.free(member_types);
 
@@ -1717,10 +1746,17 @@ const NavGen = struct {
                             member_index += 1;
                         }
 
-                        const result_id = try self.spv.structType(member_types[0..member_index], null);
+                        const result_id = self.spv.allocId();
+                        try self.spv.structType(result_id, member_types[0..member_index], null);
+
                         const type_name = try self.resolveTypeName(ty);
                         defer self.gpa.free(type_name);
                         try self.spv.debugName(result_id, type_name);
+
+                        if (target.os.tag == .vulkan) {
+                            try self.spv.decorate(result_id, .Block); // Decorate all structs as block for now...
+                        }
+
                         return result_id;
                     },
                     .struct_type => ip.loadStructType(ty.toIntern()),
@@ -1737,7 +1773,9 @@ const NavGen = struct {
                 var member_names = std.ArrayList([]const u8).init(self.gpa);
                 defer member_names.deinit();
 
+                var index: u32 = 0;
                 var it = struct_type.iterateRuntimeOrder(ip);
+                const result_id = self.spv.allocId();
                 while (it.next()) |field_index| {
                     const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[field_index]);
                     if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
@@ -1745,16 +1783,29 @@ const NavGen = struct {
                         continue;
                     }
 
+                    if (target.os.tag == .vulkan) {
+                        try self.spv.decorateMember(result_id, index, .{ .Offset = .{
+                            .byte_offset = @intCast(ty.structFieldOffset(field_index, zcu)),
+                        } });
+                    }
                     const field_name = struct_type.fieldName(ip, field_index).unwrap() orelse
                         try ip.getOrPutStringFmt(zcu.gpa, pt.tid, "{d}", .{field_index}, .no_embedded_nulls);
                     try member_types.append(try self.resolveType(field_ty, .indirect));
                     try member_names.append(field_name.toSlice(ip));
+
+                    index += 1;
                 }
 
-                const result_id = try self.spv.structType(member_types.items, member_names.items);
+                try self.spv.structType(result_id, member_types.items, member_names.items);
+
                 const type_name = try self.resolveTypeName(ty);
                 defer self.gpa.free(type_name);
                 try self.spv.debugName(result_id, type_name);
+
+                if (target.os.tag == .vulkan) {
+                    try self.spv.decorate(result_id, .Block); // Decorate all structs as block for now...
+                }
+
                 return result_id;
             },
             .optional => {
@@ -1774,10 +1825,13 @@ const NavGen = struct {
 
                 const bool_ty_id = try self.resolveType(Type.bool, .indirect);
 
-                return try self.spv.structType(
+                const result_id = self.spv.allocId();
+                try self.spv.structType(
+                    result_id,
                     &.{ payload_ty_id, bool_ty_id },
                     &.{ "payload", "valid" },
                 );
+                return result_id;
             },
             .@"union" => return try self.resolveUnionType(ty),
             .error_set => return try self.resolveType(Type.u16, repr),
@@ -1806,7 +1860,9 @@ const NavGen = struct {
                     // TODO: ABI padding?
                 }
 
-                return try self.spv.structType(&member_types, &member_names);
+                const result_id = self.spv.allocId();
+                try self.spv.structType(result_id, &member_types, &member_names);
+                return result_id;
             },
             .@"opaque" => {
                 const type_name = try self.resolveTypeName(ty);
@@ -1836,16 +1892,23 @@ const NavGen = struct {
         const target = self.getTarget();
         return switch (as) {
             .generic => switch (target.os.tag) {
-                .vulkan => .Private,
-                else => .Generic,
+                .vulkan => .Function,
+                .opencl => .Generic,
+                else => unreachable,
             },
             .shared => .Workgroup,
-            .local => .Private,
-            .global => .CrossWorkgroup,
+            .local => .Function,
+            .global => switch (target.os.tag) {
+                .opencl => .CrossWorkgroup,
+                .vulkan => .PhysicalStorageBuffer,
+                else => unreachable,
+            },
             .constant => .UniformConstant,
+            .push_constant => .PushConstant,
             .input => .Input,
             .output => .Output,
             .uniform => .Uniform,
+            .storage_buffer => .StorageBuffer,
             .gs,
             .fs,
             .ss,
@@ -2813,18 +2876,12 @@ const NavGen = struct {
                 }
             },
             .vulkan => {
-                const op_result_ty = blk: {
-                    // Operations return a struct{T, T}
-                    // where T is maybe vectorized.
-                    const types = [2]InternPool.Index{ arith_op_ty.toIntern(), arith_op_ty.toIntern() };
-                    const values = [2]InternPool.Index{ .none, .none };
-                    const index = try ip.getAnonStructType(zcu.gpa, pt.tid, .{
-                        .types = &types,
-                        .values = &values,
-                        .names = &.{},
-                    });
-                    break :blk Type.fromInterned(index);
-                };
+                // Operations return a struct{T, T}
+                // where T is maybe vectorized.
+                const op_result_ty: Type = .fromInterned(try ip.getTupleType(zcu.gpa, pt.tid, .{
+                    .types = &.{ arith_op_ty.toIntern(), arith_op_ty.toIntern() },
+                    .values = &.{ .none, .none },
+                }));
                 const op_result_ty_id = try self.resolveType(op_result_ty, .direct);
 
                 const opcode: Opcode = switch (op) {
@@ -2897,30 +2954,116 @@ const NavGen = struct {
             .flags = .{ .address_space = .global },
         });
         const ptr_anyerror_ty_id = try self.resolveType(ptr_anyerror_ty, .direct);
-        const kernel_proto_ty_id = try self.functionType(Type.void, &.{ptr_anyerror_ty});
-
-        const test_id = self.spv.declPtr(spv_test_decl_index).result_id;
 
         const spv_decl_index = try self.spv.allocDecl(.func);
         const kernel_id = self.spv.declPtr(spv_decl_index).result_id;
+        // for some reason we don't need to decorate the push constant here...
+        try self.spv.declareDeclDeps(spv_decl_index, &.{spv_test_decl_index});
+
+        const section = &self.spv.sections.functions;
+
+        const target = self.getTarget();
 
-        const error_id = self.spv.allocId();
         const p_error_id = self.spv.allocId();
+        switch (target.os.tag) {
+            .opencl => {
+                const kernel_proto_ty_id = try self.functionType(Type.void, &.{ptr_anyerror_ty});
 
-        const section = &self.spv.sections.functions;
-        try section.emit(self.spv.gpa, .OpFunction, .{
-            .id_result_type = try self.resolveType(Type.void, .direct),
-            .id_result = kernel_id,
-            .function_control = .{},
-            .function_type = kernel_proto_ty_id,
-        });
-        try section.emit(self.spv.gpa, .OpFunctionParameter, .{
-            .id_result_type = ptr_anyerror_ty_id,
-            .id_result = p_error_id,
-        });
-        try section.emit(self.spv.gpa, .OpLabel, .{
-            .id_result = self.spv.allocId(),
-        });
+                try section.emit(self.spv.gpa, .OpFunction, .{
+                    .id_result_type = try self.resolveType(Type.void, .direct),
+                    .id_result = kernel_id,
+                    .function_control = .{},
+                    .function_type = kernel_proto_ty_id,
+                });
+
+                try section.emit(self.spv.gpa, .OpFunctionParameter, .{
+                    .id_result_type = ptr_anyerror_ty_id,
+                    .id_result = p_error_id,
+                });
+
+                try section.emit(self.spv.gpa, .OpLabel, .{
+                    .id_result = self.spv.allocId(),
+                });
+            },
+            .vulkan => {
+                const ptr_ptr_anyerror_ty_id = self.spv.allocId();
+                try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpTypePointer, .{
+                    .id_result = ptr_ptr_anyerror_ty_id,
+                    .storage_class = .PushConstant,
+                    .type = ptr_anyerror_ty_id,
+                });
+
+                if (self.object.error_push_constant == null) {
+                    const spv_err_decl_index = try self.spv.allocDecl(.global);
+                    try self.spv.declareDeclDeps(spv_err_decl_index, &.{});
+
+                    const push_constant_struct_ty_id = self.spv.allocId();
+                    try self.spv.structType(push_constant_struct_ty_id, &.{ptr_anyerror_ty_id}, &.{"error_out_ptr"});
+                    try self.spv.decorate(push_constant_struct_ty_id, .Block);
+                    try self.spv.decorateMember(push_constant_struct_ty_id, 0, .{ .Offset = .{ .byte_offset = 0 } });
+
+                    const ptr_push_constant_struct_ty_id = self.spv.allocId();
+                    try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpTypePointer, .{
+                        .id_result = ptr_push_constant_struct_ty_id,
+                        .storage_class = .PushConstant,
+                        .type = push_constant_struct_ty_id,
+                    });
+
+                    try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpVariable, .{
+                        .id_result_type = ptr_push_constant_struct_ty_id,
+                        .id_result = self.spv.declPtr(spv_err_decl_index).result_id,
+                        .storage_class = .PushConstant,
+                    });
+
+                    self.object.error_push_constant = .{
+                        .push_constant_ptr = spv_err_decl_index,
+                    };
+                }
+
+                try self.spv.sections.execution_modes.emit(self.spv.gpa, .OpExecutionMode, .{
+                    .entry_point = kernel_id,
+                    .mode = .{ .LocalSize = .{
+                        .x_size = 1,
+                        .y_size = 1,
+                        .z_size = 1,
+                    } },
+                });
+
+                const kernel_proto_ty_id = try self.functionType(Type.void, &.{});
+                try section.emit(self.spv.gpa, .OpFunction, .{
+                    .id_result_type = try self.resolveType(Type.void, .direct),
+                    .id_result = kernel_id,
+                    .function_control = .{},
+                    .function_type = kernel_proto_ty_id,
+                });
+                try section.emit(self.spv.gpa, .OpLabel, .{
+                    .id_result = self.spv.allocId(),
+                });
+
+                const spv_err_decl_index = self.object.error_push_constant.?.push_constant_ptr;
+                const push_constant_id = self.spv.declPtr(spv_err_decl_index).result_id;
+
+                const zero_id = try self.constInt(Type.u32, 0, .direct);
+                // We cannot use OpInBoundsAccessChain to dereference cross-storage class, so we have to use
+                // a load.
+                const tmp = self.spv.allocId();
+                try section.emit(self.spv.gpa, .OpInBoundsAccessChain, .{
+                    .id_result_type = ptr_ptr_anyerror_ty_id,
+                    .id_result = tmp,
+                    .base = push_constant_id,
+                    .indexes = &.{zero_id},
+                });
+                try section.emit(self.spv.gpa, .OpLoad, .{
+                    .id_result_type = ptr_anyerror_ty_id,
+                    .id_result = p_error_id,
+                    .pointer = tmp,
+                });
+            },
+            else => unreachable,
+        }
+
+        const test_id = self.spv.declPtr(spv_test_decl_index).result_id;
+        const error_id = self.spv.allocId();
         try section.emit(self.spv.gpa, .OpFunctionCall, .{
             .id_result_type = anyerror_ty_id,
             .id_result = error_id,
@@ -2930,29 +3073,43 @@ const NavGen = struct {
         try section.emit(self.spv.gpa, .OpStore, .{
             .pointer = p_error_id,
             .object = error_id,
+            .memory_access = .{
+                .Aligned = .{ .literal_integer = @sizeOf(u16) },
+            },
         });
         try section.emit(self.spv.gpa, .OpReturn, {});
         try section.emit(self.spv.gpa, .OpFunctionEnd, {});
 
-        try self.spv.declareDeclDeps(spv_decl_index, &.{spv_test_decl_index});
-
         // Just generate a quick other name because the intel runtime crashes when the entry-
         // point name is the same as a different OpName.
         const test_name = try std.fmt.allocPrint(self.gpa, "test {s}", .{name});
         defer self.gpa.free(test_name);
-        try self.spv.declareEntryPoint(spv_decl_index, test_name, .Kernel);
+
+        const execution_mode: spec.ExecutionModel = switch (target.os.tag) {
+            .vulkan => .GLCompute,
+            .opencl => .Kernel,
+            else => unreachable,
+        };
+
+        try self.spv.declareEntryPoint(spv_decl_index, test_name, execution_mode);
     }
 
-    fn genNav(self: *NavGen) !void {
+    fn genNav(self: *NavGen, do_codegen: bool) !void {
         const pt = self.pt;
         const zcu = pt.zcu;
         const ip = &zcu.intern_pool;
-        const spv_decl_index = try self.object.resolveNav(zcu, self.owner_nav);
-        const result_id = self.spv.declPtr(spv_decl_index).result_id;
 
         const nav = ip.getNav(self.owner_nav);
         const val = zcu.navValue(self.owner_nav);
         const ty = val.typeOf(zcu);
+
+        if (!do_codegen and !ty.hasRuntimeBits(zcu)) {
+            return;
+        }
+
+        const spv_decl_index = try self.object.resolveNav(zcu, self.owner_nav);
+        const result_id = self.spv.declPtr(spv_decl_index).result_id;
+
         switch (self.spv.declPtr(spv_decl_index).kind) {
             .func => {
                 const fn_info = zcu.typeToFunc(ty).?;
@@ -2962,11 +3119,10 @@ const NavGen = struct {
                 try self.func.prologue.emit(self.spv.gpa, .OpFunction, .{
                     .id_result_type = return_ty_id,
                     .id_result = result_id,
-                    .function_control = switch (fn_info.cc) {
-                        .Inline => .{ .Inline = true },
-                        else => .{},
-                    },
                     .function_type = prototype_ty_id,
+                    // Note: the backend will never be asked to generate an inline function
+                    // (this is handled in sema), so we don't need to set function_control here.
+                    .function_control = .{},
                 });
 
                 comptime assert(zig_call_abi_ver == 3);
@@ -3026,15 +3182,15 @@ const NavGen = struct {
                 };
                 assert(maybe_init_val == null); // TODO
 
-                const final_storage_class = self.spvStorageClass(nav.status.resolved.@"addrspace");
-                assert(final_storage_class != .Generic); // These should be instance globals
+                const storage_class = self.spvStorageClass(nav.status.resolved.@"addrspace");
+                assert(storage_class != .Generic); // These should be instance globals
 
-                const ptr_ty_id = try self.ptrType(ty, final_storage_class);
+                const ptr_ty_id = try self.ptrType(ty, storage_class);
 
                 try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpVariable, .{
                     .id_result_type = ptr_ty_id,
                     .id_result = result_id,
-                    .storage_class = final_storage_class,
+                    .storage_class = storage_class,
                 });
 
                 try self.spv.debugName(result_id, nav.fqn.toSlice(ip));
@@ -3343,7 +3499,9 @@ const NavGen = struct {
             .store, .store_safe => return self.airStore(inst),
 
             .br             => return self.airBr(inst),
-            .repeat         => return self.fail("TODO implement `repeat`", .{}),
+            // For now just ignore this instruction. This effectively falls back on the old implementation,
+            // this doesn't change anything for us.
+            .repeat         => return,
             .breakpoint     => return,
             .cond_br        => return self.airCondBr(inst),
             .loop           => return self.airLoop(inst),
@@ -3356,7 +3514,7 @@ const NavGen = struct {
 
             .dbg_stmt                  => return self.airDbgStmt(inst),
             .dbg_inline_block          => try self.airDbgInlineBlock(inst),
-            .dbg_var_ptr, .dbg_var_val => return self.airDbgVar(inst),
+            .dbg_var_ptr, .dbg_var_val, .dbg_arg_inline => return self.airDbgVar(inst),
 
             .unwrap_errunion_err => try self.airErrUnionErr(inst),
             .unwrap_errunion_payload => try self.airErrUnionPayload(inst),
@@ -4212,13 +4370,24 @@ const NavGen = struct {
         defer self.gpa.free(ids);
 
         const result_id = self.spv.allocId();
-        try self.func.body.emit(self.spv.gpa, .OpInBoundsPtrAccessChain, .{
-            .id_result_type = result_ty_id,
-            .id_result = result_id,
-            .base = base,
-            .element = element,
-            .indexes = ids,
-        });
+        const target = self.getTarget();
+        switch (target.os.tag) {
+            .opencl => try self.func.body.emit(self.spv.gpa, .OpInBoundsPtrAccessChain, .{
+                .id_result_type = result_ty_id,
+                .id_result = result_id,
+                .base = base,
+                .element = element,
+                .indexes = ids,
+            }),
+            .vulkan => try self.func.body.emit(self.spv.gpa, .OpPtrAccessChain, .{
+                .id_result_type = result_ty_id,
+                .id_result = result_id,
+                .base = base,
+                .element = element,
+                .indexes = ids,
+            }),
+            else => unreachable,
+        }
         return result_id;
     }
 
@@ -4746,7 +4915,7 @@ const NavGen = struct {
                 var index: usize = 0;
 
                 switch (ip.indexToKey(result_ty.toIntern())) {
-                    .anon_struct_type => |tuple| {
+                    .tuple_type => |tuple| {
                         for (tuple.types.get(ip), elements, 0..) |field_ty, element, i| {
                             if ((try result_ty.structFieldValueComptime(pt, i)) != null) continue;
                             assert(Type.fromInterned(field_ty).hasRuntimeBits(zcu));
@@ -6095,15 +6264,20 @@ const NavGen = struct {
             try self.extractField(Type.anyerror, operand_id, eu_layout.errorFieldIndex());
 
         const result_id = self.spv.allocId();
-        const operands = .{
-            .id_result_type = bool_ty_id,
-            .id_result = result_id,
-            .operand_1 = error_id,
-            .operand_2 = try self.constInt(Type.anyerror, 0, .direct),
-        };
         switch (pred) {
-            .is_err => try self.func.body.emit(self.spv.gpa, .OpINotEqual, operands),
-            .is_non_err => try self.func.body.emit(self.spv.gpa, .OpIEqual, operands),
+            inline else => |pred_ct| try self.func.body.emit(
+                self.spv.gpa,
+                switch (pred_ct) {
+                    .is_err => .OpINotEqual,
+                    .is_non_err => .OpIEqual,
+                },
+                .{
+                    .id_result_type = bool_ty_id,
+                    .id_result = result_id,
+                    .operand_1 = error_id,
+                    .operand_2 = try self.constInt(Type.anyerror, 0, .direct),
+                },
+            ),
         }
         return result_id;
     }
@@ -6382,6 +6556,13 @@ const NavGen = struct {
             return self.todo("implement inline asm with more than 1 output", .{});
         }
 
+        var as = SpvAssembler{
+            .gpa = self.gpa,
+            .spv = self.spv,
+            .func = &self.func,
+        };
+        defer as.deinit();
+
         var output_extra_i = extra_i;
         for (outputs) |output| {
             if (output != .none) {
@@ -6394,7 +6575,6 @@ const NavGen = struct {
             // TODO: Record output and use it somewhere.
         }
 
-        var input_extra_i = extra_i;
         for (inputs) |input| {
             const extra_bytes = std.mem.sliceAsBytes(self.air.extra[extra_i..]);
             const constraint = std.mem.sliceTo(extra_bytes, 0);
@@ -6402,8 +6582,63 @@ const NavGen = struct {
             // 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;
-            // TODO: Record input and use it somewhere.
-            _ = input;
+
+            const input_ty = self.typeOf(input);
+
+            if (std.mem.eql(u8, constraint, "c")) {
+                // constant
+                const val = (try self.air.value(input, self.pt)) orelse {
+                    return self.fail("assembly inputs with 'c' constraint have to be compile-time known", .{});
+                };
+
+                // TODO: This entire function should be handled a bit better...
+                const ip = &zcu.intern_pool;
+                switch (ip.indexToKey(val.toIntern())) {
+                    .int_type,
+                    .ptr_type,
+                    .array_type,
+                    .vector_type,
+                    .opt_type,
+                    .anyframe_type,
+                    .error_union_type,
+                    .simple_type,
+                    .struct_type,
+                    .union_type,
+                    .opaque_type,
+                    .enum_type,
+                    .func_type,
+                    .error_set_type,
+                    .inferred_error_set_type,
+                    => unreachable, // types, not values
+
+                    .undef => return self.fail("assembly input with 'c' constraint cannot be undefined", .{}),
+
+                    .int => {
+                        try as.value_map.put(as.gpa, name, .{ .constant = @intCast(val.toUnsignedInt(zcu)) });
+                    },
+
+                    else => unreachable, // TODO
+                }
+            } else if (std.mem.eql(u8, 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 self.air.value(input, self.pt)).?;
+                    const ty_id = try self.resolveType(val.toType(), .direct);
+                    try as.value_map.put(as.gpa, name, .{ .ty = ty_id });
+                } else {
+                    const ty_id = try self.resolveType(input_ty, .direct);
+                    try as.value_map.put(as.gpa, name, .{ .ty = ty_id });
+                }
+            } else {
+                if (input_ty.zigTypeTag(zcu) == .type) {
+                    return self.fail("use the 't' constraint to supply types to SPIR-V inline assembly", .{});
+                }
+
+                const val_id = try self.resolve(input);
+                try as.value_map.put(as.gpa, name, .{ .value = val_id });
+            }
         }
 
         {
@@ -6417,27 +6652,7 @@ const NavGen = struct {
 
         const asm_source = std.mem.sliceAsBytes(self.air.extra[extra_i..])[0..extra.data.source_len];
 
-        var as = SpvAssembler{
-            .gpa = self.gpa,
-            .src = asm_source,
-            .spv = self.spv,
-            .func = &self.func,
-        };
-        defer as.deinit();
-
-        for (inputs) |input| {
-            const extra_bytes = std.mem.sliceAsBytes(self.air.extra[input_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.
-            input_extra_i += (constraint.len + name.len + (2 + 3)) / 4;
-
-            const value = try self.resolve(input);
-            try as.value_map.put(as.gpa, name, .{ .value = value });
-        }
-
-        as.assemble() catch |err| switch (err) {
+        as.assemble(asm_source) catch |err| switch (err) {
             error.AssembleFail => {
                 // TODO: For now the compiler only supports a single error message per decl,
                 // so to translate the possible multiple errors from the assembler, emit
@@ -6482,6 +6697,7 @@ const NavGen = struct {
                 .just_declared, .unresolved_forward_reference => unreachable,
                 .ty => return self.fail("cannot return spir-v type as value from assembly", .{}),
                 .value => |ref| return ref,
+                .constant => return self.fail("cannot return constant from assembly", .{}),
             }
 
             // TODO: Multiple results
@@ -6535,10 +6751,6 @@ const NavGen = struct {
             .id_ref_3 = params[0..n_params],
         });
 
-        if (return_type == .noreturn_type) {
-            try self.func.body.emit(self.spv.gpa, .OpUnreachable, {});
-        }
-
         if (self.liveness.isUnused(inst) or !Type.fromInterned(return_type).hasRuntimeBitsIgnoreComptime(zcu)) {
             return null;
         }
diff --git a/zig/src/codegen/spirv/Assembler.zig b/zig/src/codegen/spirv/Assembler.zig
index 9e39f2ed09..2cfb590273 100644
--- a/zig/src/codegen/spirv/Assembler.zig
+++ b/zig/src/codegen/spirv/Assembler.zig
@@ -45,6 +45,9 @@ const Token = struct {
         pipe,
         /// =.
         equals,
+        /// $identifier. This is used (for now) for constant values, like integers.
+        /// These can be used in place of a normal `value`.
+        placeholder,
 
         fn name(self: Tag) []const u8 {
             return switch (self) {
@@ -56,6 +59,7 @@ const Token = struct {
                 .string => "<string literal>",
                 .pipe => "'|'",
                 .equals => "'='",
+                .placeholder => "<placeholder>",
             };
         }
     };
@@ -128,12 +132,19 @@ const AsmValue = union(enum) {
     /// This result-value represents a type registered into the module's type system.
     ty: IdRef,
 
+    /// This is a pre-supplied constant integer value.
+    constant: u32,
+
     /// Retrieve the result-id of this AsmValue. Asserts that this AsmValue
     /// is of a variant that allows the result to be obtained (not an unresolved
     /// forward declaration, not in the process of being declared, etc).
     pub fn resultId(self: AsmValue) IdRef {
         return switch (self) {
-            .just_declared, .unresolved_forward_reference => unreachable,
+            .just_declared,
+            .unresolved_forward_reference,
+            // TODO: Lower this value as constant?
+            .constant,
+            => unreachable,
             .value => |result| result,
             .ty => |result| result,
         };
@@ -151,7 +162,8 @@ gpa: Allocator,
 errors: std.ArrayListUnmanaged(ErrorMsg) = .empty,
 
 /// The source code that is being assembled.
-src: []const u8,
+/// This is set when calling `assemble()`.
+src: []const u8 = undefined,
 
 /// The module that this assembly is associated to.
 /// Instructions like OpType*, OpDecorate, etc are emitted into this module.
@@ -211,7 +223,10 @@ pub fn deinit(self: *Assembler) void {
     self.instruction_map.deinit(self.gpa);
 }
 
-pub fn assemble(self: *Assembler) Error!void {
+pub fn assemble(self: *Assembler, src: []const u8) Error!void {
+    self.src = src;
+    self.errors.clearRetainingCapacity();
+
     // Populate the opcode map if it isn't already
     if (self.instruction_map.count() == 0) {
         const instructions = spec.InstructionSet.core.instructions();
@@ -369,6 +384,7 @@ fn processTypeInstruction(self: *Assembler) !AsmValue {
 /// - Function-local instructions are emitted in `self.func`.
 fn processGenericInstruction(self: *Assembler) !?AsmValue {
     const operands = self.inst.operands.items;
+    var maybe_spv_decl_index: ?SpvModule.Decl.Index = null;
     const section = switch (self.inst.opcode.class()) {
         .ConstantCreation => &self.spv.sections.types_globals_constants,
         .Annotation => &self.spv.sections.annotations,
@@ -378,13 +394,16 @@ fn processGenericInstruction(self: *Assembler) !?AsmValue {
             .OpExecutionMode, .OpExecutionModeId => &self.spv.sections.execution_modes,
             .OpVariable => switch (@as(spec.StorageClass, @enumFromInt(operands[2].value))) {
                 .Function => &self.func.prologue,
-                .UniformConstant => &self.spv.sections.types_globals_constants,
-                else => {
-                    // This is currently disabled because global variables are required to be
-                    // emitted in the proper order, and this should be honored in inline assembly
-                    // as well.
-                    return self.todo("global variables", .{});
+                .Input, .Output => section: {
+                    maybe_spv_decl_index = try self.spv.allocDecl(.global);
+                    try self.func.decl_deps.put(self.spv.gpa, maybe_spv_decl_index.?, {});
+                    // TODO: In theory this can be non-empty if there is an initializer which depends on another global...
+                    try self.spv.declareDeclDeps(maybe_spv_decl_index.?, &.{});
+                    break :section &self.spv.sections.types_globals_constants;
                 },
+                // These don't need to be marked in the dependency system.
+                // Probably we should add them anyway, then filter out PushConstant globals.
+                else => &self.spv.sections.types_globals_constants,
             },
             // Default case - to be worked out further.
             else => &self.func.body,
@@ -409,7 +428,10 @@ fn processGenericInstruction(self: *Assembler) !?AsmValue {
                 section.writeDoubleWord(dword);
             },
             .result_id => {
-                maybe_result_id = self.spv.allocId();
+                maybe_result_id = if (maybe_spv_decl_index) |spv_decl_index|
+                    self.spv.declPtr(spv_decl_index).result_id
+                else
+                    self.spv.allocId();
                 try section.ensureUnusedCapacity(self.spv.gpa, 1);
                 section.writeOperand(IdResult, maybe_result_id.?);
             },
@@ -475,8 +497,8 @@ fn resolveRefId(self: *Assembler, ref: AsmValue.Ref) !IdRef {
 /// error message has been emitted into `self.errors`.
 fn parseInstruction(self: *Assembler) !void {
     self.inst.opcode = undefined;
-    self.inst.operands.shrinkRetainingCapacity(0);
-    self.inst.string_bytes.shrinkRetainingCapacity(0);
+    self.inst.operands.clearRetainingCapacity();
+    self.inst.string_bytes.clearRetainingCapacity();
 
     const lhs_result_tok = self.currentToken();
     const maybe_lhs_result: ?AsmValue.Ref = if (self.eatToken(.result_id_assign)) blk: {
@@ -654,6 +676,22 @@ fn parseRefId(self: *Assembler) !void {
 
 fn parseLiteralInteger(self: *Assembler) !void {
     const tok = self.currentToken();
+    if (self.eatToken(.placeholder)) {
+        const name = self.tokenText(tok)[1..];
+        const value = self.value_map.get(name) orelse {
+            return self.fail(tok.start, "invalid placeholder '${s}'", .{name});
+        };
+        switch (value) {
+            .constant => |literal32| {
+                try self.inst.operands.append(self.gpa, .{ .literal32 = literal32 });
+            },
+            else => {
+                return self.fail(tok.start, "value '{s}' cannot be used as placeholder", .{name});
+            },
+        }
+        return;
+    }
+
     try self.expectToken(.value);
     // According to the SPIR-V machine readable grammar, a LiteralInteger
     // may consist of one or more words. From the SPIR-V docs it seems like there
@@ -669,6 +707,22 @@ fn parseLiteralInteger(self: *Assembler) !void {
 
 fn parseLiteralExtInstInteger(self: *Assembler) !void {
     const tok = self.currentToken();
+    if (self.eatToken(.placeholder)) {
+        const name = self.tokenText(tok)[1..];
+        const value = self.value_map.get(name) orelse {
+            return self.fail(tok.start, "invalid placeholder '${s}'", .{name});
+        };
+        switch (value) {
+            .constant => |literal32| {
+                try self.inst.operands.append(self.gpa, .{ .literal32 = literal32 });
+            },
+            else => {
+                return self.fail(tok.start, "value '{s}' cannot be used as placeholder", .{name});
+            },
+        }
+        return;
+    }
+
     try self.expectToken(.value);
     const text = self.tokenText(tok);
     const value = std.fmt.parseInt(u32, text, 0) catch {
@@ -745,6 +799,22 @@ fn parseContextDependentNumber(self: *Assembler) !void {
 
 fn parseContextDependentInt(self: *Assembler, signedness: std.builtin.Signedness, width: u32) !void {
     const tok = self.currentToken();
+    if (self.eatToken(.placeholder)) {
+        const name = self.tokenText(tok)[1..];
+        const value = self.value_map.get(name) orelse {
+            return self.fail(tok.start, "invalid placeholder '${s}'", .{name});
+        };
+        switch (value) {
+            .constant => |literal32| {
+                try self.inst.operands.append(self.gpa, .{ .literal32 = literal32 });
+            },
+            else => {
+                return self.fail(tok.start, "value '{s}' cannot be used as placeholder", .{name});
+            },
+        }
+        return;
+    }
+
     try self.expectToken(.value);
 
     if (width == 0 or width > 2 * @bitSizeOf(spec.Word)) {
@@ -848,6 +918,8 @@ fn tokenText(self: Assembler, tok: Token) []const u8 {
 /// Tokenize `self.src` and put the tokens in `self.tokens`.
 /// Any errors encountered are appended to `self.errors`.
 fn tokenize(self: *Assembler) !void {
+    self.tokens.clearRetainingCapacity();
+
     var offset: u32 = 0;
     while (true) {
         const tok = try self.nextToken(offset);
@@ -890,6 +962,7 @@ fn nextToken(self: *Assembler, start_offset: u32) !Token {
         string,
         string_end,
         escape,
+        placeholder,
     } = .start;
     var token_start = start_offset;
     var offset = start_offset;
@@ -917,6 +990,10 @@ fn nextToken(self: *Assembler, start_offset: u32) !Token {
                     offset += 1;
                     break;
                 },
+                '$' => {
+                    state = .placeholder;
+                    tag = .placeholder;
+                },
                 else => {
                     state = .value;
                     tag = .value;
@@ -932,11 +1009,11 @@ fn nextToken(self: *Assembler, start_offset: u32) !Token {
                 ' ', '\t', '\r', '\n', '=', '|' => break,
                 else => {},
             },
-            .result_id => switch (c) {
+            .result_id, .placeholder => switch (c) {
                 '_', 'a'...'z', 'A'...'Z', '0'...'9' => {},
                 ' ', '\t', '\r', '\n', '=', '|' => break,
                 else => {
-                    try self.addError(offset, "illegal character in result-id", .{});
+                    try self.addError(offset, "illegal character in result-id or placeholder", .{});
                     // Again, probably a forgotten delimiter here.
                     break;
                 },
diff --git a/zig/src/codegen/spirv/Module.zig b/zig/src/codegen/spirv/Module.zig
index 94787e06b9..f4af74b3aa 100644
--- a/zig/src/codegen/spirv/Module.zig
+++ b/zig/src/codegen/spirv/Module.zig
@@ -402,9 +402,7 @@ pub fn resolveString(self: *Module, string: []const u8) !IdRef {
     return id;
 }
 
-pub fn structType(self: *Module, types: []const IdRef, maybe_names: ?[]const []const u8) !IdRef {
-    const result_id = self.allocId();
-
+pub fn structType(self: *Module, result_id: IdResult, types: []const IdRef, maybe_names: ?[]const []const u8) !void {
     try self.sections.types_globals_constants.emit(self.gpa, .OpTypeStruct, .{
         .id_result = result_id,
         .id_ref = types,
@@ -416,8 +414,6 @@ pub fn structType(self: *Module, types: []const IdRef, maybe_names: ?[]const []c
             try self.memberDebugName(result_id, @intCast(i), name);
         }
     }
-
-    return result_id;
 }
 
 pub fn boolType(self: *Module) !IdRef {
diff --git a/zig/src/crash_report.zig b/zig/src/crash_report.zig
index d9f8bac350..45410890a5 100644
--- a/zig/src/crash_report.zig
+++ b/zig/src/crash_report.zig
@@ -229,7 +229,7 @@ const WindowsSegfaultMessage = union(enum) {
     illegal_instruction: void,
 };
 
-fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) callconv(windows.WINAPI) c_long {
+fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) callconv(.winapi) c_long {
     switch (info.ExceptionRecord.ExceptionCode) {
         windows.EXCEPTION_DATATYPE_MISALIGNMENT => handleSegfaultWindowsExtra(info, .{ .literal = "Unaligned Memory Access" }),
         windows.EXCEPTION_ACCESS_VIOLATION => handleSegfaultWindowsExtra(info, .segfault),
diff --git a/zig/lib/compiler/fmt.zig b/zig/src/fmt.zig
similarity index 94%
rename from zig/lib/compiler/fmt.zig
rename to zig/src/fmt.zig
index 5a4f112c34..b545905367 100644
--- a/zig/lib/compiler/fmt.zig
+++ b/zig/src/fmt.zig
@@ -1,11 +1,3 @@
-const std = @import("std");
-const mem = std.mem;
-const fs = std.fs;
-const process = std.process;
-const Allocator = std.mem.Allocator;
-const warn = std.log.warn;
-const Color = std.zig.Color;
-
 const usage_fmt =
     \\Usage: zig fmt [file]...
     \\
@@ -37,14 +29,11 @@ const Fmt = struct {
     const SeenMap = std.AutoHashMap(fs.File.INode, void);
 };
 
-pub fn main() !void {
-    var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer arena_instance.deinit();
-    const arena = arena_instance.allocator();
-    const gpa = arena;
-
-    const args = try process.argsAlloc(arena);
-
+pub fn run(
+    gpa: Allocator,
+    arena: Allocator,
+    args: []const []const u8,
+) !void {
     var color: Color = .auto;
     var stdin_flag: bool = false;
     var check_flag: bool = false;
@@ -55,7 +44,7 @@ pub fn main() !void {
     defer excluded_files.deinit();
 
     {
-        var i: usize = 1;
+        var i: usize = 0;
         while (i < args.len) : (i += 1) {
             const arg = args[i];
             if (mem.startsWith(u8, arg, "-")) {
@@ -214,7 +203,7 @@ fn fmtPath(fmt: *Fmt, file_path: []const u8, check_mode: bool, dir: fs.Dir, sub_
     fmtPathFile(fmt, file_path, check_mode, dir, sub_path) catch |err| switch (err) {
         error.IsDir, error.AccessDenied => return fmtPathDir(fmt, file_path, check_mode, dir, sub_path),
         else => {
-            warn("unable to format '{s}': {s}", .{ file_path, @errorName(err) });
+            std.log.err("unable to format '{s}': {s}", .{ file_path, @errorName(err) });
             fmt.any_error = true;
             return;
         },
@@ -248,7 +237,7 @@ fn fmtPathDir(
                 try fmtPathDir(fmt, full_path, check_mode, dir, entry.name);
             } else {
                 fmtPathFile(fmt, full_path, check_mode, dir, entry.name) catch |err| {
-                    warn("unable to format '{s}': {s}", .{ full_path, @errorName(err) });
+                    std.log.err("unable to format '{s}': {s}", .{ full_path, @errorName(err) });
                     fmt.any_error = true;
                     return;
                 };
@@ -338,7 +327,10 @@ fn fmtPathFile(
     }
 }
 
-fn fatal(comptime format: []const u8, args: anytype) noreturn {
-    std.log.err(format, args);
-    process.exit(1);
-}
+const std = @import("std");
+const mem = std.mem;
+const fs = std.fs;
+const process = std.process;
+const Allocator = std.mem.Allocator;
+const Color = std.zig.Color;
+const fatal = std.process.fatal;
diff --git a/zig/src/glibc.zig b/zig/src/glibc.zig
index f01e867843..f1ac544163 100644
--- a/zig/src/glibc.zig
+++ b/zig/src/glibc.zig
@@ -6,12 +6,14 @@ const fs = std.fs;
 const path = fs.path;
 const assert = std.debug.assert;
 const Version = std.SemanticVersion;
+const Path = std.Build.Cache.Path;
 
 const Compilation = @import("Compilation.zig");
 const build_options = @import("build_options");
 const trace = @import("tracy.zig").trace;
 const Cache = std.Build.Cache;
 const Module = @import("Package/Module.zig");
+const link = @import("link.zig");
 
 pub const Lib = struct {
     name: []const u8,
@@ -219,7 +221,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = comp.root_mod,
                 },
             };
-            return comp.build_crt_file("crti", .Obj, .@"glibc crti.o", prog_node, &files);
+            return comp.build_crt_file("crti", .Obj, .@"glibc crti.o", prog_node, &files, .{});
         },
         .crtn_o => {
             var args = std.ArrayList([]const u8).init(arena);
@@ -240,7 +242,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 },
             };
-            return comp.build_crt_file("crtn", .Obj, .@"glibc crtn.o", prog_node, &files);
+            return comp.build_crt_file("crtn", .Obj, .@"glibc crtn.o", prog_node, &files, .{});
         },
         .scrt1_o => {
             const start_o: Compilation.CSourceFile = blk: {
@@ -293,7 +295,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
             };
             var files = [_]Compilation.CSourceFile{ start_o, abi_note_o, init_o };
             const basename = if (comp.config.output_mode == .Exe and !comp.config.pie) "crt1" else "Scrt1";
-            return comp.build_crt_file(basename, .Obj, .@"glibc Scrt1.o", prog_node, &files);
+            return comp.build_crt_file(basename, .Obj, .@"glibc Scrt1.o", prog_node, &files, .{});
         },
         .libc_nonshared_a => {
             const s = path.sep_str;
@@ -371,7 +373,6 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     "-fmerge-all-constants",
                     "-frounding-math",
                     "-Wno-unsupported-floating-point-opt", // For targets that don't support -frounding-math.
-                    "-fno-stack-protector",
                     "-fno-common",
                     "-fmath-errno",
                     "-ftls-model=initial-exec",
@@ -411,7 +412,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                 files_index += 1;
             }
             const files = files_buf[0..files_index];
-            return comp.build_crt_file("c_nonshared", .Lib, .@"glibc libc_nonshared.a", prog_node, files);
+            return comp.build_crt_file("c_nonshared", .Lib, .@"glibc libc_nonshared.a", prog_node, files, .{});
         },
     }
 }
@@ -438,7 +439,7 @@ fn start_asm_path(comp: *Compilation, arena: Allocator, basename: []const u8) ![
                 try result.appendSlice("sparc" ++ s ++ "sparc32");
             }
         }
-    } else if (arch.isARM()) {
+    } else if (arch.isArm()) {
         try result.appendSlice("arm");
     } else if (arch.isMIPS()) {
         if (!mem.eql(u8, basename, "crti.S") and !mem.eql(u8, basename, "crtn.S")) {
@@ -602,7 +603,7 @@ fn add_include_dirs_arch(
             try args.append("-I");
             try args.append(try path.join(arena, &[_][]const u8{ dir, "x86" }));
         }
-    } else if (arch.isARM()) {
+    } else if (arch.isArm()) {
         if (opt_nptl) |nptl| {
             try args.append("-I");
             try args.append(try path.join(arena, &[_][]const u8{ dir, "arm", nptl }));
@@ -717,11 +718,11 @@ fn lib_path(comp: *Compilation, arena: Allocator, sub_path: []const u8) ![]const
 
 pub const BuiltSharedObjects = struct {
     lock: Cache.Lock,
-    dir_path: []u8,
+    dir_path: Path,
 
     pub fn deinit(self: *BuiltSharedObjects, gpa: Allocator) void {
         self.lock.release();
-        gpa.free(self.dir_path);
+        gpa.free(self.dir_path.sub_path);
         self.* = undefined;
     }
 };
@@ -742,7 +743,9 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
         return error.ZigCompilerNotBuiltWithLLVMExtensions;
     }
 
-    var arena_allocator = std.heap.ArenaAllocator.init(comp.gpa);
+    const gpa = comp.gpa;
+
+    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
 
@@ -751,7 +754,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
 
     // Use the global cache directory.
     var cache: Cache = .{
-        .gpa = comp.gpa,
+        .gpa = gpa,
         .manifest_dir = try comp.global_cache_directory.handle.makeOpenPath("h", .{}),
     };
     cache.addPrefix(.{ .path = null, .handle = fs.cwd() });
@@ -772,12 +775,13 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
     if (try man.hit()) {
         const digest = man.final();
 
-        assert(comp.glibc_so_files == null);
-        comp.glibc_so_files = BuiltSharedObjects{
+        return queueSharedObjects(comp, .{
             .lock = man.toOwnedLock(),
-            .dir_path = try comp.global_cache_directory.join(comp.gpa, &.{ "o", &digest }),
-        };
-        return;
+            .dir_path = .{
+                .root_dir = comp.global_cache_directory,
+                .sub_path = try gpa.dupe(u8, "o" ++ fs.path.sep_str ++ digest),
+            },
+        });
     }
 
     const digest = man.final();
@@ -790,8 +794,8 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
     defer o_directory.handle.close();
 
     const abilists_contents = man.files.keys()[abilists_index].contents.?;
-    const metadata = try loadMetaData(comp.gpa, abilists_contents);
-    defer metadata.destroy(comp.gpa);
+    const metadata = try loadMetaData(gpa, abilists_contents);
+    defer metadata.destroy(gpa);
 
     const target_targ_index = for (metadata.all_targets, 0..) |targ, i| {
         if (targ.arch == target.cpu.arch and
@@ -835,7 +839,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
         map_contents.deinit(); // The most recent allocation of an arena can be freed :)
     }
 
-    var stubs_asm = std.ArrayList(u8).init(comp.gpa);
+    var stubs_asm = std.ArrayList(u8).init(gpa);
     defer stubs_asm.deinit();
 
     for (libs, 0..) |lib, lib_i| {
@@ -935,10 +939,11 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
                 var ver_buf_i: u8 = 0;
                 while (ver_buf_i < versions_len) : (ver_buf_i += 1) {
                     // Example:
+                    // .balign 4
                     // .globl _Exit_2_2_5
                     // .type _Exit_2_2_5, %function;
                     // .symver _Exit_2_2_5, _Exit@@GLIBC_2.2.5
-                    // _Exit_2_2_5:
+                    // _Exit_2_2_5: .long 0
                     const ver_index = versions_buffer[ver_buf_i];
                     const ver = metadata.all_versions[ver_index];
 
@@ -957,12 +962,14 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
                                 .{ sym_name, ver.major, ver.minor },
                             );
                         try stubs_asm.writer().print(
+                            \\.balign {d}
                             \\.globl {s}
                             \\.type {s}, %function;
                             \\.symver {s}, {s}{s}GLIBC_{d}.{d}
-                            \\{s}:
+                            \\{s}: {s} 0
                             \\
                         , .{
+                            target.ptrBitWidth() / 8,
                             sym_plus_ver,
                             sym_plus_ver,
                             sym_plus_ver,
@@ -971,6 +978,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
                             ver.major,
                             ver.minor,
                             sym_plus_ver,
+                            wordDirective(target),
                         });
                     } else {
                         const sym_plus_ver = if (want_default)
@@ -982,12 +990,14 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
                                 .{ sym_name, ver.major, ver.minor, ver.patch },
                             );
                         try stubs_asm.writer().print(
+                            \\.balign {d}
                             \\.globl {s}
                             \\.type {s}, %function;
                             \\.symver {s}, {s}{s}GLIBC_{d}.{d}.{d}
-                            \\{s}:
+                            \\{s}: {s} 0
                             \\
                         , .{
+                            target.ptrBitWidth() / 8,
                             sym_plus_ver,
                             sym_plus_ver,
                             sym_plus_ver,
@@ -997,13 +1007,14 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
                             ver.minor,
                             ver.patch,
                             sym_plus_ver,
+                            wordDirective(target),
                         });
                     }
                 }
             }
         }
 
-        try stubs_asm.appendSlice(".data\n");
+        try stubs_asm.appendSlice(".rodata\n");
 
         // For some targets, the real `libc.so.6` will contain a weak reference to `_IO_stdin_used`,
         // making the linker put the symbol in the dynamic symbol table. We likewise need to emit a
@@ -1024,12 +1035,18 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
         // a strong reference.
         if (std.mem.eql(u8, lib.name, "c")) {
             try stubs_asm.writer().print(
+                \\.balign {d}
                 \\.globl _IO_stdin_used
                 \\{s} _IO_stdin_used
                 \\
-            , .{wordDirective(target)});
+            , .{
+                target.ptrBitWidth() / 8,
+                wordDirective(target),
+            });
         }
 
+        try stubs_asm.appendSlice(".data\n");
+
         const obj_inclusions_len = try inc_reader.readInt(u16, .little);
 
         sym_i = 0;
@@ -1099,11 +1116,12 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
                 var ver_buf_i: u8 = 0;
                 while (ver_buf_i < versions_len) : (ver_buf_i += 1) {
                     // Example:
+                    // .balign 4
                     // .globl environ_2_2_5
                     // .type environ_2_2_5, %object;
                     // .size environ_2_2_5, 4;
                     // .symver environ_2_2_5, environ@@GLIBC_2.2.5
-                    // environ_2_2_5:
+                    // environ_2_2_5: .fill 4, 1, 0
                     const ver_index = versions_buffer[ver_buf_i];
                     const ver = metadata.all_versions[ver_index];
 
@@ -1122,13 +1140,15 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
                                 .{ sym_name, ver.major, ver.minor },
                             );
                         try stubs_asm.writer().print(
+                            \\.balign {d}
                             \\.globl {s}
                             \\.type {s}, %object;
                             \\.size {s}, {d};
                             \\.symver {s}, {s}{s}GLIBC_{d}.{d}
-                            \\{s}:
+                            \\{s}: .fill {d}, 1, 0
                             \\
                         , .{
+                            target.ptrBitWidth() / 8,
                             sym_plus_ver,
                             sym_plus_ver,
                             sym_plus_ver,
@@ -1139,6 +1159,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
                             ver.major,
                             ver.minor,
                             sym_plus_ver,
+                            size,
                         });
                     } else {
                         const sym_plus_ver = if (want_default)
@@ -1150,13 +1171,15 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
                                 .{ sym_name, ver.major, ver.minor, ver.patch },
                             );
                         try stubs_asm.writer().print(
+                            \\.balign {d}
                             \\.globl {s}
                             \\.type {s}, %object;
                             \\.size {s}, {d};
                             \\.symver {s}, {s}{s}GLIBC_{d}.{d}.{d}
-                            \\{s}:
+                            \\{s}: .fill {d}, 1, 0
                             \\
                         , .{
+                            target.ptrBitWidth() / 8,
                             sym_plus_ver,
                             sym_plus_ver,
                             sym_plus_ver,
@@ -1168,6 +1191,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
                             ver.minor,
                             ver.patch,
                             sym_plus_ver,
+                            size,
                         });
                     }
                 }
@@ -1177,7 +1201,6 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
         var lib_name_buf: [32]u8 = undefined; // Larger than each of the names "c", "pthread", etc.
         const asm_file_basename = std.fmt.bufPrint(&lib_name_buf, "{s}.s", .{lib.name}) catch unreachable;
         try o_directory.handle.writeFile(.{ .sub_path = asm_file_basename, .data = stubs_asm.items });
-
         try buildSharedLib(comp, arena, comp.global_cache_directory, o_directory, asm_file_basename, lib, prog_node);
     }
 
@@ -1185,14 +1208,45 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) !voi
         log.warn("failed to write cache manifest for glibc stubs: {s}", .{@errorName(err)});
     };
 
-    assert(comp.glibc_so_files == null);
-    comp.glibc_so_files = BuiltSharedObjects{
+    return queueSharedObjects(comp, .{
         .lock = man.toOwnedLock(),
-        .dir_path = try comp.global_cache_directory.join(comp.gpa, &.{ "o", &digest }),
-    };
+        .dir_path = .{
+            .root_dir = comp.global_cache_directory,
+            .sub_path = try gpa.dupe(u8, "o" ++ fs.path.sep_str ++ digest),
+        },
+    });
 }
 
-// zig fmt: on
+fn queueSharedObjects(comp: *Compilation, so_files: BuiltSharedObjects) void {
+    const target_version = comp.getTarget().os.version_range.linux.glibc;
+
+    assert(comp.glibc_so_files == null);
+    comp.glibc_so_files = so_files;
+
+    var task_buffer: [libs.len]link.Task = undefined;
+    var task_buffer_i: usize = 0;
+
+    {
+        comp.mutex.lock(); // protect comp.arena
+        defer comp.mutex.unlock();
+
+        for (libs) |lib| {
+            if (lib.removed_in) |rem_in| {
+                if (target_version.order(rem_in) != .lt) continue;
+            }
+            const so_path: Path = .{
+                .root_dir = so_files.dir_path.root_dir,
+                .sub_path = std.fmt.allocPrint(comp.arena, "{s}{c}lib{s}.so.{d}", .{
+                    so_files.dir_path.sub_path, fs.path.sep, lib.name, lib.sover,
+                }) catch return comp.setAllocFailure(),
+            };
+            task_buffer[task_buffer_i] = .{ .load_dso = so_path };
+            task_buffer_i += 1;
+        }
+    }
+
+    comp.queueLinkTasks(task_buffer[0..task_buffer_i]);
+}
 
 fn buildSharedLib(
     comp: *Compilation,
@@ -1304,3 +1358,10 @@ pub fn needsCrtiCrtn(target: std.Target) bool {
         else => true,
     };
 }
+
+pub fn needsCrt0(output_mode: std.builtin.OutputMode) ?CrtFile {
+    return switch (output_mode) {
+        .Obj, .Lib => null,
+        .Exe => .scrt1_o,
+    };
+}
diff --git a/zig/src/libcxx.zig b/zig/src/libcxx.zig
index 11deff91c9..ec89ac1cfc 100644
--- a/zig/src/libcxx.zig
+++ b/zig/src/libcxx.zig
@@ -195,7 +195,7 @@ pub fn buildLibCXX(comp: *Compilation, prog_node: std.Progress.Node) BuildError!
             .valgrind = false,
             .optimize_mode = optimize_mode,
             .structured_cfg = comp.root_mod.structured_cfg,
-            .pic = comp.root_mod.pic,
+            .pic = if (target_util.supports_fpic(target)) true else null,
         },
         .global = config,
         .cc_argv = &.{},
@@ -278,9 +278,6 @@ pub fn buildLibCXX(comp: *Compilation, prog_node: std.Progress.Node) BuildError!
             try cflags.append("-faligned-allocation");
         }
 
-        if (target_util.supports_fpic(target)) {
-            try cflags.append("-fPIC");
-        }
         try cflags.append("-nostdinc++");
         try cflags.append("-std=c++23");
         try cflags.append("-Wno-user-defined-literals");
@@ -355,7 +352,9 @@ pub fn buildLibCXX(comp: *Compilation, prog_node: std.Progress.Node) BuildError!
     };
 
     assert(comp.libcxx_static_lib == null);
-    comp.libcxx_static_lib = try sub_compilation.toCrtFile();
+    const crt_file = try sub_compilation.toCrtFile();
+    comp.libcxx_static_lib = crt_file;
+    comp.queueLinkTaskMode(crt_file.full_object_path, output_mode);
 }
 
 pub fn buildLibCXXABI(comp: *Compilation, prog_node: std.Progress.Node) BuildError!void {
@@ -584,7 +583,9 @@ pub fn buildLibCXXABI(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
     };
 
     assert(comp.libcxxabi_static_lib == null);
-    comp.libcxxabi_static_lib = try sub_compilation.toCrtFile();
+    const crt_file = try sub_compilation.toCrtFile();
+    comp.libcxxabi_static_lib = crt_file;
+    comp.queueLinkTaskMode(crt_file.full_object_path, output_mode);
 }
 
 pub fn hardeningModeFlag(optimize_mode: std.builtin.OptimizeMode) []const u8 {
diff --git a/zig/src/libtsan.zig b/zig/src/libtsan.zig
index 63131def00..8b2427df1b 100644
--- a/zig/src/libtsan.zig
+++ b/zig/src/libtsan.zig
@@ -29,11 +29,11 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo
     const root_name = switch (target.os.tag) {
         // On Apple platforms, we use the same name as LLVM because the
         // TSAN library implementation hard-codes a check for these names.
-        .macos => "clang_rt.tsan_osx_dynamic",
-        .ios => switch (target.abi) {
-            .simulator => "clang_rt.tsan_iossim_dynamic",
-            else => "clang_rt.tsan_ios_dynamic",
-        },
+        .driverkit, .macos => "clang_rt.tsan_osx_dynamic",
+        .ios => if (target.abi == .simulator) "clang_rt.tsan_iossim_dynamic" else "clang_rt.tsan_ios_dynamic",
+        .tvos => if (target.abi == .simulator) "clang_rt.tsan_tvossim_dynamic" else "clang_rt.tsan_tvos_dynamic",
+        .visionos => if (target.abi == .simulator) "clang_rt.tsan_xrossim_dynamic" else "clang_rt.tsan_xros_dynamic",
+        .watchos => if (target.abi == .simulator) "clang_rt.tsan_watchossim_dynamic" else "clang_rt.tsan_watchos_dynamic",
         else => "tsan",
     };
     const link_mode: std.builtin.LinkMode = if (target.isDarwin()) .dynamic else .static;
@@ -93,11 +93,12 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo
             .sanitize_c = false,
             .sanitize_thread = false,
             .red_zone = comp.root_mod.red_zone,
-            .omit_frame_pointer = comp.root_mod.omit_frame_pointer,
+            .omit_frame_pointer = optimize_mode != .Debug and !target.os.tag.isDarwin(),
             .valgrind = false,
             .optimize_mode = optimize_mode,
             .structured_cfg = comp.root_mod.structured_cfg,
             .pic = true,
+            .no_builtin = true,
         },
         .global = config,
         .cc_argv = &common_flags,
@@ -123,10 +124,7 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo
         try cflags.append("-I");
         try cflags.append(tsan_include_path);
 
-        try cflags.append("-nostdinc++");
-        try cflags.append("-fvisibility-inlines-hidden");
-        try cflags.append("-std=c++17");
-        try cflags.append("-fno-rtti");
+        try addCcArgs(target, &cflags);
 
         c_source_files.appendAssumeCapacity(.{
             .src_path = try comp.zig_lib_directory.join(arena, &.{ "tsan", tsan_src }),
@@ -147,10 +145,7 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo
         try cflags.append("-I");
         try cflags.append(tsan_include_path);
 
-        try cflags.append("-nostdinc++");
-        try cflags.append("-fvisibility-inlines-hidden");
-        try cflags.append("-std=c++17");
-        try cflags.append("-fno-rtti");
+        try addCcArgs(target, &cflags);
 
         c_source_files.appendAssumeCapacity(.{
             .src_path = try comp.zig_lib_directory.join(arena, &[_][]const u8{ "tsan", tsan_src }),
@@ -195,10 +190,7 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo
         try cflags.append("-I");
         try cflags.append(tsan_include_path);
 
-        try cflags.append("-nostdinc++");
-        try cflags.append("-fvisibility-inlines-hidden");
-        try cflags.append("-std=c++17");
-        try cflags.append("-fno-rtti");
+        try addCcArgs(target, &cflags);
 
         c_source_files.appendAssumeCapacity(.{
             .src_path = try comp.zig_lib_directory.join(arena, &[_][]const u8{
@@ -222,10 +214,7 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo
         try cflags.append("-I");
         try cflags.append(tsan_include_path);
 
-        try cflags.append("-nostdinc++");
-        try cflags.append("-fvisibility-inlines-hidden");
-        try cflags.append("-std=c++17");
-        try cflags.append("-fno-rtti");
+        try addCcArgs(target, &cflags);
 
         c_source_files.appendAssumeCapacity(.{
             .src_path = try comp.zig_lib_directory.join(arena, &[_][]const u8{
@@ -243,10 +232,7 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo
         try cflags.append("-I");
         try cflags.append(tsan_include_path);
 
-        try cflags.append("-nostdinc++");
-        try cflags.append("-fvisibility-inlines-hidden");
-        try cflags.append("-std=c++17");
-        try cflags.append("-fno-rtti");
+        try addCcArgs(target, &cflags);
 
         c_source_files.appendAssumeCapacity(.{
             .src_path = try comp.zig_lib_directory.join(arena, &[_][]const u8{
@@ -272,10 +258,7 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo
         try cflags.append("-I");
         try cflags.append(tsan_include_path);
 
-        try cflags.append("-nostdinc++");
-        try cflags.append("-fvisibility-inlines-hidden");
-        try cflags.append("-std=c++17");
-        try cflags.append("-fno-rtti");
+        try addCcArgs(target, &cflags);
 
         c_source_files.appendAssumeCapacity(.{
             .src_path = try comp.zig_lib_directory.join(arena, &[_][]const u8{
@@ -342,8 +325,29 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo
         },
     };
 
+    const crt_file = try sub_compilation.toCrtFile();
+    comp.queueLinkTaskMode(crt_file.full_object_path, output_mode);
     assert(comp.tsan_lib == null);
-    comp.tsan_lib = try sub_compilation.toCrtFile();
+    comp.tsan_lib = crt_file;
+}
+
+fn addCcArgs(target: std.Target, args: *std.ArrayList([]const u8)) error{OutOfMemory}!void {
+    try args.appendSlice(&[_][]const u8{
+        "-nostdinc++",
+        "-fvisibility=hidden",
+        "-fvisibility-inlines-hidden",
+        "-std=c++17",
+        "-fno-rtti",
+        "-fno-exceptions",
+    });
+
+    if (target.abi.isAndroid() and target.os.version_range.linux.android >= 29) {
+        try args.append("-fno-emulated-tls");
+    }
+
+    if (target.isMinGW()) {
+        try args.append("-fms-extensions");
+    }
 }
 
 const tsan_sources = [_][]const u8{
diff --git a/zig/src/libunwind.zig b/zig/src/libunwind.zig
index 5eb19e8d67..1e101da229 100644
--- a/zig/src/libunwind.zig
+++ b/zig/src/libunwind.zig
@@ -46,6 +46,7 @@ pub fn buildStaticLib(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
         );
         return error.SubCompilationFailed;
     };
+    const target = comp.root_mod.resolved_target.result;
     const root_mod = Module.create(arena, .{
         .global_cache_directory = comp.global_cache_directory,
         .paths = .{
@@ -63,8 +64,9 @@ pub fn buildStaticLib(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
             .valgrind = false,
             .sanitize_c = false,
             .sanitize_thread = false,
-            .unwind_tables = false,
-            .pic = comp.root_mod.pic,
+            // necessary so that libunwind can unwind through its own stack frames
+            .unwind_tables = true,
+            .pic = if (target_util.supports_fpic(target)) true else null,
             .optimize_mode = comp.compilerRtOptMode(),
         },
         .global = config,
@@ -83,7 +85,6 @@ pub fn buildStaticLib(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
 
     const root_name = "unwind";
     const link_mode = .static;
-    const target = comp.root_mod.resolved_target.result;
     const basename = try std.zig.binNameAlloc(arena, .{
         .root_name = root_name,
         .target = target,
@@ -114,16 +115,11 @@ pub fn buildStaticLib(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
         try cflags.append("-fno-exceptions");
         try cflags.append("-I");
         try cflags.append(try comp.zig_lib_directory.join(arena, &[_][]const u8{ "libunwind", "include" }));
-        if (target_util.supports_fpic(target)) {
-            try cflags.append("-fPIC");
-        }
         try cflags.append("-D_LIBUNWIND_DISABLE_VISIBILITY_ANNOTATIONS");
         try cflags.append("-Wa,--noexecstack");
         try cflags.append("-fvisibility=hidden");
         try cflags.append("-fvisibility-inlines-hidden");
         try cflags.append("-fvisibility-global-new-delete=force-hidden");
-        // necessary so that libunwind can unwind through its own stack frames
-        try cflags.append("-funwind-tables");
 
         // This is intentionally always defined because the macro definition means, should it only
         // build for the target specified by compiler defines. Since we pass -target the compiler
@@ -136,7 +132,7 @@ pub fn buildStaticLib(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
         if (!comp.config.any_non_single_threaded) {
             try cflags.append("-D_LIBUNWIND_HAS_NO_THREADS");
         }
-        if (target.cpu.arch.isArmOrThumb() and target.abi.floatAbi() == .hard) {
+        if (target.cpu.arch.isArm() and target.abi.floatAbi() == .hard) {
             try cflags.append("-DCOMPILER_RT_ARMHF_TARGET");
         }
         try cflags.append("-Wno-bitwise-conditional-parentheses");
@@ -199,8 +195,10 @@ pub fn buildStaticLib(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
         },
     };
 
+    const crt_file = try sub_compilation.toCrtFile();
+    comp.queueLinkTaskMode(crt_file.full_object_path, output_mode);
     assert(comp.libunwind_static_lib == null);
-    comp.libunwind_static_lib = try sub_compilation.toCrtFile();
+    comp.libunwind_static_lib = crt_file;
 }
 
 const unwind_src_list = [_][]const u8{
diff --git a/zig/src/link.zig b/zig/src/link.zig
index 64115ab3ee..7f53bde320 100644
--- a/zig/src/link.zig
+++ b/zig/src/link.zig
@@ -12,6 +12,7 @@ const Air = @import("Air.zig");
 const Allocator = std.mem.Allocator;
 const Cache = std.Build.Cache;
 const Path = std.Build.Cache.Path;
+const Directory = std.Build.Cache.Directory;
 const Compilation = @import("Compilation.zig");
 const LibCInstallation = std.zig.LibCInstallation;
 const Liveness = @import("Liveness.zig");
@@ -23,32 +24,326 @@ const LlvmObject = @import("codegen/llvm.zig").Object;
 const lldMain = @import("main.zig").lldMain;
 const Package = @import("Package.zig");
 const dev = @import("dev.zig");
+const ThreadSafeQueue = @import("ThreadSafeQueue.zig").ThreadSafeQueue;
+const target_util = @import("target.zig");
 
-/// When adding a new field, remember to update `hashAddSystemLibs`.
-/// These are *always* dynamically linked. Static libraries will be
-/// provided as positional arguments.
-pub const SystemLib = struct {
-    needed: bool,
-    weak: bool,
-    /// This can be null in two cases right now:
-    /// 1. Windows DLLs that zig ships such as advapi32.
-    /// 2. extern "foo" fn declarations where we find out about libraries too late
-    /// TODO: make this non-optional and resolve those two cases somehow.
-    path: ?Path,
-};
+pub const LdScript = @import("link/LdScript.zig");
 
-pub fn hashAddSystemLibs(
-    man: *Cache.Manifest,
-    hm: std.StringArrayHashMapUnmanaged(SystemLib),
-) !void {
-    const keys = hm.keys();
-    man.hash.addListOfBytes(keys);
-    for (hm.values()) |value| {
-        man.hash.add(value.needed);
-        man.hash.add(value.weak);
-        if (value.path) |p| _ = try man.addFilePath(p, null);
+pub const Diags = struct {
+    /// Stored here so that function definitions can distinguish between
+    /// needing an allocator for things besides error reporting.
+    gpa: Allocator,
+    mutex: std.Thread.Mutex,
+    msgs: std.ArrayListUnmanaged(Msg),
+    flags: Flags,
+    lld: std.ArrayListUnmanaged(Lld),
+
+    pub const Flags = packed struct {
+        no_entry_point_found: bool = false,
+        missing_libc: bool = false,
+        alloc_failure_occurred: bool = false,
+
+        const Int = blk: {
+            const bits = @typeInfo(@This()).@"struct".fields.len;
+            break :blk @Type(.{ .int = .{
+                .signedness = .unsigned,
+                .bits = bits,
+            } });
+        };
+
+        pub fn anySet(ef: Flags) bool {
+            return @as(Int, @bitCast(ef)) > 0;
+        }
+    };
+
+    pub const Lld = struct {
+        /// Allocated with gpa.
+        msg: []const u8,
+        context_lines: []const []const u8 = &.{},
+
+        pub fn deinit(self: *Lld, gpa: Allocator) void {
+            for (self.context_lines) |line| gpa.free(line);
+            gpa.free(self.context_lines);
+            gpa.free(self.msg);
+            self.* = undefined;
+        }
+    };
+
+    pub const Msg = struct {
+        msg: []const u8,
+        notes: []Msg = &.{},
+
+        pub fn deinit(self: *Msg, gpa: Allocator) void {
+            for (self.notes) |*note| note.deinit(gpa);
+            gpa.free(self.notes);
+            gpa.free(self.msg);
+        }
+    };
+
+    pub const ErrorWithNotes = struct {
+        diags: *Diags,
+        /// Allocated index in diags.msgs array.
+        index: usize,
+        /// Next available note slot.
+        note_slot: usize = 0,
+
+        pub fn addMsg(
+            err: ErrorWithNotes,
+            comptime format: []const u8,
+            args: anytype,
+        ) error{OutOfMemory}!void {
+            const gpa = err.diags.gpa;
+            const err_msg = &err.diags.msgs.items[err.index];
+            err_msg.msg = try std.fmt.allocPrint(gpa, format, args);
+        }
+
+        pub fn addNote(
+            err: *ErrorWithNotes,
+            comptime format: []const u8,
+            args: anytype,
+        ) error{OutOfMemory}!void {
+            const gpa = err.diags.gpa;
+            const err_msg = &err.diags.msgs.items[err.index];
+            assert(err.note_slot < err_msg.notes.len);
+            err_msg.notes[err.note_slot] = .{ .msg = try std.fmt.allocPrint(gpa, format, args) };
+            err.note_slot += 1;
+        }
+    };
+
+    pub fn init(gpa: Allocator) Diags {
+        return .{
+            .gpa = gpa,
+            .mutex = .{},
+            .msgs = .empty,
+            .flags = .{},
+            .lld = .empty,
+        };
+    }
+
+    pub fn deinit(diags: *Diags) void {
+        const gpa = diags.gpa;
+
+        for (diags.msgs.items) |*item| item.deinit(gpa);
+        diags.msgs.deinit(gpa);
+
+        for (diags.lld.items) |*item| item.deinit(gpa);
+        diags.lld.deinit(gpa);
+
+        diags.* = undefined;
+    }
+
+    pub fn hasErrors(diags: *Diags) bool {
+        return diags.msgs.items.len > 0 or diags.flags.anySet();
+    }
+
+    pub fn lockAndParseLldStderr(diags: *Diags, prefix: []const u8, stderr: []const u8) void {
+        diags.mutex.lock();
+        defer diags.mutex.unlock();
+
+        diags.parseLldStderr(prefix, stderr) catch diags.setAllocFailure();
+    }
+
+    fn parseLldStderr(
+        diags: *Diags,
+        prefix: []const u8,
+        stderr: []const u8,
+    ) Allocator.Error!void {
+        const gpa = diags.gpa;
+
+        var context_lines = std.ArrayList([]const u8).init(gpa);
+        defer context_lines.deinit();
+
+        var current_err: ?*Lld = null;
+        var lines = mem.splitSequence(u8, stderr, if (builtin.os.tag == .windows) "\r\n" else "\n");
+        while (lines.next()) |line| {
+            if (line.len > prefix.len + ":".len and
+                mem.eql(u8, line[0..prefix.len], prefix) and line[prefix.len] == ':')
+            {
+                if (current_err) |err| {
+                    err.context_lines = try context_lines.toOwnedSlice();
+                }
+
+                var split = mem.splitSequence(u8, line, "error: ");
+                _ = split.first();
+
+                const duped_msg = try std.fmt.allocPrint(gpa, "{s}: {s}", .{ prefix, split.rest() });
+                errdefer gpa.free(duped_msg);
+
+                current_err = try diags.lld.addOne(gpa);
+                current_err.?.* = .{ .msg = duped_msg };
+            } else if (current_err != null) {
+                const context_prefix = ">>> ";
+                var trimmed = mem.trimRight(u8, line, &std.ascii.whitespace);
+                if (mem.startsWith(u8, trimmed, context_prefix)) {
+                    trimmed = trimmed[context_prefix.len..];
+                }
+
+                if (trimmed.len > 0) {
+                    const duped_line = try gpa.dupe(u8, trimmed);
+                    try context_lines.append(duped_line);
+                }
+            }
+        }
+
+        if (current_err) |err| {
+            err.context_lines = try context_lines.toOwnedSlice();
+        }
+    }
+
+    pub fn fail(diags: *Diags, comptime format: []const u8, args: anytype) error{LinkFailure} {
+        @branchHint(.cold);
+        addError(diags, format, args);
+        return error.LinkFailure;
+    }
+
+    pub fn addError(diags: *Diags, comptime format: []const u8, args: anytype) void {
+        @branchHint(.cold);
+        const gpa = diags.gpa;
+        const eu_main_msg = std.fmt.allocPrint(gpa, format, args);
+        diags.mutex.lock();
+        defer diags.mutex.unlock();
+        addErrorLockedFallible(diags, eu_main_msg) catch |err| switch (err) {
+            error.OutOfMemory => diags.setAllocFailureLocked(),
+        };
+    }
+
+    fn addErrorLockedFallible(diags: *Diags, eu_main_msg: Allocator.Error![]u8) Allocator.Error!void {
+        const gpa = diags.gpa;
+        const main_msg = try eu_main_msg;
+        errdefer gpa.free(main_msg);
+        try diags.msgs.append(gpa, .{ .msg = main_msg });
+    }
+
+    pub fn addErrorWithNotes(diags: *Diags, note_count: usize) error{OutOfMemory}!ErrorWithNotes {
+        @branchHint(.cold);
+        const gpa = diags.gpa;
+        diags.mutex.lock();
+        defer diags.mutex.unlock();
+        try diags.msgs.ensureUnusedCapacity(gpa, 1);
+        return addErrorWithNotesAssumeCapacity(diags, note_count);
+    }
+
+    pub fn addErrorWithNotesAssumeCapacity(diags: *Diags, note_count: usize) error{OutOfMemory}!ErrorWithNotes {
+        @branchHint(.cold);
+        const gpa = diags.gpa;
+        const index = diags.msgs.items.len;
+        const err = diags.msgs.addOneAssumeCapacity();
+        err.* = .{
+            .msg = undefined,
+            .notes = try gpa.alloc(Msg, note_count),
+        };
+        return .{
+            .diags = diags,
+            .index = index,
+        };
+    }
+
+    pub fn addMissingLibraryError(
+        diags: *Diags,
+        checked_paths: []const []const u8,
+        comptime format: []const u8,
+        args: anytype,
+    ) void {
+        @branchHint(.cold);
+        const gpa = diags.gpa;
+        const eu_main_msg = std.fmt.allocPrint(gpa, format, args);
+        diags.mutex.lock();
+        defer diags.mutex.unlock();
+        addMissingLibraryErrorLockedFallible(diags, checked_paths, eu_main_msg) catch |err| switch (err) {
+            error.OutOfMemory => diags.setAllocFailureLocked(),
+        };
     }
-}
+
+    fn addMissingLibraryErrorLockedFallible(
+        diags: *Diags,
+        checked_paths: []const []const u8,
+        eu_main_msg: Allocator.Error![]u8,
+    ) Allocator.Error!void {
+        const gpa = diags.gpa;
+        const main_msg = try eu_main_msg;
+        errdefer gpa.free(main_msg);
+        try diags.msgs.ensureUnusedCapacity(gpa, 1);
+        const notes = try gpa.alloc(Msg, checked_paths.len);
+        errdefer gpa.free(notes);
+        for (checked_paths, notes) |path, *note| {
+            note.* = .{ .msg = try std.fmt.allocPrint(gpa, "tried {s}", .{path}) };
+        }
+        diags.msgs.appendAssumeCapacity(.{
+            .msg = main_msg,
+            .notes = notes,
+        });
+    }
+
+    pub fn addParseError(
+        diags: *Diags,
+        path: Path,
+        comptime format: []const u8,
+        args: anytype,
+    ) void {
+        @branchHint(.cold);
+        const gpa = diags.gpa;
+        const eu_main_msg = std.fmt.allocPrint(gpa, format, args);
+        diags.mutex.lock();
+        defer diags.mutex.unlock();
+        addParseErrorLockedFallible(diags, path, eu_main_msg) catch |err| switch (err) {
+            error.OutOfMemory => diags.setAllocFailureLocked(),
+        };
+    }
+
+    fn addParseErrorLockedFallible(diags: *Diags, path: Path, m: Allocator.Error![]u8) Allocator.Error!void {
+        const gpa = diags.gpa;
+        const main_msg = try m;
+        errdefer gpa.free(main_msg);
+        try diags.msgs.ensureUnusedCapacity(gpa, 1);
+        const note = try std.fmt.allocPrint(gpa, "while parsing {}", .{path});
+        errdefer gpa.free(note);
+        const notes = try gpa.create([1]Msg);
+        errdefer gpa.destroy(notes);
+        notes.* = .{.{ .msg = note }};
+        diags.msgs.appendAssumeCapacity(.{
+            .msg = main_msg,
+            .notes = notes,
+        });
+    }
+
+    pub fn failParse(
+        diags: *Diags,
+        path: Path,
+        comptime format: []const u8,
+        args: anytype,
+    ) error{LinkFailure} {
+        @branchHint(.cold);
+        addParseError(diags, path, format, args);
+        return error.LinkFailure;
+    }
+
+    pub fn setAllocFailure(diags: *Diags) void {
+        @branchHint(.cold);
+        diags.mutex.lock();
+        defer diags.mutex.unlock();
+        setAllocFailureLocked(diags);
+    }
+
+    fn setAllocFailureLocked(diags: *Diags) void {
+        log.debug("memory allocation failure", .{});
+        diags.flags.alloc_failure_occurred = true;
+    }
+
+    pub fn addMessagesToBundle(diags: *const Diags, bundle: *std.zig.ErrorBundle.Wip) Allocator.Error!void {
+        for (diags.msgs.items) |link_err| {
+            try bundle.addRootErrorMessage(.{
+                .msg = try bundle.addString(link_err.msg),
+                .notes_len = @intCast(link_err.notes.len),
+            });
+            const notes_start = try bundle.reserveNotes(@intCast(link_err.notes.len));
+            for (link_err.notes, 0..) |note, i| {
+                bundle.extra.items[notes_start + i] = @intFromEnum(try bundle.addErrorMessage(.{
+                    .msg = try bundle.addString(note.msg),
+                }));
+            }
+        }
+    }
+};
 
 pub const producer_string = if (builtin.is_test) "zig test" else "zig " ++ build_options.version;
 
@@ -137,7 +432,7 @@ pub const File = struct {
         compatibility_version: ?std.SemanticVersion,
 
         // TODO: remove this. libraries are resolved by the frontend.
-        lib_dirs: []const []const u8,
+        lib_directories: []const Directory,
         framework_dirs: []const []const u8,
         rpath_list: []const []const u8,
 
@@ -446,58 +741,6 @@ pub const File = struct {
         }
     }
 
-    pub const ErrorWithNotes = struct {
-        base: *const File,
-
-        /// Allocated index in base.errors array.
-        index: usize,
-
-        /// Next available note slot.
-        note_slot: usize = 0,
-
-        pub fn addMsg(
-            err: ErrorWithNotes,
-            comptime format: []const u8,
-            args: anytype,
-        ) error{OutOfMemory}!void {
-            const gpa = err.base.comp.gpa;
-            const err_msg = &err.base.comp.link_errors.items[err.index];
-            err_msg.msg = try std.fmt.allocPrint(gpa, format, args);
-        }
-
-        pub fn addNote(
-            err: *ErrorWithNotes,
-            comptime format: []const u8,
-            args: anytype,
-        ) error{OutOfMemory}!void {
-            const gpa = err.base.comp.gpa;
-            const err_msg = &err.base.comp.link_errors.items[err.index];
-            assert(err.note_slot < err_msg.notes.len);
-            err_msg.notes[err.note_slot] = .{ .msg = try std.fmt.allocPrint(gpa, format, args) };
-            err.note_slot += 1;
-        }
-    };
-
-    pub fn addErrorWithNotes(base: *const File, note_count: usize) error{OutOfMemory}!ErrorWithNotes {
-        base.comp.link_errors_mutex.lock();
-        defer base.comp.link_errors_mutex.unlock();
-        const gpa = base.comp.gpa;
-        try base.comp.link_errors.ensureUnusedCapacity(gpa, 1);
-        return base.addErrorWithNotesAssumeCapacity(note_count);
-    }
-
-    pub fn addErrorWithNotesAssumeCapacity(base: *const File, note_count: usize) error{OutOfMemory}!ErrorWithNotes {
-        const gpa = base.comp.gpa;
-        const index = base.comp.link_errors.items.len;
-        const err = base.comp.link_errors.addOneAssumeCapacity();
-        err.* = .{ .msg = undefined, .notes = try gpa.alloc(ErrorMsg, note_count) };
-        return .{ .base = base, .index = index };
-    }
-
-    pub fn hasErrors(base: *const File) bool {
-        return base.comp.link_errors.items.len > 0 or base.comp.link_error_flags.isSet();
-    }
-
     pub fn releaseLock(self: *File) void {
         if (self.lock) |*lock| {
             lock.release();
@@ -523,7 +766,7 @@ pub const File = struct {
     }
 
     /// TODO audit this error set. most of these should be collapsed into one error,
-    /// and ErrorFlags should be updated to convey the meaning to the user.
+    /// and Diags.Flags should be updated to convey the meaning to the user.
     pub const FlushError = error{
         CacheUnavailable,
         CurrentWorkingDirectoryUnlinked,
@@ -533,7 +776,8 @@ pub const File = struct {
         FailedToEmit,
         FileSystem,
         FilesOpenedWithWrongFlags,
-        /// Indicates an error will be present in `Compilation.link_errors`.
+        /// Deprecated. Use `LinkFailure` instead.
+        /// Formerly used to indicate an error will be present in `Compilation.link_errors`.
         FlushFailure,
         /// Indicates an error will be present in `Compilation.link_errors`.
         LinkFailure,
@@ -753,6 +997,102 @@ pub const File = struct {
         }
     }
 
+    /// Opens a path as an object file and parses it into the linker.
+    fn openLoadObject(base: *File, path: Path) anyerror!void {
+        const diags = &base.comp.link_diags;
+        const input = try openObjectInput(diags, path);
+        errdefer input.object.file.close();
+        try loadInput(base, input);
+    }
+
+    /// Opens a path as a static library and parses it into the linker.
+    /// If `query` is non-null, allows GNU ld scripts.
+    fn openLoadArchive(base: *File, path: Path, opt_query: ?UnresolvedInput.Query) anyerror!void {
+        if (opt_query) |query| {
+            const archive = try openObject(path, query.must_link, query.hidden);
+            errdefer archive.file.close();
+            loadInput(base, .{ .archive = archive }) catch |err| switch (err) {
+                error.BadMagic, error.UnexpectedEndOfFile => {
+                    if (base.tag != .elf) return err;
+                    try loadGnuLdScript(base, path, query, archive.file);
+                    archive.file.close();
+                    return;
+                },
+                else => return err,
+            };
+        } else {
+            const archive = try openObject(path, false, false);
+            errdefer archive.file.close();
+            try loadInput(base, .{ .archive = archive });
+        }
+    }
+
+    /// Opens a path as a shared library and parses it into the linker.
+    /// Handles GNU ld scripts.
+    fn openLoadDso(base: *File, path: Path, query: UnresolvedInput.Query) anyerror!void {
+        const dso = try openDso(path, query.needed, query.weak, query.reexport);
+        errdefer dso.file.close();
+        loadInput(base, .{ .dso = dso }) catch |err| switch (err) {
+            error.BadMagic, error.UnexpectedEndOfFile => {
+                if (base.tag != .elf) return err;
+                try loadGnuLdScript(base, path, query, dso.file);
+                dso.file.close();
+                return;
+            },
+            else => return err,
+        };
+    }
+
+    fn loadGnuLdScript(base: *File, path: Path, parent_query: UnresolvedInput.Query, file: fs.File) anyerror!void {
+        const diags = &base.comp.link_diags;
+        const gpa = base.comp.gpa;
+        const stat = try file.stat();
+        const size = std.math.cast(u32, stat.size) orelse return error.FileTooBig;
+        const buf = try gpa.alloc(u8, size);
+        defer gpa.free(buf);
+        const n = try file.preadAll(buf, 0);
+        if (buf.len != n) return error.UnexpectedEndOfFile;
+        var ld_script = try LdScript.parse(gpa, diags, path, buf);
+        defer ld_script.deinit(gpa);
+        for (ld_script.args) |arg| {
+            const query: UnresolvedInput.Query = .{
+                .needed = arg.needed or parent_query.needed,
+                .weak = parent_query.weak,
+                .reexport = parent_query.reexport,
+                .preferred_mode = parent_query.preferred_mode,
+                .search_strategy = parent_query.search_strategy,
+                .allow_so_scripts = parent_query.allow_so_scripts,
+            };
+            if (mem.startsWith(u8, arg.path, "-l")) {
+                @panic("TODO");
+            } else {
+                if (fs.path.isAbsolute(arg.path)) {
+                    const new_path = Path.initCwd(try gpa.dupe(u8, arg.path));
+                    switch (Compilation.classifyFileExt(arg.path)) {
+                        .shared_library => try openLoadDso(base, new_path, query),
+                        .object => try openLoadObject(base, new_path),
+                        .static_library => try openLoadArchive(base, new_path, query),
+                        else => diags.addParseError(path, "GNU ld script references file with unrecognized extension: {s}", .{arg.path}),
+                    }
+                } else {
+                    @panic("TODO");
+                }
+            }
+        }
+    }
+
+    pub fn loadInput(base: *File, input: Input) anyerror!void {
+        const use_lld = build_options.have_llvm and base.comp.config.use_lld;
+        if (use_lld) return;
+        switch (base.tag) {
+            inline .elf, .wasm => |tag| {
+                dev.check(tag.devFeature());
+                return @as(*tag.Type(), @fieldParentPtr("base", base)).loadInput(input);
+            },
+            else => {},
+        }
+    }
+
     pub fn linkAsArchive(base: *File, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) FlushError!void {
         dev.check(.lld_linker);
 
@@ -760,7 +1100,6 @@ pub const File = struct {
         defer tracy.end();
 
         const comp = base.comp;
-        const gpa = comp.gpa;
 
         const directory = base.emit.root_dir; // Just an alias to make it shorter to type.
         const full_out_path = try directory.join(arena, &[_][]const u8{base.emit.sub_path});
@@ -792,7 +1131,7 @@ pub const File = struct {
         var man: Cache.Manifest = undefined;
         defer if (!base.disable_lld_caching) man.deinit();
 
-        const objects = comp.objects;
+        const link_inputs = comp.link_inputs;
 
         var digest: [Cache.hex_digest_len]u8 = undefined;
 
@@ -802,11 +1141,8 @@ pub const File = struct {
             // We are about to obtain this lock, so here we give other processes a chance first.
             base.releaseLock();
 
-            for (objects) |obj| {
-                _ = try man.addFilePath(obj.path, null);
-                man.hash.add(obj.must_link);
-                man.hash.add(obj.loption);
-            }
+            try hashInputs(&man, link_inputs);
+
             for (comp.c_object_table.keys()) |key| {
                 _ = try man.addFilePath(key.status.success.object_path, null);
             }
@@ -842,26 +1178,24 @@ pub const File = struct {
             };
         }
 
-        const win32_resource_table_len = comp.win32_resource_table.count();
-        const num_object_files = objects.len + comp.c_object_table.count() + win32_resource_table_len + 2;
-        var object_files = try std.ArrayList([*:0]const u8).initCapacity(gpa, num_object_files);
-        defer object_files.deinit();
+        var object_files: std.ArrayListUnmanaged([*:0]const u8) = .empty;
 
-        for (objects) |obj| {
-            object_files.appendAssumeCapacity(try obj.path.toStringZ(arena));
+        try object_files.ensureUnusedCapacity(arena, link_inputs.len);
+        for (link_inputs) |input| {
+            object_files.appendAssumeCapacity(try input.path().?.toStringZ(arena));
         }
+
+        try object_files.ensureUnusedCapacity(arena, comp.c_object_table.count() +
+            comp.win32_resource_table.count() + 2);
+
         for (comp.c_object_table.keys()) |key| {
             object_files.appendAssumeCapacity(try key.status.success.object_path.toStringZ(arena));
         }
         for (comp.win32_resource_table.keys()) |key| {
             object_files.appendAssumeCapacity(try arena.dupeZ(u8, key.status.success.res_path));
         }
-        if (zcu_obj_path) |p| {
-            object_files.appendAssumeCapacity(try arena.dupeZ(u8, p));
-        }
-        if (compiler_rt_path) |p| {
-            object_files.appendAssumeCapacity(try p.toStringZ(arena));
-        }
+        if (zcu_obj_path) |p| object_files.appendAssumeCapacity(try arena.dupeZ(u8, p));
+        if (compiler_rt_path) |p| object_files.appendAssumeCapacity(try p.toStringZ(arena));
 
         if (comp.verbose_link) {
             std.debug.print("ar rcs {s}", .{full_out_path_z});
@@ -875,8 +1209,16 @@ pub const File = struct {
         const llvm = @import("codegen/llvm.zig");
         const target = comp.root_mod.resolved_target.result;
         llvm.initializeLLVMTarget(target.cpu.arch);
-        const os_tag = llvm.targetOs(target.os.tag);
-        const bad = llvm_bindings.WriteArchive(full_out_path_z, object_files.items.ptr, object_files.items.len, os_tag);
+        const bad = llvm_bindings.WriteArchive(
+            full_out_path_z,
+            object_files.items.ptr,
+            object_files.items.len,
+            switch (target.os.tag) {
+                .aix => .AIXBIG,
+                .windows => .COFF,
+                else => if (target.os.tag.isDarwin()) .DARWIN else .GNU,
+            },
+        );
         if (bad) return error.UnableToWriteArchive;
 
         if (!base.disable_lld_caching) {
@@ -939,36 +1281,6 @@ pub const File = struct {
         }
     };
 
-    pub const ErrorFlags = packed struct {
-        no_entry_point_found: bool = false,
-        missing_libc: bool = false,
-
-        const Int = blk: {
-            const bits = @typeInfo(@This()).@"struct".fields.len;
-            break :blk @Type(.{ .int = .{
-                .signedness = .unsigned,
-                .bits = bits,
-            } });
-        };
-
-        fn isSet(ef: ErrorFlags) bool {
-            return @as(Int, @bitCast(ef)) > 0;
-        }
-    };
-
-    pub const ErrorMsg = struct {
-        msg: []const u8,
-        notes: []ErrorMsg = &.{},
-
-        pub fn deinit(self: *ErrorMsg, gpa: Allocator) void {
-            for (self.notes) |*note| {
-                note.deinit(gpa);
-            }
-            gpa.free(self.notes);
-            gpa.free(self.msg);
-        }
-    };
-
     pub const LazySymbol = struct {
         pub const Kind = enum { code, const_data };
 
@@ -1057,6 +1369,195 @@ pub const File = struct {
     pub const Dwarf = @import("link/Dwarf.zig");
 };
 
+/// Does all the tasks in the queue. Runs in exactly one separate thread
+/// from the rest of compilation. All tasks performed here are
+/// single-threaded with respect to one another.
+pub fn flushTaskQueue(tid: usize, comp: *Compilation) void {
+    // As soon as check() is called, another `flushTaskQueue` call could occur,
+    // so the safety lock must go after the check.
+    while (comp.link_task_queue.check()) |tasks| {
+        comp.link_task_queue_safety.lock();
+        defer comp.link_task_queue_safety.unlock();
+        for (tasks) |task| doTask(comp, tid, task);
+    }
+}
+
+pub const Task = union(enum) {
+    /// Loads the objects, shared objects, and archives that are already
+    /// known from the command line.
+    load_explicitly_provided,
+    /// Loads the shared objects and archives by resolving
+    /// `target_util.libcFullLinkFlags()` against the host libc
+    /// installation.
+    load_host_libc,
+    /// Tells the linker to load an object file by path.
+    load_object: Path,
+    /// Tells the linker to load a static library by path.
+    load_archive: Path,
+    /// Tells the linker to load a shared library, possibly one that is a
+    /// GNU ld script.
+    load_dso: Path,
+    /// Tells the linker to load an input which could be an object file,
+    /// archive, or shared library.
+    load_input: Input,
+
+    /// Write the constant value for a Decl to the output file.
+    codegen_nav: InternPool.Nav.Index,
+    /// Write the machine code for a function to the output file.
+    codegen_func: CodegenFunc,
+    codegen_type: InternPool.Index,
+
+    pub const CodegenFunc = struct {
+        /// This will either be a non-generic `func_decl` or a `func_instance`.
+        func: InternPool.Index,
+        /// This `Air` is owned by the `Job` and allocated with `gpa`.
+        /// It must be deinited when the job is processed.
+        air: Air,
+    };
+};
+
+pub fn doTask(comp: *Compilation, tid: usize, task: Task) void {
+    const diags = &comp.link_diags;
+    switch (task) {
+        .load_explicitly_provided => if (comp.bin_file) |base| {
+            const prog_node = comp.work_queue_progress_node.start("Parse Linker Inputs", comp.link_inputs.len);
+            defer prog_node.end();
+            for (comp.link_inputs) |input| {
+                base.loadInput(input) catch |err| switch (err) {
+                    error.LinkFailure => return, // error reported via diags
+                    else => |e| switch (input) {
+                        .dso => |dso| diags.addParseError(dso.path, "failed to parse shared library: {s}", .{@errorName(e)}),
+                        .object => |obj| diags.addParseError(obj.path, "failed to parse object: {s}", .{@errorName(e)}),
+                        .archive => |obj| diags.addParseError(obj.path, "failed to parse archive: {s}", .{@errorName(e)}),
+                        .res => |res| diags.addParseError(res.path, "failed to parse Windows resource: {s}", .{@errorName(e)}),
+                        .dso_exact => diags.addError("failed to handle dso_exact: {s}", .{@errorName(e)}),
+                    },
+                };
+                prog_node.completeOne();
+            }
+        },
+        .load_host_libc => if (comp.bin_file) |base| {
+            const prog_node = comp.work_queue_progress_node.start("Linker Parse Host libc", 0);
+            defer prog_node.end();
+
+            const target = comp.root_mod.resolved_target.result;
+            const flags = target_util.libcFullLinkFlags(target);
+            const crt_dir = comp.libc_installation.?.crt_dir.?;
+            const sep = std.fs.path.sep_str;
+            for (flags) |flag| {
+                assert(mem.startsWith(u8, flag, "-l"));
+                const lib_name = flag["-l".len..];
+                switch (comp.config.link_mode) {
+                    .dynamic => {
+                        const dso_path = Path.initCwd(
+                            std.fmt.allocPrint(comp.arena, "{s}" ++ sep ++ "{s}{s}{s}", .{
+                                crt_dir, target.libPrefix(), lib_name, target.dynamicLibSuffix(),
+                            }) catch return diags.setAllocFailure(),
+                        );
+                        base.openLoadDso(dso_path, .{
+                            .preferred_mode = .dynamic,
+                            .search_strategy = .paths_first,
+                        }) catch |err| switch (err) {
+                            error.FileNotFound => {
+                                // Also try static.
+                                const archive_path = Path.initCwd(
+                                    std.fmt.allocPrint(comp.arena, "{s}" ++ sep ++ "{s}{s}{s}", .{
+                                        crt_dir, target.libPrefix(), lib_name, target.staticLibSuffix(),
+                                    }) catch return diags.setAllocFailure(),
+                                );
+                                base.openLoadArchive(archive_path, .{
+                                    .preferred_mode = .dynamic,
+                                    .search_strategy = .paths_first,
+                                }) catch |archive_err| switch (archive_err) {
+                                    error.LinkFailure => return, // error reported via diags
+                                    else => |e| diags.addParseError(dso_path, "failed to parse archive {}: {s}", .{ archive_path, @errorName(e) }),
+                                };
+                            },
+                            error.LinkFailure => return, // error reported via diags
+                            else => |e| diags.addParseError(dso_path, "failed to parse shared library: {s}", .{@errorName(e)}),
+                        };
+                    },
+                    .static => {
+                        const path = Path.initCwd(
+                            std.fmt.allocPrint(comp.arena, "{s}" ++ sep ++ "{s}{s}{s}", .{
+                                crt_dir, target.libPrefix(), lib_name, target.staticLibSuffix(),
+                            }) catch return diags.setAllocFailure(),
+                        );
+                        // glibc sometimes makes even archive files GNU ld scripts.
+                        base.openLoadArchive(path, .{
+                            .preferred_mode = .static,
+                            .search_strategy = .no_fallback,
+                        }) catch |err| switch (err) {
+                            error.LinkFailure => return, // error reported via diags
+                            else => |e| diags.addParseError(path, "failed to parse archive: {s}", .{@errorName(e)}),
+                        };
+                    },
+                }
+            }
+        },
+        .load_object => |path| if (comp.bin_file) |base| {
+            const prog_node = comp.work_queue_progress_node.start("Linker Parse Object", 0);
+            defer prog_node.end();
+            base.openLoadObject(path) catch |err| switch (err) {
+                error.LinkFailure => return, // error reported via diags
+                else => |e| diags.addParseError(path, "failed to parse object: {s}", .{@errorName(e)}),
+            };
+        },
+        .load_archive => |path| if (comp.bin_file) |base| {
+            const prog_node = comp.work_queue_progress_node.start("Linker Parse Archive", 0);
+            defer prog_node.end();
+            base.openLoadArchive(path, null) catch |err| switch (err) {
+                error.LinkFailure => return, // error reported via link_diags
+                else => |e| diags.addParseError(path, "failed to parse archive: {s}", .{@errorName(e)}),
+            };
+        },
+        .load_dso => |path| if (comp.bin_file) |base| {
+            const prog_node = comp.work_queue_progress_node.start("Linker Parse Shared Library", 0);
+            defer prog_node.end();
+            base.openLoadDso(path, .{
+                .preferred_mode = .dynamic,
+                .search_strategy = .paths_first,
+            }) catch |err| switch (err) {
+                error.LinkFailure => return, // error reported via link_diags
+                else => |e| diags.addParseError(path, "failed to parse shared library: {s}", .{@errorName(e)}),
+            };
+        },
+        .load_input => |input| if (comp.bin_file) |base| {
+            const prog_node = comp.work_queue_progress_node.start("Linker Parse Input", 0);
+            defer prog_node.end();
+            base.loadInput(input) catch |err| switch (err) {
+                error.LinkFailure => return, // error reported via link_diags
+                else => |e| {
+                    if (input.path()) |path| {
+                        diags.addParseError(path, "failed to parse linker input: {s}", .{@errorName(e)});
+                    } else {
+                        diags.addError("failed to {s}: {s}", .{ input.taskName(), @errorName(e) });
+                    }
+                },
+            };
+        },
+        .codegen_nav => |nav_index| {
+            const pt: Zcu.PerThread = .{ .zcu = comp.zcu.?, .tid = @enumFromInt(tid) };
+            pt.linkerUpdateNav(nav_index) catch |err| switch (err) {
+                error.OutOfMemory => diags.setAllocFailure(),
+            };
+        },
+        .codegen_func => |func| {
+            const pt: Zcu.PerThread = .{ .zcu = comp.zcu.?, .tid = @enumFromInt(tid) };
+            // This call takes ownership of `func.air`.
+            pt.linkerUpdateFunc(func.func, func.air) catch |err| switch (err) {
+                error.OutOfMemory => diags.setAllocFailure(),
+            };
+        },
+        .codegen_type => |ty| {
+            const pt: Zcu.PerThread = .{ .zcu = comp.zcu.?, .tid = @enumFromInt(tid) };
+            pt.linkerUpdateContainerType(ty) catch |err| switch (err) {
+                error.OutOfMemory => diags.setAllocFailure(),
+            };
+        },
+    }
+}
+
 pub fn spawnLld(
     comp: *Compilation,
     arena: Allocator,
@@ -1154,7 +1655,8 @@ pub fn spawnLld(
     switch (term) {
         .Exited => |code| if (code != 0) {
             if (comp.clang_passthrough_mode) std.process.exit(code);
-            comp.lockAndParseLldStderr(argv[1], stderr);
+            const diags = &comp.link_diags;
+            diags.lockAndParseLldStderr(argv[1], stderr);
             return error.LLDReportedFailure;
         },
         else => {
@@ -1166,3 +1668,686 @@ pub fn spawnLld(
 
     if (stderr.len > 0) log.warn("unexpected LLD stderr:\n{s}", .{stderr});
 }
+
+/// Provided by the CLI, processed into `LinkInput` instances at the start of
+/// the compilation pipeline.
+pub const UnresolvedInput = union(enum) {
+    /// A library name that could potentially be dynamic or static depending on
+    /// query parameters, resolved according to library directories.
+    /// This could potentially resolve to a GNU ld script, resulting in more
+    /// library dependencies.
+    name_query: NameQuery,
+    /// When a file path is provided, query info is still needed because the
+    /// path may point to a .so file which may actually be a GNU ld script that
+    /// references library names which need to be resolved.
+    path_query: PathQuery,
+    /// Strings that come from GNU ld scripts. Is it a filename? Is it a path?
+    /// Who knows! Fuck around and find out.
+    ambiguous_name: NameQuery,
+    /// Put exactly this string in the dynamic section, no rpath.
+    dso_exact: Input.DsoExact,
+
+    pub const NameQuery = struct {
+        name: []const u8,
+        query: Query,
+    };
+
+    pub const PathQuery = struct {
+        path: Path,
+        query: Query,
+    };
+
+    pub const Query = struct {
+        needed: bool = false,
+        weak: bool = false,
+        reexport: bool = false,
+        must_link: bool = false,
+        hidden: bool = false,
+        allow_so_scripts: bool = false,
+        preferred_mode: std.builtin.LinkMode,
+        search_strategy: SearchStrategy,
+
+        fn fallbackMode(q: Query) std.builtin.LinkMode {
+            assert(q.search_strategy != .no_fallback);
+            return switch (q.preferred_mode) {
+                .dynamic => .static,
+                .static => .dynamic,
+            };
+        }
+    };
+
+    pub const SearchStrategy = enum {
+        paths_first,
+        mode_first,
+        no_fallback,
+    };
+};
+
+pub const Input = union(enum) {
+    object: Object,
+    archive: Object,
+    res: Res,
+    /// May not be a GNU ld script. Those are resolved when converting from
+    /// `UnresolvedInput` to `Input` values.
+    dso: Dso,
+    dso_exact: DsoExact,
+
+    pub const Object = struct {
+        path: Path,
+        file: fs.File,
+        must_link: bool,
+        hidden: bool,
+    };
+
+    pub const Res = struct {
+        path: Path,
+        file: fs.File,
+    };
+
+    pub const Dso = struct {
+        path: Path,
+        file: fs.File,
+        needed: bool,
+        weak: bool,
+        reexport: bool,
+    };
+
+    pub const DsoExact = struct {
+        /// Includes the ":" prefix. This is intended to be put into the DSO
+        /// section verbatim with no corresponding rpaths.
+        name: []const u8,
+    };
+
+    /// Returns `null` in the case of `dso_exact`.
+    pub fn path(input: Input) ?Path {
+        return switch (input) {
+            .object, .archive => |obj| obj.path,
+            inline .res, .dso => |x| x.path,
+            .dso_exact => null,
+        };
+    }
+
+    /// Returns `null` in the case of `dso_exact`.
+    pub fn pathAndFile(input: Input) ?struct { Path, fs.File } {
+        return switch (input) {
+            .object, .archive => |obj| .{ obj.path, obj.file },
+            inline .res, .dso => |x| .{ x.path, x.file },
+            .dso_exact => null,
+        };
+    }
+
+    pub fn taskName(input: Input) []const u8 {
+        return switch (input) {
+            .object, .archive => |obj| obj.path.basename(),
+            inline .res, .dso => |x| x.path.basename(),
+            .dso_exact => "dso_exact",
+        };
+    }
+};
+
+pub fn hashInputs(man: *Cache.Manifest, link_inputs: []const Input) !void {
+    for (link_inputs) |link_input| {
+        man.hash.add(@as(@typeInfo(Input).@"union".tag_type.?, link_input));
+        switch (link_input) {
+            .object, .archive => |obj| {
+                _ = try man.addOpenedFile(obj.path, obj.file, null);
+                man.hash.add(obj.must_link);
+                man.hash.add(obj.hidden);
+            },
+            .res => |res| {
+                _ = try man.addOpenedFile(res.path, res.file, null);
+            },
+            .dso => |dso| {
+                _ = try man.addOpenedFile(dso.path, dso.file, null);
+                man.hash.add(dso.needed);
+                man.hash.add(dso.weak);
+                man.hash.add(dso.reexport);
+            },
+            .dso_exact => |dso_exact| {
+                man.hash.addBytes(dso_exact.name);
+            },
+        }
+    }
+}
+
+pub fn resolveInputs(
+    gpa: Allocator,
+    arena: Allocator,
+    target: std.Target,
+    /// This function mutates this array but does not take ownership.
+    /// Allocated with `gpa`.
+    unresolved_inputs: *std.ArrayListUnmanaged(UnresolvedInput),
+    /// Allocated with `gpa`.
+    resolved_inputs: *std.ArrayListUnmanaged(Input),
+    lib_directories: []const Cache.Directory,
+    color: std.zig.Color,
+) Allocator.Error!void {
+    var checked_paths: std.ArrayListUnmanaged(u8) = .empty;
+    defer checked_paths.deinit(gpa);
+
+    var ld_script_bytes: std.ArrayListUnmanaged(u8) = .empty;
+    defer ld_script_bytes.deinit(gpa);
+
+    var failed_libs: std.ArrayListUnmanaged(struct {
+        name: []const u8,
+        strategy: UnresolvedInput.SearchStrategy,
+        checked_paths: []const u8,
+        preferred_mode: std.builtin.LinkMode,
+    }) = .empty;
+
+    // Convert external system libs into a stack so that items can be
+    // pushed to it.
+    //
+    // This is necessary because shared objects might turn out to be
+    // "linker scripts" that in fact resolve to one or more other
+    // external system libs, including parameters such as "needed".
+    //
+    // Unfortunately, such files need to be detected immediately, so
+    // that this library search logic can be applied to them.
+    mem.reverse(UnresolvedInput, unresolved_inputs.items);
+
+    syslib: while (unresolved_inputs.popOrNull()) |unresolved_input| {
+        const name_query: UnresolvedInput.NameQuery = switch (unresolved_input) {
+            .name_query => |nq| nq,
+            .ambiguous_name => |an| an: {
+                const lib_name, const link_mode = stripLibPrefixAndSuffix(an.name, target) orelse {
+                    try resolvePathInput(gpa, arena, unresolved_inputs, resolved_inputs, &ld_script_bytes, target, .{
+                        .path = Path.initCwd(an.name),
+                        .query = an.query,
+                    }, color);
+                    continue;
+                };
+                break :an .{
+                    .name = lib_name,
+                    .query = .{
+                        .needed = an.query.needed,
+                        .weak = an.query.weak,
+                        .reexport = an.query.reexport,
+                        .must_link = an.query.must_link,
+                        .hidden = an.query.hidden,
+                        .allow_so_scripts = an.query.allow_so_scripts,
+                        .preferred_mode = link_mode,
+                        .search_strategy = .no_fallback,
+                    },
+                };
+            },
+            .path_query => |pq| {
+                try resolvePathInput(gpa, arena, unresolved_inputs, resolved_inputs, &ld_script_bytes, target, pq, color);
+                continue;
+            },
+            .dso_exact => |dso_exact| {
+                try resolved_inputs.append(gpa, .{ .dso_exact = dso_exact });
+                continue;
+            },
+        };
+        const query = name_query.query;
+
+        // Checked in the first pass above while looking for libc libraries.
+        assert(!fs.path.isAbsolute(name_query.name));
+
+        checked_paths.clearRetainingCapacity();
+
+        switch (query.search_strategy) {
+            .mode_first, .no_fallback => {
+                // check for preferred mode
+                for (lib_directories) |lib_directory| switch (try resolveLibInput(
+                    gpa,
+                    arena,
+                    unresolved_inputs,
+                    resolved_inputs,
+                    &checked_paths,
+                    &ld_script_bytes,
+                    lib_directory,
+                    name_query,
+                    target,
+                    query.preferred_mode,
+                    color,
+                )) {
+                    .ok => continue :syslib,
+                    .no_match => {},
+                };
+                // check for fallback mode
+                if (query.search_strategy == .no_fallback) {
+                    try failed_libs.append(arena, .{
+                        .name = name_query.name,
+                        .strategy = query.search_strategy,
+                        .checked_paths = try arena.dupe(u8, checked_paths.items),
+                        .preferred_mode = query.preferred_mode,
+                    });
+                    continue :syslib;
+                }
+                for (lib_directories) |lib_directory| switch (try resolveLibInput(
+                    gpa,
+                    arena,
+                    unresolved_inputs,
+                    resolved_inputs,
+                    &checked_paths,
+                    &ld_script_bytes,
+                    lib_directory,
+                    name_query,
+                    target,
+                    query.fallbackMode(),
+                    color,
+                )) {
+                    .ok => continue :syslib,
+                    .no_match => {},
+                };
+                try failed_libs.append(arena, .{
+                    .name = name_query.name,
+                    .strategy = query.search_strategy,
+                    .checked_paths = try arena.dupe(u8, checked_paths.items),
+                    .preferred_mode = query.preferred_mode,
+                });
+                continue :syslib;
+            },
+            .paths_first => {
+                for (lib_directories) |lib_directory| {
+                    // check for preferred mode
+                    switch (try resolveLibInput(
+                        gpa,
+                        arena,
+                        unresolved_inputs,
+                        resolved_inputs,
+                        &checked_paths,
+                        &ld_script_bytes,
+                        lib_directory,
+                        name_query,
+                        target,
+                        query.preferred_mode,
+                        color,
+                    )) {
+                        .ok => continue :syslib,
+                        .no_match => {},
+                    }
+
+                    // check for fallback mode
+                    switch (try resolveLibInput(
+                        gpa,
+                        arena,
+                        unresolved_inputs,
+                        resolved_inputs,
+                        &checked_paths,
+                        &ld_script_bytes,
+                        lib_directory,
+                        name_query,
+                        target,
+                        query.fallbackMode(),
+                        color,
+                    )) {
+                        .ok => continue :syslib,
+                        .no_match => {},
+                    }
+                }
+                try failed_libs.append(arena, .{
+                    .name = name_query.name,
+                    .strategy = query.search_strategy,
+                    .checked_paths = try arena.dupe(u8, checked_paths.items),
+                    .preferred_mode = query.preferred_mode,
+                });
+                continue :syslib;
+            },
+        }
+        @compileError("unreachable");
+    }
+
+    if (failed_libs.items.len > 0) {
+        for (failed_libs.items) |f| {
+            const searched_paths = if (f.checked_paths.len == 0) " none" else f.checked_paths;
+            std.log.err("unable to find {s} system library '{s}' using strategy '{s}'. searched paths:{s}", .{
+                @tagName(f.preferred_mode), f.name, @tagName(f.strategy), searched_paths,
+            });
+        }
+        std.process.exit(1);
+    }
+}
+
+const ResolveLibInputResult = enum { ok, no_match };
+const fatal = std.process.fatal;
+
+fn resolveLibInput(
+    gpa: Allocator,
+    arena: Allocator,
+    /// Allocated via `gpa`.
+    unresolved_inputs: *std.ArrayListUnmanaged(UnresolvedInput),
+    /// Allocated via `gpa`.
+    resolved_inputs: *std.ArrayListUnmanaged(Input),
+    /// Allocated via `gpa`.
+    checked_paths: *std.ArrayListUnmanaged(u8),
+    /// Allocated via `gpa`.
+    ld_script_bytes: *std.ArrayListUnmanaged(u8),
+    lib_directory: Directory,
+    name_query: UnresolvedInput.NameQuery,
+    target: std.Target,
+    link_mode: std.builtin.LinkMode,
+    color: std.zig.Color,
+) Allocator.Error!ResolveLibInputResult {
+    try resolved_inputs.ensureUnusedCapacity(gpa, 1);
+
+    const lib_name = name_query.name;
+
+    if (target.isDarwin() and link_mode == .dynamic) tbd: {
+        // Prefer .tbd over .dylib.
+        const test_path: Path = .{
+            .root_dir = lib_directory,
+            .sub_path = try std.fmt.allocPrint(arena, "lib{s}.tbd", .{lib_name}),
+        };
+        try checked_paths.writer(gpa).print("\n  {}", .{test_path});
+        var file = test_path.root_dir.handle.openFile(test_path.sub_path, .{}) catch |err| switch (err) {
+            error.FileNotFound => break :tbd,
+            else => |e| fatal("unable to search for tbd library '{}': {s}", .{ test_path, @errorName(e) }),
+        };
+        errdefer file.close();
+        return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, name_query.query);
+    }
+
+    {
+        const test_path: Path = .{
+            .root_dir = lib_directory,
+            .sub_path = try std.fmt.allocPrint(arena, "{s}{s}{s}", .{
+                target.libPrefix(), lib_name, switch (link_mode) {
+                    .static => target.staticLibSuffix(),
+                    .dynamic => target.dynamicLibSuffix(),
+                },
+            }),
+        };
+        try checked_paths.writer(gpa).print("\n  {}", .{test_path});
+        switch (try resolvePathInputLib(gpa, arena, unresolved_inputs, resolved_inputs, ld_script_bytes, target, .{
+            .path = test_path,
+            .query = name_query.query,
+        }, link_mode, color)) {
+            .no_match => {},
+            .ok => return .ok,
+        }
+    }
+
+    // In the case of Darwin, the main check will be .dylib, so here we
+    // additionally check for .so files.
+    if (target.isDarwin() and link_mode == .dynamic) so: {
+        const test_path: Path = .{
+            .root_dir = lib_directory,
+            .sub_path = try std.fmt.allocPrint(arena, "lib{s}.so", .{lib_name}),
+        };
+        try checked_paths.writer(gpa).print("\n  {}", .{test_path});
+        var file = test_path.root_dir.handle.openFile(test_path.sub_path, .{}) catch |err| switch (err) {
+            error.FileNotFound => break :so,
+            else => |e| fatal("unable to search for so library '{}': {s}", .{
+                test_path, @errorName(e),
+            }),
+        };
+        errdefer file.close();
+        return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, name_query.query);
+    }
+
+    // In the case of MinGW, the main check will be .lib but we also need to
+    // look for `libfoo.a`.
+    if (target.isMinGW() and link_mode == .static) mingw: {
+        const test_path: Path = .{
+            .root_dir = lib_directory,
+            .sub_path = try std.fmt.allocPrint(arena, "lib{s}.a", .{lib_name}),
+        };
+        try checked_paths.writer(gpa).print("\n  {}", .{test_path});
+        var file = test_path.root_dir.handle.openFile(test_path.sub_path, .{}) catch |err| switch (err) {
+            error.FileNotFound => break :mingw,
+            else => |e| fatal("unable to search for static library '{}': {s}", .{ test_path, @errorName(e) }),
+        };
+        errdefer file.close();
+        return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, name_query.query);
+    }
+
+    return .no_match;
+}
+
+fn finishResolveLibInput(
+    resolved_inputs: *std.ArrayListUnmanaged(Input),
+    path: Path,
+    file: std.fs.File,
+    link_mode: std.builtin.LinkMode,
+    query: UnresolvedInput.Query,
+) ResolveLibInputResult {
+    switch (link_mode) {
+        .static => resolved_inputs.appendAssumeCapacity(.{ .archive = .{
+            .path = path,
+            .file = file,
+            .must_link = query.must_link,
+            .hidden = query.hidden,
+        } }),
+        .dynamic => resolved_inputs.appendAssumeCapacity(.{ .dso = .{
+            .path = path,
+            .file = file,
+            .needed = query.needed,
+            .weak = query.weak,
+            .reexport = query.reexport,
+        } }),
+    }
+    return .ok;
+}
+
+fn resolvePathInput(
+    gpa: Allocator,
+    arena: Allocator,
+    /// Allocated with `gpa`.
+    unresolved_inputs: *std.ArrayListUnmanaged(UnresolvedInput),
+    /// Allocated with `gpa`.
+    resolved_inputs: *std.ArrayListUnmanaged(Input),
+    /// Allocated via `gpa`.
+    ld_script_bytes: *std.ArrayListUnmanaged(u8),
+    target: std.Target,
+    pq: UnresolvedInput.PathQuery,
+    color: std.zig.Color,
+) Allocator.Error!void {
+    switch (switch (Compilation.classifyFileExt(pq.path.sub_path)) {
+        .static_library => try resolvePathInputLib(gpa, arena, unresolved_inputs, resolved_inputs, ld_script_bytes, target, pq, .static, color),
+        .shared_library => try resolvePathInputLib(gpa, arena, unresolved_inputs, resolved_inputs, ld_script_bytes, target, pq, .dynamic, color),
+        .object => {
+            var file = pq.path.root_dir.handle.openFile(pq.path.sub_path, .{}) catch |err|
+                fatal("failed to open object {}: {s}", .{ pq.path, @errorName(err) });
+            errdefer file.close();
+            try resolved_inputs.append(gpa, .{ .object = .{
+                .path = pq.path,
+                .file = file,
+                .must_link = pq.query.must_link,
+                .hidden = pq.query.hidden,
+            } });
+            return;
+        },
+        .res => {
+            var file = pq.path.root_dir.handle.openFile(pq.path.sub_path, .{}) catch |err|
+                fatal("failed to open windows resource {}: {s}", .{ pq.path, @errorName(err) });
+            errdefer file.close();
+            try resolved_inputs.append(gpa, .{ .res = .{
+                .path = pq.path,
+                .file = file,
+            } });
+            return;
+        },
+        else => fatal("{}: unrecognized file extension", .{pq.path}),
+    }) {
+        .ok => {},
+        .no_match => fatal("{}: file not found", .{pq.path}),
+    }
+}
+
+fn resolvePathInputLib(
+    gpa: Allocator,
+    arena: Allocator,
+    /// Allocated with `gpa`.
+    unresolved_inputs: *std.ArrayListUnmanaged(UnresolvedInput),
+    /// Allocated with `gpa`.
+    resolved_inputs: *std.ArrayListUnmanaged(Input),
+    /// Allocated via `gpa`.
+    ld_script_bytes: *std.ArrayListUnmanaged(u8),
+    target: std.Target,
+    pq: UnresolvedInput.PathQuery,
+    link_mode: std.builtin.LinkMode,
+    color: std.zig.Color,
+) Allocator.Error!ResolveLibInputResult {
+    try resolved_inputs.ensureUnusedCapacity(gpa, 1);
+
+    const test_path: Path = pq.path;
+    // In the case of .so files, they might actually be "linker scripts"
+    // that contain references to other libraries.
+    if (pq.query.allow_so_scripts and target.ofmt == .elf and mem.endsWith(u8, test_path.sub_path, ".so")) {
+        var file = test_path.root_dir.handle.openFile(test_path.sub_path, .{}) catch |err| switch (err) {
+            error.FileNotFound => return .no_match,
+            else => |e| fatal("unable to search for {s} library '{'}': {s}", .{
+                @tagName(link_mode), test_path, @errorName(e),
+            }),
+        };
+        errdefer file.close();
+        try ld_script_bytes.resize(gpa, @sizeOf(std.elf.Elf64_Ehdr));
+        const n = file.preadAll(ld_script_bytes.items, 0) catch |err| fatal("failed to read '{'}': {s}", .{
+            test_path, @errorName(err),
+        });
+        elf_file: {
+            if (n != ld_script_bytes.items.len) break :elf_file;
+            if (!mem.eql(u8, ld_script_bytes.items[0..4], "\x7fELF")) break :elf_file;
+            // Appears to be an ELF file.
+            return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, pq.query);
+        }
+        const stat = file.stat() catch |err|
+            fatal("failed to stat {}: {s}", .{ test_path, @errorName(err) });
+        const size = std.math.cast(u32, stat.size) orelse
+            fatal("{}: linker script too big", .{test_path});
+        try ld_script_bytes.resize(gpa, size);
+        const buf = ld_script_bytes.items[n..];
+        const n2 = file.preadAll(buf, n) catch |err|
+            fatal("failed to read {}: {s}", .{ test_path, @errorName(err) });
+        if (n2 != buf.len) fatal("failed to read {}: unexpected end of file", .{test_path});
+        var diags = Diags.init(gpa);
+        defer diags.deinit();
+        const ld_script_result = LdScript.parse(gpa, &diags, test_path, ld_script_bytes.items);
+        if (diags.hasErrors()) {
+            var wip_errors: std.zig.ErrorBundle.Wip = undefined;
+            try wip_errors.init(gpa);
+            defer wip_errors.deinit();
+
+            try diags.addMessagesToBundle(&wip_errors);
+
+            var error_bundle = try wip_errors.toOwnedBundle("");
+            defer error_bundle.deinit(gpa);
+
+            error_bundle.renderToStdErr(color.renderOptions());
+
+            std.process.exit(1);
+        }
+
+        var ld_script = ld_script_result catch |err|
+            fatal("{}: failed to parse linker script: {s}", .{ test_path, @errorName(err) });
+        defer ld_script.deinit(gpa);
+
+        try unresolved_inputs.ensureUnusedCapacity(gpa, ld_script.args.len);
+        for (ld_script.args) |arg| {
+            const query: UnresolvedInput.Query = .{
+                .needed = arg.needed or pq.query.needed,
+                .weak = pq.query.weak,
+                .reexport = pq.query.reexport,
+                .preferred_mode = pq.query.preferred_mode,
+                .search_strategy = pq.query.search_strategy,
+                .allow_so_scripts = pq.query.allow_so_scripts,
+            };
+            if (mem.startsWith(u8, arg.path, "-l")) {
+                unresolved_inputs.appendAssumeCapacity(.{ .name_query = .{
+                    .name = try arena.dupe(u8, arg.path["-l".len..]),
+                    .query = query,
+                } });
+            } else {
+                unresolved_inputs.appendAssumeCapacity(.{ .ambiguous_name = .{
+                    .name = try arena.dupe(u8, arg.path),
+                    .query = query,
+                } });
+            }
+        }
+        file.close();
+        return .ok;
+    }
+
+    var file = test_path.root_dir.handle.openFile(test_path.sub_path, .{}) catch |err| switch (err) {
+        error.FileNotFound => return .no_match,
+        else => |e| fatal("unable to search for {s} library {}: {s}", .{
+            @tagName(link_mode), test_path, @errorName(e),
+        }),
+    };
+    errdefer file.close();
+    return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, pq.query);
+}
+
+pub fn openObject(path: Path, must_link: bool, hidden: bool) !Input.Object {
+    var file = try path.root_dir.handle.openFile(path.sub_path, .{});
+    errdefer file.close();
+    return .{
+        .path = path,
+        .file = file,
+        .must_link = must_link,
+        .hidden = hidden,
+    };
+}
+
+pub fn openDso(path: Path, needed: bool, weak: bool, reexport: bool) !Input.Dso {
+    var file = try path.root_dir.handle.openFile(path.sub_path, .{});
+    errdefer file.close();
+    return .{
+        .path = path,
+        .file = file,
+        .needed = needed,
+        .weak = weak,
+        .reexport = reexport,
+    };
+}
+
+pub fn openObjectInput(diags: *Diags, path: Path) error{LinkFailure}!Input {
+    return .{ .object = openObject(path, false, false) catch |err| {
+        return diags.failParse(path, "failed to open {}: {s}", .{ path, @errorName(err) });
+    } };
+}
+
+pub fn openArchiveInput(diags: *Diags, path: Path, must_link: bool, hidden: bool) error{LinkFailure}!Input {
+    return .{ .archive = openObject(path, must_link, hidden) catch |err| {
+        return diags.failParse(path, "failed to open {}: {s}", .{ path, @errorName(err) });
+    } };
+}
+
+pub fn openDsoInput(diags: *Diags, path: Path, needed: bool, weak: bool, reexport: bool) error{LinkFailure}!Input {
+    return .{ .dso = openDso(path, needed, weak, reexport) catch |err| {
+        return diags.failParse(path, "failed to open {}: {s}", .{ path, @errorName(err) });
+    } };
+}
+
+fn stripLibPrefixAndSuffix(path: []const u8, target: std.Target) ?struct { []const u8, std.builtin.LinkMode } {
+    const prefix = target.libPrefix();
+    const static_suffix = target.staticLibSuffix();
+    const dynamic_suffix = target.dynamicLibSuffix();
+    const basename = fs.path.basename(path);
+    const unlibbed = if (mem.startsWith(u8, basename, prefix)) basename[prefix.len..] else return null;
+    if (mem.endsWith(u8, unlibbed, static_suffix)) return .{
+        unlibbed[0 .. unlibbed.len - static_suffix.len], .static,
+    };
+    if (mem.endsWith(u8, unlibbed, dynamic_suffix)) return .{
+        unlibbed[0 .. unlibbed.len - dynamic_suffix.len], .dynamic,
+    };
+    return null;
+}
+
+/// Returns true if and only if there is at least one input of type object,
+/// archive, or Windows resource file.
+pub fn anyObjectInputs(inputs: []const Input) bool {
+    return countObjectInputs(inputs) != 0;
+}
+
+/// Returns the number of inputs of type object, archive, or Windows resource file.
+pub fn countObjectInputs(inputs: []const Input) usize {
+    var count: usize = 0;
+    for (inputs) |input| switch (input) {
+        .dso, .dso_exact => continue,
+        .res, .object, .archive => count += 1,
+    };
+    return count;
+}
+
+/// Returns the first input of type object or archive.
+pub fn firstObjectInput(inputs: []const Input) ?Input.Object {
+    for (inputs) |input| switch (input) {
+        .object, .archive => |obj| return obj,
+        .res, .dso, .dso_exact => continue,
+    };
+    return null;
+}
diff --git a/zig/src/link/C.zig b/zig/src/link/C.zig
index d2d4ca9fbc..21dc42a718 100644
--- a/zig/src/link/C.zig
+++ b/zig/src/link/C.zig
@@ -217,7 +217,7 @@ pub fn updateFunc(
                 .mod = zcu.navFileScope(func.owner_nav).mod,
                 .error_msg = null,
                 .pass = .{ .nav = func.owner_nav },
-                .is_naked_fn = zcu.navValue(func.owner_nav).typeOf(zcu).fnCallingConvention(zcu) == .Naked,
+                .is_naked_fn = zcu.navValue(func.owner_nav).typeOf(zcu).fnCallingConvention(zcu) == .naked,
                 .fwd_decl = fwd_decl.toManaged(gpa),
                 .ctype_pool = ctype_pool.*,
                 .scratch = .{},
diff --git a/zig/src/link/Coff.zig b/zig/src/link/Coff.zig
index b104cd5840..cf691c4f12 100644
--- a/zig/src/link/Coff.zig
+++ b/zig/src/link/Coff.zig
@@ -16,7 +16,7 @@ dynamicbase: bool,
 /// default or populated together. They should not be separate fields.
 major_subsystem_version: u16,
 minor_subsystem_version: u16,
-lib_dirs: []const []const u8,
+lib_directories: []const Directory,
 entry: link.File.OpenOptions.Entry,
 entry_addr: ?u32,
 module_definition_file: ?[]const u8,
@@ -26,10 +26,8 @@ repro: bool,
 ptr_width: PtrWidth,
 page_size: u32,
 
-objects: std.ArrayListUnmanaged(Object) = .empty,
-
 sections: std.MultiArrayList(Section) = .{},
-data_directories: [coff.IMAGE_NUMBEROF_DIRECTORY_ENTRIES]coff.ImageDataDirectory,
+data_directories: [coff_util.IMAGE_NUMBEROF_DIRECTORY_ENTRIES]coff_util.ImageDataDirectory,
 
 text_section_index: ?u16 = null,
 got_section_index: ?u16 = null,
@@ -38,7 +36,7 @@ data_section_index: ?u16 = null,
 reloc_section_index: ?u16 = null,
 idata_section_index: ?u16 = null,
 
-locals: std.ArrayListUnmanaged(coff.Symbol) = .empty,
+locals: std.ArrayListUnmanaged(coff_util.Symbol) = .empty,
 globals: std.ArrayListUnmanaged(SymbolWithLoc) = .empty,
 resolver: std.StringHashMapUnmanaged(u32) = .empty,
 unresolved: std.AutoArrayHashMapUnmanaged(u32, bool) = .empty,
@@ -112,7 +110,7 @@ const default_size_of_heap_reserve: u32 = 0x100000;
 const default_size_of_heap_commit: u32 = 0x1000;
 
 const Section = struct {
-    header: coff.SectionHeader,
+    header: coff_util.SectionHeader,
 
     last_atom_index: ?Atom.Index = null,
 
@@ -154,9 +152,9 @@ const AvMetadata = struct {
         m.exports.deinit(allocator);
     }
 
-    fn getExport(m: AvMetadata, coff_file: *const Coff, name: []const u8) ?u32 {
+    fn getExport(m: AvMetadata, coff: *const Coff, name: []const u8) ?u32 {
         for (m.exports.items) |exp| {
-            if (mem.eql(u8, name, coff_file.getSymbolName(.{
+            if (mem.eql(u8, name, coff.getSymbolName(.{
                 .sym_index = exp,
                 .file = null,
             }))) return exp;
@@ -164,9 +162,9 @@ const AvMetadata = struct {
         return null;
     }
 
-    fn getExportPtr(m: *AvMetadata, coff_file: *Coff, name: []const u8) ?*u32 {
+    fn getExportPtr(m: *AvMetadata, coff: *Coff, name: []const u8) ?*u32 {
         for (m.exports.items) |*exp| {
-            if (mem.eql(u8, name, coff_file.getSymbolName(.{
+            if (mem.eql(u8, name, coff.getSymbolName(.{
                 .sym_index = exp.*,
                 .file = null,
             }))) return exp;
@@ -247,10 +245,10 @@ pub fn createEmpty(
     const zcu_object_sub_path = if (!use_lld and !use_llvm)
         null
     else
-        try std.fmt.allocPrint(arena, "{s}.obj", .{emit.sub_path});
+        try allocPrint(arena, "{s}.obj", .{emit.sub_path});
 
-    const self = try arena.create(Coff);
-    self.* = .{
+    const coff = try arena.create(Coff);
+    coff.* = .{
         .base = .{
             .tag = .coff,
             .comp = comp,
@@ -267,18 +265,22 @@ pub fn createEmpty(
         .ptr_width = ptr_width,
         .page_size = page_size,
 
-        .data_directories = [1]coff.ImageDataDirectory{.{
+        .data_directories = [1]coff_util.ImageDataDirectory{.{
             .virtual_address = 0,
             .size = 0,
-        }} ** coff.IMAGE_NUMBEROF_DIRECTORY_ENTRIES,
+        }} ** coff_util.IMAGE_NUMBEROF_DIRECTORY_ENTRIES,
 
         .image_base = options.image_base orelse switch (output_mode) {
             .Exe => switch (target.cpu.arch) {
-                .aarch64 => 0x140000000,
-                .thumb, .x86_64, .x86 => 0x400000,
+                .aarch64, .x86_64 => 0x140000000,
+                .thumb, .x86 => 0x400000,
+                else => unreachable,
+            },
+            .Lib => switch (target.cpu.arch) {
+                .aarch64, .x86_64 => 0x180000000,
+                .thumb, .x86 => 0x10000000,
                 else => unreachable,
             },
-            .Lib => 0x10000000,
             .Obj => 0,
         },
 
@@ -293,7 +295,7 @@ pub fn createEmpty(
         .dynamicbase = options.dynamicbase,
         .major_subsystem_version = options.major_subsystem_version orelse 6,
         .minor_subsystem_version = options.minor_subsystem_version orelse 0,
-        .lib_dirs = options.lib_dirs,
+        .lib_directories = options.lib_directories,
         .entry_addr = math.cast(u32, options.entry_addr orelse 0) orelse
             return error.EntryAddressTooBig,
         .module_definition_file = options.module_definition_file,
@@ -301,35 +303,35 @@ pub fn createEmpty(
         .repro = options.repro,
     };
     if (use_llvm and comp.config.have_zcu) {
-        self.llvm_object = try LlvmObject.create(arena, comp);
+        coff.llvm_object = try LlvmObject.create(arena, comp);
     }
-    errdefer self.base.destroy();
+    errdefer coff.base.destroy();
 
     if (use_lld and (use_llvm or !comp.config.have_zcu)) {
         // LLVM emits the object file (if any); LLD links it into the final product.
-        return self;
+        return coff;
     }
 
     // What path should this COFF linker code output to?
     // If using LLD to link, this code should produce an object file so that it
     // can be passed to LLD.
     const sub_path = if (use_lld) zcu_object_sub_path.? else emit.sub_path;
-    self.base.file = try emit.root_dir.handle.createFile(sub_path, .{
+    coff.base.file = try emit.root_dir.handle.createFile(sub_path, .{
         .truncate = true,
         .read = true,
         .mode = link.File.determineMode(use_lld, output_mode, link_mode),
     });
 
-    assert(self.llvm_object == null);
+    assert(coff.llvm_object == null);
     const gpa = comp.gpa;
 
-    try self.strtab.buffer.ensureUnusedCapacity(gpa, @sizeOf(u32));
-    self.strtab.buffer.appendNTimesAssumeCapacity(0, @sizeOf(u32));
+    try coff.strtab.buffer.ensureUnusedCapacity(gpa, @sizeOf(u32));
+    coff.strtab.buffer.appendNTimesAssumeCapacity(0, @sizeOf(u32));
 
-    try self.temp_strtab.buffer.append(gpa, 0);
+    try coff.temp_strtab.buffer.append(gpa, 0);
 
     // Index 0 is always a null symbol.
-    try self.locals.append(gpa, .{
+    try coff.locals.append(gpa, .{
         .name = [_]u8{0} ** 8,
         .value = 0,
         .section_number = .UNDEFINED,
@@ -338,61 +340,61 @@ pub fn createEmpty(
         .number_of_aux_symbols = 0,
     });
 
-    if (self.text_section_index == null) {
+    if (coff.text_section_index == null) {
         const file_size: u32 = @intCast(options.program_code_size_hint);
-        self.text_section_index = try self.allocateSection(".text", file_size, .{
+        coff.text_section_index = try coff.allocateSection(".text", file_size, .{
             .CNT_CODE = 1,
             .MEM_EXECUTE = 1,
             .MEM_READ = 1,
         });
     }
 
-    if (self.got_section_index == null) {
-        const file_size = @as(u32, @intCast(options.symbol_count_hint)) * self.ptr_width.size();
-        self.got_section_index = try self.allocateSection(".got", file_size, .{
+    if (coff.got_section_index == null) {
+        const file_size = @as(u32, @intCast(options.symbol_count_hint)) * coff.ptr_width.size();
+        coff.got_section_index = try coff.allocateSection(".got", file_size, .{
             .CNT_INITIALIZED_DATA = 1,
             .MEM_READ = 1,
         });
     }
 
-    if (self.rdata_section_index == null) {
-        const file_size: u32 = self.page_size;
-        self.rdata_section_index = try self.allocateSection(".rdata", file_size, .{
+    if (coff.rdata_section_index == null) {
+        const file_size: u32 = coff.page_size;
+        coff.rdata_section_index = try coff.allocateSection(".rdata", file_size, .{
             .CNT_INITIALIZED_DATA = 1,
             .MEM_READ = 1,
         });
     }
 
-    if (self.data_section_index == null) {
-        const file_size: u32 = self.page_size;
-        self.data_section_index = try self.allocateSection(".data", file_size, .{
+    if (coff.data_section_index == null) {
+        const file_size: u32 = coff.page_size;
+        coff.data_section_index = try coff.allocateSection(".data", file_size, .{
             .CNT_INITIALIZED_DATA = 1,
             .MEM_READ = 1,
             .MEM_WRITE = 1,
         });
     }
 
-    if (self.idata_section_index == null) {
-        const file_size = @as(u32, @intCast(options.symbol_count_hint)) * self.ptr_width.size();
-        self.idata_section_index = try self.allocateSection(".idata", file_size, .{
+    if (coff.idata_section_index == null) {
+        const file_size = @as(u32, @intCast(options.symbol_count_hint)) * coff.ptr_width.size();
+        coff.idata_section_index = try coff.allocateSection(".idata", file_size, .{
             .CNT_INITIALIZED_DATA = 1,
             .MEM_READ = 1,
         });
     }
 
-    if (self.reloc_section_index == null) {
-        const file_size = @as(u32, @intCast(options.symbol_count_hint)) * @sizeOf(coff.BaseRelocation);
-        self.reloc_section_index = try self.allocateSection(".reloc", file_size, .{
+    if (coff.reloc_section_index == null) {
+        const file_size = @as(u32, @intCast(options.symbol_count_hint)) * @sizeOf(coff_util.BaseRelocation);
+        coff.reloc_section_index = try coff.allocateSection(".reloc", file_size, .{
             .CNT_INITIALIZED_DATA = 1,
             .MEM_DISCARDABLE = 1,
             .MEM_READ = 1,
         });
     }
 
-    if (self.strtab_offset == null) {
-        const file_size = @as(u32, @intCast(self.strtab.buffer.items.len));
-        self.strtab_offset = self.findFreeSpace(file_size, @alignOf(u32)); // 4bytes aligned seems like a good idea here
-        log.debug("found strtab free space 0x{x} to 0x{x}", .{ self.strtab_offset.?, self.strtab_offset.? + file_size });
+    if (coff.strtab_offset == null) {
+        const file_size = @as(u32, @intCast(coff.strtab.buffer.items.len));
+        coff.strtab_offset = coff.findFreeSpace(file_size, @alignOf(u32)); // 4bytes aligned seems like a good idea here
+        log.debug("found strtab free space 0x{x} to 0x{x}", .{ coff.strtab_offset.?, coff.strtab_offset.? + file_size });
     }
 
     {
@@ -401,15 +403,15 @@ pub fn createEmpty(
         // offset + it's filesize.
         // TODO I don't like this here one bit
         var max_file_offset: u64 = 0;
-        for (self.sections.items(.header)) |header| {
+        for (coff.sections.items(.header)) |header| {
             if (header.pointer_to_raw_data + header.size_of_raw_data > max_file_offset) {
                 max_file_offset = header.pointer_to_raw_data + header.size_of_raw_data;
             }
         }
-        try self.base.file.?.pwriteAll(&[_]u8{0}, max_file_offset);
+        try coff.base.file.?.pwriteAll(&[_]u8{0}, max_file_offset);
     }
 
-    return self;
+    return coff;
 }
 
 pub fn open(
@@ -423,85 +425,80 @@ pub fn open(
     return createEmpty(arena, comp, emit, options);
 }
 
-pub fn deinit(self: *Coff) void {
-    const gpa = self.base.comp.gpa;
+pub fn deinit(coff: *Coff) void {
+    const gpa = coff.base.comp.gpa;
 
-    if (self.llvm_object) |llvm_object| llvm_object.deinit();
-
-    for (self.objects.items) |*object| {
-        object.deinit(gpa);
-    }
-    self.objects.deinit(gpa);
+    if (coff.llvm_object) |llvm_object| llvm_object.deinit();
 
-    for (self.sections.items(.free_list)) |*free_list| {
+    for (coff.sections.items(.free_list)) |*free_list| {
         free_list.deinit(gpa);
     }
-    self.sections.deinit(gpa);
+    coff.sections.deinit(gpa);
 
-    self.atoms.deinit(gpa);
-    self.locals.deinit(gpa);
-    self.globals.deinit(gpa);
+    coff.atoms.deinit(gpa);
+    coff.locals.deinit(gpa);
+    coff.globals.deinit(gpa);
 
     {
-        var it = self.resolver.keyIterator();
+        var it = coff.resolver.keyIterator();
         while (it.next()) |key_ptr| {
             gpa.free(key_ptr.*);
         }
-        self.resolver.deinit(gpa);
+        coff.resolver.deinit(gpa);
     }
 
-    self.unresolved.deinit(gpa);
-    self.locals_free_list.deinit(gpa);
-    self.globals_free_list.deinit(gpa);
-    self.strtab.deinit(gpa);
-    self.temp_strtab.deinit(gpa);
-    self.got_table.deinit(gpa);
+    coff.unresolved.deinit(gpa);
+    coff.locals_free_list.deinit(gpa);
+    coff.globals_free_list.deinit(gpa);
+    coff.strtab.deinit(gpa);
+    coff.temp_strtab.deinit(gpa);
+    coff.got_table.deinit(gpa);
 
-    for (self.import_tables.values()) |*itab| {
+    for (coff.import_tables.values()) |*itab| {
         itab.deinit(gpa);
     }
-    self.import_tables.deinit(gpa);
+    coff.import_tables.deinit(gpa);
 
-    self.lazy_syms.deinit(gpa);
+    coff.lazy_syms.deinit(gpa);
 
-    for (self.navs.values()) |*metadata| {
+    for (coff.navs.values()) |*metadata| {
         metadata.deinit(gpa);
     }
-    self.navs.deinit(gpa);
+    coff.navs.deinit(gpa);
 
-    self.atom_by_index_table.deinit(gpa);
+    coff.atom_by_index_table.deinit(gpa);
 
     {
-        var it = self.uavs.iterator();
+        var it = coff.uavs.iterator();
         while (it.next()) |entry| {
             entry.value_ptr.exports.deinit(gpa);
         }
-        self.uavs.deinit(gpa);
+        coff.uavs.deinit(gpa);
     }
 
-    for (self.relocs.values()) |*relocs| {
+    for (coff.relocs.values()) |*relocs| {
         relocs.deinit(gpa);
     }
-    self.relocs.deinit(gpa);
+    coff.relocs.deinit(gpa);
 
-    for (self.base_relocs.values()) |*relocs| {
+    for (coff.base_relocs.values()) |*relocs| {
         relocs.deinit(gpa);
     }
-    self.base_relocs.deinit(gpa);
+    coff.base_relocs.deinit(gpa);
 }
 
-fn allocateSection(self: *Coff, name: []const u8, size: u32, flags: coff.SectionHeaderFlags) !u16 {
-    const index = @as(u16, @intCast(self.sections.slice().len));
-    const off = self.findFreeSpace(size, default_file_alignment);
+fn allocateSection(coff: *Coff, name: []const u8, size: u32, flags: coff_util.SectionHeaderFlags) !u16 {
+    const index = @as(u16, @intCast(coff.sections.slice().len));
+    const off = coff.findFreeSpace(size, default_file_alignment);
     // Memory is always allocated in sequence
     // TODO: investigate if we can allocate .text last; this way it would never need to grow in memory!
     const vaddr = blk: {
-        if (index == 0) break :blk self.page_size;
-        const prev_header = self.sections.items(.header)[index - 1];
-        break :blk mem.alignForward(u32, prev_header.virtual_address + prev_header.virtual_size, self.page_size);
+        if (index == 0) break :blk coff.page_size;
+        const prev_header = coff.sections.items(.header)[index - 1];
+        break :blk mem.alignForward(u32, prev_header.virtual_address + prev_header.virtual_size, coff.page_size);
     };
     // We commit more memory than needed upfront so that we don't have to reallocate too soon.
-    const memsz = mem.alignForward(u32, size, self.page_size) * 100;
+    const memsz = mem.alignForward(u32, size, coff.page_size) * 100;
     log.debug("found {s} free space 0x{x} to 0x{x} (0x{x} - 0x{x})", .{
         name,
         off,
@@ -509,7 +506,7 @@ fn allocateSection(self: *Coff, name: []const u8, size: u32, flags: coff.Section
         vaddr,
         vaddr + size,
     });
-    var header = coff.SectionHeader{
+    var header = coff_util.SectionHeader{
         .name = undefined,
         .virtual_size = memsz,
         .virtual_address = vaddr,
@@ -521,32 +518,32 @@ fn allocateSection(self: *Coff, name: []const u8, size: u32, flags: coff.Section
         .number_of_linenumbers = 0,
         .flags = flags,
     };
-    const gpa = self.base.comp.gpa;
-    try self.setSectionName(&header, name);
-    try self.sections.append(gpa, .{ .header = header });
+    const gpa = coff.base.comp.gpa;
+    try coff.setSectionName(&header, name);
+    try coff.sections.append(gpa, .{ .header = header });
     return index;
 }
 
-fn growSection(self: *Coff, sect_id: u32, needed_size: u32) !void {
-    const header = &self.sections.items(.header)[sect_id];
-    const maybe_last_atom_index = self.sections.items(.last_atom_index)[sect_id];
-    const sect_capacity = self.allocatedSize(header.pointer_to_raw_data);
+fn growSection(coff: *Coff, sect_id: u32, needed_size: u32) !void {
+    const header = &coff.sections.items(.header)[sect_id];
+    const maybe_last_atom_index = coff.sections.items(.last_atom_index)[sect_id];
+    const sect_capacity = coff.allocatedSize(header.pointer_to_raw_data);
 
     if (needed_size > sect_capacity) {
-        const new_offset = self.findFreeSpace(needed_size, default_file_alignment);
+        const new_offset = coff.findFreeSpace(needed_size, default_file_alignment);
         const current_size = if (maybe_last_atom_index) |last_atom_index| blk: {
-            const last_atom = self.getAtom(last_atom_index);
-            const sym = last_atom.getSymbol(self);
+            const last_atom = coff.getAtom(last_atom_index);
+            const sym = last_atom.getSymbol(coff);
             break :blk (sym.value + last_atom.size) - header.virtual_address;
         } else 0;
         log.debug("moving {s} from 0x{x} to 0x{x}", .{
-            self.getSectionName(header),
+            coff.getSectionName(header),
             header.pointer_to_raw_data,
             new_offset,
         });
-        const amt = try self.base.file.?.copyRangeAll(
+        const amt = try coff.base.file.?.copyRangeAll(
             header.pointer_to_raw_data,
-            self.base.file.?,
+            coff.base.file.?,
             new_offset,
             current_size,
         );
@@ -554,35 +551,35 @@ fn growSection(self: *Coff, sect_id: u32, needed_size: u32) !void {
         header.pointer_to_raw_data = new_offset;
     }
 
-    const sect_vm_capacity = self.allocatedVirtualSize(header.virtual_address);
+    const sect_vm_capacity = coff.allocatedVirtualSize(header.virtual_address);
     if (needed_size > sect_vm_capacity) {
-        self.markRelocsDirtyByAddress(header.virtual_address + header.virtual_size);
-        try self.growSectionVirtualMemory(sect_id, needed_size);
+        coff.markRelocsDirtyByAddress(header.virtual_address + header.virtual_size);
+        try coff.growSectionVirtualMemory(sect_id, needed_size);
     }
 
     header.virtual_size = @max(header.virtual_size, needed_size);
     header.size_of_raw_data = needed_size;
 }
 
-fn growSectionVirtualMemory(self: *Coff, sect_id: u32, needed_size: u32) !void {
-    const header = &self.sections.items(.header)[sect_id];
+fn growSectionVirtualMemory(coff: *Coff, sect_id: u32, needed_size: u32) !void {
+    const header = &coff.sections.items(.header)[sect_id];
     const increased_size = padToIdeal(needed_size);
-    const old_aligned_end = header.virtual_address + mem.alignForward(u32, header.virtual_size, self.page_size);
-    const new_aligned_end = header.virtual_address + mem.alignForward(u32, increased_size, self.page_size);
+    const old_aligned_end = header.virtual_address + mem.alignForward(u32, header.virtual_size, coff.page_size);
+    const new_aligned_end = header.virtual_address + mem.alignForward(u32, increased_size, coff.page_size);
     const diff = new_aligned_end - old_aligned_end;
-    log.debug("growing {s} in virtual memory by {x}", .{ self.getSectionName(header), diff });
+    log.debug("growing {s} in virtual memory by {x}", .{ coff.getSectionName(header), diff });
 
-    // TODO: enforce order by increasing VM addresses in self.sections container.
+    // TODO: enforce order by increasing VM addresses in coff.sections container.
     // This is required by the loader anyhow as far as I can tell.
-    for (self.sections.items(.header)[sect_id + 1 ..], 0..) |*next_header, next_sect_id| {
-        const maybe_last_atom_index = self.sections.items(.last_atom_index)[sect_id + 1 + next_sect_id];
+    for (coff.sections.items(.header)[sect_id + 1 ..], 0..) |*next_header, next_sect_id| {
+        const maybe_last_atom_index = coff.sections.items(.last_atom_index)[sect_id + 1 + next_sect_id];
         next_header.virtual_address += diff;
 
         if (maybe_last_atom_index) |last_atom_index| {
             var atom_index = last_atom_index;
             while (true) {
-                const atom = self.getAtom(atom_index);
-                const sym = atom.getSymbolPtr(self);
+                const atom = coff.getAtom(atom_index);
+                const sym = atom.getSymbolPtr(coff);
                 sym.value += diff;
 
                 if (atom.prev_index) |prev_index| {
@@ -595,15 +592,15 @@ fn growSectionVirtualMemory(self: *Coff, sect_id: u32, needed_size: u32) !void {
     header.virtual_size = increased_size;
 }
 
-fn allocateAtom(self: *Coff, atom_index: Atom.Index, new_atom_size: u32, alignment: u32) !u32 {
+fn allocateAtom(coff: *Coff, atom_index: Atom.Index, new_atom_size: u32, alignment: u32) !u32 {
     const tracy = trace(@src());
     defer tracy.end();
 
-    const atom = self.getAtom(atom_index);
-    const sect_id = @intFromEnum(atom.getSymbol(self).section_number) - 1;
-    const header = &self.sections.items(.header)[sect_id];
-    const free_list = &self.sections.items(.free_list)[sect_id];
-    const maybe_last_atom_index = &self.sections.items(.last_atom_index)[sect_id];
+    const atom = coff.getAtom(atom_index);
+    const sect_id = @intFromEnum(atom.getSymbol(coff).section_number) - 1;
+    const header = &coff.sections.items(.header)[sect_id];
+    const free_list = &coff.sections.items(.free_list)[sect_id];
+    const maybe_last_atom_index = &coff.sections.items(.last_atom_index)[sect_id];
     const new_atom_ideal_capacity = if (header.isCode()) padToIdeal(new_atom_size) else new_atom_size;
 
     // We use these to indicate our intention to update metadata, placing the new atom,
@@ -620,11 +617,11 @@ fn allocateAtom(self: *Coff, atom_index: Atom.Index, new_atom_size: u32, alignme
         var i: usize = 0;
         while (i < free_list.items.len) {
             const big_atom_index = free_list.items[i];
-            const big_atom = self.getAtom(big_atom_index);
+            const big_atom = coff.getAtom(big_atom_index);
             // We now have a pointer to a live atom that has too much capacity.
             // Is it enough that we could fit this new atom?
-            const sym = big_atom.getSymbol(self);
-            const capacity = big_atom.capacity(self);
+            const sym = big_atom.getSymbol(coff);
+            const capacity = big_atom.capacity(coff);
             const ideal_capacity = if (header.isCode()) padToIdeal(capacity) else capacity;
             const ideal_capacity_end_vaddr = math.add(u32, sym.value, ideal_capacity) catch ideal_capacity;
             const capacity_end_vaddr = sym.value + capacity;
@@ -634,7 +631,7 @@ fn allocateAtom(self: *Coff, atom_index: Atom.Index, new_atom_size: u32, alignme
                 // Additional bookkeeping here to notice if this free list node
                 // should be deleted because the atom that it points to has grown to take up
                 // more of the extra capacity.
-                if (!big_atom.freeListEligible(self)) {
+                if (!big_atom.freeListEligible(coff)) {
                     _ = free_list.swapRemove(i);
                 } else {
                     i += 1;
@@ -654,8 +651,8 @@ fn allocateAtom(self: *Coff, atom_index: Atom.Index, new_atom_size: u32, alignme
             }
             break :blk new_start_vaddr;
         } else if (maybe_last_atom_index.*) |last_index| {
-            const last = self.getAtom(last_index);
-            const last_symbol = last.getSymbol(self);
+            const last = coff.getAtom(last_index);
+            const last_symbol = last.getSymbol(coff);
             const ideal_capacity = if (header.isCode()) padToIdeal(last.size) else last.size;
             const ideal_capacity_end_vaddr = last_symbol.value + ideal_capacity;
             const new_start_vaddr = mem.alignForward(u32, ideal_capacity_end_vaddr, alignment);
@@ -667,33 +664,33 @@ fn allocateAtom(self: *Coff, atom_index: Atom.Index, new_atom_size: u32, alignme
     };
 
     const expand_section = if (atom_placement) |placement_index|
-        self.getAtom(placement_index).next_index == null
+        coff.getAtom(placement_index).next_index == null
     else
         true;
     if (expand_section) {
         const needed_size: u32 = (vaddr + new_atom_size) - header.virtual_address;
-        try self.growSection(sect_id, needed_size);
+        try coff.growSection(sect_id, needed_size);
         maybe_last_atom_index.* = atom_index;
     }
-    self.getAtomPtr(atom_index).size = new_atom_size;
+    coff.getAtomPtr(atom_index).size = new_atom_size;
 
     if (atom.prev_index) |prev_index| {
-        const prev = self.getAtomPtr(prev_index);
+        const prev = coff.getAtomPtr(prev_index);
         prev.next_index = atom.next_index;
     }
     if (atom.next_index) |next_index| {
-        const next = self.getAtomPtr(next_index);
+        const next = coff.getAtomPtr(next_index);
         next.prev_index = atom.prev_index;
     }
 
     if (atom_placement) |big_atom_index| {
-        const big_atom = self.getAtomPtr(big_atom_index);
-        const atom_ptr = self.getAtomPtr(atom_index);
+        const big_atom = coff.getAtomPtr(big_atom_index);
+        const atom_ptr = coff.getAtomPtr(atom_index);
         atom_ptr.prev_index = big_atom_index;
         atom_ptr.next_index = big_atom.next_index;
         big_atom.next_index = atom_index;
     } else {
-        const atom_ptr = self.getAtomPtr(atom_index);
+        const atom_ptr = coff.getAtomPtr(atom_index);
         atom_ptr.prev_index = null;
         atom_ptr.next_index = null;
     }
@@ -704,23 +701,23 @@ fn allocateAtom(self: *Coff, atom_index: Atom.Index, new_atom_size: u32, alignme
     return vaddr;
 }
 
-pub fn allocateSymbol(self: *Coff) !u32 {
-    const gpa = self.base.comp.gpa;
-    try self.locals.ensureUnusedCapacity(gpa, 1);
+pub fn allocateSymbol(coff: *Coff) !u32 {
+    const gpa = coff.base.comp.gpa;
+    try coff.locals.ensureUnusedCapacity(gpa, 1);
 
     const index = blk: {
-        if (self.locals_free_list.popOrNull()) |index| {
+        if (coff.locals_free_list.popOrNull()) |index| {
             log.debug("  (reusing symbol index {d})", .{index});
             break :blk index;
         } else {
-            log.debug("  (allocating symbol index {d})", .{self.locals.items.len});
-            const index = @as(u32, @intCast(self.locals.items.len));
-            _ = self.locals.addOneAssumeCapacity();
+            log.debug("  (allocating symbol index {d})", .{coff.locals.items.len});
+            const index = @as(u32, @intCast(coff.locals.items.len));
+            _ = coff.locals.addOneAssumeCapacity();
             break :blk index;
         }
     };
 
-    self.locals.items[index] = .{
+    coff.locals.items[index] = .{
         .name = [_]u8{0} ** 8,
         .value = 0,
         .section_number = .UNDEFINED,
@@ -732,23 +729,23 @@ pub fn allocateSymbol(self: *Coff) !u32 {
     return index;
 }
 
-fn allocateGlobal(self: *Coff) !u32 {
-    const gpa = self.base.comp.gpa;
-    try self.globals.ensureUnusedCapacity(gpa, 1);
+fn allocateGlobal(coff: *Coff) !u32 {
+    const gpa = coff.base.comp.gpa;
+    try coff.globals.ensureUnusedCapacity(gpa, 1);
 
     const index = blk: {
-        if (self.globals_free_list.popOrNull()) |index| {
+        if (coff.globals_free_list.popOrNull()) |index| {
             log.debug("  (reusing global index {d})", .{index});
             break :blk index;
         } else {
-            log.debug("  (allocating global index {d})", .{self.globals.items.len});
-            const index = @as(u32, @intCast(self.globals.items.len));
-            _ = self.globals.addOneAssumeCapacity();
+            log.debug("  (allocating global index {d})", .{coff.globals.items.len});
+            const index = @as(u32, @intCast(coff.globals.items.len));
+            _ = coff.globals.addOneAssumeCapacity();
             break :blk index;
         }
     };
 
-    self.globals.items[index] = .{
+    coff.globals.items[index] = .{
         .sym_index = 0,
         .file = null,
     };
@@ -756,21 +753,21 @@ fn allocateGlobal(self: *Coff) !u32 {
     return index;
 }
 
-fn addGotEntry(self: *Coff, target: SymbolWithLoc) !void {
-    const gpa = self.base.comp.gpa;
-    if (self.got_table.lookup.contains(target)) return;
-    const got_index = try self.got_table.allocateEntry(gpa, target);
-    try self.writeOffsetTableEntry(got_index);
-    self.got_table_count_dirty = true;
-    self.markRelocsDirtyByTarget(target);
+fn addGotEntry(coff: *Coff, target: SymbolWithLoc) !void {
+    const gpa = coff.base.comp.gpa;
+    if (coff.got_table.lookup.contains(target)) return;
+    const got_index = try coff.got_table.allocateEntry(gpa, target);
+    try coff.writeOffsetTableEntry(got_index);
+    coff.got_table_count_dirty = true;
+    coff.markRelocsDirtyByTarget(target);
 }
 
-pub fn createAtom(self: *Coff) !Atom.Index {
-    const gpa = self.base.comp.gpa;
-    const atom_index = @as(Atom.Index, @intCast(self.atoms.items.len));
-    const atom = try self.atoms.addOne(gpa);
-    const sym_index = try self.allocateSymbol();
-    try self.atom_by_index_table.putNoClobber(gpa, sym_index, atom_index);
+pub fn createAtom(coff: *Coff) !Atom.Index {
+    const gpa = coff.base.comp.gpa;
+    const atom_index = @as(Atom.Index, @intCast(coff.atoms.items.len));
+    const atom = try coff.atoms.addOne(gpa);
+    const sym_index = try coff.allocateSymbol();
+    try coff.atom_by_index_table.putNoClobber(gpa, sym_index, atom_index);
     atom.* = .{
         .sym_index = sym_index,
         .file = null,
@@ -782,36 +779,36 @@ pub fn createAtom(self: *Coff) !Atom.Index {
     return atom_index;
 }
 
-fn growAtom(self: *Coff, atom_index: Atom.Index, new_atom_size: u32, alignment: u32) !u32 {
-    const atom = self.getAtom(atom_index);
-    const sym = atom.getSymbol(self);
+fn growAtom(coff: *Coff, atom_index: Atom.Index, new_atom_size: u32, alignment: u32) !u32 {
+    const atom = coff.getAtom(atom_index);
+    const sym = atom.getSymbol(coff);
     const align_ok = mem.alignBackward(u32, sym.value, alignment) == sym.value;
-    const need_realloc = !align_ok or new_atom_size > atom.capacity(self);
+    const need_realloc = !align_ok or new_atom_size > atom.capacity(coff);
     if (!need_realloc) return sym.value;
-    return self.allocateAtom(atom_index, new_atom_size, alignment);
+    return coff.allocateAtom(atom_index, new_atom_size, alignment);
 }
 
-fn shrinkAtom(self: *Coff, atom_index: Atom.Index, new_block_size: u32) void {
-    _ = self;
+fn shrinkAtom(coff: *Coff, atom_index: Atom.Index, new_block_size: u32) void {
+    _ = coff;
     _ = atom_index;
     _ = new_block_size;
     // TODO check the new capacity, and if it crosses the size threshold into a big enough
     // capacity, insert a free list node for it.
 }
 
-fn writeAtom(self: *Coff, atom_index: Atom.Index, code: []u8) !void {
-    const atom = self.getAtom(atom_index);
-    const sym = atom.getSymbol(self);
-    const section = self.sections.get(@intFromEnum(sym.section_number) - 1);
+fn writeAtom(coff: *Coff, atom_index: Atom.Index, code: []u8) !void {
+    const atom = coff.getAtom(atom_index);
+    const sym = atom.getSymbol(coff);
+    const section = coff.sections.get(@intFromEnum(sym.section_number) - 1);
     const file_offset = section.header.pointer_to_raw_data + sym.value - section.header.virtual_address;
 
     log.debug("writing atom for symbol {s} at file offset 0x{x} to 0x{x}", .{
-        atom.getName(self),
+        atom.getName(coff),
         file_offset,
         file_offset + code.len,
     });
 
-    const gpa = self.base.comp.gpa;
+    const gpa = coff.base.comp.gpa;
 
     // Gather relocs which can be resolved.
     // We need to do this as we will be applying different slide values depending
@@ -821,22 +818,22 @@ fn writeAtom(self: *Coff, atom_index: Atom.Index, code: []u8) !void {
     var relocs = std.ArrayList(*Relocation).init(gpa);
     defer relocs.deinit();
 
-    if (self.relocs.getPtr(atom_index)) |rels| {
+    if (coff.relocs.getPtr(atom_index)) |rels| {
         try relocs.ensureTotalCapacityPrecise(rels.items.len);
         for (rels.items) |*reloc| {
-            if (reloc.isResolvable(self) and reloc.dirty) {
+            if (reloc.isResolvable(coff) and reloc.dirty) {
                 relocs.appendAssumeCapacity(reloc);
             }
         }
     }
 
     if (is_hot_update_compatible) {
-        if (self.base.child_pid) |handle| {
-            const slide = @intFromPtr(self.hot_state.loaded_base_address.?);
+        if (coff.base.child_pid) |handle| {
+            const slide = @intFromPtr(coff.hot_state.loaded_base_address.?);
 
             const mem_code = try gpa.dupe(u8, code);
             defer gpa.free(mem_code);
-            self.resolveRelocs(atom_index, relocs.items, mem_code, slide);
+            coff.resolveRelocs(atom_index, relocs.items, mem_code, slide);
 
             const vaddr = sym.value + slide;
             const pvaddr = @as(*anyopaque, @ptrFromInt(vaddr));
@@ -859,8 +856,8 @@ fn writeAtom(self: *Coff, atom_index: Atom.Index, code: []u8) !void {
         }
     }
 
-    self.resolveRelocs(atom_index, relocs.items, code, self.image_base);
-    try self.base.file.?.pwriteAll(code, file_offset);
+    coff.resolveRelocs(atom_index, relocs.items, code, coff.image_base);
+    try coff.base.file.?.pwriteAll(code, file_offset);
 
     // Now we can mark the relocs as resolved.
     while (relocs.popOrNull()) |reloc| {
@@ -889,46 +886,46 @@ fn writeMem(handle: std.process.Child.Id, pvaddr: std.os.windows.LPVOID, code: [
     if (amt != code.len) return error.InputOutput;
 }
 
-fn writeOffsetTableEntry(self: *Coff, index: usize) !void {
-    const sect_id = self.got_section_index.?;
+fn writeOffsetTableEntry(coff: *Coff, index: usize) !void {
+    const sect_id = coff.got_section_index.?;
 
-    if (self.got_table_count_dirty) {
-        const needed_size = @as(u32, @intCast(self.got_table.entries.items.len * self.ptr_width.size()));
-        try self.growSection(sect_id, needed_size);
-        self.got_table_count_dirty = false;
+    if (coff.got_table_count_dirty) {
+        const needed_size = @as(u32, @intCast(coff.got_table.entries.items.len * coff.ptr_width.size()));
+        try coff.growSection(sect_id, needed_size);
+        coff.got_table_count_dirty = false;
     }
 
-    const header = &self.sections.items(.header)[sect_id];
-    const entry = self.got_table.entries.items[index];
-    const entry_value = self.getSymbol(entry).value;
-    const entry_offset = index * self.ptr_width.size();
+    const header = &coff.sections.items(.header)[sect_id];
+    const entry = coff.got_table.entries.items[index];
+    const entry_value = coff.getSymbol(entry).value;
+    const entry_offset = index * coff.ptr_width.size();
     const file_offset = header.pointer_to_raw_data + entry_offset;
     const vmaddr = header.virtual_address + entry_offset;
 
-    log.debug("writing GOT entry {d}: @{x} => {x}", .{ index, vmaddr, entry_value + self.image_base });
+    log.debug("writing GOT entry {d}: @{x} => {x}", .{ index, vmaddr, entry_value + coff.image_base });
 
-    switch (self.ptr_width) {
+    switch (coff.ptr_width) {
         .p32 => {
             var buf: [4]u8 = undefined;
-            mem.writeInt(u32, &buf, @as(u32, @intCast(entry_value + self.image_base)), .little);
-            try self.base.file.?.pwriteAll(&buf, file_offset);
+            mem.writeInt(u32, &buf, @as(u32, @intCast(entry_value + coff.image_base)), .little);
+            try coff.base.file.?.pwriteAll(&buf, file_offset);
         },
         .p64 => {
             var buf: [8]u8 = undefined;
-            mem.writeInt(u64, &buf, entry_value + self.image_base, .little);
-            try self.base.file.?.pwriteAll(&buf, file_offset);
+            mem.writeInt(u64, &buf, entry_value + coff.image_base, .little);
+            try coff.base.file.?.pwriteAll(&buf, file_offset);
         },
     }
 
     if (is_hot_update_compatible) {
-        if (self.base.child_pid) |handle| {
-            const gpa = self.base.comp.gpa;
-            const slide = @intFromPtr(self.hot_state.loaded_base_address.?);
+        if (coff.base.child_pid) |handle| {
+            const gpa = coff.base.comp.gpa;
+            const slide = @intFromPtr(coff.hot_state.loaded_base_address.?);
             const actual_vmaddr = vmaddr + slide;
             const pvaddr = @as(*anyopaque, @ptrFromInt(actual_vmaddr));
             log.debug("writing GOT entry to memory at address {x}", .{actual_vmaddr});
             if (build_options.enable_logging) {
-                switch (self.ptr_width) {
+                switch (coff.ptr_width) {
                     .p32 => {
                         var buf: [4]u8 = undefined;
                         try debugMem(gpa, handle, pvaddr, &buf);
@@ -940,7 +937,7 @@ fn writeOffsetTableEntry(self: *Coff, index: usize) !void {
                 }
             }
 
-            switch (self.ptr_width) {
+            switch (coff.ptr_width) {
                 .p32 => {
                     var buf: [4]u8 = undefined;
                     mem.writeInt(u32, &buf, @as(u32, @intCast(entry_value + slide)), .little);
@@ -960,9 +957,9 @@ fn writeOffsetTableEntry(self: *Coff, index: usize) !void {
     }
 }
 
-fn markRelocsDirtyByTarget(self: *Coff, target: SymbolWithLoc) void {
+fn markRelocsDirtyByTarget(coff: *Coff, target: SymbolWithLoc) void {
     // TODO: reverse-lookup might come in handy here
-    for (self.relocs.values()) |*relocs| {
+    for (coff.relocs.values()) |*relocs| {
         for (relocs.items) |*reloc| {
             if (!reloc.target.eql(target)) continue;
             reloc.dirty = true;
@@ -970,71 +967,71 @@ fn markRelocsDirtyByTarget(self: *Coff, target: SymbolWithLoc) void {
     }
 }
 
-fn markRelocsDirtyByAddress(self: *Coff, addr: u32) void {
+fn markRelocsDirtyByAddress(coff: *Coff, addr: u32) void {
     const got_moved = blk: {
-        const sect_id = self.got_section_index orelse break :blk false;
-        break :blk self.sections.items(.header)[sect_id].virtual_address >= addr;
+        const sect_id = coff.got_section_index orelse break :blk false;
+        break :blk coff.sections.items(.header)[sect_id].virtual_address >= addr;
     };
 
     // TODO: dirty relocations targeting import table if that got moved in memory
 
-    for (self.relocs.values()) |*relocs| {
+    for (coff.relocs.values()) |*relocs| {
         for (relocs.items) |*reloc| {
             if (reloc.isGotIndirection()) {
                 reloc.dirty = reloc.dirty or got_moved;
             } else {
-                const target_vaddr = reloc.getTargetAddress(self) orelse continue;
+                const target_vaddr = reloc.getTargetAddress(coff) orelse continue;
                 if (target_vaddr >= addr) reloc.dirty = true;
             }
         }
     }
 
     // TODO: dirty only really affected GOT cells
-    for (self.got_table.entries.items) |entry| {
-        const target_addr = self.getSymbol(entry).value;
+    for (coff.got_table.entries.items) |entry| {
+        const target_addr = coff.getSymbol(entry).value;
         if (target_addr >= addr) {
-            self.got_table_contents_dirty = true;
+            coff.got_table_contents_dirty = true;
             break;
         }
     }
 }
 
-fn resolveRelocs(self: *Coff, atom_index: Atom.Index, relocs: []*const Relocation, code: []u8, image_base: u64) void {
-    log.debug("relocating '{s}'", .{self.getAtom(atom_index).getName(self)});
+fn resolveRelocs(coff: *Coff, atom_index: Atom.Index, relocs: []*const Relocation, code: []u8, image_base: u64) void {
+    log.debug("relocating '{s}'", .{coff.getAtom(atom_index).getName(coff)});
     for (relocs) |reloc| {
-        reloc.resolve(atom_index, code, image_base, self);
+        reloc.resolve(atom_index, code, image_base, coff);
     }
 }
 
-pub fn ptraceAttach(self: *Coff, handle: std.process.Child.Id) !void {
+pub fn ptraceAttach(coff: *Coff, handle: std.process.Child.Id) !void {
     if (!is_hot_update_compatible) return;
 
     log.debug("attaching to process with handle {*}", .{handle});
-    self.hot_state.loaded_base_address = std.os.windows.ProcessBaseAddress(handle) catch |err| {
+    coff.hot_state.loaded_base_address = std.os.windows.ProcessBaseAddress(handle) catch |err| {
         log.warn("failed to get base address for the process with error: {s}", .{@errorName(err)});
         return;
     };
 }
 
-pub fn ptraceDetach(self: *Coff, handle: std.process.Child.Id) void {
+pub fn ptraceDetach(coff: *Coff, handle: std.process.Child.Id) void {
     if (!is_hot_update_compatible) return;
 
     log.debug("detaching from process with handle {*}", .{handle});
-    self.hot_state.loaded_base_address = null;
+    coff.hot_state.loaded_base_address = null;
 }
 
-fn freeAtom(self: *Coff, atom_index: Atom.Index) void {
+fn freeAtom(coff: *Coff, atom_index: Atom.Index) void {
     log.debug("freeAtom {d}", .{atom_index});
 
-    const gpa = self.base.comp.gpa;
+    const gpa = coff.base.comp.gpa;
 
     // Remove any relocs and base relocs associated with this Atom
-    Atom.freeRelocations(self, atom_index);
+    coff.freeRelocations(atom_index);
 
-    const atom = self.getAtom(atom_index);
-    const sym = atom.getSymbol(self);
+    const atom = coff.getAtom(atom_index);
+    const sym = atom.getSymbol(coff);
     const sect_id = @intFromEnum(sym.section_number) - 1;
-    const free_list = &self.sections.items(.free_list)[sect_id];
+    const free_list = &coff.sections.items(.free_list)[sect_id];
     var already_have_free_list_node = false;
     {
         var i: usize = 0;
@@ -1051,7 +1048,7 @@ fn freeAtom(self: *Coff, atom_index: Atom.Index) void {
         }
     }
 
-    const maybe_last_atom_index = &self.sections.items(.last_atom_index)[sect_id];
+    const maybe_last_atom_index = &coff.sections.items(.last_atom_index)[sect_id];
     if (maybe_last_atom_index.*) |last_atom_index| {
         if (last_atom_index == atom_index) {
             if (atom.prev_index) |prev_index| {
@@ -1064,42 +1061,42 @@ fn freeAtom(self: *Coff, atom_index: Atom.Index) void {
     }
 
     if (atom.prev_index) |prev_index| {
-        const prev = self.getAtomPtr(prev_index);
+        const prev = coff.getAtomPtr(prev_index);
         prev.next_index = atom.next_index;
 
-        if (!already_have_free_list_node and prev.*.freeListEligible(self)) {
+        if (!already_have_free_list_node and prev.*.freeListEligible(coff)) {
             // The free list is heuristics, it doesn't have to be perfect, so we can
             // ignore the OOM here.
             free_list.append(gpa, prev_index) catch {};
         }
     } else {
-        self.getAtomPtr(atom_index).prev_index = null;
+        coff.getAtomPtr(atom_index).prev_index = null;
     }
 
     if (atom.next_index) |next_index| {
-        self.getAtomPtr(next_index).prev_index = atom.prev_index;
+        coff.getAtomPtr(next_index).prev_index = atom.prev_index;
     } else {
-        self.getAtomPtr(atom_index).next_index = null;
+        coff.getAtomPtr(atom_index).next_index = null;
     }
 
     // Appending to free lists is allowed to fail because the free lists are heuristics based anyway.
     const sym_index = atom.getSymbolIndex().?;
-    self.locals_free_list.append(gpa, sym_index) catch {};
+    coff.locals_free_list.append(gpa, sym_index) catch {};
 
     // Try freeing GOT atom if this decl had one
-    self.got_table.freeEntry(gpa, .{ .sym_index = sym_index });
+    coff.got_table.freeEntry(gpa, .{ .sym_index = sym_index });
 
-    self.locals.items[sym_index].section_number = .UNDEFINED;
-    _ = self.atom_by_index_table.remove(sym_index);
+    coff.locals.items[sym_index].section_number = .UNDEFINED;
+    _ = coff.atom_by_index_table.remove(sym_index);
     log.debug("  adding local symbol index {d} to free list", .{sym_index});
-    self.getAtomPtr(atom_index).sym_index = 0;
+    coff.getAtomPtr(atom_index).sym_index = 0;
 }
 
-pub fn updateFunc(self: *Coff, pt: Zcu.PerThread, func_index: InternPool.Index, air: Air, liveness: Liveness) !void {
+pub fn updateFunc(coff: *Coff, pt: Zcu.PerThread, func_index: InternPool.Index, air: Air, liveness: Liveness) !void {
     if (build_options.skip_non_native and builtin.object_format != .coff) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (self.llvm_object) |llvm_object| {
+    if (coff.llvm_object) |llvm_object| {
         return llvm_object.updateFunc(pt, func_index, air, liveness);
     }
     const tracy = trace(@src());
@@ -1109,14 +1106,14 @@ pub fn updateFunc(self: *Coff, pt: Zcu.PerThread, func_index: InternPool.Index,
     const gpa = zcu.gpa;
     const func = zcu.funcInfo(func_index);
 
-    const atom_index = try self.getOrCreateAtomForNav(func.owner_nav);
-    Atom.freeRelocations(self, atom_index);
+    const atom_index = try coff.getOrCreateAtomForNav(func.owner_nav);
+    coff.freeRelocations(atom_index);
 
     var code_buffer = std.ArrayList(u8).init(gpa);
     defer code_buffer.deinit();
 
     const res = try codegen.generateFunction(
-        &self.base,
+        &coff.base,
         pt,
         zcu.navSrcLoc(func.owner_nav),
         func_index,
@@ -1133,7 +1130,7 @@ pub fn updateFunc(self: *Coff, pt: Zcu.PerThread, func_index: InternPool.Index,
         },
     };
 
-    try self.updateNavCode(pt, func.owner_nav, code, .FUNCTION);
+    try coff.updateNavCode(pt, func.owner_nav, code, .FUNCTION);
 
     // Exports will be updated by `Zcu.processExports` after the update.
 }
@@ -1144,7 +1141,7 @@ const LowerConstResult = union(enum) {
 };
 
 fn lowerConst(
-    self: *Coff,
+    coff: *Coff,
     pt: Zcu.PerThread,
     name: []const u8,
     val: Value,
@@ -1152,50 +1149,50 @@ fn lowerConst(
     sect_id: u16,
     src_loc: Zcu.LazySrcLoc,
 ) !LowerConstResult {
-    const gpa = self.base.comp.gpa;
+    const gpa = coff.base.comp.gpa;
 
     var code_buffer = std.ArrayList(u8).init(gpa);
     defer code_buffer.deinit();
 
-    const atom_index = try self.createAtom();
-    const sym = self.getAtom(atom_index).getSymbolPtr(self);
-    try self.setSymbolName(sym, name);
-    sym.section_number = @as(coff.SectionNumber, @enumFromInt(sect_id + 1));
+    const atom_index = try coff.createAtom();
+    const sym = coff.getAtom(atom_index).getSymbolPtr(coff);
+    try coff.setSymbolName(sym, name);
+    sym.section_number = @as(coff_util.SectionNumber, @enumFromInt(sect_id + 1));
 
-    const res = try codegen.generateSymbol(&self.base, pt, src_loc, val, &code_buffer, .{
-        .atom_index = self.getAtom(atom_index).getSymbolIndex().?,
+    const res = try codegen.generateSymbol(&coff.base, pt, src_loc, val, &code_buffer, .{
+        .atom_index = coff.getAtom(atom_index).getSymbolIndex().?,
     });
     const code = switch (res) {
         .ok => code_buffer.items,
         .fail => |em| return .{ .fail = em },
     };
 
-    const atom = self.getAtomPtr(atom_index);
+    const atom = coff.getAtomPtr(atom_index);
     atom.size = @as(u32, @intCast(code.len));
-    atom.getSymbolPtr(self).value = try self.allocateAtom(
+    atom.getSymbolPtr(coff).value = try coff.allocateAtom(
         atom_index,
         atom.size,
         @intCast(required_alignment.toByteUnits().?),
     );
-    errdefer self.freeAtom(atom_index);
+    errdefer coff.freeAtom(atom_index);
 
-    log.debug("allocated atom for {s} at 0x{x}", .{ name, atom.getSymbol(self).value });
+    log.debug("allocated atom for {s} at 0x{x}", .{ name, atom.getSymbol(coff).value });
     log.debug("  (required alignment 0x{x})", .{required_alignment});
 
-    try self.writeAtom(atom_index, code);
+    try coff.writeAtom(atom_index, code);
 
     return .{ .ok = atom_index };
 }
 
 pub fn updateNav(
-    self: *Coff,
+    coff: *Coff,
     pt: Zcu.PerThread,
     nav_index: InternPool.Nav.Index,
 ) link.File.UpdateNavError!void {
     if (build_options.skip_non_native and builtin.object_format != .coff) {
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
-    if (self.llvm_object) |llvm_object| return llvm_object.updateNav(pt, nav_index);
+    if (coff.llvm_object) |llvm_object| return llvm_object.updateNav(pt, nav_index);
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -1213,23 +1210,23 @@ pub fn updateNav(
             // TODO make this part of getGlobalSymbol
             const name = nav.name.toSlice(ip);
             const lib_name = @"extern".lib_name.toSlice(ip);
-            const global_index = try self.getGlobalSymbol(name, lib_name);
-            try self.need_got_table.put(gpa, global_index, {});
+            const global_index = try coff.getGlobalSymbol(name, lib_name);
+            try coff.need_got_table.put(gpa, global_index, {});
             return;
         },
         else => nav_val,
     };
 
     if (nav_init.typeOf(zcu).hasRuntimeBits(zcu)) {
-        const atom_index = try self.getOrCreateAtomForNav(nav_index);
-        Atom.freeRelocations(self, atom_index);
-        const atom = self.getAtom(atom_index);
+        const atom_index = try coff.getOrCreateAtomForNav(nav_index);
+        coff.freeRelocations(atom_index);
+        const atom = coff.getAtom(atom_index);
 
         var code_buffer = std.ArrayList(u8).init(gpa);
         defer code_buffer.deinit();
 
         const res = try codegen.generateSymbol(
-            &self.base,
+            &coff.base,
             pt,
             zcu.navSrcLoc(nav_index),
             nav_init,
@@ -1244,14 +1241,14 @@ pub fn updateNav(
             },
         };
 
-        try self.updateNavCode(pt, nav_index, code, .NULL);
+        try coff.updateNavCode(pt, nav_index, code, .NULL);
     }
 
     // Exports will be updated by `Zcu.processExports` after the update.
 }
 
 fn updateLazySymbolAtom(
-    self: *Coff,
+    coff: *Coff,
     pt: Zcu.PerThread,
     sym: link.File.LazySymbol,
     atom_index: Atom.Index,
@@ -1264,18 +1261,18 @@ fn updateLazySymbolAtom(
     var code_buffer = std.ArrayList(u8).init(gpa);
     defer code_buffer.deinit();
 
-    const name = try std.fmt.allocPrint(gpa, "__lazy_{s}_{}", .{
+    const name = try allocPrint(gpa, "__lazy_{s}_{}", .{
         @tagName(sym.kind),
         Type.fromInterned(sym.ty).fmt(pt),
     });
     defer gpa.free(name);
 
-    const atom = self.getAtomPtr(atom_index);
+    const atom = coff.getAtomPtr(atom_index);
     const local_sym_index = atom.getSymbolIndex().?;
 
     const src = Type.fromInterned(sym.ty).srcLocOrNull(zcu) orelse Zcu.LazySrcLoc.unneeded;
     const res = try codegen.generateLazySymbol(
-        &self.base,
+        &coff.base,
         pt,
         src,
         sym,
@@ -1293,13 +1290,13 @@ fn updateLazySymbolAtom(
     };
 
     const code_len: u32 = @intCast(code.len);
-    const symbol = atom.getSymbolPtr(self);
-    try self.setSymbolName(symbol, name);
+    const symbol = atom.getSymbolPtr(coff);
+    try coff.setSymbolName(symbol, name);
     symbol.section_number = @enumFromInt(section_index + 1);
     symbol.type = .{ .complex_type = .NULL, .base_type = .NULL };
 
-    const vaddr = try self.allocateAtom(atom_index, code_len, @intCast(required_alignment.toByteUnits() orelse 0));
-    errdefer self.freeAtom(atom_index);
+    const vaddr = try coff.allocateAtom(atom_index, code_len, @intCast(required_alignment.toByteUnits() orelse 0));
+    errdefer coff.freeAtom(atom_index);
 
     log.debug("allocated atom for {s} at 0x{x}", .{ name, vaddr });
     log.debug("  (required alignment 0x{x})", .{required_alignment});
@@ -1307,52 +1304,52 @@ fn updateLazySymbolAtom(
     atom.size = code_len;
     symbol.value = vaddr;
 
-    try self.addGotEntry(.{ .sym_index = local_sym_index });
-    try self.writeAtom(atom_index, code);
+    try coff.addGotEntry(.{ .sym_index = local_sym_index });
+    try coff.writeAtom(atom_index, code);
 }
 
 pub fn getOrCreateAtomForLazySymbol(
-    self: *Coff,
+    coff: *Coff,
     pt: Zcu.PerThread,
     lazy_sym: link.File.LazySymbol,
 ) !Atom.Index {
-    const gop = try self.lazy_syms.getOrPut(pt.zcu.gpa, lazy_sym.ty);
-    errdefer _ = if (!gop.found_existing) self.lazy_syms.pop();
+    const gop = try coff.lazy_syms.getOrPut(pt.zcu.gpa, lazy_sym.ty);
+    errdefer _ = if (!gop.found_existing) coff.lazy_syms.pop();
     if (!gop.found_existing) gop.value_ptr.* = .{};
     const atom_ptr, const state_ptr = switch (lazy_sym.kind) {
         .code => .{ &gop.value_ptr.text_atom, &gop.value_ptr.text_state },
         .const_data => .{ &gop.value_ptr.rdata_atom, &gop.value_ptr.rdata_state },
     };
     switch (state_ptr.*) {
-        .unused => atom_ptr.* = try self.createAtom(),
+        .unused => atom_ptr.* = try coff.createAtom(),
         .pending_flush => return atom_ptr.*,
         .flushed => {},
     }
     state_ptr.* = .pending_flush;
     const atom = atom_ptr.*;
     // anyerror needs to be deferred until flushModule
-    if (lazy_sym.ty != .anyerror_type) try self.updateLazySymbolAtom(pt, lazy_sym, atom, switch (lazy_sym.kind) {
-        .code => self.text_section_index.?,
-        .const_data => self.rdata_section_index.?,
+    if (lazy_sym.ty != .anyerror_type) try coff.updateLazySymbolAtom(pt, lazy_sym, atom, switch (lazy_sym.kind) {
+        .code => coff.text_section_index.?,
+        .const_data => coff.rdata_section_index.?,
     });
     return atom;
 }
 
-pub fn getOrCreateAtomForNav(self: *Coff, nav_index: InternPool.Nav.Index) !Atom.Index {
-    const gpa = self.base.comp.gpa;
-    const gop = try self.navs.getOrPut(gpa, nav_index);
+pub fn getOrCreateAtomForNav(coff: *Coff, nav_index: InternPool.Nav.Index) !Atom.Index {
+    const gpa = coff.base.comp.gpa;
+    const gop = try coff.navs.getOrPut(gpa, nav_index);
     if (!gop.found_existing) {
         gop.value_ptr.* = .{
-            .atom = try self.createAtom(),
-            .section = self.getNavOutputSection(nav_index),
+            .atom = try coff.createAtom(),
+            .section = coff.getNavOutputSection(nav_index),
             .exports = .{},
         };
     }
     return gop.value_ptr.atom;
 }
 
-fn getNavOutputSection(self: *Coff, nav_index: InternPool.Nav.Index) u16 {
-    const zcu = self.base.comp.zcu.?;
+fn getNavOutputSection(coff: *Coff, nav_index: InternPool.Nav.Index) u16 {
+    const zcu = coff.base.comp.zcu.?;
     const ip = &zcu.intern_pool;
     const nav = ip.getNav(nav_index);
     const ty = Type.fromInterned(nav.typeOf(ip));
@@ -1361,17 +1358,17 @@ fn getNavOutputSection(self: *Coff, nav_index: InternPool.Nav.Index) u16 {
     const index: u16 = blk: {
         if (val.isUndefDeep(zcu)) {
             // TODO in release-fast and release-small, we should put undef in .bss
-            break :blk self.data_section_index.?;
+            break :blk coff.data_section_index.?;
         }
 
         switch (zig_ty) {
             // TODO: what if this is a function pointer?
-            .@"fn" => break :blk self.text_section_index.?,
+            .@"fn" => break :blk coff.text_section_index.?,
             else => {
                 if (val.getVariable(zcu)) |_| {
-                    break :blk self.data_section_index.?;
+                    break :blk coff.data_section_index.?;
                 }
-                break :blk self.rdata_section_index.?;
+                break :blk coff.rdata_section_index.?;
             },
         }
     };
@@ -1379,11 +1376,11 @@ fn getNavOutputSection(self: *Coff, nav_index: InternPool.Nav.Index) u16 {
 }
 
 fn updateNavCode(
-    self: *Coff,
+    coff: *Coff,
     pt: Zcu.PerThread,
     nav_index: InternPool.Nav.Index,
     code: []u8,
-    complex_type: coff.ComplexType,
+    complex_type: coff_util.ComplexType,
 ) !void {
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
@@ -1391,74 +1388,76 @@ fn updateNavCode(
 
     log.debug("updateNavCode {} 0x{x}", .{ nav.fqn.fmt(ip), nav_index });
 
-    const required_alignment = pt.navAlignment(nav_index).max(
-        target_util.minFunctionAlignment(zcu.navFileScope(nav_index).mod.resolved_target.result),
-    );
+    const target = zcu.navFileScope(nav_index).mod.resolved_target.result;
+    const required_alignment = switch (pt.navAlignment(nav_index)) {
+        .none => target_util.defaultFunctionAlignment(target),
+        else => |a| a.maxStrict(target_util.minFunctionAlignment(target)),
+    };
 
-    const nav_metadata = self.navs.get(nav_index).?;
+    const nav_metadata = coff.navs.get(nav_index).?;
     const atom_index = nav_metadata.atom;
-    const atom = self.getAtom(atom_index);
+    const atom = coff.getAtom(atom_index);
     const sym_index = atom.getSymbolIndex().?;
     const sect_index = nav_metadata.section;
     const code_len = @as(u32, @intCast(code.len));
 
     if (atom.size != 0) {
-        const sym = atom.getSymbolPtr(self);
-        try self.setSymbolName(sym, nav.fqn.toSlice(ip));
-        sym.section_number = @as(coff.SectionNumber, @enumFromInt(sect_index + 1));
+        const sym = atom.getSymbolPtr(coff);
+        try coff.setSymbolName(sym, nav.fqn.toSlice(ip));
+        sym.section_number = @as(coff_util.SectionNumber, @enumFromInt(sect_index + 1));
         sym.type = .{ .complex_type = complex_type, .base_type = .NULL };
 
-        const capacity = atom.capacity(self);
+        const capacity = atom.capacity(coff);
         const need_realloc = code.len > capacity or !required_alignment.check(sym.value);
         if (need_realloc) {
-            const vaddr = try self.growAtom(atom_index, code_len, @intCast(required_alignment.toByteUnits() orelse 0));
+            const vaddr = try coff.growAtom(atom_index, code_len, @intCast(required_alignment.toByteUnits() orelse 0));
             log.debug("growing {} from 0x{x} to 0x{x}", .{ nav.fqn.fmt(ip), sym.value, vaddr });
             log.debug("  (required alignment 0x{x}", .{required_alignment});
 
             if (vaddr != sym.value) {
                 sym.value = vaddr;
                 log.debug("  (updating GOT entry)", .{});
-                const got_entry_index = self.got_table.lookup.get(.{ .sym_index = sym_index }).?;
-                try self.writeOffsetTableEntry(got_entry_index);
-                self.markRelocsDirtyByTarget(.{ .sym_index = sym_index });
+                const got_entry_index = coff.got_table.lookup.get(.{ .sym_index = sym_index }).?;
+                try coff.writeOffsetTableEntry(got_entry_index);
+                coff.markRelocsDirtyByTarget(.{ .sym_index = sym_index });
             }
         } else if (code_len < atom.size) {
-            self.shrinkAtom(atom_index, code_len);
+            coff.shrinkAtom(atom_index, code_len);
         }
-        self.getAtomPtr(atom_index).size = code_len;
+        coff.getAtomPtr(atom_index).size = code_len;
     } else {
-        const sym = atom.getSymbolPtr(self);
-        try self.setSymbolName(sym, nav.fqn.toSlice(ip));
-        sym.section_number = @as(coff.SectionNumber, @enumFromInt(sect_index + 1));
+        const sym = atom.getSymbolPtr(coff);
+        try coff.setSymbolName(sym, nav.fqn.toSlice(ip));
+        sym.section_number = @as(coff_util.SectionNumber, @enumFromInt(sect_index + 1));
         sym.type = .{ .complex_type = complex_type, .base_type = .NULL };
 
-        const vaddr = try self.allocateAtom(atom_index, code_len, @intCast(required_alignment.toByteUnits() orelse 0));
-        errdefer self.freeAtom(atom_index);
+        const vaddr = try coff.allocateAtom(atom_index, code_len, @intCast(required_alignment.toByteUnits() orelse 0));
+        errdefer coff.freeAtom(atom_index);
         log.debug("allocated atom for {} at 0x{x}", .{ nav.fqn.fmt(ip), vaddr });
-        self.getAtomPtr(atom_index).size = code_len;
+        coff.getAtomPtr(atom_index).size = code_len;
         sym.value = vaddr;
 
-        try self.addGotEntry(.{ .sym_index = sym_index });
+        try coff.addGotEntry(.{ .sym_index = sym_index });
     }
 
-    try self.writeAtom(atom_index, code);
+    try coff.writeAtom(atom_index, code);
 }
 
-pub fn freeNav(self: *Coff, nav_index: InternPool.NavIndex) void {
-    if (self.llvm_object) |llvm_object| return llvm_object.freeNav(nav_index);
+pub fn freeNav(coff: *Coff, nav_index: InternPool.NavIndex) void {
+    if (coff.llvm_object) |llvm_object| return llvm_object.freeNav(nav_index);
 
-    const gpa = self.base.comp.gpa;
+    const gpa = coff.base.comp.gpa;
     log.debug("freeDecl 0x{x}", .{nav_index});
 
-    if (self.decls.fetchOrderedRemove(nav_index)) |const_kv| {
+    if (coff.decls.fetchOrderedRemove(nav_index)) |const_kv| {
         var kv = const_kv;
-        self.freeAtom(kv.value.atom);
+        coff.freeAtom(kv.value.atom);
         kv.value.exports.deinit(gpa);
     }
 }
 
 pub fn updateExports(
-    self: *Coff,
+    coff: *Coff,
     pt: Zcu.PerThread,
     exported: Zcu.Exported,
     export_indices: []const u32,
@@ -1469,7 +1468,7 @@ pub fn updateExports(
 
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    const comp = self.base.comp;
+    const comp = coff.base.comp;
     const target = comp.root_mod.resolved_target.result;
 
     if (comp.config.use_llvm) {
@@ -1484,14 +1483,16 @@ pub fn updateExports(
             const exported_nav = ip.getNav(exported_nav_index);
             const exported_ty = exported_nav.typeOf(ip);
             if (!ip.isFunctionType(exported_ty)) continue;
+            const c_cc = target.cCallingConvention().?;
             const winapi_cc: std.builtin.CallingConvention = switch (target.cpu.arch) {
-                .x86 => .Stdcall,
-                else => .C,
+                .x86 => .{ .x86_stdcall = .{} },
+                else => c_cc,
             };
             const exported_cc = Type.fromInterned(exported_ty).fnCallingConvention(zcu);
-            if (exported_cc == .C and exp.opts.name.eqlSlice("main", ip) and comp.config.link_libc) {
+            const CcTag = std.builtin.CallingConvention.Tag;
+            if (@as(CcTag, exported_cc) == @as(CcTag, c_cc) and exp.opts.name.eqlSlice("main", ip) and comp.config.link_libc) {
                 zcu.stage1_flags.have_c_main = true;
-            } else if (exported_cc == winapi_cc and target.os.tag == .windows) {
+            } else if (@as(CcTag, exported_cc) == @as(CcTag, winapi_cc) and target.os.tag == .windows) {
                 if (exp.opts.name.eqlSlice("WinMain", ip)) {
                     zcu.stage1_flags.have_winmain = true;
                 } else if (exp.opts.name.eqlSlice("wWinMain", ip)) {
@@ -1507,18 +1508,18 @@ pub fn updateExports(
         }
     }
 
-    if (self.llvm_object) |llvm_object| return llvm_object.updateExports(pt, exported, export_indices);
+    if (coff.llvm_object) |llvm_object| return llvm_object.updateExports(pt, exported, export_indices);
 
     const gpa = comp.gpa;
 
     const metadata = switch (exported) {
         .nav => |nav| blk: {
-            _ = try self.getOrCreateAtomForNav(nav);
-            break :blk self.navs.getPtr(nav).?;
+            _ = try coff.getOrCreateAtomForNav(nav);
+            break :blk coff.navs.getPtr(nav).?;
         },
-        .uav => |uav| self.uavs.getPtr(uav) orelse blk: {
+        .uav => |uav| coff.uavs.getPtr(uav) orelse blk: {
             const first_exp = zcu.all_exports.items[export_indices[0]];
-            const res = try self.lowerUav(pt, uav, .none, first_exp.src);
+            const res = try coff.lowerUav(pt, uav, .none, first_exp.src);
             switch (res) {
                 .mcv => {},
                 .fail => |em| {
@@ -1529,11 +1530,11 @@ pub fn updateExports(
                     return;
                 },
             }
-            break :blk self.uavs.getPtr(uav).?;
+            break :blk coff.uavs.getPtr(uav).?;
         },
     };
     const atom_index = metadata.atom;
-    const atom = self.getAtom(atom_index);
+    const atom = coff.getAtom(atom_index);
 
     for (export_indices) |export_idx| {
         const exp = zcu.all_exports.items[export_idx];
@@ -1562,27 +1563,27 @@ pub fn updateExports(
         }
 
         const exp_name = exp.opts.name.toSlice(&zcu.intern_pool);
-        const sym_index = metadata.getExport(self, exp_name) orelse blk: {
-            const sym_index = if (self.getGlobalIndex(exp_name)) |global_index| ind: {
-                const global = self.globals.items[global_index];
+        const sym_index = metadata.getExport(coff, exp_name) orelse blk: {
+            const sym_index = if (coff.getGlobalIndex(exp_name)) |global_index| ind: {
+                const global = coff.globals.items[global_index];
                 // TODO this is just plain wrong as it all should happen in a single `resolveSymbols`
                 // pass. This will go away once we abstact away Zig's incremental compilation into
                 // its own module.
-                if (global.file == null and self.getSymbol(global).section_number == .UNDEFINED) {
-                    _ = self.unresolved.swapRemove(global_index);
+                if (global.file == null and coff.getSymbol(global).section_number == .UNDEFINED) {
+                    _ = coff.unresolved.swapRemove(global_index);
                     break :ind global.sym_index;
                 }
-                break :ind try self.allocateSymbol();
-            } else try self.allocateSymbol();
+                break :ind try coff.allocateSymbol();
+            } else try coff.allocateSymbol();
             try metadata.exports.append(gpa, sym_index);
             break :blk sym_index;
         };
         const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = null };
-        const sym = self.getSymbolPtr(sym_loc);
-        try self.setSymbolName(sym, exp_name);
-        sym.value = atom.getSymbol(self).value;
-        sym.section_number = @as(coff.SectionNumber, @enumFromInt(metadata.section + 1));
-        sym.type = atom.getSymbol(self).type;
+        const sym = coff.getSymbolPtr(sym_loc);
+        try coff.setSymbolName(sym, exp_name);
+        sym.value = atom.getSymbol(coff).value;
+        sym.section_number = @as(coff_util.SectionNumber, @enumFromInt(metadata.section + 1));
+        sym.type = atom.getSymbol(coff).type;
 
         switch (exp.opts.linkage) {
             .strong => {
@@ -1593,27 +1594,27 @@ pub fn updateExports(
             else => unreachable,
         }
 
-        try self.resolveGlobalSymbol(sym_loc);
+        try coff.resolveGlobalSymbol(sym_loc);
     }
 }
 
 pub fn deleteExport(
-    self: *Coff,
+    coff: *Coff,
     exported: Zcu.Exported,
     name: InternPool.NullTerminatedString,
 ) void {
-    if (self.llvm_object) |_| return;
+    if (coff.llvm_object) |_| return;
     const metadata = switch (exported) {
-        .nav => |nav| self.navs.getPtr(nav),
-        .uav => |uav| self.uavs.getPtr(uav),
+        .nav => |nav| coff.navs.getPtr(nav),
+        .uav => |uav| coff.uavs.getPtr(uav),
     } orelse return;
-    const zcu = self.base.comp.zcu.?;
+    const zcu = coff.base.comp.zcu.?;
     const name_slice = name.toSlice(&zcu.intern_pool);
-    const sym_index = metadata.getExportPtr(self, name_slice) orelse return;
+    const sym_index = metadata.getExportPtr(coff, name_slice) orelse return;
 
-    const gpa = self.base.comp.gpa;
+    const gpa = coff.base.comp.gpa;
     const sym_loc = SymbolWithLoc{ .sym_index = sym_index.*, .file = null };
-    const sym = self.getSymbolPtr(sym_loc);
+    const sym = coff.getSymbolPtr(sym_loc);
     log.debug("deleting export '{}'", .{name.fmt(&zcu.intern_pool)});
     assert(sym.storage_class == .EXTERNAL and sym.section_number != .UNDEFINED);
     sym.* = .{
@@ -1624,12 +1625,12 @@ pub fn deleteExport(
         .storage_class = .NULL,
         .number_of_aux_symbols = 0,
     };
-    self.locals_free_list.append(gpa, sym_index.*) catch {};
+    coff.locals_free_list.append(gpa, sym_index.*) catch {};
 
-    if (self.resolver.fetchRemove(name_slice)) |entry| {
+    if (coff.resolver.fetchRemove(name_slice)) |entry| {
         defer gpa.free(entry.key);
-        self.globals_free_list.append(gpa, entry.value) catch {};
-        self.globals.items[entry.value] = .{
+        coff.globals_free_list.append(gpa, entry.value) catch {};
+        coff.globals.items[entry.value] = .{
             .sym_index = 0,
             .file = null,
         };
@@ -1638,16 +1639,16 @@ pub fn deleteExport(
     sym_index.* = 0;
 }
 
-fn resolveGlobalSymbol(self: *Coff, current: SymbolWithLoc) !void {
-    const gpa = self.base.comp.gpa;
-    const sym = self.getSymbol(current);
-    const sym_name = self.getSymbolName(current);
+fn resolveGlobalSymbol(coff: *Coff, current: SymbolWithLoc) !void {
+    const gpa = coff.base.comp.gpa;
+    const sym = coff.getSymbol(current);
+    const sym_name = coff.getSymbolName(current);
 
-    const gop = try self.getOrPutGlobalPtr(sym_name);
+    const gop = try coff.getOrPutGlobalPtr(sym_name);
     if (!gop.found_existing) {
         gop.value_ptr.* = current;
         if (sym.section_number == .UNDEFINED) {
-            try self.unresolved.putNoClobber(gpa, self.getGlobalIndex(sym_name).?, false);
+            try coff.unresolved.putNoClobber(gpa, coff.getGlobalIndex(sym_name).?, false);
         }
         return;
     }
@@ -1656,32 +1657,560 @@ fn resolveGlobalSymbol(self: *Coff, current: SymbolWithLoc) !void {
 
     if (sym.section_number == .UNDEFINED) return;
 
-    _ = self.unresolved.swapRemove(self.getGlobalIndex(sym_name).?);
+    _ = coff.unresolved.swapRemove(coff.getGlobalIndex(sym_name).?);
 
     gop.value_ptr.* = current;
 }
 
-pub fn flush(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
-    const comp = self.base.comp;
+pub fn flush(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
+    const comp = coff.base.comp;
     const use_lld = build_options.have_llvm and comp.config.use_lld;
     if (use_lld) {
-        return lld.linkWithLLD(self, arena, tid, prog_node);
+        return coff.linkWithLLD(arena, tid, prog_node);
     }
     switch (comp.config.output_mode) {
-        .Exe, .Obj => return self.flushModule(arena, tid, prog_node),
+        .Exe, .Obj => return coff.flushModule(arena, tid, prog_node),
         .Lib => return error.TODOImplementWritingLibFiles,
     }
 }
 
-pub fn flushModule(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
+fn linkWithLLD(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) !void {
+    dev.check(.lld_linker);
+
+    const tracy = trace(@src());
+    defer tracy.end();
+
+    const comp = coff.base.comp;
+    const gpa = comp.gpa;
+
+    const directory = coff.base.emit.root_dir; // Just an alias to make it shorter to type.
+    const full_out_path = try directory.join(arena, &[_][]const u8{coff.base.emit.sub_path});
+
+    // If there is no Zig code to compile, then we should skip flushing the output file because it
+    // will not be part of the linker line anyway.
+    const module_obj_path: ?[]const u8 = if (comp.zcu != null) blk: {
+        try coff.flushModule(arena, tid, prog_node);
+
+        if (fs.path.dirname(full_out_path)) |dirname| {
+            break :blk try fs.path.join(arena, &.{ dirname, coff.base.zcu_object_sub_path.? });
+        } else {
+            break :blk coff.base.zcu_object_sub_path.?;
+        }
+    } else null;
+
+    const sub_prog_node = prog_node.start("LLD Link", 0);
+    defer sub_prog_node.end();
+
+    const is_lib = comp.config.output_mode == .Lib;
+    const is_dyn_lib = comp.config.link_mode == .dynamic and is_lib;
+    const is_exe_or_dyn_lib = is_dyn_lib or comp.config.output_mode == .Exe;
+    const link_in_crt = comp.config.link_libc and is_exe_or_dyn_lib;
+    const target = comp.root_mod.resolved_target.result;
+    const optimize_mode = comp.root_mod.optimize_mode;
+    const entry_name: ?[]const u8 = switch (coff.entry) {
+        // This logic isn't quite right for disabled or enabled. No point in fixing it
+        // when the goal is to eliminate dependency on LLD anyway.
+        // https://github.com/ziglang/zig/issues/17751
+        .disabled, .default, .enabled => null,
+        .named => |name| name,
+    };
+
+    // See link/Elf.zig for comments on how this mechanism works.
+    const id_symlink_basename = "lld.id";
+
+    var man: Cache.Manifest = undefined;
+    defer if (!coff.base.disable_lld_caching) man.deinit();
+
+    var digest: [Cache.hex_digest_len]u8 = undefined;
+
+    if (!coff.base.disable_lld_caching) {
+        man = comp.cache_parent.obtain();
+        coff.base.releaseLock();
+
+        comptime assert(Compilation.link_hash_implementation_version == 14);
+
+        try link.hashInputs(&man, comp.link_inputs);
+        for (comp.c_object_table.keys()) |key| {
+            _ = try man.addFilePath(key.status.success.object_path, null);
+        }
+        for (comp.win32_resource_table.keys()) |key| {
+            _ = try man.addFile(key.status.success.res_path, null);
+        }
+        try man.addOptionalFile(module_obj_path);
+        man.hash.addOptionalBytes(entry_name);
+        man.hash.add(coff.base.stack_size);
+        man.hash.add(coff.image_base);
+        {
+            // TODO remove this, libraries must instead be resolved by the frontend.
+            for (coff.lib_directories) |lib_directory| man.hash.addOptionalBytes(lib_directory.path);
+        }
+        man.hash.add(comp.skip_linker_dependencies);
+        if (comp.config.link_libc) {
+            man.hash.add(comp.libc_installation != null);
+            if (comp.libc_installation) |libc_installation| {
+                man.hash.addBytes(libc_installation.crt_dir.?);
+                if (target.abi == .msvc or target.abi == .itanium) {
+                    man.hash.addBytes(libc_installation.msvc_lib_dir.?);
+                    man.hash.addBytes(libc_installation.kernel32_lib_dir.?);
+                }
+            }
+        }
+        man.hash.addListOfBytes(comp.windows_libs.keys());
+        man.hash.addListOfBytes(comp.force_undefined_symbols.keys());
+        man.hash.addOptional(coff.subsystem);
+        man.hash.add(comp.config.is_test);
+        man.hash.add(coff.tsaware);
+        man.hash.add(coff.nxcompat);
+        man.hash.add(coff.dynamicbase);
+        man.hash.add(coff.base.allow_shlib_undefined);
+        // strip does not need to go into the linker hash because it is part of the hash namespace
+        man.hash.add(coff.major_subsystem_version);
+        man.hash.add(coff.minor_subsystem_version);
+        man.hash.add(coff.repro);
+        man.hash.addOptional(comp.version);
+        try man.addOptionalFile(coff.module_definition_file);
+
+        // We don't actually care whether it's a cache hit or miss; we just need the digest and the lock.
+        _ = try man.hit();
+        digest = man.final();
+        var prev_digest_buf: [digest.len]u8 = undefined;
+        const prev_digest: []u8 = Cache.readSmallFile(
+            directory.handle,
+            id_symlink_basename,
+            &prev_digest_buf,
+        ) catch |err| blk: {
+            log.debug("COFF LLD new_digest={s} error: {s}", .{ std.fmt.fmtSliceHexLower(&digest), @errorName(err) });
+            // Handle this as a cache miss.
+            break :blk prev_digest_buf[0..0];
+        };
+        if (mem.eql(u8, prev_digest, &digest)) {
+            log.debug("COFF LLD digest={s} match - skipping invocation", .{std.fmt.fmtSliceHexLower(&digest)});
+            // Hot diggity dog! The output binary is already there.
+            coff.base.lock = man.toOwnedLock();
+            return;
+        }
+        log.debug("COFF LLD prev_digest={s} new_digest={s}", .{ std.fmt.fmtSliceHexLower(prev_digest), std.fmt.fmtSliceHexLower(&digest) });
+
+        // We are about to change the output file to be different, so we invalidate the build hash now.
+        directory.handle.deleteFile(id_symlink_basename) catch |err| switch (err) {
+            error.FileNotFound => {},
+            else => |e| return e,
+        };
+    }
+
+    if (comp.config.output_mode == .Obj) {
+        // LLD's COFF driver does not support the equivalent of `-r` so we do a simple file copy
+        // here. TODO: think carefully about how we can avoid this redundant operation when doing
+        // build-obj. See also the corresponding TODO in linkAsArchive.
+        const the_object_path = blk: {
+            if (link.firstObjectInput(comp.link_inputs)) |obj| break :blk obj.path;
+
+            if (comp.c_object_table.count() != 0)
+                break :blk comp.c_object_table.keys()[0].status.success.object_path;
+
+            if (module_obj_path) |p|
+                break :blk Path.initCwd(p);
+
+            // TODO I think this is unreachable. Audit this situation when solving the above TODO
+            // regarding eliding redundant object -> object transformations.
+            return error.NoObjectsToLink;
+        };
+        try std.fs.Dir.copyFile(
+            the_object_path.root_dir.handle,
+            the_object_path.sub_path,
+            directory.handle,
+            coff.base.emit.sub_path,
+            .{},
+        );
+    } else {
+        // Create an LLD command line and invoke it.
+        var argv = std.ArrayList([]const u8).init(gpa);
+        defer argv.deinit();
+        // We will invoke ourselves as a child process to gain access to LLD.
+        // This is necessary because LLD does not behave properly as a library -
+        // 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 });
+
+        if (target.isMinGW()) {
+            try argv.append("-lldmingw");
+        }
+
+        try argv.append("-ERRORLIMIT:0");
+        try argv.append("-NOLOGO");
+        if (comp.config.debug_format != .strip) {
+            try argv.append("-DEBUG");
+
+            const out_ext = std.fs.path.extension(full_out_path);
+            const out_pdb = coff.pdb_out_path orelse try allocPrint(arena, "{s}.pdb", .{
+                full_out_path[0 .. full_out_path.len - out_ext.len],
+            });
+            const out_pdb_basename = std.fs.path.basename(out_pdb);
+
+            try argv.append(try allocPrint(arena, "-PDB:{s}", .{out_pdb}));
+            try argv.append(try allocPrint(arena, "-PDBALTPATH:{s}", .{out_pdb_basename}));
+        }
+        if (comp.version) |version| {
+            try argv.append(try allocPrint(arena, "-VERSION:{}.{}", .{ version.major, version.minor }));
+        }
+        if (comp.config.lto) {
+            switch (optimize_mode) {
+                .Debug => {},
+                .ReleaseSmall => try argv.append("-OPT:lldlto=2"),
+                .ReleaseFast, .ReleaseSafe => try argv.append("-OPT:lldlto=3"),
+            }
+        }
+        if (comp.config.output_mode == .Exe) {
+            try argv.append(try allocPrint(arena, "-STACK:{d}", .{coff.base.stack_size}));
+        }
+        try argv.append(try allocPrint(arena, "-BASE:{d}", .{coff.image_base}));
+
+        if (target.cpu.arch == .x86) {
+            try argv.append("-MACHINE:X86");
+        } else if (target.cpu.arch == .x86_64) {
+            try argv.append("-MACHINE:X64");
+        } else if (target.cpu.arch == .thumb) {
+            try argv.append("-MACHINE:ARM");
+        } else if (target.cpu.arch == .aarch64) {
+            try argv.append("-MACHINE:ARM64");
+        }
+
+        for (comp.force_undefined_symbols.keys()) |symbol| {
+            try argv.append(try allocPrint(arena, "-INCLUDE:{s}", .{symbol}));
+        }
+
+        if (is_dyn_lib) {
+            try argv.append("-DLL");
+        }
+
+        if (entry_name) |name| {
+            try argv.append(try allocPrint(arena, "-ENTRY:{s}", .{name}));
+        }
+
+        if (coff.repro) {
+            try argv.append("-BREPRO");
+        }
+
+        if (coff.tsaware) {
+            try argv.append("-tsaware");
+        }
+        if (coff.nxcompat) {
+            try argv.append("-nxcompat");
+        }
+        if (!coff.dynamicbase) {
+            try argv.append("-dynamicbase:NO");
+        }
+        if (coff.base.allow_shlib_undefined) {
+            try argv.append("-FORCE:UNRESOLVED");
+        }
+
+        try argv.append(try allocPrint(arena, "-OUT:{s}", .{full_out_path}));
+
+        if (comp.implib_emit) |emit| {
+            const implib_out_path = try emit.root_dir.join(arena, &[_][]const u8{emit.sub_path});
+            try argv.append(try allocPrint(arena, "-IMPLIB:{s}", .{implib_out_path}));
+        }
+
+        if (comp.config.link_libc) {
+            if (comp.libc_installation) |libc_installation| {
+                try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.crt_dir.?}));
+
+                if (target.abi == .msvc or target.abi == .itanium) {
+                    try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.msvc_lib_dir.?}));
+                    try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.kernel32_lib_dir.?}));
+                }
+            }
+        }
+
+        for (coff.lib_directories) |lib_directory| {
+            try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{lib_directory.path orelse "."}));
+        }
+
+        try argv.ensureUnusedCapacity(comp.link_inputs.len);
+        for (comp.link_inputs) |link_input| switch (link_input) {
+            .dso_exact => unreachable, // not applicable to PE/COFF
+            inline .dso, .res => |x| {
+                argv.appendAssumeCapacity(try x.path.toString(arena));
+            },
+            .object, .archive => |obj| {
+                if (obj.must_link) {
+                    argv.appendAssumeCapacity(try allocPrint(arena, "-WHOLEARCHIVE:{}", .{@as(Path, obj.path)}));
+                } else {
+                    argv.appendAssumeCapacity(try obj.path.toString(arena));
+                }
+            },
+        };
+
+        for (comp.c_object_table.keys()) |key| {
+            try argv.append(try key.status.success.object_path.toString(arena));
+        }
+
+        for (comp.win32_resource_table.keys()) |key| {
+            try argv.append(key.status.success.res_path);
+        }
+
+        if (module_obj_path) |p| {
+            try argv.append(p);
+        }
+
+        if (coff.module_definition_file) |def| {
+            try argv.append(try allocPrint(arena, "-DEF:{s}", .{def}));
+        }
+
+        const resolved_subsystem: ?std.Target.SubSystem = blk: {
+            if (coff.subsystem) |explicit| break :blk explicit;
+            switch (target.os.tag) {
+                .windows => {
+                    if (comp.zcu) |module| {
+                        if (module.stage1_flags.have_dllmain_crt_startup or is_dyn_lib)
+                            break :blk null;
+                        if (module.stage1_flags.have_c_main or comp.config.is_test or
+                            module.stage1_flags.have_winmain_crt_startup or
+                            module.stage1_flags.have_wwinmain_crt_startup)
+                        {
+                            break :blk .Console;
+                        }
+                        if (module.stage1_flags.have_winmain or module.stage1_flags.have_wwinmain)
+                            break :blk .Windows;
+                    }
+                },
+                .uefi => break :blk .EfiApplication,
+                else => {},
+            }
+            break :blk null;
+        };
+
+        const Mode = enum { uefi, win32 };
+        const mode: Mode = mode: {
+            if (resolved_subsystem) |subsystem| {
+                const subsystem_suffix = try allocPrint(arena, ",{d}.{d}", .{
+                    coff.major_subsystem_version, coff.minor_subsystem_version,
+                });
+
+                switch (subsystem) {
+                    .Console => {
+                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:console{s}", .{
+                            subsystem_suffix,
+                        }));
+                        break :mode .win32;
+                    },
+                    .EfiApplication => {
+                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:efi_application{s}", .{
+                            subsystem_suffix,
+                        }));
+                        break :mode .uefi;
+                    },
+                    .EfiBootServiceDriver => {
+                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:efi_boot_service_driver{s}", .{
+                            subsystem_suffix,
+                        }));
+                        break :mode .uefi;
+                    },
+                    .EfiRom => {
+                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:efi_rom{s}", .{
+                            subsystem_suffix,
+                        }));
+                        break :mode .uefi;
+                    },
+                    .EfiRuntimeDriver => {
+                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:efi_runtime_driver{s}", .{
+                            subsystem_suffix,
+                        }));
+                        break :mode .uefi;
+                    },
+                    .Native => {
+                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:native{s}", .{
+                            subsystem_suffix,
+                        }));
+                        break :mode .win32;
+                    },
+                    .Posix => {
+                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:posix{s}", .{
+                            subsystem_suffix,
+                        }));
+                        break :mode .win32;
+                    },
+                    .Windows => {
+                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:windows{s}", .{
+                            subsystem_suffix,
+                        }));
+                        break :mode .win32;
+                    },
+                }
+            } else if (target.os.tag == .uefi) {
+                break :mode .uefi;
+            } else {
+                break :mode .win32;
+            }
+        };
+
+        switch (mode) {
+            .uefi => try argv.appendSlice(&[_][]const u8{
+                "-BASE:0",
+                "-ENTRY:EfiMain",
+                "-OPT:REF",
+                "-SAFESEH:NO",
+                "-MERGE:.rdata=.data",
+                "-NODEFAULTLIB",
+                "-SECTION:.xdata,D",
+            }),
+            .win32 => {
+                if (link_in_crt) {
+                    if (target.abi.isGnu()) {
+                        if (target.cpu.arch == .x86) {
+                            try argv.append("-ALTERNATENAME:__image_base__=___ImageBase");
+                        } else {
+                            try argv.append("-ALTERNATENAME:__image_base__=__ImageBase");
+                        }
+
+                        if (is_dyn_lib) {
+                            try argv.append(try comp.crtFileAsString(arena, "dllcrt2.obj"));
+                            if (target.cpu.arch == .x86) {
+                                try argv.append("-ALTERNATENAME:__DllMainCRTStartup@12=_DllMainCRTStartup@12");
+                            } else {
+                                try argv.append("-ALTERNATENAME:_DllMainCRTStartup=DllMainCRTStartup");
+                            }
+                        } else {
+                            try argv.append(try comp.crtFileAsString(arena, "crt2.obj"));
+                        }
+
+                        try argv.append(try comp.crtFileAsString(arena, "mingw32.lib"));
+                    } else {
+                        const lib_str = switch (comp.config.link_mode) {
+                            .dynamic => "",
+                            .static => "lib",
+                        };
+                        const d_str = switch (optimize_mode) {
+                            .Debug => "d",
+                            else => "",
+                        };
+                        switch (comp.config.link_mode) {
+                            .static => try argv.append(try allocPrint(arena, "libcmt{s}.lib", .{d_str})),
+                            .dynamic => try argv.append(try allocPrint(arena, "msvcrt{s}.lib", .{d_str})),
+                        }
+
+                        try argv.append(try allocPrint(arena, "{s}vcruntime{s}.lib", .{ lib_str, d_str }));
+                        try argv.append(try allocPrint(arena, "{s}ucrt{s}.lib", .{ lib_str, d_str }));
+
+                        //Visual C++ 2015 Conformance Changes
+                        //https://msdn.microsoft.com/en-us/library/bb531344.aspx
+                        try argv.append("legacy_stdio_definitions.lib");
+
+                        // msvcrt depends on kernel32 and ntdll
+                        try argv.append("kernel32.lib");
+                        try argv.append("ntdll.lib");
+                    }
+                } else {
+                    try argv.append("-NODEFAULTLIB");
+                    if (!is_lib and entry_name == null) {
+                        if (comp.zcu) |module| {
+                            if (module.stage1_flags.have_winmain_crt_startup) {
+                                try argv.append("-ENTRY:WinMainCRTStartup");
+                            } else {
+                                try argv.append("-ENTRY:wWinMainCRTStartup");
+                            }
+                        } else {
+                            try argv.append("-ENTRY:wWinMainCRTStartup");
+                        }
+                    }
+                }
+            },
+        }
+
+        // libc++ dep
+        if (comp.config.link_libcpp) {
+            try argv.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
+            try argv.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
+        }
+
+        // libunwind dep
+        if (comp.config.link_libunwind) {
+            try argv.append(try comp.libunwind_static_lib.?.full_object_path.toString(arena));
+        }
+
+        if (comp.config.any_fuzz) {
+            try argv.append(try comp.fuzzer_lib.?.full_object_path.toString(arena));
+        }
+
+        if (is_exe_or_dyn_lib and !comp.skip_linker_dependencies) {
+            if (!comp.config.link_libc) {
+                if (comp.libc_static_lib) |lib| {
+                    try argv.append(try lib.full_object_path.toString(arena));
+                }
+            }
+            // MSVC compiler_rt is missing some stuff, so we build it unconditionally but
+            // and rely on weak linkage to allow MSVC compiler_rt functions to override ours.
+            if (comp.compiler_rt_obj) |obj| try argv.append(try obj.full_object_path.toString(arena));
+            if (comp.compiler_rt_lib) |lib| try argv.append(try lib.full_object_path.toString(arena));
+        }
+
+        try argv.ensureUnusedCapacity(comp.windows_libs.count());
+        for (comp.windows_libs.keys()) |key| {
+            const lib_basename = try allocPrint(arena, "{s}.lib", .{key});
+            if (comp.crt_files.get(lib_basename)) |crt_file| {
+                argv.appendAssumeCapacity(try crt_file.full_object_path.toString(arena));
+                continue;
+            }
+            if (try findLib(arena, lib_basename, coff.lib_directories)) |full_path| {
+                argv.appendAssumeCapacity(full_path);
+                continue;
+            }
+            if (target.abi.isGnu()) {
+                const fallback_name = try allocPrint(arena, "lib{s}.dll.a", .{key});
+                if (try findLib(arena, fallback_name, coff.lib_directories)) |full_path| {
+                    argv.appendAssumeCapacity(full_path);
+                    continue;
+                }
+            }
+            if (target.abi == .msvc or target.abi == .itanium) {
+                argv.appendAssumeCapacity(lib_basename);
+                continue;
+            }
+
+            log.err("DLL import library for -l{s} not found", .{key});
+            return error.DllImportLibraryNotFound;
+        }
+
+        try link.spawnLld(comp, arena, argv.items);
+    }
+
+    if (!coff.base.disable_lld_caching) {
+        // Update the file with the digest. If it fails we can continue; it only
+        // means that the next invocation will have an unnecessary cache miss.
+        Cache.writeSmallFile(directory.handle, id_symlink_basename, &digest) catch |err| {
+            log.warn("failed to save linking hash digest file: {s}", .{@errorName(err)});
+        };
+        // Again failure here only means an unnecessary cache miss.
+        man.writeManifest() catch |err| {
+            log.warn("failed to write cache manifest when linking: {s}", .{@errorName(err)});
+        };
+        // We hang on to this lock so that the output file path can be used without
+        // other processes clobbering it.
+        coff.base.lock = man.toOwnedLock();
+    }
+}
+
+fn findLib(arena: Allocator, name: []const u8, lib_directories: []const Directory) !?[]const u8 {
+    for (lib_directories) |lib_directory| {
+        lib_directory.handle.access(name, .{}) catch |err| switch (err) {
+            error.FileNotFound => continue,
+            else => |e| return e,
+        };
+        return try lib_directory.join(arena, &.{name});
+    }
+    return null;
+}
+
+pub fn flushModule(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    const comp = self.base.comp;
+    const comp = coff.base.comp;
     const gpa = comp.gpa;
+    const diags = &comp.link_diags;
 
-    if (self.llvm_object) |llvm_object| {
-        try self.base.emitLlvmObject(arena, llvm_object, prog_node);
+    if (coff.llvm_object) |llvm_object| {
+        try coff.base.emitLlvmObject(arena, llvm_object, prog_node);
         return;
     }
 
@@ -1693,46 +2222,46 @@ pub fn flushModule(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
         .tid = tid,
     };
 
-    if (self.lazy_syms.getPtr(.anyerror_type)) |metadata| {
+    if (coff.lazy_syms.getPtr(.anyerror_type)) |metadata| {
         // Most lazy symbols can be updated on first use, but
         // anyerror needs to wait for everything to be flushed.
-        if (metadata.text_state != .unused) self.updateLazySymbolAtom(
+        if (metadata.text_state != .unused) coff.updateLazySymbolAtom(
             pt,
             .{ .kind = .code, .ty = .anyerror_type },
             metadata.text_atom,
-            self.text_section_index.?,
+            coff.text_section_index.?,
         ) catch |err| return switch (err) {
             error.CodegenFail => error.FlushFailure,
             else => |e| e,
         };
-        if (metadata.rdata_state != .unused) self.updateLazySymbolAtom(
+        if (metadata.rdata_state != .unused) coff.updateLazySymbolAtom(
             pt,
             .{ .kind = .const_data, .ty = .anyerror_type },
             metadata.rdata_atom,
-            self.rdata_section_index.?,
+            coff.rdata_section_index.?,
         ) catch |err| return switch (err) {
             error.CodegenFail => error.FlushFailure,
             else => |e| e,
         };
     }
-    for (self.lazy_syms.values()) |*metadata| {
+    for (coff.lazy_syms.values()) |*metadata| {
         if (metadata.text_state != .unused) metadata.text_state = .flushed;
         if (metadata.rdata_state != .unused) metadata.rdata_state = .flushed;
     }
 
     {
-        var it = self.need_got_table.iterator();
+        var it = coff.need_got_table.iterator();
         while (it.next()) |entry| {
-            const global = self.globals.items[entry.key_ptr.*];
-            try self.addGotEntry(global);
+            const global = coff.globals.items[entry.key_ptr.*];
+            try coff.addGotEntry(global);
         }
     }
 
-    while (self.unresolved.popOrNull()) |entry| {
+    while (coff.unresolved.popOrNull()) |entry| {
         assert(entry.value);
-        const global = self.globals.items[entry.key];
-        const sym = self.getSymbol(global);
-        const res = try self.import_tables.getOrPut(gpa, sym.value);
+        const global = coff.globals.items[entry.key];
+        const sym = coff.getSymbol(global);
+        const res = try coff.import_tables.getOrPut(gpa, sym.value);
         const itable = res.value_ptr;
         if (!res.found_existing) {
             itable.* = .{};
@@ -1741,21 +2270,21 @@ pub fn flushModule(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
         // TODO: we could technically write the pointer placeholder for to-be-bound import here,
         // but since this happens in flush, there is currently no point.
         _ = try itable.addImport(gpa, global);
-        self.imports_count_dirty = true;
+        coff.imports_count_dirty = true;
     }
 
-    try self.writeImportTables();
+    try coff.writeImportTables();
 
-    for (self.relocs.keys(), self.relocs.values()) |atom_index, relocs| {
+    for (coff.relocs.keys(), coff.relocs.values()) |atom_index, relocs| {
         const needs_update = for (relocs.items) |reloc| {
             if (reloc.dirty) break true;
         } else false;
 
         if (!needs_update) continue;
 
-        const atom = self.getAtom(atom_index);
-        const sym = atom.getSymbol(self);
-        const section = self.sections.get(@intFromEnum(sym.section_number) - 1).header;
+        const atom = coff.getAtom(atom_index);
+        const sym = atom.getSymbol(coff);
+        const section = coff.sections.get(@intFromEnum(sym.section_number) - 1).header;
         const file_offset = section.pointer_to_raw_data + sym.value - section.virtual_address;
 
         var code = std.ArrayList(u8).init(gpa);
@@ -1763,70 +2292,70 @@ pub fn flushModule(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
         try code.resize(math.cast(usize, atom.size) orelse return error.Overflow);
         assert(atom.size > 0);
 
-        const amt = try self.base.file.?.preadAll(code.items, file_offset);
+        const amt = try coff.base.file.?.preadAll(code.items, file_offset);
         if (amt != code.items.len) return error.InputOutput;
 
-        try self.writeAtom(atom_index, code.items);
+        try coff.writeAtom(atom_index, code.items);
     }
 
     // Update GOT if it got moved in memory.
-    if (self.got_table_contents_dirty) {
-        for (self.got_table.entries.items, 0..) |entry, i| {
-            if (!self.got_table.lookup.contains(entry)) continue;
+    if (coff.got_table_contents_dirty) {
+        for (coff.got_table.entries.items, 0..) |entry, i| {
+            if (!coff.got_table.lookup.contains(entry)) continue;
             // TODO: write all in one go rather than incrementally.
-            try self.writeOffsetTableEntry(i);
+            try coff.writeOffsetTableEntry(i);
         }
-        self.got_table_contents_dirty = false;
+        coff.got_table_contents_dirty = false;
     }
 
-    try self.writeBaseRelocations();
+    try coff.writeBaseRelocations();
 
-    if (self.getEntryPoint()) |entry_sym_loc| {
-        self.entry_addr = self.getSymbol(entry_sym_loc).value;
+    if (coff.getEntryPoint()) |entry_sym_loc| {
+        coff.entry_addr = coff.getSymbol(entry_sym_loc).value;
     }
 
     if (build_options.enable_logging) {
-        self.logSymtab();
-        self.logImportTables();
+        coff.logSymtab();
+        coff.logImportTables();
     }
 
-    try self.writeStrtab();
-    try self.writeDataDirectoriesHeaders();
-    try self.writeSectionHeaders();
+    try coff.writeStrtab();
+    try coff.writeDataDirectoriesHeaders();
+    try coff.writeSectionHeaders();
 
-    if (self.entry_addr == null and comp.config.output_mode == .Exe) {
+    if (coff.entry_addr == null and comp.config.output_mode == .Exe) {
         log.debug("flushing. no_entry_point_found = true\n", .{});
-        comp.link_error_flags.no_entry_point_found = true;
+        diags.flags.no_entry_point_found = true;
     } else {
         log.debug("flushing. no_entry_point_found = false\n", .{});
-        comp.link_error_flags.no_entry_point_found = false;
-        try self.writeHeader();
+        diags.flags.no_entry_point_found = false;
+        try coff.writeHeader();
     }
 
-    assert(!self.imports_count_dirty);
+    assert(!coff.imports_count_dirty);
 }
 
 pub fn getNavVAddr(
-    self: *Coff,
+    coff: *Coff,
     pt: Zcu.PerThread,
     nav_index: InternPool.Nav.Index,
     reloc_info: link.File.RelocInfo,
 ) !u64 {
-    assert(self.llvm_object == null);
+    assert(coff.llvm_object == null);
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const nav = ip.getNav(nav_index);
     log.debug("getNavVAddr {}({d})", .{ nav.fqn.fmt(ip), nav_index });
     const sym_index = switch (ip.indexToKey(nav.status.resolved.val)) {
-        .@"extern" => |@"extern"| try self.getGlobalSymbol(nav.name.toSlice(ip), @"extern".lib_name.toSlice(ip)),
-        else => self.getAtom(try self.getOrCreateAtomForNav(nav_index)).getSymbolIndex().?,
+        .@"extern" => |@"extern"| try coff.getGlobalSymbol(nav.name.toSlice(ip), @"extern".lib_name.toSlice(ip)),
+        else => coff.getAtom(try coff.getOrCreateAtomForNav(nav_index)).getSymbolIndex().?,
     };
-    const atom_index = self.getAtomIndexForSymbol(.{
+    const atom_index = coff.getAtomIndexForSymbol(.{
         .sym_index = reloc_info.parent.atom_index,
         .file = null,
     }).?;
     const target = SymbolWithLoc{ .sym_index = sym_index, .file = null };
-    try Atom.addRelocation(self, atom_index, .{
+    try coff.addRelocation(atom_index, .{
         .type = .direct,
         .target = target,
         .offset = @as(u32, @intCast(reloc_info.offset)),
@@ -1834,13 +2363,13 @@ pub fn getNavVAddr(
         .pcrel = false,
         .length = 3,
     });
-    try Atom.addBaseRelocation(self, atom_index, @as(u32, @intCast(reloc_info.offset)));
+    try coff.addBaseRelocation(atom_index, @as(u32, @intCast(reloc_info.offset)));
 
     return 0;
 }
 
 pub fn lowerUav(
-    self: *Coff,
+    coff: *Coff,
     pt: Zcu.PerThread,
     uav: InternPool.Index,
     explicit_alignment: InternPool.Alignment,
@@ -1853,9 +2382,9 @@ pub fn lowerUav(
         .none => val.typeOf(zcu).abiAlignment(zcu),
         else => explicit_alignment,
     };
-    if (self.uavs.get(uav)) |metadata| {
-        const atom = self.getAtom(metadata.atom);
-        const existing_addr = atom.getSymbol(self).value;
+    if (coff.uavs.get(uav)) |metadata| {
+        const atom = coff.getAtom(metadata.atom);
+        const existing_addr = atom.getSymbol(coff).value;
         if (uav_alignment.check(existing_addr))
             return .{ .mcv = .{ .load_direct = atom.getSymbolIndex().? } };
     }
@@ -1864,12 +2393,12 @@ pub fn lowerUav(
     const name = std.fmt.bufPrint(&name_buf, "__anon_{d}", .{
         @intFromEnum(uav),
     }) catch unreachable;
-    const res = self.lowerConst(
+    const res = coff.lowerConst(
         pt,
         name,
         val,
         uav_alignment,
-        self.rdata_section_index.?,
+        coff.rdata_section_index.?,
         src_loc,
     ) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
@@ -1884,30 +2413,30 @@ pub fn lowerUav(
         .ok => |atom_index| atom_index,
         .fail => |em| return .{ .fail = em },
     };
-    try self.uavs.put(gpa, uav, .{
+    try coff.uavs.put(gpa, uav, .{
         .atom = atom_index,
-        .section = self.rdata_section_index.?,
+        .section = coff.rdata_section_index.?,
     });
     return .{ .mcv = .{
-        .load_direct = self.getAtom(atom_index).getSymbolIndex().?,
+        .load_direct = coff.getAtom(atom_index).getSymbolIndex().?,
     } };
 }
 
 pub fn getUavVAddr(
-    self: *Coff,
+    coff: *Coff,
     uav: InternPool.Index,
     reloc_info: link.File.RelocInfo,
 ) !u64 {
-    assert(self.llvm_object == null);
+    assert(coff.llvm_object == null);
 
-    const this_atom_index = self.uavs.get(uav).?.atom;
-    const sym_index = self.getAtom(this_atom_index).getSymbolIndex().?;
-    const atom_index = self.getAtomIndexForSymbol(.{
+    const this_atom_index = coff.uavs.get(uav).?.atom;
+    const sym_index = coff.getAtom(this_atom_index).getSymbolIndex().?;
+    const atom_index = coff.getAtomIndexForSymbol(.{
         .sym_index = reloc_info.parent.atom_index,
         .file = null,
     }).?;
     const target = SymbolWithLoc{ .sym_index = sym_index, .file = null };
-    try Atom.addRelocation(self, atom_index, .{
+    try coff.addRelocation(atom_index, .{
         .type = .direct,
         .target = target,
         .offset = @as(u32, @intCast(reloc_info.offset)),
@@ -1915,41 +2444,41 @@ pub fn getUavVAddr(
         .pcrel = false,
         .length = 3,
     });
-    try Atom.addBaseRelocation(self, atom_index, @as(u32, @intCast(reloc_info.offset)));
+    try coff.addBaseRelocation(atom_index, @as(u32, @intCast(reloc_info.offset)));
 
     return 0;
 }
 
-pub fn getGlobalSymbol(self: *Coff, name: []const u8, lib_name_name: ?[]const u8) !u32 {
-    const gop = try self.getOrPutGlobalPtr(name);
-    const global_index = self.getGlobalIndex(name).?;
+pub fn getGlobalSymbol(coff: *Coff, name: []const u8, lib_name_name: ?[]const u8) !u32 {
+    const gop = try coff.getOrPutGlobalPtr(name);
+    const global_index = coff.getGlobalIndex(name).?;
 
     if (gop.found_existing) {
         return global_index;
     }
 
-    const sym_index = try self.allocateSymbol();
+    const sym_index = try coff.allocateSymbol();
     const sym_loc = SymbolWithLoc{ .sym_index = sym_index, .file = null };
     gop.value_ptr.* = sym_loc;
 
-    const gpa = self.base.comp.gpa;
-    const sym = self.getSymbolPtr(sym_loc);
-    try self.setSymbolName(sym, name);
+    const gpa = coff.base.comp.gpa;
+    const sym = coff.getSymbolPtr(sym_loc);
+    try coff.setSymbolName(sym, name);
     sym.storage_class = .EXTERNAL;
 
     if (lib_name_name) |lib_name| {
         // We repurpose the 'value' of the Symbol struct to store an offset into
         // temporary string table where we will store the library name hint.
-        sym.value = try self.temp_strtab.insert(gpa, lib_name);
+        sym.value = try coff.temp_strtab.insert(gpa, lib_name);
     }
 
-    try self.unresolved.putNoClobber(gpa, global_index, true);
+    try coff.unresolved.putNoClobber(gpa, global_index, true);
 
     return global_index;
 }
 
-pub fn updateDeclLineNumber(self: *Coff, pt: Zcu.PerThread, decl_index: InternPool.DeclIndex) !void {
-    _ = self;
+pub fn updateDeclLineNumber(coff: *Coff, pt: Zcu.PerThread, decl_index: InternPool.DeclIndex) !void {
+    _ = coff;
     _ = pt;
     _ = decl_index;
     log.debug("TODO implement updateDeclLineNumber", .{});
@@ -1958,10 +2487,10 @@ pub fn updateDeclLineNumber(self: *Coff, pt: Zcu.PerThread, decl_index: InternPo
 /// TODO: note if we need to rewrite base relocations by dirtying any of the entries in the global table
 /// TODO: note that .ABSOLUTE is used as padding within each block; we could use this fact to do
 ///       incremental updates and writes into the table instead of doing it all at once
-fn writeBaseRelocations(self: *Coff) !void {
-    const gpa = self.base.comp.gpa;
+fn writeBaseRelocations(coff: *Coff) !void {
+    const gpa = coff.base.comp.gpa;
 
-    var page_table = std.AutoHashMap(u32, std.ArrayList(coff.BaseRelocation)).init(gpa);
+    var page_table = std.AutoHashMap(u32, std.ArrayList(coff_util.BaseRelocation)).init(gpa);
     defer {
         var it = page_table.valueIterator();
         while (it.next()) |inner| {
@@ -1971,19 +2500,19 @@ fn writeBaseRelocations(self: *Coff) !void {
     }
 
     {
-        var it = self.base_relocs.iterator();
+        var it = coff.base_relocs.iterator();
         while (it.next()) |entry| {
             const atom_index = entry.key_ptr.*;
-            const atom = self.getAtom(atom_index);
-            const sym = atom.getSymbol(self);
+            const atom = coff.getAtom(atom_index);
+            const sym = atom.getSymbol(coff);
             const offsets = entry.value_ptr.*;
 
             for (offsets.items) |offset| {
                 const rva = sym.value + offset;
-                const page = mem.alignBackward(u32, rva, self.page_size);
+                const page = mem.alignBackward(u32, rva, coff.page_size);
                 const gop = try page_table.getOrPut(page);
                 if (!gop.found_existing) {
-                    gop.value_ptr.* = std.ArrayList(coff.BaseRelocation).init(gpa);
+                    gop.value_ptr.* = std.ArrayList(coff_util.BaseRelocation).init(gpa);
                 }
                 try gop.value_ptr.append(.{
                     .offset = @as(u12, @intCast(rva - page)),
@@ -1993,18 +2522,18 @@ fn writeBaseRelocations(self: *Coff) !void {
         }
 
         {
-            const header = &self.sections.items(.header)[self.got_section_index.?];
-            for (self.got_table.entries.items, 0..) |entry, index| {
-                if (!self.got_table.lookup.contains(entry)) continue;
+            const header = &coff.sections.items(.header)[coff.got_section_index.?];
+            for (coff.got_table.entries.items, 0..) |entry, index| {
+                if (!coff.got_table.lookup.contains(entry)) continue;
 
-                const sym = self.getSymbol(entry);
+                const sym = coff.getSymbol(entry);
                 if (sym.section_number == .UNDEFINED) continue;
 
-                const rva = @as(u32, @intCast(header.virtual_address + index * self.ptr_width.size()));
-                const page = mem.alignBackward(u32, rva, self.page_size);
+                const rva = @as(u32, @intCast(header.virtual_address + index * coff.ptr_width.size()));
+                const page = mem.alignBackward(u32, rva, coff.page_size);
                 const gop = try page_table.getOrPut(page);
                 if (!gop.found_existing) {
-                    gop.value_ptr.* = std.ArrayList(coff.BaseRelocation).init(gpa);
+                    gop.value_ptr.* = std.ArrayList(coff_util.BaseRelocation).init(gpa);
                 }
                 try gop.value_ptr.append(.{
                     .offset = @as(u12, @intCast(rva - page)),
@@ -2033,7 +2562,7 @@ fn writeBaseRelocations(self: *Coff) !void {
         // Pad to required 4byte alignment
         if (!mem.isAlignedGeneric(
             usize,
-            entries.items.len * @sizeOf(coff.BaseRelocation),
+            entries.items.len * @sizeOf(coff_util.BaseRelocation),
             @sizeOf(u32),
         )) {
             try entries.append(.{
@@ -2044,58 +2573,58 @@ fn writeBaseRelocations(self: *Coff) !void {
 
         const block_size = @as(
             u32,
-            @intCast(entries.items.len * @sizeOf(coff.BaseRelocation) + @sizeOf(coff.BaseRelocationDirectoryEntry)),
+            @intCast(entries.items.len * @sizeOf(coff_util.BaseRelocation) + @sizeOf(coff_util.BaseRelocationDirectoryEntry)),
         );
         try buffer.ensureUnusedCapacity(block_size);
-        buffer.appendSliceAssumeCapacity(mem.asBytes(&coff.BaseRelocationDirectoryEntry{
+        buffer.appendSliceAssumeCapacity(mem.asBytes(&coff_util.BaseRelocationDirectoryEntry{
             .page_rva = page,
             .block_size = block_size,
         }));
         buffer.appendSliceAssumeCapacity(mem.sliceAsBytes(entries.items));
     }
 
-    const header = &self.sections.items(.header)[self.reloc_section_index.?];
+    const header = &coff.sections.items(.header)[coff.reloc_section_index.?];
     const needed_size = @as(u32, @intCast(buffer.items.len));
-    try self.growSection(self.reloc_section_index.?, needed_size);
+    try coff.growSection(coff.reloc_section_index.?, needed_size);
 
-    try self.base.file.?.pwriteAll(buffer.items, header.pointer_to_raw_data);
+    try coff.base.file.?.pwriteAll(buffer.items, header.pointer_to_raw_data);
 
-    self.data_directories[@intFromEnum(coff.DirectoryEntry.BASERELOC)] = .{
+    coff.data_directories[@intFromEnum(coff_util.DirectoryEntry.BASERELOC)] = .{
         .virtual_address = header.virtual_address,
         .size = needed_size,
     };
 }
 
-fn writeImportTables(self: *Coff) !void {
-    if (self.idata_section_index == null) return;
-    if (!self.imports_count_dirty) return;
+fn writeImportTables(coff: *Coff) !void {
+    if (coff.idata_section_index == null) return;
+    if (!coff.imports_count_dirty) return;
 
-    const gpa = self.base.comp.gpa;
+    const gpa = coff.base.comp.gpa;
 
     const ext = ".dll";
-    const header = &self.sections.items(.header)[self.idata_section_index.?];
+    const header = &coff.sections.items(.header)[coff.idata_section_index.?];
 
     // Calculate needed size
     var iat_size: u32 = 0;
-    var dir_table_size: u32 = @sizeOf(coff.ImportDirectoryEntry); // sentinel
+    var dir_table_size: u32 = @sizeOf(coff_util.ImportDirectoryEntry); // sentinel
     var lookup_table_size: u32 = 0;
     var names_table_size: u32 = 0;
     var dll_names_size: u32 = 0;
-    for (self.import_tables.keys(), 0..) |off, i| {
-        const lib_name = self.temp_strtab.getAssumeExists(off);
-        const itable = self.import_tables.values()[i];
+    for (coff.import_tables.keys(), 0..) |off, i| {
+        const lib_name = coff.temp_strtab.getAssumeExists(off);
+        const itable = coff.import_tables.values()[i];
         iat_size += itable.size() + 8;
-        dir_table_size += @sizeOf(coff.ImportDirectoryEntry);
-        lookup_table_size += @as(u32, @intCast(itable.entries.items.len + 1)) * @sizeOf(coff.ImportLookupEntry64.ByName);
+        dir_table_size += @sizeOf(coff_util.ImportDirectoryEntry);
+        lookup_table_size += @as(u32, @intCast(itable.entries.items.len + 1)) * @sizeOf(coff_util.ImportLookupEntry64.ByName);
         for (itable.entries.items) |entry| {
-            const sym_name = self.getSymbolName(entry);
+            const sym_name = coff.getSymbolName(entry);
             names_table_size += 2 + mem.alignForward(u32, @as(u32, @intCast(sym_name.len + 1)), 2);
         }
         dll_names_size += @as(u32, @intCast(lib_name.len + ext.len + 1));
     }
 
     const needed_size = iat_size + dir_table_size + lookup_table_size + names_table_size + dll_names_size;
-    try self.growSection(self.idata_section_index.?, needed_size);
+    try coff.growSection(coff.idata_section_index.?, needed_size);
 
     // Do the actual writes
     var buffer = std.ArrayList(u8).init(gpa);
@@ -2103,41 +2632,41 @@ fn writeImportTables(self: *Coff) !void {
     try buffer.ensureTotalCapacityPrecise(needed_size);
     buffer.resize(needed_size) catch unreachable;
 
-    const dir_header_size = @sizeOf(coff.ImportDirectoryEntry);
-    const lookup_entry_size = @sizeOf(coff.ImportLookupEntry64.ByName);
+    const dir_header_size = @sizeOf(coff_util.ImportDirectoryEntry);
+    const lookup_entry_size = @sizeOf(coff_util.ImportLookupEntry64.ByName);
 
     var iat_offset: u32 = 0;
     var dir_table_offset = iat_size;
     var lookup_table_offset = dir_table_offset + dir_table_size;
     var names_table_offset = lookup_table_offset + lookup_table_size;
     var dll_names_offset = names_table_offset + names_table_size;
-    for (self.import_tables.keys(), 0..) |off, i| {
-        const lib_name = self.temp_strtab.getAssumeExists(off);
-        const itable = self.import_tables.values()[i];
+    for (coff.import_tables.keys(), 0..) |off, i| {
+        const lib_name = coff.temp_strtab.getAssumeExists(off);
+        const itable = coff.import_tables.values()[i];
 
         // Lookup table header
-        const lookup_header = coff.ImportDirectoryEntry{
+        const lookup_header = coff_util.ImportDirectoryEntry{
             .import_lookup_table_rva = header.virtual_address + lookup_table_offset,
             .time_date_stamp = 0,
             .forwarder_chain = 0,
             .name_rva = header.virtual_address + dll_names_offset,
             .import_address_table_rva = header.virtual_address + iat_offset,
         };
-        @memcpy(buffer.items[dir_table_offset..][0..@sizeOf(coff.ImportDirectoryEntry)], mem.asBytes(&lookup_header));
+        @memcpy(buffer.items[dir_table_offset..][0..@sizeOf(coff_util.ImportDirectoryEntry)], mem.asBytes(&lookup_header));
         dir_table_offset += dir_header_size;
 
         for (itable.entries.items) |entry| {
-            const import_name = self.getSymbolName(entry);
+            const import_name = coff.getSymbolName(entry);
 
             // IAT and lookup table entry
-            const lookup = coff.ImportLookupEntry64.ByName{ .name_table_rva = @as(u31, @intCast(header.virtual_address + names_table_offset)) };
+            const lookup = coff_util.ImportLookupEntry64.ByName{ .name_table_rva = @as(u31, @intCast(header.virtual_address + names_table_offset)) };
             @memcpy(
-                buffer.items[iat_offset..][0..@sizeOf(coff.ImportLookupEntry64.ByName)],
+                buffer.items[iat_offset..][0..@sizeOf(coff_util.ImportLookupEntry64.ByName)],
                 mem.asBytes(&lookup),
             );
             iat_offset += lookup_entry_size;
             @memcpy(
-                buffer.items[lookup_table_offset..][0..@sizeOf(coff.ImportLookupEntry64.ByName)],
+                buffer.items[lookup_table_offset..][0..@sizeOf(coff_util.ImportLookupEntry64.ByName)],
                 mem.asBytes(&lookup),
             );
             lookup_table_offset += lookup_entry_size;
@@ -2161,8 +2690,8 @@ fn writeImportTables(self: *Coff) !void {
 
         // Lookup table sentinel
         @memcpy(
-            buffer.items[lookup_table_offset..][0..@sizeOf(coff.ImportLookupEntry64.ByName)],
-            mem.asBytes(&coff.ImportLookupEntry64.ByName{ .name_table_rva = 0 }),
+            buffer.items[lookup_table_offset..][0..@sizeOf(coff_util.ImportLookupEntry64.ByName)],
+            mem.asBytes(&coff_util.ImportLookupEntry64.ByName{ .name_table_rva = 0 }),
         );
         lookup_table_offset += lookup_entry_size;
 
@@ -2176,7 +2705,7 @@ fn writeImportTables(self: *Coff) !void {
     }
 
     // Sentinel
-    const lookup_header = coff.ImportDirectoryEntry{
+    const lookup_header = coff_util.ImportDirectoryEntry{
         .import_lookup_table_rva = 0,
         .time_date_stamp = 0,
         .forwarder_chain = 0,
@@ -2184,93 +2713,93 @@ fn writeImportTables(self: *Coff) !void {
         .import_address_table_rva = 0,
     };
     @memcpy(
-        buffer.items[dir_table_offset..][0..@sizeOf(coff.ImportDirectoryEntry)],
+        buffer.items[dir_table_offset..][0..@sizeOf(coff_util.ImportDirectoryEntry)],
         mem.asBytes(&lookup_header),
     );
     dir_table_offset += dir_header_size;
 
     assert(dll_names_offset == needed_size);
 
-    try self.base.file.?.pwriteAll(buffer.items, header.pointer_to_raw_data);
+    try coff.base.file.?.pwriteAll(buffer.items, header.pointer_to_raw_data);
 
-    self.data_directories[@intFromEnum(coff.DirectoryEntry.IMPORT)] = .{
+    coff.data_directories[@intFromEnum(coff_util.DirectoryEntry.IMPORT)] = .{
         .virtual_address = header.virtual_address + iat_size,
         .size = dir_table_size,
     };
-    self.data_directories[@intFromEnum(coff.DirectoryEntry.IAT)] = .{
+    coff.data_directories[@intFromEnum(coff_util.DirectoryEntry.IAT)] = .{
         .virtual_address = header.virtual_address,
         .size = iat_size,
     };
 
-    self.imports_count_dirty = false;
+    coff.imports_count_dirty = false;
 }
 
-fn writeStrtab(self: *Coff) !void {
-    if (self.strtab_offset == null) return;
+fn writeStrtab(coff: *Coff) !void {
+    if (coff.strtab_offset == null) return;
 
-    const allocated_size = self.allocatedSize(self.strtab_offset.?);
-    const needed_size = @as(u32, @intCast(self.strtab.buffer.items.len));
+    const allocated_size = coff.allocatedSize(coff.strtab_offset.?);
+    const needed_size = @as(u32, @intCast(coff.strtab.buffer.items.len));
 
     if (needed_size > allocated_size) {
-        self.strtab_offset = null;
-        self.strtab_offset = @as(u32, @intCast(self.findFreeSpace(needed_size, @alignOf(u32))));
+        coff.strtab_offset = null;
+        coff.strtab_offset = @as(u32, @intCast(coff.findFreeSpace(needed_size, @alignOf(u32))));
     }
 
-    log.debug("writing strtab from 0x{x} to 0x{x}", .{ self.strtab_offset.?, self.strtab_offset.? + needed_size });
+    log.debug("writing strtab from 0x{x} to 0x{x}", .{ coff.strtab_offset.?, coff.strtab_offset.? + needed_size });
 
-    const gpa = self.base.comp.gpa;
+    const gpa = coff.base.comp.gpa;
     var buffer = std.ArrayList(u8).init(gpa);
     defer buffer.deinit();
     try buffer.ensureTotalCapacityPrecise(needed_size);
-    buffer.appendSliceAssumeCapacity(self.strtab.buffer.items);
+    buffer.appendSliceAssumeCapacity(coff.strtab.buffer.items);
     // Here, we do a trick in that we do not commit the size of the strtab to strtab buffer, instead
     // we write the length of the strtab to a temporary buffer that goes to file.
-    mem.writeInt(u32, buffer.items[0..4], @as(u32, @intCast(self.strtab.buffer.items.len)), .little);
+    mem.writeInt(u32, buffer.items[0..4], @as(u32, @intCast(coff.strtab.buffer.items.len)), .little);
 
-    try self.base.file.?.pwriteAll(buffer.items, self.strtab_offset.?);
+    try coff.base.file.?.pwriteAll(buffer.items, coff.strtab_offset.?);
 }
 
-fn writeSectionHeaders(self: *Coff) !void {
-    const offset = self.getSectionHeadersOffset();
-    try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.sections.items(.header)), offset);
+fn writeSectionHeaders(coff: *Coff) !void {
+    const offset = coff.getSectionHeadersOffset();
+    try coff.base.file.?.pwriteAll(mem.sliceAsBytes(coff.sections.items(.header)), offset);
 }
 
-fn writeDataDirectoriesHeaders(self: *Coff) !void {
-    const offset = self.getDataDirectoryHeadersOffset();
-    try self.base.file.?.pwriteAll(mem.sliceAsBytes(&self.data_directories), offset);
+fn writeDataDirectoriesHeaders(coff: *Coff) !void {
+    const offset = coff.getDataDirectoryHeadersOffset();
+    try coff.base.file.?.pwriteAll(mem.sliceAsBytes(&coff.data_directories), offset);
 }
 
-fn writeHeader(self: *Coff) !void {
-    const target = self.base.comp.root_mod.resolved_target.result;
-    const gpa = self.base.comp.gpa;
+fn writeHeader(coff: *Coff) !void {
+    const target = coff.base.comp.root_mod.resolved_target.result;
+    const gpa = coff.base.comp.gpa;
     var buffer = std.ArrayList(u8).init(gpa);
     defer buffer.deinit();
     const writer = buffer.writer();
 
-    try buffer.ensureTotalCapacity(self.getSizeOfHeaders());
+    try buffer.ensureTotalCapacity(coff.getSizeOfHeaders());
     writer.writeAll(msdos_stub) catch unreachable;
     mem.writeInt(u32, buffer.items[0x3c..][0..4], msdos_stub.len, .little);
 
     writer.writeAll("PE\x00\x00") catch unreachable;
-    var flags = coff.CoffHeaderFlags{
+    var flags = coff_util.CoffHeaderFlags{
         .EXECUTABLE_IMAGE = 1,
         .DEBUG_STRIPPED = 1, // TODO
     };
-    switch (self.ptr_width) {
+    switch (coff.ptr_width) {
         .p32 => flags.@"32BIT_MACHINE" = 1,
         .p64 => flags.LARGE_ADDRESS_AWARE = 1,
     }
-    if (self.base.comp.config.output_mode == .Lib and self.base.comp.config.link_mode == .dynamic) {
+    if (coff.base.comp.config.output_mode == .Lib and coff.base.comp.config.link_mode == .dynamic) {
         flags.DLL = 1;
     }
 
-    const timestamp = if (self.repro) 0 else std.time.timestamp();
-    const size_of_optional_header = @as(u16, @intCast(self.getOptionalHeaderSize() + self.getDataDirectoryHeadersSize()));
-    var coff_header = coff.CoffHeader{
+    const timestamp = if (coff.repro) 0 else std.time.timestamp();
+    const size_of_optional_header = @as(u16, @intCast(coff.getOptionalHeaderSize() + coff.getDataDirectoryHeadersSize()));
+    var coff_header = coff_util.CoffHeader{
         .machine = target.toCoffMachine(),
-        .number_of_sections = @as(u16, @intCast(self.sections.slice().len)), // TODO what if we prune a section
+        .number_of_sections = @as(u16, @intCast(coff.sections.slice().len)), // TODO what if we prune a section
         .time_date_stamp = @as(u32, @truncate(@as(u64, @bitCast(timestamp)))),
-        .pointer_to_symbol_table = self.strtab_offset orelse 0,
+        .pointer_to_symbol_table = coff.strtab_offset orelse 0,
         .number_of_symbols = 0,
         .size_of_optional_header = size_of_optional_header,
         .flags = flags,
@@ -2278,22 +2807,22 @@ fn writeHeader(self: *Coff) !void {
 
     writer.writeAll(mem.asBytes(&coff_header)) catch unreachable;
 
-    const dll_flags: coff.DllFlags = .{
+    const dll_flags: coff_util.DllFlags = .{
         .HIGH_ENTROPY_VA = 1, // TODO do we want to permit non-PIE builds at all?
         .DYNAMIC_BASE = 1,
         .TERMINAL_SERVER_AWARE = 1, // We are not a legacy app
         .NX_COMPAT = 1, // We are compatible with Data Execution Prevention
     };
-    const subsystem: coff.Subsystem = .WINDOWS_CUI;
-    const size_of_image: u32 = self.getSizeOfImage();
-    const size_of_headers: u32 = mem.alignForward(u32, self.getSizeOfHeaders(), default_file_alignment);
-    const base_of_code = self.sections.get(self.text_section_index.?).header.virtual_address;
-    const base_of_data = self.sections.get(self.data_section_index.?).header.virtual_address;
+    const subsystem: coff_util.Subsystem = .WINDOWS_CUI;
+    const size_of_image: u32 = coff.getSizeOfImage();
+    const size_of_headers: u32 = mem.alignForward(u32, coff.getSizeOfHeaders(), default_file_alignment);
+    const base_of_code = coff.sections.get(coff.text_section_index.?).header.virtual_address;
+    const base_of_data = coff.sections.get(coff.data_section_index.?).header.virtual_address;
 
     var size_of_code: u32 = 0;
     var size_of_initialized_data: u32 = 0;
     var size_of_uninitialized_data: u32 = 0;
-    for (self.sections.items(.header)) |header| {
+    for (coff.sections.items(.header)) |header| {
         if (header.flags.CNT_CODE == 1) {
             size_of_code += header.size_of_raw_data;
         }
@@ -2305,27 +2834,27 @@ fn writeHeader(self: *Coff) !void {
         }
     }
 
-    switch (self.ptr_width) {
+    switch (coff.ptr_width) {
         .p32 => {
-            var opt_header = coff.OptionalHeaderPE32{
-                .magic = coff.IMAGE_NT_OPTIONAL_HDR32_MAGIC,
+            var opt_header = coff_util.OptionalHeaderPE32{
+                .magic = coff_util.IMAGE_NT_OPTIONAL_HDR32_MAGIC,
                 .major_linker_version = 0,
                 .minor_linker_version = 0,
                 .size_of_code = size_of_code,
                 .size_of_initialized_data = size_of_initialized_data,
                 .size_of_uninitialized_data = size_of_uninitialized_data,
-                .address_of_entry_point = self.entry_addr orelse 0,
+                .address_of_entry_point = coff.entry_addr orelse 0,
                 .base_of_code = base_of_code,
                 .base_of_data = base_of_data,
-                .image_base = @intCast(self.image_base),
-                .section_alignment = self.page_size,
+                .image_base = @intCast(coff.image_base),
+                .section_alignment = coff.page_size,
                 .file_alignment = default_file_alignment,
                 .major_operating_system_version = 6,
                 .minor_operating_system_version = 0,
                 .major_image_version = 0,
                 .minor_image_version = 0,
-                .major_subsystem_version = @intCast(self.major_subsystem_version),
-                .minor_subsystem_version = @intCast(self.minor_subsystem_version),
+                .major_subsystem_version = @intCast(coff.major_subsystem_version),
+                .minor_subsystem_version = @intCast(coff.minor_subsystem_version),
                 .win32_version_value = 0,
                 .size_of_image = size_of_image,
                 .size_of_headers = size_of_headers,
@@ -2337,29 +2866,29 @@ fn writeHeader(self: *Coff) !void {
                 .size_of_heap_reserve = default_size_of_heap_reserve,
                 .size_of_heap_commit = default_size_of_heap_commit,
                 .loader_flags = 0,
-                .number_of_rva_and_sizes = @intCast(self.data_directories.len),
+                .number_of_rva_and_sizes = @intCast(coff.data_directories.len),
             };
             writer.writeAll(mem.asBytes(&opt_header)) catch unreachable;
         },
         .p64 => {
-            var opt_header = coff.OptionalHeaderPE64{
-                .magic = coff.IMAGE_NT_OPTIONAL_HDR64_MAGIC,
+            var opt_header = coff_util.OptionalHeaderPE64{
+                .magic = coff_util.IMAGE_NT_OPTIONAL_HDR64_MAGIC,
                 .major_linker_version = 0,
                 .minor_linker_version = 0,
                 .size_of_code = size_of_code,
                 .size_of_initialized_data = size_of_initialized_data,
                 .size_of_uninitialized_data = size_of_uninitialized_data,
-                .address_of_entry_point = self.entry_addr orelse 0,
+                .address_of_entry_point = coff.entry_addr orelse 0,
                 .base_of_code = base_of_code,
-                .image_base = self.image_base,
-                .section_alignment = self.page_size,
+                .image_base = coff.image_base,
+                .section_alignment = coff.page_size,
                 .file_alignment = default_file_alignment,
                 .major_operating_system_version = 6,
                 .minor_operating_system_version = 0,
                 .major_image_version = 0,
                 .minor_image_version = 0,
-                .major_subsystem_version = self.major_subsystem_version,
-                .minor_subsystem_version = self.minor_subsystem_version,
+                .major_subsystem_version = coff.major_subsystem_version,
+                .minor_subsystem_version = coff.minor_subsystem_version,
                 .win32_version_value = 0,
                 .size_of_image = size_of_image,
                 .size_of_headers = size_of_headers,
@@ -2371,28 +2900,28 @@ fn writeHeader(self: *Coff) !void {
                 .size_of_heap_reserve = default_size_of_heap_reserve,
                 .size_of_heap_commit = default_size_of_heap_commit,
                 .loader_flags = 0,
-                .number_of_rva_and_sizes = @intCast(self.data_directories.len),
+                .number_of_rva_and_sizes = @intCast(coff.data_directories.len),
             };
             writer.writeAll(mem.asBytes(&opt_header)) catch unreachable;
         },
     }
 
-    try self.base.file.?.pwriteAll(buffer.items, 0);
+    try coff.base.file.?.pwriteAll(buffer.items, 0);
 }
 
 pub fn padToIdeal(actual_size: anytype) @TypeOf(actual_size) {
     return actual_size +| (actual_size / ideal_factor);
 }
 
-fn detectAllocCollision(self: *Coff, start: u32, size: u32) ?u32 {
-    const headers_size = @max(self.getSizeOfHeaders(), self.page_size);
+fn detectAllocCollision(coff: *Coff, start: u32, size: u32) ?u32 {
+    const headers_size = @max(coff.getSizeOfHeaders(), coff.page_size);
     if (start < headers_size)
         return headers_size;
 
     const end = start + padToIdeal(size);
 
-    if (self.strtab_offset) |off| {
-        const tight_size = @as(u32, @intCast(self.strtab.buffer.items.len));
+    if (coff.strtab_offset) |off| {
+        const tight_size = @as(u32, @intCast(coff.strtab.buffer.items.len));
         const increased_size = padToIdeal(tight_size);
         const test_end = off + increased_size;
         if (end > off and start < test_end) {
@@ -2400,7 +2929,7 @@ fn detectAllocCollision(self: *Coff, start: u32, size: u32) ?u32 {
         }
     }
 
-    for (self.sections.items(.header)) |header| {
+    for (coff.sections.items(.header)) |header| {
         const tight_size = header.size_of_raw_data;
         const increased_size = padToIdeal(tight_size);
         const test_end = header.pointer_to_raw_data + increased_size;
@@ -2412,86 +2941,86 @@ fn detectAllocCollision(self: *Coff, start: u32, size: u32) ?u32 {
     return null;
 }
 
-fn allocatedSize(self: *Coff, start: u32) u32 {
+fn allocatedSize(coff: *Coff, start: u32) u32 {
     if (start == 0)
         return 0;
     var min_pos: u32 = std.math.maxInt(u32);
-    if (self.strtab_offset) |off| {
+    if (coff.strtab_offset) |off| {
         if (off > start and off < min_pos) min_pos = off;
     }
-    for (self.sections.items(.header)) |header| {
+    for (coff.sections.items(.header)) |header| {
         if (header.pointer_to_raw_data <= start) continue;
         if (header.pointer_to_raw_data < min_pos) min_pos = header.pointer_to_raw_data;
     }
     return min_pos - start;
 }
 
-fn findFreeSpace(self: *Coff, object_size: u32, min_alignment: u32) u32 {
+fn findFreeSpace(coff: *Coff, object_size: u32, min_alignment: u32) u32 {
     var start: u32 = 0;
-    while (self.detectAllocCollision(start, object_size)) |item_end| {
+    while (coff.detectAllocCollision(start, object_size)) |item_end| {
         start = mem.alignForward(u32, item_end, min_alignment);
     }
     return start;
 }
 
-fn allocatedVirtualSize(self: *Coff, start: u32) u32 {
+fn allocatedVirtualSize(coff: *Coff, start: u32) u32 {
     if (start == 0)
         return 0;
     var min_pos: u32 = std.math.maxInt(u32);
-    for (self.sections.items(.header)) |header| {
+    for (coff.sections.items(.header)) |header| {
         if (header.virtual_address <= start) continue;
         if (header.virtual_address < min_pos) min_pos = header.virtual_address;
     }
     return min_pos - start;
 }
 
-inline fn getSizeOfHeaders(self: Coff) u32 {
+fn getSizeOfHeaders(coff: Coff) u32 {
     const msdos_hdr_size = msdos_stub.len + 4;
-    return @as(u32, @intCast(msdos_hdr_size + @sizeOf(coff.CoffHeader) + self.getOptionalHeaderSize() +
-        self.getDataDirectoryHeadersSize() + self.getSectionHeadersSize()));
+    return @as(u32, @intCast(msdos_hdr_size + @sizeOf(coff_util.CoffHeader) + coff.getOptionalHeaderSize() +
+        coff.getDataDirectoryHeadersSize() + coff.getSectionHeadersSize()));
 }
 
-inline fn getOptionalHeaderSize(self: Coff) u32 {
-    return switch (self.ptr_width) {
-        .p32 => @as(u32, @intCast(@sizeOf(coff.OptionalHeaderPE32))),
-        .p64 => @as(u32, @intCast(@sizeOf(coff.OptionalHeaderPE64))),
+fn getOptionalHeaderSize(coff: Coff) u32 {
+    return switch (coff.ptr_width) {
+        .p32 => @as(u32, @intCast(@sizeOf(coff_util.OptionalHeaderPE32))),
+        .p64 => @as(u32, @intCast(@sizeOf(coff_util.OptionalHeaderPE64))),
     };
 }
 
-inline fn getDataDirectoryHeadersSize(self: Coff) u32 {
-    return @as(u32, @intCast(self.data_directories.len * @sizeOf(coff.ImageDataDirectory)));
+fn getDataDirectoryHeadersSize(coff: Coff) u32 {
+    return @as(u32, @intCast(coff.data_directories.len * @sizeOf(coff_util.ImageDataDirectory)));
 }
 
-inline fn getSectionHeadersSize(self: Coff) u32 {
-    return @as(u32, @intCast(self.sections.slice().len * @sizeOf(coff.SectionHeader)));
+fn getSectionHeadersSize(coff: Coff) u32 {
+    return @as(u32, @intCast(coff.sections.slice().len * @sizeOf(coff_util.SectionHeader)));
 }
 
-inline fn getDataDirectoryHeadersOffset(self: Coff) u32 {
+fn getDataDirectoryHeadersOffset(coff: Coff) u32 {
     const msdos_hdr_size = msdos_stub.len + 4;
-    return @as(u32, @intCast(msdos_hdr_size + @sizeOf(coff.CoffHeader) + self.getOptionalHeaderSize()));
+    return @as(u32, @intCast(msdos_hdr_size + @sizeOf(coff_util.CoffHeader) + coff.getOptionalHeaderSize()));
 }
 
-inline fn getSectionHeadersOffset(self: Coff) u32 {
-    return self.getDataDirectoryHeadersOffset() + self.getDataDirectoryHeadersSize();
+fn getSectionHeadersOffset(coff: Coff) u32 {
+    return coff.getDataDirectoryHeadersOffset() + coff.getDataDirectoryHeadersSize();
 }
 
-inline fn getSizeOfImage(self: Coff) u32 {
-    var image_size: u32 = mem.alignForward(u32, self.getSizeOfHeaders(), self.page_size);
-    for (self.sections.items(.header)) |header| {
-        image_size += mem.alignForward(u32, header.virtual_size, self.page_size);
+fn getSizeOfImage(coff: Coff) u32 {
+    var image_size: u32 = mem.alignForward(u32, coff.getSizeOfHeaders(), coff.page_size);
+    for (coff.sections.items(.header)) |header| {
+        image_size += mem.alignForward(u32, header.virtual_size, coff.page_size);
     }
     return image_size;
 }
 
 /// Returns symbol location corresponding to the set entrypoint (if any).
-pub fn getEntryPoint(self: Coff) ?SymbolWithLoc {
-    const comp = self.base.comp;
+pub fn getEntryPoint(coff: Coff) ?SymbolWithLoc {
+    const comp = coff.base.comp;
 
     // TODO This is incomplete.
     // The entry symbol name depends on the subsystem as well as the set of
     // public symbol names from linked objects.
     // See LinkerDriver::findDefaultEntry from the LLD project for the flow chart.
-    const entry_name = switch (self.entry) {
+    const entry_name = switch (coff.entry) {
         .disabled => return null,
         .default => switch (comp.config.output_mode) {
             .Exe => "wWinMainCRTStartup",
@@ -2500,51 +3029,51 @@ pub fn getEntryPoint(self: Coff) ?SymbolWithLoc {
         .enabled => "wWinMainCRTStartup",
         .named => |name| name,
     };
-    const global_index = self.resolver.get(entry_name) orelse return null;
-    return self.globals.items[global_index];
+    const global_index = coff.resolver.get(entry_name) orelse return null;
+    return coff.globals.items[global_index];
 }
 
 /// Returns pointer-to-symbol described by `sym_loc` descriptor.
-pub fn getSymbolPtr(self: *Coff, sym_loc: SymbolWithLoc) *coff.Symbol {
+pub fn getSymbolPtr(coff: *Coff, sym_loc: SymbolWithLoc) *coff_util.Symbol {
     assert(sym_loc.file == null); // TODO linking object files
-    return &self.locals.items[sym_loc.sym_index];
+    return &coff.locals.items[sym_loc.sym_index];
 }
 
 /// Returns symbol described by `sym_loc` descriptor.
-pub fn getSymbol(self: *const Coff, sym_loc: SymbolWithLoc) *const coff.Symbol {
+pub fn getSymbol(coff: *const Coff, sym_loc: SymbolWithLoc) *const coff_util.Symbol {
     assert(sym_loc.file == null); // TODO linking object files
-    return &self.locals.items[sym_loc.sym_index];
+    return &coff.locals.items[sym_loc.sym_index];
 }
 
 /// Returns name of the symbol described by `sym_loc` descriptor.
-pub fn getSymbolName(self: *const Coff, sym_loc: SymbolWithLoc) []const u8 {
+pub fn getSymbolName(coff: *const Coff, sym_loc: SymbolWithLoc) []const u8 {
     assert(sym_loc.file == null); // TODO linking object files
-    const sym = self.getSymbol(sym_loc);
+    const sym = coff.getSymbol(sym_loc);
     const offset = sym.getNameOffset() orelse return sym.getName().?;
-    return self.strtab.get(offset).?;
+    return coff.strtab.get(offset).?;
 }
 
 /// Returns pointer to the global entry for `name` if one exists.
-pub fn getGlobalPtr(self: *Coff, name: []const u8) ?*SymbolWithLoc {
-    const global_index = self.resolver.get(name) orelse return null;
-    return &self.globals.items[global_index];
+pub fn getGlobalPtr(coff: *Coff, name: []const u8) ?*SymbolWithLoc {
+    const global_index = coff.resolver.get(name) orelse return null;
+    return &coff.globals.items[global_index];
 }
 
 /// Returns the global entry for `name` if one exists.
-pub fn getGlobal(self: *const Coff, name: []const u8) ?SymbolWithLoc {
-    const global_index = self.resolver.get(name) orelse return null;
-    return self.globals.items[global_index];
+pub fn getGlobal(coff: *const Coff, name: []const u8) ?SymbolWithLoc {
+    const global_index = coff.resolver.get(name) orelse return null;
+    return coff.globals.items[global_index];
 }
 
 /// Returns the index of the global entry for `name` if one exists.
-pub fn getGlobalIndex(self: *const Coff, name: []const u8) ?u32 {
-    return self.resolver.get(name);
+pub fn getGlobalIndex(coff: *const Coff, name: []const u8) ?u32 {
+    return coff.resolver.get(name);
 }
 
 /// Returns global entry at `index`.
-pub fn getGlobalByIndex(self: *const Coff, index: u32) SymbolWithLoc {
-    assert(index < self.globals.items.len);
-    return self.globals.items[index];
+pub fn getGlobalByIndex(coff: *const Coff, index: u32) SymbolWithLoc {
+    assert(index < coff.globals.items.len);
+    return coff.globals.items[index];
 }
 
 const GetOrPutGlobalPtrResult = struct {
@@ -2560,68 +3089,68 @@ pub const global_symbol_mask: u32 = 0x7fffffff;
 /// Return pointer to the global entry for `name` if one exists.
 /// Puts a new global entry for `name` if one doesn't exist, and
 /// returns a pointer to it.
-pub fn getOrPutGlobalPtr(self: *Coff, name: []const u8) !GetOrPutGlobalPtrResult {
-    if (self.getGlobalPtr(name)) |ptr| {
+pub fn getOrPutGlobalPtr(coff: *Coff, name: []const u8) !GetOrPutGlobalPtrResult {
+    if (coff.getGlobalPtr(name)) |ptr| {
         return GetOrPutGlobalPtrResult{ .found_existing = true, .value_ptr = ptr };
     }
-    const gpa = self.base.comp.gpa;
-    const global_index = try self.allocateGlobal();
+    const gpa = coff.base.comp.gpa;
+    const global_index = try coff.allocateGlobal();
     const global_name = try gpa.dupe(u8, name);
-    _ = try self.resolver.put(gpa, global_name, global_index);
-    const ptr = &self.globals.items[global_index];
+    _ = try coff.resolver.put(gpa, global_name, global_index);
+    const ptr = &coff.globals.items[global_index];
     return GetOrPutGlobalPtrResult{ .found_existing = false, .value_ptr = ptr };
 }
 
-pub fn getAtom(self: *const Coff, atom_index: Atom.Index) Atom {
-    assert(atom_index < self.atoms.items.len);
-    return self.atoms.items[atom_index];
+pub fn getAtom(coff: *const Coff, atom_index: Atom.Index) Atom {
+    assert(atom_index < coff.atoms.items.len);
+    return coff.atoms.items[atom_index];
 }
 
-pub fn getAtomPtr(self: *Coff, atom_index: Atom.Index) *Atom {
-    assert(atom_index < self.atoms.items.len);
-    return &self.atoms.items[atom_index];
+pub fn getAtomPtr(coff: *Coff, atom_index: Atom.Index) *Atom {
+    assert(atom_index < coff.atoms.items.len);
+    return &coff.atoms.items[atom_index];
 }
 
 /// Returns atom if there is an atom referenced by the symbol described by `sym_loc` descriptor.
 /// Returns null on failure.
-pub fn getAtomIndexForSymbol(self: *const Coff, sym_loc: SymbolWithLoc) ?Atom.Index {
+pub fn getAtomIndexForSymbol(coff: *const Coff, sym_loc: SymbolWithLoc) ?Atom.Index {
     assert(sym_loc.file == null); // TODO linking with object files
-    return self.atom_by_index_table.get(sym_loc.sym_index);
+    return coff.atom_by_index_table.get(sym_loc.sym_index);
 }
 
-fn setSectionName(self: *Coff, header: *coff.SectionHeader, name: []const u8) !void {
+fn setSectionName(coff: *Coff, header: *coff_util.SectionHeader, name: []const u8) !void {
     if (name.len <= 8) {
         @memcpy(header.name[0..name.len], name);
         @memset(header.name[name.len..], 0);
         return;
     }
-    const gpa = self.base.comp.gpa;
-    const offset = try self.strtab.insert(gpa, name);
+    const gpa = coff.base.comp.gpa;
+    const offset = try coff.strtab.insert(gpa, name);
     const name_offset = fmt.bufPrint(&header.name, "/{d}", .{offset}) catch unreachable;
     @memset(header.name[name_offset.len..], 0);
 }
 
-fn getSectionName(self: *const Coff, header: *const coff.SectionHeader) []const u8 {
+fn getSectionName(coff: *const Coff, header: *const coff_util.SectionHeader) []const u8 {
     if (header.getName()) |name| {
         return name;
     }
     const offset = header.getNameOffset().?;
-    return self.strtab.get(offset).?;
+    return coff.strtab.get(offset).?;
 }
 
-fn setSymbolName(self: *Coff, symbol: *coff.Symbol, name: []const u8) !void {
+fn setSymbolName(coff: *Coff, symbol: *coff_util.Symbol, name: []const u8) !void {
     if (name.len <= 8) {
         @memcpy(symbol.name[0..name.len], name);
         @memset(symbol.name[name.len..], 0);
         return;
     }
-    const gpa = self.base.comp.gpa;
-    const offset = try self.strtab.insert(gpa, name);
+    const gpa = coff.base.comp.gpa;
+    const offset = try coff.strtab.insert(gpa, name);
     @memset(symbol.name[0..4], 0);
     mem.writeInt(u32, symbol.name[4..8], offset, .little);
 }
 
-fn logSymAttributes(sym: *const coff.Symbol, buf: *[4]u8) []const u8 {
+fn logSymAttributes(sym: *const coff_util.Symbol, buf: *[4]u8) []const u8 {
     @memset(buf[0..4], '_');
     switch (sym.section_number) {
         .UNDEFINED => {
@@ -2648,12 +3177,12 @@ fn logSymAttributes(sym: *const coff.Symbol, buf: *[4]u8) []const u8 {
     return buf[0..];
 }
 
-fn logSymtab(self: *Coff) void {
+fn logSymtab(coff: *Coff) void {
     var buf: [4]u8 = undefined;
 
     log.debug("symtab:", .{});
     log.debug("  object(null)", .{});
-    for (self.locals.items, 0..) |*sym, sym_id| {
+    for (coff.locals.items, 0..) |*sym, sym_id| {
         const where = if (sym.section_number == .UNDEFINED) "ord" else "sect";
         const def_index: u16 = switch (sym.section_number) {
             .UNDEFINED => 0, // TODO
@@ -2663,7 +3192,7 @@ fn logSymtab(self: *Coff) void {
         };
         log.debug("    %{d}: {?s} @{x} in {s}({d}), {s}", .{
             sym_id,
-            self.getSymbolName(.{ .sym_index = @as(u32, @intCast(sym_id)), .file = null }),
+            coff.getSymbolName(.{ .sym_index = @as(u32, @intCast(sym_id)), .file = null }),
             sym.value,
             where,
             def_index,
@@ -2672,20 +3201,20 @@ fn logSymtab(self: *Coff) void {
     }
 
     log.debug("globals table:", .{});
-    for (self.globals.items) |sym_loc| {
-        const sym_name = self.getSymbolName(sym_loc);
+    for (coff.globals.items) |sym_loc| {
+        const sym_name = coff.getSymbolName(sym_loc);
         log.debug("  {s} => %{d} in object({?d})", .{ sym_name, sym_loc.sym_index, sym_loc.file });
     }
 
     log.debug("GOT entries:", .{});
-    log.debug("{}", .{self.got_table});
+    log.debug("{}", .{coff.got_table});
 }
 
-fn logSections(self: *Coff) void {
+fn logSections(coff: *Coff) void {
     log.debug("sections:", .{});
-    for (self.sections.items(.header)) |*header| {
+    for (coff.sections.items(.header)) |*header| {
         log.debug("  {s}: VM({x}, {x}) FILE({x}, {x})", .{
-            self.getSectionName(header),
+            coff.getSectionName(header),
             header.virtual_address,
             header.virtual_address + header.virtual_size,
             header.pointer_to_raw_data,
@@ -2694,49 +3223,517 @@ fn logSections(self: *Coff) void {
     }
 }
 
-fn logImportTables(self: *const Coff) void {
+fn logImportTables(coff: *const Coff) void {
     log.debug("import tables:", .{});
-    for (self.import_tables.keys(), 0..) |off, i| {
-        const itable = self.import_tables.values()[i];
+    for (coff.import_tables.keys(), 0..) |off, i| {
+        const itable = coff.import_tables.values()[i];
         log.debug("{}", .{itable.fmtDebug(.{
-            .coff_file = self,
+            .coff = coff,
             .index = i,
             .name_off = off,
         })});
     }
 }
 
+pub const Atom = struct {
+    /// Each decl always gets a local symbol with the fully qualified name.
+    /// The vaddr and size are found here directly.
+    /// The file offset is found by computing the vaddr offset from the section vaddr
+    /// the symbol references, and adding that to the file offset of the section.
+    /// If this field is 0, it means the codegen size = 0 and there is no symbol or
+    /// offset table entry.
+    sym_index: u32,
+
+    /// null means symbol defined by Zig source.
+    file: ?u32,
+
+    /// Size of the atom
+    size: u32,
+
+    /// Points to the previous and next neighbors, based on the `text_offset`.
+    /// This can be used to find, for example, the capacity of this `Atom`.
+    prev_index: ?Index,
+    next_index: ?Index,
+
+    const Index = u32;
+
+    pub fn getSymbolIndex(atom: Atom) ?u32 {
+        if (atom.sym_index == 0) return null;
+        return atom.sym_index;
+    }
+
+    /// Returns symbol referencing this atom.
+    fn getSymbol(atom: Atom, coff: *const Coff) *const coff_util.Symbol {
+        const sym_index = atom.getSymbolIndex().?;
+        return coff.getSymbol(.{
+            .sym_index = sym_index,
+            .file = atom.file,
+        });
+    }
+
+    /// Returns pointer-to-symbol referencing this atom.
+    fn getSymbolPtr(atom: Atom, coff: *Coff) *coff_util.Symbol {
+        const sym_index = atom.getSymbolIndex().?;
+        return coff.getSymbolPtr(.{
+            .sym_index = sym_index,
+            .file = atom.file,
+        });
+    }
+
+    fn getSymbolWithLoc(atom: Atom) SymbolWithLoc {
+        const sym_index = atom.getSymbolIndex().?;
+        return .{ .sym_index = sym_index, .file = atom.file };
+    }
+
+    /// Returns the name of this atom.
+    fn getName(atom: Atom, coff: *const Coff) []const u8 {
+        const sym_index = atom.getSymbolIndex().?;
+        return coff.getSymbolName(.{
+            .sym_index = sym_index,
+            .file = atom.file,
+        });
+    }
+
+    /// Returns how much room there is to grow in virtual address space.
+    fn capacity(atom: Atom, coff: *const Coff) u32 {
+        const atom_sym = atom.getSymbol(coff);
+        if (atom.next_index) |next_index| {
+            const next = coff.getAtom(next_index);
+            const next_sym = next.getSymbol(coff);
+            return next_sym.value - atom_sym.value;
+        } else {
+            // We are the last atom.
+            // The capacity is limited only by virtual address space.
+            return std.math.maxInt(u32) - atom_sym.value;
+        }
+    }
+
+    fn freeListEligible(atom: Atom, coff: *const Coff) bool {
+        // No need to keep a free list node for the last atom.
+        const next_index = atom.next_index orelse return false;
+        const next = coff.getAtom(next_index);
+        const atom_sym = atom.getSymbol(coff);
+        const next_sym = next.getSymbol(coff);
+        const cap = next_sym.value - atom_sym.value;
+        const ideal_cap = padToIdeal(atom.size);
+        if (cap <= ideal_cap) return false;
+        const surplus = cap - ideal_cap;
+        return surplus >= min_text_capacity;
+    }
+};
+
+pub const Relocation = struct {
+    type: enum {
+        // x86, x86_64
+        /// RIP-relative displacement to a GOT pointer
+        got,
+        /// RIP-relative displacement to an import pointer
+        import,
+
+        // aarch64
+        /// PC-relative distance to target page in GOT section
+        got_page,
+        /// Offset to a GOT pointer relative to the start of a page in GOT section
+        got_pageoff,
+        /// PC-relative distance to target page in a section (e.g., .rdata)
+        page,
+        /// Offset to a pointer relative to the start of a page in a section (e.g., .rdata)
+        pageoff,
+        /// PC-relative distance to target page in a import section
+        import_page,
+        /// Offset to a pointer relative to the start of a page in an import section (e.g., .rdata)
+        import_pageoff,
+
+        // common
+        /// Absolute pointer value
+        direct,
+    },
+    target: SymbolWithLoc,
+    offset: u32,
+    addend: u32,
+    pcrel: bool,
+    length: u2,
+    dirty: bool = true,
+
+    /// Returns true if and only if the reloc can be resolved.
+    fn isResolvable(reloc: Relocation, coff: *Coff) bool {
+        _ = reloc.getTargetAddress(coff) orelse return false;
+        return true;
+    }
+
+    fn isGotIndirection(reloc: Relocation) bool {
+        return switch (reloc.type) {
+            .got, .got_page, .got_pageoff => true,
+            else => false,
+        };
+    }
+
+    /// Returns address of the target if any.
+    fn getTargetAddress(reloc: Relocation, coff: *const Coff) ?u32 {
+        switch (reloc.type) {
+            .got, .got_page, .got_pageoff => {
+                const got_index = coff.got_table.lookup.get(reloc.target) orelse return null;
+                const header = coff.sections.items(.header)[coff.got_section_index.?];
+                return header.virtual_address + got_index * coff.ptr_width.size();
+            },
+            .import, .import_page, .import_pageoff => {
+                const sym = coff.getSymbol(reloc.target);
+                const index = coff.import_tables.getIndex(sym.value) orelse return null;
+                const itab = coff.import_tables.values()[index];
+                return itab.getImportAddress(reloc.target, .{
+                    .coff = coff,
+                    .index = index,
+                    .name_off = sym.value,
+                });
+            },
+            else => {
+                const target_atom_index = coff.getAtomIndexForSymbol(reloc.target) orelse return null;
+                const target_atom = coff.getAtom(target_atom_index);
+                return target_atom.getSymbol(coff).value;
+            },
+        }
+    }
+
+    fn resolve(reloc: Relocation, atom_index: Atom.Index, code: []u8, image_base: u64, coff: *Coff) void {
+        const atom = coff.getAtom(atom_index);
+        const source_sym = atom.getSymbol(coff);
+        const source_vaddr = source_sym.value + reloc.offset;
+
+        const target_vaddr = reloc.getTargetAddress(coff).?; // Oops, you didn't check if the relocation can be resolved with isResolvable().
+        const target_vaddr_with_addend = target_vaddr + reloc.addend;
+
+        log.debug("  ({x}: [() => 0x{x} ({s})) ({s}) ", .{
+            source_vaddr,
+            target_vaddr_with_addend,
+            coff.getSymbolName(reloc.target),
+            @tagName(reloc.type),
+        });
+
+        const ctx: Context = .{
+            .source_vaddr = source_vaddr,
+            .target_vaddr = target_vaddr_with_addend,
+            .image_base = image_base,
+            .code = code,
+            .ptr_width = coff.ptr_width,
+        };
+
+        const target = coff.base.comp.root_mod.resolved_target.result;
+        switch (target.cpu.arch) {
+            .aarch64 => reloc.resolveAarch64(ctx),
+            .x86, .x86_64 => reloc.resolveX86(ctx),
+            else => unreachable, // unhandled target architecture
+        }
+    }
+
+    const Context = struct {
+        source_vaddr: u32,
+        target_vaddr: u32,
+        image_base: u64,
+        code: []u8,
+        ptr_width: PtrWidth,
+    };
+
+    fn resolveAarch64(reloc: Relocation, ctx: Context) void {
+        var buffer = ctx.code[reloc.offset..];
+        switch (reloc.type) {
+            .got_page, .import_page, .page => {
+                const source_page = @as(i32, @intCast(ctx.source_vaddr >> 12));
+                const target_page = @as(i32, @intCast(ctx.target_vaddr >> 12));
+                const pages = @as(u21, @bitCast(@as(i21, @intCast(target_page - source_page))));
+                var inst = aarch64_util.Instruction{
+                    .pc_relative_address = mem.bytesToValue(std.meta.TagPayload(
+                        aarch64_util.Instruction,
+                        aarch64_util.Instruction.pc_relative_address,
+                    ), buffer[0..4]),
+                };
+                inst.pc_relative_address.immhi = @as(u19, @truncate(pages >> 2));
+                inst.pc_relative_address.immlo = @as(u2, @truncate(pages));
+                mem.writeInt(u32, buffer[0..4], inst.toU32(), .little);
+            },
+            .got_pageoff, .import_pageoff, .pageoff => {
+                assert(!reloc.pcrel);
+
+                const narrowed = @as(u12, @truncate(@as(u64, @intCast(ctx.target_vaddr))));
+                if (isArithmeticOp(buffer[0..4])) {
+                    var inst = aarch64_util.Instruction{
+                        .add_subtract_immediate = mem.bytesToValue(std.meta.TagPayload(
+                            aarch64_util.Instruction,
+                            aarch64_util.Instruction.add_subtract_immediate,
+                        ), buffer[0..4]),
+                    };
+                    inst.add_subtract_immediate.imm12 = narrowed;
+                    mem.writeInt(u32, buffer[0..4], inst.toU32(), .little);
+                } else {
+                    var inst = aarch64_util.Instruction{
+                        .load_store_register = mem.bytesToValue(std.meta.TagPayload(
+                            aarch64_util.Instruction,
+                            aarch64_util.Instruction.load_store_register,
+                        ), buffer[0..4]),
+                    };
+                    const offset: u12 = blk: {
+                        if (inst.load_store_register.size == 0) {
+                            if (inst.load_store_register.v == 1) {
+                                // 128-bit SIMD is scaled by 16.
+                                break :blk @divExact(narrowed, 16);
+                            }
+                            // Otherwise, 8-bit SIMD or ldrb.
+                            break :blk narrowed;
+                        } else {
+                            const denom: u4 = math.powi(u4, 2, inst.load_store_register.size) catch unreachable;
+                            break :blk @divExact(narrowed, denom);
+                        }
+                    };
+                    inst.load_store_register.offset = offset;
+                    mem.writeInt(u32, buffer[0..4], inst.toU32(), .little);
+                }
+            },
+            .direct => {
+                assert(!reloc.pcrel);
+                switch (reloc.length) {
+                    2 => mem.writeInt(
+                        u32,
+                        buffer[0..4],
+                        @as(u32, @truncate(ctx.target_vaddr + ctx.image_base)),
+                        .little,
+                    ),
+                    3 => mem.writeInt(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base, .little),
+                    else => unreachable,
+                }
+            },
+
+            .got => unreachable,
+            .import => unreachable,
+        }
+    }
+
+    fn resolveX86(reloc: Relocation, ctx: Context) void {
+        var buffer = ctx.code[reloc.offset..];
+        switch (reloc.type) {
+            .got_page => unreachable,
+            .got_pageoff => unreachable,
+            .page => unreachable,
+            .pageoff => unreachable,
+            .import_page => unreachable,
+            .import_pageoff => unreachable,
+
+            .got, .import => {
+                assert(reloc.pcrel);
+                const disp = @as(i32, @intCast(ctx.target_vaddr)) - @as(i32, @intCast(ctx.source_vaddr)) - 4;
+                mem.writeInt(i32, buffer[0..4], disp, .little);
+            },
+            .direct => {
+                if (reloc.pcrel) {
+                    const disp = @as(i32, @intCast(ctx.target_vaddr)) - @as(i32, @intCast(ctx.source_vaddr)) - 4;
+                    mem.writeInt(i32, buffer[0..4], disp, .little);
+                } else switch (ctx.ptr_width) {
+                    .p32 => mem.writeInt(u32, buffer[0..4], @as(u32, @intCast(ctx.target_vaddr + ctx.image_base)), .little),
+                    .p64 => switch (reloc.length) {
+                        2 => mem.writeInt(u32, buffer[0..4], @as(u32, @truncate(ctx.target_vaddr + ctx.image_base)), .little),
+                        3 => mem.writeInt(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base, .little),
+                        else => unreachable,
+                    },
+                }
+            },
+        }
+    }
+
+    fn isArithmeticOp(inst: *const [4]u8) bool {
+        const group_decode = @as(u5, @truncate(inst[3]));
+        return ((group_decode >> 2) == 4);
+    }
+};
+
+pub fn addRelocation(coff: *Coff, atom_index: Atom.Index, reloc: Relocation) !void {
+    const comp = coff.base.comp;
+    const gpa = comp.gpa;
+    log.debug("  (adding reloc of type {s} to target %{d})", .{ @tagName(reloc.type), reloc.target.sym_index });
+    const gop = try coff.relocs.getOrPut(gpa, atom_index);
+    if (!gop.found_existing) {
+        gop.value_ptr.* = .{};
+    }
+    try gop.value_ptr.append(gpa, reloc);
+}
+
+fn addBaseRelocation(coff: *Coff, atom_index: Atom.Index, offset: u32) !void {
+    const comp = coff.base.comp;
+    const gpa = comp.gpa;
+    log.debug("  (adding base relocation at offset 0x{x} in %{d})", .{
+        offset,
+        coff.getAtom(atom_index).getSymbolIndex().?,
+    });
+    const gop = try coff.base_relocs.getOrPut(gpa, atom_index);
+    if (!gop.found_existing) {
+        gop.value_ptr.* = .{};
+    }
+    try gop.value_ptr.append(gpa, offset);
+}
+
+fn freeRelocations(coff: *Coff, atom_index: Atom.Index) void {
+    const comp = coff.base.comp;
+    const gpa = comp.gpa;
+    var removed_relocs = coff.relocs.fetchOrderedRemove(atom_index);
+    if (removed_relocs) |*relocs| relocs.value.deinit(gpa);
+    var removed_base_relocs = coff.base_relocs.fetchOrderedRemove(atom_index);
+    if (removed_base_relocs) |*base_relocs| base_relocs.value.deinit(gpa);
+}
+
+/// Represents an import table in the .idata section where each contained pointer
+/// is to a symbol from the same DLL.
+///
+/// The layout of .idata section is as follows:
+///
+/// --- ADDR1 : IAT (all import tables concatenated together)
+///     ptr
+///     ptr
+///     0 sentinel
+///     ptr
+///     0 sentinel
+/// --- ADDR2: headers
+///     ImportDirectoryEntry header
+///     ImportDirectoryEntry header
+///     sentinel
+/// --- ADDR2: lookup tables
+///     Lookup table
+///     0 sentinel
+///     Lookup table
+///     0 sentinel
+/// --- ADDR3: name hint tables
+///     hint-symname
+///     hint-symname
+/// --- ADDR4: DLL names
+///     DLL#1 name
+///     DLL#2 name
+/// --- END
+const ImportTable = struct {
+    entries: std.ArrayListUnmanaged(SymbolWithLoc) = .empty,
+    free_list: std.ArrayListUnmanaged(u32) = .empty,
+    lookup: std.AutoHashMapUnmanaged(SymbolWithLoc, u32) = .empty,
+
+    fn deinit(itab: *ImportTable, allocator: Allocator) void {
+        itab.entries.deinit(allocator);
+        itab.free_list.deinit(allocator);
+        itab.lookup.deinit(allocator);
+    }
+
+    /// Size of the import table does not include the sentinel.
+    fn size(itab: ImportTable) u32 {
+        return @as(u32, @intCast(itab.entries.items.len)) * @sizeOf(u64);
+    }
+
+    fn addImport(itab: *ImportTable, allocator: Allocator, target: SymbolWithLoc) !ImportIndex {
+        try itab.entries.ensureUnusedCapacity(allocator, 1);
+        const index: u32 = blk: {
+            if (itab.free_list.popOrNull()) |index| {
+                log.debug("  (reusing import entry index {d})", .{index});
+                break :blk index;
+            } else {
+                log.debug("  (allocating import entry at index {d})", .{itab.entries.items.len});
+                const index = @as(u32, @intCast(itab.entries.items.len));
+                _ = itab.entries.addOneAssumeCapacity();
+                break :blk index;
+            }
+        };
+        itab.entries.items[index] = target;
+        try itab.lookup.putNoClobber(allocator, target, index);
+        return index;
+    }
+
+    const Context = struct {
+        coff: *const Coff,
+        /// Index of this ImportTable in a global list of all tables.
+        /// This is required in order to calculate the base vaddr of this ImportTable.
+        index: usize,
+        /// Offset into the string interning table of the DLL this ImportTable corresponds to.
+        name_off: u32,
+    };
+
+    fn getBaseAddress(ctx: Context) u32 {
+        const header = ctx.coff.sections.items(.header)[ctx.coff.idata_section_index.?];
+        var addr = header.virtual_address;
+        for (ctx.coff.import_tables.values(), 0..) |other_itab, i| {
+            if (ctx.index == i) break;
+            addr += @as(u32, @intCast(other_itab.entries.items.len * @sizeOf(u64))) + 8;
+        }
+        return addr;
+    }
+
+    fn getImportAddress(itab: *const ImportTable, target: SymbolWithLoc, ctx: Context) ?u32 {
+        const index = itab.lookup.get(target) orelse return null;
+        const base_vaddr = getBaseAddress(ctx);
+        return base_vaddr + index * @sizeOf(u64);
+    }
+
+    const FormatContext = struct {
+        itab: ImportTable,
+        ctx: Context,
+    };
+
+    fn format(itab: ImportTable, comptime unused_format_string: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+        _ = itab;
+        _ = unused_format_string;
+        _ = options;
+        _ = writer;
+        @compileError("do not format ImportTable directly; use itab.fmtDebug()");
+    }
+
+    fn format2(
+        fmt_ctx: FormatContext,
+        comptime unused_format_string: []const u8,
+        options: fmt.FormatOptions,
+        writer: anytype,
+    ) @TypeOf(writer).Error!void {
+        _ = options;
+        comptime assert(unused_format_string.len == 0);
+        const lib_name = fmt_ctx.ctx.coff.temp_strtab.getAssumeExists(fmt_ctx.ctx.name_off);
+        const base_vaddr = getBaseAddress(fmt_ctx.ctx);
+        try writer.print("IAT({s}.dll) @{x}:", .{ lib_name, base_vaddr });
+        for (fmt_ctx.itab.entries.items, 0..) |entry, i| {
+            try writer.print("\n  {d}@{?x} => {s}", .{
+                i,
+                fmt_ctx.itab.getImportAddress(entry, fmt_ctx.ctx),
+                fmt_ctx.ctx.coff.getSymbolName(entry),
+            });
+        }
+    }
+
+    fn fmtDebug(itab: ImportTable, ctx: Context) fmt.Formatter(format2) {
+        return .{ .data = .{ .itab = itab, .ctx = ctx } };
+    }
+
+    const ImportIndex = u32;
+};
+
 const Coff = @This();
 
 const std = @import("std");
 const build_options = @import("build_options");
 const builtin = @import("builtin");
 const assert = std.debug.assert;
-const coff = std.coff;
+const coff_util = std.coff;
 const fmt = std.fmt;
+const fs = std.fs;
 const log = std.log.scoped(.link);
 const math = std.math;
 const mem = std.mem;
 
 const Allocator = std.mem.Allocator;
 const Path = std.Build.Cache.Path;
+const Directory = std.Build.Cache.Directory;
+const Cache = std.Build.Cache;
 
+const aarch64_util = @import("../arch/aarch64/bits.zig");
+const allocPrint = std.fmt.allocPrint;
 const codegen = @import("../codegen.zig");
 const link = @import("../link.zig");
-const lld = @import("Coff/lld.zig");
 const target_util = @import("../target.zig");
 const trace = @import("../tracy.zig").trace;
 
 const Air = @import("../Air.zig");
-pub const Atom = @import("Coff/Atom.zig");
 const Compilation = @import("../Compilation.zig");
-const ImportTable = @import("Coff/ImportTable.zig");
 const Liveness = @import("../Liveness.zig");
 const LlvmObject = @import("../codegen/llvm.zig").Object;
 const Zcu = @import("../Zcu.zig");
 const InternPool = @import("../InternPool.zig");
-const Object = @import("Coff/Object.zig");
-const Relocation = @import("Coff/Relocation.zig");
 const TableSection = @import("table_section.zig").TableSection;
 const StringTable = @import("StringTable.zig");
 const Type = @import("../Type.zig");
diff --git a/zig/src/link/Coff/Atom.zig b/zig/src/link/Coff/Atom.zig
deleted file mode 100644
index 4aa97fa6ac..0000000000
--- a/zig/src/link/Coff/Atom.zig
+++ /dev/null
@@ -1,128 +0,0 @@
-const Atom = @This();
-
-const std = @import("std");
-const coff = std.coff;
-const log = std.log.scoped(.link);
-
-const Coff = @import("../Coff.zig");
-const Relocation = @import("Relocation.zig");
-const SymbolWithLoc = Coff.SymbolWithLoc;
-
-/// Each decl always gets a local symbol with the fully qualified name.
-/// The vaddr and size are found here directly.
-/// The file offset is found by computing the vaddr offset from the section vaddr
-/// the symbol references, and adding that to the file offset of the section.
-/// If this field is 0, it means the codegen size = 0 and there is no symbol or
-/// offset table entry.
-sym_index: u32,
-
-/// null means symbol defined by Zig source.
-file: ?u32,
-
-/// Size of the atom
-size: u32,
-
-/// Points to the previous and next neighbors, based on the `text_offset`.
-/// This can be used to find, for example, the capacity of this `Atom`.
-prev_index: ?Index,
-next_index: ?Index,
-
-pub const Index = u32;
-
-pub fn getSymbolIndex(self: Atom) ?u32 {
-    if (self.sym_index == 0) return null;
-    return self.sym_index;
-}
-
-/// Returns symbol referencing this atom.
-pub fn getSymbol(self: Atom, coff_file: *const Coff) *const coff.Symbol {
-    const sym_index = self.getSymbolIndex().?;
-    return coff_file.getSymbol(.{
-        .sym_index = sym_index,
-        .file = self.file,
-    });
-}
-
-/// Returns pointer-to-symbol referencing this atom.
-pub fn getSymbolPtr(self: Atom, coff_file: *Coff) *coff.Symbol {
-    const sym_index = self.getSymbolIndex().?;
-    return coff_file.getSymbolPtr(.{
-        .sym_index = sym_index,
-        .file = self.file,
-    });
-}
-
-pub fn getSymbolWithLoc(self: Atom) SymbolWithLoc {
-    const sym_index = self.getSymbolIndex().?;
-    return .{ .sym_index = sym_index, .file = self.file };
-}
-
-/// Returns the name of this atom.
-pub fn getName(self: Atom, coff_file: *const Coff) []const u8 {
-    const sym_index = self.getSymbolIndex().?;
-    return coff_file.getSymbolName(.{
-        .sym_index = sym_index,
-        .file = self.file,
-    });
-}
-
-/// Returns how much room there is to grow in virtual address space.
-pub fn capacity(self: Atom, coff_file: *const Coff) u32 {
-    const self_sym = self.getSymbol(coff_file);
-    if (self.next_index) |next_index| {
-        const next = coff_file.getAtom(next_index);
-        const next_sym = next.getSymbol(coff_file);
-        return next_sym.value - self_sym.value;
-    } else {
-        // We are the last atom.
-        // The capacity is limited only by virtual address space.
-        return std.math.maxInt(u32) - self_sym.value;
-    }
-}
-
-pub fn freeListEligible(self: Atom, coff_file: *const Coff) bool {
-    // No need to keep a free list node for the last atom.
-    const next_index = self.next_index orelse return false;
-    const next = coff_file.getAtom(next_index);
-    const self_sym = self.getSymbol(coff_file);
-    const next_sym = next.getSymbol(coff_file);
-    const cap = next_sym.value - self_sym.value;
-    const ideal_cap = Coff.padToIdeal(self.size);
-    if (cap <= ideal_cap) return false;
-    const surplus = cap - ideal_cap;
-    return surplus >= Coff.min_text_capacity;
-}
-
-pub fn addRelocation(coff_file: *Coff, atom_index: Index, reloc: Relocation) !void {
-    const comp = coff_file.base.comp;
-    const gpa = comp.gpa;
-    log.debug("  (adding reloc of type {s} to target %{d})", .{ @tagName(reloc.type), reloc.target.sym_index });
-    const gop = try coff_file.relocs.getOrPut(gpa, atom_index);
-    if (!gop.found_existing) {
-        gop.value_ptr.* = .{};
-    }
-    try gop.value_ptr.append(gpa, reloc);
-}
-
-pub fn addBaseRelocation(coff_file: *Coff, atom_index: Index, offset: u32) !void {
-    const comp = coff_file.base.comp;
-    const gpa = comp.gpa;
-    log.debug("  (adding base relocation at offset 0x{x} in %{d})", .{
-        offset,
-        coff_file.getAtom(atom_index).getSymbolIndex().?,
-    });
-    const gop = try coff_file.base_relocs.getOrPut(gpa, atom_index);
-    if (!gop.found_existing) {
-        gop.value_ptr.* = .{};
-    }
-    try gop.value_ptr.append(gpa, offset);
-}
-
-pub fn freeRelocations(coff_file: *Coff, atom_index: Index) void {
-    const comp = coff_file.base.comp;
-    const gpa = comp.gpa;
-    var removed_relocs = coff_file.relocs.fetchOrderedRemove(atom_index);
-    if (removed_relocs) |*relocs| relocs.value.deinit(gpa);
-    var removed_base_relocs = coff_file.base_relocs.fetchOrderedRemove(atom_index);
-    if (removed_base_relocs) |*base_relocs| base_relocs.value.deinit(gpa);
-}
diff --git a/zig/src/link/Coff/ImportTable.zig b/zig/src/link/Coff/ImportTable.zig
deleted file mode 100644
index 9ce00cf5ee..0000000000
--- a/zig/src/link/Coff/ImportTable.zig
+++ /dev/null
@@ -1,133 +0,0 @@
-//! Represents an import table in the .idata section where each contained pointer
-//! is to a symbol from the same DLL.
-//!
-//! The layout of .idata section is as follows:
-//!
-//! --- ADDR1 : IAT (all import tables concatenated together)
-//!     ptr
-//!     ptr
-//!     0 sentinel
-//!     ptr
-//!     0 sentinel
-//! --- ADDR2: headers
-//!     ImportDirectoryEntry header
-//!     ImportDirectoryEntry header
-//!     sentinel
-//! --- ADDR2: lookup tables
-//!     Lookup table
-//!     0 sentinel
-//!     Lookup table
-//!     0 sentinel
-//! --- ADDR3: name hint tables
-//!     hint-symname
-//!     hint-symname
-//! --- ADDR4: DLL names
-//!     DLL#1 name
-//!     DLL#2 name
-//! --- END
-
-entries: std.ArrayListUnmanaged(SymbolWithLoc) = .empty,
-free_list: std.ArrayListUnmanaged(u32) = .empty,
-lookup: std.AutoHashMapUnmanaged(SymbolWithLoc, u32) = .empty,
-
-pub fn deinit(itab: *ImportTable, allocator: Allocator) void {
-    itab.entries.deinit(allocator);
-    itab.free_list.deinit(allocator);
-    itab.lookup.deinit(allocator);
-}
-
-/// Size of the import table does not include the sentinel.
-pub fn size(itab: ImportTable) u32 {
-    return @as(u32, @intCast(itab.entries.items.len)) * @sizeOf(u64);
-}
-
-pub fn addImport(itab: *ImportTable, allocator: Allocator, target: SymbolWithLoc) !ImportIndex {
-    try itab.entries.ensureUnusedCapacity(allocator, 1);
-    const index: u32 = blk: {
-        if (itab.free_list.popOrNull()) |index| {
-            log.debug("  (reusing import entry index {d})", .{index});
-            break :blk index;
-        } else {
-            log.debug("  (allocating import entry at index {d})", .{itab.entries.items.len});
-            const index = @as(u32, @intCast(itab.entries.items.len));
-            _ = itab.entries.addOneAssumeCapacity();
-            break :blk index;
-        }
-    };
-    itab.entries.items[index] = target;
-    try itab.lookup.putNoClobber(allocator, target, index);
-    return index;
-}
-
-const Context = struct {
-    coff_file: *const Coff,
-    /// Index of this ImportTable in a global list of all tables.
-    /// This is required in order to calculate the base vaddr of this ImportTable.
-    index: usize,
-    /// Offset into the string interning table of the DLL this ImportTable corresponds to.
-    name_off: u32,
-};
-
-fn getBaseAddress(ctx: Context) u32 {
-    const header = ctx.coff_file.sections.items(.header)[ctx.coff_file.idata_section_index.?];
-    var addr = header.virtual_address;
-    for (ctx.coff_file.import_tables.values(), 0..) |other_itab, i| {
-        if (ctx.index == i) break;
-        addr += @as(u32, @intCast(other_itab.entries.items.len * @sizeOf(u64))) + 8;
-    }
-    return addr;
-}
-
-pub fn getImportAddress(itab: *const ImportTable, target: SymbolWithLoc, ctx: Context) ?u32 {
-    const index = itab.lookup.get(target) orelse return null;
-    const base_vaddr = getBaseAddress(ctx);
-    return base_vaddr + index * @sizeOf(u64);
-}
-
-const FormatContext = struct {
-    itab: ImportTable,
-    ctx: Context,
-};
-
-fn fmt(
-    fmt_ctx: FormatContext,
-    comptime unused_format_string: []const u8,
-    options: std.fmt.FormatOptions,
-    writer: anytype,
-) @TypeOf(writer).Error!void {
-    _ = options;
-    comptime assert(unused_format_string.len == 0);
-    const lib_name = fmt_ctx.ctx.coff_file.temp_strtab.getAssumeExists(fmt_ctx.ctx.name_off);
-    const base_vaddr = getBaseAddress(fmt_ctx.ctx);
-    try writer.print("IAT({s}.dll) @{x}:", .{ lib_name, base_vaddr });
-    for (fmt_ctx.itab.entries.items, 0..) |entry, i| {
-        try writer.print("\n  {d}@{?x} => {s}", .{
-            i,
-            fmt_ctx.itab.getImportAddress(entry, fmt_ctx.ctx),
-            fmt_ctx.ctx.coff_file.getSymbolName(entry),
-        });
-    }
-}
-
-fn format(itab: ImportTable, comptime unused_format_string: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
-    _ = itab;
-    _ = unused_format_string;
-    _ = options;
-    _ = writer;
-    @compileError("do not format ImportTable directly; use itab.fmtDebug()");
-}
-
-pub fn fmtDebug(itab: ImportTable, ctx: Context) std.fmt.Formatter(fmt) {
-    return .{ .data = .{ .itab = itab, .ctx = ctx } };
-}
-
-pub const ImportIndex = u32;
-const ImportTable = @This();
-
-const std = @import("std");
-const assert = std.debug.assert;
-const log = std.log.scoped(.link);
-
-const Allocator = std.mem.Allocator;
-const Coff = @import("../Coff.zig");
-const SymbolWithLoc = Coff.SymbolWithLoc;
diff --git a/zig/src/link/Coff/Object.zig b/zig/src/link/Coff/Object.zig
deleted file mode 100644
index 63bbd07463..0000000000
--- a/zig/src/link/Coff/Object.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-const Object = @This();
-
-const std = @import("std");
-const mem = std.mem;
-
-const Allocator = mem.Allocator;
-
-name: []const u8,
-
-pub fn deinit(self: *Object, gpa: Allocator) void {
-    gpa.free(self.name);
-}
diff --git a/zig/src/link/Coff/Relocation.zig b/zig/src/link/Coff/Relocation.zig
deleted file mode 100644
index b25427feda..0000000000
--- a/zig/src/link/Coff/Relocation.zig
+++ /dev/null
@@ -1,233 +0,0 @@
-const Relocation = @This();
-
-const std = @import("std");
-const assert = std.debug.assert;
-const log = std.log.scoped(.link);
-const math = std.math;
-const mem = std.mem;
-const meta = std.meta;
-
-const aarch64 = @import("../../arch/aarch64/bits.zig");
-
-const Atom = @import("Atom.zig");
-const Coff = @import("../Coff.zig");
-const SymbolWithLoc = Coff.SymbolWithLoc;
-
-type: enum {
-    // x86, x86_64
-    /// RIP-relative displacement to a GOT pointer
-    got,
-    /// RIP-relative displacement to an import pointer
-    import,
-
-    // aarch64
-    /// PC-relative distance to target page in GOT section
-    got_page,
-    /// Offset to a GOT pointer relative to the start of a page in GOT section
-    got_pageoff,
-    /// PC-relative distance to target page in a section (e.g., .rdata)
-    page,
-    /// Offset to a pointer relative to the start of a page in a section (e.g., .rdata)
-    pageoff,
-    /// PC-relative distance to target page in a import section
-    import_page,
-    /// Offset to a pointer relative to the start of a page in an import section (e.g., .rdata)
-    import_pageoff,
-
-    // common
-    /// Absolute pointer value
-    direct,
-},
-target: SymbolWithLoc,
-offset: u32,
-addend: u32,
-pcrel: bool,
-length: u2,
-dirty: bool = true,
-
-/// Returns true if and only if the reloc can be resolved.
-pub fn isResolvable(self: Relocation, coff_file: *Coff) bool {
-    _ = self.getTargetAddress(coff_file) orelse return false;
-    return true;
-}
-
-pub fn isGotIndirection(self: Relocation) bool {
-    return switch (self.type) {
-        .got, .got_page, .got_pageoff => true,
-        else => false,
-    };
-}
-
-/// Returns address of the target if any.
-pub fn getTargetAddress(self: Relocation, coff_file: *const Coff) ?u32 {
-    switch (self.type) {
-        .got, .got_page, .got_pageoff => {
-            const got_index = coff_file.got_table.lookup.get(self.target) orelse return null;
-            const header = coff_file.sections.items(.header)[coff_file.got_section_index.?];
-            return header.virtual_address + got_index * coff_file.ptr_width.size();
-        },
-        .import, .import_page, .import_pageoff => {
-            const sym = coff_file.getSymbol(self.target);
-            const index = coff_file.import_tables.getIndex(sym.value) orelse return null;
-            const itab = coff_file.import_tables.values()[index];
-            return itab.getImportAddress(self.target, .{
-                .coff_file = coff_file,
-                .index = index,
-                .name_off = sym.value,
-            });
-        },
-        else => {
-            const target_atom_index = coff_file.getAtomIndexForSymbol(self.target) orelse return null;
-            const target_atom = coff_file.getAtom(target_atom_index);
-            return target_atom.getSymbol(coff_file).value;
-        },
-    }
-}
-
-pub fn resolve(self: Relocation, atom_index: Atom.Index, code: []u8, image_base: u64, coff_file: *Coff) void {
-    const atom = coff_file.getAtom(atom_index);
-    const source_sym = atom.getSymbol(coff_file);
-    const source_vaddr = source_sym.value + self.offset;
-
-    const target_vaddr = self.getTargetAddress(coff_file).?; // Oops, you didn't check if the relocation can be resolved with isResolvable().
-    const target_vaddr_with_addend = target_vaddr + self.addend;
-
-    log.debug("  ({x}: [() => 0x{x} ({s})) ({s}) ", .{
-        source_vaddr,
-        target_vaddr_with_addend,
-        coff_file.getSymbolName(self.target),
-        @tagName(self.type),
-    });
-
-    const ctx: Context = .{
-        .source_vaddr = source_vaddr,
-        .target_vaddr = target_vaddr_with_addend,
-        .image_base = image_base,
-        .code = code,
-        .ptr_width = coff_file.ptr_width,
-    };
-
-    const target = coff_file.base.comp.root_mod.resolved_target.result;
-    switch (target.cpu.arch) {
-        .aarch64 => self.resolveAarch64(ctx),
-        .x86, .x86_64 => self.resolveX86(ctx),
-        else => unreachable, // unhandled target architecture
-    }
-}
-
-const Context = struct {
-    source_vaddr: u32,
-    target_vaddr: u32,
-    image_base: u64,
-    code: []u8,
-    ptr_width: Coff.PtrWidth,
-};
-
-fn resolveAarch64(self: Relocation, ctx: Context) void {
-    var buffer = ctx.code[self.offset..];
-    switch (self.type) {
-        .got_page, .import_page, .page => {
-            const source_page = @as(i32, @intCast(ctx.source_vaddr >> 12));
-            const target_page = @as(i32, @intCast(ctx.target_vaddr >> 12));
-            const pages = @as(u21, @bitCast(@as(i21, @intCast(target_page - source_page))));
-            var inst = aarch64.Instruction{
-                .pc_relative_address = mem.bytesToValue(meta.TagPayload(
-                    aarch64.Instruction,
-                    aarch64.Instruction.pc_relative_address,
-                ), buffer[0..4]),
-            };
-            inst.pc_relative_address.immhi = @as(u19, @truncate(pages >> 2));
-            inst.pc_relative_address.immlo = @as(u2, @truncate(pages));
-            mem.writeInt(u32, buffer[0..4], inst.toU32(), .little);
-        },
-        .got_pageoff, .import_pageoff, .pageoff => {
-            assert(!self.pcrel);
-
-            const narrowed = @as(u12, @truncate(@as(u64, @intCast(ctx.target_vaddr))));
-            if (isArithmeticOp(buffer[0..4])) {
-                var inst = aarch64.Instruction{
-                    .add_subtract_immediate = mem.bytesToValue(meta.TagPayload(
-                        aarch64.Instruction,
-                        aarch64.Instruction.add_subtract_immediate,
-                    ), buffer[0..4]),
-                };
-                inst.add_subtract_immediate.imm12 = narrowed;
-                mem.writeInt(u32, buffer[0..4], inst.toU32(), .little);
-            } else {
-                var inst = aarch64.Instruction{
-                    .load_store_register = mem.bytesToValue(meta.TagPayload(
-                        aarch64.Instruction,
-                        aarch64.Instruction.load_store_register,
-                    ), buffer[0..4]),
-                };
-                const offset: u12 = blk: {
-                    if (inst.load_store_register.size == 0) {
-                        if (inst.load_store_register.v == 1) {
-                            // 128-bit SIMD is scaled by 16.
-                            break :blk @divExact(narrowed, 16);
-                        }
-                        // Otherwise, 8-bit SIMD or ldrb.
-                        break :blk narrowed;
-                    } else {
-                        const denom: u4 = math.powi(u4, 2, inst.load_store_register.size) catch unreachable;
-                        break :blk @divExact(narrowed, denom);
-                    }
-                };
-                inst.load_store_register.offset = offset;
-                mem.writeInt(u32, buffer[0..4], inst.toU32(), .little);
-            }
-        },
-        .direct => {
-            assert(!self.pcrel);
-            switch (self.length) {
-                2 => mem.writeInt(
-                    u32,
-                    buffer[0..4],
-                    @as(u32, @truncate(ctx.target_vaddr + ctx.image_base)),
-                    .little,
-                ),
-                3 => mem.writeInt(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base, .little),
-                else => unreachable,
-            }
-        },
-
-        .got => unreachable,
-        .import => unreachable,
-    }
-}
-
-fn resolveX86(self: Relocation, ctx: Context) void {
-    var buffer = ctx.code[self.offset..];
-    switch (self.type) {
-        .got_page => unreachable,
-        .got_pageoff => unreachable,
-        .page => unreachable,
-        .pageoff => unreachable,
-        .import_page => unreachable,
-        .import_pageoff => unreachable,
-
-        .got, .import => {
-            assert(self.pcrel);
-            const disp = @as(i32, @intCast(ctx.target_vaddr)) - @as(i32, @intCast(ctx.source_vaddr)) - 4;
-            mem.writeInt(i32, buffer[0..4], disp, .little);
-        },
-        .direct => {
-            if (self.pcrel) {
-                const disp = @as(i32, @intCast(ctx.target_vaddr)) - @as(i32, @intCast(ctx.source_vaddr)) - 4;
-                mem.writeInt(i32, buffer[0..4], disp, .little);
-            } else switch (ctx.ptr_width) {
-                .p32 => mem.writeInt(u32, buffer[0..4], @as(u32, @intCast(ctx.target_vaddr + ctx.image_base)), .little),
-                .p64 => switch (self.length) {
-                    2 => mem.writeInt(u32, buffer[0..4], @as(u32, @truncate(ctx.target_vaddr + ctx.image_base)), .little),
-                    3 => mem.writeInt(u64, buffer[0..8], ctx.target_vaddr + ctx.image_base, .little),
-                    else => unreachable,
-                },
-            }
-        },
-    }
-}
-
-inline fn isArithmeticOp(inst: *const [4]u8) bool {
-    const group_decode = @as(u5, @truncate(inst[3]));
-    return ((group_decode >> 2) == 4);
-}
diff --git a/zig/src/link/Coff/lld.zig b/zig/src/link/Coff/lld.zig
deleted file mode 100644
index cf09174e88..0000000000
--- a/zig/src/link/Coff/lld.zig
+++ /dev/null
@@ -1,543 +0,0 @@
-const std = @import("std");
-const build_options = @import("build_options");
-const allocPrint = std.fmt.allocPrint;
-const assert = std.debug.assert;
-const dev = @import("../../dev.zig");
-const fs = std.fs;
-const log = std.log.scoped(.link);
-const mem = std.mem;
-const Cache = std.Build.Cache;
-const Path = std.Build.Cache.Path;
-
-const mingw = @import("../../mingw.zig");
-const link = @import("../../link.zig");
-const trace = @import("../../tracy.zig").trace;
-
-const Allocator = mem.Allocator;
-
-const Coff = @import("../Coff.zig");
-const Compilation = @import("../../Compilation.zig");
-const Zcu = @import("../../Zcu.zig");
-
-pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) !void {
-    dev.check(.lld_linker);
-
-    const tracy = trace(@src());
-    defer tracy.end();
-
-    const comp = self.base.comp;
-    const gpa = comp.gpa;
-
-    const directory = self.base.emit.root_dir; // Just an alias to make it shorter to type.
-    const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
-
-    // If there is no Zig code to compile, then we should skip flushing the output file because it
-    // will not be part of the linker line anyway.
-    const module_obj_path: ?[]const u8 = if (comp.zcu != null) blk: {
-        try self.flushModule(arena, tid, prog_node);
-
-        if (fs.path.dirname(full_out_path)) |dirname| {
-            break :blk try fs.path.join(arena, &.{ dirname, self.base.zcu_object_sub_path.? });
-        } else {
-            break :blk self.base.zcu_object_sub_path.?;
-        }
-    } else null;
-
-    const sub_prog_node = prog_node.start("LLD Link", 0);
-    defer sub_prog_node.end();
-
-    const is_lib = comp.config.output_mode == .Lib;
-    const is_dyn_lib = comp.config.link_mode == .dynamic and is_lib;
-    const is_exe_or_dyn_lib = is_dyn_lib or comp.config.output_mode == .Exe;
-    const link_in_crt = comp.config.link_libc and is_exe_or_dyn_lib;
-    const target = comp.root_mod.resolved_target.result;
-    const optimize_mode = comp.root_mod.optimize_mode;
-    const entry_name: ?[]const u8 = switch (self.entry) {
-        // This logic isn't quite right for disabled or enabled. No point in fixing it
-        // when the goal is to eliminate dependency on LLD anyway.
-        // https://github.com/ziglang/zig/issues/17751
-        .disabled, .default, .enabled => null,
-        .named => |name| name,
-    };
-
-    // See link/Elf.zig for comments on how this mechanism works.
-    const id_symlink_basename = "lld.id";
-
-    var man: Cache.Manifest = undefined;
-    defer if (!self.base.disable_lld_caching) man.deinit();
-
-    var digest: [Cache.hex_digest_len]u8 = undefined;
-
-    if (!self.base.disable_lld_caching) {
-        man = comp.cache_parent.obtain();
-        self.base.releaseLock();
-
-        comptime assert(Compilation.link_hash_implementation_version == 14);
-
-        for (comp.objects) |obj| {
-            _ = try man.addFilePath(obj.path, null);
-            man.hash.add(obj.must_link);
-        }
-        for (comp.c_object_table.keys()) |key| {
-            _ = try man.addFilePath(key.status.success.object_path, null);
-        }
-        for (comp.win32_resource_table.keys()) |key| {
-            _ = try man.addFile(key.status.success.res_path, null);
-        }
-        try man.addOptionalFile(module_obj_path);
-        man.hash.addOptionalBytes(entry_name);
-        man.hash.add(self.base.stack_size);
-        man.hash.add(self.image_base);
-        man.hash.addListOfBytes(self.lib_dirs);
-        man.hash.add(comp.skip_linker_dependencies);
-        if (comp.config.link_libc) {
-            man.hash.add(comp.libc_installation != null);
-            if (comp.libc_installation) |libc_installation| {
-                man.hash.addBytes(libc_installation.crt_dir.?);
-                if (target.abi == .msvc or target.abi == .itanium) {
-                    man.hash.addBytes(libc_installation.msvc_lib_dir.?);
-                    man.hash.addBytes(libc_installation.kernel32_lib_dir.?);
-                }
-            }
-        }
-        try link.hashAddSystemLibs(&man, comp.system_libs);
-        man.hash.addListOfBytes(comp.force_undefined_symbols.keys());
-        man.hash.addOptional(self.subsystem);
-        man.hash.add(comp.config.is_test);
-        man.hash.add(self.tsaware);
-        man.hash.add(self.nxcompat);
-        man.hash.add(self.dynamicbase);
-        man.hash.add(self.base.allow_shlib_undefined);
-        // strip does not need to go into the linker hash because it is part of the hash namespace
-        man.hash.add(self.major_subsystem_version);
-        man.hash.add(self.minor_subsystem_version);
-        man.hash.add(self.repro);
-        man.hash.addOptional(comp.version);
-        try man.addOptionalFile(self.module_definition_file);
-
-        // We don't actually care whether it's a cache hit or miss; we just need the digest and the lock.
-        _ = try man.hit();
-        digest = man.final();
-        var prev_digest_buf: [digest.len]u8 = undefined;
-        const prev_digest: []u8 = Cache.readSmallFile(
-            directory.handle,
-            id_symlink_basename,
-            &prev_digest_buf,
-        ) catch |err| blk: {
-            log.debug("COFF LLD new_digest={s} error: {s}", .{ std.fmt.fmtSliceHexLower(&digest), @errorName(err) });
-            // Handle this as a cache miss.
-            break :blk prev_digest_buf[0..0];
-        };
-        if (mem.eql(u8, prev_digest, &digest)) {
-            log.debug("COFF LLD digest={s} match - skipping invocation", .{std.fmt.fmtSliceHexLower(&digest)});
-            // Hot diggity dog! The output binary is already there.
-            self.base.lock = man.toOwnedLock();
-            return;
-        }
-        log.debug("COFF LLD prev_digest={s} new_digest={s}", .{ std.fmt.fmtSliceHexLower(prev_digest), std.fmt.fmtSliceHexLower(&digest) });
-
-        // We are about to change the output file to be different, so we invalidate the build hash now.
-        directory.handle.deleteFile(id_symlink_basename) catch |err| switch (err) {
-            error.FileNotFound => {},
-            else => |e| return e,
-        };
-    }
-
-    if (comp.config.output_mode == .Obj) {
-        // LLD's COFF driver does not support the equivalent of `-r` so we do a simple file copy
-        // here. TODO: think carefully about how we can avoid this redundant operation when doing
-        // build-obj. See also the corresponding TODO in linkAsArchive.
-        const the_object_path = blk: {
-            if (comp.objects.len != 0)
-                break :blk comp.objects[0].path;
-
-            if (comp.c_object_table.count() != 0)
-                break :blk comp.c_object_table.keys()[0].status.success.object_path;
-
-            if (module_obj_path) |p|
-                break :blk Path.initCwd(p);
-
-            // TODO I think this is unreachable. Audit this situation when solving the above TODO
-            // regarding eliding redundant object -> object transformations.
-            return error.NoObjectsToLink;
-        };
-        try std.fs.Dir.copyFile(
-            the_object_path.root_dir.handle,
-            the_object_path.sub_path,
-            directory.handle,
-            self.base.emit.sub_path,
-            .{},
-        );
-    } else {
-        // Create an LLD command line and invoke it.
-        var argv = std.ArrayList([]const u8).init(gpa);
-        defer argv.deinit();
-        // We will invoke ourselves as a child process to gain access to LLD.
-        // This is necessary because LLD does not behave properly as a library -
-        // 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 argv.append("-ERRORLIMIT:0");
-        try argv.append("-NOLOGO");
-        if (comp.config.debug_format != .strip) {
-            try argv.append("-DEBUG");
-
-            const out_ext = std.fs.path.extension(full_out_path);
-            const out_pdb = self.pdb_out_path orelse try allocPrint(arena, "{s}.pdb", .{
-                full_out_path[0 .. full_out_path.len - out_ext.len],
-            });
-            const out_pdb_basename = std.fs.path.basename(out_pdb);
-
-            try argv.append(try allocPrint(arena, "-PDB:{s}", .{out_pdb}));
-            try argv.append(try allocPrint(arena, "-PDBALTPATH:{s}", .{out_pdb_basename}));
-        }
-        if (comp.version) |version| {
-            try argv.append(try allocPrint(arena, "-VERSION:{}.{}", .{ version.major, version.minor }));
-        }
-        if (comp.config.lto) {
-            switch (optimize_mode) {
-                .Debug => {},
-                .ReleaseSmall => try argv.append("-OPT:lldlto=2"),
-                .ReleaseFast, .ReleaseSafe => try argv.append("-OPT:lldlto=3"),
-            }
-        }
-        if (comp.config.output_mode == .Exe) {
-            try argv.append(try allocPrint(arena, "-STACK:{d}", .{self.base.stack_size}));
-        }
-        try argv.append(try std.fmt.allocPrint(arena, "-BASE:{d}", .{self.image_base}));
-
-        if (target.cpu.arch == .x86) {
-            try argv.append("-MACHINE:X86");
-        } else if (target.cpu.arch == .x86_64) {
-            try argv.append("-MACHINE:X64");
-        } else if (target.cpu.arch.isARM()) {
-            if (target.ptrBitWidth() == 32) {
-                try argv.append("-MACHINE:ARM");
-            } else {
-                try argv.append("-MACHINE:ARM64");
-            }
-        }
-
-        for (comp.force_undefined_symbols.keys()) |symbol| {
-            try argv.append(try allocPrint(arena, "-INCLUDE:{s}", .{symbol}));
-        }
-
-        if (is_dyn_lib) {
-            try argv.append("-DLL");
-        }
-
-        if (entry_name) |name| {
-            try argv.append(try allocPrint(arena, "-ENTRY:{s}", .{name}));
-        }
-
-        if (self.repro) {
-            try argv.append("-BREPRO");
-        }
-
-        if (self.tsaware) {
-            try argv.append("-tsaware");
-        }
-        if (self.nxcompat) {
-            try argv.append("-nxcompat");
-        }
-        if (!self.dynamicbase) {
-            try argv.append("-dynamicbase:NO");
-        }
-        if (self.base.allow_shlib_undefined) {
-            try argv.append("-FORCE:UNRESOLVED");
-        }
-
-        try argv.append(try allocPrint(arena, "-OUT:{s}", .{full_out_path}));
-
-        if (comp.implib_emit) |emit| {
-            const implib_out_path = try emit.root_dir.join(arena, &[_][]const u8{emit.sub_path});
-            try argv.append(try allocPrint(arena, "-IMPLIB:{s}", .{implib_out_path}));
-        }
-
-        if (comp.config.link_libc) {
-            if (comp.libc_installation) |libc_installation| {
-                try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.crt_dir.?}));
-
-                if (target.abi == .msvc or target.abi == .itanium) {
-                    try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.msvc_lib_dir.?}));
-                    try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{libc_installation.kernel32_lib_dir.?}));
-                }
-            }
-        }
-
-        for (self.lib_dirs) |lib_dir| {
-            try argv.append(try allocPrint(arena, "-LIBPATH:{s}", .{lib_dir}));
-        }
-
-        try argv.ensureUnusedCapacity(comp.objects.len);
-        for (comp.objects) |obj| {
-            if (obj.must_link) {
-                argv.appendAssumeCapacity(try allocPrint(arena, "-WHOLEARCHIVE:{}", .{@as(Path, obj.path)}));
-            } else {
-                argv.appendAssumeCapacity(try obj.path.toString(arena));
-            }
-        }
-
-        for (comp.c_object_table.keys()) |key| {
-            try argv.append(try key.status.success.object_path.toString(arena));
-        }
-
-        for (comp.win32_resource_table.keys()) |key| {
-            try argv.append(key.status.success.res_path);
-        }
-
-        if (module_obj_path) |p| {
-            try argv.append(p);
-        }
-
-        if (self.module_definition_file) |def| {
-            try argv.append(try allocPrint(arena, "-DEF:{s}", .{def}));
-        }
-
-        const resolved_subsystem: ?std.Target.SubSystem = blk: {
-            if (self.subsystem) |explicit| break :blk explicit;
-            switch (target.os.tag) {
-                .windows => {
-                    if (comp.zcu) |module| {
-                        if (module.stage1_flags.have_dllmain_crt_startup or is_dyn_lib)
-                            break :blk null;
-                        if (module.stage1_flags.have_c_main or comp.config.is_test or
-                            module.stage1_flags.have_winmain_crt_startup or
-                            module.stage1_flags.have_wwinmain_crt_startup)
-                        {
-                            break :blk .Console;
-                        }
-                        if (module.stage1_flags.have_winmain or module.stage1_flags.have_wwinmain)
-                            break :blk .Windows;
-                    }
-                },
-                .uefi => break :blk .EfiApplication,
-                else => {},
-            }
-            break :blk null;
-        };
-
-        const Mode = enum { uefi, win32 };
-        const mode: Mode = mode: {
-            if (resolved_subsystem) |subsystem| {
-                const subsystem_suffix = try allocPrint(arena, ",{d}.{d}", .{
-                    self.major_subsystem_version, self.minor_subsystem_version,
-                });
-
-                switch (subsystem) {
-                    .Console => {
-                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:console{s}", .{
-                            subsystem_suffix,
-                        }));
-                        break :mode .win32;
-                    },
-                    .EfiApplication => {
-                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:efi_application{s}", .{
-                            subsystem_suffix,
-                        }));
-                        break :mode .uefi;
-                    },
-                    .EfiBootServiceDriver => {
-                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:efi_boot_service_driver{s}", .{
-                            subsystem_suffix,
-                        }));
-                        break :mode .uefi;
-                    },
-                    .EfiRom => {
-                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:efi_rom{s}", .{
-                            subsystem_suffix,
-                        }));
-                        break :mode .uefi;
-                    },
-                    .EfiRuntimeDriver => {
-                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:efi_runtime_driver{s}", .{
-                            subsystem_suffix,
-                        }));
-                        break :mode .uefi;
-                    },
-                    .Native => {
-                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:native{s}", .{
-                            subsystem_suffix,
-                        }));
-                        break :mode .win32;
-                    },
-                    .Posix => {
-                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:posix{s}", .{
-                            subsystem_suffix,
-                        }));
-                        break :mode .win32;
-                    },
-                    .Windows => {
-                        try argv.append(try allocPrint(arena, "-SUBSYSTEM:windows{s}", .{
-                            subsystem_suffix,
-                        }));
-                        break :mode .win32;
-                    },
-                }
-            } else if (target.os.tag == .uefi) {
-                break :mode .uefi;
-            } else {
-                break :mode .win32;
-            }
-        };
-
-        switch (mode) {
-            .uefi => try argv.appendSlice(&[_][]const u8{
-                "-BASE:0",
-                "-ENTRY:EfiMain",
-                "-OPT:REF",
-                "-SAFESEH:NO",
-                "-MERGE:.rdata=.data",
-                "-NODEFAULTLIB",
-                "-SECTION:.xdata,D",
-            }),
-            .win32 => {
-                if (link_in_crt) {
-                    if (target.abi.isGnu()) {
-                        try argv.append("-lldmingw");
-
-                        if (target.cpu.arch == .x86) {
-                            try argv.append("-ALTERNATENAME:__image_base__=___ImageBase");
-                        } else {
-                            try argv.append("-ALTERNATENAME:__image_base__=__ImageBase");
-                        }
-
-                        if (is_dyn_lib) {
-                            try argv.append(try comp.crtFileAsString(arena, "dllcrt2.obj"));
-                            if (target.cpu.arch == .x86) {
-                                try argv.append("-ALTERNATENAME:__DllMainCRTStartup@12=_DllMainCRTStartup@12");
-                            } else {
-                                try argv.append("-ALTERNATENAME:_DllMainCRTStartup=DllMainCRTStartup");
-                            }
-                        } else {
-                            try argv.append(try comp.crtFileAsString(arena, "crt2.obj"));
-                        }
-
-                        try argv.append(try comp.crtFileAsString(arena, "mingw32.lib"));
-                    } else {
-                        const lib_str = switch (comp.config.link_mode) {
-                            .dynamic => "",
-                            .static => "lib",
-                        };
-                        const d_str = switch (optimize_mode) {
-                            .Debug => "d",
-                            else => "",
-                        };
-                        switch (comp.config.link_mode) {
-                            .static => try argv.append(try allocPrint(arena, "libcmt{s}.lib", .{d_str})),
-                            .dynamic => try argv.append(try allocPrint(arena, "msvcrt{s}.lib", .{d_str})),
-                        }
-
-                        try argv.append(try allocPrint(arena, "{s}vcruntime{s}.lib", .{ lib_str, d_str }));
-                        try argv.append(try allocPrint(arena, "{s}ucrt{s}.lib", .{ lib_str, d_str }));
-
-                        //Visual C++ 2015 Conformance Changes
-                        //https://msdn.microsoft.com/en-us/library/bb531344.aspx
-                        try argv.append("legacy_stdio_definitions.lib");
-
-                        // msvcrt depends on kernel32 and ntdll
-                        try argv.append("kernel32.lib");
-                        try argv.append("ntdll.lib");
-                    }
-                } else {
-                    try argv.append("-NODEFAULTLIB");
-                    if (!is_lib and entry_name == null) {
-                        if (comp.zcu) |module| {
-                            if (module.stage1_flags.have_winmain_crt_startup) {
-                                try argv.append("-ENTRY:WinMainCRTStartup");
-                            } else {
-                                try argv.append("-ENTRY:wWinMainCRTStartup");
-                            }
-                        } else {
-                            try argv.append("-ENTRY:wWinMainCRTStartup");
-                        }
-                    }
-                }
-            },
-        }
-
-        // libc++ dep
-        if (comp.config.link_libcpp) {
-            try argv.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
-            try argv.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
-        }
-
-        // libunwind dep
-        if (comp.config.link_libunwind) {
-            try argv.append(try comp.libunwind_static_lib.?.full_object_path.toString(arena));
-        }
-
-        if (comp.config.any_fuzz) {
-            try argv.append(try comp.fuzzer_lib.?.full_object_path.toString(arena));
-        }
-
-        if (is_exe_or_dyn_lib and !comp.skip_linker_dependencies) {
-            if (!comp.config.link_libc) {
-                if (comp.libc_static_lib) |lib| {
-                    try argv.append(try lib.full_object_path.toString(arena));
-                }
-            }
-            // MSVC compiler_rt is missing some stuff, so we build it unconditionally but
-            // and rely on weak linkage to allow MSVC compiler_rt functions to override ours.
-            if (comp.compiler_rt_obj) |obj| try argv.append(try obj.full_object_path.toString(arena));
-            if (comp.compiler_rt_lib) |lib| try argv.append(try lib.full_object_path.toString(arena));
-        }
-
-        try argv.ensureUnusedCapacity(comp.system_libs.count());
-        for (comp.system_libs.keys()) |key| {
-            const lib_basename = try allocPrint(arena, "{s}.lib", .{key});
-            if (comp.crt_files.get(lib_basename)) |crt_file| {
-                argv.appendAssumeCapacity(try crt_file.full_object_path.toString(arena));
-                continue;
-            }
-            if (try findLib(arena, lib_basename, self.lib_dirs)) |full_path| {
-                argv.appendAssumeCapacity(full_path);
-                continue;
-            }
-            if (target.abi.isGnu()) {
-                const fallback_name = try allocPrint(arena, "lib{s}.dll.a", .{key});
-                if (try findLib(arena, fallback_name, self.lib_dirs)) |full_path| {
-                    argv.appendAssumeCapacity(full_path);
-                    continue;
-                }
-            }
-            if (target.abi == .msvc or target.abi == .itanium) {
-                argv.appendAssumeCapacity(lib_basename);
-                continue;
-            }
-
-            log.err("DLL import library for -l{s} not found", .{key});
-            return error.DllImportLibraryNotFound;
-        }
-
-        try link.spawnLld(comp, arena, argv.items);
-    }
-
-    if (!self.base.disable_lld_caching) {
-        // Update the file with the digest. If it fails we can continue; it only
-        // means that the next invocation will have an unnecessary cache miss.
-        Cache.writeSmallFile(directory.handle, id_symlink_basename, &digest) catch |err| {
-            log.warn("failed to save linking hash digest file: {s}", .{@errorName(err)});
-        };
-        // Again failure here only means an unnecessary cache miss.
-        man.writeManifest() catch |err| {
-            log.warn("failed to write cache manifest when linking: {s}", .{@errorName(err)});
-        };
-        // We hang on to this lock so that the output file path can be used without
-        // other processes clobbering it.
-        self.base.lock = man.toOwnedLock();
-    }
-}
-
-fn findLib(arena: Allocator, name: []const u8, lib_dirs: []const []const u8) !?[]const u8 {
-    for (lib_dirs) |lib_dir| {
-        const full_path = try fs.path.join(arena, &.{ lib_dir, name });
-        fs.cwd().access(full_path, .{}) catch |err| switch (err) {
-            error.FileNotFound => continue,
-            else => |e| return e,
-        };
-        return full_path;
-    }
-    return null;
-}
diff --git a/zig/src/link/Dwarf.zig b/zig/src/link/Dwarf.zig
index 3b5e4fddeb..6653a8309a 100644
--- a/zig/src/link/Dwarf.zig
+++ b/zig/src/link/Dwarf.zig
@@ -2372,8 +2372,11 @@ pub fn initWipNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.In
             try wip_nav.infoAddrSym(sym_index, 0);
             wip_nav.func_high_pc = @intCast(wip_nav.debug_info.items.len);
             try diw.writeInt(u32, 0, dwarf.endian);
-            try uleb128(diw, nav.status.resolved.alignment.toByteUnits() orelse
-                target_info.defaultFunctionAlignment(file.mod.resolved_target.result).toByteUnits().?);
+            const target = file.mod.resolved_target.result;
+            try uleb128(diw, switch (nav.status.resolved.alignment) {
+                .none => target_info.defaultFunctionAlignment(target),
+                else => |a| a.maxStrict(target_info.minFunctionAlignment(target)),
+            }.toByteUnits().?);
             try diw.writeByte(@intFromBool(false));
             try diw.writeByte(@intFromBool(func_type.return_type == .noreturn_type));
 
@@ -2596,16 +2599,15 @@ pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool
         .anyframe_type,
         .error_union_type,
         .simple_type,
-        .anon_struct_type,
+        .tuple_type,
         .func_type,
         .error_set_type,
         .inferred_error_set_type,
         => .decl_alias,
         .struct_type => tag: {
             const loaded_struct = ip.loadStructType(nav_val.toIntern());
-            if (loaded_struct.zir_index == .none) break :tag .decl_alias;
 
-            const type_inst_info = loaded_struct.zir_index.unwrap().?.resolveFull(ip).?;
+            const type_inst_info = loaded_struct.zir_index.resolveFull(ip).?;
             if (type_inst_info.file != inst_info.file) break :tag .decl_alias;
 
             const value_inst = value_inst: {
@@ -3346,7 +3348,7 @@ fn updateType(
         .union_type,
         .opaque_type,
         => unreachable,
-        .anon_struct_type => |anon_struct_type| if (anon_struct_type.types.len == 0) {
+        .tuple_type => |tuple_type| if (tuple_type.types.len == 0) {
             try wip_nav.abbrevCode(.namespace_struct_type);
             try wip_nav.strp(name);
             try diw.writeByte(@intFromBool(false));
@@ -3356,15 +3358,15 @@ fn updateType(
             try uleb128(diw, ty.abiSize(zcu));
             try uleb128(diw, ty.abiAlignment(zcu).toByteUnits().?);
             var field_byte_offset: u64 = 0;
-            for (0..anon_struct_type.types.len) |field_index| {
-                const comptime_value = anon_struct_type.values.get(ip)[field_index];
+            for (0..tuple_type.types.len) |field_index| {
+                const comptime_value = tuple_type.values.get(ip)[field_index];
                 try wip_nav.abbrevCode(if (comptime_value != .none) .struct_field_comptime else .struct_field);
-                if (anon_struct_type.fieldName(ip, field_index).unwrap()) |field_name| try wip_nav.strp(field_name.toSlice(ip)) else {
-                    const field_name = try std.fmt.allocPrint(dwarf.gpa, "{d}", .{field_index});
-                    defer dwarf.gpa.free(field_name);
+                {
+                    var name_buf: [32]u8 = undefined;
+                    const field_name = std.fmt.bufPrint(&name_buf, "{d}", .{field_index}) catch unreachable;
                     try wip_nav.strp(field_name);
                 }
-                const field_type = Type.fromInterned(anon_struct_type.types.get(ip)[field_index]);
+                const field_type = Type.fromInterned(tuple_type.types.get(ip)[field_index]);
                 try wip_nav.refType(field_type);
                 if (comptime_value != .none) try wip_nav.blockValue(
                     src_loc,
@@ -3398,21 +3400,72 @@ fn updateType(
             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 diw.writeByte(@intFromEnum(@as(DW.CC, switch (func_type.cc) {
-                .Unspecified, .C => .normal,
-                .Naked, .Async, .Inline => .nocall,
-                .Interrupt, .Signal => .nocall,
-                .Stdcall => .BORLAND_stdcall,
-                .Fastcall => .BORLAND_fastcall,
-                .Vectorcall => .LLVM_vectorcall,
-                .Thiscall => .BORLAND_thiscall,
-                .APCS => .nocall,
-                .AAPCS => .LLVM_AAPCS,
-                .AAPCSVFP => .LLVM_AAPCS_VFP,
-                .SysV => .LLVM_X86_64SysV,
-                .Win64 => .LLVM_Win64,
-                .Kernel, .Fragment, .Vertex => .nocall,
-            })));
+            const cc: DW.CC = cc: {
+                if (zcu.getTarget().cCallingConvention()) |cc| {
+                    if (@as(std.builtin.CallingConvention.Tag, cc) == func_type.cc) {
+                        break :cc .normal;
+                    }
+                }
+                // For better or worse, we try to match what Clang emits.
+                break :cc switch (func_type.cc) {
+                    .@"inline" => unreachable,
+                    .@"async", .auto, .naked => .normal,
+                    .x86_64_sysv => .LLVM_X86_64SysV,
+                    .x86_64_win => .LLVM_Win64,
+                    .x86_64_regcall_v3_sysv => .LLVM_X86RegCall,
+                    .x86_64_regcall_v4_win => .LLVM_X86RegCall,
+                    .x86_64_vectorcall => .LLVM_vectorcall,
+                    .x86_sysv => .normal,
+                    .x86_win => .normal,
+                    .x86_stdcall => .BORLAND_stdcall,
+                    .x86_fastcall => .BORLAND_msfastcall,
+                    .x86_thiscall => .BORLAND_thiscall,
+                    .x86_thiscall_mingw => .BORLAND_thiscall,
+                    .x86_regcall_v3 => .LLVM_X86RegCall,
+                    .x86_regcall_v4_win => .LLVM_X86RegCall,
+                    .x86_vectorcall => .LLVM_vectorcall,
+
+                    .aarch64_aapcs => .normal,
+                    .aarch64_aapcs_darwin => .normal,
+                    .aarch64_aapcs_win => .normal,
+                    .aarch64_vfabi => .LLVM_AAPCS,
+                    .aarch64_vfabi_sve => .LLVM_AAPCS,
+
+                    .arm_apcs => .normal,
+                    .arm_aapcs => .LLVM_AAPCS,
+                    .arm_aapcs_vfp,
+                    .arm_aapcs16_vfp,
+                    => .LLVM_AAPCS_VFP,
+
+                    .riscv64_lp64_v,
+                    .riscv32_ilp32_v,
+                    => .LLVM_RISCVVectorCall,
+
+                    .m68k_rtd => .LLVM_M68kRTD,
+
+                    .amdgcn_kernel => .LLVM_OpenCLKernel,
+                    .nvptx_kernel,
+                    .spirv_kernel,
+                    => .nocall,
+
+                    .x86_64_interrupt,
+                    .x86_interrupt,
+                    .arm_interrupt,
+                    .mips64_interrupt,
+                    .mips_interrupt,
+                    .riscv64_interrupt,
+                    .riscv32_interrupt,
+                    .avr_builtin,
+                    .avr_signal,
+                    .avr_interrupt,
+                    .csky_interrupt,
+                    .m68k_interrupt,
+                    => .normal,
+
+                    else => .nocall,
+                };
+            };
+            try diw.writeByte(@intFromEnum(cc));
             try wip_nav.refType(Type.fromInterned(func_type.return_type));
             for (0..func_type.param_types.len) |param_index| {
                 try wip_nav.abbrevCode(.func_type_param);
@@ -3542,16 +3595,26 @@ pub fn updateContainerType(dwarf: *Dwarf, pt: Zcu.PerThread, type_index: InternP
         try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.items);
         try wip_nav.flush(ty_src_loc);
     } else {
-        const decl_inst = file.zir.instructions.get(@intFromEnum(inst_info.inst));
-        assert(decl_inst.tag == .extended);
-        if (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,
-            .reify => @as(Zir.Inst.NameStrategy, @enumFromInt(decl_inst.data.extended.small)),
-            else => unreachable,
-        } == .parent) return;
+        {
+            // 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 => @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,
+                    .reify => @as(Zir.Inst.NameStrategy, @enumFromInt(decl_inst.data.extended.small)),
+                    else => unreachable,
+                },
+                else => unreachable,
+            };
+            if (name_strat == .parent) return;
+        }
 
         const unit = try dwarf.getUnit(file.mod);
         const type_gop = try dwarf.types.getOrPut(dwarf.gpa, type_index);
@@ -3792,6 +3855,7 @@ pub fn flushModule(dwarf: *Dwarf, pt: Zcu.PerThread) FlushError!void {
         }
         if (global_error_set_names.len > 0) try uleb128(diw, @intFromEnum(AbbrevCode.null));
         try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.items);
+        try wip_nav.flush(.unneeded);
     }
 
     {
diff --git a/zig/src/link/Elf.zig b/zig/src/link/Elf.zig
index 5f6a073842..8f39d3412f 100644
--- a/zig/src/link/Elf.zig
+++ b/zig/src/link/Elf.zig
@@ -1,4 +1,7 @@
+pub const Atom = @import("Elf/Atom.zig");
+
 base: link.File,
+zig_object: ?*ZigObject,
 rpath_table: std.StringArrayHashMapUnmanaged(void),
 image_base: u64,
 emit_relocs: bool,
@@ -13,7 +16,6 @@ z_relro: bool,
 z_common_page_size: ?u64,
 /// TODO make this non optional and resolve the default in open()
 z_max_page_size: ?u64,
-lib_dirs: []const []const u8,
 hash_style: HashStyle,
 compress_debug_sections: CompressDebugSections,
 symbol_wrap_set: std.StringArrayHashMapUnmanaged(void),
@@ -34,8 +36,7 @@ ptr_width: PtrWidth,
 llvm_object: ?LlvmObject.Ptr = null,
 
 /// A list of all input files.
-/// Index of each input file also encodes the priority or precedence of one input file
-/// over another.
+/// First index is a special "null file". Order is otherwise not observed.
 files: std.MultiArrayList(File.Entry) = .{},
 /// Long-lived list of all file descriptors.
 /// We store them globally rather than per actual File so that we can re-use
@@ -44,7 +45,7 @@ file_handles: std.ArrayListUnmanaged(File.Handle) = .empty,
 zig_object_index: ?File.Index = null,
 linker_defined_index: ?File.Index = null,
 objects: std.ArrayListUnmanaged(File.Index) = .empty,
-shared_objects: std.ArrayListUnmanaged(File.Index) = .empty,
+shared_objects: std.StringArrayHashMapUnmanaged(File.Index) = .empty,
 
 /// List of all output sections and their associated metadata.
 sections: std.MultiArrayList(Section) = .{},
@@ -53,29 +54,14 @@ shdr_table_offset: ?u64 = null,
 
 /// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
 /// Same order as in the file.
-phdrs: std.ArrayListUnmanaged(elf.Elf64_Phdr) = .empty,
-
-/// Special program headers
-/// PT_PHDR
-phdr_table_index: ?u16 = null,
-/// PT_LOAD for PHDR table
-/// We add this special load segment to ensure the EHDR and PHDR table are always
-/// loaded into memory.
-phdr_table_load_index: ?u16 = null,
-/// PT_INTERP
-phdr_interp_index: ?u16 = null,
-/// PT_DYNAMIC
-phdr_dynamic_index: ?u16 = null,
-/// PT_GNU_EH_FRAME
-phdr_gnu_eh_frame_index: ?u16 = null,
-/// PT_GNU_STACK
-phdr_gnu_stack_index: ?u16 = null,
-/// PT_TLS
-/// TODO I think ELF permits multiple TLS segments but for now, assume one per file.
-phdr_tls_index: ?u16 = null,
+phdrs: ProgramHeaderList = .empty,
+
+/// Special program headers.
+phdr_indexes: ProgramHeaderIndexes = .{},
+section_indexes: SectionIndexes = .{},
 
 page_size: u32,
-default_sym_version: elf.Elf64_Versym,
+default_sym_version: elf.Versym,
 
 /// .shstrtab buffer
 shstrtab: std.ArrayListUnmanaged(u8) = .empty,
@@ -88,7 +74,7 @@ dynsym: DynsymSection = .{},
 /// .dynstrtab buffer
 dynstrtab: std.ArrayListUnmanaged(u8) = .empty,
 /// Version symbol table. Only populated and emitted when linking dynamically.
-versym: std.ArrayListUnmanaged(elf.Elf64_Versym) = .empty,
+versym: std.ArrayListUnmanaged(elf.Versym) = .empty,
 /// .verneed section
 verneed: VerneedSection = .{},
 /// .got section
@@ -115,29 +101,6 @@ rela_plt: std.ArrayListUnmanaged(elf.Elf64_Rela) = .empty,
 /// Applies only to a relocatable.
 comdat_group_sections: std.ArrayListUnmanaged(ComdatGroupSection) = .empty,
 
-copy_rel_section_index: ?u32 = null,
-dynamic_section_index: ?u32 = null,
-dynstrtab_section_index: ?u32 = null,
-dynsymtab_section_index: ?u32 = null,
-eh_frame_section_index: ?u32 = null,
-eh_frame_rela_section_index: ?u32 = null,
-eh_frame_hdr_section_index: ?u32 = null,
-hash_section_index: ?u32 = null,
-gnu_hash_section_index: ?u32 = null,
-got_section_index: ?u32 = null,
-got_plt_section_index: ?u32 = null,
-interp_section_index: ?u32 = null,
-plt_section_index: ?u32 = null,
-plt_got_section_index: ?u32 = null,
-rela_dyn_section_index: ?u32 = null,
-rela_plt_section_index: ?u32 = null,
-versym_section_index: ?u32 = null,
-verneed_section_index: ?u32 = null,
-
-shstrtab_section_index: ?u32 = null,
-strtab_section_index: ?u32 = null,
-symtab_section_index: ?u32 = null,
-
 resolver: SymbolResolver = .{},
 
 has_text_reloc: bool = false,
@@ -147,10 +110,90 @@ num_ifunc_dynrelocs: usize = 0,
 thunks: std.ArrayListUnmanaged(Thunk) = .empty,
 
 /// List of output merge sections with deduped contents.
-merge_sections: std.ArrayListUnmanaged(MergeSection) = .empty,
-comment_merge_section_index: ?MergeSection.Index = null,
+merge_sections: std.ArrayListUnmanaged(Merge.Section) = .empty,
+comment_merge_section_index: ?Merge.Section.Index = null,
+
+first_eflags: ?elf.Word = null,
+
+/// `--verbose-link` output.
+/// Initialized on creation, appended to as inputs are added, printed during `flush`.
+dump_argv_list: std.ArrayListUnmanaged([]const u8),
+
+const SectionIndexes = struct {
+    copy_rel: ?u32 = null,
+    dynamic: ?u32 = null,
+    dynstrtab: ?u32 = null,
+    dynsymtab: ?u32 = null,
+    eh_frame: ?u32 = null,
+    eh_frame_rela: ?u32 = null,
+    eh_frame_hdr: ?u32 = null,
+    hash: ?u32 = null,
+    gnu_hash: ?u32 = null,
+    got: ?u32 = null,
+    got_plt: ?u32 = null,
+    interp: ?u32 = null,
+    plt: ?u32 = null,
+    plt_got: ?u32 = null,
+    rela_dyn: ?u32 = null,
+    rela_plt: ?u32 = null,
+    versym: ?u32 = null,
+    verneed: ?u32 = null,
+
+    shstrtab: ?u32 = null,
+    strtab: ?u32 = null,
+    symtab: ?u32 = null,
+};
+
+const ProgramHeaderList = std.ArrayListUnmanaged(elf.Elf64_Phdr);
+
+const OptionalProgramHeaderIndex = enum(u16) {
+    none = std.math.maxInt(u16),
+    _,
+
+    fn unwrap(i: OptionalProgramHeaderIndex) ?ProgramHeaderIndex {
+        if (i == .none) return null;
+        return @enumFromInt(@intFromEnum(i));
+    }
+
+    fn int(i: OptionalProgramHeaderIndex) ?u16 {
+        if (i == .none) return null;
+        return @intFromEnum(i);
+    }
+};
+
+const ProgramHeaderIndex = enum(u16) {
+    _,
+
+    fn toOptional(i: ProgramHeaderIndex) OptionalProgramHeaderIndex {
+        const result: OptionalProgramHeaderIndex = @enumFromInt(@intFromEnum(i));
+        assert(result != .none);
+        return result;
+    }
 
-first_eflags: ?elf.Elf64_Word = null,
+    fn int(i: ProgramHeaderIndex) u16 {
+        return @intFromEnum(i);
+    }
+};
+
+const ProgramHeaderIndexes = struct {
+    /// PT_PHDR
+    table: OptionalProgramHeaderIndex = .none,
+    /// PT_LOAD for PHDR table
+    /// We add this special load segment to ensure the EHDR and PHDR table are always
+    /// loaded into memory.
+    table_load: OptionalProgramHeaderIndex = .none,
+    /// PT_INTERP
+    interp: OptionalProgramHeaderIndex = .none,
+    /// PT_DYNAMIC
+    dynamic: OptionalProgramHeaderIndex = .none,
+    /// PT_GNU_EH_FRAME
+    gnu_eh_frame: OptionalProgramHeaderIndex = .none,
+    /// PT_GNU_STACK
+    gnu_stack: OptionalProgramHeaderIndex = .none,
+    /// PT_TLS
+    /// TODO I think ELF permits multiple TLS segments but for now, assume one per file.
+    tls: OptionalProgramHeaderIndex = .none,
+};
 
 /// When allocating, the ideal_capacity is calculated by
 /// actual_capacity + (actual_capacity / ideal_factor)
@@ -225,10 +268,7 @@ pub fn createEmpty(
     };
 
     const is_dyn_lib = output_mode == .Lib and link_mode == .dynamic;
-    const default_sym_version: elf.Elf64_Versym = if (is_dyn_lib or comp.config.rdynamic)
-        elf.VER_NDX_GLOBAL
-    else
-        elf.VER_NDX_LOCAL;
+    const default_sym_version: elf.Versym = if (is_dyn_lib or comp.config.rdynamic) .GLOBAL else .LOCAL;
 
     // If using LLD to link, this code should produce an object file so that it
     // can be passed to LLD.
@@ -260,6 +300,7 @@ pub fn createEmpty(
             .disable_lld_caching = options.disable_lld_caching,
             .build_id = options.build_id,
         },
+        .zig_object = null,
         .rpath_table = rpath_table,
         .ptr_width = ptr_width,
         .page_size = page_size,
@@ -291,7 +332,6 @@ pub fn createEmpty(
         .z_relro = options.z_relro,
         .z_common_page_size = options.z_common_page_size,
         .z_max_page_size = options.z_max_page_size,
-        .lib_dirs = options.lib_dirs,
         .hash_style = options.hash_style,
         .compress_debug_sections = options.compress_debug_sections,
         .symbol_wrap_set = options.symbol_wrap_set,
@@ -304,6 +344,7 @@ pub fn createEmpty(
         .enable_new_dtags = options.enable_new_dtags,
         .print_icf_sections = options.print_icf_sections,
         .print_map = options.print_map,
+        .dump_argv_list = .empty,
     };
     if (use_llvm and comp.config.have_zcu) {
         self.llvm_object = try LlvmObject.create(arena, comp);
@@ -315,6 +356,9 @@ pub fn createEmpty(
         return self;
     }
 
+    // --verbose-link
+    if (comp.verbose_link) try dumpArgvInit(self, arena);
+
     const is_obj = output_mode == .Obj;
     const is_obj_or_ar = is_obj or (output_mode == .Lib and link_mode == .static);
 
@@ -358,7 +402,7 @@ pub fn createEmpty(
         };
         const max_nphdrs = comptime getMaxNumberOfPhdrs();
         const reserved: u64 = mem.alignForward(u64, padToIdeal(max_nphdrs * phsize), self.page_size);
-        self.phdr_table_index = try self.addPhdr(.{
+        self.phdr_indexes.table = (try self.addPhdr(.{
             .type = elf.PT_PHDR,
             .flags = elf.PF_R,
             .@"align" = p_align,
@@ -366,8 +410,8 @@ pub fn createEmpty(
             .offset = ehsize,
             .filesz = reserved,
             .memsz = reserved,
-        });
-        self.phdr_table_load_index = try self.addPhdr(.{
+        })).toOptional();
+        self.phdr_indexes.table_load = (try self.addPhdr(.{
             .type = elf.PT_LOAD,
             .flags = elf.PF_R,
             .@"align" = self.page_size,
@@ -375,20 +419,23 @@ pub fn createEmpty(
             .offset = 0,
             .filesz = reserved + ehsize,
             .memsz = reserved + ehsize,
-        });
+        })).toOptional();
     }
 
     if (opt_zcu) |zcu| {
         if (!use_llvm) {
             const index: File.Index = @intCast(try self.files.addOne(gpa));
-            self.files.set(index, .{ .zig_object = .{
+            self.files.set(index, .zig_object);
+            self.zig_object_index = index;
+            const zig_object = try arena.create(ZigObject);
+            self.zig_object = zig_object;
+            zig_object.* = .{
                 .index = index,
                 .basename = try std.fmt.allocPrint(arena, "{s}.o", .{
                     fs.path.stem(zcu.main_mod.root_src_path),
                 }),
-            } });
-            self.zig_object_index = index;
-            try self.zigObjectPtr().?.init(self, .{
+            };
+            try zig_object.init(self, .{
                 .symbol_count_hint = options.symbol_count_hint,
                 .program_code_size_hint = options.program_code_size_hint,
             });
@@ -420,12 +467,14 @@ pub fn deinit(self: *Elf) void {
     self.file_handles.deinit(gpa);
 
     for (self.files.items(.tags), self.files.items(.data)) |tag, *data| switch (tag) {
-        .null => {},
-        .zig_object => data.zig_object.deinit(gpa),
+        .null, .zig_object => {},
         .linker_defined => data.linker_defined.deinit(gpa),
         .object => data.object.deinit(gpa),
         .shared_object => data.shared_object.deinit(gpa),
     };
+    if (self.zig_object) |zig_object| {
+        zig_object.deinit(gpa);
+    }
     self.files.deinit(gpa);
     self.objects.deinit(gpa);
     self.shared_objects.deinit(gpa);
@@ -464,6 +513,7 @@ pub fn deinit(self: *Elf) void {
     self.rela_dyn.deinit(gpa);
     self.rela_plt.deinit(gpa);
     self.comdat_group_sections.deinit(gpa);
+    self.dump_argv_list.deinit(gpa);
 }
 
 pub fn getNavVAddr(self: *Elf, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index, reloc_info: link.File.RelocInfo) !u64 {
@@ -715,6 +765,37 @@ pub fn allocateChunk(self: *Elf, args: struct {
     return res;
 }
 
+pub fn loadInput(self: *Elf, input: link.Input) !void {
+    const comp = self.base.comp;
+    const gpa = comp.gpa;
+    const diags = &comp.link_diags;
+    const target = self.getTarget();
+    const debug_fmt_strip = comp.config.debug_format == .strip;
+    const default_sym_version = self.default_sym_version;
+    const is_static_lib = self.base.isStaticLib();
+
+    if (comp.verbose_link) {
+        comp.mutex.lock(); // protect comp.arena
+        defer comp.mutex.unlock();
+
+        const argv = &self.dump_argv_list;
+        switch (input) {
+            .res => unreachable,
+            .dso_exact => |dso_exact| try argv.appendSlice(gpa, &.{ "-l", dso_exact.name }),
+            .object, .archive => |obj| try argv.append(gpa, try obj.path.toString(comp.arena)),
+            .dso => |dso| try argv.append(gpa, try dso.path.toString(comp.arena)),
+        }
+    }
+
+    switch (input) {
+        .res => unreachable,
+        .dso_exact => @panic("TODO"),
+        .object => |obj| try parseObject(self, obj),
+        .archive => |obj| try parseArchive(gpa, diags, &self.file_handles, &self.files, &self.first_eflags, target, debug_fmt_strip, default_sym_version, &self.objects, obj, is_static_lib),
+        .dso => |dso| try parseDso(gpa, diags, dso, &self.shared_objects, &self.files, target),
+    }
+}
+
 pub fn flush(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
     const use_lld = build_options.have_llvm and self.base.comp.config.use_lld;
     if (use_lld) {
@@ -729,6 +810,7 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
 
     const comp = self.base.comp;
     const gpa = comp.gpa;
+    const diags = &comp.link_diags;
 
     if (self.llvm_object) |llvm_object| {
         try self.base.emitLlvmObject(arena, llvm_object, prog_node);
@@ -736,169 +818,33 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
         if (use_lld) return;
     }
 
+    if (comp.verbose_link) Compilation.dump_argv(self.dump_argv_list.items);
+
     const sub_prog_node = prog_node.start("ELF Flush", 0);
     defer sub_prog_node.end();
 
-    const target = self.getTarget();
-    const link_mode = comp.config.link_mode;
-    const directory = self.base.emit.root_dir; // Just an alias to make it shorter to type.
     const module_obj_path: ?Path = if (self.base.zcu_object_sub_path) |path| .{
-        .root_dir = directory,
+        .root_dir = self.base.emit.root_dir,
         .sub_path = if (fs.path.dirname(self.base.emit.sub_path)) |dirname|
             try fs.path.join(arena, &.{ dirname, path })
         else
             path,
     } else null;
 
-    // --verbose-link
-    if (comp.verbose_link) try self.dumpArgv(comp);
-
-    if (self.zigObjectPtr()) |zig_object| try zig_object.flushModule(self, tid);
-    if (self.base.isStaticLib()) return relocatable.flushStaticLib(self, comp, module_obj_path);
-    if (self.base.isObject()) return relocatable.flushObject(self, comp, module_obj_path);
-
-    const csu = try comp.getCrtPaths(arena);
-
-    // csu prelude
-    if (csu.crt0) |path| try parseObjectReportingFailure(self, path);
-    if (csu.crti) |path| try parseObjectReportingFailure(self, path);
-    if (csu.crtbegin) |path| try parseObjectReportingFailure(self, path);
-
-    for (comp.objects) |obj| {
-        if (obj.isObject()) {
-            try parseObjectReportingFailure(self, obj.path);
-        } else {
-            try parseLibraryReportingFailure(self, .{ .path = obj.path }, obj.must_link);
-        }
-    }
-
-    // This is a set of object files emitted by clang in a single `build-exe` invocation.
-    // For instance, the implicit `a.o` as compiled by `zig build-exe a.c` will end up
-    // in this set.
-    for (comp.c_object_table.keys()) |key| {
-        try parseObjectReportingFailure(self, key.status.success.object_path);
-    }
-
-    if (module_obj_path) |path| try parseObjectReportingFailure(self, path);
-
-    if (comp.config.any_sanitize_thread) try parseCrtFileReportingFailure(self, comp.tsan_lib.?);
-    if (comp.config.any_fuzz) try parseCrtFileReportingFailure(self, comp.fuzzer_lib.?);
-
-    // libc
-    if (!comp.skip_linker_dependencies and !comp.config.link_libc) {
-        if (comp.libc_static_lib) |lib| try parseCrtFileReportingFailure(self, lib);
-    }
-
-    for (comp.system_libs.values()) |lib_info| {
-        try self.parseLibraryReportingFailure(.{
-            .needed = lib_info.needed,
-            .path = lib_info.path.?,
-        }, false);
-    }
-
-    // libc++ dep
-    if (comp.config.link_libcpp) {
-        try self.parseLibraryReportingFailure(.{ .path = comp.libcxxabi_static_lib.?.full_object_path }, false);
-        try self.parseLibraryReportingFailure(.{ .path = comp.libcxx_static_lib.?.full_object_path }, false);
-    }
-
-    // libunwind dep
-    if (comp.config.link_libunwind) {
-        try self.parseLibraryReportingFailure(.{ .path = comp.libunwind_static_lib.?.full_object_path }, false);
-    }
-
-    // libc dep
-    comp.link_error_flags.missing_libc = false;
-    if (comp.config.link_libc) {
-        if (comp.libc_installation) |lc| {
-            const flags = target_util.libcFullLinkFlags(target);
-
-            var test_path = std.ArrayList(u8).init(arena);
-            var checked_paths = std.ArrayList([]const u8).init(arena);
+    if (self.zigObjectPtr()) |zig_object| try zig_object.flush(self, tid);
 
-            for (flags) |flag| {
-                checked_paths.clearRetainingCapacity();
-                const lib_name = flag["-l".len..];
+    if (module_obj_path) |path| openParseObjectReportingFailure(self, path);
 
-                success: {
-                    if (!self.base.isStatic()) {
-                        if (try self.accessLibPath(arena, &test_path, &checked_paths, lc.crt_dir.?, lib_name, .dynamic))
-                            break :success;
-                    }
-                    if (try self.accessLibPath(arena, &test_path, &checked_paths, lc.crt_dir.?, lib_name, .static))
-                        break :success;
-
-                    try self.reportMissingLibraryError(
-                        checked_paths.items,
-                        "missing system library: '{s}' was not found",
-                        .{lib_name},
-                    );
-
-                    continue;
-                }
-
-                const resolved_path = Path.initCwd(try arena.dupe(u8, test_path.items));
-                try self.parseLibraryReportingFailure(.{ .path = resolved_path }, false);
-            }
-        } else if (target.isGnuLibC()) {
-            for (glibc.libs) |lib| {
-                if (lib.removed_in) |rem_in| {
-                    if (target.os.version_range.linux.glibc.order(rem_in) != .lt) continue;
-                }
-
-                const lib_path = Path.initCwd(try std.fmt.allocPrint(arena, "{s}{c}lib{s}.so.{d}", .{
-                    comp.glibc_so_files.?.dir_path, fs.path.sep, lib.name, lib.sover,
-                }));
-                try self.parseLibraryReportingFailure(.{ .path = lib_path }, false);
-            }
-            try self.parseLibraryReportingFailure(.{
-                .path = try comp.get_libc_crt_file(arena, "libc_nonshared.a"),
-            }, false);
-        } else if (target.isMusl()) {
-            const path = try comp.get_libc_crt_file(arena, switch (link_mode) {
-                .static => "libc.a",
-                .dynamic => "libc.so",
-            });
-            try self.parseLibraryReportingFailure(.{ .path = path }, false);
-        } else {
-            comp.link_error_flags.missing_libc = true;
-        }
-    }
-
-    // Finally, as the last input objects we add compiler_rt and CSU postlude (if any).
-
-    // compiler-rt. Since compiler_rt exports symbols like `memset`, it needs
-    // to be after the shared libraries, so they are picked up from the shared
-    // libraries, not libcompiler_rt.
-    if (comp.compiler_rt_lib) |crt_file| {
-        try parseLibraryReportingFailure(self, .{ .path = crt_file.full_object_path }, false);
-    } else if (comp.compiler_rt_obj) |crt_file| {
-        try parseObjectReportingFailure(self, crt_file.full_object_path);
+    switch (comp.config.output_mode) {
+        .Obj => return relocatable.flushObject(self, comp),
+        .Lib => switch (comp.config.link_mode) {
+            .dynamic => {},
+            .static => return relocatable.flushStaticLib(self, comp),
+        },
+        .Exe => {},
     }
 
-    // csu postlude
-    if (csu.crtend) |path| try parseObjectReportingFailure(self, path);
-    if (csu.crtn) |path| try parseObjectReportingFailure(self, path);
-
-    if (self.base.hasErrors()) return error.FlushFailure;
-
-    // Dedup shared objects
-    {
-        var seen_dsos = std.StringHashMap(void).init(gpa);
-        defer seen_dsos.deinit();
-        try seen_dsos.ensureTotalCapacity(@as(u32, @intCast(self.shared_objects.items.len)));
-
-        var i: usize = 0;
-        while (i < self.shared_objects.items.len) {
-            const index = self.shared_objects.items[i];
-            const shared_object = self.file(index).?.shared_object;
-            const soname = shared_object.soname();
-            const gop = seen_dsos.getOrPutAssumeCapacity(soname);
-            if (gop.found_existing) {
-                _ = self.shared_objects.orderedRemove(i);
-            } else i += 1;
-        }
-    }
+    if (diags.hasErrors()) return error.FlushFailure;
 
     // If we haven't already, create a linker-generated input file comprising of
     // linker-defined synthetic symbols only such as `_DYNAMIC`, etc.
@@ -952,7 +898,16 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
     // Generate and emit synthetic sections.
     try self.initSyntheticSections();
     try self.initSpecialPhdrs();
-    try self.sortShdrs();
+    try sortShdrs(
+        gpa,
+        &self.section_indexes,
+        &self.sections,
+        self.shstrtab.items,
+        self.merge_sections.items,
+        self.comdat_group_sections.items,
+        self.zigObjectPtr(),
+        self.files,
+    );
 
     try self.setDynamicSection(self.rpath_table.keys());
     self.sortDynamicSymtab();
@@ -966,7 +921,7 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
     try self.addLoadPhdrs();
     try self.allocatePhdrTable();
     try self.allocateAllocSections();
-    try self.sortPhdrs();
+    try sortPhdrs(gpa, &self.phdrs, &self.phdr_indexes, self.sections.items(.phndx));
     try self.allocateNonAllocSections();
     self.allocateSpecialPhdrs();
     if (self.linkerDefinedPtr()) |obj| {
@@ -1029,348 +984,160 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
 
     if (self.base.isExe() and self.linkerDefinedPtr().?.entry_index == null) {
         log.debug("flushing. no_entry_point_found = true", .{});
-        comp.link_error_flags.no_entry_point_found = true;
+        diags.flags.no_entry_point_found = true;
     } else {
         log.debug("flushing. no_entry_point_found = false", .{});
-        comp.link_error_flags.no_entry_point_found = false;
+        diags.flags.no_entry_point_found = false;
         try self.writeElfHeader();
     }
 
-    if (self.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
 }
 
-/// --verbose-link output
-fn dumpArgv(self: *Elf, comp: *Compilation) !void {
-    const gpa = self.base.comp.gpa;
-    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
-    defer arena_allocator.deinit();
-    const arena = arena_allocator.allocator();
-
+fn dumpArgvInit(self: *Elf, arena: Allocator) !void {
+    const comp = self.base.comp;
+    const gpa = comp.gpa;
     const target = self.getTarget();
-    const link_mode = self.base.comp.config.link_mode;
-    const directory = self.base.emit.root_dir; // Just an alias to make it shorter to type.
-    const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
-    const module_obj_path: ?[]const u8 = if (self.base.zcu_object_sub_path) |path| blk: {
-        if (fs.path.dirname(full_out_path)) |dirname| {
-            break :blk try fs.path.join(arena, &.{ dirname, path });
-        } else {
-            break :blk path;
-        }
-    } else null;
-
-    const csu = try comp.getCrtPaths(arena);
-    const compiler_rt_path: ?[]const u8 = blk: {
-        if (comp.compiler_rt_lib) |x| break :blk try x.full_object_path.toString(arena);
-        if (comp.compiler_rt_obj) |x| break :blk try x.full_object_path.toString(arena);
-        break :blk null;
-    };
+    const full_out_path = try self.base.emit.root_dir.join(arena, &[_][]const u8{self.base.emit.sub_path});
 
-    var argv = std.ArrayList([]const u8).init(arena);
+    const argv = &self.dump_argv_list;
 
-    try argv.append("zig");
+    try argv.append(gpa, "zig");
 
     if (self.base.isStaticLib()) {
-        try argv.append("ar");
+        try argv.append(gpa, "ar");
     } else {
-        try argv.append("ld");
+        try argv.append(gpa, "ld");
     }
 
     if (self.base.isObject()) {
-        try argv.append("-r");
+        try argv.append(gpa, "-r");
     }
 
-    try argv.append("-o");
-    try argv.append(full_out_path);
+    try argv.append(gpa, "-o");
+    try argv.append(gpa, full_out_path);
 
-    if (self.base.isRelocatable()) {
-        for (comp.objects) |obj| {
-            try argv.append(try obj.path.toString(arena));
-        }
-
-        for (comp.c_object_table.keys()) |key| {
-            try argv.append(try key.status.success.object_path.toString(arena));
-        }
-
-        if (module_obj_path) |p| {
-            try argv.append(p);
-        }
-    } else {
+    if (!self.base.isRelocatable()) {
         if (!self.base.isStatic()) {
             if (target.dynamic_linker.get()) |path| {
-                try argv.append("-dynamic-linker");
-                try argv.append(path);
+                try argv.appendSlice(gpa, &.{ "-dynamic-linker", try arena.dupe(u8, path) });
             }
         }
 
         if (self.base.isDynLib()) {
             if (self.soname) |name| {
-                try argv.append("-soname");
-                try argv.append(name);
+                try argv.append(gpa, "-soname");
+                try argv.append(gpa, name);
             }
         }
 
         if (self.entry_name) |name| {
-            try argv.appendSlice(&.{ "--entry", name });
+            try argv.appendSlice(gpa, &.{ "--entry", name });
         }
 
         for (self.rpath_table.keys()) |rpath| {
-            try argv.appendSlice(&.{ "-rpath", rpath });
+            try argv.appendSlice(gpa, &.{ "-rpath", rpath });
         }
 
-        try argv.appendSlice(&.{
+        try argv.appendSlice(gpa, &.{
             "-z",
             try std.fmt.allocPrint(arena, "stack-size={d}", .{self.base.stack_size}),
         });
 
-        try argv.append(try std.fmt.allocPrint(arena, "--image-base={d}", .{self.image_base}));
+        try argv.append(gpa, try std.fmt.allocPrint(arena, "--image-base={d}", .{self.image_base}));
 
         if (self.base.gc_sections) {
-            try argv.append("--gc-sections");
+            try argv.append(gpa, "--gc-sections");
         }
 
         if (self.base.print_gc_sections) {
-            try argv.append("--print-gc-sections");
+            try argv.append(gpa, "--print-gc-sections");
         }
 
         if (comp.link_eh_frame_hdr) {
-            try argv.append("--eh-frame-hdr");
+            try argv.append(gpa, "--eh-frame-hdr");
         }
 
         if (comp.config.rdynamic) {
-            try argv.append("--export-dynamic");
+            try argv.append(gpa, "--export-dynamic");
         }
 
         if (self.z_notext) {
-            try argv.append("-z");
-            try argv.append("notext");
+            try argv.append(gpa, "-z");
+            try argv.append(gpa, "notext");
         }
 
         if (self.z_nocopyreloc) {
-            try argv.append("-z");
-            try argv.append("nocopyreloc");
+            try argv.append(gpa, "-z");
+            try argv.append(gpa, "nocopyreloc");
         }
 
         if (self.z_now) {
-            try argv.append("-z");
-            try argv.append("now");
+            try argv.append(gpa, "-z");
+            try argv.append(gpa, "now");
         }
 
         if (self.base.isStatic()) {
-            try argv.append("-static");
+            try argv.append(gpa, "-static");
         } else if (self.isEffectivelyDynLib()) {
-            try argv.append("-shared");
+            try argv.append(gpa, "-shared");
         }
 
         if (comp.config.pie and self.base.isExe()) {
-            try argv.append("-pie");
+            try argv.append(gpa, "-pie");
         }
 
         if (comp.config.debug_format == .strip) {
-            try argv.append("-s");
-        }
-
-        // csu prelude
-        if (csu.crt0) |path| try argv.append(try path.toString(arena));
-        if (csu.crti) |path| try argv.append(try path.toString(arena));
-        if (csu.crtbegin) |path| try argv.append(try path.toString(arena));
-
-        for (self.lib_dirs) |lib_dir| {
-            try argv.append("-L");
-            try argv.append(lib_dir);
-        }
-
-        if (comp.config.link_libc) {
-            if (self.base.comp.libc_installation) |libc_installation| {
-                try argv.append("-L");
-                try argv.append(libc_installation.crt_dir.?);
-            }
-        }
-
-        var whole_archive = false;
-        for (comp.objects) |obj| {
-            if (obj.must_link and !whole_archive) {
-                try argv.append("-whole-archive");
-                whole_archive = true;
-            } else if (!obj.must_link and whole_archive) {
-                try argv.append("-no-whole-archive");
-                whole_archive = false;
-            }
-
-            if (obj.loption) {
-                try argv.append("-l");
-            }
-            try argv.append(try obj.path.toString(arena));
-        }
-        if (whole_archive) {
-            try argv.append("-no-whole-archive");
-            whole_archive = false;
-        }
-
-        for (comp.c_object_table.keys()) |key| {
-            try argv.append(try key.status.success.object_path.toString(arena));
-        }
-
-        if (module_obj_path) |p| {
-            try argv.append(p);
-        }
-
-        if (comp.config.any_sanitize_thread) {
-            try argv.append(try comp.tsan_lib.?.full_object_path.toString(arena));
-        }
-
-        if (comp.config.any_fuzz) {
-            try argv.append(try comp.fuzzer_lib.?.full_object_path.toString(arena));
-        }
-
-        // libc
-        if (!comp.skip_linker_dependencies and !comp.config.link_libc) {
-            if (comp.libc_static_lib) |lib| {
-                try argv.append(try lib.full_object_path.toString(arena));
-            }
-        }
-
-        // Shared libraries.
-        // Worst-case, we need an --as-needed argument for every lib, as well
-        // as one before and one after.
-        try argv.ensureUnusedCapacity(self.base.comp.system_libs.keys().len * 2 + 2);
-        argv.appendAssumeCapacity("--as-needed");
-        var as_needed = true;
-
-        for (self.base.comp.system_libs.values()) |lib_info| {
-            const lib_as_needed = !lib_info.needed;
-            switch ((@as(u2, @intFromBool(lib_as_needed)) << 1) | @intFromBool(as_needed)) {
-                0b00, 0b11 => {},
-                0b01 => {
-                    argv.appendAssumeCapacity("--no-as-needed");
-                    as_needed = false;
-                },
-                0b10 => {
-                    argv.appendAssumeCapacity("--as-needed");
-                    as_needed = true;
-                },
-            }
-            argv.appendAssumeCapacity(try lib_info.path.?.toString(arena));
-        }
-
-        if (!as_needed) {
-            argv.appendAssumeCapacity("--as-needed");
-            as_needed = true;
+            try argv.append(gpa, "-s");
         }
 
-        // libc++ dep
-        if (comp.config.link_libcpp) {
-            try argv.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
-            try argv.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
-        }
-
-        // libunwind dep
-        if (comp.config.link_libunwind) {
-            try argv.append(try comp.libunwind_static_lib.?.full_object_path.toString(arena));
-        }
-
-        // libc dep
         if (comp.config.link_libc) {
-            if (self.base.comp.libc_installation != null) {
-                const needs_grouping = link_mode == .static;
-                if (needs_grouping) try argv.append("--start-group");
-                try argv.appendSlice(target_util.libcFullLinkFlags(target));
-                if (needs_grouping) try argv.append("--end-group");
-            } else if (target.isGnuLibC()) {
-                for (glibc.libs) |lib| {
-                    if (lib.removed_in) |rem_in| {
-                        if (target.os.version_range.linux.glibc.order(rem_in) != .lt) continue;
-                    }
-
-                    const lib_path = try std.fmt.allocPrint(arena, "{s}{c}lib{s}.so.{d}", .{
-                        comp.glibc_so_files.?.dir_path, fs.path.sep, lib.name, lib.sover,
-                    });
-                    try argv.append(lib_path);
-                }
-                try argv.append(try comp.crtFileAsString(arena, "libc_nonshared.a"));
-            } else if (target.isMusl()) {
-                try argv.append(try comp.crtFileAsString(arena, switch (link_mode) {
-                    .static => "libc.a",
-                    .dynamic => "libc.so",
-                }));
+            if (self.base.comp.libc_installation) |lci| {
+                try argv.append(gpa, "-L");
+                try argv.append(gpa, lci.crt_dir.?);
             }
         }
-
-        // compiler-rt
-        if (compiler_rt_path) |p| {
-            try argv.append(p);
-        }
-
-        // crt postlude
-        if (csu.crtend) |path| try argv.append(try path.toString(arena));
-        if (csu.crtn) |path| try argv.append(try path.toString(arena));
     }
-
-    Compilation.dump_argv(argv.items);
 }
 
-pub const ParseError = error{
-    /// Indicates the error is already reported on `Compilation.link_errors`.
-    LinkFailure,
-
-    OutOfMemory,
-    Overflow,
-    InputOutput,
-    EndOfStream,
-    FileSystem,
-    NotSupported,
-    InvalidCharacter,
-    UnknownFileType,
-} || LdScript.Error || fs.Dir.AccessError || fs.File.SeekError || fs.File.OpenError || fs.File.ReadError;
-
-fn parseCrtFileReportingFailure(self: *Elf, crt_file: Compilation.CrtFile) error{OutOfMemory}!void {
-    if (crt_file.isObject()) {
-        try parseObjectReportingFailure(self, crt_file.full_object_path);
-    } else {
-        try parseLibraryReportingFailure(self, .{ .path = crt_file.full_object_path }, false);
-    }
-}
-
-pub fn parseObjectReportingFailure(self: *Elf, path: Path) error{OutOfMemory}!void {
-    self.parseObject(path) catch |err| switch (err) {
-        error.LinkFailure => return, // already reported
-        error.OutOfMemory => return error.OutOfMemory,
-        else => |e| try self.addParseError(path, "unable to parse object: {s}", .{@errorName(e)}),
+pub fn openParseObjectReportingFailure(self: *Elf, path: Path) void {
+    const diags = &self.base.comp.link_diags;
+    const obj = link.openObject(path, false, false) catch |err| {
+        switch (diags.failParse(path, "failed to open object: {s}", .{@errorName(err)})) {
+            error.LinkFailure => return,
+        }
     };
+    self.parseObjectReportingFailure(obj);
 }
 
-pub fn parseLibraryReportingFailure(self: *Elf, lib: SystemLib, must_link: bool) error{OutOfMemory}!void {
-    self.parseLibrary(lib, must_link) catch |err| switch (err) {
+fn parseObjectReportingFailure(self: *Elf, obj: link.Input.Object) void {
+    const diags = &self.base.comp.link_diags;
+    self.parseObject(obj) catch |err| switch (err) {
         error.LinkFailure => return, // already reported
-        error.OutOfMemory => return error.OutOfMemory,
-        else => |e| try self.addParseError(lib.path, "unable to parse library: {s}", .{@errorName(e)}),
+        else => |e| diags.addParseError(obj.path, "failed to parse object: {s}", .{@errorName(e)}),
     };
 }
 
-fn parseLibrary(self: *Elf, lib: SystemLib, must_link: bool) ParseError!void {
-    const tracy = trace(@src());
-    defer tracy.end();
-    if (try Archive.isArchive(lib.path)) {
-        try self.parseArchive(lib.path, must_link);
-    } else if (try SharedObject.isSharedObject(lib.path)) {
-        try self.parseSharedObject(lib);
-    } else {
-        try self.parseLdScript(lib);
-    }
-}
-
-fn parseObject(self: *Elf, path: Path) ParseError!void {
+fn parseObject(self: *Elf, obj: link.Input.Object) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
     const gpa = self.base.comp.gpa;
-    const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
-    const fh = try self.addFileHandle(handle);
+    const diags = &self.base.comp.link_diags;
+    const first_eflags = &self.first_eflags;
+    const target = self.base.comp.root_mod.resolved_target.result;
+    const debug_fmt_strip = self.base.comp.config.debug_format == .strip;
+    const default_sym_version = self.default_sym_version;
+    const file_handles = &self.file_handles;
+
+    const handle = obj.file;
+    const fh = try addFileHandle(gpa, file_handles, handle);
 
     const index: File.Index = @intCast(try self.files.addOne(gpa));
     self.files.set(index, .{ .object = .{
         .path = .{
-            .root_dir = path.root_dir,
-            .sub_path = try gpa.dupe(u8, path.sub_path),
+            .root_dir = obj.path.root_dir,
+            .sub_path = try gpa.dupe(u8, obj.path.sub_path),
         },
         .file_handle = fh,
         .index = index,
@@ -1378,206 +1145,117 @@ fn parseObject(self: *Elf, path: Path) ParseError!void {
     try self.objects.append(gpa, index);
 
     const object = self.file(index).?.object;
-    try object.parse(self);
-}
-
-fn parseArchive(self: *Elf, path: Path, must_link: bool) ParseError!void {
+    try object.parseCommon(gpa, diags, obj.path, handle, target, first_eflags);
+    if (!self.base.isStaticLib()) {
+        try object.parse(gpa, diags, obj.path, handle, target, debug_fmt_strip, default_sym_version);
+    }
+}
+
+fn parseArchive(
+    gpa: Allocator,
+    diags: *Diags,
+    file_handles: *std.ArrayListUnmanaged(File.Handle),
+    files: *std.MultiArrayList(File.Entry),
+    first_eflags: *?elf.Word,
+    target: std.Target,
+    debug_fmt_strip: bool,
+    default_sym_version: elf.Versym,
+    objects: *std.ArrayListUnmanaged(File.Index),
+    obj: link.Input.Object,
+    is_static_lib: bool,
+) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    const gpa = self.base.comp.gpa;
-    const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
-    const fh = try self.addFileHandle(handle);
-
-    var archive: Archive = .{};
+    const fh = try addFileHandle(gpa, file_handles, obj.file);
+    var archive = try Archive.parse(gpa, diags, file_handles, obj.path, fh);
     defer archive.deinit(gpa);
-    try archive.parse(self, path, fh);
 
-    const objects = try archive.objects.toOwnedSlice(gpa);
-    defer gpa.free(objects);
+    const init_alive = if (is_static_lib) true else obj.must_link;
 
-    for (objects) |extracted| {
-        const index: File.Index = @intCast(try self.files.addOne(gpa));
-        self.files.set(index, .{ .object = extracted });
-        const object = &self.files.items(.data)[index].object;
+    for (archive.objects) |extracted| {
+        const index: File.Index = @intCast(try files.addOne(gpa));
+        files.set(index, .{ .object = extracted });
+        const object = &files.items(.data)[index].object;
         object.index = index;
-        object.alive = must_link;
-        try object.parse(self);
-        try self.objects.append(gpa, index);
+        object.alive = init_alive;
+        try object.parseCommon(gpa, diags, obj.path, obj.file, target, first_eflags);
+        if (!is_static_lib)
+            try object.parse(gpa, diags, obj.path, obj.file, target, debug_fmt_strip, default_sym_version);
+        try objects.append(gpa, index);
     }
 }
 
-fn parseSharedObject(self: *Elf, lib: SystemLib) ParseError!void {
+fn parseDso(
+    gpa: Allocator,
+    diags: *Diags,
+    dso: link.Input.Dso,
+    shared_objects: *std.StringArrayHashMapUnmanaged(File.Index),
+    files: *std.MultiArrayList(File.Entry),
+    target: std.Target,
+) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    const gpa = self.base.comp.gpa;
-    const handle = try lib.path.root_dir.handle.openFile(lib.path.sub_path, .{});
-    defer handle.close();
-
-    const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
-    self.files.set(index, .{ .shared_object = .{
-        .path = .{
-            .root_dir = lib.path.root_dir,
-            .sub_path = try gpa.dupe(u8, lib.path.sub_path),
-        },
-        .index = index,
-        .needed = lib.needed,
-        .alive = lib.needed,
-    } });
-    try self.shared_objects.append(gpa, index);
-
-    const shared_object = self.file(index).?.shared_object;
-    try shared_object.parse(self, handle);
-}
+    const handle = dso.file;
 
-fn parseLdScript(self: *Elf, lib: SystemLib) ParseError!void {
-    const tracy = trace(@src());
-    defer tracy.end();
+    const stat = Stat.fromFs(try handle.stat());
+    var header = try SharedObject.parseHeader(gpa, diags, dso.path, handle, stat, target);
+    defer header.deinit(gpa);
 
-    const gpa = self.base.comp.gpa;
-    const in_file = try lib.path.root_dir.handle.openFile(lib.path.sub_path, .{});
-    defer in_file.close();
-    const data = try in_file.readToEndAlloc(gpa, std.math.maxInt(u32));
-    defer gpa.free(data);
-
-    var script: LdScript = .{ .path = lib.path };
-    defer script.deinit(gpa);
-    try script.parse(data, self);
-
-    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
-    defer arena_allocator.deinit();
-    const arena = arena_allocator.allocator();
-
-    var test_path = std.ArrayList(u8).init(arena);
-    var checked_paths = std.ArrayList([]const u8).init(arena);
-
-    for (script.args.items) |script_arg| {
-        checked_paths.clearRetainingCapacity();
-
-        success: {
-            if (mem.startsWith(u8, script_arg.path, "-l")) {
-                const lib_name = script_arg.path["-l".len..];
-
-                // TODO I think technically we should re-use the mechanism used by the frontend here.
-                // Maybe we should hoist search-strategy all the way here?
-                for (self.lib_dirs) |lib_dir| {
-                    if (!self.base.isStatic()) {
-                        if (try self.accessLibPath(arena, &test_path, &checked_paths, lib_dir, lib_name, .dynamic))
-                            break :success;
-                    }
-                    if (try self.accessLibPath(arena, &test_path, &checked_paths, lib_dir, lib_name, .static))
-                        break :success;
-                }
-            } else {
-                var buffer: [fs.max_path_bytes]u8 = undefined;
-                if (fs.realpath(script_arg.path, &buffer)) |path| {
-                    test_path.clearRetainingCapacity();
-                    try test_path.writer().writeAll(path);
-                    break :success;
-                } else |_| {}
-
-                try checked_paths.append(try arena.dupe(u8, script_arg.path));
-                for (self.lib_dirs) |lib_dir| {
-                    if (try self.accessLibPath(arena, &test_path, &checked_paths, lib_dir, script_arg.path, null))
-                        break :success;
-                }
-            }
+    const soname = header.soname() orelse dso.path.basename();
 
-            try self.reportMissingLibraryError(
-                checked_paths.items,
-                "missing library dependency: GNU ld script '{}' requires '{s}', but file not found",
-                .{ @as(Path, lib.path), script_arg.path },
-            );
-            continue;
-        }
-
-        const full_path = Path.initCwd(test_path.items);
-        self.parseLibrary(.{
-            .needed = script_arg.needed,
-            .path = full_path,
-        }, false) catch |err| switch (err) {
-            error.LinkFailure => continue, // already reported
-            else => |e| try self.addParseError(
-                full_path,
-                "unexpected error: parsing library failed with error {s}",
-                .{@errorName(e)},
-            ),
-        };
-    }
-}
+    const gop = try shared_objects.getOrPut(gpa, soname);
+    if (gop.found_existing) return;
+    errdefer _ = shared_objects.pop();
 
-pub fn validateEFlags(self: *Elf, file_index: File.Index, e_flags: elf.Elf64_Word) !void {
-    if (self.first_eflags == null) {
-        self.first_eflags = e_flags;
-        return; // there isn't anything to conflict with yet
-    }
-    const self_eflags: *elf.Elf64_Word = &self.first_eflags.?;
+    const index: File.Index = @intCast(try files.addOne(gpa));
+    errdefer _ = files.pop();
 
-    switch (self.getTarget().cpu.arch) {
-        .riscv64 => {
-            if (e_flags != self_eflags.*) {
-                const riscv_eflags: riscv.RiscvEflags = @bitCast(e_flags);
-                const self_riscv_eflags: *riscv.RiscvEflags = @ptrCast(self_eflags);
+    gop.value_ptr.* = index;
 
-                self_riscv_eflags.rvc = self_riscv_eflags.rvc or riscv_eflags.rvc;
-                self_riscv_eflags.tso = self_riscv_eflags.tso or riscv_eflags.tso;
+    var parsed = try SharedObject.parse(gpa, &header, handle);
+    errdefer parsed.deinit(gpa);
 
-                var any_errors: bool = false;
-                if (self_riscv_eflags.fabi != riscv_eflags.fabi) {
-                    any_errors = true;
-                    try self.addFileError(
-                        file_index,
-                        "cannot link object files with different float-point ABIs",
-                        .{},
-                    );
-                }
-                if (self_riscv_eflags.rve != riscv_eflags.rve) {
-                    any_errors = true;
-                    try self.addFileError(
-                        file_index,
-                        "cannot link object files with different RVEs",
-                        .{},
-                    );
-                }
-                if (any_errors) return error.LinkFailure;
-            }
+    const duped_path: Path = .{
+        .root_dir = dso.path.root_dir,
+        .sub_path = try gpa.dupe(u8, dso.path.sub_path),
+    };
+    errdefer gpa.free(duped_path.sub_path);
+
+    files.set(index, .{
+        .shared_object = .{
+            .parsed = parsed,
+            .path = duped_path,
+            .index = index,
+            .needed = dso.needed,
+            .alive = dso.needed,
+            .aliases = null,
+            .symbols = .empty,
+            .symbols_extra = .empty,
+            .symbols_resolver = .empty,
+            .output_symtab_ctx = .{},
         },
-        else => {},
-    }
-}
-
-fn accessLibPath(
-    self: *Elf,
-    arena: Allocator,
-    test_path: *std.ArrayList(u8),
-    checked_paths: ?*std.ArrayList([]const u8),
-    lib_dir_path: []const u8,
-    lib_name: []const u8,
-    link_mode: ?std.builtin.LinkMode,
-) !bool {
-    const sep = fs.path.sep_str;
-    const target = self.getTarget();
-    test_path.clearRetainingCapacity();
-    const prefix = if (link_mode != null) "lib" else "";
-    const suffix = if (link_mode) |mode| switch (mode) {
-        .static => target.staticLibSuffix(),
-        .dynamic => target.dynamicLibSuffix(),
-    } else "";
-    try test_path.writer().print("{s}" ++ sep ++ "{s}{s}{s}", .{
-        lib_dir_path,
-        prefix,
-        lib_name,
-        suffix,
     });
-    if (checked_paths) |cpaths| {
-        try cpaths.append(try arena.dupe(u8, test_path.items));
+    const so = fileLookup(files.*, index, null).?.shared_object;
+
+    // TODO: save this work for later
+    const nsyms = parsed.symbols.len;
+    try so.symbols.ensureTotalCapacityPrecise(gpa, nsyms);
+    try so.symbols_extra.ensureTotalCapacityPrecise(gpa, nsyms * @typeInfo(Symbol.Extra).@"struct".fields.len);
+    try so.symbols_resolver.ensureTotalCapacityPrecise(gpa, nsyms);
+    so.symbols_resolver.appendNTimesAssumeCapacity(0, nsyms);
+
+    for (parsed.symtab, parsed.symbols, parsed.versyms, 0..) |esym, sym, versym, i| {
+        const out_sym_index = so.addSymbolAssumeCapacity();
+        const out_sym = &so.symbols.items[out_sym_index];
+        out_sym.value = @intCast(esym.st_value);
+        out_sym.name_offset = sym.mangled_name;
+        out_sym.ref = .{ .index = 0, .file = 0 };
+        out_sym.esym_index = @intCast(i);
+        out_sym.version_index = versym;
+        out_sym.extra_index = so.addSymbolExtraAssumeCapacity(.{});
     }
-    fs.cwd().access(test_path.items, .{}) catch |err| switch (err) {
-        error.FileNotFound => return false,
-        else => |e| return e,
-    };
-    return true;
 }
 
 /// When resolving symbols, we approach the problem similarly to `mold`.
@@ -1588,11 +1266,14 @@ fn accessLibPath(
 /// 5. Remove references to dead objects/shared objects
 /// 6. Re-run symbol resolution on pruned objects and shared objects sets.
 pub fn resolveSymbols(self: *Elf) !void {
+    // This function mutates `shared_objects`.
+    const shared_objects = &self.shared_objects;
+
     // Resolve symbols in the ZigObject. For now, we assume that it's always live.
     if (self.zigObjectPtr()) |zo| try zo.asFile().resolveSymbols(self);
     // Resolve symbols on the set of all objects and shared objects (even if some are unneeded).
     for (self.objects.items) |index| try self.file(index).?.resolveSymbols(self);
-    for (self.shared_objects.items) |index| try self.file(index).?.resolveSymbols(self);
+    for (shared_objects.values()) |index| try self.file(index).?.resolveSymbols(self);
     if (self.linkerDefinedPtr()) |obj| try obj.asFile().resolveSymbols(self);
 
     // Mark live objects.
@@ -1609,11 +1290,14 @@ pub fn resolveSymbols(self: *Elf) !void {
             _ = self.objects.orderedRemove(i);
         } else i += 1;
     }
+    // TODO This loop has 2 major flaws:
+    // 1. It is O(N^2) which is never allowed in the codebase.
+    // 2. It mutates shared_objects, which is a non-starter for incremental compilation.
     i = 0;
-    while (i < self.shared_objects.items.len) {
-        const index = self.shared_objects.items[i];
+    while (i < shared_objects.values().len) {
+        const index = shared_objects.values()[i];
         if (!self.file(index).?.isAlive()) {
-            _ = self.shared_objects.orderedRemove(i);
+            _ = shared_objects.orderedRemoveAt(i);
         } else i += 1;
     }
 
@@ -1634,7 +1318,7 @@ pub fn resolveSymbols(self: *Elf) !void {
     // Re-resolve the symbols.
     if (self.zigObjectPtr()) |zo| try zo.asFile().resolveSymbols(self);
     for (self.objects.items) |index| try self.file(index).?.resolveSymbols(self);
-    for (self.shared_objects.items) |index| try self.file(index).?.resolveSymbols(self);
+    for (shared_objects.values()) |index| try self.file(index).?.resolveSymbols(self);
     if (self.linkerDefinedPtr()) |obj| try obj.asFile().resolveSymbols(self);
 }
 
@@ -1643,12 +1327,13 @@ pub fn resolveSymbols(self: *Elf) !void {
 /// This routine will prune unneeded objects extracted from archives and
 /// unneeded shared objects.
 fn markLive(self: *Elf) void {
+    const shared_objects = self.shared_objects.values();
     if (self.zigObjectPtr()) |zig_object| zig_object.asFile().markLive(self);
     for (self.objects.items) |index| {
         const file_ptr = self.file(index).?;
         if (file_ptr.isAlive()) file_ptr.markLive(self);
     }
-    for (self.shared_objects.items) |index| {
+    for (shared_objects) |index| {
         const file_ptr = self.file(index).?;
         if (file_ptr.isAlive()) file_ptr.markLive(self);
     }
@@ -1663,6 +1348,7 @@ pub fn markEhFrameAtomsDead(self: *Elf) void {
 }
 
 fn markImportsExports(self: *Elf) void {
+    const shared_objects = self.shared_objects.values();
     if (self.zigObjectPtr()) |zo| {
         zo.markImportsExports(self);
     }
@@ -1670,7 +1356,7 @@ fn markImportsExports(self: *Elf) void {
         self.file(index).?.object.markImportsExports(self);
     }
     if (!self.isEffectivelyDynLib()) {
-        for (self.shared_objects.items) |index| {
+        for (shared_objects) |index| {
             self.file(index).?.shared_object.markImportExports(self);
         }
     }
@@ -1691,6 +1377,7 @@ fn claimUnresolved(self: *Elf) void {
 /// alloc sections.
 fn scanRelocs(self: *Elf) !void {
     const gpa = self.base.comp.gpa;
+    const shared_objects = self.shared_objects.values();
 
     var undefs = std.AutoArrayHashMap(SymbolResolver.Index, std.ArrayList(Ref)).init(gpa);
     defer {
@@ -1734,7 +1421,7 @@ fn scanRelocs(self: *Elf) !void {
     for (self.objects.items) |index| {
         try self.file(index).?.createSymbolIndirection(self);
     }
-    for (self.shared_objects.items) |index| {
+    for (shared_objects) |index| {
         try self.file(index).?.createSymbolIndirection(self);
     }
     if (self.linkerDefinedPtr()) |obj| {
@@ -1760,7 +1447,7 @@ pub fn initOutputSection(self: *Elf, args: struct {
             ".dtors",      ".gnu.warning",
         };
         inline for (name_prefixes) |prefix| {
-            if (std.mem.eql(u8, args.name, prefix) or std.mem.startsWith(u8, args.name, prefix ++ ".")) {
+            if (mem.eql(u8, args.name, prefix) or mem.startsWith(u8, args.name, prefix ++ ".")) {
                 break :blk prefix;
             }
         }
@@ -1772,9 +1459,9 @@ pub fn initOutputSection(self: *Elf, args: struct {
         switch (args.type) {
             elf.SHT_NULL => unreachable,
             elf.SHT_PROGBITS => {
-                if (std.mem.eql(u8, args.name, ".init_array") or std.mem.startsWith(u8, args.name, ".init_array."))
+                if (mem.eql(u8, args.name, ".init_array") or mem.startsWith(u8, args.name, ".init_array."))
                     break :tt elf.SHT_INIT_ARRAY;
-                if (std.mem.eql(u8, args.name, ".fini_array") or std.mem.startsWith(u8, args.name, ".fini_array."))
+                if (mem.eql(u8, args.name, ".fini_array") or mem.startsWith(u8, args.name, ".fini_array."))
                     break :tt elf.SHT_FINI_ARRAY;
                 break :tt args.type;
             },
@@ -1807,6 +1494,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
 
     const comp = self.base.comp;
     const gpa = comp.gpa;
+    const diags = &comp.link_diags;
 
     const directory = self.base.emit.root_dir; // Just an alias to make it shorter to type.
     const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
@@ -1851,10 +1539,10 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
     // our digest. If so, we can skip linking. Otherwise, we proceed with invoking LLD.
     const id_symlink_basename = "lld.id";
 
-    var man: Cache.Manifest = undefined;
+    var man: std.Build.Cache.Manifest = undefined;
     defer if (!self.base.disable_lld_caching) man.deinit();
 
-    var digest: [Cache.hex_digest_len]u8 = undefined;
+    var digest: [std.Build.Cache.hex_digest_len]u8 = undefined;
 
     if (!self.base.disable_lld_caching) {
         man = comp.cache_parent.obtain();
@@ -1868,11 +1556,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         try man.addOptionalFile(self.version_script);
         man.hash.add(self.allow_undefined_version);
         man.hash.addOptional(self.enable_new_dtags);
-        for (comp.objects) |obj| {
-            _ = try man.addFilePath(obj.path, null);
-            man.hash.add(obj.must_link);
-            man.hash.add(obj.loption);
-        }
+        try link.hashInputs(&man, comp.link_inputs);
         for (comp.c_object_table.keys()) |key| {
             _ = try man.addFilePath(key.status.success.object_path, null);
         }
@@ -1890,7 +1574,6 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         man.hash.add(comp.link_eh_frame_hdr);
         man.hash.add(self.emit_relocs);
         man.hash.add(comp.config.rdynamic);
-        man.hash.addListOfBytes(self.lib_dirs);
         man.hash.addListOfBytes(self.rpath_table.keys());
         if (output_mode == .Exe) {
             man.hash.add(self.base.stack_size);
@@ -1920,7 +1603,6 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         }
         man.hash.addOptionalBytes(self.soname);
         man.hash.addOptional(comp.version);
-        try link.hashAddSystemLibs(&man, comp.system_libs);
         man.hash.addListOfBytes(comp.force_undefined_symbols.keys());
         man.hash.add(self.base.allow_shlib_undefined);
         man.hash.add(self.bind_global_refs_locally);
@@ -1934,7 +1616,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         digest = man.final();
 
         var prev_digest_buf: [digest.len]u8 = undefined;
-        const prev_digest: []u8 = Cache.readSmallFile(
+        const prev_digest: []u8 = std.Build.Cache.readSmallFile(
             directory.handle,
             id_symlink_basename,
             &prev_digest_buf,
@@ -1962,15 +1644,12 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
     // copy when generating relocatables. Normally, we would expect `lld -r` to work.
     // However, because LLD wants to resolve BPF relocations which it shouldn't, it fails
     // before even generating the relocatable.
-    if (output_mode == .Obj and
-        (comp.config.lto or target.isBpfFreestanding()))
-    {
+    if (output_mode == .Obj and (comp.config.lto or target.cpu.arch.isBpf())) {
         // In this case we must do a simple file copy
         // here. TODO: think carefully about how we can avoid this redundant operation when doing
         // build-obj. See also the corresponding TODO in linkAsArchive.
         const the_object_path = blk: {
-            if (comp.objects.len != 0)
-                break :blk comp.objects[0].path;
+            if (link.firstObjectInput(comp.link_inputs)) |obj| break :blk obj.path;
 
             if (comp.c_object_table.count() != 0)
                 break :blk comp.c_object_table.keys()[0].status.success.object_path;
@@ -2144,7 +1823,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
         }
 
         if (link_mode == .static) {
-            if (target.cpu.arch.isArmOrThumb()) {
+            if (target.cpu.arch.isArm()) {
                 try argv.append("-Bstatic");
             } else {
                 try argv.append("-static");
@@ -2186,11 +1865,6 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
             try argv.appendSlice(&.{ "-wrap", symbol_name });
         }
 
-        for (self.lib_dirs) |lib_dir| {
-            try argv.append("-L");
-            try argv.append(lib_dir);
-        }
-
         if (comp.config.link_libc) {
             if (comp.libc_installation) |libc_installation| {
                 try argv.append("-L");
@@ -2230,21 +1904,26 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
 
         // Positional arguments to the linker such as object files.
         var whole_archive = false;
-        for (comp.objects) |obj| {
-            if (obj.must_link and !whole_archive) {
-                try argv.append("-whole-archive");
-                whole_archive = true;
-            } else if (!obj.must_link and whole_archive) {
-                try argv.append("-no-whole-archive");
-                whole_archive = false;
-            }
 
-            if (obj.loption) {
-                assert(obj.path.sub_path[0] == ':');
-                try argv.append("-l");
-            }
-            try argv.append(try obj.path.toString(arena));
-        }
+        for (self.base.comp.link_inputs) |link_input| switch (link_input) {
+            .res => unreachable, // Windows-only
+            .dso => continue,
+            .object, .archive => |obj| {
+                if (obj.must_link and !whole_archive) {
+                    try argv.append("-whole-archive");
+                    whole_archive = true;
+                } else if (!obj.must_link and whole_archive) {
+                    try argv.append("-no-whole-archive");
+                    whole_archive = false;
+                }
+                try argv.append(try obj.path.toString(arena));
+            },
+            .dso_exact => |dso_exact| {
+                assert(dso_exact.name[0] == ':');
+                try argv.appendSlice(&.{ "-l", dso_exact.name });
+            },
+        };
+
         if (whole_archive) {
             try argv.append("-no-whole-archive");
             whole_archive = false;
@@ -2280,35 +1959,36 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
 
         // Shared libraries.
         if (is_exe_or_dyn_lib) {
-            const system_libs = comp.system_libs.keys();
-            const system_libs_values = comp.system_libs.values();
-
             // Worst-case, we need an --as-needed argument for every lib, as well
             // as one before and one after.
-            try argv.ensureUnusedCapacity(system_libs.len * 2 + 2);
+            try argv.ensureUnusedCapacity(2 * self.base.comp.link_inputs.len + 2);
             argv.appendAssumeCapacity("--as-needed");
             var as_needed = true;
 
-            for (system_libs_values) |lib_info| {
-                const lib_as_needed = !lib_info.needed;
-                switch ((@as(u2, @intFromBool(lib_as_needed)) << 1) | @intFromBool(as_needed)) {
-                    0b00, 0b11 => {},
-                    0b01 => {
-                        argv.appendAssumeCapacity("--no-as-needed");
-                        as_needed = false;
-                    },
-                    0b10 => {
-                        argv.appendAssumeCapacity("--as-needed");
-                        as_needed = true;
-                    },
-                }
+            for (self.base.comp.link_inputs) |link_input| switch (link_input) {
+                .res => unreachable, // Windows-only
+                .object, .archive, .dso_exact => continue,
+                .dso => |dso| {
+                    const lib_as_needed = !dso.needed;
+                    switch ((@as(u2, @intFromBool(lib_as_needed)) << 1) | @intFromBool(as_needed)) {
+                        0b00, 0b11 => {},
+                        0b01 => {
+                            argv.appendAssumeCapacity("--no-as-needed");
+                            as_needed = false;
+                        },
+                        0b10 => {
+                            argv.appendAssumeCapacity("--as-needed");
+                            as_needed = true;
+                        },
+                    }
 
-                // By this time, we depend on these libs being dynamically linked
-                // libraries and not static libraries (the check for that needs to be earlier),
-                // but they could be full paths to .so files, in which case we
-                // want to avoid prepending "-l".
-                argv.appendAssumeCapacity(try lib_info.path.?.toString(arena));
-            }
+                    // By this time, we depend on these libs being dynamically linked
+                    // libraries and not static libraries (the check for that needs to be earlier),
+                    // but they could be full paths to .so files, in which case we
+                    // want to avoid prepending "-l".
+                    argv.appendAssumeCapacity(try dso.path.toString(arena));
+                },
+            };
 
             if (!as_needed) {
                 argv.appendAssumeCapacity("--as-needed");
@@ -2327,7 +2007,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
             }
 
             // libc dep
-            comp.link_error_flags.missing_libc = false;
+            diags.flags.missing_libc = false;
             if (comp.config.link_libc) {
                 if (comp.libc_installation != null) {
                     const needs_grouping = link_mode == .static;
@@ -2340,7 +2020,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
                             if (target.os.version_range.linux.glibc.order(rem_in) != .lt) continue;
                         }
 
-                        const lib_path = try std.fmt.allocPrint(arena, "{s}{c}lib{s}.so.{d}", .{
+                        const lib_path = try std.fmt.allocPrint(arena, "{}{c}lib{s}.so.{d}", .{
                             comp.glibc_so_files.?.dir_path, fs.path.sep, lib.name, lib.sover,
                         });
                         try argv.append(lib_path);
@@ -2352,7 +2032,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
                         .dynamic => "libc.so",
                     }));
                 } else {
-                    comp.link_error_flags.missing_libc = true;
+                    diags.flags.missing_libc = true;
                 }
             }
         }
@@ -2388,7 +2068,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
     if (!self.base.disable_lld_caching) {
         // Update the file with the digest. If it fails we can continue; it only
         // means that the next invocation will have an unnecessary cache miss.
-        Cache.writeSmallFile(directory.handle, id_symlink_basename, &digest) catch |err| {
+        std.Build.Cache.writeSmallFile(directory.handle, id_symlink_basename, &digest) catch |err| {
             log.warn("failed to save linking hash digest file: {s}", .{@errorName(err)});
         };
         // Again failure here only means an unnecessary cache miss.
@@ -2461,7 +2141,7 @@ fn writePhdrTable(self: *Elf) !void {
     const gpa = self.base.comp.gpa;
     const target_endian = self.getTarget().cpu.arch.endian();
     const foreign_endian = target_endian != builtin.cpu.arch.endian();
-    const phdr_table = &self.phdrs.items[self.phdr_table_index.?];
+    const phdr_table = &self.phdrs.items[self.phdr_indexes.table.int().?];
 
     log.debug("writing program headers from 0x{x} to 0x{x}", .{
         phdr_table.p_offset,
@@ -2497,7 +2177,8 @@ fn writePhdrTable(self: *Elf) !void {
 }
 
 pub fn writeElfHeader(self: *Elf) !void {
-    if (self.base.hasErrors()) return; // We had errors, so skip flushing to render the output unusable
+    const diags = &self.base.comp.link_diags;
+    if (diags.hasErrors()) return; // We had errors, so skip flushing to render the output unusable
 
     const comp = self.base.comp;
     var hdr_buf: [@sizeOf(elf.Elf64_Ehdr)]u8 = undefined;
@@ -2573,18 +2254,18 @@ pub fn writeElfHeader(self: *Elf) !void {
         const entry_sym = obj.entrySymbol(self) orelse break :blk 0;
         break :blk @intCast(entry_sym.address(.{}, self));
     } else 0;
-    const phdr_table_offset = if (self.phdr_table_index) |phndx| self.phdrs.items[phndx].p_offset else 0;
+    const phdr_table_offset = if (self.phdr_indexes.table.int()) |phndx| self.phdrs.items[phndx].p_offset else 0;
     switch (self.ptr_width) {
         .p32 => {
-            mem.writeInt(u32, hdr_buf[index..][0..4], @as(u32, @intCast(e_entry)), endian);
+            mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(e_entry), endian);
             index += 4;
 
             // e_phoff
-            mem.writeInt(u32, hdr_buf[index..][0..4], @as(u32, @intCast(phdr_table_offset)), endian);
+            mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(phdr_table_offset), endian);
             index += 4;
 
             // e_shoff
-            mem.writeInt(u32, hdr_buf[index..][0..4], @as(u32, @intCast(self.shdr_table_offset.?)), endian);
+            mem.writeInt(u32, hdr_buf[index..][0..4], @intCast(self.shdr_table_offset.?), endian);
             index += 4;
         },
         .p64 => {
@@ -2631,11 +2312,11 @@ pub fn writeElfHeader(self: *Elf) !void {
     mem.writeInt(u16, hdr_buf[index..][0..2], e_shentsize, endian);
     index += 2;
 
-    const e_shnum = @as(u16, @intCast(self.sections.items(.shdr).len));
+    const e_shnum: u16 = @intCast(self.sections.items(.shdr).len);
     mem.writeInt(u16, hdr_buf[index..][0..2], e_shnum, endian);
     index += 2;
 
-    mem.writeInt(u16, hdr_buf[index..][0..2], @intCast(self.shstrtab_section_index.?), endian);
+    mem.writeInt(u16, hdr_buf[index..][0..2], @intCast(self.section_indexes.shstrtab.?), endian);
     index += 2;
 
     assert(index == e_ehsize);
@@ -2844,6 +2525,7 @@ fn initSyntheticSections(self: *Elf) !void {
     const comp = self.base.comp;
     const target = self.getTarget();
     const ptr_size = self.ptrWidthBytes();
+    const shared_objects = self.shared_objects.values();
 
     const needs_eh_frame = blk: {
         if (self.zigObjectPtr()) |zo|
@@ -2853,8 +2535,8 @@ fn initSyntheticSections(self: *Elf) !void {
         } else false;
     };
     if (needs_eh_frame) {
-        if (self.eh_frame_section_index == null) {
-            self.eh_frame_section_index = self.sectionByName(".eh_frame") orelse try self.addSection(.{
+        if (self.section_indexes.eh_frame == null) {
+            self.section_indexes.eh_frame = self.sectionByName(".eh_frame") orelse try self.addSection(.{
                 .name = try self.insertShString(".eh_frame"),
                 .type = if (target.cpu.arch == .x86_64)
                     elf.SHT_X86_64_UNWIND
@@ -2864,8 +2546,8 @@ fn initSyntheticSections(self: *Elf) !void {
                 .addralign = ptr_size,
             });
         }
-        if (comp.link_eh_frame_hdr and self.eh_frame_hdr_section_index == null) {
-            self.eh_frame_hdr_section_index = try self.addSection(.{
+        if (comp.link_eh_frame_hdr and self.section_indexes.eh_frame_hdr == null) {
+            self.section_indexes.eh_frame_hdr = try self.addSection(.{
                 .name = try self.insertShString(".eh_frame_hdr"),
                 .type = elf.SHT_PROGBITS,
                 .flags = elf.SHF_ALLOC,
@@ -2874,8 +2556,8 @@ fn initSyntheticSections(self: *Elf) !void {
         }
     }
 
-    if (self.got.entries.items.len > 0 and self.got_section_index == null) {
-        self.got_section_index = try self.addSection(.{
+    if (self.got.entries.items.len > 0 and self.section_indexes.got == null) {
+        self.section_indexes.got = try self.addSection(.{
             .name = try self.insertShString(".got"),
             .type = elf.SHT_PROGBITS,
             .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
@@ -2883,8 +2565,8 @@ fn initSyntheticSections(self: *Elf) !void {
         });
     }
 
-    if (self.got_plt_section_index == null) {
-        self.got_plt_section_index = try self.addSection(.{
+    if (self.section_indexes.got_plt == null) {
+        self.section_indexes.got_plt = try self.addSection(.{
             .name = try self.insertShString(".got.plt"),
             .type = elf.SHT_PROGBITS,
             .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
@@ -2903,8 +2585,8 @@ fn initSyntheticSections(self: *Elf) !void {
         }
         break :blk false;
     };
-    if (needs_rela_dyn and self.rela_dyn_section_index == null) {
-        self.rela_dyn_section_index = try self.addSection(.{
+    if (needs_rela_dyn and self.section_indexes.rela_dyn == null) {
+        self.section_indexes.rela_dyn = try self.addSection(.{
             .name = try self.insertShString(".rela.dyn"),
             .type = elf.SHT_RELA,
             .flags = elf.SHF_ALLOC,
@@ -2914,16 +2596,16 @@ fn initSyntheticSections(self: *Elf) !void {
     }
 
     if (self.plt.symbols.items.len > 0) {
-        if (self.plt_section_index == null) {
-            self.plt_section_index = try self.addSection(.{
+        if (self.section_indexes.plt == null) {
+            self.section_indexes.plt = try self.addSection(.{
                 .name = try self.insertShString(".plt"),
                 .type = elf.SHT_PROGBITS,
                 .flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR,
                 .addralign = 16,
             });
         }
-        if (self.rela_plt_section_index == null) {
-            self.rela_plt_section_index = try self.addSection(.{
+        if (self.section_indexes.rela_plt == null) {
+            self.section_indexes.rela_plt = try self.addSection(.{
                 .name = try self.insertShString(".rela.plt"),
                 .type = elf.SHT_RELA,
                 .flags = elf.SHF_ALLOC,
@@ -2933,8 +2615,8 @@ fn initSyntheticSections(self: *Elf) !void {
         }
     }
 
-    if (self.plt_got.symbols.items.len > 0 and self.plt_got_section_index == null) {
-        self.plt_got_section_index = try self.addSection(.{
+    if (self.plt_got.symbols.items.len > 0 and self.section_indexes.plt_got == null) {
+        self.section_indexes.plt_got = try self.addSection(.{
             .name = try self.insertShString(".plt.got"),
             .type = elf.SHT_PROGBITS,
             .flags = elf.SHF_ALLOC | elf.SHF_EXECINSTR,
@@ -2942,8 +2624,8 @@ fn initSyntheticSections(self: *Elf) !void {
         });
     }
 
-    if (self.copy_rel.symbols.items.len > 0 and self.copy_rel_section_index == null) {
-        self.copy_rel_section_index = try self.addSection(.{
+    if (self.copy_rel.symbols.items.len > 0 and self.section_indexes.copy_rel == null) {
+        self.section_indexes.copy_rel = try self.addSection(.{
             .name = try self.insertShString(".copyrel"),
             .type = elf.SHT_NOBITS,
             .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
@@ -2959,8 +2641,8 @@ fn initSyntheticSections(self: *Elf) !void {
         if (self.base.isStatic() and !comp.config.pie) break :blk false;
         break :blk target.dynamic_linker.get() != null;
     };
-    if (needs_interp and self.interp_section_index == null) {
-        self.interp_section_index = try self.addSection(.{
+    if (needs_interp and self.section_indexes.interp == null) {
+        self.section_indexes.interp = try self.addSection(.{
             .name = try self.insertShString(".interp"),
             .type = elf.SHT_PROGBITS,
             .flags = elf.SHF_ALLOC,
@@ -2968,9 +2650,9 @@ fn initSyntheticSections(self: *Elf) !void {
         });
     }
 
-    if (self.isEffectivelyDynLib() or self.shared_objects.items.len > 0 or comp.config.pie) {
-        if (self.dynstrtab_section_index == null) {
-            self.dynstrtab_section_index = try self.addSection(.{
+    if (self.isEffectivelyDynLib() or shared_objects.len > 0 or comp.config.pie) {
+        if (self.section_indexes.dynstrtab == null) {
+            self.section_indexes.dynstrtab = try self.addSection(.{
                 .name = try self.insertShString(".dynstr"),
                 .flags = elf.SHF_ALLOC,
                 .type = elf.SHT_STRTAB,
@@ -2978,8 +2660,8 @@ fn initSyntheticSections(self: *Elf) !void {
                 .addralign = 1,
             });
         }
-        if (self.dynamic_section_index == null) {
-            self.dynamic_section_index = try self.addSection(.{
+        if (self.section_indexes.dynamic == null) {
+            self.section_indexes.dynamic = try self.addSection(.{
                 .name = try self.insertShString(".dynamic"),
                 .flags = elf.SHF_ALLOC | elf.SHF_WRITE,
                 .type = elf.SHT_DYNAMIC,
@@ -2987,8 +2669,8 @@ fn initSyntheticSections(self: *Elf) !void {
                 .addralign = @alignOf(elf.Elf64_Dyn),
             });
         }
-        if (self.dynsymtab_section_index == null) {
-            self.dynsymtab_section_index = try self.addSection(.{
+        if (self.section_indexes.dynsymtab == null) {
+            self.section_indexes.dynsymtab = try self.addSection(.{
                 .name = try self.insertShString(".dynsym"),
                 .flags = elf.SHF_ALLOC,
                 .type = elf.SHT_DYNSYM,
@@ -2997,8 +2679,8 @@ fn initSyntheticSections(self: *Elf) !void {
                 .info = 1,
             });
         }
-        if (self.hash_section_index == null) {
-            self.hash_section_index = try self.addSection(.{
+        if (self.section_indexes.hash == null) {
+            self.section_indexes.hash = try self.addSection(.{
                 .name = try self.insertShString(".hash"),
                 .flags = elf.SHF_ALLOC,
                 .type = elf.SHT_HASH,
@@ -3006,8 +2688,8 @@ fn initSyntheticSections(self: *Elf) !void {
                 .entsize = 4,
             });
         }
-        if (self.gnu_hash_section_index == null) {
-            self.gnu_hash_section_index = try self.addSection(.{
+        if (self.section_indexes.gnu_hash == null) {
+            self.section_indexes.gnu_hash = try self.addSection(.{
                 .name = try self.insertShString(".gnu.hash"),
                 .flags = elf.SHF_ALLOC,
                 .type = elf.SHT_GNU_HASH,
@@ -3017,20 +2699,20 @@ fn initSyntheticSections(self: *Elf) !void {
 
         const needs_versions = for (self.dynsym.entries.items) |entry| {
             const sym = self.symbol(entry.ref).?;
-            if (sym.flags.import and sym.version_index & elf.VERSYM_VERSION > elf.VER_NDX_GLOBAL) break true;
+            if (sym.flags.import and sym.version_index.VERSION > elf.Versym.GLOBAL.VERSION) break true;
         } else false;
         if (needs_versions) {
-            if (self.versym_section_index == null) {
-                self.versym_section_index = try self.addSection(.{
+            if (self.section_indexes.versym == null) {
+                self.section_indexes.versym = try self.addSection(.{
                     .name = try self.insertShString(".gnu.version"),
                     .flags = elf.SHF_ALLOC,
                     .type = elf.SHT_GNU_VERSYM,
-                    .addralign = @alignOf(elf.Elf64_Versym),
-                    .entsize = @sizeOf(elf.Elf64_Versym),
+                    .addralign = @alignOf(elf.Versym),
+                    .entsize = @sizeOf(elf.Versym),
                 });
             }
-            if (self.verneed_section_index == null) {
-                self.verneed_section_index = try self.addSection(.{
+            if (self.section_indexes.verneed == null) {
+                self.section_indexes.verneed = try self.addSection(.{
                     .name = try self.insertShString(".gnu.version_r"),
                     .flags = elf.SHF_ALLOC,
                     .type = elf.SHT_GNU_VERNEED,
@@ -3049,16 +2731,16 @@ pub fn initSymtab(self: *Elf) !void {
         .p32 => true,
         .p64 => false,
     };
-    if (self.symtab_section_index == null) {
-        self.symtab_section_index = try self.addSection(.{
+    if (self.section_indexes.symtab == null) {
+        self.section_indexes.symtab = try self.addSection(.{
             .name = try self.insertShString(".symtab"),
             .type = elf.SHT_SYMTAB,
             .addralign = if (small_ptr) @alignOf(elf.Elf32_Sym) else @alignOf(elf.Elf64_Sym),
             .entsize = if (small_ptr) @sizeOf(elf.Elf32_Sym) else @sizeOf(elf.Elf64_Sym),
         });
     }
-    if (self.strtab_section_index == null) {
-        self.strtab_section_index = try self.addSection(.{
+    if (self.section_indexes.strtab == null) {
+        self.section_indexes.strtab = try self.addSection(.{
             .name = try self.insertShString(".strtab"),
             .type = elf.SHT_STRTAB,
             .entsize = 1,
@@ -3068,8 +2750,8 @@ pub fn initSymtab(self: *Elf) !void {
 }
 
 pub fn initShStrtab(self: *Elf) !void {
-    if (self.shstrtab_section_index == null) {
-        self.shstrtab_section_index = try self.addSection(.{
+    if (self.section_indexes.shstrtab == null) {
+        self.section_indexes.shstrtab = try self.addSection(.{
             .name = try self.insertShString(".shstrtab"),
             .type = elf.SHT_STRTAB,
             .entsize = 1,
@@ -3081,43 +2763,43 @@ pub fn initShStrtab(self: *Elf) !void {
 fn initSpecialPhdrs(self: *Elf) !void {
     comptime assert(max_number_of_special_phdrs == 5);
 
-    if (self.interp_section_index != null and self.phdr_interp_index == null) {
-        self.phdr_interp_index = try self.addPhdr(.{
+    if (self.section_indexes.interp != null and self.phdr_indexes.interp == .none) {
+        self.phdr_indexes.interp = (try self.addPhdr(.{
             .type = elf.PT_INTERP,
             .flags = elf.PF_R,
             .@"align" = 1,
-        });
+        })).toOptional();
     }
-    if (self.dynamic_section_index != null and self.phdr_dynamic_index == null) {
-        self.phdr_dynamic_index = try self.addPhdr(.{
+    if (self.section_indexes.dynamic != null and self.phdr_indexes.dynamic == .none) {
+        self.phdr_indexes.dynamic = (try self.addPhdr(.{
             .type = elf.PT_DYNAMIC,
             .flags = elf.PF_R | elf.PF_W,
-        });
+        })).toOptional();
     }
-    if (self.eh_frame_hdr_section_index != null and self.phdr_gnu_eh_frame_index == null) {
-        self.phdr_gnu_eh_frame_index = try self.addPhdr(.{
+    if (self.section_indexes.eh_frame_hdr != null and self.phdr_indexes.gnu_eh_frame == .none) {
+        self.phdr_indexes.gnu_eh_frame = (try self.addPhdr(.{
             .type = elf.PT_GNU_EH_FRAME,
             .flags = elf.PF_R,
-        });
+        })).toOptional();
     }
-    if (self.phdr_gnu_stack_index == null) {
-        self.phdr_gnu_stack_index = try self.addPhdr(.{
+    if (self.phdr_indexes.gnu_stack == .none) {
+        self.phdr_indexes.gnu_stack = (try self.addPhdr(.{
             .type = elf.PT_GNU_STACK,
             .flags = elf.PF_W | elf.PF_R,
             .memsz = self.base.stack_size,
             .@"align" = 1,
-        });
+        })).toOptional();
     }
 
     const has_tls = for (self.sections.items(.shdr)) |shdr| {
         if (shdr.sh_flags & elf.SHF_TLS != 0) break true;
     } else false;
-    if (has_tls and self.phdr_tls_index == null) {
-        self.phdr_tls_index = try self.addPhdr(.{
+    if (has_tls and self.phdr_indexes.tls == .none) {
+        self.phdr_indexes.tls = (try self.addPhdr(.{
             .type = elf.PT_TLS,
             .flags = elf.PF_R,
             .@"align" = 1,
-        });
+        })).toOptional();
     }
 }
 
@@ -3202,9 +2884,11 @@ fn sortInitFini(self: *Elf) !void {
 }
 
 fn setDynamicSection(self: *Elf, rpaths: []const []const u8) !void {
-    if (self.dynamic_section_index == null) return;
+    if (self.section_indexes.dynamic == null) return;
+
+    const shared_objects = self.shared_objects.values();
 
-    for (self.shared_objects.items) |index| {
+    for (shared_objects) |index| {
         const shared_object = self.file(index).?.shared_object;
         if (!shared_object.alive) continue;
         try self.dynamic.addNeeded(shared_object, self);
@@ -3220,21 +2904,21 @@ fn setDynamicSection(self: *Elf, rpaths: []const []const u8) !void {
 }
 
 fn sortDynamicSymtab(self: *Elf) void {
-    if (self.gnu_hash_section_index == null) return;
+    if (self.section_indexes.gnu_hash == null) return;
     self.dynsym.sort(self);
 }
 
 fn setVersionSymtab(self: *Elf) !void {
     const gpa = self.base.comp.gpa;
-    if (self.versym_section_index == null) return;
+    if (self.section_indexes.versym == null) return;
     try self.versym.resize(gpa, self.dynsym.count());
-    self.versym.items[0] = elf.VER_NDX_LOCAL;
+    self.versym.items[0] = .LOCAL;
     for (self.dynsym.entries.items, 1..) |entry, i| {
         const sym = self.symbol(entry.ref).?;
         self.versym.items[i] = sym.version_index;
     }
 
-    if (self.verneed_section_index) |shndx| {
+    if (self.section_indexes.verneed) |shndx| {
         try self.verneed.generate(self);
         const shdr = &self.sections.items(.shdr)[shndx];
         shdr.sh_info = @as(u32, @intCast(self.verneed.verneed.items.len));
@@ -3242,34 +2926,39 @@ fn setVersionSymtab(self: *Elf) !void {
 }
 
 fn setHashSections(self: *Elf) !void {
-    if (self.hash_section_index != null) {
+    if (self.section_indexes.hash != null) {
         try self.hash.generate(self);
     }
-    if (self.gnu_hash_section_index != null) {
+    if (self.section_indexes.gnu_hash != null) {
         try self.gnu_hash.calcSize(self);
     }
 }
 
 fn phdrRank(phdr: elf.Elf64_Phdr) u8 {
-    switch (phdr.p_type) {
-        elf.PT_NULL => return 0,
-        elf.PT_PHDR => return 1,
-        elf.PT_INTERP => return 2,
-        elf.PT_LOAD => return 3,
-        elf.PT_DYNAMIC, elf.PT_TLS => return 4,
-        elf.PT_GNU_EH_FRAME => return 5,
-        elf.PT_GNU_STACK => return 6,
-        else => return 7,
-    }
+    return switch (phdr.p_type) {
+        elf.PT_NULL => 0,
+        elf.PT_PHDR => 1,
+        elf.PT_INTERP => 2,
+        elf.PT_LOAD => 3,
+        elf.PT_DYNAMIC, elf.PT_TLS => 4,
+        elf.PT_GNU_EH_FRAME => 5,
+        elf.PT_GNU_STACK => 6,
+        else => 7,
+    };
 }
 
-fn sortPhdrs(self: *Elf) error{OutOfMemory}!void {
+fn sortPhdrs(
+    gpa: Allocator,
+    phdrs: *ProgramHeaderList,
+    special_indexes: *ProgramHeaderIndexes,
+    section_indexes: []OptionalProgramHeaderIndex,
+) error{OutOfMemory}!void {
     const Entry = struct {
         phndx: u16,
 
-        pub fn lessThan(elf_file: *Elf, lhs: @This(), rhs: @This()) bool {
-            const lhs_phdr = elf_file.phdrs.items[lhs.phndx];
-            const rhs_phdr = elf_file.phdrs.items[rhs.phndx];
+        pub fn lessThan(program_headers: []const elf.Elf64_Phdr, lhs: @This(), rhs: @This()) bool {
+            const lhs_phdr = program_headers[lhs.phndx];
+            const rhs_phdr = program_headers[rhs.phndx];
             const lhs_rank = phdrRank(lhs_phdr);
             const rhs_rank = phdrRank(rhs_phdr);
             if (lhs_rank == rhs_rank) return lhs_phdr.p_vaddr < rhs_phdr.p_vaddr;
@@ -3277,52 +2966,41 @@ fn sortPhdrs(self: *Elf) error{OutOfMemory}!void {
         }
     };
 
-    const gpa = self.base.comp.gpa;
-    var entries = try std.ArrayList(Entry).initCapacity(gpa, self.phdrs.items.len);
-    defer entries.deinit();
-    for (0..self.phdrs.items.len) |phndx| {
-        entries.appendAssumeCapacity(.{ .phndx = @as(u16, @intCast(phndx)) });
+    const entries = try gpa.alloc(Entry, phdrs.items.len);
+    defer gpa.free(entries);
+    for (entries, 0..) |*entry, phndx| {
+        entry.* = .{ .phndx = @intCast(phndx) };
     }
 
-    mem.sort(Entry, entries.items, self, Entry.lessThan);
+    // The `@as` here works around a bug in the C backend.
+    mem.sort(Entry, entries, @as([]const elf.Elf64_Phdr, phdrs.items), Entry.lessThan);
 
-    const backlinks = try gpa.alloc(u16, entries.items.len);
+    const backlinks = try gpa.alloc(u16, entries.len);
     defer gpa.free(backlinks);
-    for (entries.items, 0..) |entry, i| {
-        backlinks[entry.phndx] = @as(u16, @intCast(i));
-    }
-
-    const slice = try self.phdrs.toOwnedSlice(gpa);
+    const slice = try phdrs.toOwnedSlice(gpa);
     defer gpa.free(slice);
+    try phdrs.resize(gpa, slice.len);
 
-    try self.phdrs.ensureTotalCapacityPrecise(gpa, slice.len);
-    for (entries.items) |sorted| {
-        self.phdrs.appendAssumeCapacity(slice[sorted.phndx]);
+    for (entries, phdrs.items, 0..) |entry, *phdr, i| {
+        backlinks[entry.phndx] = @intCast(i);
+        phdr.* = slice[entry.phndx];
     }
 
-    for (&[_]*?u16{
-        &self.phdr_table_index,
-        &self.phdr_table_load_index,
-        &self.phdr_interp_index,
-        &self.phdr_dynamic_index,
-        &self.phdr_gnu_eh_frame_index,
-        &self.phdr_tls_index,
-    }) |maybe_index| {
-        if (maybe_index.*) |*index| {
-            index.* = backlinks[index.*];
+    inline for (@typeInfo(ProgramHeaderIndexes).@"struct".fields) |field| {
+        if (@field(special_indexes, field.name).int()) |special_index| {
+            @field(special_indexes, field.name) = @enumFromInt(backlinks[special_index]);
         }
     }
 
-    for (self.sections.items(.phndx)) |*maybe_phndx| {
-        if (maybe_phndx.*) |*index| {
-            index.* = backlinks[index.*];
+    for (section_indexes) |*opt_phndx| {
+        if (opt_phndx.int()) |index| {
+            opt_phndx.* = @enumFromInt(backlinks[index]);
         }
     }
 }
 
-fn shdrRank(self: *Elf, shndx: u32) u8 {
-    const shdr = self.sections.items(.shdr)[shndx];
-    const name = self.getShString(shdr.sh_name);
+fn shdrRank(shdr: elf.Elf64_Shdr, shstrtab: []const u8) u8 {
+    const name = shString(shstrtab, shdr.sh_name);
     const flags = shdr.sh_flags;
 
     switch (shdr.sh_type) {
@@ -3371,145 +3049,144 @@ fn shdrRank(self: *Elf, shndx: u32) u8 {
     }
 }
 
-pub fn sortShdrs(self: *Elf) !void {
+pub fn sortShdrs(
+    gpa: Allocator,
+    section_indexes: *SectionIndexes,
+    sections: *std.MultiArrayList(Section),
+    shstrtab: []const u8,
+    merge_sections: []Merge.Section,
+    comdat_group_sections: []ComdatGroupSection,
+    zig_object_ptr: ?*ZigObject,
+    files: std.MultiArrayList(File.Entry),
+) !void {
     const Entry = struct {
         shndx: u32,
 
-        pub fn lessThan(elf_file: *Elf, lhs: @This(), rhs: @This()) bool {
-            return elf_file.shdrRank(lhs.shndx) < elf_file.shdrRank(rhs.shndx);
+        const Context = struct {
+            shdrs: []const elf.Elf64_Shdr,
+            shstrtab: []const u8,
+        };
+
+        pub fn lessThan(ctx: Context, lhs: @This(), rhs: @This()) bool {
+            const lhs_rank = shdrRank(ctx.shdrs[lhs.shndx], ctx.shstrtab);
+            const rhs_rank = shdrRank(ctx.shdrs[rhs.shndx], ctx.shstrtab);
+            if (lhs_rank == rhs_rank) {
+                const lhs_name = shString(ctx.shstrtab, ctx.shdrs[lhs.shndx].sh_name);
+                const rhs_name = shString(ctx.shstrtab, ctx.shdrs[rhs.shndx].sh_name);
+                return std.mem.lessThan(u8, lhs_name, rhs_name);
+            }
+            return lhs_rank < rhs_rank;
         }
     };
 
-    const gpa = self.base.comp.gpa;
-    var entries = try std.ArrayList(Entry).initCapacity(gpa, self.sections.items(.shdr).len);
-    defer entries.deinit();
-    for (0..self.sections.items(.shdr).len) |shndx| {
-        entries.appendAssumeCapacity(.{ .shndx = @intCast(shndx) });
+    const shdrs = sections.items(.shdr);
+
+    const entries = try gpa.alloc(Entry, shdrs.len);
+    defer gpa.free(entries);
+    for (entries, 0..shdrs.len) |*entry, shndx| {
+        entry.* = .{ .shndx = @intCast(shndx) };
     }
 
-    mem.sort(Entry, entries.items, self, Entry.lessThan);
+    const sort_context: Entry.Context = .{
+        .shdrs = shdrs,
+        .shstrtab = shstrtab,
+    };
+    mem.sortUnstable(Entry, entries, sort_context, Entry.lessThan);
 
-    const backlinks = try gpa.alloc(u32, entries.items.len);
+    const backlinks = try gpa.alloc(u32, entries.len);
     defer gpa.free(backlinks);
-    for (entries.items, 0..) |entry, i| {
-        backlinks[entry.shndx] = @intCast(i);
-    }
-
-    var slice = self.sections.toOwnedSlice();
-    defer slice.deinit(gpa);
-
-    try self.sections.ensureTotalCapacity(gpa, slice.len);
-    for (entries.items) |sorted| {
-        self.sections.appendAssumeCapacity(slice.get(sorted.shndx));
-    }
-
-    self.resetShdrIndexes(backlinks);
-}
-
-fn resetShdrIndexes(self: *Elf, backlinks: []const u32) void {
-    for (&[_]*?u32{
-        &self.eh_frame_section_index,
-        &self.eh_frame_rela_section_index,
-        &self.eh_frame_hdr_section_index,
-        &self.got_section_index,
-        &self.symtab_section_index,
-        &self.strtab_section_index,
-        &self.shstrtab_section_index,
-        &self.interp_section_index,
-        &self.dynamic_section_index,
-        &self.dynsymtab_section_index,
-        &self.dynstrtab_section_index,
-        &self.hash_section_index,
-        &self.gnu_hash_section_index,
-        &self.plt_section_index,
-        &self.got_plt_section_index,
-        &self.plt_got_section_index,
-        &self.rela_dyn_section_index,
-        &self.rela_plt_section_index,
-        &self.copy_rel_section_index,
-        &self.versym_section_index,
-        &self.verneed_section_index,
-    }) |maybe_index| {
-        if (maybe_index.*) |*index| {
-            index.* = backlinks[index.*];
+    {
+        var slice = sections.toOwnedSlice();
+        defer slice.deinit(gpa);
+        try sections.resize(gpa, slice.len);
+
+        for (entries, 0..) |entry, i| {
+            backlinks[entry.shndx] = @intCast(i);
+            sections.set(i, slice.get(entry.shndx));
         }
     }
 
-    for (self.merge_sections.items) |*msec| {
+    inline for (@typeInfo(SectionIndexes).@"struct".fields) |field| {
+        if (@field(section_indexes, field.name)) |special_index| {
+            @field(section_indexes, field.name) = backlinks[special_index];
+        }
+    }
+
+    for (merge_sections) |*msec| {
         msec.output_section_index = backlinks[msec.output_section_index];
     }
 
-    const slice = self.sections.slice();
+    const slice = sections.slice();
     for (slice.items(.shdr), slice.items(.atom_list_2)) |*shdr, *atom_list| {
         atom_list.output_section_index = backlinks[atom_list.output_section_index];
         for (atom_list.atoms.keys()) |ref| {
-            self.atom(ref).?.output_section_index = atom_list.output_section_index;
+            fileLookup(files, ref.file, zig_object_ptr).?.atom(ref.index).?.output_section_index = atom_list.output_section_index;
         }
         if (shdr.sh_type == elf.SHT_RELA) {
             // FIXME:JK we should spin up .symtab potentially earlier, or set all non-dynamic RELA sections
             // to point at symtab
             // shdr.sh_link = backlinks[shdr.sh_link];
-            shdr.sh_link = self.symtab_section_index.?;
+            shdr.sh_link = section_indexes.symtab.?;
             shdr.sh_info = backlinks[shdr.sh_info];
         }
     }
 
-    if (self.zigObjectPtr()) |zo| zo.resetShdrIndexes(backlinks);
+    if (zig_object_ptr) |zo| zo.resetShdrIndexes(backlinks);
 
-    for (self.comdat_group_sections.items) |*cg| {
+    for (comdat_group_sections) |*cg| {
         cg.shndx = backlinks[cg.shndx];
     }
 
-    if (self.symtab_section_index) |index| {
+    if (section_indexes.symtab) |index| {
         const shdr = &slice.items(.shdr)[index];
-        shdr.sh_link = self.strtab_section_index.?;
+        shdr.sh_link = section_indexes.strtab.?;
     }
 
-    if (self.dynamic_section_index) |index| {
+    if (section_indexes.dynamic) |index| {
         const shdr = &slice.items(.shdr)[index];
-        shdr.sh_link = self.dynstrtab_section_index.?;
+        shdr.sh_link = section_indexes.dynstrtab.?;
     }
 
-    if (self.dynsymtab_section_index) |index| {
+    if (section_indexes.dynsymtab) |index| {
         const shdr = &slice.items(.shdr)[index];
-        shdr.sh_link = self.dynstrtab_section_index.?;
+        shdr.sh_link = section_indexes.dynstrtab.?;
     }
 
-    if (self.hash_section_index) |index| {
+    if (section_indexes.hash) |index| {
         const shdr = &slice.items(.shdr)[index];
-        shdr.sh_link = self.dynsymtab_section_index.?;
+        shdr.sh_link = section_indexes.dynsymtab.?;
     }
 
-    if (self.gnu_hash_section_index) |index| {
+    if (section_indexes.gnu_hash) |index| {
         const shdr = &slice.items(.shdr)[index];
-        shdr.sh_link = self.dynsymtab_section_index.?;
+        shdr.sh_link = section_indexes.dynsymtab.?;
     }
 
-    if (self.versym_section_index) |index| {
+    if (section_indexes.versym) |index| {
         const shdr = &slice.items(.shdr)[index];
-        shdr.sh_link = self.dynsymtab_section_index.?;
+        shdr.sh_link = section_indexes.dynsymtab.?;
     }
 
-    if (self.verneed_section_index) |index| {
+    if (section_indexes.verneed) |index| {
         const shdr = &slice.items(.shdr)[index];
-        shdr.sh_link = self.dynstrtab_section_index.?;
+        shdr.sh_link = section_indexes.dynstrtab.?;
     }
 
-    if (self.rela_dyn_section_index) |index| {
+    if (section_indexes.rela_dyn) |index| {
         const shdr = &slice.items(.shdr)[index];
-        shdr.sh_link = self.dynsymtab_section_index orelse 0;
+        shdr.sh_link = section_indexes.dynsymtab orelse 0;
     }
 
-    if (self.rela_plt_section_index) |index| {
+    if (section_indexes.rela_plt) |index| {
         const shdr = &slice.items(.shdr)[index];
-        shdr.sh_link = self.dynsymtab_section_index.?;
-        shdr.sh_info = self.plt_section_index.?;
+        shdr.sh_link = section_indexes.dynsymtab.?;
+        shdr.sh_info = section_indexes.plt.?;
     }
 
-    if (self.eh_frame_rela_section_index) |index| {
+    if (section_indexes.eh_frame_rela) |index| {
         const shdr = &slice.items(.shdr)[index];
-        shdr.sh_link = self.symtab_section_index.?;
-        shdr.sh_info = self.eh_frame_section_index.?;
+        shdr.sh_link = section_indexes.symtab.?;
+        shdr.sh_info = section_indexes.eh_frame.?;
     }
 }
 
@@ -3543,31 +3220,31 @@ fn updateSectionSizes(self: *Elf) !void {
     }
 
     const shdrs = slice.items(.shdr);
-    if (self.eh_frame_section_index) |index| {
+    if (self.section_indexes.eh_frame) |index| {
         shdrs[index].sh_size = try eh_frame.calcEhFrameSize(self);
     }
 
-    if (self.eh_frame_hdr_section_index) |index| {
+    if (self.section_indexes.eh_frame_hdr) |index| {
         shdrs[index].sh_size = eh_frame.calcEhFrameHdrSize(self);
     }
 
-    if (self.got_section_index) |index| {
+    if (self.section_indexes.got) |index| {
         shdrs[index].sh_size = self.got.size(self);
     }
 
-    if (self.plt_section_index) |index| {
+    if (self.section_indexes.plt) |index| {
         shdrs[index].sh_size = self.plt.size(self);
     }
 
-    if (self.got_plt_section_index) |index| {
+    if (self.section_indexes.got_plt) |index| {
         shdrs[index].sh_size = self.got_plt.size(self);
     }
 
-    if (self.plt_got_section_index) |index| {
+    if (self.section_indexes.plt_got) |index| {
         shdrs[index].sh_size = self.plt_got.size(self);
     }
 
-    if (self.rela_dyn_section_index) |shndx| {
+    if (self.section_indexes.rela_dyn) |shndx| {
         var num = self.got.numRela(self) + self.copy_rel.numRela();
         if (self.zigObjectPtr()) |zig_object| {
             num += zig_object.num_dynrelocs;
@@ -3578,43 +3255,43 @@ fn updateSectionSizes(self: *Elf) !void {
         shdrs[shndx].sh_size = num * @sizeOf(elf.Elf64_Rela);
     }
 
-    if (self.rela_plt_section_index) |index| {
+    if (self.section_indexes.rela_plt) |index| {
         shdrs[index].sh_size = self.plt.numRela() * @sizeOf(elf.Elf64_Rela);
     }
 
-    if (self.copy_rel_section_index) |index| {
+    if (self.section_indexes.copy_rel) |index| {
         try self.copy_rel.updateSectionSize(index, self);
     }
 
-    if (self.interp_section_index) |index| {
+    if (self.section_indexes.interp) |index| {
         shdrs[index].sh_size = self.getTarget().dynamic_linker.get().?.len + 1;
     }
 
-    if (self.hash_section_index) |index| {
+    if (self.section_indexes.hash) |index| {
         shdrs[index].sh_size = self.hash.size();
     }
 
-    if (self.gnu_hash_section_index) |index| {
+    if (self.section_indexes.gnu_hash) |index| {
         shdrs[index].sh_size = self.gnu_hash.size();
     }
 
-    if (self.dynamic_section_index) |index| {
+    if (self.section_indexes.dynamic) |index| {
         shdrs[index].sh_size = self.dynamic.size(self);
     }
 
-    if (self.dynsymtab_section_index) |index| {
+    if (self.section_indexes.dynsymtab) |index| {
         shdrs[index].sh_size = self.dynsym.size();
     }
 
-    if (self.dynstrtab_section_index) |index| {
+    if (self.section_indexes.dynstrtab) |index| {
         shdrs[index].sh_size = self.dynstrtab.items.len;
     }
 
-    if (self.versym_section_index) |index| {
-        shdrs[index].sh_size = self.versym.items.len * @sizeOf(elf.Elf64_Versym);
+    if (self.section_indexes.versym) |index| {
+        shdrs[index].sh_size = self.versym.items.len * @sizeOf(elf.Versym);
     }
 
-    if (self.verneed_section_index) |index| {
+    if (self.section_indexes.verneed) |index| {
         shdrs[index].sh_size = self.verneed.size();
     }
 
@@ -3624,7 +3301,7 @@ fn updateSectionSizes(self: *Elf) !void {
 
 // FIXME:JK this is very much obsolete, remove!
 pub fn updateShStrtabSize(self: *Elf) void {
-    if (self.shstrtab_section_index) |index| {
+    if (self.section_indexes.shstrtab) |index| {
         self.sections.items(.shdr)[index].sh_size = self.shstrtab.items.len;
     }
 }
@@ -3656,7 +3333,7 @@ fn addLoadPhdrs(self: *Elf) error{OutOfMemory}!void {
         if (shdr.sh_type == elf.SHT_NULL) continue;
         if (shdr.sh_flags & elf.SHF_ALLOC == 0) continue;
         const flags = shdrToPhdrFlags(shdr.sh_flags);
-        if (self.getPhdr(.{ .flags = flags, .type = elf.PT_LOAD }) == null) {
+        if (self.getPhdr(.{ .flags = flags, .type = elf.PT_LOAD }) == .none) {
             _ = try self.addPhdr(.{ .flags = flags, .type = elf.PT_LOAD });
         }
     }
@@ -3664,8 +3341,9 @@ fn addLoadPhdrs(self: *Elf) error{OutOfMemory}!void {
 
 /// Allocates PHDR table in virtual memory and in file.
 fn allocatePhdrTable(self: *Elf) error{OutOfMemory}!void {
-    const phdr_table = &self.phdrs.items[self.phdr_table_index.?];
-    const phdr_table_load = &self.phdrs.items[self.phdr_table_load_index.?];
+    const diags = &self.base.comp.link_diags;
+    const phdr_table = &self.phdrs.items[self.phdr_indexes.table.int().?];
+    const phdr_table_load = &self.phdrs.items[self.phdr_indexes.table_load.int().?];
 
     const ehsize: u64 = switch (self.ptr_width) {
         .p32 => @sizeOf(elf.Elf32_Ehdr),
@@ -3684,7 +3362,7 @@ fn allocatePhdrTable(self: *Elf) error{OutOfMemory}!void {
         //    (revisit getMaxNumberOfPhdrs())
         // 2. shift everything in file to free more space for EHDR + PHDR table
         // TODO verify `getMaxNumberOfPhdrs()` is accurate and convert this into no-op
-        var err = try self.base.addErrorWithNotes(1);
+        var err = try diags.addErrorWithNotes(1);
         try err.addMsg("fatal linker error: not enough space reserved for EHDR and PHDR table", .{});
         try err.addNote("required 0x{x}, available 0x{x}", .{ needed_size, available_space });
     }
@@ -3757,7 +3435,7 @@ pub fn allocateAllocSections(self: *Elf) !void {
     // When allocating we first find the largest required alignment
     // of any section that is contained in a cover and use it to align
     // the start address of the segement (and first section).
-    const phdr_table = &self.phdrs.items[self.phdr_table_load_index.?];
+    const phdr_table = &self.phdrs.items[self.phdr_indexes.table_load.int().?];
     var addr = phdr_table.p_vaddr + phdr_table.p_memsz;
 
     for (covers) |cover| {
@@ -3817,8 +3495,8 @@ pub fn allocateAllocSections(self: *Elf) !void {
         }
 
         const first = slice.items(.shdr)[cover.items[0]];
-        const phndx = self.getPhdr(.{ .type = elf.PT_LOAD, .flags = shdrToPhdrFlags(first.sh_flags) }).?;
-        const phdr = &self.phdrs.items[phndx];
+        const phndx = self.getPhdr(.{ .type = elf.PT_LOAD, .flags = shdrToPhdrFlags(first.sh_flags) }).unwrap().?;
+        const phdr = &self.phdrs.items[phndx.int()];
         const allocated_size = self.allocatedSize(phdr.p_offset);
         if (filesz > allocated_size) {
             const old_offset = phdr.p_offset;
@@ -3830,7 +3508,7 @@ pub fn allocateAllocSections(self: *Elf) !void {
 
             for (cover.items) |shndx| {
                 const shdr = &slice.items(.shdr)[shndx];
-                slice.items(.phndx)[shndx] = phndx;
+                slice.items(.phndx)[shndx] = phndx.toOptional();
                 if (shdr.sh_type == elf.SHT_NOBITS) {
                     shdr.sh_offset = 0;
                     continue;
@@ -3906,12 +3584,12 @@ pub fn allocateNonAllocSections(self: *Elf) !void {
 fn allocateSpecialPhdrs(self: *Elf) void {
     const slice = self.sections.slice();
 
-    for (&[_]struct { ?u16, ?u32 }{
-        .{ self.phdr_interp_index, self.interp_section_index },
-        .{ self.phdr_dynamic_index, self.dynamic_section_index },
-        .{ self.phdr_gnu_eh_frame_index, self.eh_frame_hdr_section_index },
+    for (&[_]struct { OptionalProgramHeaderIndex, ?u32 }{
+        .{ self.phdr_indexes.interp, self.section_indexes.interp },
+        .{ self.phdr_indexes.dynamic, self.section_indexes.dynamic },
+        .{ self.phdr_indexes.gnu_eh_frame, self.section_indexes.eh_frame_hdr },
     }) |pair| {
-        if (pair[0]) |index| {
+        if (pair[0].int()) |index| {
             const shdr = slice.items(.shdr)[pair[1].?];
             const phdr = &self.phdrs.items[index];
             phdr.p_align = shdr.sh_addralign;
@@ -3926,7 +3604,7 @@ fn allocateSpecialPhdrs(self: *Elf) void {
     // Set the TLS segment boundaries.
     // We assume TLS sections are laid out contiguously and that there is
     // a single TLS segment.
-    if (self.phdr_tls_index) |index| {
+    if (self.phdr_indexes.tls.int()) |index| {
         const shdrs = slice.items(.shdr);
         const phdr = &self.phdrs.items[index];
         var shndx: u32 = 0;
@@ -4012,13 +3690,15 @@ pub fn updateSymtabSize(self: *Elf) !void {
     var strsize: u32 = 0;
 
     const gpa = self.base.comp.gpa;
+    const shared_objects = self.shared_objects.values();
+
     var files = std.ArrayList(File.Index).init(gpa);
     defer files.deinit();
-    try files.ensureTotalCapacityPrecise(self.objects.items.len + self.shared_objects.items.len + 2);
+    try files.ensureTotalCapacityPrecise(self.objects.items.len + shared_objects.len + 2);
 
     if (self.zig_object_index) |index| files.appendAssumeCapacity(index);
     for (self.objects.items) |index| files.appendAssumeCapacity(index);
-    for (self.shared_objects.items) |index| files.appendAssumeCapacity(index);
+    for (shared_objects) |index| files.appendAssumeCapacity(index);
     if (self.linker_defined_index) |index| files.appendAssumeCapacity(index);
 
     // Section symbols
@@ -4046,7 +3726,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
         strsize += ctx.strsize;
     }
 
-    if (self.got_section_index) |_| {
+    if (self.section_indexes.got) |_| {
         self.got.output_symtab_ctx.reset();
         self.got.output_symtab_ctx.ilocal = nlocals;
         self.got.updateSymtabSize(self);
@@ -4054,7 +3734,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
         strsize += self.got.output_symtab_ctx.strsize;
     }
 
-    if (self.plt_section_index) |_| {
+    if (self.section_indexes.plt) |_| {
         self.plt.output_symtab_ctx.reset();
         self.plt.output_symtab_ctx.ilocal = nlocals;
         self.plt.updateSymtabSize(self);
@@ -4062,7 +3742,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
         strsize += self.plt.output_symtab_ctx.strsize;
     }
 
-    if (self.plt_got_section_index) |_| {
+    if (self.section_indexes.plt_got) |_| {
         self.plt_got.output_symtab_ctx.reset();
         self.plt_got.output_symtab_ctx.ilocal = nlocals;
         self.plt_got.updateSymtabSize(self);
@@ -4079,9 +3759,9 @@ pub fn updateSymtabSize(self: *Elf) !void {
     }
 
     const slice = self.sections.slice();
-    const symtab_shdr = &slice.items(.shdr)[self.symtab_section_index.?];
+    const symtab_shdr = &slice.items(.shdr)[self.section_indexes.symtab.?];
     symtab_shdr.sh_info = nlocals;
-    symtab_shdr.sh_link = self.strtab_section_index.?;
+    symtab_shdr.sh_link = self.section_indexes.strtab.?;
 
     const sym_size: u64 = switch (self.ptr_width) {
         .p32 => @sizeOf(elf.Elf32_Sym),
@@ -4090,7 +3770,7 @@ pub fn updateSymtabSize(self: *Elf) !void {
     const needed_size = (nlocals + nglobals) * sym_size;
     symtab_shdr.sh_size = needed_size;
 
-    const strtab = &slice.items(.shdr)[self.strtab_section_index.?];
+    const strtab = &slice.items(.shdr)[self.section_indexes.strtab.?];
     strtab.sh_size = strsize + 1;
 }
 
@@ -4098,7 +3778,7 @@ fn writeSyntheticSections(self: *Elf) !void {
     const gpa = self.base.comp.gpa;
     const slice = self.sections.slice();
 
-    if (self.interp_section_index) |shndx| {
+    if (self.section_indexes.interp) |shndx| {
         var buffer: [256]u8 = undefined;
         const interp = self.getTarget().dynamic_linker.get().?;
         @memcpy(buffer[0..interp.len], interp);
@@ -4109,12 +3789,12 @@ fn writeSyntheticSections(self: *Elf) !void {
         try self.base.file.?.pwriteAll(contents, shdr.sh_offset);
     }
 
-    if (self.hash_section_index) |shndx| {
+    if (self.section_indexes.hash) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
         try self.base.file.?.pwriteAll(self.hash.buffer.items, shdr.sh_offset);
     }
 
-    if (self.gnu_hash_section_index) |shndx| {
+    if (self.section_indexes.gnu_hash) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
         var buffer = try std.ArrayList(u8).initCapacity(gpa, self.gnu_hash.size());
         defer buffer.deinit();
@@ -4122,12 +3802,12 @@ fn writeSyntheticSections(self: *Elf) !void {
         try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
     }
 
-    if (self.versym_section_index) |shndx| {
+    if (self.section_indexes.versym) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
         try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.versym.items), shdr.sh_offset);
     }
 
-    if (self.verneed_section_index) |shndx| {
+    if (self.section_indexes.verneed) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
         var buffer = try std.ArrayList(u8).initCapacity(gpa, self.verneed.size());
         defer buffer.deinit();
@@ -4135,7 +3815,7 @@ fn writeSyntheticSections(self: *Elf) !void {
         try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
     }
 
-    if (self.dynamic_section_index) |shndx| {
+    if (self.section_indexes.dynamic) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
         var buffer = try std.ArrayList(u8).initCapacity(gpa, self.dynamic.size(self));
         defer buffer.deinit();
@@ -4143,7 +3823,7 @@ fn writeSyntheticSections(self: *Elf) !void {
         try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
     }
 
-    if (self.dynsymtab_section_index) |shndx| {
+    if (self.section_indexes.dynsymtab) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
         var buffer = try std.ArrayList(u8).initCapacity(gpa, self.dynsym.size());
         defer buffer.deinit();
@@ -4151,12 +3831,12 @@ fn writeSyntheticSections(self: *Elf) !void {
         try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
     }
 
-    if (self.dynstrtab_section_index) |shndx| {
+    if (self.section_indexes.dynstrtab) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
         try self.base.file.?.pwriteAll(self.dynstrtab.items, shdr.sh_offset);
     }
 
-    if (self.eh_frame_section_index) |shndx| {
+    if (self.section_indexes.eh_frame) |shndx| {
         const existing_size = existing_size: {
             const zo = self.zigObjectPtr() orelse break :existing_size 0;
             const sym = zo.symbol(zo.eh_frame_index orelse break :existing_size 0);
@@ -4171,7 +3851,7 @@ fn writeSyntheticSections(self: *Elf) !void {
         try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset + existing_size);
     }
 
-    if (self.eh_frame_hdr_section_index) |shndx| {
+    if (self.section_indexes.eh_frame_hdr) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
         const sh_size = math.cast(usize, shdr.sh_size) orelse return error.Overflow;
         var buffer = try std.ArrayList(u8).initCapacity(gpa, sh_size);
@@ -4180,7 +3860,7 @@ fn writeSyntheticSections(self: *Elf) !void {
         try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
     }
 
-    if (self.got_section_index) |index| {
+    if (self.section_indexes.got) |index| {
         const shdr = slice.items(.shdr)[index];
         var buffer = try std.ArrayList(u8).initCapacity(gpa, self.got.size(self));
         defer buffer.deinit();
@@ -4188,7 +3868,7 @@ fn writeSyntheticSections(self: *Elf) !void {
         try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
     }
 
-    if (self.rela_dyn_section_index) |shndx| {
+    if (self.section_indexes.rela_dyn) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
         try self.got.addRela(self);
         try self.copy_rel.addRela(self);
@@ -4196,7 +3876,7 @@ fn writeSyntheticSections(self: *Elf) !void {
         try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.rela_dyn.items), shdr.sh_offset);
     }
 
-    if (self.plt_section_index) |shndx| {
+    if (self.section_indexes.plt) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
         var buffer = try std.ArrayList(u8).initCapacity(gpa, self.plt.size(self));
         defer buffer.deinit();
@@ -4204,7 +3884,7 @@ fn writeSyntheticSections(self: *Elf) !void {
         try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
     }
 
-    if (self.got_plt_section_index) |shndx| {
+    if (self.section_indexes.got_plt) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
         var buffer = try std.ArrayList(u8).initCapacity(gpa, self.got_plt.size(self));
         defer buffer.deinit();
@@ -4212,7 +3892,7 @@ fn writeSyntheticSections(self: *Elf) !void {
         try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
     }
 
-    if (self.plt_got_section_index) |shndx| {
+    if (self.section_indexes.plt_got) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
         var buffer = try std.ArrayList(u8).initCapacity(gpa, self.plt_got.size(self));
         defer buffer.deinit();
@@ -4220,7 +3900,7 @@ fn writeSyntheticSections(self: *Elf) !void {
         try self.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
     }
 
-    if (self.rela_plt_section_index) |shndx| {
+    if (self.section_indexes.rela_plt) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
         try self.plt.addRela(self);
         try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.rela_plt.items), shdr.sh_offset);
@@ -4232,7 +3912,7 @@ fn writeSyntheticSections(self: *Elf) !void {
 
 // FIXME:JK again, why is this needed?
 pub fn writeShStrtab(self: *Elf) !void {
-    if (self.shstrtab_section_index) |index| {
+    if (self.section_indexes.shstrtab) |index| {
         const shdr = self.sections.items(.shdr)[index];
         log.debug("writing .shstrtab from 0x{x} to 0x{x}", .{ shdr.sh_offset, shdr.sh_offset + shdr.sh_size });
         try self.base.file.?.pwriteAll(self.shstrtab.items, shdr.sh_offset);
@@ -4241,9 +3921,11 @@ pub fn writeShStrtab(self: *Elf) !void {
 
 pub fn writeSymtab(self: *Elf) !void {
     const gpa = self.base.comp.gpa;
+    const shared_objects = self.shared_objects.values();
+
     const slice = self.sections.slice();
-    const symtab_shdr = slice.items(.shdr)[self.symtab_section_index.?];
-    const strtab_shdr = slice.items(.shdr)[self.strtab_section_index.?];
+    const symtab_shdr = slice.items(.shdr)[self.section_indexes.symtab.?];
+    const strtab_shdr = slice.items(.shdr)[self.section_indexes.strtab.?];
     const sym_size: u64 = switch (self.ptr_width) {
         .p32 => @sizeOf(elf.Elf32_Sym),
         .p64 => @sizeOf(elf.Elf64_Sym),
@@ -4292,7 +3974,7 @@ pub fn writeSymtab(self: *Elf) !void {
         file_ptr.writeSymtab(self);
     }
 
-    for (self.shared_objects.items) |index| {
+    for (shared_objects) |index| {
         const file_ptr = self.file(index).?;
         file_ptr.writeSymtab(self);
     }
@@ -4301,15 +3983,15 @@ pub fn writeSymtab(self: *Elf) !void {
         obj.asFile().writeSymtab(self);
     }
 
-    if (self.got_section_index) |_| {
+    if (self.section_indexes.got) |_| {
         self.got.writeSymtab(self);
     }
 
-    if (self.plt_section_index) |_| {
+    if (self.section_indexes.plt) |_| {
         self.plt.writeSymtab(self);
     }
 
-    if (self.plt_got_section_index) |_| {
+    if (self.section_indexes.plt_got) |_| {
         self.plt_got.writeSymtab(self);
     }
 
@@ -4325,8 +4007,8 @@ pub fn writeSymtab(self: *Elf) !void {
                     .st_info = sym.st_info,
                     .st_other = sym.st_other,
                     .st_shndx = sym.st_shndx,
-                    .st_value = @as(u32, @intCast(sym.st_value)),
-                    .st_size = @as(u32, @intCast(sym.st_size)),
+                    .st_value = @intCast(sym.st_value),
+                    .st_size = @intCast(sym.st_size),
                 };
                 if (foreign_endian) mem.byteSwapAllFields(elf.Elf32_Sym, out);
             }
@@ -4418,21 +4100,21 @@ fn getLDMOption(target: std.Target) ?[]const u8 {
         },
         .mips64 => switch (target.os.tag) {
             .freebsd => switch (target.abi) {
-                .gnuabin32 => "elf32btsmipn32_fbsd",
+                .gnuabin32, .muslabin32 => "elf32btsmipn32_fbsd",
                 else => "elf64btsmip_fbsd",
             },
             else => switch (target.abi) {
-                .gnuabin32 => "elf32btsmipn32",
+                .gnuabin32, .muslabin32 => "elf32btsmipn32",
                 else => "elf64btsmip",
             },
         },
         .mips64el => switch (target.os.tag) {
             .freebsd => switch (target.abi) {
-                .gnuabin32 => "elf32ltsmipn32_fbsd",
+                .gnuabin32, .muslabin32 => "elf32ltsmipn32_fbsd",
                 else => "elf64ltsmip_fbsd",
             },
             else => switch (target.abi) {
-                .gnuabin32 => "elf32ltsmipn32",
+                .gnuabin32, .muslabin32 => "elf32ltsmipn32",
                 else => "elf64ltsmip",
             },
         },
@@ -4482,14 +4164,15 @@ pub fn isEffectivelyDynLib(self: Elf) bool {
 fn getPhdr(self: *Elf, opts: struct {
     type: u32 = 0,
     flags: u32 = 0,
-}) ?u16 {
+}) OptionalProgramHeaderIndex {
     for (self.phdrs.items, 0..) |phdr, phndx| {
-        if (self.phdr_table_load_index) |index| {
+        if (self.phdr_indexes.table_load.int()) |index| {
             if (phndx == index) continue;
         }
-        if (phdr.p_type == opts.type and phdr.p_flags == opts.flags) return @intCast(phndx);
+        if (phdr.p_type == opts.type and phdr.p_flags == opts.flags)
+            return @enumFromInt(phndx);
     }
-    return null;
+    return .none;
 }
 
 fn addPhdr(self: *Elf, opts: struct {
@@ -4500,9 +4183,9 @@ fn addPhdr(self: *Elf, opts: struct {
     addr: u64 = 0,
     filesz: u64 = 0,
     memsz: u64 = 0,
-}) error{OutOfMemory}!u16 {
+}) error{OutOfMemory}!ProgramHeaderIndex {
     const gpa = self.base.comp.gpa;
-    const index = @as(u16, @intCast(self.phdrs.items.len));
+    const index: ProgramHeaderIndex = @enumFromInt(self.phdrs.items.len);
     try self.phdrs.append(gpa, .{
         .p_type = opts.type,
         .p_flags = opts.flags,
@@ -4667,26 +4350,30 @@ pub fn thunk(self: *Elf, index: Thunk.Index) *Thunk {
 }
 
 pub fn file(self: *Elf, index: File.Index) ?File {
-    const tag = self.files.items(.tags)[index];
+    return fileLookup(self.files, index, self.zig_object);
+}
+
+fn fileLookup(files: std.MultiArrayList(File.Entry), index: File.Index, zig_object: ?*ZigObject) ?File {
+    const tag = files.items(.tags)[index];
     return switch (tag) {
         .null => null,
-        .linker_defined => .{ .linker_defined = &self.files.items(.data)[index].linker_defined },
-        .zig_object => .{ .zig_object = &self.files.items(.data)[index].zig_object },
-        .object => .{ .object = &self.files.items(.data)[index].object },
-        .shared_object => .{ .shared_object = &self.files.items(.data)[index].shared_object },
+        .linker_defined => .{ .linker_defined = &files.items(.data)[index].linker_defined },
+        .zig_object => .{ .zig_object = zig_object.? },
+        .object => .{ .object = &files.items(.data)[index].object },
+        .shared_object => .{ .shared_object = &files.items(.data)[index].shared_object },
     };
 }
 
-pub fn addFileHandle(self: *Elf, handle: fs.File) !File.HandleIndex {
-    const gpa = self.base.comp.gpa;
-    const index: File.HandleIndex = @intCast(self.file_handles.items.len);
-    const fh = try self.file_handles.addOne(gpa);
-    fh.* = handle;
-    return index;
+pub fn addFileHandle(
+    gpa: Allocator,
+    file_handles: *std.ArrayListUnmanaged(File.Handle),
+    handle: fs.File,
+) Allocator.Error!File.HandleIndex {
+    try file_handles.append(gpa, handle);
+    return @intCast(file_handles.items.len - 1);
 }
 
 pub fn fileHandle(self: Elf, index: File.HandleIndex) File.Handle {
-    assert(index < self.file_handles.items.len);
     return self.file_handles.items[index];
 }
 
@@ -4709,8 +4396,7 @@ pub fn getGlobalSymbol(self: *Elf, name: []const u8, lib_name: ?[]const u8) !u32
 }
 
 pub fn zigObjectPtr(self: *Elf) ?*ZigObject {
-    const index = self.zig_object_index orelse return null;
-    return self.file(index).?.zig_object;
+    return self.zig_object;
 }
 
 pub fn linkerDefinedPtr(self: *Elf) ?*LinkerDefined {
@@ -4718,7 +4404,7 @@ pub fn linkerDefinedPtr(self: *Elf) ?*LinkerDefined {
     return self.file(index).?.linker_defined;
 }
 
-pub fn getOrCreateMergeSection(self: *Elf, name: [:0]const u8, flags: u64, @"type": u32) !MergeSection.Index {
+pub fn getOrCreateMergeSection(self: *Elf, name: [:0]const u8, flags: u64, @"type": u32) !Merge.Section.Index {
     const gpa = self.base.comp.gpa;
     const out_name = name: {
         if (self.base.isRelocatable()) break :name name;
@@ -4731,7 +4417,7 @@ pub fn getOrCreateMergeSection(self: *Elf, name: [:0]const u8, flags: u64, @"typ
     }
     const out_off = try self.insertShString(out_name);
     const out_flags = flags & ~@as(u64, elf.SHF_COMPRESSED | elf.SHF_GROUP);
-    const index = @as(MergeSection.Index, @intCast(self.merge_sections.items.len));
+    const index: Merge.Section.Index = @intCast(self.merge_sections.items.len);
     const msec = try self.merge_sections.addOne(gpa);
     msec.* = .{
         .name_offset = out_off,
@@ -4741,22 +4427,22 @@ pub fn getOrCreateMergeSection(self: *Elf, name: [:0]const u8, flags: u64, @"typ
     return index;
 }
 
-pub fn mergeSection(self: *Elf, index: MergeSection.Index) *MergeSection {
+pub fn mergeSection(self: *Elf, index: Merge.Section.Index) *Merge.Section {
     assert(index < self.merge_sections.items.len);
     return &self.merge_sections.items[index];
 }
 
 pub fn gotAddress(self: *Elf) i64 {
     const shndx = blk: {
-        if (self.getTarget().cpu.arch == .x86_64 and self.got_plt_section_index != null)
-            break :blk self.got_plt_section_index.?;
-        break :blk if (self.got_section_index) |shndx| shndx else null;
+        if (self.getTarget().cpu.arch == .x86_64 and self.section_indexes.got_plt != null)
+            break :blk self.section_indexes.got_plt.?;
+        break :blk if (self.section_indexes.got) |shndx| shndx else null;
     };
     return if (shndx) |index| @intCast(self.sections.items(.shdr)[index].sh_addr) else 0;
 }
 
 pub fn tpAddress(self: *Elf) i64 {
-    const index = self.phdr_tls_index orelse return 0;
+    const index = self.phdr_indexes.tls.int() orelse return 0;
     const phdr = self.phdrs.items[index];
     const addr = switch (self.getTarget().cpu.arch) {
         .x86_64 => mem.alignForward(u64, phdr.p_vaddr + phdr.p_memsz, phdr.p_align),
@@ -4768,20 +4454,27 @@ pub fn tpAddress(self: *Elf) i64 {
 }
 
 pub fn dtpAddress(self: *Elf) i64 {
-    const index = self.phdr_tls_index orelse return 0;
+    const index = self.phdr_indexes.tls.int() orelse return 0;
     const phdr = self.phdrs.items[index];
     return @intCast(phdr.p_vaddr);
 }
 
 pub fn tlsAddress(self: *Elf) i64 {
-    const index = self.phdr_tls_index orelse return 0;
+    const index = self.phdr_indexes.tls.int() orelse return 0;
     const phdr = self.phdrs.items[index];
     return @intCast(phdr.p_vaddr);
 }
 
 pub fn getShString(self: Elf, off: u32) [:0]const u8 {
-    assert(off < self.shstrtab.items.len);
-    return mem.sliceTo(@as([*:0]const u8, @ptrCast(self.shstrtab.items.ptr + off)), 0);
+    return shString(self.shstrtab.items, off);
+}
+
+fn shString(
+    shstrtab: []const u8,
+    off: u32,
+) [:0]const u8 {
+    const slice = shstrtab[off..];
+    return slice[0..mem.indexOfScalar(u8, slice, 0).? :0];
 }
 
 pub fn insertShString(self: *Elf, name: [:0]const u8) error{OutOfMemory}!u32 {
@@ -4807,16 +4500,17 @@ pub fn insertDynString(self: *Elf, name: []const u8) error{OutOfMemory}!u32 {
 
 fn reportUndefinedSymbols(self: *Elf, undefs: anytype) !void {
     const gpa = self.base.comp.gpa;
+    const diags = &self.base.comp.link_diags;
     const max_notes = 4;
 
-    try self.base.comp.link_errors.ensureUnusedCapacity(gpa, undefs.count());
+    try diags.msgs.ensureUnusedCapacity(gpa, undefs.count());
 
     for (undefs.keys(), undefs.values()) |key, refs| {
         const undef_sym = self.resolver.keys.items[key - 1];
         const nrefs = @min(refs.items.len, max_notes);
         const nnotes = nrefs + @intFromBool(refs.items.len > max_notes);
 
-        var err = try self.base.addErrorWithNotesAssumeCapacity(nnotes);
+        var err = try diags.addErrorWithNotesAssumeCapacity(nnotes);
         try err.addMsg("undefined symbol: {s}", .{undef_sym.name(self)});
 
         for (refs.items[0..nrefs]) |ref| {
@@ -4834,6 +4528,7 @@ fn reportUndefinedSymbols(self: *Elf, undefs: anytype) !void {
 
 fn reportDuplicates(self: *Elf, dupes: anytype) error{ HasDuplicates, OutOfMemory }!void {
     if (dupes.keys().len == 0) return; // Nothing to do
+    const diags = &self.base.comp.link_diags;
 
     const max_notes = 3;
 
@@ -4841,7 +4536,7 @@ fn reportDuplicates(self: *Elf, dupes: anytype) error{ HasDuplicates, OutOfMemor
         const sym = self.resolver.keys.items[key - 1];
         const nnotes = @min(notes.items.len, max_notes) + @intFromBool(notes.items.len > max_notes);
 
-        var err = try self.base.addErrorWithNotes(nnotes + 1);
+        var err = try diags.addErrorWithNotes(nnotes + 1);
         try err.addMsg("duplicate symbol definition: {s}", .{sym.name(self)});
         try err.addNote("defined by {}", .{sym.file(self).?.fmtPath()});
 
@@ -4860,44 +4555,22 @@ fn reportDuplicates(self: *Elf, dupes: anytype) error{ HasDuplicates, OutOfMemor
     return error.HasDuplicates;
 }
 
-fn reportMissingLibraryError(
-    self: *Elf,
-    checked_paths: []const []const u8,
-    comptime format: []const u8,
-    args: anytype,
-) error{OutOfMemory}!void {
-    var err = try self.base.addErrorWithNotes(checked_paths.len);
-    try err.addMsg(format, args);
-    for (checked_paths) |path| {
-        try err.addNote("tried {s}", .{path});
-    }
-}
-
 fn reportUnsupportedCpuArch(self: *Elf) error{OutOfMemory}!void {
-    var err = try self.base.addErrorWithNotes(0);
+    const diags = &self.base.comp.link_diags;
+    var err = try diags.addErrorWithNotes(0);
     try err.addMsg("fatal linker error: unsupported CPU architecture {s}", .{
         @tagName(self.getTarget().cpu.arch),
     });
 }
 
-pub fn addParseError(
-    self: *Elf,
-    path: Path,
-    comptime format: []const u8,
-    args: anytype,
-) error{OutOfMemory}!void {
-    var err = try self.base.addErrorWithNotes(1);
-    try err.addMsg(format, args);
-    try err.addNote("while parsing {}", .{path});
-}
-
 pub fn addFileError(
     self: *Elf,
     file_index: File.Index,
     comptime format: []const u8,
     args: anytype,
 ) error{OutOfMemory}!void {
-    var err = try self.base.addErrorWithNotes(1);
+    const diags = &self.base.comp.link_diags;
+    var err = try diags.addErrorWithNotes(1);
     try err.addMsg(format, args);
     try err.addNote("while parsing {}", .{self.file(file_index).?.fmtPath()});
 }
@@ -4912,16 +4585,6 @@ pub fn failFile(
     return error.LinkFailure;
 }
 
-pub fn failParse(
-    self: *Elf,
-    path: Path,
-    comptime format: []const u8,
-    args: anytype,
-) error{ OutOfMemory, LinkFailure } {
-    try addParseError(self, path, format, args);
-    return error.LinkFailure;
-}
-
 const FormatShdrCtx = struct {
     elf_file: *Elf,
     shdr: elf.Elf64_Shdr,
@@ -5066,6 +4729,8 @@ fn fmtDumpState(
     _ = unused_fmt_string;
     _ = options;
 
+    const shared_objects = self.shared_objects.values();
+
     if (self.zigObjectPtr()) |zig_object| {
         try writer.print("zig_object({d}) : {s}\n", .{ zig_object.index, zig_object.basename });
         try writer.print("{}{}", .{
@@ -5089,11 +4754,11 @@ fn fmtDumpState(
         });
     }
 
-    for (self.shared_objects.items) |index| {
+    for (shared_objects) |index| {
         const shared_object = self.file(index).?.shared_object;
-        try writer.print("shared_object({d}) : ", .{index});
-        try writer.print("{}", .{shared_object.path});
-        try writer.print(" : needed({})", .{shared_object.needed});
+        try writer.print("shared_object({d}) : {} : needed({})", .{
+            index, shared_object.path, shared_object.needed,
+        });
         if (!shared_object.alive) try writer.writeAll(" : [*]");
         try writer.writeByte('\n');
         try writer.print("{}\n", .{shared_object.fmtSymtab(self)});
@@ -5157,10 +4822,7 @@ pub fn preadAllAlloc(allocator: Allocator, handle: fs.File, offset: u64, size: u
 }
 
 /// Binary search
-pub fn bsearch(comptime T: type, haystack: []align(1) const T, predicate: anytype) usize {
-    if (!@hasDecl(@TypeOf(predicate), "predicate"))
-        @compileError("Predicate is required to define fn predicate(@This(), T) bool");
-
+pub fn bsearch(comptime T: type, haystack: []const T, predicate: anytype) usize {
     var min: usize = 0;
     var max: usize = haystack.len;
     while (min < max) {
@@ -5176,10 +4838,7 @@ pub fn bsearch(comptime T: type, haystack: []align(1) const T, predicate: anytyp
 }
 
 /// Linear search
-pub fn lsearch(comptime T: type, haystack: []align(1) const T, predicate: anytype) usize {
-    if (!@hasDecl(@TypeOf(predicate), "predicate"))
-        @compileError("Predicate is required to define fn predicate(@This(), T) bool");
-
+pub fn lsearch(comptime T: type, haystack: []const T, predicate: anytype) usize {
     var i: usize = 0;
     while (i < haystack.len) : (i += 1) {
         if (predicate.predicate(haystack[i])) break;
@@ -5393,7 +5052,7 @@ const Section = struct {
     shdr: elf.Elf64_Shdr,
 
     /// Assigned program header index if any.
-    phndx: ?u32 = null,
+    phndx: OptionalProgramHeaderIndex = .none,
 
     /// List of atoms contributing to this section.
     /// TODO currently this is only used for relocations tracking in relocatable mode
@@ -5522,6 +5181,11 @@ fn createThunks(elf_file: *Elf, atom_list: *AtomList) !void {
     }
 }
 
+pub fn stringTableLookup(strtab: []const u8, off: u32) [:0]const u8 {
+    const slice = strtab[off..];
+    return slice[0..mem.indexOfScalar(u8, slice, 0).? :0];
+}
+
 const std = @import("std");
 const build_options = @import("build_options");
 const builtin = @import("builtin");
@@ -5533,6 +5197,10 @@ const relocs_log = std.log.scoped(.link_relocs);
 const state_log = std.log.scoped(.link_state);
 const math = std.math;
 const mem = std.mem;
+const Allocator = std.mem.Allocator;
+const Hash = std.hash.Wyhash;
+const Path = std.Build.Cache.Path;
+const Stat = std.Build.Cache.File.Stat;
 
 const codegen = @import("../codegen.zig");
 const dev = @import("../dev.zig");
@@ -5540,7 +5208,6 @@ const eh_frame = @import("Elf/eh_frame.zig");
 const gc = @import("Elf/gc.zig");
 const glibc = @import("../glibc.zig");
 const link = @import("../link.zig");
-const merge_section = @import("Elf/merge_section.zig");
 const musl = @import("../musl.zig");
 const relocatable = @import("Elf/relocatable.zig");
 const relocation = @import("Elf/relocation.zig");
@@ -5548,16 +5215,14 @@ const target_util = @import("../target.zig");
 const trace = @import("../tracy.zig").trace;
 const synthetic_sections = @import("Elf/synthetic_sections.zig");
 
+const Merge = @import("Elf/Merge.zig");
 const Air = @import("../Air.zig");
-const Allocator = std.mem.Allocator;
 const Archive = @import("Elf/Archive.zig");
-pub const Atom = @import("Elf/Atom.zig");
 const AtomList = @import("Elf/AtomList.zig");
-const Cache = std.Build.Cache;
-const Path = Cache.Path;
 const Compilation = @import("../Compilation.zig");
 const ComdatGroupSection = synthetic_sections.ComdatGroupSection;
 const CopyRelSection = synthetic_sections.CopyRelSection;
+const Diags = @import("../link.zig").Diags;
 const DynamicSection = synthetic_sections.DynamicSection;
 const DynsymSection = synthetic_sections.DynsymSection;
 const Dwarf = @import("Dwarf.zig");
@@ -5566,15 +5231,10 @@ const File = @import("Elf/file.zig").File;
 const GnuHashSection = synthetic_sections.GnuHashSection;
 const GotSection = synthetic_sections.GotSection;
 const GotPltSection = synthetic_sections.GotPltSection;
-const Hash = std.hash.Wyhash;
 const HashSection = synthetic_sections.HashSection;
-const InputMergeSection = merge_section.InputMergeSection;
-const LdScript = @import("Elf/LdScript.zig");
 const LinkerDefined = @import("Elf/LinkerDefined.zig");
 const Liveness = @import("../Liveness.zig");
 const LlvmObject = @import("../codegen/llvm.zig").Object;
-const MergeSection = merge_section.MergeSection;
-const MergeSubsection = merge_section.MergeSubsection;
 const Zcu = @import("../Zcu.zig");
 const Object = @import("Elf/Object.zig");
 const InternPool = @import("../InternPool.zig");
@@ -5587,4 +5247,3 @@ const Thunk = @import("Elf/Thunk.zig");
 const Value = @import("../Value.zig");
 const VerneedSection = synthetic_sections.VerneedSection;
 const ZigObject = @import("Elf/ZigObject.zig");
-const riscv = @import("riscv.zig");
diff --git a/zig/src/link/Elf/Archive.zig b/zig/src/link/Elf/Archive.zig
index 7cc454f10c..0d177bc21a 100644
--- a/zig/src/link/Elf/Archive.zig
+++ b/zig/src/link/Elf/Archive.zig
@@ -1,41 +1,50 @@
-objects: std.ArrayListUnmanaged(Object) = .empty,
-strtab: std.ArrayListUnmanaged(u8) = .empty,
-
-pub fn isArchive(path: Path) !bool {
-    const file = try path.root_dir.handle.openFile(path.sub_path, .{});
-    defer file.close();
-    const reader = file.reader();
-    const magic = reader.readBytesNoEof(elf.ARMAG.len) catch return false;
-    if (!mem.eql(u8, &magic, elf.ARMAG)) return false;
-    return true;
+objects: []const Object,
+/// '\n'-delimited
+strtab: []const u8,
+
+pub fn deinit(a: *Archive, gpa: Allocator) void {
+    gpa.free(a.objects);
+    gpa.free(a.strtab);
+    a.* = undefined;
 }
 
-pub fn deinit(self: *Archive, allocator: Allocator) void {
-    self.objects.deinit(allocator);
-    self.strtab.deinit(allocator);
-}
+pub fn parse(
+    gpa: Allocator,
+    diags: *Diags,
+    file_handles: *const std.ArrayListUnmanaged(File.Handle),
+    path: Path,
+    handle_index: File.HandleIndex,
+) !Archive {
+    const handle = file_handles.items[handle_index];
+    var pos: usize = 0;
+    {
+        var magic_buffer: [elf.ARMAG.len]u8 = undefined;
+        const n = try handle.preadAll(&magic_buffer, pos);
+        if (n != magic_buffer.len) return error.BadMagic;
+        if (!mem.eql(u8, &magic_buffer, elf.ARMAG)) return error.BadMagic;
+        pos += magic_buffer.len;
+    }
 
-pub fn parse(self: *Archive, elf_file: *Elf, path: Path, handle_index: File.HandleIndex) !void {
-    const comp = elf_file.base.comp;
-    const gpa = comp.gpa;
-    const handle = elf_file.fileHandle(handle_index);
     const size = (try handle.stat()).size;
 
-    var pos: usize = elf.ARMAG.len;
-    while (true) {
-        if (pos >= size) break;
-        if (!mem.isAligned(pos, 2)) pos += 1;
+    var objects: std.ArrayListUnmanaged(Object) = .empty;
+    defer objects.deinit(gpa);
+
+    var strtab: std.ArrayListUnmanaged(u8) = .empty;
+    defer strtab.deinit(gpa);
 
-        var hdr_buffer: [@sizeOf(elf.ar_hdr)]u8 = undefined;
+    while (pos < size) {
+        pos = mem.alignForward(usize, pos, 2);
+
+        var hdr: elf.ar_hdr = undefined;
         {
-            const amt = try handle.preadAll(&hdr_buffer, pos);
-            if (amt != @sizeOf(elf.ar_hdr)) return error.InputOutput;
+            const n = try handle.preadAll(mem.asBytes(&hdr), pos);
+            if (n != @sizeOf(elf.ar_hdr)) return error.UnexpectedEndOfFile;
         }
-        const hdr = @as(*align(1) const elf.ar_hdr, @ptrCast(&hdr_buffer)).*;
         pos += @sizeOf(elf.ar_hdr);
 
         if (!mem.eql(u8, &hdr.ar_fmag, elf.ARFMAG)) {
-            return elf_file.failParse(path, "invalid archive header delimiter: {s}", .{
+            return diags.failParse(path, "invalid archive header delimiter: {s}", .{
                 std.fmt.fmtSliceEscapeLower(&hdr.ar_fmag),
             });
         }
@@ -45,8 +54,8 @@ pub fn parse(self: *Archive, elf_file: *Elf, path: Path, handle_index: File.Hand
 
         if (hdr.isSymtab() or hdr.isSymtab64()) continue;
         if (hdr.isStrtab()) {
-            try self.strtab.resize(gpa, obj_size);
-            const amt = try handle.preadAll(self.strtab.items, pos);
+            try strtab.resize(gpa, obj_size);
+            const amt = try handle.preadAll(strtab.items, pos);
             if (amt != obj_size) return error.InputOutput;
             continue;
         }
@@ -55,7 +64,7 @@ pub fn parse(self: *Archive, elf_file: *Elf, path: Path, handle_index: File.Hand
         const name = if (hdr.name()) |name|
             name
         else if (try hdr.nameOffset()) |off|
-            self.getString(off)
+            stringTableLookup(strtab.items, off)
         else
             unreachable;
 
@@ -78,14 +87,18 @@ pub fn parse(self: *Archive, elf_file: *Elf, path: Path, handle_index: File.Hand
             @as(Path, object.path), @as(Path, path),
         });
 
-        try self.objects.append(gpa, object);
+        try objects.append(gpa, object);
     }
+
+    return .{
+        .objects = try objects.toOwnedSlice(gpa),
+        .strtab = try strtab.toOwnedSlice(gpa),
+    };
 }
 
-fn getString(self: Archive, off: u32) []const u8 {
-    assert(off < self.strtab.items.len);
-    const name = mem.sliceTo(@as([*:'\n']const u8, @ptrCast(self.strtab.items.ptr + off)), 0);
-    return name[0 .. name.len - 1];
+pub fn stringTableLookup(strtab: []const u8, off: u32) [:'\n']const u8 {
+    const slice = strtab[off..];
+    return slice[0..mem.indexOfScalar(u8, slice, '\n').? :'\n'];
 }
 
 pub fn setArHdr(opts: struct {
@@ -298,8 +311,9 @@ const fs = std.fs;
 const log = std.log.scoped(.link);
 const mem = std.mem;
 const Path = std.Build.Cache.Path;
+const Allocator = std.mem.Allocator;
 
-const Allocator = mem.Allocator;
+const Diags = @import("../../link.zig").Diags;
 const Archive = @This();
 const Elf = @import("../Elf.zig");
 const File = @import("file.zig").File;
diff --git a/zig/src/link/Elf/Atom.zig b/zig/src/link/Elf/Atom.zig
index 20aa249ea5..6775c8c7ff 100644
--- a/zig/src/link/Elf/Atom.zig
+++ b/zig/src/link/Elf/Atom.zig
@@ -102,9 +102,13 @@ pub fn relocsShndx(self: Atom) ?u32 {
     return self.relocs_section_index;
 }
 
-pub fn priority(self: Atom, elf_file: *Elf) u64 {
-    const index = self.file(elf_file).?.index();
-    return (@as(u64, @intCast(index)) << 32) | @as(u64, @intCast(self.input_section_index));
+pub fn priority(atom: Atom, elf_file: *Elf) u64 {
+    const index = atom.file(elf_file).?.index();
+    return priorityLookup(index, atom.input_section_index);
+}
+
+pub fn priorityLookup(file_index: File.Index, input_section_index: u32) u64 {
+    return (@as(u64, @intCast(file_index)) << 32) | @as(u64, @intCast(input_section_index));
 }
 
 /// Returns how much room there is to grow in virtual address space.
@@ -255,19 +259,13 @@ pub fn writeRelocs(self: Atom, elf_file: *Elf, out_relocs: *std.ArrayList(elf.El
     }
 }
 
-pub fn fdes(self: Atom, elf_file: *Elf) []Fde {
-    const extras = self.extra(elf_file);
-    return switch (self.file(elf_file).?) {
-        .shared_object => unreachable,
-        .linker_defined, .zig_object => &[0]Fde{},
-        .object => |x| x.fdes.items[extras.fde_start..][0..extras.fde_count],
-    };
+pub fn fdes(atom: Atom, object: *Object) []Fde {
+    const extras = object.atomExtra(atom.extra_index);
+    return object.fdes.items[extras.fde_start..][0..extras.fde_count];
 }
 
-pub fn markFdesDead(self: Atom, elf_file: *Elf) void {
-    for (self.fdes(elf_file)) |*fde| {
-        fde.alive = false;
-    }
+pub fn markFdesDead(self: Atom, object: *Object) void {
+    for (self.fdes(object)) |*fde| fde.alive = false;
 }
 
 pub fn addReloc(self: Atom, alloc: Allocator, reloc: elf.Elf64_Rela, zo: *ZigObject) !void {
@@ -519,7 +517,8 @@ fn dataType(symbol: *const Symbol, elf_file: *Elf) u2 {
 }
 
 fn reportUnhandledRelocError(self: Atom, rel: elf.Elf64_Rela, elf_file: *Elf) RelocError!void {
-    var err = try elf_file.base.addErrorWithNotes(1);
+    const diags = &elf_file.base.comp.link_diags;
+    var err = try diags.addErrorWithNotes(1);
     try err.addMsg("fatal linker error: unhandled relocation type {} at offset 0x{x}", .{
         relocation.fmtRelocType(rel.r_type(), elf_file.getTarget().cpu.arch),
         rel.r_offset,
@@ -534,7 +533,8 @@ fn reportTextRelocError(
     rel: elf.Elf64_Rela,
     elf_file: *Elf,
 ) RelocError!void {
-    var err = try elf_file.base.addErrorWithNotes(1);
+    const diags = &elf_file.base.comp.link_diags;
+    var err = try diags.addErrorWithNotes(1);
     try err.addMsg("relocation at offset 0x{x} against symbol '{s}' cannot be used", .{
         rel.r_offset,
         symbol.name(elf_file),
@@ -549,7 +549,8 @@ fn reportPicError(
     rel: elf.Elf64_Rela,
     elf_file: *Elf,
 ) RelocError!void {
-    var err = try elf_file.base.addErrorWithNotes(2);
+    const diags = &elf_file.base.comp.link_diags;
+    var err = try diags.addErrorWithNotes(2);
     try err.addMsg("relocation at offset 0x{x} against symbol '{s}' cannot be used", .{
         rel.r_offset,
         symbol.name(elf_file),
@@ -565,7 +566,8 @@ fn reportNoPicError(
     rel: elf.Elf64_Rela,
     elf_file: *Elf,
 ) RelocError!void {
-    var err = try elf_file.base.addErrorWithNotes(2);
+    const diags = &elf_file.base.comp.link_diags;
+    var err = try diags.addErrorWithNotes(2);
     try err.addMsg("relocation at offset 0x{x} against symbol '{s}' cannot be used", .{
         rel.r_offset,
         symbol.name(elf_file),
@@ -588,6 +590,7 @@ fn reportUndefined(
     const file_ptr = self.file(elf_file).?;
     const rel_esym = switch (file_ptr) {
         .zig_object => |x| x.symbol(rel.r_sym()).elfSym(elf_file),
+        .shared_object => |so| so.parsed.symtab[rel.r_sym()],
         inline else => |x| x.symtab.items[rel.r_sym()],
     };
     const esym = sym.elfSym(elf_file);
@@ -941,16 +944,21 @@ fn format2(
         atom.output_section_index, atom.alignment.toByteUnits() orelse 0, atom.size,
         atom.prev_atom_ref,        atom.next_atom_ref,
     });
-    if (atom.fdes(elf_file).len > 0) {
-        try writer.writeAll(" : fdes{ ");
-        const extras = atom.extra(elf_file);
-        for (atom.fdes(elf_file), extras.fde_start..) |fde, i| {
-            try writer.print("{d}", .{i});
-            if (!fde.alive) try writer.writeAll("([*])");
-            if (i - extras.fde_start < extras.fde_count - 1) try writer.writeAll(", ");
-        }
-        try writer.writeAll(" }");
-    }
+    if (atom.file(elf_file)) |atom_file| switch (atom_file) {
+        .object => |object| {
+            if (atom.fdes(object).len > 0) {
+                try writer.writeAll(" : fdes{ ");
+                const extras = atom.extra(elf_file);
+                for (atom.fdes(object), extras.fde_start..) |fde, i| {
+                    try writer.print("{d}", .{i});
+                    if (!fde.alive) try writer.writeAll("([*])");
+                    if (i - extras.fde_start < extras.fde_count - 1) try writer.writeAll(", ");
+                }
+                try writer.writeAll(" }");
+            }
+        },
+        else => {},
+    };
     if (!atom.alive) {
         try writer.writeAll(" : [*]");
     }
@@ -1082,6 +1090,7 @@ const x86_64 = struct {
         stream: anytype,
     ) (error{ InvalidInstruction, CannotEncode } || RelocError)!void {
         dev.check(.x86_64_backend);
+        const diags = &elf_file.base.comp.link_diags;
         const r_type: elf.R_X86_64 = @enumFromInt(rel.r_type());
         const r_offset = std.math.cast(usize, rel.r_offset) orelse return error.Overflow;
 
@@ -1176,7 +1185,7 @@ const x86_64 = struct {
                     try cwriter.writeInt(i32, @as(i32, @intCast(S_ + A - P)), .little);
                 } else {
                     x86_64.relaxGotPcTlsDesc(code[r_offset - 3 ..]) catch {
-                        var err = try elf_file.base.addErrorWithNotes(1);
+                        var err = try diags.addErrorWithNotes(1);
                         try err.addMsg("could not relax {s}", .{@tagName(r_type)});
                         try err.addNote("in {}:{s} at offset 0x{x}", .{
                             atom.file(elf_file).?.fmtPath(),
@@ -1301,6 +1310,7 @@ const x86_64 = struct {
     ) !void {
         dev.check(.x86_64_backend);
         assert(rels.len == 2);
+        const diags = &elf_file.base.comp.link_diags;
         const writer = stream.writer();
         const rel: elf.R_X86_64 = @enumFromInt(rels[1].r_type());
         switch (rel) {
@@ -1317,7 +1327,7 @@ const x86_64 = struct {
             },
 
             else => {
-                var err = try elf_file.base.addErrorWithNotes(1);
+                var err = try diags.addErrorWithNotes(1);
                 try err.addMsg("TODO: rewrite {} when followed by {}", .{
                     relocation.fmtRelocType(rels[0].r_type(), .x86_64),
                     relocation.fmtRelocType(rels[1].r_type(), .x86_64),
@@ -1341,6 +1351,7 @@ const x86_64 = struct {
     ) !void {
         dev.check(.x86_64_backend);
         assert(rels.len == 2);
+        const diags = &elf_file.base.comp.link_diags;
         const writer = stream.writer();
         const rel: elf.R_X86_64 = @enumFromInt(rels[1].r_type());
         switch (rel) {
@@ -1372,7 +1383,7 @@ const x86_64 = struct {
             },
 
             else => {
-                var err = try elf_file.base.addErrorWithNotes(1);
+                var err = try diags.addErrorWithNotes(1);
                 try err.addMsg("TODO: rewrite {} when followed by {}", .{
                     relocation.fmtRelocType(rels[0].r_type(), .x86_64),
                     relocation.fmtRelocType(rels[1].r_type(), .x86_64),
@@ -1446,6 +1457,7 @@ const x86_64 = struct {
     ) !void {
         dev.check(.x86_64_backend);
         assert(rels.len == 2);
+        const diags = &elf_file.base.comp.link_diags;
         const writer = stream.writer();
         const rel: elf.R_X86_64 = @enumFromInt(rels[1].r_type());
         switch (rel) {
@@ -1468,7 +1480,7 @@ const x86_64 = struct {
             },
 
             else => {
-                var err = try elf_file.base.addErrorWithNotes(1);
+                var err = try diags.addErrorWithNotes(1);
                 try err.addMsg("fatal linker error: rewrite {} when followed by {}", .{
                     relocation.fmtRelocType(rels[0].r_type(), .x86_64),
                     relocation.fmtRelocType(rels[1].r_type(), .x86_64),
@@ -1603,6 +1615,7 @@ const aarch64 = struct {
     ) (error{ UnexpectedRemainder, DivisionByZero } || RelocError)!void {
         _ = it;
 
+        const diags = &elf_file.base.comp.link_diags;
         const r_type: elf.R_AARCH64 = @enumFromInt(rel.r_type());
         const r_offset = std.math.cast(usize, rel.r_offset) orelse return error.Overflow;
         const cwriter = stream.writer();
@@ -1657,7 +1670,7 @@ const aarch64 = struct {
                 aarch64_util.writeAdrpInst(pages, code);
             } else {
                 // TODO: relax
-                var err = try elf_file.base.addErrorWithNotes(1);
+                var err = try diags.addErrorWithNotes(1);
                 try err.addMsg("TODO: relax ADR_GOT_PAGE", .{});
                 try err.addNote("in {}:{s} at offset 0x{x}", .{
                     atom.file(elf_file).?.fmtPath(),
@@ -1882,6 +1895,7 @@ const riscv = struct {
         code: []u8,
         stream: anytype,
     ) !void {
+        const diags = &elf_file.base.comp.link_diags;
         const r_type: elf.R_RISCV = @enumFromInt(rel.r_type());
         const r_offset = std.math.cast(usize, rel.r_offset) orelse return error.Overflow;
         const cwriter = stream.writer();
@@ -1943,7 +1957,7 @@ const riscv = struct {
                     if (S == atom_addr + @as(i64, @intCast(pair.r_offset))) break pair;
                 } else {
                     // TODO: implement searching forward
-                    var err = try elf_file.base.addErrorWithNotes(1);
+                    var err = try diags.addErrorWithNotes(1);
                     try err.addMsg("TODO: find HI20 paired reloc scanning forward", .{});
                     try err.addNote("in {}:{s} at offset 0x{x}", .{
                         atom.file(elf_file).?.fmtPath(),
diff --git a/zig/src/link/Elf/LinkerDefined.zig b/zig/src/link/Elf/LinkerDefined.zig
index 9515dfcd43..ad02d8d5d9 100644
--- a/zig/src/link/Elf/LinkerDefined.zig
+++ b/zig/src/link/Elf/LinkerDefined.zig
@@ -205,7 +205,7 @@ pub fn allocateSymbols(self: *LinkerDefined, elf_file: *Elf) void {
     }.allocSymbol;
 
     // _DYNAMIC
-    if (elf_file.dynamic_section_index) |shndx| {
+    if (elf_file.section_indexes.dynamic) |shndx| {
         const shdr = shdrs[shndx];
         allocSymbol(self, self.dynamic_index.?, shdr.sh_addr, shndx, elf_file);
     }
@@ -236,19 +236,19 @@ pub fn allocateSymbols(self: *LinkerDefined, elf_file: *Elf) void {
 
     // _GLOBAL_OFFSET_TABLE_
     if (elf_file.getTarget().cpu.arch == .x86_64) {
-        if (elf_file.got_plt_section_index) |shndx| {
+        if (elf_file.section_indexes.got_plt) |shndx| {
             const shdr = shdrs[shndx];
             allocSymbol(self, self.got_index.?, shdr.sh_addr, shndx, elf_file);
         }
     } else {
-        if (elf_file.got_section_index) |shndx| {
+        if (elf_file.section_indexes.got) |shndx| {
             const shdr = shdrs[shndx];
             allocSymbol(self, self.got_index.?, shdr.sh_addr, shndx, elf_file);
         }
     }
 
     // _PROCEDURE_LINKAGE_TABLE_
-    if (elf_file.plt_section_index) |shndx| {
+    if (elf_file.section_indexes.plt) |shndx| {
         const shdr = shdrs[shndx];
         allocSymbol(self, self.plt_index.?, shdr.sh_addr, shndx, elf_file);
     }
@@ -262,13 +262,13 @@ pub fn allocateSymbols(self: *LinkerDefined, elf_file: *Elf) void {
     }
 
     // __GNU_EH_FRAME_HDR
-    if (elf_file.eh_frame_hdr_section_index) |shndx| {
+    if (elf_file.section_indexes.eh_frame_hdr) |shndx| {
         const shdr = shdrs[shndx];
         allocSymbol(self, self.gnu_eh_frame_hdr_index.?, shdr.sh_addr, shndx, elf_file);
     }
 
     // __rela_iplt_start, __rela_iplt_end
-    if (elf_file.rela_dyn_section_index) |shndx| blk: {
+    if (elf_file.section_indexes.rela_dyn) |shndx| blk: {
         if (link_mode != .static or comp.config.pie) break :blk;
         const shdr = shdrs[shndx];
         const end_addr = shdr.sh_addr + shdr.sh_size;
diff --git a/zig/src/link/Elf/merge_section.zig b/zig/src/link/Elf/Merge.zig
similarity index 77%
rename from zig/src/link/Elf/merge_section.zig
rename to zig/src/link/Elf/Merge.zig
index dc6239d738..33e4f9c5b2 100644
--- a/zig/src/link/Elf/merge_section.zig
+++ b/zig/src/link/Elf/Merge.zig
@@ -1,4 +1,4 @@
-pub const MergeSection = struct {
+pub const Section = struct {
     value: u64 = 0,
     size: u64 = 0,
     alignment: Atom.Alignment = .@"1",
@@ -10,25 +10,25 @@ pub const MergeSection = struct {
     bytes: std.ArrayListUnmanaged(u8) = .empty,
     table: std.HashMapUnmanaged(
         String,
-        MergeSubsection.Index,
+        Subsection.Index,
         IndexContext,
         std.hash_map.default_max_load_percentage,
     ) = .{},
-    subsections: std.ArrayListUnmanaged(MergeSubsection) = .empty,
-    finalized_subsections: std.ArrayListUnmanaged(MergeSubsection.Index) = .empty,
+    subsections: std.ArrayListUnmanaged(Subsection) = .empty,
+    finalized_subsections: std.ArrayListUnmanaged(Subsection.Index) = .empty,
 
-    pub fn deinit(msec: *MergeSection, allocator: Allocator) void {
+    pub fn deinit(msec: *Section, allocator: Allocator) void {
         msec.bytes.deinit(allocator);
         msec.table.deinit(allocator);
         msec.subsections.deinit(allocator);
         msec.finalized_subsections.deinit(allocator);
     }
 
-    pub fn name(msec: MergeSection, elf_file: *Elf) [:0]const u8 {
+    pub fn name(msec: Section, elf_file: *Elf) [:0]const u8 {
         return elf_file.getShString(msec.name_offset);
     }
 
-    pub fn address(msec: MergeSection, elf_file: *Elf) i64 {
+    pub fn address(msec: Section, elf_file: *Elf) i64 {
         const shdr = elf_file.sections.items(.shdr)[msec.output_section_index];
         return @intCast(shdr.sh_addr + msec.value);
     }
@@ -36,10 +36,10 @@ pub const MergeSection = struct {
     const InsertResult = struct {
         found_existing: bool,
         key: String,
-        sub: *MergeSubsection.Index,
+        sub: *Subsection.Index,
     };
 
-    pub fn insert(msec: *MergeSection, allocator: Allocator, string: []const u8) !InsertResult {
+    pub fn insert(msec: *Section, allocator: Allocator, string: []const u8) !InsertResult {
         const gop = try msec.table.getOrPutContextAdapted(
             allocator,
             string,
@@ -54,7 +54,7 @@ pub const MergeSection = struct {
         return .{ .found_existing = gop.found_existing, .key = gop.key_ptr.*, .sub = gop.value_ptr };
     }
 
-    pub fn insertZ(msec: *MergeSection, allocator: Allocator, string: []const u8) !InsertResult {
+    pub fn insertZ(msec: *Section, allocator: Allocator, string: []const u8) !InsertResult {
         const with_null = try allocator.alloc(u8, string.len + 1);
         defer allocator.free(with_null);
         @memcpy(with_null[0..string.len], string);
@@ -64,7 +64,7 @@ pub const MergeSection = struct {
 
     /// Finalizes the merge section and clears hash table.
     /// Sorts all owned subsections.
-    pub fn finalize(msec: *MergeSection, allocator: Allocator) !void {
+    pub fn finalize(msec: *Section, allocator: Allocator) !void {
         try msec.finalized_subsections.ensureTotalCapacityPrecise(allocator, msec.subsections.items.len);
 
         var it = msec.table.iterator();
@@ -76,7 +76,7 @@ pub const MergeSection = struct {
         msec.table.clearAndFree(allocator);
 
         const sortFn = struct {
-            pub fn sortFn(ctx: *MergeSection, lhs: MergeSubsection.Index, rhs: MergeSubsection.Index) bool {
+            pub fn sortFn(ctx: *Section, lhs: Subsection.Index, rhs: Subsection.Index) bool {
                 const lhs_msub = ctx.mergeSubsection(lhs);
                 const rhs_msub = ctx.mergeSubsection(rhs);
                 if (lhs_msub.alignment.compareStrict(.eq, rhs_msub.alignment)) {
@@ -91,10 +91,10 @@ pub const MergeSection = struct {
             }
         }.sortFn;
 
-        std.mem.sort(MergeSubsection.Index, msec.finalized_subsections.items, msec, sortFn);
+        std.mem.sort(Subsection.Index, msec.finalized_subsections.items, msec, sortFn);
     }
 
-    pub fn updateSize(msec: *MergeSection) void {
+    pub fn updateSize(msec: *Section) void {
         // TODO a 'stale' flag would be better here perhaps?
         msec.size = 0;
         msec.alignment = .@"1";
@@ -111,7 +111,7 @@ pub const MergeSection = struct {
         }
     }
 
-    pub fn initOutputSection(msec: *MergeSection, elf_file: *Elf) !void {
+    pub fn initOutputSection(msec: *Section, elf_file: *Elf) !void {
         msec.output_section_index = elf_file.sectionByName(msec.name(elf_file)) orelse try elf_file.addSection(.{
             .name = msec.name_offset,
             .type = msec.type,
@@ -119,14 +119,14 @@ pub const MergeSection = struct {
         });
     }
 
-    pub fn addMergeSubsection(msec: *MergeSection, allocator: Allocator) !MergeSubsection.Index {
-        const index: MergeSubsection.Index = @intCast(msec.subsections.items.len);
+    pub fn addMergeSubsection(msec: *Section, allocator: Allocator) !Subsection.Index {
+        const index: Subsection.Index = @intCast(msec.subsections.items.len);
         const msub = try msec.subsections.addOne(allocator);
         msub.* = .{};
         return index;
     }
 
-    pub fn mergeSubsection(msec: *MergeSection, index: MergeSubsection.Index) *MergeSubsection {
+    pub fn mergeSubsection(msec: *Section, index: Subsection.Index) *Subsection {
         assert(index < msec.subsections.items.len);
         return &msec.subsections.items[index];
     }
@@ -158,7 +158,7 @@ pub const MergeSection = struct {
     };
 
     pub fn format(
-        msec: MergeSection,
+        msec: Section,
         comptime unused_fmt_string: []const u8,
         options: std.fmt.FormatOptions,
         writer: anytype,
@@ -167,10 +167,10 @@ pub const MergeSection = struct {
         _ = unused_fmt_string;
         _ = options;
         _ = writer;
-        @compileError("do not format MergeSection directly");
+        @compileError("do not format directly");
     }
 
-    pub fn fmt(msec: MergeSection, elf_file: *Elf) std.fmt.Formatter(format2) {
+    pub fn fmt(msec: Section, elf_file: *Elf) std.fmt.Formatter(format2) {
         return .{ .data = .{
             .msec = msec,
             .elf_file = elf_file,
@@ -178,7 +178,7 @@ pub const MergeSection = struct {
     }
 
     const FormatContext = struct {
-        msec: MergeSection,
+        msec: Section,
         elf_file: *Elf,
     };
 
@@ -209,30 +209,30 @@ pub const MergeSection = struct {
     pub const Index = u32;
 };
 
-pub const MergeSubsection = struct {
+pub const Subsection = struct {
     value: i64 = 0,
-    merge_section_index: MergeSection.Index = 0,
+    merge_section_index: Section.Index = 0,
     string_index: u32 = 0,
     size: u32 = 0,
     alignment: Atom.Alignment = .@"1",
     entsize: u32 = 0,
     alive: bool = false,
 
-    pub fn address(msub: MergeSubsection, elf_file: *Elf) i64 {
+    pub fn address(msub: Subsection, elf_file: *Elf) i64 {
         return msub.mergeSection(elf_file).address(elf_file) + msub.value;
     }
 
-    pub fn mergeSection(msub: MergeSubsection, elf_file: *Elf) *MergeSection {
+    pub fn mergeSection(msub: Subsection, elf_file: *Elf) *Section {
         return elf_file.mergeSection(msub.merge_section_index);
     }
 
-    pub fn getString(msub: MergeSubsection, elf_file: *Elf) []const u8 {
+    pub fn getString(msub: Subsection, elf_file: *Elf) []const u8 {
         const msec = msub.mergeSection(elf_file);
         return msec.bytes.items[msub.string_index..][0..msub.size];
     }
 
     pub fn format(
-        msub: MergeSubsection,
+        msub: Subsection,
         comptime unused_fmt_string: []const u8,
         options: std.fmt.FormatOptions,
         writer: anytype,
@@ -241,10 +241,10 @@ pub const MergeSubsection = struct {
         _ = unused_fmt_string;
         _ = options;
         _ = writer;
-        @compileError("do not format MergeSubsection directly");
+        @compileError("do not format directly");
     }
 
-    pub fn fmt(msub: MergeSubsection, elf_file: *Elf) std.fmt.Formatter(format2) {
+    pub fn fmt(msub: Subsection, elf_file: *Elf) std.fmt.Formatter(format2) {
         return .{ .data = .{
             .msub = msub,
             .elf_file = elf_file,
@@ -252,7 +252,7 @@ pub const MergeSubsection = struct {
     }
 
     const FormatContext = struct {
-        msub: MergeSubsection,
+        msub: Subsection,
         elf_file: *Elf,
     };
 
@@ -277,32 +277,32 @@ pub const MergeSubsection = struct {
     pub const Index = u32;
 };
 
-pub const InputMergeSection = struct {
-    merge_section_index: MergeSection.Index = 0,
+pub const InputSection = struct {
+    merge_section_index: Section.Index = 0,
     atom_index: Atom.Index = 0,
     offsets: std.ArrayListUnmanaged(u32) = .empty,
-    subsections: std.ArrayListUnmanaged(MergeSubsection.Index) = .empty,
+    subsections: std.ArrayListUnmanaged(Subsection.Index) = .empty,
     bytes: std.ArrayListUnmanaged(u8) = .empty,
     strings: std.ArrayListUnmanaged(String) = .empty,
 
-    pub fn deinit(imsec: *InputMergeSection, allocator: Allocator) void {
+    pub fn deinit(imsec: *InputSection, allocator: Allocator) void {
         imsec.offsets.deinit(allocator);
         imsec.subsections.deinit(allocator);
         imsec.bytes.deinit(allocator);
         imsec.strings.deinit(allocator);
     }
 
-    pub fn clearAndFree(imsec: *InputMergeSection, allocator: Allocator) void {
+    pub fn clearAndFree(imsec: *InputSection, allocator: Allocator) void {
         imsec.bytes.clearAndFree(allocator);
         // TODO: imsec.strings.clearAndFree(allocator);
     }
 
     const FindSubsectionResult = struct {
-        msub_index: MergeSubsection.Index,
+        msub_index: Subsection.Index,
         offset: u32,
     };
 
-    pub fn findSubsection(imsec: InputMergeSection, offset: u32) ?FindSubsectionResult {
+    pub fn findSubsection(imsec: InputSection, offset: u32) ?FindSubsectionResult {
         // TODO: binary search
         for (imsec.offsets.items, 0..) |off, index| {
             if (offset < off) return .{
@@ -320,7 +320,7 @@ pub const InputMergeSection = struct {
         return null;
     }
 
-    pub fn insert(imsec: *InputMergeSection, allocator: Allocator, string: []const u8) !void {
+    pub fn insert(imsec: *InputSection, allocator: Allocator, string: []const u8) !void {
         const index: u32 = @intCast(imsec.bytes.items.len);
         try imsec.bytes.appendSlice(allocator, string);
         try imsec.strings.append(allocator, .{ .pos = index, .len = @intCast(string.len) });
@@ -338,3 +338,4 @@ const std = @import("std");
 const Allocator = mem.Allocator;
 const Atom = @import("Atom.zig");
 const Elf = @import("../Elf.zig");
+const Merge = @This();
diff --git a/zig/src/link/Elf/Object.zig b/zig/src/link/Elf/Object.zig
index 23216020a6..688e51f3f1 100644
--- a/zig/src/link/Elf/Object.zig
+++ b/zig/src/link/Elf/Object.zig
@@ -23,8 +23,8 @@ atoms_extra: std.ArrayListUnmanaged(u32) = .empty,
 comdat_groups: std.ArrayListUnmanaged(Elf.ComdatGroup) = .empty,
 comdat_group_data: std.ArrayListUnmanaged(u32) = .empty,
 
-input_merge_sections: std.ArrayListUnmanaged(InputMergeSection) = .empty,
-input_merge_sections_indexes: std.ArrayListUnmanaged(InputMergeSection.Index) = .empty,
+input_merge_sections: std.ArrayListUnmanaged(Merge.InputSection) = .empty,
+input_merge_sections_indexes: std.ArrayListUnmanaged(Merge.InputSection.Index) = .empty,
 
 fdes: std.ArrayListUnmanaged(Fde) = .empty,
 cies: std.ArrayListUnmanaged(Cie) = .empty,
@@ -37,72 +37,84 @@ num_dynrelocs: u32 = 0,
 output_symtab_ctx: Elf.SymtabCtx = .{},
 output_ar_state: Archive.ArState = .{},
 
-pub fn deinit(self: *Object, allocator: Allocator) void {
-    if (self.archive) |*ar| allocator.free(ar.path.sub_path);
-    allocator.free(self.path.sub_path);
-    self.shdrs.deinit(allocator);
-    self.symtab.deinit(allocator);
-    self.strtab.deinit(allocator);
-    self.symbols.deinit(allocator);
-    self.symbols_extra.deinit(allocator);
-    self.symbols_resolver.deinit(allocator);
-    self.atoms.deinit(allocator);
-    self.atoms_indexes.deinit(allocator);
-    self.atoms_extra.deinit(allocator);
-    self.comdat_groups.deinit(allocator);
-    self.comdat_group_data.deinit(allocator);
-    self.relocs.deinit(allocator);
-    self.fdes.deinit(allocator);
-    self.cies.deinit(allocator);
-    self.eh_frame_data.deinit(allocator);
+pub fn deinit(self: *Object, gpa: Allocator) void {
+    if (self.archive) |*ar| gpa.free(ar.path.sub_path);
+    gpa.free(self.path.sub_path);
+    self.shdrs.deinit(gpa);
+    self.symtab.deinit(gpa);
+    self.strtab.deinit(gpa);
+    self.symbols.deinit(gpa);
+    self.symbols_extra.deinit(gpa);
+    self.symbols_resolver.deinit(gpa);
+    self.atoms.deinit(gpa);
+    self.atoms_indexes.deinit(gpa);
+    self.atoms_extra.deinit(gpa);
+    self.comdat_groups.deinit(gpa);
+    self.comdat_group_data.deinit(gpa);
+    self.relocs.deinit(gpa);
+    self.fdes.deinit(gpa);
+    self.cies.deinit(gpa);
+    self.eh_frame_data.deinit(gpa);
     for (self.input_merge_sections.items) |*isec| {
-        isec.deinit(allocator);
+        isec.deinit(gpa);
     }
-    self.input_merge_sections.deinit(allocator);
-    self.input_merge_sections_indexes.deinit(allocator);
+    self.input_merge_sections.deinit(gpa);
+    self.input_merge_sections_indexes.deinit(gpa);
 }
 
-pub fn parse(self: *Object, elf_file: *Elf) !void {
-    const gpa = elf_file.base.comp.gpa;
-    const cpu_arch = elf_file.getTarget().cpu.arch;
-    const handle = elf_file.fileHandle(self.file_handle);
-
-    try self.parseCommon(gpa, handle, elf_file);
-
+pub fn parse(
+    self: *Object,
+    gpa: Allocator,
+    diags: *Diags,
+    /// For error reporting purposes only.
+    path: Path,
+    handle: fs.File,
+    target: std.Target,
+    debug_fmt_strip: bool,
+    default_sym_version: elf.Versym,
+) !void {
     // Append null input merge section
     try self.input_merge_sections.append(gpa, .{});
     // Allocate atom index 0 to null atom
     try self.atoms.append(gpa, .{ .extra_index = try self.addAtomExtra(gpa, .{}) });
 
-    try self.initAtoms(gpa, handle, elf_file);
-    try self.initSymbols(gpa, elf_file);
+    try self.initAtoms(gpa, diags, path, handle, debug_fmt_strip, target);
+    try self.initSymbols(gpa, default_sym_version);
 
     for (self.shdrs.items, 0..) |shdr, i| {
         const atom_ptr = self.atom(self.atoms_indexes.items[i]) orelse continue;
         if (!atom_ptr.alive) continue;
-        if ((cpu_arch == .x86_64 and shdr.sh_type == elf.SHT_X86_64_UNWIND) or
-            mem.eql(u8, atom_ptr.name(elf_file), ".eh_frame"))
+        if ((target.cpu.arch == .x86_64 and shdr.sh_type == elf.SHT_X86_64_UNWIND) or
+            mem.eql(u8, self.getString(atom_ptr.name_offset), ".eh_frame"))
         {
-            try self.parseEhFrame(gpa, handle, @as(u32, @intCast(i)), elf_file);
+            try self.parseEhFrame(gpa, handle, @intCast(i), target);
         }
     }
 }
 
-fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file: *Elf) !void {
+pub fn parseCommon(
+    self: *Object,
+    gpa: Allocator,
+    diags: *Diags,
+    path: Path,
+    handle: fs.File,
+    target: std.Target,
+    first_eflags: *?elf.Word,
+) !void {
     const offset = if (self.archive) |ar| ar.offset else 0;
     const file_size = (try handle.stat()).size;
 
-    const header_buffer = try Elf.preadAllAlloc(allocator, handle, offset, @sizeOf(elf.Elf64_Ehdr));
-    defer allocator.free(header_buffer);
+    const header_buffer = try Elf.preadAllAlloc(gpa, handle, offset, @sizeOf(elf.Elf64_Ehdr));
+    defer gpa.free(header_buffer);
     self.header = @as(*align(1) const elf.Elf64_Ehdr, @ptrCast(header_buffer)).*;
 
-    const em = elf_file.base.comp.root_mod.resolved_target.result.toElfMachine();
+    const em = target.toElfMachine();
     if (em != self.header.?.e_machine) {
-        return elf_file.failFile(self.index, "invalid ELF machine type: {s}", .{
+        return diags.failParse(path, "invalid ELF machine type: {s}", .{
             @tagName(self.header.?.e_machine),
         });
     }
-    try elf_file.validateEFlags(self.index, self.header.?.e_flags);
+    try validateEFlags(diags, path, target, self.header.?.e_flags, first_eflags);
 
     if (self.header.?.e_shnum == 0) return;
 
@@ -110,30 +122,30 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil
     const shnum = math.cast(usize, self.header.?.e_shnum) orelse return error.Overflow;
     const shsize = shnum * @sizeOf(elf.Elf64_Shdr);
     if (file_size < offset + shoff or file_size < offset + shoff + shsize) {
-        return elf_file.failFile(self.index, "corrupt header: section header table extends past the end of file", .{});
+        return diags.failParse(path, "corrupt header: section header table extends past the end of file", .{});
     }
 
-    const shdrs_buffer = try Elf.preadAllAlloc(allocator, handle, offset + shoff, shsize);
-    defer allocator.free(shdrs_buffer);
+    const shdrs_buffer = try Elf.preadAllAlloc(gpa, handle, offset + shoff, shsize);
+    defer gpa.free(shdrs_buffer);
     const shdrs = @as([*]align(1) const elf.Elf64_Shdr, @ptrCast(shdrs_buffer.ptr))[0..shnum];
-    try self.shdrs.appendUnalignedSlice(allocator, shdrs);
+    try self.shdrs.appendUnalignedSlice(gpa, shdrs);
 
     for (self.shdrs.items) |shdr| {
         if (shdr.sh_type != elf.SHT_NOBITS) {
             if (file_size < offset + shdr.sh_offset or file_size < offset + shdr.sh_offset + shdr.sh_size) {
-                return elf_file.failFile(self.index, "corrupt section: extends past the end of file", .{});
+                return diags.failParse(path, "corrupt section: extends past the end of file", .{});
             }
         }
     }
 
-    const shstrtab = try self.preadShdrContentsAlloc(allocator, handle, self.header.?.e_shstrndx);
-    defer allocator.free(shstrtab);
+    const shstrtab = try self.preadShdrContentsAlloc(gpa, handle, self.header.?.e_shstrndx);
+    defer gpa.free(shstrtab);
     for (self.shdrs.items) |shdr| {
         if (shdr.sh_name >= shstrtab.len) {
-            return elf_file.failFile(self.index, "corrupt section name offset", .{});
+            return diags.failParse(path, "corrupt section name offset", .{});
         }
     }
-    try self.strtab.appendSlice(allocator, shstrtab);
+    try self.strtab.appendSlice(gpa, shstrtab);
 
     const symtab_index = for (self.shdrs.items, 0..) |shdr, i| switch (shdr.sh_type) {
         elf.SHT_SYMTAB => break @as(u32, @intCast(i)),
@@ -144,19 +156,19 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil
         const shdr = self.shdrs.items[index];
         self.first_global = shdr.sh_info;
 
-        const raw_symtab = try self.preadShdrContentsAlloc(allocator, handle, index);
-        defer allocator.free(raw_symtab);
+        const raw_symtab = try self.preadShdrContentsAlloc(gpa, handle, index);
+        defer gpa.free(raw_symtab);
         const nsyms = math.divExact(usize, raw_symtab.len, @sizeOf(elf.Elf64_Sym)) catch {
-            return elf_file.failFile(self.index, "symbol table not evenly divisible", .{});
+            return diags.failParse(path, "symbol table not evenly divisible", .{});
         };
         const symtab = @as([*]align(1) const elf.Elf64_Sym, @ptrCast(raw_symtab.ptr))[0..nsyms];
 
         const strtab_bias = @as(u32, @intCast(self.strtab.items.len));
-        const strtab = try self.preadShdrContentsAlloc(allocator, handle, shdr.sh_link);
-        defer allocator.free(strtab);
-        try self.strtab.appendSlice(allocator, strtab);
+        const strtab = try self.preadShdrContentsAlloc(gpa, handle, shdr.sh_link);
+        defer gpa.free(strtab);
+        try self.strtab.appendSlice(gpa, strtab);
 
-        try self.symtab.ensureUnusedCapacity(allocator, symtab.len);
+        try self.symtab.ensureUnusedCapacity(gpa, symtab.len);
         for (symtab) |sym| {
             const out_sym = self.symtab.addOneAssumeCapacity();
             out_sym.* = sym;
@@ -168,15 +180,56 @@ fn parseCommon(self: *Object, allocator: Allocator, handle: std.fs.File, elf_fil
     }
 }
 
-fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file: *Elf) !void {
-    const comp = elf_file.base.comp;
-    const debug_fmt_strip = comp.config.debug_format == .strip;
-    const target = comp.root_mod.resolved_target.result;
+fn validateEFlags(
+    diags: *Diags,
+    path: Path,
+    target: std.Target,
+    e_flags: elf.Word,
+    first_eflags: *?elf.Word,
+) error{LinkFailure}!void {
+    if (first_eflags.*) |*self_eflags| {
+        switch (target.cpu.arch) {
+            .riscv64 => {
+                if (e_flags != self_eflags.*) {
+                    const riscv_eflags: riscv.RiscvEflags = @bitCast(e_flags);
+                    const self_riscv_eflags: *riscv.RiscvEflags = @ptrCast(self_eflags);
+
+                    self_riscv_eflags.rvc = self_riscv_eflags.rvc or riscv_eflags.rvc;
+                    self_riscv_eflags.tso = self_riscv_eflags.tso or riscv_eflags.tso;
+
+                    var any_errors: bool = false;
+                    if (self_riscv_eflags.fabi != riscv_eflags.fabi) {
+                        any_errors = true;
+                        diags.addParseError(path, "cannot link object files with different float-point ABIs", .{});
+                    }
+                    if (self_riscv_eflags.rve != riscv_eflags.rve) {
+                        any_errors = true;
+                        diags.addParseError(path, "cannot link object files with different RVEs", .{});
+                    }
+                    if (any_errors) return error.LinkFailure;
+                }
+            },
+            else => {},
+        }
+    } else {
+        first_eflags.* = e_flags;
+    }
+}
+
+fn initAtoms(
+    self: *Object,
+    gpa: Allocator,
+    diags: *Diags,
+    path: Path,
+    handle: fs.File,
+    debug_fmt_strip: bool,
+    target: std.Target,
+) !void {
     const shdrs = self.shdrs.items;
-    try self.atoms.ensureTotalCapacityPrecise(allocator, shdrs.len);
-    try self.atoms_extra.ensureTotalCapacityPrecise(allocator, shdrs.len * @sizeOf(Atom.Extra));
-    try self.atoms_indexes.ensureTotalCapacityPrecise(allocator, shdrs.len);
-    try self.atoms_indexes.resize(allocator, shdrs.len);
+    try self.atoms.ensureTotalCapacityPrecise(gpa, shdrs.len);
+    try self.atoms_extra.ensureTotalCapacityPrecise(gpa, shdrs.len * @sizeOf(Atom.Extra));
+    try self.atoms_indexes.ensureTotalCapacityPrecise(gpa, shdrs.len);
+    try self.atoms_indexes.resize(gpa, shdrs.len);
     @memset(self.atoms_indexes.items, 0);
 
     for (shdrs, 0..) |shdr, i| {
@@ -201,24 +254,24 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:
                 };
 
                 const shndx: u32 = @intCast(i);
-                const group_raw_data = try self.preadShdrContentsAlloc(allocator, handle, shndx);
-                defer allocator.free(group_raw_data);
+                const group_raw_data = try self.preadShdrContentsAlloc(gpa, handle, shndx);
+                defer gpa.free(group_raw_data);
                 const group_nmembers = math.divExact(usize, group_raw_data.len, @sizeOf(u32)) catch {
-                    return elf_file.failFile(self.index, "corrupt section group: not evenly divisible ", .{});
+                    return diags.failParse(path, "corrupt section group: not evenly divisible ", .{});
                 };
                 if (group_nmembers == 0) {
-                    return elf_file.failFile(self.index, "corrupt section group: empty section", .{});
+                    return diags.failParse(path, "corrupt section group: empty section", .{});
                 }
                 const group_members = @as([*]align(1) const u32, @ptrCast(group_raw_data.ptr))[0..group_nmembers];
 
                 if (group_members[0] != elf.GRP_COMDAT) {
-                    return elf_file.failFile(self.index, "corrupt section group: unknown SHT_GROUP format", .{});
+                    return diags.failParse(path, "corrupt section group: unknown SHT_GROUP format", .{});
                 }
 
                 const group_start: u32 = @intCast(self.comdat_group_data.items.len);
-                try self.comdat_group_data.appendUnalignedSlice(allocator, group_members[1..]);
+                try self.comdat_group_data.appendUnalignedSlice(gpa, group_members[1..]);
 
-                const comdat_group_index = try self.addComdatGroup(allocator);
+                const comdat_group_index = try self.addComdatGroup(gpa);
                 const comdat_group = self.comdatGroup(comdat_group_index);
                 comdat_group.* = .{
                     .signature_off = group_signature,
@@ -242,8 +295,8 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:
                 const shndx: u32 = @intCast(i);
                 if (self.skipShdr(shndx, debug_fmt_strip)) continue;
                 const size, const alignment = if (shdr.sh_flags & elf.SHF_COMPRESSED != 0) blk: {
-                    const data = try self.preadShdrContentsAlloc(allocator, handle, shndx);
-                    defer allocator.free(data);
+                    const data = try self.preadShdrContentsAlloc(gpa, handle, shndx);
+                    defer gpa.free(data);
                     const chdr = @as(*align(1) const elf.Elf64_Chdr, @ptrCast(data.ptr)).*;
                     break :blk .{ chdr.ch_size, Alignment.fromNonzeroByteUnits(chdr.ch_addralign) };
                 } else .{ shdr.sh_size, Alignment.fromNonzeroByteUnits(shdr.sh_addralign) };
@@ -263,13 +316,13 @@ fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file:
         elf.SHT_REL, elf.SHT_RELA => {
             const atom_index = self.atoms_indexes.items[shdr.sh_info];
             if (self.atom(atom_index)) |atom_ptr| {
-                const relocs = try self.preadRelocsAlloc(allocator, handle, @intCast(i));
-                defer allocator.free(relocs);
+                const relocs = try self.preadRelocsAlloc(gpa, handle, @intCast(i));
+                defer gpa.free(relocs);
                 atom_ptr.relocs_section_index = @intCast(i);
                 const rel_index: u32 = @intCast(self.relocs.items.len);
                 const rel_count: u32 = @intCast(relocs.len);
                 self.setAtomFields(atom_ptr, .{ .rel_index = rel_index, .rel_count = rel_count });
-                try self.relocs.appendUnalignedSlice(allocator, relocs);
+                try self.relocs.appendUnalignedSlice(gpa, relocs);
                 if (target.cpu.arch == .riscv64) {
                     sortRelocs(self.relocs.items[rel_index..][0..rel_count]);
                 }
@@ -293,14 +346,18 @@ fn skipShdr(self: *Object, index: u32, debug_fmt_strip: bool) bool {
     return ignore;
 }
 
-fn initSymbols(self: *Object, allocator: Allocator, elf_file: *Elf) !void {
+fn initSymbols(
+    self: *Object,
+    gpa: Allocator,
+    default_sym_version: elf.Versym,
+) !void {
     const first_global = self.first_global orelse self.symtab.items.len;
     const nglobals = self.symtab.items.len - first_global;
 
-    try self.symbols.ensureTotalCapacityPrecise(allocator, self.symtab.items.len);
-    try self.symbols_extra.ensureTotalCapacityPrecise(allocator, self.symtab.items.len * @sizeOf(Symbol.Extra));
-    try self.symbols_resolver.ensureTotalCapacityPrecise(allocator, nglobals);
-    self.symbols_resolver.resize(allocator, nglobals) catch unreachable;
+    try self.symbols.ensureTotalCapacityPrecise(gpa, self.symtab.items.len);
+    try self.symbols_extra.ensureTotalCapacityPrecise(gpa, self.symtab.items.len * @sizeOf(Symbol.Extra));
+    try self.symbols_resolver.ensureTotalCapacityPrecise(gpa, nglobals);
+    self.symbols_resolver.resize(gpa, nglobals) catch unreachable;
     @memset(self.symbols_resolver.items, 0);
 
     for (self.symtab.items, 0..) |sym, i| {
@@ -310,7 +367,7 @@ fn initSymbols(self: *Object, allocator: Allocator, elf_file: *Elf) !void {
         sym_ptr.name_offset = sym.st_name;
         sym_ptr.esym_index = @intCast(i);
         sym_ptr.extra_index = self.addSymbolExtraAssumeCapacity(.{});
-        sym_ptr.version_index = if (i >= first_global) elf_file.default_sym_version else elf.VER_NDX_LOCAL;
+        sym_ptr.version_index = if (i >= first_global) default_sym_version else .LOCAL;
         sym_ptr.flags.weak = sym.st_bind() == elf.STB_WEAK;
         if (sym.st_shndx != elf.SHN_ABS and sym.st_shndx != elf.SHN_COMMON) {
             sym_ptr.ref = .{ .index = self.atoms_indexes.items[sym.st_shndx], .file = self.index };
@@ -318,24 +375,34 @@ fn initSymbols(self: *Object, allocator: Allocator, elf_file: *Elf) !void {
     }
 }
 
-fn parseEhFrame(self: *Object, allocator: Allocator, handle: std.fs.File, shndx: u32, elf_file: *Elf) !void {
+fn parseEhFrame(
+    self: *Object,
+    gpa: Allocator,
+    handle: fs.File,
+    shndx: u32,
+    target: std.Target,
+) !void {
     const relocs_shndx = for (self.shdrs.items, 0..) |shdr, i| switch (shdr.sh_type) {
         elf.SHT_RELA => if (shdr.sh_info == shndx) break @as(u32, @intCast(i)),
         else => {},
     } else null;
 
-    const raw = try self.preadShdrContentsAlloc(allocator, handle, shndx);
-    defer allocator.free(raw);
-    const data_start = @as(u32, @intCast(self.eh_frame_data.items.len));
-    try self.eh_frame_data.appendSlice(allocator, raw);
+    const raw = try self.preadShdrContentsAlloc(gpa, handle, shndx);
+    defer gpa.free(raw);
+    const data_start: u32 = @intCast(self.eh_frame_data.items.len);
+    try self.eh_frame_data.appendSlice(gpa, raw);
     const relocs = if (relocs_shndx) |index|
-        try self.preadRelocsAlloc(allocator, handle, index)
+        try self.preadRelocsAlloc(gpa, handle, index)
     else
         &[0]elf.Elf64_Rela{};
-    defer allocator.free(relocs);
-    const rel_start = @as(u32, @intCast(self.relocs.items.len));
-    try self.relocs.appendUnalignedSlice(allocator, relocs);
-    if (elf_file.getTarget().cpu.arch == .riscv64) {
+    defer gpa.free(relocs);
+    const rel_start: u32 = @intCast(self.relocs.items.len);
+    try self.relocs.appendUnalignedSlice(gpa, relocs);
+
+    // We expect relocations to be sorted by r_offset as per this comment in mold linker:
+    // https://github.com/rui314/mold/blob/8e4f7b53832d8af4f48a633a8385cbc932d1944e/src/input-files.cc#L653
+    // Except for RISCV and Loongarch which do not seem to be uphold this convention.
+    if (target.cpu.arch == .riscv64) {
         sortRelocs(self.relocs.items[rel_start..][0..relocs.len]);
     }
     const fdes_start = self.fdes.items.len;
@@ -345,11 +412,11 @@ fn parseEhFrame(self: *Object, allocator: Allocator, handle: std.fs.File, shndx:
     while (try it.next()) |rec| {
         const rel_range = filterRelocs(self.relocs.items[rel_start..][0..relocs.len], rec.offset, rec.size + 4);
         switch (rec.tag) {
-            .cie => try self.cies.append(allocator, .{
+            .cie => try self.cies.append(gpa, .{
                 .offset = data_start + rec.offset,
                 .size = rec.size,
                 .rel_index = rel_start + @as(u32, @intCast(rel_range.start)),
-                .rel_num = @as(u32, @intCast(rel_range.len)),
+                .rel_num = @intCast(rel_range.len),
                 .input_section_index = shndx,
                 .file_index = self.index,
             }),
@@ -361,12 +428,12 @@ fn parseEhFrame(self: *Object, allocator: Allocator, handle: std.fs.File, shndx:
                     // this can happen for object files built with -r flag by the linker.
                     continue;
                 }
-                try self.fdes.append(allocator, .{
+                try self.fdes.append(gpa, .{
                     .offset = data_start + rec.offset,
                     .size = rec.size,
                     .cie_index = undefined,
                     .rel_index = rel_start + @as(u32, @intCast(rel_range.start)),
-                    .rel_num = @as(u32, @intCast(rel_range.len)),
+                    .rel_num = @intCast(rel_range.len),
                     .input_section_index = shndx,
                     .file_index = self.index,
                 });
@@ -376,7 +443,7 @@ fn parseEhFrame(self: *Object, allocator: Allocator, handle: std.fs.File, shndx:
 
     // Tie each FDE to its CIE
     for (self.fdes.items[fdes_start..]) |*fde| {
-        const cie_ptr = fde.offset + 4 - fde.ciePointer(elf_file);
+        const cie_ptr = fde.offset + 4 - fde.ciePointer(self);
         const cie_index = for (self.cies.items[cies_start..], cies_start..) |cie, cie_index| {
             if (cie.offset == cie_ptr) break @as(u32, @intCast(cie_index));
         } else {
@@ -392,26 +459,26 @@ fn parseEhFrame(self: *Object, allocator: Allocator, handle: std.fs.File, shndx:
 
     // Tie each FDE record to its matching atom
     const SortFdes = struct {
-        pub fn lessThan(ctx: *Elf, lhs: Fde, rhs: Fde) bool {
+        pub fn lessThan(ctx: *Object, lhs: Fde, rhs: Fde) bool {
             const lhs_atom = lhs.atom(ctx);
             const rhs_atom = rhs.atom(ctx);
-            return lhs_atom.priority(ctx) < rhs_atom.priority(ctx);
+            return Atom.priorityLookup(ctx.index, lhs_atom.input_section_index) < Atom.priorityLookup(ctx.index, rhs_atom.input_section_index);
         }
     };
-    mem.sort(Fde, self.fdes.items[fdes_start..], elf_file, SortFdes.lessThan);
+    mem.sort(Fde, self.fdes.items[fdes_start..], self, SortFdes.lessThan);
 
     // Create a back-link from atom to FDEs
-    var i: u32 = @as(u32, @intCast(fdes_start));
+    var i: u32 = @intCast(fdes_start);
     while (i < self.fdes.items.len) {
         const fde = self.fdes.items[i];
-        const atom_ptr = fde.atom(elf_file);
+        const atom_ptr = fde.atom(self);
         const start = i;
         i += 1;
         while (i < self.fdes.items.len) : (i += 1) {
             const next_fde = self.fdes.items[i];
-            if (atom_ptr.atom_index != next_fde.atom(elf_file).atom_index) break;
+            if (atom_ptr.atom_index != next_fde.atom(self).atom_index) break;
         }
-        atom_ptr.addExtra(.{ .fde_start = start, .fde_count = i - start }, elf_file);
+        self.setAtomFields(atom_ptr, .{ .fde_start = start, .fde_count = i - start });
     }
 }
 
@@ -536,7 +603,7 @@ pub fn claimUnresolved(self: *Object, elf_file: *Elf) void {
         sym.ref = .{ .index = 0, .file = 0 };
         sym.esym_index = esym_index;
         sym.file_index = self.index;
-        sym.version_index = if (is_import) elf.VER_NDX_LOCAL else elf_file.default_sym_version;
+        sym.version_index = if (is_import) .LOCAL else elf_file.default_sym_version;
         sym.flags.import = is_import;
 
         const idx = self.symbols_resolver.items[i];
@@ -598,8 +665,9 @@ pub fn markImportsExports(self: *Object, elf_file: *Elf) void {
         const ref = self.resolveSymbol(@intCast(idx), elf_file);
         const sym = elf_file.symbol(ref) orelse continue;
         const file = sym.file(elf_file).?;
-        if (sym.version_index == elf.VER_NDX_LOCAL) continue;
-        const vis = @as(elf.STV, @enumFromInt(sym.elfSym(elf_file).st_other));
+        // https://github.com/ziglang/zig/issues/21678
+        if (@as(u16, @bitCast(sym.version_index)) == @as(u16, @bitCast(elf.Versym.LOCAL))) continue;
+        const vis: elf.STV = @enumFromInt(sym.elfSym(elf_file).st_other);
         if (vis == .HIDDEN) continue;
         if (file == .shared_object and !sym.isAbs(elf_file)) {
             sym.flags.import = true;
@@ -644,6 +712,7 @@ pub fn checkDuplicates(self: *Object, dupes: anytype, elf_file: *Elf) error{OutO
 
 pub fn initInputMergeSections(self: *Object, elf_file: *Elf) !void {
     const gpa = elf_file.base.comp.gpa;
+    const diags = &elf_file.base.comp.link_diags;
 
     try self.input_merge_sections.ensureUnusedCapacity(gpa, self.shdrs.items.len);
     try self.input_merge_sections_indexes.resize(gpa, self.shdrs.items.len);
@@ -685,7 +754,7 @@ pub fn initInputMergeSections(self: *Object, elf_file: *Elf) !void {
                 var end = start;
                 while (end < data.len - sh_entsize and !isNull(data[end .. end + sh_entsize])) : (end += sh_entsize) {}
                 if (!isNull(data[end .. end + sh_entsize])) {
-                    var err = try elf_file.base.addErrorWithNotes(1);
+                    var err = try diags.addErrorWithNotes(1);
                     try err.addMsg("string not null terminated", .{});
                     try err.addNote("in {}:{s}", .{ self.fmtPath(), atom_ptr.name(elf_file) });
                     return error.LinkFailure;
@@ -700,7 +769,7 @@ pub fn initInputMergeSections(self: *Object, elf_file: *Elf) !void {
             const sh_entsize: u32 = @intCast(shdr.sh_entsize);
             if (sh_entsize == 0) continue; // Malformed, don't split but don't error out
             if (shdr.sh_size % sh_entsize != 0) {
-                var err = try elf_file.base.addErrorWithNotes(1);
+                var err = try diags.addErrorWithNotes(1);
                 try err.addMsg("size not a multiple of sh_entsize", .{});
                 try err.addNote("in {}:{s}", .{ self.fmtPath(), atom_ptr.name(elf_file) });
                 return error.LinkFailure;
@@ -738,6 +807,7 @@ pub fn resolveMergeSubsections(self: *Object, elf_file: *Elf) error{
     Overflow,
 }!void {
     const gpa = elf_file.base.comp.gpa;
+    const diags = &elf_file.base.comp.link_diags;
 
     for (self.input_merge_sections_indexes.items) |index| {
         const imsec = self.inputMergeSection(index) orelse continue;
@@ -776,7 +846,7 @@ pub fn resolveMergeSubsections(self: *Object, elf_file: *Elf) error{
         const imsec = self.inputMergeSection(imsec_index) orelse continue;
         if (imsec.offsets.items.len == 0) continue;
         const res = imsec.findSubsection(@intCast(esym.st_value)) orelse {
-            var err = try elf_file.base.addErrorWithNotes(2);
+            var err = try diags.addErrorWithNotes(2);
             try err.addMsg("invalid symbol value: {x}", .{esym.st_value});
             try err.addNote("for symbol {s}", .{sym.name(elf_file)});
             try err.addNote("in {}", .{self.fmtPath()});
@@ -802,7 +872,7 @@ pub fn resolveMergeSubsections(self: *Object, elf_file: *Elf) error{
             if (imsec.offsets.items.len == 0) continue;
             const msec = elf_file.mergeSection(imsec.merge_section_index);
             const res = imsec.findSubsection(@intCast(@as(i64, @intCast(esym.st_value)) + rel.r_addend)) orelse {
-                var err = try elf_file.base.addErrorWithNotes(1);
+                var err = try diags.addErrorWithNotes(1);
                 try err.addMsg("invalid relocation at offset 0x{x}", .{rel.r_offset});
                 try err.addNote("in {}:{s}", .{ self.fmtPath(), atom_ptr.name(elf_file) });
                 return error.LinkFailure;
@@ -901,7 +971,7 @@ pub fn markComdatGroupsDead(self: *Object, elf_file: *Elf) void {
             const atom_index = self.atoms_indexes.items[shndx];
             if (self.atom(atom_index)) |atom_ptr| {
                 atom_ptr.alive = false;
-                atom_ptr.markFdesDead(elf_file);
+                atom_ptr.markFdesDead(self);
             }
         }
     }
@@ -927,7 +997,7 @@ pub fn initRelaSections(self: *Object, elf_file: *Elf) !void {
     for (self.atoms_indexes.items) |atom_index| {
         const atom_ptr = self.atom(atom_index) orelse continue;
         if (!atom_ptr.alive) continue;
-        if (atom_ptr.output_section_index == elf_file.eh_frame_section_index) continue;
+        if (atom_ptr.output_section_index == elf_file.section_indexes.eh_frame) continue;
         const shndx = atom_ptr.relocsShndx() orelse continue;
         const shdr = self.shdrs.items[shndx];
         const out_shndx = try elf_file.initOutputSection(.{
@@ -947,7 +1017,7 @@ pub fn addAtomsToRelaSections(self: *Object, elf_file: *Elf) !void {
     for (self.atoms_indexes.items) |atom_index| {
         const atom_ptr = self.atom(atom_index) orelse continue;
         if (!atom_ptr.alive) continue;
-        if (atom_ptr.output_section_index == elf_file.eh_frame_section_index) continue;
+        if (atom_ptr.output_section_index == elf_file.section_indexes.eh_frame) continue;
         const shndx = blk: {
             const shndx = atom_ptr.relocsShndx() orelse continue;
             const shdr = self.shdrs.items[shndx];
@@ -960,19 +1030,13 @@ pub fn addAtomsToRelaSections(self: *Object, elf_file: *Elf) !void {
         const slice = elf_file.sections.slice();
         const shdr = &slice.items(.shdr)[shndx];
         shdr.sh_info = atom_ptr.output_section_index;
-        shdr.sh_link = elf_file.symtab_section_index.?;
+        shdr.sh_link = elf_file.section_indexes.symtab.?;
         const gpa = elf_file.base.comp.gpa;
         const atom_list = &elf_file.sections.items(.atom_list)[shndx];
         try atom_list.append(gpa, .{ .index = atom_index, .file = self.index });
     }
 }
 
-pub fn parseAr(self: *Object, elf_file: *Elf) !void {
-    const gpa = elf_file.base.comp.gpa;
-    const handle = elf_file.fileHandle(self.file_handle);
-    try self.parseCommon(gpa, handle, elf_file);
-}
-
 pub fn updateArSymtab(self: Object, ar_symtab: *Archive.ArSymtab, elf_file: *Elf) !void {
     const comp = elf_file.base.comp;
     const gpa = comp.gpa;
@@ -997,7 +1061,7 @@ pub fn updateArSize(self: *Object, elf_file: *Elf) !void {
 pub fn writeAr(self: Object, elf_file: *Elf, writer: anytype) !void {
     const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;
     const offset: u64 = if (self.archive) |ar| ar.offset else 0;
-    const name = std.fs.path.basename(self.path.sub_path);
+    const name = fs.path.basename(self.path.sub_path);
     const hdr = Archive.setArHdr(.{
         .name = if (name.len <= Archive.max_member_name_len)
             .{ .name = name }
@@ -1133,8 +1197,8 @@ pub fn resolveSymbol(self: Object, index: Symbol.Index, elf_file: *Elf) Elf.Ref
     return elf_file.resolver.get(resolv).?;
 }
 
-fn addSymbol(self: *Object, allocator: Allocator) !Symbol.Index {
-    try self.symbols.ensureUnusedCapacity(allocator, 1);
+fn addSymbol(self: *Object, gpa: Allocator) !Symbol.Index {
+    try self.symbols.ensureUnusedCapacity(gpa, 1);
     return self.addSymbolAssumeCapacity();
 }
 
@@ -1144,9 +1208,9 @@ fn addSymbolAssumeCapacity(self: *Object) Symbol.Index {
     return index;
 }
 
-pub fn addSymbolExtra(self: *Object, allocator: Allocator, extra: Symbol.Extra) !u32 {
+pub fn addSymbolExtra(self: *Object, gpa: Allocator, extra: Symbol.Extra) !u32 {
     const fields = @typeInfo(Symbol.Extra).@"struct".fields;
-    try self.symbols_extra.ensureUnusedCapacity(allocator, fields.len);
+    try self.symbols_extra.ensureUnusedCapacity(gpa, fields.len);
     return self.addSymbolExtraAssumeCapacity(extra);
 }
 
@@ -1195,27 +1259,27 @@ pub fn getString(self: Object, off: u32) [:0]const u8 {
     return mem.sliceTo(@as([*:0]const u8, @ptrCast(self.strtab.items.ptr + off)), 0);
 }
 
-fn addString(self: *Object, allocator: Allocator, str: []const u8) !u32 {
+fn addString(self: *Object, gpa: Allocator, str: []const u8) !u32 {
     const off: u32 = @intCast(self.strtab.items.len);
-    try self.strtab.ensureUnusedCapacity(allocator, str.len + 1);
+    try self.strtab.ensureUnusedCapacity(gpa, str.len + 1);
     self.strtab.appendSliceAssumeCapacity(str);
     self.strtab.appendAssumeCapacity(0);
     return off;
 }
 
 /// Caller owns the memory.
-fn preadShdrContentsAlloc(self: Object, allocator: Allocator, handle: std.fs.File, index: u32) ![]u8 {
+fn preadShdrContentsAlloc(self: Object, gpa: Allocator, handle: fs.File, index: u32) ![]u8 {
     assert(index < self.shdrs.items.len);
     const offset = if (self.archive) |ar| ar.offset else 0;
     const shdr = self.shdrs.items[index];
     const sh_offset = math.cast(u64, shdr.sh_offset) orelse return error.Overflow;
     const sh_size = math.cast(u64, shdr.sh_size) orelse return error.Overflow;
-    return Elf.preadAllAlloc(allocator, handle, offset + sh_offset, sh_size);
+    return Elf.preadAllAlloc(gpa, handle, offset + sh_offset, sh_size);
 }
 
 /// Caller owns the memory.
-fn preadRelocsAlloc(self: Object, allocator: Allocator, handle: std.fs.File, shndx: u32) ![]align(1) const elf.Elf64_Rela {
-    const raw = try self.preadShdrContentsAlloc(allocator, handle, shndx);
+fn preadRelocsAlloc(self: Object, gpa: Allocator, handle: fs.File, shndx: u32) ![]align(1) const elf.Elf64_Rela {
+    const raw = try self.preadShdrContentsAlloc(gpa, handle, shndx);
     const num = @divExact(raw.len, @sizeOf(elf.Elf64_Rela));
     return @as([*]align(1) const elf.Elf64_Rela, @ptrCast(raw.ptr))[0..num];
 }
@@ -1227,9 +1291,9 @@ const AddAtomArgs = struct {
     alignment: Alignment,
 };
 
-fn addAtom(self: *Object, allocator: Allocator, args: AddAtomArgs) !Atom.Index {
-    try self.atoms.ensureUnusedCapacity(allocator, 1);
-    try self.atoms_extra.ensureUnusedCapacity(allocator, @sizeOf(Atom.Extra));
+fn addAtom(self: *Object, gpa: Allocator, args: AddAtomArgs) !Atom.Index {
+    try self.atoms.ensureUnusedCapacity(gpa, 1);
+    try self.atoms_extra.ensureUnusedCapacity(gpa, @sizeOf(Atom.Extra));
     return self.addAtomAssumeCapacity(args);
 }
 
@@ -1254,9 +1318,9 @@ pub fn atom(self: *Object, atom_index: Atom.Index) ?*Atom {
     return &self.atoms.items[atom_index];
 }
 
-pub fn addAtomExtra(self: *Object, allocator: Allocator, extra: Atom.Extra) !u32 {
+pub fn addAtomExtra(self: *Object, gpa: Allocator, extra: Atom.Extra) !u32 {
     const fields = @typeInfo(Atom.Extra).@"struct".fields;
-    try self.atoms_extra.ensureUnusedCapacity(allocator, fields.len);
+    try self.atoms_extra.ensureUnusedCapacity(gpa, fields.len);
     return self.addAtomExtraAssumeCapacity(extra);
 }
 
@@ -1305,21 +1369,21 @@ fn setAtomFields(o: *Object, atom_ptr: *Atom, opts: Atom.Extra.AsOptionals) void
     o.setAtomExtra(atom_ptr.extra_index, extras);
 }
 
-fn addInputMergeSection(self: *Object, allocator: Allocator) !InputMergeSection.Index {
-    const index: InputMergeSection.Index = @intCast(self.input_merge_sections.items.len);
-    const msec = try self.input_merge_sections.addOne(allocator);
+fn addInputMergeSection(self: *Object, gpa: Allocator) !Merge.InputSection.Index {
+    const index: Merge.InputSection.Index = @intCast(self.input_merge_sections.items.len);
+    const msec = try self.input_merge_sections.addOne(gpa);
     msec.* = .{};
     return index;
 }
 
-fn inputMergeSection(self: *Object, index: InputMergeSection.Index) ?*InputMergeSection {
+fn inputMergeSection(self: *Object, index: Merge.InputSection.Index) ?*Merge.InputSection {
     if (index == 0) return null;
     return &self.input_merge_sections.items[index];
 }
 
-fn addComdatGroup(self: *Object, allocator: Allocator) !Elf.ComdatGroup.Index {
+fn addComdatGroup(self: *Object, gpa: Allocator) !Elf.ComdatGroup.Index {
     const index = @as(Elf.ComdatGroup.Index, @intCast(self.comdat_groups.items.len));
-    _ = try self.comdat_groups.addOne(allocator);
+    _ = try self.comdat_groups.addOne(gpa);
     return index;
 }
 
@@ -1513,8 +1577,9 @@ const log = std.log.scoped(.link);
 const math = std.math;
 const mem = std.mem;
 const Path = std.Build.Cache.Path;
-const Allocator = mem.Allocator;
+const Allocator = std.mem.Allocator;
 
+const Diags = @import("../../link.zig").Diags;
 const Archive = @import("Archive.zig");
 const Atom = @import("Atom.zig");
 const AtomList = @import("AtomList.zig");
@@ -1522,6 +1587,7 @@ const Cie = eh_frame.Cie;
 const Elf = @import("../Elf.zig");
 const Fde = eh_frame.Fde;
 const File = @import("file.zig").File;
-const InputMergeSection = @import("merge_section.zig").InputMergeSection;
+const Merge = @import("Merge.zig");
 const Symbol = @import("Symbol.zig");
 const Alignment = Atom.Alignment;
+const riscv = @import("../riscv.zig");
diff --git a/zig/src/link/Elf/SharedObject.zig b/zig/src/link/Elf/SharedObject.zig
index 7e6aabea38..8b4f482226 100644
--- a/zig/src/link/Elf/SharedObject.zig
+++ b/zig/src/link/Elf/SharedObject.zig
@@ -1,236 +1,317 @@
 path: Path,
 index: File.Index,
 
-header: ?elf.Elf64_Ehdr = null,
-shdrs: std.ArrayListUnmanaged(elf.Elf64_Shdr) = .empty,
+parsed: Parsed,
 
-symtab: std.ArrayListUnmanaged(elf.Elf64_Sym) = .empty,
-strtab: std.ArrayListUnmanaged(u8) = .empty,
-/// Version symtab contains version strings of the symbols if present.
-versyms: std.ArrayListUnmanaged(elf.Elf64_Versym) = .empty,
-verstrings: std.ArrayListUnmanaged(u32) = .empty,
+symbols: std.ArrayListUnmanaged(Symbol),
+symbols_extra: std.ArrayListUnmanaged(u32),
+symbols_resolver: std.ArrayListUnmanaged(Elf.SymbolResolver.Index),
 
-symbols: std.ArrayListUnmanaged(Symbol) = .empty,
-symbols_extra: std.ArrayListUnmanaged(u32) = .empty,
-symbols_resolver: std.ArrayListUnmanaged(Elf.SymbolResolver.Index) = .empty,
-
-aliases: ?std.ArrayListUnmanaged(u32) = null,
-dynamic_table: std.ArrayListUnmanaged(elf.Elf64_Dyn) = .empty,
+aliases: ?std.ArrayListUnmanaged(u32),
 
 needed: bool,
 alive: bool,
 
-output_symtab_ctx: Elf.SymtabCtx = .{},
-
-pub fn isSharedObject(path: Path) !bool {
-    const file = try path.root_dir.handle.openFile(path.sub_path, .{});
-    defer file.close();
-    const reader = file.reader();
-    const header = reader.readStruct(elf.Elf64_Ehdr) catch return false;
-    if (!mem.eql(u8, header.e_ident[0..4], "\x7fELF")) return false;
-    if (header.e_ident[elf.EI_VERSION] != 1) return false;
-    if (header.e_type != elf.ET.DYN) return false;
-    return true;
-}
+output_symtab_ctx: Elf.SymtabCtx,
 
-pub fn deinit(self: *SharedObject, allocator: Allocator) void {
-    allocator.free(self.path.sub_path);
-    self.shdrs.deinit(allocator);
-    self.symtab.deinit(allocator);
-    self.strtab.deinit(allocator);
-    self.versyms.deinit(allocator);
-    self.verstrings.deinit(allocator);
-    self.symbols.deinit(allocator);
-    self.symbols_extra.deinit(allocator);
-    self.symbols_resolver.deinit(allocator);
-    if (self.aliases) |*aliases| aliases.deinit(allocator);
-    self.dynamic_table.deinit(allocator);
+pub fn deinit(so: *SharedObject, gpa: Allocator) void {
+    gpa.free(so.path.sub_path);
+    so.parsed.deinit(gpa);
+    so.symbols.deinit(gpa);
+    so.symbols_extra.deinit(gpa);
+    so.symbols_resolver.deinit(gpa);
+    if (so.aliases) |*aliases| aliases.deinit(gpa);
+    so.* = undefined;
 }
 
-pub fn parse(self: *SharedObject, elf_file: *Elf, handle: std.fs.File) !void {
-    const comp = elf_file.base.comp;
-    const gpa = comp.gpa;
-    const file_size = (try handle.stat()).size;
+pub const Header = struct {
+    dynamic_table: []const elf.Elf64_Dyn,
+    soname_index: ?u32,
+    verdefnum: ?u32,
 
-    const header_buffer = try Elf.preadAllAlloc(gpa, handle, 0, @sizeOf(elf.Elf64_Ehdr));
-    defer gpa.free(header_buffer);
-    self.header = @as(*align(1) const elf.Elf64_Ehdr, @ptrCast(header_buffer)).*;
+    sections: []const elf.Elf64_Shdr,
+    dynsym_sect_index: ?u32,
+    versym_sect_index: ?u32,
+    verdef_sect_index: ?u32,
 
-    const em = elf_file.base.comp.root_mod.resolved_target.result.toElfMachine();
-    if (em != self.header.?.e_machine) {
-        return elf_file.failFile(self.index, "invalid ELF machine type: {s}", .{
-            @tagName(self.header.?.e_machine),
-        });
+    stat: Stat,
+    strtab: std.ArrayListUnmanaged(u8),
+
+    pub fn deinit(header: *Header, gpa: Allocator) void {
+        gpa.free(header.sections);
+        gpa.free(header.dynamic_table);
+        header.strtab.deinit(gpa);
+        header.* = undefined;
+    }
+
+    pub fn soname(header: Header) ?[]const u8 {
+        const i = header.soname_index orelse return null;
+        return Elf.stringTableLookup(header.strtab.items, i);
+    }
+};
+
+pub const Parsed = struct {
+    stat: Stat,
+    strtab: []const u8,
+    soname_index: ?u32,
+    sections: []const elf.Elf64_Shdr,
+
+    /// Nonlocal symbols only.
+    symtab: []const elf.Elf64_Sym,
+    /// Version symtab contains version strings of the symbols if present.
+    /// Nonlocal symbols only.
+    versyms: []const elf.Versym,
+    /// Nonlocal symbols only.
+    symbols: []const Parsed.Symbol,
+
+    verstrings: []const u32,
+
+    const Symbol = struct {
+        mangled_name: u32,
+    };
+
+    pub fn deinit(p: *Parsed, gpa: Allocator) void {
+        gpa.free(p.strtab);
+        gpa.free(p.symtab);
+        gpa.free(p.versyms);
+        gpa.free(p.symbols);
+        gpa.free(p.verstrings);
+        p.* = undefined;
+    }
+
+    pub fn versionString(p: Parsed, index: elf.Versym) [:0]const u8 {
+        return versionStringLookup(p.strtab, p.verstrings, index);
     }
 
-    const shoff = std.math.cast(usize, self.header.?.e_shoff) orelse return error.Overflow;
-    const shnum = std.math.cast(usize, self.header.?.e_shnum) orelse return error.Overflow;
-    const shsize = shnum * @sizeOf(elf.Elf64_Shdr);
-    if (file_size < shoff or file_size < shoff + shsize) {
-        return elf_file.failFile(self.index, "corrupted header: section header table extends past the end of file", .{});
+    pub fn soname(p: Parsed) ?[]const u8 {
+        const i = p.soname_index orelse return null;
+        return Elf.stringTableLookup(p.strtab, i);
     }
+};
 
-    const shdrs_buffer = try Elf.preadAllAlloc(gpa, handle, shoff, shsize);
-    defer gpa.free(shdrs_buffer);
-    const shdrs = @as([*]align(1) const elf.Elf64_Shdr, @ptrCast(shdrs_buffer.ptr))[0..shnum];
-    try self.shdrs.appendUnalignedSlice(gpa, shdrs);
+pub fn parseHeader(
+    gpa: Allocator,
+    diags: *Diags,
+    file_path: Path,
+    fs_file: std.fs.File,
+    stat: Stat,
+    target: std.Target,
+) !Header {
+    var ehdr: elf.Elf64_Ehdr = undefined;
+    {
+        const buf = mem.asBytes(&ehdr);
+        const amt = try fs_file.preadAll(buf, 0);
+        if (amt != buf.len) return error.UnexpectedEndOfFile;
+    }
+    if (!mem.eql(u8, ehdr.e_ident[0..4], "\x7fELF")) return error.BadMagic;
+    if (ehdr.e_ident[elf.EI_VERSION] != 1) return error.BadElfVersion;
+    if (ehdr.e_type != elf.ET.DYN) return error.NotSharedObject;
+
+    if (target.toElfMachine() != ehdr.e_machine)
+        return diags.failParse(file_path, "invalid ELF machine type: {s}", .{@tagName(ehdr.e_machine)});
+
+    const shoff = std.math.cast(usize, ehdr.e_shoff) orelse return error.Overflow;
+    const shnum = std.math.cast(u32, ehdr.e_shnum) orelse return error.Overflow;
+
+    const sections = try gpa.alloc(elf.Elf64_Shdr, shnum);
+    errdefer gpa.free(sections);
+    {
+        const buf = mem.sliceAsBytes(sections);
+        const amt = try fs_file.preadAll(buf, shoff);
+        if (amt != buf.len) return error.UnexpectedEndOfFile;
+    }
 
     var dynsym_sect_index: ?u32 = null;
     var dynamic_sect_index: ?u32 = null;
     var versym_sect_index: ?u32 = null;
     var verdef_sect_index: ?u32 = null;
-    for (self.shdrs.items, 0..) |shdr, i| {
-        if (shdr.sh_type != elf.SHT_NOBITS) {
-            if (file_size < shdr.sh_offset or file_size < shdr.sh_offset + shdr.sh_size) {
-                return elf_file.failFile(self.index, "corrupted section header", .{});
-            }
-        }
+    for (sections, 0..) |shdr, i_usize| {
+        const i: u32 = @intCast(i_usize);
         switch (shdr.sh_type) {
-            elf.SHT_DYNSYM => dynsym_sect_index = @intCast(i),
-            elf.SHT_DYNAMIC => dynamic_sect_index = @intCast(i),
-            elf.SHT_GNU_VERSYM => versym_sect_index = @intCast(i),
-            elf.SHT_GNU_VERDEF => verdef_sect_index = @intCast(i),
-            else => {},
+            elf.SHT_DYNSYM => dynsym_sect_index = i,
+            elf.SHT_DYNAMIC => dynamic_sect_index = i,
+            elf.SHT_GNU_VERSYM => versym_sect_index = i,
+            elf.SHT_GNU_VERDEF => verdef_sect_index = i,
+            else => continue,
         }
     }
 
-    if (dynamic_sect_index) |index| {
-        const shdr = self.shdrs.items[index];
-        const raw = try Elf.preadAllAlloc(gpa, handle, shdr.sh_offset, shdr.sh_size);
-        defer gpa.free(raw);
-        const num = @divExact(raw.len, @sizeOf(elf.Elf64_Dyn));
-        const dyntab = @as([*]align(1) const elf.Elf64_Dyn, @ptrCast(raw.ptr))[0..num];
-        try self.dynamic_table.appendUnalignedSlice(gpa, dyntab);
+    const dynamic_table: []elf.Elf64_Dyn = if (dynamic_sect_index) |index| dt: {
+        const shdr = sections[index];
+        const n = std.math.cast(usize, shdr.sh_size / @sizeOf(elf.Elf64_Dyn)) orelse return error.Overflow;
+        const dynamic_table = try gpa.alloc(elf.Elf64_Dyn, n);
+        errdefer gpa.free(dynamic_table);
+        const buf = mem.sliceAsBytes(dynamic_table);
+        const amt = try fs_file.preadAll(buf, shdr.sh_offset);
+        if (amt != buf.len) return error.UnexpectedEndOfFile;
+        break :dt dynamic_table;
+    } else &.{};
+    errdefer gpa.free(dynamic_table);
+
+    var strtab: std.ArrayListUnmanaged(u8) = .empty;
+    errdefer strtab.deinit(gpa);
+
+    if (dynsym_sect_index) |index| {
+        const dynsym_shdr = sections[index];
+        if (dynsym_shdr.sh_link >= sections.len) return error.BadStringTableIndex;
+        const strtab_shdr = sections[dynsym_shdr.sh_link];
+        const n = std.math.cast(usize, strtab_shdr.sh_size) orelse return error.Overflow;
+        const buf = try strtab.addManyAsSlice(gpa, n);
+        const amt = try fs_file.preadAll(buf, strtab_shdr.sh_offset);
+        if (amt != buf.len) return error.UnexpectedEndOfFile;
     }
 
-    const symtab = if (dynsym_sect_index) |index| blk: {
-        const shdr = self.shdrs.items[index];
-        const buffer = try Elf.preadAllAlloc(gpa, handle, shdr.sh_offset, shdr.sh_size);
-        const nsyms = @divExact(buffer.len, @sizeOf(elf.Elf64_Sym));
-        break :blk @as([*]align(1) const elf.Elf64_Sym, @ptrCast(buffer.ptr))[0..nsyms];
-    } else &[0]elf.Elf64_Sym{};
-    defer gpa.free(symtab);
-
-    const strtab = if (dynsym_sect_index) |index| blk: {
-        const symtab_shdr = self.shdrs.items[index];
-        const shdr = self.shdrs.items[symtab_shdr.sh_link];
-        const buffer = try Elf.preadAllAlloc(gpa, handle, shdr.sh_offset, shdr.sh_size);
-        break :blk buffer;
-    } else &[0]u8{};
-    defer gpa.free(strtab);
+    var soname_index: ?u32 = null;
+    var verdefnum: ?u32 = null;
+    for (dynamic_table) |entry| switch (entry.d_tag) {
+        elf.DT_SONAME => {
+            if (entry.d_val >= strtab.items.len) return error.BadSonameIndex;
+            soname_index = @intCast(entry.d_val);
+        },
+        elf.DT_VERDEFNUM => {
+            verdefnum = @intCast(entry.d_val);
+        },
+        else => continue,
+    };
 
-    try self.parseVersions(elf_file, handle, .{
-        .symtab = symtab,
-        .verdef_sect_index = verdef_sect_index,
+    return .{
+        .dynamic_table = dynamic_table,
+        .soname_index = soname_index,
+        .verdefnum = verdefnum,
+        .sections = sections,
+        .dynsym_sect_index = dynsym_sect_index,
         .versym_sect_index = versym_sect_index,
-    });
-
-    try self.initSymbols(elf_file, .{
-        .symtab = symtab,
+        .verdef_sect_index = verdef_sect_index,
         .strtab = strtab,
-    });
+        .stat = stat,
+    };
 }
 
-fn parseVersions(self: *SharedObject, elf_file: *Elf, handle: std.fs.File, opts: struct {
-    symtab: []align(1) const elf.Elf64_Sym,
-    verdef_sect_index: ?u32,
-    versym_sect_index: ?u32,
-}) !void {
-    const comp = elf_file.base.comp;
-    const gpa = comp.gpa;
+pub fn parse(
+    gpa: Allocator,
+    /// Moves resources from header. Caller may unconditionally deinit.
+    header: *Header,
+    fs_file: std.fs.File,
+) !Parsed {
+    const symtab = if (header.dynsym_sect_index) |index| st: {
+        const shdr = header.sections[index];
+        const n = std.math.cast(usize, shdr.sh_size / @sizeOf(elf.Elf64_Sym)) orelse return error.Overflow;
+        const symtab = try gpa.alloc(elf.Elf64_Sym, n);
+        errdefer gpa.free(symtab);
+        const buf = mem.sliceAsBytes(symtab);
+        const amt = try fs_file.preadAll(buf, shdr.sh_offset);
+        if (amt != buf.len) return error.UnexpectedEndOfFile;
+        break :st symtab;
+    } else &.{};
+    defer gpa.free(symtab);
 
-    try self.verstrings.resize(gpa, 2);
-    self.verstrings.items[elf.VER_NDX_LOCAL] = 0;
-    self.verstrings.items[elf.VER_NDX_GLOBAL] = 0;
+    var verstrings: std.ArrayListUnmanaged(u32) = .empty;
+    defer verstrings.deinit(gpa);
 
-    if (opts.verdef_sect_index) |shndx| {
-        const shdr = self.shdrs.items[shndx];
-        const verdefs = try Elf.preadAllAlloc(gpa, handle, shdr.sh_offset, shdr.sh_size);
+    if (header.verdef_sect_index) |shndx| {
+        const shdr = header.sections[shndx];
+        const verdefs = try Elf.preadAllAlloc(gpa, fs_file, shdr.sh_offset, shdr.sh_size);
         defer gpa.free(verdefs);
-        const nverdefs = self.verdefNum();
-        try self.verstrings.resize(gpa, self.verstrings.items.len + nverdefs);
 
-        var i: u32 = 0;
         var offset: u32 = 0;
-        while (i < nverdefs) : (i += 1) {
-            const verdef = @as(*align(1) const elf.Elf64_Verdef, @ptrCast(verdefs.ptr + offset)).*;
-            defer offset += verdef.vd_next;
-            if (verdef.vd_flags == elf.VER_FLG_BASE) continue; // Skip BASE entry
-            const vda_name = if (verdef.vd_cnt > 0)
-                @as(*align(1) const elf.Elf64_Verdaux, @ptrCast(verdefs.ptr + offset + verdef.vd_aux)).vda_name
-            else
-                0;
-            self.verstrings.items[verdef.vd_ndx] = vda_name;
-        }
-    }
+        while (true) {
+            const verdef = mem.bytesAsValue(elf.Verdef, verdefs[offset..][0..@sizeOf(elf.Verdef)]);
+            if (verdef.ndx == .UNSPECIFIED) return error.VerDefSymbolTooLarge;
+
+            if (verstrings.items.len <= @intFromEnum(verdef.ndx))
+                try verstrings.appendNTimes(gpa, 0, @intFromEnum(verdef.ndx) + 1 - verstrings.items.len);
 
-    try self.versyms.ensureTotalCapacityPrecise(gpa, opts.symtab.len);
-
-    if (opts.versym_sect_index) |shndx| {
-        const shdr = self.shdrs.items[shndx];
-        const versyms_raw = try Elf.preadAllAlloc(gpa, handle, shdr.sh_offset, shdr.sh_size);
-        defer gpa.free(versyms_raw);
-        const nversyms = @divExact(versyms_raw.len, @sizeOf(elf.Elf64_Versym));
-        const versyms = @as([*]align(1) const elf.Elf64_Versym, @ptrCast(versyms_raw.ptr))[0..nversyms];
-        for (versyms) |ver| {
-            const normalized_ver = if (ver & elf.VERSYM_VERSION >= self.verstrings.items.len - 1)
-                elf.VER_NDX_GLOBAL
-            else
-                ver;
-            self.versyms.appendAssumeCapacity(normalized_ver);
+            const aux = mem.bytesAsValue(elf.Verdaux, verdefs[offset + verdef.aux ..][0..@sizeOf(elf.Verdaux)]);
+            verstrings.items[@intFromEnum(verdef.ndx)] = aux.name;
+
+            if (verdef.next == 0) break;
+            offset += verdef.next;
         }
-    } else for (0..opts.symtab.len) |_| {
-        self.versyms.appendAssumeCapacity(elf.VER_NDX_GLOBAL);
     }
-}
 
-fn initSymbols(self: *SharedObject, elf_file: *Elf, opts: struct {
-    symtab: []align(1) const elf.Elf64_Sym,
-    strtab: []const u8,
-}) !void {
-    const gpa = elf_file.base.comp.gpa;
-    const nsyms = opts.symtab.len;
-
-    try self.strtab.appendSlice(gpa, opts.strtab);
-    try self.symtab.ensureTotalCapacityPrecise(gpa, nsyms);
-    try self.symbols.ensureTotalCapacityPrecise(gpa, nsyms);
-    try self.symbols_extra.ensureTotalCapacityPrecise(gpa, nsyms * @sizeOf(Symbol.Extra));
-    try self.symbols_resolver.ensureTotalCapacityPrecise(gpa, nsyms);
-    self.symbols_resolver.resize(gpa, nsyms) catch unreachable;
-    @memset(self.symbols_resolver.items, 0);
-
-    for (opts.symtab, 0..) |sym, i| {
-        const hidden = self.versyms.items[i] & elf.VERSYM_HIDDEN != 0;
-        const name = self.getString(sym.st_name);
-        // We need to garble up the name so that we don't pick this symbol
-        // during symbol resolution. Thank you GNU!
-        const name_off = if (hidden) blk: {
-            const mangled = try std.fmt.allocPrint(gpa, "{s}@{s}", .{
-                name,
-                self.versionString(self.versyms.items[i]),
-            });
-            defer gpa.free(mangled);
-            break :blk try self.addString(gpa, mangled);
-        } else sym.st_name;
-        const out_esym_index: u32 = @intCast(self.symtab.items.len);
-        const out_esym = self.symtab.addOneAssumeCapacity();
-        out_esym.* = sym;
-        out_esym.st_name = name_off;
-        const out_sym_index = self.addSymbolAssumeCapacity();
-        const out_sym = &self.symbols.items[out_sym_index];
-        out_sym.value = @intCast(out_esym.st_value);
-        out_sym.name_offset = name_off;
-        out_sym.ref = .{ .index = 0, .file = 0 };
-        out_sym.esym_index = out_esym_index;
-        out_sym.version_index = self.versyms.items[out_esym_index];
-        out_sym.extra_index = self.addSymbolExtraAssumeCapacity(.{});
+    const versyms = if (header.versym_sect_index) |versym_sect_index| vs: {
+        const shdr = header.sections[versym_sect_index];
+        if (shdr.sh_size != symtab.len * @sizeOf(elf.Versym)) return error.BadVerSymSectionSize;
+
+        const versyms = try gpa.alloc(elf.Versym, symtab.len);
+        errdefer gpa.free(versyms);
+        const buf = mem.sliceAsBytes(versyms);
+        const amt = try fs_file.preadAll(buf, shdr.sh_offset);
+        if (amt != buf.len) return error.UnexpectedEndOfFile;
+        break :vs versyms;
+    } else &.{};
+    defer gpa.free(versyms);
+
+    var nonlocal_esyms: std.ArrayListUnmanaged(elf.Elf64_Sym) = .empty;
+    defer nonlocal_esyms.deinit(gpa);
+
+    var nonlocal_versyms: std.ArrayListUnmanaged(elf.Versym) = .empty;
+    defer nonlocal_versyms.deinit(gpa);
+
+    var nonlocal_symbols: std.ArrayListUnmanaged(Parsed.Symbol) = .empty;
+    defer nonlocal_symbols.deinit(gpa);
+
+    var strtab = header.strtab;
+    header.strtab = .empty;
+    defer strtab.deinit(gpa);
+
+    for (symtab, 0..) |sym, i| {
+        const ver: elf.Versym = if (versyms.len == 0 or sym.st_shndx == elf.SHN_UNDEF)
+            .GLOBAL
+        else
+            .{ .VERSION = versyms[i].VERSION, .HIDDEN = false };
+
+        // https://github.com/ziglang/zig/issues/21678
+        //if (ver == .LOCAL) continue;
+        if (@as(u16, @bitCast(ver)) == 0) continue;
+
+        try nonlocal_esyms.ensureUnusedCapacity(gpa, 1);
+        try nonlocal_versyms.ensureUnusedCapacity(gpa, 1);
+        try nonlocal_symbols.ensureUnusedCapacity(gpa, 1);
+
+        const name = Elf.stringTableLookup(strtab.items, sym.st_name);
+        const is_default = versyms.len == 0 or !versyms[i].HIDDEN;
+        const mangled_name = if (is_default) sym.st_name else mn: {
+            const off: u32 = @intCast(strtab.items.len);
+            const version_string = versionStringLookup(strtab.items, verstrings.items, versyms[i]);
+            try strtab.ensureUnusedCapacity(gpa, name.len + version_string.len + 2);
+            // Reload since the string table might have been resized.
+            const name2 = Elf.stringTableLookup(strtab.items, sym.st_name);
+            const version_string2 = versionStringLookup(strtab.items, verstrings.items, versyms[i]);
+            strtab.appendSliceAssumeCapacity(name2);
+            strtab.appendAssumeCapacity('@');
+            strtab.appendSliceAssumeCapacity(version_string2);
+            strtab.appendAssumeCapacity(0);
+            break :mn off;
+        };
+
+        nonlocal_esyms.appendAssumeCapacity(sym);
+        nonlocal_versyms.appendAssumeCapacity(ver);
+        nonlocal_symbols.appendAssumeCapacity(.{
+            .mangled_name = mangled_name,
+        });
     }
+
+    const sections = header.sections;
+    header.sections = &.{};
+    errdefer gpa.free(sections);
+
+    return .{
+        .sections = sections,
+        .stat = header.stat,
+        .soname_index = header.soname_index,
+        .strtab = try strtab.toOwnedSlice(gpa),
+        .symtab = try nonlocal_esyms.toOwnedSlice(gpa),
+        .versyms = try nonlocal_versyms.toOwnedSlice(gpa),
+        .symbols = try nonlocal_symbols.toOwnedSlice(gpa),
+        .verstrings = try verstrings.toOwnedSlice(gpa),
+    };
 }
 
 pub fn resolveSymbols(self: *SharedObject, elf_file: *Elf) !void {
     const gpa = elf_file.base.comp.gpa;
 
-    for (self.symtab.items, self.symbols_resolver.items, 0..) |esym, *resolv, i| {
+    for (self.parsed.symtab, self.symbols_resolver.items, 0..) |esym, *resolv, i| {
         const gop = try elf_file.resolver.getOrPut(gpa, .{
             .index = @intCast(i),
             .file = self.index,
@@ -253,7 +334,7 @@ pub fn resolveSymbols(self: *SharedObject, elf_file: *Elf) !void {
 }
 
 pub fn markLive(self: *SharedObject, elf_file: *Elf) void {
-    for (self.symtab.items, 0..) |esym, i| {
+    for (self.parsed.symtab, 0..) |esym, i| {
         if (esym.st_shndx != elf.SHN_UNDEF) continue;
 
         const ref = self.resolveSymbol(@intCast(i), elf_file);
@@ -308,29 +389,21 @@ pub fn writeSymtab(self: *SharedObject, elf_file: *Elf) void {
     }
 }
 
-pub fn versionString(self: SharedObject, index: elf.Elf64_Versym) [:0]const u8 {
-    const off = self.verstrings.items[index & elf.VERSYM_VERSION];
-    return self.getString(off);
+pub fn versionString(self: SharedObject, index: elf.Versym) [:0]const u8 {
+    return self.parsed.versionString(index);
 }
 
-pub fn asFile(self: *SharedObject) File {
-    return .{ .shared_object = self };
+fn versionStringLookup(strtab: []const u8, verstrings: []const u32, index: elf.Versym) [:0]const u8 {
+    const off = verstrings[index.VERSION];
+    return Elf.stringTableLookup(strtab, off);
 }
 
-fn verdefNum(self: *SharedObject) u32 {
-    for (self.dynamic_table.items) |entry| switch (entry.d_tag) {
-        elf.DT_VERDEFNUM => return @intCast(entry.d_val),
-        else => {},
-    };
-    return 0;
+pub fn asFile(self: *SharedObject) File {
+    return .{ .shared_object = self };
 }
 
 pub fn soname(self: *SharedObject) []const u8 {
-    for (self.dynamic_table.items) |entry| switch (entry.d_tag) {
-        elf.DT_SONAME => return self.getString(@intCast(entry.d_val)),
-        else => {},
-    };
-    return std.fs.path.basename(self.path.sub_path);
+    return self.parsed.soname() orelse self.path.basename();
 }
 
 pub fn initSymbolAliases(self: *SharedObject, elf_file: *Elf) !void {
@@ -360,7 +433,7 @@ pub fn initSymbolAliases(self: *SharedObject, elf_file: *Elf) !void {
         aliases.appendAssumeCapacity(@intCast(index));
     }
 
-    std.mem.sort(u32, aliases.items, SortAlias{ .so = self, .ef = elf_file }, SortAlias.lessThan);
+    mem.sort(u32, aliases.items, SortAlias{ .so = self, .ef = elf_file }, SortAlias.lessThan);
 
     self.aliases = aliases.moveToUnmanaged();
 }
@@ -384,17 +457,8 @@ pub fn symbolAliases(self: *SharedObject, index: u32, elf_file: *Elf) []const u3
     return aliases.items[start..end];
 }
 
-fn addString(self: *SharedObject, allocator: Allocator, str: []const u8) !u32 {
-    const off: u32 = @intCast(self.strtab.items.len);
-    try self.strtab.ensureUnusedCapacity(allocator, str.len + 1);
-    self.strtab.appendSliceAssumeCapacity(str);
-    self.strtab.appendAssumeCapacity(0);
-    return off;
-}
-
 pub fn getString(self: SharedObject, off: u32) [:0]const u8 {
-    assert(off < self.strtab.items.len);
-    return mem.sliceTo(@as([*:0]const u8, @ptrCast(self.strtab.items.ptr + off)), 0);
+    return Elf.stringTableLookup(self.parsed.strtab, off);
 }
 
 pub fn resolveSymbol(self: SharedObject, index: Symbol.Index, elf_file: *Elf) Elf.Ref {
@@ -402,25 +466,14 @@ pub fn resolveSymbol(self: SharedObject, index: Symbol.Index, elf_file: *Elf) El
     return elf_file.resolver.get(resolv).?;
 }
 
-fn addSymbol(self: *SharedObject, allocator: Allocator) !Symbol.Index {
-    try self.symbols.ensureUnusedCapacity(allocator, 1);
-    return self.addSymbolAssumeCapacity();
-}
-
-fn addSymbolAssumeCapacity(self: *SharedObject) Symbol.Index {
+pub fn addSymbolAssumeCapacity(self: *SharedObject) Symbol.Index {
     const index: Symbol.Index = @intCast(self.symbols.items.len);
     self.symbols.appendAssumeCapacity(.{ .file_index = self.index });
     return index;
 }
 
-pub fn addSymbolExtra(self: *SharedObject, allocator: Allocator, extra: Symbol.Extra) !u32 {
-    const fields = @typeInfo(Symbol.Extra).@"struct".fields;
-    try self.symbols_extra.ensureUnusedCapacity(allocator, fields.len);
-    return self.addSymbolExtraAssumeCapacity(extra);
-}
-
 pub fn addSymbolExtraAssumeCapacity(self: *SharedObject, extra: Symbol.Extra) u32 {
-    const index = @as(u32, @intCast(self.symbols_extra.items.len));
+    const index: u32 = @intCast(self.symbols_extra.items.len);
     const fields = @typeInfo(Symbol.Extra).@"struct".fields;
     inline for (fields) |field| {
         self.symbols_extra.appendAssumeCapacity(switch (field.type) {
@@ -465,7 +518,7 @@ pub fn format(
     _ = unused_fmt_string;
     _ = options;
     _ = writer;
-    @compileError("do not format shared objects directly");
+    @compileError("unreachable");
 }
 
 pub fn fmtSymtab(self: SharedObject, elf_file: *Elf) std.fmt.Formatter(formatSymtab) {
@@ -509,8 +562,10 @@ const elf = std.elf;
 const log = std.log.scoped(.elf);
 const mem = std.mem;
 const Path = std.Build.Cache.Path;
-
+const Stat = std.Build.Cache.File.Stat;
 const Allocator = mem.Allocator;
+
 const Elf = @import("../Elf.zig");
 const File = @import("file.zig").File;
 const Symbol = @import("Symbol.zig");
+const Diags = @import("../../link.zig").Diags;
diff --git a/zig/src/link/Elf/Symbol.zig b/zig/src/link/Elf/Symbol.zig
index 6eaaedf28c..31584ca406 100644
--- a/zig/src/link/Elf/Symbol.zig
+++ b/zig/src/link/Elf/Symbol.zig
@@ -22,7 +22,7 @@ esym_index: Index = 0,
 
 /// Index of the source version symbol this symbol references if any.
 /// If the symbol is unversioned it will have either VER_NDX_LOCAL or VER_NDX_GLOBAL.
-version_index: elf.Elf64_Versym = elf.VER_NDX_LOCAL,
+version_index: elf.Versym = .LOCAL,
 
 /// Misc flags for the symbol packaged as packed struct for compression.
 flags: Flags = .{},
@@ -74,7 +74,7 @@ pub fn atom(symbol: Symbol, elf_file: *Elf) ?*Atom {
     return file_ptr.atom(symbol.ref.index);
 }
 
-pub fn mergeSubsection(symbol: Symbol, elf_file: *Elf) ?*MergeSubsection {
+pub fn mergeSubsection(symbol: Symbol, elf_file: *Elf) ?*Merge.Subsection {
     if (!symbol.flags.merge_subsection) return null;
     const msec = elf_file.mergeSection(symbol.ref.file);
     return msec.mergeSubsection(symbol.ref.index);
@@ -87,6 +87,7 @@ pub fn file(symbol: Symbol, elf_file: *Elf) ?File {
 pub fn elfSym(symbol: Symbol, elf_file: *Elf) elf.Elf64_Sym {
     return switch (symbol.file(elf_file).?) {
         .zig_object => |x| x.symtab.items(.elf_sym)[symbol.esym_index],
+        .shared_object => |so| so.parsed.symtab[symbol.esym_index],
         inline else => |x| x.symtab.items[symbol.esym_index],
     };
 }
@@ -128,7 +129,7 @@ pub fn address(symbol: Symbol, opts: struct { plt: bool = true, trampoline: bool
             if (mem.eql(u8, atom_ptr.name(elf_file), ".eh_frame")) {
                 const sym_name = symbol.name(elf_file);
                 const sh_addr, const sh_size = blk: {
-                    const shndx = elf_file.eh_frame_section_index orelse break :blk .{ 0, 0 };
+                    const shndx = elf_file.section_indexes.eh_frame orelse break :blk .{ 0, 0 };
                     const shdr = elf_file.sections.items(.shdr)[shndx];
                     break :blk .{ shdr.sh_addr, shdr.sh_size };
                 };
@@ -176,7 +177,7 @@ pub fn gotAddress(symbol: Symbol, elf_file: *Elf) i64 {
 pub fn pltGotAddress(symbol: Symbol, elf_file: *Elf) i64 {
     if (!symbol.flags.has_pltgot) return 0;
     const extras = symbol.extra(elf_file);
-    const shdr = elf_file.sections.items(.shdr)[elf_file.plt_got_section_index.?];
+    const shdr = elf_file.sections.items(.shdr)[elf_file.section_indexes.plt_got.?];
     const cpu_arch = elf_file.getTarget().cpu.arch;
     return @intCast(shdr.sh_addr + extras.plt_got * PltGotSection.entrySize(cpu_arch));
 }
@@ -184,7 +185,7 @@ pub fn pltGotAddress(symbol: Symbol, elf_file: *Elf) i64 {
 pub fn pltAddress(symbol: Symbol, elf_file: *Elf) i64 {
     if (!symbol.flags.has_plt) return 0;
     const extras = symbol.extra(elf_file);
-    const shdr = elf_file.sections.items(.shdr)[elf_file.plt_section_index.?];
+    const shdr = elf_file.sections.items(.shdr)[elf_file.section_indexes.plt.?];
     const cpu_arch = elf_file.getTarget().cpu.arch;
     return @intCast(shdr.sh_addr + extras.plt * PltSection.entrySize(cpu_arch) + PltSection.preambleSize(cpu_arch));
 }
@@ -192,13 +193,13 @@ pub fn pltAddress(symbol: Symbol, elf_file: *Elf) i64 {
 pub fn gotPltAddress(symbol: Symbol, elf_file: *Elf) i64 {
     if (!symbol.flags.has_plt) return 0;
     const extras = symbol.extra(elf_file);
-    const shdr = elf_file.sections.items(.shdr)[elf_file.got_plt_section_index.?];
+    const shdr = elf_file.sections.items(.shdr)[elf_file.section_indexes.got_plt.?];
     return @intCast(shdr.sh_addr + extras.plt * 8 + GotPltSection.preamble_size);
 }
 
 pub fn copyRelAddress(symbol: Symbol, elf_file: *Elf) i64 {
     if (!symbol.flags.has_copy_rel) return 0;
-    const shdr = elf_file.sections.items(.shdr)[elf_file.copy_rel_section_index.?];
+    const shdr = elf_file.sections.items(.shdr)[elf_file.section_indexes.copy_rel.?];
     return @as(i64, @intCast(shdr.sh_addr)) + symbol.value;
 }
 
@@ -235,7 +236,7 @@ pub fn dsoAlignment(symbol: Symbol, elf_file: *Elf) !u64 {
     assert(file_ptr == .shared_object);
     const shared_object = file_ptr.shared_object;
     const esym = symbol.elfSym(elf_file);
-    const shdr = shared_object.shdrs.items[esym.st_shndx];
+    const shdr = shared_object.parsed.sections[esym.st_shndx];
     const alignment = @max(1, shdr.sh_addralign);
     return if (esym.st_value == 0)
         alignment
@@ -289,7 +290,7 @@ pub fn setOutputSym(symbol: Symbol, elf_file: *Elf, out: *elf.Elf64_Sym) void {
         break :blk esym.st_bind();
     };
     const st_shndx: u16 = blk: {
-        if (symbol.flags.has_copy_rel) break :blk @intCast(elf_file.copy_rel_section_index.?);
+        if (symbol.flags.has_copy_rel) break :blk @intCast(elf_file.section_indexes.copy_rel.?);
         if (file_ptr == .shared_object or esym.st_shndx == elf.SHN_UNDEF) break :blk elf.SHN_UNDEF;
         if (elf_file.base.isRelocatable() and esym.st_shndx == elf.SHN_COMMON) break :blk elf.SHN_COMMON;
         if (symbol.mergeSubsection(elf_file)) |msub| break :blk @intCast(msub.mergeSection(elf_file).output_section_index);
@@ -351,8 +352,8 @@ fn formatName(
     const elf_file = ctx.elf_file;
     const symbol = ctx.symbol;
     try writer.writeAll(symbol.name(elf_file));
-    switch (symbol.version_index & elf.VERSYM_VERSION) {
-        elf.VER_NDX_LOCAL, elf.VER_NDX_GLOBAL => {},
+    switch (symbol.version_index.VERSION) {
+        @intFromEnum(elf.VER_NDX.LOCAL), @intFromEnum(elf.VER_NDX.GLOBAL) => {},
         else => {
             const file_ptr = symbol.file(elf_file).?;
             assert(file_ptr == .shared_object);
@@ -493,7 +494,7 @@ const File = @import("file.zig").File;
 const GotSection = synthetic_sections.GotSection;
 const GotPltSection = synthetic_sections.GotPltSection;
 const LinkerDefined = @import("LinkerDefined.zig");
-const MergeSubsection = @import("merge_section.zig").MergeSubsection;
+const Merge = @import("Merge.zig");
 const Object = @import("Object.zig");
 const PltSection = synthetic_sections.PltSection;
 const PltGotSection = synthetic_sections.PltGotSection;
diff --git a/zig/src/link/Elf/ZigObject.zig b/zig/src/link/Elf/ZigObject.zig
index 54d15297d5..84b54aabcd 100644
--- a/zig/src/link/Elf/ZigObject.zig
+++ b/zig/src/link/Elf/ZigObject.zig
@@ -264,7 +264,7 @@ pub fn deinit(self: *ZigObject, allocator: Allocator) void {
     }
 }
 
-pub fn flushModule(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !void {
+pub fn flush(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !void {
     // Handle any lazy symbols that were emitted by incremental compilation.
     if (self.lazy_syms.getPtr(.anyerror_type)) |metadata| {
         const pt: Zcu.PerThread = .{ .zcu = elf_file.base.comp.zcu.?, .tid = tid };
@@ -623,7 +623,7 @@ pub fn claimUnresolved(self: *ZigObject, elf_file: *Elf) void {
         global.ref = .{ .index = 0, .file = 0 };
         global.esym_index = @intCast(index);
         global.file_index = self.index;
-        global.version_index = if (is_import) elf.VER_NDX_LOCAL else elf_file.default_sym_version;
+        global.version_index = if (is_import) .LOCAL else elf_file.default_sym_version;
         global.flags.import = is_import;
 
         const idx = self.symbols_resolver.items[i];
@@ -689,8 +689,9 @@ pub fn markImportsExports(self: *ZigObject, elf_file: *Elf) void {
         const ref = self.resolveSymbol(@intCast(i | global_symbol_bit), elf_file);
         const sym = elf_file.symbol(ref) orelse continue;
         const file = sym.file(elf_file).?;
-        if (sym.version_index == elf.VER_NDX_LOCAL) continue;
-        const vis = @as(elf.STV, @enumFromInt(sym.elfSym(elf_file).st_other));
+        // https://github.com/ziglang/zig/issues/21678
+        if (@as(u16, @bitCast(sym.version_index)) == @as(u16, @bitCast(elf.Versym.LOCAL))) continue;
+        const vis: elf.STV = @enumFromInt(sym.elfSym(elf_file).st_other);
         if (vis == .HIDDEN) continue;
         if (file == .shared_object and !sym.isAbs(elf_file)) {
             sym.flags.import = true;
@@ -791,7 +792,7 @@ pub fn initRelaSections(self: *ZigObject, elf_file: *Elf) !void {
     for (self.atoms_indexes.items) |atom_index| {
         const atom_ptr = self.atom(atom_index) orelse continue;
         if (!atom_ptr.alive) continue;
-        if (atom_ptr.output_section_index == elf_file.eh_frame_section_index) continue;
+        if (atom_ptr.output_section_index == elf_file.section_indexes.eh_frame) continue;
         const rela_shndx = atom_ptr.relocsShndx() orelse continue;
         // TODO this check will become obsolete when we rework our relocs mechanism at the ZigObject level
         if (self.relocs.items[rela_shndx].items.len == 0) continue;
@@ -812,7 +813,7 @@ pub fn addAtomsToRelaSections(self: *ZigObject, elf_file: *Elf) !void {
     for (self.atoms_indexes.items) |atom_index| {
         const atom_ptr = self.atom(atom_index) orelse continue;
         if (!atom_ptr.alive) continue;
-        if (atom_ptr.output_section_index == elf_file.eh_frame_section_index) continue;
+        if (atom_ptr.output_section_index == elf_file.section_indexes.eh_frame) continue;
         const rela_shndx = atom_ptr.relocsShndx() orelse continue;
         // TODO this check will become obsolete when we rework our relocs mechanism at the ZigObject level
         if (self.relocs.items[rela_shndx].items.len == 0) continue;
@@ -826,7 +827,7 @@ pub fn addAtomsToRelaSections(self: *ZigObject, elf_file: *Elf) !void {
         const out_rela_shndx = elf_file.sectionByName(rela_sect_name).?;
         const out_rela_shdr = &elf_file.sections.items(.shdr)[out_rela_shndx];
         out_rela_shdr.sh_info = out_shndx;
-        out_rela_shdr.sh_link = elf_file.symtab_section_index.?;
+        out_rela_shdr.sh_link = elf_file.section_indexes.symtab.?;
         const atom_list = &elf_file.sections.items(.atom_list)[out_rela_shndx];
         try atom_list.append(gpa, .{ .index = atom_index, .file = self.index });
     }
@@ -927,7 +928,7 @@ pub fn getNavVAddr(
             nav.name.toSlice(ip),
             @"extern".lib_name.toSlice(ip),
         ),
-        else => try self.getOrCreateMetadataForNav(elf_file, nav_index),
+        else => try self.getOrCreateMetadataForNav(zcu, nav_index),
     };
     const this_sym = self.symbol(this_sym_index);
     const vaddr = this_sym.address(.{}, elf_file);
@@ -1101,21 +1102,15 @@ pub fn freeNav(self: *ZigObject, elf_file: *Elf, nav_index: InternPool.Nav.Index
     }
 }
 
-pub fn getOrCreateMetadataForNav(
-    self: *ZigObject,
-    elf_file: *Elf,
-    nav_index: InternPool.Nav.Index,
-) !Symbol.Index {
-    const gpa = elf_file.base.comp.gpa;
+pub fn getOrCreateMetadataForNav(self: *ZigObject, zcu: *Zcu, nav_index: InternPool.Nav.Index) !Symbol.Index {
+    const gpa = zcu.gpa;
     const gop = try self.navs.getOrPut(gpa, nav_index);
     if (!gop.found_existing) {
-        const any_non_single_threaded = elf_file.base.comp.config.any_non_single_threaded;
         const symbol_index = try self.newSymbolWithAtom(gpa, 0);
-        const zcu = elf_file.base.comp.zcu.?;
         const nav_val = Value.fromInterned(zcu.intern_pool.getNav(nav_index).status.resolved.val);
         const sym = self.symbol(symbol_index);
         if (nav_val.getVariable(zcu)) |variable| {
-            if (variable.is_threadlocal and any_non_single_threaded) {
+            if (variable.is_threadlocal and zcu.comp.config.any_non_single_threaded) {
                 sym.flags.is_tls = true;
             }
         }
@@ -1276,9 +1271,11 @@ fn updateNavCode(
 
     log.debug("updateNavCode {}({d})", .{ nav.fqn.fmt(ip), nav_index });
 
-    const required_alignment = pt.navAlignment(nav_index).max(
-        target_util.minFunctionAlignment(zcu.navFileScope(nav_index).mod.resolved_target.result),
-    );
+    const target = zcu.navFileScope(nav_index).mod.resolved_target.result;
+    const required_alignment = switch (pt.navAlignment(nav_index)) {
+        .none => target_util.defaultFunctionAlignment(target),
+        else => |a| a.maxStrict(target_util.minFunctionAlignment(target)),
+    };
 
     const sym = self.symbol(sym_index);
     const esym = &self.symtab.items(.elf_sym)[sym.esym_index];
@@ -1424,8 +1421,8 @@ pub fn updateFunc(
 
     log.debug("updateFunc {}({d})", .{ ip.getNav(func.owner_nav).fqn.fmt(ip), func.owner_nav });
 
-    const sym_index = try self.getOrCreateMetadataForNav(elf_file, func.owner_nav);
-    self.symbol(sym_index).atom(elf_file).?.freeRelocs(self);
+    const sym_index = try self.getOrCreateMetadataForNav(zcu, func.owner_nav);
+    self.atom(self.symbol(sym_index).ref.index).?.freeRelocs(self);
 
     var code_buffer = std.ArrayList(u8).init(gpa);
     defer code_buffer.deinit();
@@ -1459,12 +1456,12 @@ pub fn updateFunc(
         ip.getNav(func.owner_nav).fqn.fmt(ip),
     });
     const old_rva, const old_alignment = blk: {
-        const atom_ptr = self.symbol(sym_index).atom(elf_file).?;
+        const atom_ptr = self.atom(self.symbol(sym_index).ref.index).?;
         break :blk .{ atom_ptr.value, atom_ptr.alignment };
     };
     try self.updateNavCode(elf_file, pt, func.owner_nav, sym_index, shndx, code, elf.STT_FUNC);
     const new_rva, const new_alignment = blk: {
-        const atom_ptr = self.symbol(sym_index).atom(elf_file).?;
+        const atom_ptr = self.atom(self.symbol(sym_index).ref.index).?;
         break :blk .{ atom_ptr.value, atom_ptr.alignment };
     };
 
@@ -1476,7 +1473,7 @@ pub fn updateFunc(
             .{
                 .index = sym_index,
                 .addr = @intCast(sym.address(.{}, elf_file)),
-                .size = sym.atom(elf_file).?.size,
+                .size = self.atom(sym.ref.index).?.size,
             },
             wip_nav,
         );
@@ -1499,7 +1496,7 @@ pub fn updateFunc(
             });
             defer gpa.free(name);
             const osec = if (self.text_index) |sect_sym_index|
-                self.symbol(sect_sym_index).atom(elf_file).?.output_section_index
+                self.atom(self.symbol(sect_sym_index).ref.index).?.output_section_index
             else osec: {
                 const osec = try elf_file.addSection(.{
                     .name = try elf_file.insertShString(".text"),
@@ -1564,7 +1561,7 @@ pub fn updateNav(
     };
 
     if (nav_init != .none and Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(zcu)) {
-        const sym_index = try self.getOrCreateMetadataForNav(elf_file, nav_index);
+        const sym_index = try self.getOrCreateMetadataForNav(zcu, nav_index);
         self.symbol(sym_index).atom(elf_file).?.freeRelocs(self);
 
         var code_buffer = std.ArrayList(u8).init(zcu.gpa);
@@ -1788,7 +1785,7 @@ pub fn updateExports(
     const gpa = elf_file.base.comp.gpa;
     const metadata = switch (exported) {
         .nav => |nav| blk: {
-            _ = try self.getOrCreateMetadataForNav(elf_file, nav);
+            _ = try self.getOrCreateMetadataForNav(zcu, nav);
             break :blk self.navs.getPtr(nav).?;
         },
         .uav => |uav| self.uavs.getPtr(uav) orelse blk: {
@@ -2027,7 +2024,7 @@ pub fn allocateAtom(self: *ZigObject, atom_ptr: *Atom, requires_padding: bool, e
     log.debug("  prev {?}, next {?}", .{ atom_ptr.prev_atom_ref, atom_ptr.next_atom_ref });
 }
 
-pub fn resetShdrIndexes(self: *ZigObject, backlinks: anytype) void {
+pub fn resetShdrIndexes(self: *ZigObject, backlinks: []const u32) void {
     for (self.atoms_indexes.items) |atom_index| {
         const atom_ptr = self.atom(atom_index) orelse continue;
         atom_ptr.output_section_index = backlinks[atom_ptr.output_section_index];
diff --git a/zig/src/link/Elf/eh_frame.zig b/zig/src/link/Elf/eh_frame.zig
index b520c94aaf..4df05d49d3 100644
--- a/zig/src/link/Elf/eh_frame.zig
+++ b/zig/src/link/Elf/eh_frame.zig
@@ -12,25 +12,23 @@ pub const Fde = struct {
     out_offset: u64 = 0,
 
     pub fn address(fde: Fde, elf_file: *Elf) u64 {
-        const base: u64 = if (elf_file.eh_frame_section_index) |shndx|
+        const base: u64 = if (elf_file.section_indexes.eh_frame) |shndx|
             elf_file.sections.items(.shdr)[shndx].sh_addr
         else
             0;
         return base + fde.out_offset;
     }
 
-    pub fn data(fde: Fde, elf_file: *Elf) []u8 {
-        const object = elf_file.file(fde.file_index).?.object;
+    pub fn data(fde: Fde, object: *Object) []u8 {
         return object.eh_frame_data.items[fde.offset..][0..fde.calcSize()];
     }
 
-    pub fn cie(fde: Fde, elf_file: *Elf) Cie {
-        const object = elf_file.file(fde.file_index).?.object;
+    pub fn cie(fde: Fde, object: *Object) Cie {
         return object.cies.items[fde.cie_index];
     }
 
-    pub fn ciePointer(fde: Fde, elf_file: *Elf) u32 {
-        const fde_data = fde.data(elf_file);
+    pub fn ciePointer(fde: Fde, object: *Object) u32 {
+        const fde_data = fde.data(object);
         return std.mem.readInt(u32, fde_data[4..8], .little);
     }
 
@@ -38,16 +36,14 @@ pub const Fde = struct {
         return fde.size + 4;
     }
 
-    pub fn atom(fde: Fde, elf_file: *Elf) *Atom {
-        const object = elf_file.file(fde.file_index).?.object;
-        const rel = fde.relocs(elf_file)[0];
+    pub fn atom(fde: Fde, object: *Object) *Atom {
+        const rel = fde.relocs(object)[0];
         const sym = object.symtab.items[rel.r_sym()];
         const atom_index = object.atoms_indexes.items[sym.st_shndx];
         return object.atom(atom_index).?;
     }
 
-    pub fn relocs(fde: Fde, elf_file: *Elf) []align(1) const elf.Elf64_Rela {
-        const object = elf_file.file(fde.file_index).?.object;
+    pub fn relocs(fde: Fde, object: *Object) []const elf.Elf64_Rela {
         return object.relocs.items[fde.rel_index..][0..fde.rel_num];
     }
 
@@ -87,7 +83,8 @@ pub const Fde = struct {
         const fde = ctx.fde;
         const elf_file = ctx.elf_file;
         const base_addr = fde.address(elf_file);
-        const atom_name = fde.atom(elf_file).name(elf_file);
+        const object = elf_file.file(fde.file_index).?.object;
+        const atom_name = fde.atom(object).name(elf_file);
         try writer.print("@{x} : size({x}) : cie({d}) : {s}", .{
             base_addr + fde.out_offset,
             fde.calcSize(),
@@ -111,7 +108,7 @@ pub const Cie = struct {
     alive: bool = false,
 
     pub fn address(cie: Cie, elf_file: *Elf) u64 {
-        const base: u64 = if (elf_file.eh_frame_section_index) |shndx|
+        const base: u64 = if (elf_file.section_indexes.eh_frame) |shndx|
             elf_file.sections.items(.shdr)[shndx].sh_addr
         else
             0;
@@ -306,7 +303,7 @@ pub fn calcEhFrameRelocs(elf_file: *Elf) usize {
         }
         for (object.fdes.items) |fde| {
             if (!fde.alive) continue;
-            count += fde.relocs(elf_file).len;
+            count += fde.relocs(object).len;
         }
     }
     return count;
@@ -337,7 +334,7 @@ fn resolveReloc(rec: anytype, sym: *const Symbol, rel: elf.Elf64_Rela, elf_file:
 
 pub fn writeEhFrame(elf_file: *Elf, writer: anytype) !void {
     relocs_log.debug("{x}: .eh_frame", .{
-        elf_file.sections.items(.shdr)[elf_file.eh_frame_section_index.?].sh_addr,
+        elf_file.sections.items(.shdr)[elf_file.section_indexes.eh_frame.?].sh_addr,
     });
 
     var has_reloc_errors = false;
@@ -369,16 +366,16 @@ pub fn writeEhFrame(elf_file: *Elf, writer: anytype) !void {
         for (object.fdes.items) |fde| {
             if (!fde.alive) continue;
 
-            const contents = fde.data(elf_file);
+            const contents = fde.data(object);
 
             std.mem.writeInt(
                 i32,
                 contents[4..8],
-                @truncate(@as(i64, @intCast(fde.out_offset + 4)) - @as(i64, @intCast(fde.cie(elf_file).out_offset))),
+                @truncate(@as(i64, @intCast(fde.out_offset + 4)) - @as(i64, @intCast(fde.cie(object).out_offset))),
                 .little,
             );
 
-            for (fde.relocs(elf_file)) |rel| {
+            for (fde.relocs(object)) |rel| {
                 const ref = object.resolveSymbol(rel.r_sym(), elf_file);
                 const sym = elf_file.symbol(ref).?;
                 resolveReloc(fde, sym, rel, elf_file, contents) catch |err| switch (err) {
@@ -412,12 +409,12 @@ pub fn writeEhFrameRelocatable(elf_file: *Elf, writer: anytype) !void {
         for (object.fdes.items) |fde| {
             if (!fde.alive) continue;
 
-            const contents = fde.data(elf_file);
+            const contents = fde.data(object);
 
             std.mem.writeInt(
                 i32,
                 contents[4..8],
-                @truncate(@as(i64, @intCast(fde.out_offset + 4)) - @as(i64, @intCast(fde.cie(elf_file).out_offset))),
+                @truncate(@as(i64, @intCast(fde.out_offset + 4)) - @as(i64, @intCast(fde.cie(object).out_offset))),
                 .little,
             );
 
@@ -456,9 +453,9 @@ fn emitReloc(elf_file: *Elf, r_offset: u64, sym: *const Symbol, rel: elf.Elf64_R
     };
 }
 
-pub fn writeEhFrameRelocs(elf_file: *Elf, writer: anytype) !void {
+pub fn writeEhFrameRelocs(elf_file: *Elf, relocs: *std.ArrayList(elf.Elf64_Rela)) !void {
     relocs_log.debug("{x}: .eh_frame", .{
-        elf_file.sections.items(.shdr)[elf_file.eh_frame_section_index.?].sh_addr,
+        elf_file.sections.items(.shdr)[elf_file.section_indexes.eh_frame.?].sh_addr,
     });
 
     if (elf_file.zigObjectPtr()) |zo| zo: {
@@ -469,8 +466,7 @@ pub fn writeEhFrameRelocs(elf_file: *Elf, writer: anytype) !void {
         for (atom_ptr.relocs(elf_file)) |rel| {
             const ref = zo.resolveSymbol(rel.r_sym(), elf_file);
             const target = elf_file.symbol(ref).?;
-            const out_rel = emitReloc(elf_file, rel.r_offset, target, rel);
-            try writer.writeStruct(out_rel);
+            try relocs.append(emitReloc(elf_file, rel.r_offset, target, rel));
         }
     }
 
@@ -483,19 +479,17 @@ pub fn writeEhFrameRelocs(elf_file: *Elf, writer: anytype) !void {
                 const ref = object.resolveSymbol(rel.r_sym(), elf_file);
                 const sym = elf_file.symbol(ref).?;
                 const r_offset = cie.address(elf_file) + rel.r_offset - cie.offset;
-                const out_rel = emitReloc(elf_file, r_offset, sym, rel);
-                try writer.writeStruct(out_rel);
+                try relocs.append(emitReloc(elf_file, r_offset, sym, rel));
             }
         }
 
         for (object.fdes.items) |fde| {
             if (!fde.alive) continue;
-            for (fde.relocs(elf_file)) |rel| {
+            for (fde.relocs(object)) |rel| {
                 const ref = object.resolveSymbol(rel.r_sym(), elf_file);
                 const sym = elf_file.symbol(ref).?;
                 const r_offset = fde.address(elf_file) + rel.r_offset - fde.offset;
-                const out_rel = emitReloc(elf_file, r_offset, sym, rel);
-                try writer.writeStruct(out_rel);
+                try relocs.append(emitReloc(elf_file, r_offset, sym, rel));
             }
         }
     }
@@ -511,8 +505,8 @@ pub fn writeEhFrameHdr(elf_file: *Elf, writer: anytype) !void {
     try writer.writeByte(DW_EH_PE.datarel | DW_EH_PE.sdata4);
 
     const shdrs = elf_file.sections.items(.shdr);
-    const eh_frame_shdr = shdrs[elf_file.eh_frame_section_index.?];
-    const eh_frame_hdr_shdr = shdrs[elf_file.eh_frame_hdr_section_index.?];
+    const eh_frame_shdr = shdrs[elf_file.section_indexes.eh_frame.?];
+    const eh_frame_hdr_shdr = shdrs[elf_file.section_indexes.eh_frame_hdr.?];
     const num_fdes = @as(u32, @intCast(@divExact(eh_frame_hdr_shdr.sh_size - eh_frame_hdr_header_size, 8)));
     const existing_size = existing_size: {
         const zo = elf_file.zigObjectPtr() orelse break :existing_size 0;
@@ -548,7 +542,7 @@ pub fn writeEhFrameHdr(elf_file: *Elf, writer: anytype) !void {
         for (object.fdes.items) |fde| {
             if (!fde.alive) continue;
 
-            const relocs = fde.relocs(elf_file);
+            const relocs = fde.relocs(object);
             assert(relocs.len > 0); // Should this be an error? Things are completely broken anyhow if this trips...
             const rel = relocs[0];
             const ref = object.resolveSymbol(rel.r_sym(), elf_file);
@@ -611,7 +605,8 @@ const riscv = struct {
 };
 
 fn reportInvalidReloc(rec: anytype, elf_file: *Elf, rel: elf.Elf64_Rela) !void {
-    var err = try elf_file.base.addErrorWithNotes(1);
+    const diags = &elf_file.base.comp.link_diags;
+    var err = try diags.addErrorWithNotes(1);
     try err.addMsg("invalid relocation type {} at offset 0x{x}", .{
         relocation.fmtRelocType(rel.r_type(), elf_file.getTarget().cpu.arch),
         rel.r_offset,
diff --git a/zig/src/link/Elf/file.zig b/zig/src/link/Elf/file.zig
index 6eb4c2201f..e560644329 100644
--- a/zig/src/link/Elf/file.zig
+++ b/zig/src/link/Elf/file.zig
@@ -279,8 +279,8 @@ pub const File = union(enum) {
     pub const Index = u32;
 
     pub const Entry = union(enum) {
-        null: void,
-        zig_object: ZigObject,
+        null,
+        zig_object,
         linker_defined: LinkerDefined,
         object: Object,
         shared_object: SharedObject,
diff --git a/zig/src/link/Elf/gc.zig b/zig/src/link/Elf/gc.zig
index e0680d5db6..ff6c0bb7ce 100644
--- a/zig/src/link/Elf/gc.zig
+++ b/zig/src/link/Elf/gc.zig
@@ -103,15 +103,20 @@ fn markLive(atom: *Atom, elf_file: *Elf) void {
     assert(atom.visited);
     const file = atom.file(elf_file).?;
 
-    for (atom.fdes(elf_file)) |fde| {
-        for (fde.relocs(elf_file)[1..]) |rel| {
-            const ref = file.resolveSymbol(rel.r_sym(), elf_file);
-            const target_sym = elf_file.symbol(ref) orelse continue;
-            const target_atom = target_sym.atom(elf_file) orelse continue;
-            target_atom.alive = true;
-            gc_track_live_log.debug("{}marking live atom({d})", .{ track_live_level, target_atom.atom_index });
-            if (markAtom(target_atom)) markLive(target_atom, elf_file);
-        }
+    switch (file) {
+        .object => |object| {
+            for (atom.fdes(object)) |fde| {
+                for (fde.relocs(object)[1..]) |rel| {
+                    const ref = file.resolveSymbol(rel.r_sym(), elf_file);
+                    const target_sym = elf_file.symbol(ref) orelse continue;
+                    const target_atom = target_sym.atom(elf_file) orelse continue;
+                    target_atom.alive = true;
+                    gc_track_live_log.debug("{}marking live atom({d})", .{ track_live_level, target_atom.atom_index });
+                    if (markAtom(target_atom)) markLive(target_atom, elf_file);
+                }
+            }
+        },
+        else => {},
     }
 
     for (atom.relocs(elf_file)) |rel| {
@@ -135,23 +140,25 @@ fn mark(roots: std.ArrayList(*Atom), elf_file: *Elf) void {
     }
 }
 
-fn prune(elf_file: *Elf) void {
-    const pruneInFile = struct {
-        fn pruneInFile(file: File, ef: *Elf) void {
-            for (file.atoms()) |atom_index| {
-                const atom = file.atom(atom_index) orelse continue;
-                if (atom.alive and !atom.visited) {
-                    atom.alive = false;
-                    atom.markFdesDead(ef);
-                }
+fn pruneInFile(file: File) void {
+    for (file.atoms()) |atom_index| {
+        const atom = file.atom(atom_index) orelse continue;
+        if (atom.alive and !atom.visited) {
+            atom.alive = false;
+            switch (file) {
+                .object => |object| atom.markFdesDead(object),
+                else => {},
             }
         }
-    }.pruneInFile;
+    }
+}
+
+fn prune(elf_file: *Elf) void {
     if (elf_file.zigObjectPtr()) |zo| {
-        pruneInFile(zo.asFile(), elf_file);
+        pruneInFile(zo.asFile());
     }
     for (elf_file.objects.items) |index| {
-        pruneInFile(elf_file.file(index).?, elf_file);
+        pruneInFile(elf_file.file(index).?);
     }
 }
 
diff --git a/zig/src/link/Elf/relocatable.zig b/zig/src/link/Elf/relocatable.zig
index bdf0d378ff..3035c33790 100644
--- a/zig/src/link/Elf/relocatable.zig
+++ b/zig/src/link/Elf/relocatable.zig
@@ -1,27 +1,8 @@
-pub fn flushStaticLib(elf_file: *Elf, comp: *Compilation, module_obj_path: ?Path) link.File.FlushError!void {
+pub fn flushStaticLib(elf_file: *Elf, comp: *Compilation) link.File.FlushError!void {
     const gpa = comp.gpa;
+    const diags = &comp.link_diags;
 
-    for (comp.objects) |obj| {
-        switch (Compilation.classifyFileExt(obj.path.sub_path)) {
-            .object => try parseObjectStaticLibReportingFailure(elf_file, obj.path),
-            .static_library => try parseArchiveStaticLibReportingFailure(elf_file, obj.path),
-            else => try elf_file.addParseError(obj.path, "unrecognized file extension", .{}),
-        }
-    }
-
-    for (comp.c_object_table.keys()) |key| {
-        try parseObjectStaticLibReportingFailure(elf_file, key.status.success.object_path);
-    }
-
-    if (module_obj_path) |path| {
-        try parseObjectStaticLibReportingFailure(elf_file, path);
-    }
-
-    if (comp.include_compiler_rt) {
-        try parseObjectStaticLibReportingFailure(elf_file, comp.compiler_rt_obj.?.full_object_path);
-    }
-
-    if (elf_file.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
 
     // First, we flush relocatable object file generated with our backends.
     if (elf_file.zigObjectPtr()) |zig_object| {
@@ -32,7 +13,16 @@ pub fn flushStaticLib(elf_file: *Elf, comp: *Compilation, module_obj_path: ?Path
         zig_object.claimUnresolvedRelocatable(elf_file);
 
         try initSections(elf_file);
-        try elf_file.sortShdrs();
+        try Elf.sortShdrs(
+            gpa,
+            &elf_file.section_indexes,
+            &elf_file.sections,
+            elf_file.shstrtab.items,
+            elf_file.merge_sections.items,
+            elf_file.comdat_group_sections.items,
+            elf_file.zigObjectPtr(),
+            elf_file.files,
+        );
         try zig_object.addAtomsToRelaSections(elf_file);
         try elf_file.updateMergeSectionSizes();
         try updateSectionSizes(elf_file);
@@ -137,28 +127,13 @@ pub fn flushStaticLib(elf_file: *Elf, comp: *Compilation, module_obj_path: ?Path
     try elf_file.base.file.?.setEndPos(total_size);
     try elf_file.base.file.?.pwriteAll(buffer.items, 0);
 
-    if (elf_file.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
 }
 
-pub fn flushObject(elf_file: *Elf, comp: *Compilation, module_obj_path: ?Path) link.File.FlushError!void {
-    for (comp.objects) |obj| {
-        if (obj.isObject()) {
-            try elf_file.parseObjectReportingFailure(obj.path);
-        } else {
-            try elf_file.parseLibraryReportingFailure(.{ .path = obj.path }, obj.must_link);
-        }
-    }
-
-    // This is a set of object files emitted by clang in a single `build-exe` invocation.
-    // For instance, the implicit `a.o` as compiled by `zig build-exe a.c` will end up
-    // in this set.
-    for (comp.c_object_table.keys()) |key| {
-        try elf_file.parseObjectReportingFailure(key.status.success.object_path);
-    }
-
-    if (module_obj_path) |path| try elf_file.parseObjectReportingFailure(path);
+pub fn flushObject(elf_file: *Elf, comp: *Compilation) link.File.FlushError!void {
+    const diags = &comp.link_diags;
 
-    if (elf_file.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
 
     // Now, we are ready to resolve the symbols across all input files.
     // We will first resolve the files in the ZigObject, next in the parsed
@@ -171,7 +146,16 @@ pub fn flushObject(elf_file: *Elf, comp: *Compilation, module_obj_path: ?Path) l
     claimUnresolved(elf_file);
 
     try initSections(elf_file);
-    try elf_file.sortShdrs();
+    try Elf.sortShdrs(
+        comp.gpa,
+        &elf_file.section_indexes,
+        &elf_file.sections,
+        elf_file.shstrtab.items,
+        elf_file.merge_sections.items,
+        elf_file.comdat_group_sections.items,
+        elf_file.zigObjectPtr(),
+        elf_file.files,
+    );
     if (elf_file.zigObjectPtr()) |zig_object| {
         try zig_object.addAtomsToRelaSections(elf_file);
     }
@@ -195,65 +179,7 @@ pub fn flushObject(elf_file: *Elf, comp: *Compilation, module_obj_path: ?Path) l
     try elf_file.writeShdrTable();
     try elf_file.writeElfHeader();
 
-    if (elf_file.base.hasErrors()) return error.FlushFailure;
-}
-
-fn parseObjectStaticLibReportingFailure(elf_file: *Elf, path: Path) error{OutOfMemory}!void {
-    parseObjectStaticLib(elf_file, path) catch |err| switch (err) {
-        error.LinkFailure => return,
-        error.OutOfMemory => return error.OutOfMemory,
-        else => |e| try elf_file.addParseError(path, "parsing object failed: {s}", .{@errorName(e)}),
-    };
-}
-
-fn parseArchiveStaticLibReportingFailure(elf_file: *Elf, path: Path) error{OutOfMemory}!void {
-    parseArchiveStaticLib(elf_file, path) catch |err| switch (err) {
-        error.LinkFailure => return,
-        error.OutOfMemory => return error.OutOfMemory,
-        else => |e| try elf_file.addParseError(path, "parsing static library failed: {s}", .{@errorName(e)}),
-    };
-}
-
-fn parseObjectStaticLib(elf_file: *Elf, path: Path) Elf.ParseError!void {
-    const gpa = elf_file.base.comp.gpa;
-    const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
-    const fh = try elf_file.addFileHandle(handle);
-
-    const index: File.Index = @intCast(try elf_file.files.addOne(gpa));
-    elf_file.files.set(index, .{ .object = .{
-        .path = .{
-            .root_dir = path.root_dir,
-            .sub_path = try gpa.dupe(u8, path.sub_path),
-        },
-        .file_handle = fh,
-        .index = index,
-    } });
-    try elf_file.objects.append(gpa, index);
-
-    const object = elf_file.file(index).?.object;
-    try object.parseAr(elf_file);
-}
-
-fn parseArchiveStaticLib(elf_file: *Elf, path: Path) Elf.ParseError!void {
-    const gpa = elf_file.base.comp.gpa;
-    const handle = try path.root_dir.handle.openFile(path.sub_path, .{});
-    const fh = try elf_file.addFileHandle(handle);
-
-    var archive = Archive{};
-    defer archive.deinit(gpa);
-    try archive.parse(elf_file, path, fh);
-
-    const objects = try archive.objects.toOwnedSlice(gpa);
-    defer gpa.free(objects);
-
-    for (objects) |extracted| {
-        const index = @as(File.Index, @intCast(try elf_file.files.addOne(gpa)));
-        elf_file.files.set(index, .{ .object = extracted });
-        const object = &elf_file.files.items(.data)[index].object;
-        object.index = index;
-        try object.parseAr(elf_file);
-        try elf_file.objects.append(gpa, index);
-    }
+    if (diags.hasErrors()) return error.FlushFailure;
 }
 
 fn claimUnresolved(elf_file: *Elf) void {
@@ -288,8 +214,8 @@ fn initSections(elf_file: *Elf) !void {
         } else false;
     };
     if (needs_eh_frame) {
-        if (elf_file.eh_frame_section_index == null) {
-            elf_file.eh_frame_section_index = elf_file.sectionByName(".eh_frame") orelse
+        if (elf_file.section_indexes.eh_frame == null) {
+            elf_file.section_indexes.eh_frame = elf_file.sectionByName(".eh_frame") orelse
                 try elf_file.addSection(.{
                 .name = try elf_file.insertShString(".eh_frame"),
                 .type = if (elf_file.getTarget().cpu.arch == .x86_64)
@@ -300,10 +226,10 @@ fn initSections(elf_file: *Elf) !void {
                 .addralign = elf_file.ptrWidthBytes(),
             });
         }
-        elf_file.eh_frame_rela_section_index = elf_file.sectionByName(".rela.eh_frame") orelse
+        elf_file.section_indexes.eh_frame_rela = elf_file.sectionByName(".rela.eh_frame") orelse
             try elf_file.addRelaShdr(
             try elf_file.insertShString(".rela.eh_frame"),
-            elf_file.eh_frame_section_index.?,
+            elf_file.section_indexes.eh_frame.?,
         );
     }
 
@@ -346,7 +272,7 @@ fn updateSectionSizes(elf_file: *Elf) !void {
     for (slice.items(.shdr), 0..) |*shdr, shndx| {
         const atom_list = slice.items(.atom_list)[shndx];
         if (shdr.sh_type != elf.SHT_RELA) continue;
-        if (@as(u32, @intCast(shndx)) == elf_file.eh_frame_section_index) continue;
+        if (@as(u32, @intCast(shndx)) == elf_file.section_indexes.eh_frame) continue;
         for (atom_list.items) |ref| {
             const atom_ptr = elf_file.atom(ref) orelse continue;
             if (!atom_ptr.alive) continue;
@@ -357,10 +283,10 @@ fn updateSectionSizes(elf_file: *Elf) !void {
         if (shdr.sh_size == 0) shdr.sh_offset = 0;
     }
 
-    if (elf_file.eh_frame_section_index) |index| {
+    if (elf_file.section_indexes.eh_frame) |index| {
         slice.items(.shdr)[index].sh_size = try eh_frame.calcEhFrameSize(elf_file);
     }
-    if (elf_file.eh_frame_rela_section_index) |index| {
+    if (elf_file.section_indexes.eh_frame_rela) |index| {
         const shdr = &slice.items(.shdr)[index];
         shdr.sh_size = eh_frame.calcEhFrameRelocs(elf_file) * shdr.sh_entsize;
     }
@@ -374,7 +300,7 @@ fn updateComdatGroupsSizes(elf_file: *Elf) void {
     for (elf_file.comdat_group_sections.items) |cg| {
         const shdr = &elf_file.sections.items(.shdr)[cg.shndx];
         shdr.sh_size = cg.size(elf_file);
-        shdr.sh_link = elf_file.symtab_section_index.?;
+        shdr.sh_link = elf_file.section_indexes.symtab.?;
 
         const sym = cg.symbol(elf_file);
         shdr.sh_info = sym.outputSymtabIndex(elf_file) orelse sym.outputShndx(elf_file).?;
@@ -436,10 +362,18 @@ fn writeSyntheticSections(elf_file: *Elf) !void {
     const gpa = elf_file.base.comp.gpa;
     const slice = elf_file.sections.slice();
 
+    const SortRelocs = struct {
+        pub fn lessThan(ctx: void, lhs: elf.Elf64_Rela, rhs: elf.Elf64_Rela) bool {
+            _ = ctx;
+            assert(lhs.r_offset != rhs.r_offset);
+            return lhs.r_offset < rhs.r_offset;
+        }
+    };
+
     for (slice.items(.shdr), slice.items(.atom_list), 0..) |shdr, atom_list, shndx| {
         if (shdr.sh_type != elf.SHT_RELA) continue;
         if (atom_list.items.len == 0) continue;
-        if (@as(u32, @intCast(shndx)) == elf_file.eh_frame_section_index) continue;
+        if (@as(u32, @intCast(shndx)) == elf_file.section_indexes.eh_frame) continue;
 
         const num_relocs = math.cast(usize, @divExact(shdr.sh_size, shdr.sh_entsize)) orelse
             return error.Overflow;
@@ -452,15 +386,9 @@ fn writeSyntheticSections(elf_file: *Elf) !void {
             try atom_ptr.writeRelocs(elf_file, &relocs);
         }
         assert(relocs.items.len == num_relocs);
-
-        const SortRelocs = struct {
-            pub fn lessThan(ctx: void, lhs: elf.Elf64_Rela, rhs: elf.Elf64_Rela) bool {
-                _ = ctx;
-                return lhs.r_offset < rhs.r_offset;
-            }
-        };
-
-        mem.sort(elf.Elf64_Rela, relocs.items, {}, SortRelocs.lessThan);
+        // Sort output relocations by r_offset which is usually an expected (and desired) condition
+        // by the linkers.
+        mem.sortUnstable(elf.Elf64_Rela, relocs.items, {}, SortRelocs.lessThan);
 
         log.debug("writing {s} from 0x{x} to 0x{x}", .{
             elf_file.getShString(shdr.sh_name),
@@ -471,7 +399,7 @@ fn writeSyntheticSections(elf_file: *Elf) !void {
         try elf_file.base.file.?.pwriteAll(mem.sliceAsBytes(relocs.items), shdr.sh_offset);
     }
 
-    if (elf_file.eh_frame_section_index) |shndx| {
+    if (elf_file.section_indexes.eh_frame) |shndx| {
         const existing_size = existing_size: {
             const zo = elf_file.zigObjectPtr() orelse break :existing_size 0;
             const sym = zo.symbol(zo.eh_frame_index orelse break :existing_size 0);
@@ -489,18 +417,23 @@ fn writeSyntheticSections(elf_file: *Elf) !void {
         assert(buffer.items.len == sh_size - existing_size);
         try elf_file.base.file.?.pwriteAll(buffer.items, shdr.sh_offset + existing_size);
     }
-    if (elf_file.eh_frame_rela_section_index) |shndx| {
+    if (elf_file.section_indexes.eh_frame_rela) |shndx| {
         const shdr = slice.items(.shdr)[shndx];
-        const sh_size = math.cast(usize, shdr.sh_size) orelse return error.Overflow;
-        var buffer = try std.ArrayList(u8).initCapacity(gpa, sh_size);
-        defer buffer.deinit();
-        try eh_frame.writeEhFrameRelocs(elf_file, buffer.writer());
-        assert(buffer.items.len == sh_size);
+        const num_relocs = math.cast(usize, @divExact(shdr.sh_size, shdr.sh_entsize)) orelse
+            return error.Overflow;
+        var relocs = try std.ArrayList(elf.Elf64_Rela).initCapacity(gpa, num_relocs);
+        defer relocs.deinit();
+        try eh_frame.writeEhFrameRelocs(elf_file, &relocs);
+        assert(relocs.items.len == num_relocs);
+        // Sort output relocations by r_offset which is usually an expected (and desired) condition
+        // by the linkers.
+        mem.sortUnstable(elf.Elf64_Rela, relocs.items, {}, SortRelocs.lessThan);
+
         log.debug("writing .rela.eh_frame from 0x{x} to 0x{x}", .{
             shdr.sh_offset,
             shdr.sh_offset + shdr.sh_size,
         });
-        try elf_file.base.file.?.pwriteAll(buffer.items, shdr.sh_offset);
+        try elf_file.base.file.?.pwriteAll(mem.sliceAsBytes(relocs.items), shdr.sh_offset);
     }
 
     try writeComdatGroups(elf_file);
diff --git a/zig/src/link/Elf/synthetic_sections.zig b/zig/src/link/Elf/synthetic_sections.zig
index 987ee4bf9a..6d26ec5d1f 100644
--- a/zig/src/link/Elf/synthetic_sections.zig
+++ b/zig/src/link/Elf/synthetic_sections.zig
@@ -75,18 +75,18 @@ pub const DynamicSection = struct {
         if (elf_file.sectionByName(".fini") != null) nentries += 1; // FINI
         if (elf_file.sectionByName(".init_array") != null) nentries += 2; // INIT_ARRAY
         if (elf_file.sectionByName(".fini_array") != null) nentries += 2; // FINI_ARRAY
-        if (elf_file.rela_dyn_section_index != null) nentries += 3; // RELA
-        if (elf_file.rela_plt_section_index != null) nentries += 3; // JMPREL
-        if (elf_file.got_plt_section_index != null) nentries += 1; // PLTGOT
+        if (elf_file.section_indexes.rela_dyn != null) nentries += 3; // RELA
+        if (elf_file.section_indexes.rela_plt != null) nentries += 3; // JMPREL
+        if (elf_file.section_indexes.got_plt != null) nentries += 1; // PLTGOT
         nentries += 1; // HASH
-        if (elf_file.gnu_hash_section_index != null) nentries += 1; // GNU_HASH
+        if (elf_file.section_indexes.gnu_hash != null) nentries += 1; // GNU_HASH
         if (elf_file.has_text_reloc) nentries += 1; // TEXTREL
         nentries += 1; // SYMTAB
         nentries += 1; // SYMENT
         nentries += 1; // STRTAB
         nentries += 1; // STRSZ
-        if (elf_file.versym_section_index != null) nentries += 1; // VERSYM
-        if (elf_file.verneed_section_index != null) nentries += 2; // VERNEED
+        if (elf_file.section_indexes.versym != null) nentries += 1; // VERSYM
+        if (elf_file.section_indexes.verneed != null) nentries += 2; // VERNEED
         if (dt.getFlags(elf_file) != null) nentries += 1; // FLAGS
         if (dt.getFlags1(elf_file) != null) nentries += 1; // FLAGS_1
         if (!elf_file.isEffectivelyDynLib()) nentries += 1; // DEBUG
@@ -139,7 +139,7 @@ pub const DynamicSection = struct {
         }
 
         // RELA
-        if (elf_file.rela_dyn_section_index) |shndx| {
+        if (elf_file.section_indexes.rela_dyn) |shndx| {
             const shdr = shdrs[shndx];
             try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_RELA, .d_val = shdr.sh_addr });
             try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_RELASZ, .d_val = shdr.sh_size });
@@ -147,7 +147,7 @@ pub const DynamicSection = struct {
         }
 
         // JMPREL
-        if (elf_file.rela_plt_section_index) |shndx| {
+        if (elf_file.section_indexes.rela_plt) |shndx| {
             const shdr = shdrs[shndx];
             try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_JMPREL, .d_val = shdr.sh_addr });
             try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_PLTRELSZ, .d_val = shdr.sh_size });
@@ -155,18 +155,18 @@ pub const DynamicSection = struct {
         }
 
         // PLTGOT
-        if (elf_file.got_plt_section_index) |shndx| {
+        if (elf_file.section_indexes.got_plt) |shndx| {
             const addr = shdrs[shndx].sh_addr;
             try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_PLTGOT, .d_val = addr });
         }
 
         {
-            assert(elf_file.hash_section_index != null);
-            const addr = shdrs[elf_file.hash_section_index.?].sh_addr;
+            assert(elf_file.section_indexes.hash != null);
+            const addr = shdrs[elf_file.section_indexes.hash.?].sh_addr;
             try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_HASH, .d_val = addr });
         }
 
-        if (elf_file.gnu_hash_section_index) |shndx| {
+        if (elf_file.section_indexes.gnu_hash) |shndx| {
             const addr = shdrs[shndx].sh_addr;
             try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_GNU_HASH, .d_val = addr });
         }
@@ -178,28 +178,28 @@ pub const DynamicSection = struct {
 
         // SYMTAB + SYMENT
         {
-            assert(elf_file.dynsymtab_section_index != null);
-            const shdr = shdrs[elf_file.dynsymtab_section_index.?];
+            assert(elf_file.section_indexes.dynsymtab != null);
+            const shdr = shdrs[elf_file.section_indexes.dynsymtab.?];
             try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_SYMTAB, .d_val = shdr.sh_addr });
             try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_SYMENT, .d_val = shdr.sh_entsize });
         }
 
         // STRTAB + STRSZ
         {
-            assert(elf_file.dynstrtab_section_index != null);
-            const shdr = shdrs[elf_file.dynstrtab_section_index.?];
+            assert(elf_file.section_indexes.dynstrtab != null);
+            const shdr = shdrs[elf_file.section_indexes.dynstrtab.?];
             try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_STRTAB, .d_val = shdr.sh_addr });
             try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_STRSZ, .d_val = shdr.sh_size });
         }
 
         // VERSYM
-        if (elf_file.versym_section_index) |shndx| {
+        if (elf_file.section_indexes.versym) |shndx| {
             const addr = shdrs[shndx].sh_addr;
             try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_VERSYM, .d_val = addr });
         }
 
         // VERNEED + VERNEEDNUM
-        if (elf_file.verneed_section_index) |shndx| {
+        if (elf_file.section_indexes.verneed) |shndx| {
             const addr = shdrs[shndx].sh_addr;
             try writer.writeStruct(elf.Elf64_Dyn{ .d_tag = elf.DT_VERNEED, .d_val = addr });
             try writer.writeStruct(elf.Elf64_Dyn{
@@ -261,7 +261,7 @@ pub const GotSection = struct {
 
         pub fn address(entry: Entry, elf_file: *Elf) i64 {
             const ptr_bytes = elf_file.archPtrWidthBytes();
-            const shdr = &elf_file.sections.items(.shdr)[elf_file.got_section_index.?];
+            const shdr = &elf_file.sections.items(.shdr)[elf_file.section_indexes.got.?];
             return @as(i64, @intCast(shdr.sh_addr)) + entry.cell_index * ptr_bytes;
         }
     };
@@ -599,7 +599,7 @@ pub const GotSection = struct {
                 .st_name = st_name,
                 .st_info = elf.STT_OBJECT,
                 .st_other = 0,
-                .st_shndx = @intCast(elf_file.got_section_index.?),
+                .st_shndx = @intCast(elf_file.section_indexes.got.?),
                 .st_value = @intCast(st_value),
                 .st_size = st_size,
             };
@@ -742,7 +742,7 @@ pub const PltSection = struct {
                 .st_name = st_name,
                 .st_info = elf.STT_FUNC,
                 .st_other = 0,
-                .st_shndx = @intCast(elf_file.plt_section_index.?),
+                .st_shndx = @intCast(elf_file.section_indexes.plt.?),
                 .st_value = @intCast(sym.pltAddress(elf_file)),
                 .st_size = entrySize(cpu_arch),
             };
@@ -784,8 +784,8 @@ pub const PltSection = struct {
     const x86_64 = struct {
         fn write(plt: PltSection, elf_file: *Elf, writer: anytype) !void {
             const shdrs = elf_file.sections.items(.shdr);
-            const plt_addr = shdrs[elf_file.plt_section_index.?].sh_addr;
-            const got_plt_addr = shdrs[elf_file.got_plt_section_index.?].sh_addr;
+            const plt_addr = shdrs[elf_file.section_indexes.plt.?].sh_addr;
+            const got_plt_addr = shdrs[elf_file.section_indexes.got_plt.?].sh_addr;
             var preamble = [_]u8{
                 0xf3, 0x0f, 0x1e, 0xfa, // endbr64
                 0x41, 0x53, // push r11
@@ -820,8 +820,8 @@ pub const PltSection = struct {
         fn write(plt: PltSection, elf_file: *Elf, writer: anytype) !void {
             {
                 const shdrs = elf_file.sections.items(.shdr);
-                const plt_addr: i64 = @intCast(shdrs[elf_file.plt_section_index.?].sh_addr);
-                const got_plt_addr: i64 = @intCast(shdrs[elf_file.got_plt_section_index.?].sh_addr);
+                const plt_addr: i64 = @intCast(shdrs[elf_file.section_indexes.plt.?].sh_addr);
+                const got_plt_addr: i64 = @intCast(shdrs[elf_file.section_indexes.got_plt.?].sh_addr);
                 // TODO: relax if possible
                 // .got.plt[2]
                 const pages = try aarch64_util.calcNumberOfPages(plt_addr + 4, got_plt_addr + 16);
@@ -894,7 +894,7 @@ pub const GotPltSection = struct {
         // [2]: 0x0
         try writer.writeInt(u64, 0x0, .little);
         try writer.writeInt(u64, 0x0, .little);
-        if (elf_file.plt_section_index) |shndx| {
+        if (elf_file.section_indexes.plt) |shndx| {
             const plt_addr = elf_file.sections.items(.shdr)[shndx].sh_addr;
             for (0..elf_file.plt.symbols.items.len) |_| {
                 // [N]: .plt
@@ -962,7 +962,7 @@ pub const PltGotSection = struct {
                 .st_name = st_name,
                 .st_info = elf.STT_FUNC,
                 .st_other = 0,
-                .st_shndx = @intCast(elf_file.plt_got_section_index.?),
+                .st_shndx = @intCast(elf_file.section_indexes.plt_got.?),
                 .st_value = @intCast(sym.pltGotAddress(elf_file)),
                 .st_size = 16,
             };
@@ -1345,8 +1345,8 @@ pub const GnuHashSection = struct {
 
 pub const VerneedSection = struct {
     verneed: std.ArrayListUnmanaged(elf.Elf64_Verneed) = .empty,
-    vernaux: std.ArrayListUnmanaged(elf.Elf64_Vernaux) = .empty,
-    index: elf.Elf64_Versym = elf.VER_NDX_GLOBAL + 1,
+    vernaux: std.ArrayListUnmanaged(elf.Vernaux) = .empty,
+    index: elf.Versym = .{ .VERSION = elf.Versym.GLOBAL.VERSION + 1, .HIDDEN = false },
 
     pub fn deinit(vern: *VerneedSection, allocator: Allocator) void {
         vern.verneed.deinit(allocator);
@@ -1363,7 +1363,7 @@ pub const VerneedSection = struct {
             /// Index of the defining this symbol version shared object file
             shared_object: File.Index,
             /// Version index
-            version_index: elf.Elf64_Versym,
+            version_index: elf.Versym,
 
             fn soname(this: @This(), ctx: *Elf) []const u8 {
                 const shared_object = ctx.file(this.shared_object).?.shared_object;
@@ -1376,7 +1376,8 @@ pub const VerneedSection = struct {
             }
 
             pub fn lessThan(ctx: *Elf, lhs: @This(), rhs: @This()) bool {
-                if (lhs.shared_object == rhs.shared_object) return lhs.version_index < rhs.version_index;
+                if (lhs.shared_object == rhs.shared_object)
+                    return @as(u16, @bitCast(lhs.version_index)) < @as(u16, @bitCast(rhs.version_index));
                 return mem.lessThan(u8, lhs.soname(ctx), rhs.soname(ctx));
             }
         };
@@ -1389,7 +1390,7 @@ pub const VerneedSection = struct {
 
         for (dynsyms, 1..) |entry, i| {
             const symbol = elf_file.symbol(entry.ref).?;
-            if (symbol.flags.import and symbol.version_index & elf.VERSYM_VERSION > elf.VER_NDX_GLOBAL) {
+            if (symbol.flags.import and symbol.version_index.VERSION > elf.Versym.GLOBAL.VERSION) {
                 const shared_object = symbol.file(elf_file).?.shared_object;
                 verneed.appendAssumeCapacity(.{
                     .index = i,
@@ -1404,11 +1405,12 @@ pub const VerneedSection = struct {
         var last = verneed.items[0];
         var last_verneed = try vern.addVerneed(last.soname(elf_file), elf_file);
         var last_vernaux = try vern.addVernaux(last_verneed, last.versionString(elf_file), elf_file);
-        versyms[last.index] = last_vernaux.vna_other;
+        versyms[last.index] = @bitCast(last_vernaux.other);
 
         for (verneed.items[1..]) |ver| {
             if (ver.shared_object == last.shared_object) {
-                if (ver.version_index != last.version_index) {
+                // https://github.com/ziglang/zig/issues/21678
+                if (@as(u16, @bitCast(ver.version_index)) != @as(u16, @bitCast(last.version_index))) {
                     last_vernaux = try vern.addVernaux(last_verneed, ver.versionString(elf_file), elf_file);
                 }
             } else {
@@ -1416,7 +1418,7 @@ pub const VerneedSection = struct {
                 last_vernaux = try vern.addVernaux(last_verneed, ver.versionString(elf_file), elf_file);
             }
             last = ver;
-            versyms[ver.index] = last_vernaux.vna_other;
+            versyms[ver.index] = @bitCast(last_vernaux.other);
         }
 
         // Fixup offsets
@@ -1428,8 +1430,8 @@ pub const VerneedSection = struct {
             vsym.vn_aux = vernaux_off - verneed_off;
             var inner_off: u32 = 0;
             for (vern.vernaux.items[count..][0..vsym.vn_cnt], 0..) |*vaux, vaux_i| {
-                if (vaux_i < vsym.vn_cnt - 1) vaux.vna_next = @sizeOf(elf.Elf64_Vernaux);
-                inner_off += @sizeOf(elf.Elf64_Vernaux);
+                if (vaux_i < vsym.vn_cnt - 1) vaux.next = @sizeOf(elf.Vernaux);
+                inner_off += @sizeOf(elf.Vernaux);
             }
             vernaux_off += inner_off;
             verneed_off += @sizeOf(elf.Elf64_Verneed);
@@ -1456,24 +1458,24 @@ pub const VerneedSection = struct {
         verneed_sym: *elf.Elf64_Verneed,
         version: [:0]const u8,
         elf_file: *Elf,
-    ) !elf.Elf64_Vernaux {
+    ) !elf.Vernaux {
         const comp = elf_file.base.comp;
         const gpa = comp.gpa;
         const sym = try vern.vernaux.addOne(gpa);
         sym.* = .{
-            .vna_hash = HashSection.hasher(version),
-            .vna_flags = 0,
-            .vna_other = vern.index,
-            .vna_name = try elf_file.insertDynString(version),
-            .vna_next = 0,
+            .hash = HashSection.hasher(version),
+            .flags = 0,
+            .other = @bitCast(vern.index),
+            .name = try elf_file.insertDynString(version),
+            .next = 0,
         };
         verneed_sym.vn_cnt += 1;
-        vern.index += 1;
+        vern.index.VERSION += 1;
         return sym.*;
     }
 
     pub fn size(vern: VerneedSection) usize {
-        return vern.verneed.items.len * @sizeOf(elf.Elf64_Verneed) + vern.vernaux.items.len * @sizeOf(elf.Elf64_Vernaux);
+        return vern.verneed.items.len * @sizeOf(elf.Elf64_Verneed) + vern.vernaux.items.len * @sizeOf(elf.Vernaux);
     }
 
     pub fn write(vern: VerneedSection, writer: anytype) !void {
diff --git a/zig/src/link/Elf/LdScript.zig b/zig/src/link/LdScript.zig
similarity index 80%
rename from zig/src/link/Elf/LdScript.zig
rename to zig/src/link/LdScript.zig
index 7bb1f62104..ed5dbc4681 100644
--- a/zig/src/link/Elf/LdScript.zig
+++ b/zig/src/link/LdScript.zig
@@ -1,43 +1,47 @@
 path: Path,
-cpu_arch: ?std.Target.Cpu.Arch = null,
-args: std.ArrayListUnmanaged(Arg) = .empty,
+cpu_arch: ?std.Target.Cpu.Arch,
+args: []const Arg,
 
 pub const Arg = struct {
     needed: bool = false,
     path: []const u8,
 };
 
-pub fn deinit(scr: *LdScript, allocator: Allocator) void {
-    scr.args.deinit(allocator);
+pub fn deinit(ls: *LdScript, gpa: Allocator) void {
+    gpa.free(ls.args);
+    ls.* = undefined;
 }
 
 pub const Error = error{
     LinkFailure,
-    UnexpectedToken,
     UnknownCpuArch,
     OutOfMemory,
 };
 
-pub fn parse(scr: *LdScript, data: []const u8, elf_file: *Elf) Error!void {
-    const comp = elf_file.base.comp;
-    const gpa = comp.gpa;
+pub fn parse(
+    gpa: Allocator,
+    diags: *Diags,
+    /// For error reporting.
+    path: Path,
+    data: []const u8,
+) Error!LdScript {
     var tokenizer = Tokenizer{ .source = data };
-    var tokens = std.ArrayList(Token).init(gpa);
-    defer tokens.deinit();
-    var line_col = std.ArrayList(LineColumn).init(gpa);
-    defer line_col.deinit();
+    var tokens: std.ArrayListUnmanaged(Token) = .empty;
+    defer tokens.deinit(gpa);
+    var line_col: std.ArrayListUnmanaged(LineColumn) = .empty;
+    defer line_col.deinit(gpa);
 
     var line: usize = 0;
     var prev_line_last_col: usize = 0;
 
     while (true) {
         const tok = tokenizer.next();
-        try tokens.append(tok);
+        try tokens.append(gpa, tok);
         const column = tok.start - prev_line_last_col;
-        try line_col.append(.{ .line = line, .column = column });
+        try line_col.append(gpa, .{ .line = line, .column = column });
         switch (tok.id) {
             .invalid => {
-                return elf_file.failParse(scr.path, "invalid token in LD script: '{s}' ({d}:{d})", .{
+                return diags.failParse(path, "invalid token in LD script: '{s}' ({d}:{d})", .{
                     std.fmt.fmtSliceEscapeLower(tok.get(data)), line, column,
                 });
             },
@@ -50,18 +54,22 @@ pub fn parse(scr: *LdScript, data: []const u8, elf_file: *Elf) Error!void {
         }
     }
 
-    var it = TokenIterator{ .tokens = tokens.items };
-    var parser = Parser{ .source = data, .it = &it };
-    var args = std.ArrayList(Arg).init(gpa);
-    scr.doParse(.{
-        .parser = &parser,
-        .args = &args,
-    }) catch |err| switch (err) {
+    var it: TokenIterator = .{ .tokens = tokens.items };
+    var parser: Parser = .{
+        .gpa = gpa,
+        .source = data,
+        .it = &it,
+        .args = .empty,
+        .cpu_arch = null,
+    };
+    defer parser.args.deinit(gpa);
+
+    parser.start() catch |err| switch (err) {
         error.UnexpectedToken => {
             const last_token_id = parser.it.pos - 1;
             const last_token = parser.it.get(last_token_id);
             const lcol = line_col.items[last_token_id];
-            return elf_file.failParse(scr.path, "unexpected token in LD script: {s}: '{s}' ({d}:{d})", .{
+            return diags.failParse(path, "unexpected token in LD script: {s}: '{s}' ({d}:{d})", .{
                 @tagName(last_token.id),
                 last_token.get(data),
                 lcol.line,
@@ -70,30 +78,10 @@ pub fn parse(scr: *LdScript, data: []const u8, elf_file: *Elf) Error!void {
         },
         else => |e| return e,
     };
-    scr.args = args.moveToUnmanaged();
-}
-
-fn doParse(scr: *LdScript, ctx: struct {
-    parser: *Parser,
-    args: *std.ArrayList(Arg),
-}) !void {
-    while (true) {
-        ctx.parser.skipAny(&.{ .comment, .new_line });
-
-        if (ctx.parser.maybe(.command)) |cmd_id| {
-            const cmd = ctx.parser.getCommand(cmd_id);
-            switch (cmd) {
-                .output_format => scr.cpu_arch = try ctx.parser.outputFormat(),
-                // TODO we should verify that group only contains libraries
-                .input, .group => try ctx.parser.group(ctx.args),
-                else => return error.UnexpectedToken,
-            }
-        } else break;
-    }
-
-    if (ctx.parser.it.next()) |tok| switch (tok.id) {
-        .eof => {},
-        else => return error.UnexpectedToken,
+    return .{
+        .path = path,
+        .cpu_arch = parser.cpu_arch,
+        .args = try parser.args.toOwnedSlice(gpa),
     };
 }
 
@@ -124,9 +112,34 @@ const Command = enum {
 };
 
 const Parser = struct {
+    gpa: Allocator,
     source: []const u8,
     it: *TokenIterator,
 
+    cpu_arch: ?std.Target.Cpu.Arch,
+    args: std.ArrayListUnmanaged(Arg),
+
+    fn start(parser: *Parser) !void {
+        while (true) {
+            parser.skipAny(&.{ .comment, .new_line });
+
+            if (parser.maybe(.command)) |cmd_id| {
+                const cmd = parser.getCommand(cmd_id);
+                switch (cmd) {
+                    .output_format => parser.cpu_arch = try parser.outputFormat(),
+                    // TODO we should verify that group only contains libraries
+                    .input, .group => try parser.group(),
+                    else => return error.UnexpectedToken,
+                }
+            } else break;
+        }
+
+        if (parser.it.next()) |tok| switch (tok.id) {
+            .eof => {},
+            else => return error.UnexpectedToken,
+        };
+    }
+
     fn outputFormat(p: *Parser) !std.Target.Cpu.Arch {
         const value = value: {
             if (p.skip(&.{.lparen})) {
@@ -147,18 +160,19 @@ const Parser = struct {
         return error.UnknownCpuArch;
     }
 
-    fn group(p: *Parser, args: *std.ArrayList(Arg)) !void {
+    fn group(p: *Parser) !void {
+        const gpa = p.gpa;
         if (!p.skip(&.{.lparen})) return error.UnexpectedToken;
 
         while (true) {
             if (p.maybe(.literal)) |tok_id| {
                 const tok = p.it.get(tok_id);
                 const path = tok.get(p.source);
-                try args.append(.{ .path = path, .needed = true });
+                try p.args.append(gpa, .{ .path = path, .needed = true });
             } else if (p.maybe(.command)) |cmd_id| {
                 const cmd = p.getCommand(cmd_id);
                 switch (cmd) {
-                    .as_needed => try p.asNeeded(args),
+                    .as_needed => try p.asNeeded(),
                     else => return error.UnexpectedToken,
                 }
             } else break;
@@ -167,13 +181,14 @@ const Parser = struct {
         _ = try p.require(.rparen);
     }
 
-    fn asNeeded(p: *Parser, args: *std.ArrayList(Arg)) !void {
+    fn asNeeded(p: *Parser) !void {
+        const gpa = p.gpa;
         if (!p.skip(&.{.lparen})) return error.UnexpectedToken;
 
         while (p.maybe(.literal)) |tok_id| {
             const tok = p.it.get(tok_id);
             const path = tok.get(p.source);
-            try args.append(.{ .path = path, .needed = false });
+            try p.args.append(gpa, .{ .path = path, .needed = false });
         }
 
         _ = try p.require(.rparen);
@@ -225,21 +240,19 @@ const Token = struct {
     end: usize,
 
     const Id = enum {
-        // zig fmt: off
         eof,
         invalid,
 
         new_line,
-        lparen,    // (
-        rparen,    // )
-        lbrace,    // {
-        rbrace,    // }
+        lparen, // (
+        rparen, // )
+        lbrace, // {
+        rbrace, // }
 
-        comment,   // /* */
+        comment, // /* */
 
-        command,   // literal with special meaning, see Command
+        command, // literal with special meaning, see Command
         literal,
-        // zig fmt: on
     };
 
     const Index = usize;
@@ -428,10 +441,9 @@ const TokenIterator = struct {
 };
 
 const LdScript = @This();
+const Diags = @import("../link.zig").Diags;
 
 const std = @import("std");
 const assert = std.debug.assert;
 const Path = std.Build.Cache.Path;
-
 const Allocator = std.mem.Allocator;
-const Elf = @import("../Elf.zig");
diff --git a/zig/src/link/MachO.zig b/zig/src/link/MachO.zig
index 38684e4d6a..1ffcabb1f5 100644
--- a/zig/src/link/MachO.zig
+++ b/zig/src/link/MachO.zig
@@ -1,3 +1,7 @@
+pub const Atom = @import("MachO/Atom.zig");
+pub const DebugSymbols = @import("MachO/DebugSymbols.zig");
+pub const Relocation = @import("MachO/Relocation.zig");
+
 base: link.File,
 
 rpath_list: []const []const u8,
@@ -100,7 +104,6 @@ debug_rnglists_sect_index: ?u8 = null,
 has_tlv: AtomicBool = AtomicBool.init(false),
 binds_to_weak: AtomicBool = AtomicBool.init(false),
 weak_defines: AtomicBool = AtomicBool.init(false),
-has_errors: AtomicBool = AtomicBool.init(false),
 
 /// Options
 /// SDK layout
@@ -115,8 +118,8 @@ headerpad_max_install_names: bool,
 dead_strip_dylibs: bool,
 /// Treatment of undefined symbols
 undefined_treatment: UndefinedTreatment,
-/// Resolved list of library search directories
-lib_dirs: []const []const u8,
+/// TODO: delete this, libraries need to be resolved by the frontend instead
+lib_directories: []const Directory,
 /// Resolved list of framework search directories
 framework_dirs: []const []const u8,
 /// List of input frameworks
@@ -214,7 +217,8 @@ pub fn createEmpty(
         .platform = Platform.fromTarget(target),
         .sdk_version = if (options.darwin_sdk_layout) |layout| inferSdkVersion(comp, layout) else null,
         .undefined_treatment = if (allow_shlib_undefined) .dynamic_lookup else .@"error",
-        .lib_dirs = options.lib_dirs,
+        // TODO delete this, directories must instead be resolved by the frontend
+        .lib_directories = options.lib_directories,
         .framework_dirs = options.framework_dirs,
         .force_load_objc = options.force_load_objc,
     };
@@ -347,6 +351,7 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
 
     const comp = self.base.comp;
     const gpa = comp.gpa;
+    const diags = &self.base.comp.link_diags;
 
     if (self.llvm_object) |llvm_object| {
         try self.base.emitLlvmObject(arena, llvm_object, prog_node);
@@ -371,54 +376,44 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
     if (self.base.isStaticLib()) return relocatable.flushStaticLib(self, comp, module_obj_path);
     if (self.base.isObject()) return relocatable.flushObject(self, comp, module_obj_path);
 
-    var positionals = std.ArrayList(Compilation.LinkObject).init(gpa);
+    var positionals = std.ArrayList(link.Input).init(gpa);
     defer positionals.deinit();
 
-    try positionals.ensureUnusedCapacity(comp.objects.len);
-    positionals.appendSliceAssumeCapacity(comp.objects);
+    try positionals.ensureUnusedCapacity(comp.link_inputs.len);
+
+    for (comp.link_inputs) |link_input| switch (link_input) {
+        .dso => continue, // handled below
+        .object, .archive => positionals.appendAssumeCapacity(link_input),
+        .dso_exact => @panic("TODO"),
+        .res => unreachable,
+    };
 
     // This is a set of object files emitted by clang in a single `build-exe` invocation.
     // For instance, the implicit `a.o` as compiled by `zig build-exe a.c` will end up
     // in this set.
     try positionals.ensureUnusedCapacity(comp.c_object_table.keys().len);
     for (comp.c_object_table.keys()) |key| {
-        positionals.appendAssumeCapacity(.{ .path = key.status.success.object_path });
+        positionals.appendAssumeCapacity(try link.openObjectInput(diags, key.status.success.object_path));
     }
 
-    if (module_obj_path) |path| try positionals.append(.{ .path = path });
+    if (module_obj_path) |path| try positionals.append(try link.openObjectInput(diags, path));
 
     if (comp.config.any_sanitize_thread) {
-        try positionals.append(.{ .path = comp.tsan_lib.?.full_object_path });
+        try positionals.append(try link.openObjectInput(diags, comp.tsan_lib.?.full_object_path));
     }
 
     if (comp.config.any_fuzz) {
-        try positionals.append(.{ .path = comp.fuzzer_lib.?.full_object_path });
+        try positionals.append(try link.openObjectInput(diags, comp.fuzzer_lib.?.full_object_path));
     }
 
-    for (positionals.items) |obj| {
-        self.classifyInputFile(obj.path, .{ .path = obj.path }, obj.must_link) catch |err| switch (err) {
-            error.UnknownFileType => try self.reportParseError(obj.path, "unknown file type for an input file", .{}),
-            else => |e| try self.reportParseError(
-                obj.path,
-                "unexpected error: reading input file failed with error {s}",
-                .{@errorName(e)},
-            ),
-        };
+    for (positionals.items) |link_input| {
+        self.classifyInputFile(link_input) catch |err|
+            diags.addParseError(link_input.path().?, "failed to read input file: {s}", .{@errorName(err)});
     }
 
     var system_libs = std.ArrayList(SystemLib).init(gpa);
     defer system_libs.deinit();
 
-    // libs
-    try system_libs.ensureUnusedCapacity(comp.system_libs.values().len);
-    for (comp.system_libs.values()) |info| {
-        system_libs.appendAssumeCapacity(.{
-            .needed = info.needed,
-            .weak = info.weak,
-            .path = info.path.?,
-        });
-    }
-
     // frameworks
     try system_libs.ensureUnusedCapacity(self.frameworks.len);
     for (self.frameworks) |info| {
@@ -442,46 +437,51 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
         else => |e| return e, // TODO: convert into an error
     };
 
+    for (comp.link_inputs) |link_input| switch (link_input) {
+        .object, .archive, .dso_exact => continue,
+        .res => unreachable,
+        .dso => {
+            self.classifyInputFile(link_input) catch |err|
+                diags.addParseError(link_input.path().?, "failed to parse input file: {s}", .{@errorName(err)});
+        },
+    };
+
     for (system_libs.items) |lib| {
-        self.classifyInputFile(lib.path, lib, false) catch |err| switch (err) {
-            error.UnknownFileType => try self.reportParseError(lib.path, "unknown file type for an input file", .{}),
-            else => |e| try self.reportParseError(
-                lib.path,
-                "unexpected error: parsing input file failed with error {s}",
-                .{@errorName(e)},
-            ),
-        };
+        switch (Compilation.classifyFileExt(lib.path.sub_path)) {
+            .shared_library => {
+                const dso_input = try link.openDsoInput(diags, lib.path, lib.needed, lib.weak, lib.reexport);
+                self.classifyInputFile(dso_input) catch |err|
+                    diags.addParseError(lib.path, "failed to parse input file: {s}", .{@errorName(err)});
+            },
+            .static_library => {
+                const archive_input = try link.openArchiveInput(diags, lib.path, lib.must_link, lib.hidden);
+                self.classifyInputFile(archive_input) catch |err|
+                    diags.addParseError(lib.path, "failed to parse input file: {s}", .{@errorName(err)});
+            },
+            else => unreachable,
+        }
     }
 
     // Finally, link against compiler_rt.
-    const compiler_rt_path: ?Path = blk: {
-        if (comp.compiler_rt_lib) |x| break :blk x.full_object_path;
-        if (comp.compiler_rt_obj) |x| break :blk x.full_object_path;
-        break :blk null;
-    };
-    if (compiler_rt_path) |path| {
-        self.classifyInputFile(path, .{ .path = path }, false) catch |err| switch (err) {
-            error.UnknownFileType => try self.reportParseError(path, "unknown file type for an input file", .{}),
-            else => |e| try self.reportParseError(
-                path,
-                "unexpected error: parsing input file failed with error {s}",
-                .{@errorName(e)},
-            ),
-        };
+    if (comp.compiler_rt_lib) |crt_file| {
+        const path = crt_file.full_object_path;
+        self.classifyInputFile(try link.openArchiveInput(diags, path, false, false)) catch |err|
+            diags.addParseError(path, "failed to parse archive: {s}", .{@errorName(err)});
+    } else if (comp.compiler_rt_obj) |crt_file| {
+        const path = crt_file.full_object_path;
+        self.classifyInputFile(try link.openObjectInput(diags, path)) catch |err|
+            diags.addParseError(path, "failed to parse archive: {s}", .{@errorName(err)});
     }
 
     try self.parseInputFiles();
     self.parseDependentDylibs() catch |err| {
         switch (err) {
             error.MissingLibraryDependencies => {},
-            else => |e| try self.reportUnexpectedError(
-                "unexpected error while parsing dependent libraries: {s}",
-                .{@errorName(e)},
-            ),
+            else => |e| return diags.fail("failed to parse dependent libraries: {s}", .{@errorName(e)}),
         }
     };
 
-    if (self.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
 
     {
         const index = @as(File.Index, @intCast(try self.files.addOne(gpa)));
@@ -502,10 +502,7 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
 
     self.checkDuplicates() catch |err| switch (err) {
         error.HasDuplicates => return error.FlushFailure,
-        else => |e| {
-            try self.reportUnexpectedError("unexpected error while checking for duplicate symbol definitions", .{});
-            return e;
-        },
+        else => |e| return diags.fail("failed to check for duplicate symbol definitions: {s}", .{@errorName(e)}),
     };
 
     self.markImportsAndExports();
@@ -520,10 +517,7 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
 
     self.scanRelocs() catch |err| switch (err) {
         error.HasUndefinedSymbols => return error.FlushFailure,
-        else => |e| {
-            try self.reportUnexpectedError("unexpected error while scanning relocations", .{});
-            return e;
-        },
+        else => |e| return diags.fail("failed to scan relocations: {s}", .{@errorName(e)}),
     };
 
     try self.initOutputSections();
@@ -623,9 +617,12 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
     }
 
     if (self.base.isRelocatable()) {
-        for (comp.objects) |obj| {
-            try argv.append(try obj.path.toString(arena));
-        }
+        for (comp.link_inputs) |link_input| switch (link_input) {
+            .object, .archive => |obj| try argv.append(try obj.path.toString(arena)),
+            .res => |res| try argv.append(try res.path.toString(arena)),
+            .dso => |dso| try argv.append(try dso.path.toString(arena)),
+            .dso_exact => |dso_exact| try argv.appendSlice(&.{ "-l", dso_exact.name }),
+        };
 
         for (comp.c_object_table.keys()) |key| {
             try argv.append(try key.status.success.object_path.toString(arena));
@@ -705,13 +702,15 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
             try argv.append("dynamic_lookup");
         }
 
-        for (comp.objects) |obj| {
-            // TODO: verify this
-            if (obj.must_link) {
-                try argv.append("-force_load");
-            }
-            try argv.append(try obj.path.toString(arena));
-        }
+        for (comp.link_inputs) |link_input| switch (link_input) {
+            .dso => continue, // handled below
+            .res => unreachable, // windows only
+            .object, .archive => |obj| {
+                if (obj.must_link) try argv.append("-force_load"); // TODO: verify this
+                try argv.append(try obj.path.toString(arena));
+            },
+            .dso_exact => |dso_exact| try argv.appendSlice(&.{ "-l", dso_exact.name }),
+        };
 
         for (comp.c_object_table.keys()) |key| {
             try argv.append(try key.status.success.object_path.toString(arena));
@@ -730,21 +729,25 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
             try argv.append(try comp.fuzzer_lib.?.full_object_path.toString(arena));
         }
 
-        for (self.lib_dirs) |lib_dir| {
-            const arg = try std.fmt.allocPrint(arena, "-L{s}", .{lib_dir});
+        for (self.lib_directories) |lib_directory| {
+            // TODO delete this, directories must instead be resolved by the frontend
+            const arg = try std.fmt.allocPrint(arena, "-L{s}", .{lib_directory.path orelse "."});
             try argv.append(arg);
         }
 
-        for (comp.system_libs.keys()) |l_name| {
-            const info = comp.system_libs.get(l_name).?;
-            const arg = if (info.needed)
-                try std.fmt.allocPrint(arena, "-needed-l{s}", .{l_name})
-            else if (info.weak)
-                try std.fmt.allocPrint(arena, "-weak-l{s}", .{l_name})
-            else
-                try std.fmt.allocPrint(arena, "-l{s}", .{l_name});
-            try argv.append(arg);
-        }
+        for (comp.link_inputs) |link_input| switch (link_input) {
+            .object, .archive, .dso_exact => continue, // handled above
+            .res => unreachable, // windows only
+            .dso => |dso| {
+                if (dso.needed) {
+                    try argv.appendSlice(&.{ "-needed-l", try dso.path.toString(arena) });
+                } else if (dso.weak) {
+                    try argv.appendSlice(&.{ "-weak-l", try dso.path.toString(arena) });
+                } else {
+                    try argv.appendSlice(&.{ "-l", try dso.path.toString(arena) });
+                }
+            },
+        };
 
         for (self.framework_dirs) |f_dir| {
             try argv.append("-F");
@@ -778,12 +781,15 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
     Compilation.dump_argv(argv.items);
 }
 
+/// TODO delete this, libsystem must be resolved when setting up the compilation pipeline
 pub fn resolveLibSystem(
     self: *MachO,
     arena: Allocator,
     comp: *Compilation,
     out_libs: anytype,
 ) !void {
+    const diags = &self.base.comp.link_diags;
+
     var test_path = std.ArrayList(u8).init(arena);
     var checked_paths = std.ArrayList([]const u8).init(arena);
 
@@ -799,11 +805,11 @@ pub fn resolveLibSystem(
             },
         };
 
-        for (self.lib_dirs) |dir| {
-            if (try accessLibPath(arena, &test_path, &checked_paths, dir, "System")) break :success;
+        for (self.lib_directories) |directory| {
+            if (try accessLibPath(arena, &test_path, &checked_paths, directory.path orelse ".", "System")) break :success;
         }
 
-        try self.reportMissingLibraryError(checked_paths.items, "unable to find libSystem system library", .{});
+        diags.addMissingLibraryError(checked_paths.items, "unable to find libSystem system library", .{});
         return error.MissingLibSystem;
     }
 
@@ -814,13 +820,14 @@ pub fn resolveLibSystem(
     });
 }
 
-pub fn classifyInputFile(self: *MachO, path: Path, lib: SystemLib, must_link: bool) !void {
+pub fn classifyInputFile(self: *MachO, input: link.Input) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
+    const path, const file = input.pathAndFile().?;
+    // TODO don't classify now, it's too late. The input file has already been classified
     log.debug("classifying input file {}", .{path});
 
-    const file = try path.root_dir.handle.openFile(path.sub_path, .{});
     const fh = try self.addFileHandle(file);
     var buffer: [Archive.SARMAG]u8 = undefined;
 
@@ -831,20 +838,21 @@ pub fn classifyInputFile(self: *MachO, path: Path, lib: SystemLib, must_link: bo
         if (h.magic != macho.MH_MAGIC_64) break :blk;
         switch (h.filetype) {
             macho.MH_OBJECT => try self.addObject(path, fh, offset),
-            macho.MH_DYLIB => _ = try self.addDylib(lib, true, fh, offset),
+            macho.MH_DYLIB => _ = try self.addDylib(.fromLinkInput(input), true, fh, offset),
             else => return error.UnknownFileType,
         }
         return;
     }
     if (readArMagic(file, offset, &buffer) catch null) |ar_magic| blk: {
         if (!mem.eql(u8, ar_magic, Archive.ARMAG)) break :blk;
-        try self.addArchive(lib, must_link, fh, fat_arch);
+        try self.addArchive(input.archive, fh, fat_arch);
         return;
     }
-    _ = try self.addTbd(lib, true, fh);
+    _ = try self.addTbd(.fromLinkInput(input), true, fh);
 }
 
 fn parseFatFile(self: *MachO, file: std.fs.File, path: Path) !?fat.Arch {
+    const diags = &self.base.comp.link_diags;
     const fat_h = fat.readFatHeader(file) catch return null;
     if (fat_h.magic != macho.FAT_MAGIC and fat_h.magic != macho.FAT_MAGIC_64) return null;
     var fat_archs_buffer: [2]fat.Arch = undefined;
@@ -853,10 +861,7 @@ fn parseFatFile(self: *MachO, file: std.fs.File, path: Path) !?fat.Arch {
     for (fat_archs) |arch| {
         if (arch.tag == cpu_arch) return arch;
     }
-    try self.reportParseError(path, "missing arch in universal file: expected {s}", .{
-        @tagName(cpu_arch),
-    });
-    return error.MissingCpuArch;
+    return diags.failParse(path, "missing arch in universal file: expected {s}", .{@tagName(cpu_arch)});
 }
 
 pub fn readMachHeader(file: std.fs.File, offset: usize) !macho.mach_header_64 {
@@ -901,22 +906,18 @@ pub fn parseInputFiles(self: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    const tp = self.base.comp.thread_pool;
-    var wg: WaitGroup = .{};
+    const diags = &self.base.comp.link_diags;
 
     {
-        wg.reset();
-        defer wg.wait();
-
         for (self.objects.items) |index| {
-            tp.spawnWg(&wg, parseInputFileWorker, .{ self, self.getFile(index).? });
+            parseInputFileWorker(self, self.getFile(index).?);
         }
         for (self.dylibs.items) |index| {
-            tp.spawnWg(&wg, parseInputFileWorker, .{ self, self.getFile(index).? });
+            parseInputFileWorker(self, self.getFile(index).?);
         }
     }
 
-    if (self.has_errors.swap(false, .seq_cst)) return error.FlushFailure;
+    if (diags.hasErrors()) return error.LinkFailure;
 }
 
 fn parseInputFileWorker(self: *MachO, file: File) void {
@@ -928,13 +929,13 @@ fn parseInputFileWorker(self: *MachO, file: File) void {
             error.InvalidMachineType,
             error.InvalidTarget,
             => {}, // already reported
+
             else => |e| self.reportParseError2(file.getIndex(), "unexpected error: parsing input file failed with error {s}", .{@errorName(e)}) catch {},
         }
-        _ = self.has_errors.swap(true, .seq_cst);
     };
 }
 
-fn addArchive(self: *MachO, lib: SystemLib, must_link: bool, handle: File.HandleIndex, fat_arch: ?fat.Arch) !void {
+fn addArchive(self: *MachO, lib: link.Input.Object, handle: File.HandleIndex, fat_arch: ?fat.Arch) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -949,7 +950,7 @@ fn addArchive(self: *MachO, lib: SystemLib, must_link: bool, handle: File.Handle
         self.files.set(index, .{ .object = unpacked });
         const object = &self.files.items(.data)[index].object;
         object.index = index;
-        object.alive = must_link or lib.needed; // TODO: or self.options.all_load;
+        object.alive = lib.must_link; // TODO: or self.options.all_load;
         object.hidden = lib.hidden;
         try self.objects.append(gpa, index);
     }
@@ -1024,6 +1025,7 @@ fn isHoisted(self: *MachO, install_name: []const u8) bool {
     return false;
 }
 
+/// TODO delete this, libraries must be instead resolved when instantiating the compilation pipeline
 fn accessLibPath(
     arena: Allocator,
     test_path: *std.ArrayList(u8),
@@ -1082,9 +1084,11 @@ fn parseDependentDylibs(self: *MachO) !void {
     if (self.dylibs.items.len == 0) return;
 
     const gpa = self.base.comp.gpa;
-    const lib_dirs = self.lib_dirs;
     const framework_dirs = self.framework_dirs;
 
+    // TODO delete this, directories must instead be resolved by the frontend
+    const lib_directories = self.lib_directories;
+
     var arena_alloc = std.heap.ArenaAllocator.init(gpa);
     defer arena_alloc.deinit();
     const arena = arena_alloc.allocator();
@@ -1125,9 +1129,9 @@ fn parseDependentDylibs(self: *MachO) !void {
 
                     // Library
                     const lib_name = eatPrefix(stem, "lib") orelse stem;
-                    for (lib_dirs) |dir| {
+                    for (lib_directories) |lib_directory| {
                         test_path.clearRetainingCapacity();
-                        if (try accessLibPath(arena, &test_path, &checked_paths, dir, lib_name)) break :full_path test_path.items;
+                        if (try accessLibPath(arena, &test_path, &checked_paths, lib_directory.path orelse ".", lib_name)) break :full_path test_path.items;
                     }
                 }
 
@@ -1295,19 +1299,16 @@ fn markLive(self: *MachO) void {
 }
 
 fn convertTentativeDefsAndResolveSpecialSymbols(self: *MachO) !void {
-    const tp = self.base.comp.thread_pool;
-    var wg: WaitGroup = .{};
+    const diags = &self.base.comp.link_diags;
     {
-        wg.reset();
-        defer wg.wait();
         for (self.objects.items) |index| {
-            tp.spawnWg(&wg, convertTentativeDefinitionsWorker, .{ self, self.getFile(index).?.object });
+            convertTentativeDefinitionsWorker(self, self.getFile(index).?.object);
         }
         if (self.getInternalObject()) |obj| {
-            tp.spawnWg(&wg, resolveSpecialSymbolsWorker, .{ self, obj });
+            resolveSpecialSymbolsWorker(self, obj);
         }
     }
-    if (self.has_errors.swap(false, .seq_cst)) return error.FlushFailure;
+    if (diags.hasErrors()) return error.LinkFailure;
 }
 
 fn convertTentativeDefinitionsWorker(self: *MachO, object: *Object) void {
@@ -1319,26 +1320,19 @@ fn convertTentativeDefinitionsWorker(self: *MachO, object: *Object) void {
             "unexpected error occurred while converting tentative symbols into defined symbols: {s}",
             .{@errorName(err)},
         ) catch {};
-        _ = self.has_errors.swap(true, .seq_cst);
     };
 }
 
 fn resolveSpecialSymbolsWorker(self: *MachO, obj: *InternalObject) void {
     const tracy = trace(@src());
     defer tracy.end();
-    obj.resolveBoundarySymbols(self) catch |err| {
-        self.reportUnexpectedError("unexpected error occurred while resolving boundary symbols: {s}", .{
-            @errorName(err),
-        }) catch {};
-        _ = self.has_errors.swap(true, .seq_cst);
-        return;
-    };
-    obj.resolveObjcMsgSendSymbols(self) catch |err| {
-        self.reportUnexpectedError("unexpected error occurred while resolving ObjC msgsend stubs: {s}", .{
-            @errorName(err),
-        }) catch {};
-        _ = self.has_errors.swap(true, .seq_cst);
-    };
+
+    const diags = &self.base.comp.link_diags;
+
+    obj.resolveBoundarySymbols(self) catch |err|
+        return diags.addError("failed to resolve boundary symbols: {s}", .{@errorName(err)});
+    obj.resolveObjcMsgSendSymbols(self) catch |err|
+        return diags.addError("failed to resolve ObjC msgsend stubs: {s}", .{@errorName(err)});
 }
 
 pub fn dedupLiterals(self: *MachO) !void {
@@ -1359,19 +1353,15 @@ pub fn dedupLiterals(self: *MachO) !void {
         try object.resolveLiterals(&lp, self);
     }
 
-    const tp = self.base.comp.thread_pool;
-    var wg: WaitGroup = .{};
     {
-        wg.reset();
-        defer wg.wait();
         if (self.getZigObject()) |zo| {
-            tp.spawnWg(&wg, File.dedupLiterals, .{ zo.asFile(), lp, self });
+            File.dedupLiterals(zo.asFile(), lp, self);
         }
         for (self.objects.items) |index| {
-            tp.spawnWg(&wg, File.dedupLiterals, .{ self.getFile(index).?, lp, self });
+            File.dedupLiterals(self.getFile(index).?, lp, self);
         }
         if (self.getInternalObject()) |object| {
-            tp.spawnWg(&wg, File.dedupLiterals, .{ object.asFile(), lp, self });
+            File.dedupLiterals(object.asFile(), lp, self);
         }
     }
 }
@@ -1389,23 +1379,21 @@ fn checkDuplicates(self: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    const tp = self.base.comp.thread_pool;
-    var wg: WaitGroup = .{};
+    const diags = &self.base.comp.link_diags;
+
     {
-        wg.reset();
-        defer wg.wait();
         if (self.getZigObject()) |zo| {
-            tp.spawnWg(&wg, checkDuplicatesWorker, .{ self, zo.asFile() });
+            checkDuplicatesWorker(self, zo.asFile());
         }
         for (self.objects.items) |index| {
-            tp.spawnWg(&wg, checkDuplicatesWorker, .{ self, self.getFile(index).? });
+            checkDuplicatesWorker(self, self.getFile(index).?);
         }
         if (self.getInternalObject()) |obj| {
-            tp.spawnWg(&wg, checkDuplicatesWorker, .{ self, obj.asFile() });
+            checkDuplicatesWorker(self, obj.asFile());
         }
     }
 
-    if (self.has_errors.swap(false, .seq_cst)) return error.FlushFailure;
+    if (diags.hasErrors()) return error.LinkFailure;
 
     try self.reportDuplicates();
 }
@@ -1417,7 +1405,6 @@ fn checkDuplicatesWorker(self: *MachO, file: File) void {
         self.reportParseError2(file.getIndex(), "failed to check for duplicate definitions: {s}", .{
             @errorName(err),
         }) catch {};
-        _ = self.has_errors.swap(true, .seq_cst);
     };
 }
 
@@ -1459,25 +1446,21 @@ fn scanRelocs(self: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    const tp = self.base.comp.thread_pool;
-    var wg: WaitGroup = .{};
+    const diags = &self.base.comp.link_diags;
 
     {
-        wg.reset();
-        defer wg.wait();
-
         if (self.getZigObject()) |zo| {
-            tp.spawnWg(&wg, scanRelocsWorker, .{ self, zo.asFile() });
+            scanRelocsWorker(self, zo.asFile());
         }
         for (self.objects.items) |index| {
-            tp.spawnWg(&wg, scanRelocsWorker, .{ self, self.getFile(index).? });
+            scanRelocsWorker(self, self.getFile(index).?);
         }
         if (self.getInternalObject()) |obj| {
-            tp.spawnWg(&wg, scanRelocsWorker, .{ self, obj.asFile() });
+            scanRelocsWorker(self, obj.asFile());
         }
     }
 
-    if (self.has_errors.swap(false, .seq_cst)) return error.FlushFailure;
+    if (diags.hasErrors()) return error.LinkFailure;
 
     if (self.getInternalObject()) |obj| {
         try obj.checkUndefs(self);
@@ -1503,7 +1486,6 @@ fn scanRelocsWorker(self: *MachO, file: File) void {
         self.reportParseError2(file.getIndex(), "failed to scan relocations: {s}", .{
             @errorName(err),
         }) catch {};
-        _ = self.has_errors.swap(true, .seq_cst);
     };
 }
 
@@ -1527,6 +1509,7 @@ fn reportUndefs(self: *MachO) !void {
     if (self.undefs.keys().len == 0) return; // Nothing to do
 
     const gpa = self.base.comp.gpa;
+    const diags = &self.base.comp.link_diags;
     const max_notes = 4;
 
     // We will sort by name, and then by file to ensure deterministic output.
@@ -1558,7 +1541,7 @@ fn reportUndefs(self: *MachO) !void {
             break :nnotes @min(nnotes, max_notes) + @intFromBool(nnotes > max_notes);
         };
 
-        var err = try self.base.addErrorWithNotes(nnotes);
+        var err = try diags.addErrorWithNotes(nnotes);
         try err.addMsg("undefined symbol: {s}", .{undef_sym.getName(self)});
 
         switch (notes) {
@@ -1908,6 +1891,7 @@ fn calcSectionSizes(self: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
+    const diags = &self.base.comp.link_diags;
     const cpu_arch = self.getTarget().cpu.arch;
 
     if (self.data_sect_index) |idx| {
@@ -1916,42 +1900,38 @@ fn calcSectionSizes(self: *MachO) !void {
         header.@"align" = 3;
     }
 
-    const tp = self.base.comp.thread_pool;
-    var wg: WaitGroup = .{};
     {
-        wg.reset();
-        defer wg.wait();
         const slice = self.sections.slice();
         for (slice.items(.header), slice.items(.atoms), 0..) |header, atoms, i| {
             if (atoms.items.len == 0) continue;
             if (self.requiresThunks() and header.isCode()) continue;
-            tp.spawnWg(&wg, calcSectionSizeWorker, .{ self, @as(u8, @intCast(i)) });
+            calcSectionSizeWorker(self, @as(u8, @intCast(i)));
         }
 
         if (self.requiresThunks()) {
             for (slice.items(.header), slice.items(.atoms), 0..) |header, atoms, i| {
                 if (!header.isCode()) continue;
                 if (atoms.items.len == 0) continue;
-                tp.spawnWg(&wg, createThunksWorker, .{ self, @as(u8, @intCast(i)) });
+                createThunksWorker(self, @as(u8, @intCast(i)));
             }
         }
 
         // At this point, we can also calculate most of the symtab and data-in-code linkedit section sizes
         if (self.getZigObject()) |zo| {
-            tp.spawnWg(&wg, File.calcSymtabSize, .{ zo.asFile(), self });
+            File.calcSymtabSize(zo.asFile(), self);
         }
         for (self.objects.items) |index| {
-            tp.spawnWg(&wg, File.calcSymtabSize, .{ self.getFile(index).?, self });
+            File.calcSymtabSize(self.getFile(index).?, self);
         }
         for (self.dylibs.items) |index| {
-            tp.spawnWg(&wg, File.calcSymtabSize, .{ self.getFile(index).?, self });
+            File.calcSymtabSize(self.getFile(index).?, self);
         }
         if (self.getInternalObject()) |obj| {
-            tp.spawnWg(&wg, File.calcSymtabSize, .{ obj.asFile(), self });
+            File.calcSymtabSize(obj.asFile(), self);
         }
     }
 
-    if (self.has_errors.swap(false, .seq_cst)) return error.FlushFailure;
+    if (diags.hasErrors()) return error.LinkFailure;
 
     try self.calcSymtabSize();
 
@@ -2003,6 +1983,9 @@ fn calcSectionSizes(self: *MachO) !void {
 fn calcSectionSizeWorker(self: *MachO, sect_id: u8) void {
     const tracy = trace(@src());
     defer tracy.end();
+
+    const diags = &self.base.comp.link_diags;
+
     const doWork = struct {
         fn doWork(macho_file: *MachO, header: *macho.section_64, atoms: []const Ref) !void {
             for (atoms) |ref| {
@@ -2020,26 +2003,21 @@ fn calcSectionSizeWorker(self: *MachO, sect_id: u8) void {
     const header = &slice.items(.header)[sect_id];
     const atoms = slice.items(.atoms)[sect_id].items;
     doWork(self, header, atoms) catch |err| {
-        self.reportUnexpectedError("failed to calculate size of section '{s},{s}': {s}", .{
-            header.segName(),
-            header.sectName(),
-            @errorName(err),
-        }) catch {};
-        _ = self.has_errors.swap(true, .seq_cst);
+        try diags.addError("failed to calculate size of section '{s},{s}': {s}", .{
+            header.segName(), header.sectName(), @errorName(err),
+        });
     };
 }
 
 fn createThunksWorker(self: *MachO, sect_id: u8) void {
     const tracy = trace(@src());
     defer tracy.end();
+    const diags = &self.base.comp.link_diags;
     self.createThunks(sect_id) catch |err| {
         const header = self.sections.items(.header)[sect_id];
-        self.reportUnexpectedError("failed to create thunks and calculate size of section '{s},{s}': {s}", .{
-            header.segName(),
-            header.sectName(),
-            @errorName(err),
-        }) catch {};
-        _ = self.has_errors.swap(true, .seq_cst);
+        diags.addError("failed to create thunks and calculate size of section '{s},{s}': {s}", .{
+            header.segName(), header.sectName(), @errorName(err),
+        });
     };
 }
 
@@ -2047,6 +2025,8 @@ fn generateUnwindInfo(self: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
+    const diags = &self.base.comp.link_diags;
+
     if (self.eh_frame_sect_index) |index| {
         const sect = &self.sections.items(.header)[index];
         sect.size = try eh_frame.calcSize(self);
@@ -2055,10 +2035,7 @@ fn generateUnwindInfo(self: *MachO) !void {
     if (self.unwind_info_sect_index) |index| {
         const sect = &self.sections.items(.header)[index];
         self.unwind_info.generate(self) catch |err| switch (err) {
-            error.TooManyPersonalities => return self.reportUnexpectedError(
-                "too many personalities in unwind info",
-                .{},
-            ),
+            error.TooManyPersonalities => return diags.fail("too many personalities in unwind info", .{}),
             else => |e| return e,
         };
         sect.size = self.unwind_info.calcSize();
@@ -2427,29 +2404,25 @@ fn writeSectionsAndUpdateLinkeditSizes(self: *MachO) !void {
     defer tracy.end();
 
     const gpa = self.base.comp.gpa;
+    const diags = &self.base.comp.link_diags;
 
     const cmd = self.symtab_cmd;
     try self.symtab.resize(gpa, cmd.nsyms);
     try self.strtab.resize(gpa, cmd.strsize);
     self.strtab.items[0] = 0;
 
-    const tp = self.base.comp.thread_pool;
-    var wg: WaitGroup = .{};
     {
-        wg.reset();
-        defer wg.wait();
-
         for (self.objects.items) |index| {
-            tp.spawnWg(&wg, writeAtomsWorker, .{ self, self.getFile(index).? });
+            writeAtomsWorker(self, self.getFile(index).?);
         }
         if (self.getZigObject()) |zo| {
-            tp.spawnWg(&wg, writeAtomsWorker, .{ self, zo.asFile() });
+            writeAtomsWorker(self, zo.asFile());
         }
         if (self.getInternalObject()) |obj| {
-            tp.spawnWg(&wg, writeAtomsWorker, .{ self, obj.asFile() });
+            writeAtomsWorker(self, obj.asFile());
         }
         for (self.thunks.items) |thunk| {
-            tp.spawnWg(&wg, writeThunkWorker, .{ self, thunk });
+            writeThunkWorker(self, thunk);
         }
 
         const slice = self.sections.slice();
@@ -2464,38 +2437,38 @@ fn writeSectionsAndUpdateLinkeditSizes(self: *MachO) !void {
         }) |maybe_sect_id| {
             if (maybe_sect_id) |sect_id| {
                 const out = slice.items(.out)[sect_id].items;
-                tp.spawnWg(&wg, writeSyntheticSectionWorker, .{ self, sect_id, out });
+                writeSyntheticSectionWorker(self, sect_id, out);
             }
         }
 
         if (self.la_symbol_ptr_sect_index) |_| {
-            tp.spawnWg(&wg, updateLazyBindSizeWorker, .{self});
+            updateLazyBindSizeWorker(self);
         }
 
-        tp.spawnWg(&wg, updateLinkeditSizeWorker, .{ self, .rebase });
-        tp.spawnWg(&wg, updateLinkeditSizeWorker, .{ self, .bind });
-        tp.spawnWg(&wg, updateLinkeditSizeWorker, .{ self, .weak_bind });
-        tp.spawnWg(&wg, updateLinkeditSizeWorker, .{ self, .export_trie });
-        tp.spawnWg(&wg, updateLinkeditSizeWorker, .{ self, .data_in_code });
+        updateLinkeditSizeWorker(self, .rebase);
+        updateLinkeditSizeWorker(self, .bind);
+        updateLinkeditSizeWorker(self, .weak_bind);
+        updateLinkeditSizeWorker(self, .export_trie);
+        updateLinkeditSizeWorker(self, .data_in_code);
 
         if (self.getZigObject()) |zo| {
-            tp.spawnWg(&wg, File.writeSymtab, .{ zo.asFile(), self, self });
+            File.writeSymtab(zo.asFile(), self, self);
         }
         for (self.objects.items) |index| {
-            tp.spawnWg(&wg, File.writeSymtab, .{ self.getFile(index).?, self, self });
+            File.writeSymtab(self.getFile(index).?, self, self);
         }
         for (self.dylibs.items) |index| {
-            tp.spawnWg(&wg, File.writeSymtab, .{ self.getFile(index).?, self, self });
+            File.writeSymtab(self.getFile(index).?, self, self);
         }
         if (self.getInternalObject()) |obj| {
-            tp.spawnWg(&wg, File.writeSymtab, .{ obj.asFile(), self, self });
+            File.writeSymtab(obj.asFile(), self, self);
         }
         if (self.requiresThunks()) for (self.thunks.items) |th| {
-            tp.spawnWg(&wg, Thunk.writeSymtab, .{ th, self, self });
+            Thunk.writeSymtab(th, self, self);
         };
     }
 
-    if (self.has_errors.swap(false, .seq_cst)) return error.FlushFailure;
+    if (diags.hasErrors()) return error.LinkFailure;
 }
 
 fn writeAtomsWorker(self: *MachO, file: File) void {
@@ -2505,13 +2478,15 @@ fn writeAtomsWorker(self: *MachO, file: File) void {
         self.reportParseError2(file.getIndex(), "failed to resolve relocations and write atoms: {s}", .{
             @errorName(err),
         }) catch {};
-        _ = self.has_errors.swap(true, .seq_cst);
     };
 }
 
 fn writeThunkWorker(self: *MachO, thunk: Thunk) void {
     const tracy = trace(@src());
     defer tracy.end();
+
+    const diags = &self.base.comp.link_diags;
+
     const doWork = struct {
         fn doWork(th: Thunk, buffer: []u8, macho_file: *MachO) !void {
             const off = math.cast(usize, th.value) orelse return error.Overflow;
@@ -2522,8 +2497,7 @@ fn writeThunkWorker(self: *MachO, thunk: Thunk) void {
     }.doWork;
     const out = self.sections.items(.out)[thunk.out_n_sect].items;
     doWork(thunk, out, self) catch |err| {
-        self.reportUnexpectedError("failed to write contents of thunk: {s}", .{@errorName(err)}) catch {};
-        _ = self.has_errors.swap(true, .seq_cst);
+        diags.addError("failed to write contents of thunk: {s}", .{@errorName(err)});
     };
 }
 
@@ -2531,6 +2505,8 @@ fn writeSyntheticSectionWorker(self: *MachO, sect_id: u8, out: []u8) void {
     const tracy = trace(@src());
     defer tracy.end();
 
+    const diags = &self.base.comp.link_diags;
+
     const Tag = enum {
         eh_frame,
         unwind_info,
@@ -2575,18 +2551,18 @@ fn writeSyntheticSectionWorker(self: *MachO, sect_id: u8, out: []u8) void {
         unreachable;
     };
     doWork(self, tag, out) catch |err| {
-        self.reportUnexpectedError("could not write section '{s},{s}': {s}", .{
-            header.segName(),
-            header.sectName(),
-            @errorName(err),
-        }) catch {};
-        _ = self.has_errors.swap(true, .seq_cst);
+        diags.addError("could not write section '{s},{s}': {s}", .{
+            header.segName(), header.sectName(), @errorName(err),
+        });
     };
 }
 
 fn updateLazyBindSizeWorker(self: *MachO) void {
     const tracy = trace(@src());
     defer tracy.end();
+
+    const diags = &self.base.comp.link_diags;
+
     const doWork = struct {
         fn doWork(macho_file: *MachO) !void {
             try macho_file.lazy_bind_section.updateSize(macho_file);
@@ -2596,12 +2572,8 @@ fn updateLazyBindSizeWorker(self: *MachO) void {
             try macho_file.stubs_helper.write(macho_file, stream.writer());
         }
     }.doWork;
-    doWork(self) catch |err| {
-        self.reportUnexpectedError("could not calculate size of lazy binding section: {s}", .{
-            @errorName(err),
-        }) catch {};
-        _ = self.has_errors.swap(true, .seq_cst);
-    };
+    doWork(self) catch |err|
+        diags.addError("could not calculate size of lazy binding section: {s}", .{@errorName(err)});
 }
 
 pub fn updateLinkeditSizeWorker(self: *MachO, tag: enum {
@@ -2611,6 +2583,7 @@ pub fn updateLinkeditSizeWorker(self: *MachO, tag: enum {
     export_trie,
     data_in_code,
 }) void {
+    const diags = &self.base.comp.link_diags;
     const res = switch (tag) {
         .rebase => self.rebase_section.updateSize(self),
         .bind => self.bind_section.updateSize(self),
@@ -2618,13 +2591,8 @@ pub fn updateLinkeditSizeWorker(self: *MachO, tag: enum {
         .export_trie => self.export_trie.updateSize(self),
         .data_in_code => self.data_in_code.updateSize(self),
     };
-    res catch |err| {
-        self.reportUnexpectedError("could not calculate size of {s} section: {s}", .{
-            @tagName(tag),
-            @errorName(err),
-        }) catch {};
-        _ = self.has_errors.swap(true, .seq_cst);
-    };
+    res catch |err|
+        diags.addError("could not calculate size of {s} section: {s}", .{ @tagName(tag), @errorName(err) });
 }
 
 fn writeSectionsToFile(self: *MachO) !void {
@@ -3432,6 +3400,7 @@ pub fn growSection(self: *MachO, sect_index: u8, needed_size: u64) !void {
 }
 
 fn growSectionNonRelocatable(self: *MachO, sect_index: u8, needed_size: u64) !void {
+    const diags = &self.base.comp.link_diags;
     const sect = &self.sections.items(.header)[sect_index];
 
     const seg_id = self.sections.items(.segment_id)[sect_index];
@@ -3467,7 +3436,7 @@ fn growSectionNonRelocatable(self: *MachO, sect_index: u8, needed_size: u64) !vo
 
     const mem_capacity = self.allocatedSizeVirtual(seg.vmaddr);
     if (needed_size > mem_capacity) {
-        var err = try self.base.addErrorWithNotes(2);
+        var err = try diags.addErrorWithNotes(2);
         try err.addMsg("fatal linker error: cannot expand segment seg({d})({s}) in virtual memory", .{
             seg_id,
             seg.segName(),
@@ -3766,41 +3735,18 @@ pub fn eatPrefix(path: []const u8, prefix: []const u8) ?[]const u8 {
     return null;
 }
 
-pub fn reportParseError(
-    self: *MachO,
-    path: Path,
-    comptime format: []const u8,
-    args: anytype,
-) error{OutOfMemory}!void {
-    var err = try self.base.addErrorWithNotes(1);
-    try err.addMsg(format, args);
-    try err.addNote("while parsing {}", .{path});
-}
-
 pub fn reportParseError2(
     self: *MachO,
     file_index: File.Index,
     comptime format: []const u8,
     args: anytype,
 ) error{OutOfMemory}!void {
-    var err = try self.base.addErrorWithNotes(1);
+    const diags = &self.base.comp.link_diags;
+    var err = try diags.addErrorWithNotes(1);
     try err.addMsg(format, args);
     try err.addNote("while parsing {}", .{self.getFile(file_index).?.fmtPath()});
 }
 
-fn reportMissingLibraryError(
-    self: *MachO,
-    checked_paths: []const []const u8,
-    comptime format: []const u8,
-    args: anytype,
-) error{OutOfMemory}!void {
-    var err = try self.base.addErrorWithNotes(checked_paths.len);
-    try err.addMsg(format, args);
-    for (checked_paths) |path| {
-        try err.addNote("tried {s}", .{path});
-    }
-}
-
 fn reportMissingDependencyError(
     self: *MachO,
     parent: File.Index,
@@ -3809,7 +3755,8 @@ fn reportMissingDependencyError(
     comptime format: []const u8,
     args: anytype,
 ) error{OutOfMemory}!void {
-    var err = try self.base.addErrorWithNotes(2 + checked_paths.len);
+    const diags = &self.base.comp.link_diags;
+    var err = try diags.addErrorWithNotes(2 + checked_paths.len);
     try err.addMsg(format, args);
     try err.addNote("while resolving {s}", .{path});
     try err.addNote("a dependency of {}", .{self.getFile(parent).?.fmtPath()});
@@ -3825,18 +3772,13 @@ fn reportDependencyError(
     comptime format: []const u8,
     args: anytype,
 ) error{OutOfMemory}!void {
-    var err = try self.base.addErrorWithNotes(2);
+    const diags = &self.base.comp.link_diags;
+    var err = try diags.addErrorWithNotes(2);
     try err.addMsg(format, args);
     try err.addNote("while parsing {s}", .{path});
     try err.addNote("a dependency of {}", .{self.getFile(parent).?.fmtPath()});
 }
 
-pub fn reportUnexpectedError(self: *MachO, comptime format: []const u8, args: anytype) error{OutOfMemory}!void {
-    var err = try self.base.addErrorWithNotes(1);
-    try err.addMsg(format, args);
-    try err.addNote("please report this as a linker bug on https://github.com/ziglang/zig/issues/new/choose", .{});
-}
-
 fn reportDuplicates(self: *MachO) error{ HasDuplicates, OutOfMemory }!void {
     const tracy = trace(@src());
     defer tracy.end();
@@ -3844,6 +3786,7 @@ fn reportDuplicates(self: *MachO) error{ HasDuplicates, OutOfMemory }!void {
     if (self.dupes.keys().len == 0) return; // Nothing to do
 
     const gpa = self.base.comp.gpa;
+    const diags = &self.base.comp.link_diags;
     const max_notes = 3;
 
     // We will sort by name, and then by file to ensure deterministic output.
@@ -3861,7 +3804,7 @@ fn reportDuplicates(self: *MachO) error{ HasDuplicates, OutOfMemory }!void {
         const notes = self.dupes.get(key).?;
         const nnotes = @min(notes.items.len, max_notes) + @intFromBool(notes.items.len > max_notes);
 
-        var err = try self.base.addErrorWithNotes(nnotes + 1);
+        var err = try diags.addErrorWithNotes(nnotes + 1);
         try err.addMsg("duplicate symbol definition: {s}", .{sym.getName(self)});
         try err.addNote("defined by {}", .{sym.getFile(self).?.fmtPath()});
 
@@ -4458,6 +4401,24 @@ const SystemLib = struct {
     hidden: bool = false,
     reexport: bool = false,
     must_link: bool = false,
+
+    fn fromLinkInput(link_input: link.Input) SystemLib {
+        return switch (link_input) {
+            .dso_exact => unreachable,
+            .res => unreachable,
+            .object, .archive => |obj| .{
+                .path = obj.path,
+                .must_link = obj.must_link,
+                .hidden = obj.hidden,
+            },
+            .dso => |dso| .{
+                .path = dso.path,
+                .needed = dso.needed,
+                .weak = dso.weak,
+                .reexport = dso.reexport,
+            },
+        };
+    }
 };
 
 pub const SdkLayout = std.zig.LibCDirs.DarwinSdkLayout;
@@ -5395,17 +5356,16 @@ const Air = @import("../Air.zig");
 const Alignment = Atom.Alignment;
 const Allocator = mem.Allocator;
 const Archive = @import("MachO/Archive.zig");
-pub const Atom = @import("MachO/Atom.zig");
 const AtomicBool = std.atomic.Value(bool);
 const Bind = bind.Bind;
 const Cache = std.Build.Cache;
-const Path = Cache.Path;
 const CodeSignature = @import("MachO/CodeSignature.zig");
 const Compilation = @import("../Compilation.zig");
 const DataInCode = synthetic.DataInCode;
-pub const DebugSymbols = @import("MachO/DebugSymbols.zig");
+const Directory = Cache.Directory;
 const Dylib = @import("MachO/Dylib.zig");
 const ExportTrie = @import("MachO/dyld_info/Trie.zig");
+const Path = Cache.Path;
 const File = @import("MachO/file.zig").File;
 const GotSection = synthetic.GotSection;
 const Hash = std.hash.Wyhash;
@@ -5421,7 +5381,6 @@ const Md5 = std.crypto.hash.Md5;
 const Zcu = @import("../Zcu.zig");
 const InternPool = @import("../InternPool.zig");
 const Rebase = @import("MachO/dyld_info/Rebase.zig");
-pub const Relocation = @import("MachO/Relocation.zig");
 const StringTable = @import("StringTable.zig");
 const StubsSection = synthetic.StubsSection;
 const StubsHelperSection = synthetic.StubsHelperSection;
@@ -5430,7 +5389,6 @@ const Thunk = @import("MachO/Thunk.zig");
 const TlvPtrSection = synthetic.TlvPtrSection;
 const Value = @import("../Value.zig");
 const UnwindInfo = @import("MachO/UnwindInfo.zig");
-const WaitGroup = std.Thread.WaitGroup;
 const WeakBind = bind.WeakBind;
 const ZigObject = @import("MachO/ZigObject.zig");
 const dev = @import("../dev.zig");
diff --git a/zig/src/link/MachO/Archive.zig b/zig/src/link/MachO/Archive.zig
index ba3c66689b..9ad25d77c7 100644
--- a/zig/src/link/MachO/Archive.zig
+++ b/zig/src/link/MachO/Archive.zig
@@ -6,6 +6,7 @@ pub fn deinit(self: *Archive, allocator: Allocator) void {
 
 pub fn unpack(self: *Archive, macho_file: *MachO, path: Path, handle_index: File.HandleIndex, fat_arch: ?fat.Arch) !void {
     const gpa = macho_file.base.comp.gpa;
+    const diags = &macho_file.base.comp.link_diags;
 
     var arena = std.heap.ArenaAllocator.init(gpa);
     defer arena.deinit();
@@ -28,10 +29,9 @@ pub fn unpack(self: *Archive, macho_file: *MachO, path: Path, handle_index: File
         pos += @sizeOf(ar_hdr);
 
         if (!mem.eql(u8, &hdr.ar_fmag, ARFMAG)) {
-            try macho_file.reportParseError(path, "invalid header delimiter: expected '{s}', found '{s}'", .{
+            return diags.failParse(path, "invalid header delimiter: expected '{s}', found '{s}'", .{
                 std.fmt.fmtSliceEscapeLower(ARFMAG), std.fmt.fmtSliceEscapeLower(&hdr.ar_fmag),
             });
-            return error.MalformedArchive;
         }
 
         var hdr_size = try hdr.size();
diff --git a/zig/src/link/MachO/Atom.zig b/zig/src/link/MachO/Atom.zig
index 6e3b4311eb..f8bf9c37e7 100644
--- a/zig/src/link/MachO/Atom.zig
+++ b/zig/src/link/MachO/Atom.zig
@@ -893,6 +893,7 @@ fn resolveRelocInner(
 const x86_64 = struct {
     fn relaxGotLoad(self: Atom, code: []u8, rel: Relocation, macho_file: *MachO) ResolveError!void {
         dev.check(.x86_64_backend);
+        const diags = &macho_file.base.comp.link_diags;
         const old_inst = disassemble(code) orelse return error.RelaxFail;
         switch (old_inst.encoding.mnemonic) {
             .mov => {
@@ -901,7 +902,7 @@ const x86_64 = struct {
                 encode(&.{inst}, code) catch return error.RelaxFail;
             },
             else => |x| {
-                var err = try macho_file.base.addErrorWithNotes(2);
+                var err = try diags.addErrorWithNotes(2);
                 try err.addMsg("{s}: 0x{x}: 0x{x}: failed to relax relocation of type {}", .{
                     self.getName(macho_file),
                     self.getAddress(macho_file),
diff --git a/zig/src/link/MachO/Object.zig b/zig/src/link/MachO/Object.zig
index 9181112f2a..3efc0a1e5a 100644
--- a/zig/src/link/MachO/Object.zig
+++ b/zig/src/link/MachO/Object.zig
@@ -308,7 +308,7 @@ fn initSubsections(self: *Object, allocator: Allocator, nlists: anytype) !void {
         } else nlists.len;
 
         if (nlist_start == nlist_end or nlists[nlist_start].nlist.n_value > sect.addr) {
-            const name = try std.fmt.allocPrintZ(allocator, "{s}${s}", .{ sect.segName(), sect.sectName() });
+            const name = try std.fmt.allocPrintZ(allocator, "{s}${s}$begin", .{ sect.segName(), sect.sectName() });
             defer allocator.free(name);
             const size = if (nlist_start == nlist_end) sect.size else nlists[nlist_start].nlist.n_value - sect.addr;
             const atom_index = try self.addAtom(allocator, .{
@@ -359,6 +359,25 @@ fn initSubsections(self: *Object, allocator: Allocator, nlists: anytype) !void {
                 self.symtab.items(.size)[nlists[i].idx] = size;
             }
         }
+
+        // Some compilers such as Go reference the end of a section (addr + size)
+        // which cannot be contained in any non-zero atom (since then this atom
+        // would exceed section boundaries). In order to facilitate this behaviour,
+        // we create a dummy zero-sized atom at section end (addr + size).
+        const name = try std.fmt.allocPrintZ(allocator, "{s}${s}$end", .{ sect.segName(), sect.sectName() });
+        defer allocator.free(name);
+        const atom_index = try self.addAtom(allocator, .{
+            .name = try self.addString(allocator, name),
+            .n_sect = @intCast(n_sect),
+            .off = sect.size,
+            .size = 0,
+            .alignment = sect.@"align",
+        });
+        try self.atoms_indexes.append(allocator, atom_index);
+        try subsections.append(allocator, .{
+            .atom = atom_index,
+            .off = sect.size,
+        });
     }
 }
 
@@ -743,7 +762,7 @@ pub fn findAtom(self: Object, addr: u64) ?Atom.Index {
     const slice = self.sections.slice();
     for (slice.items(.header), slice.items(.subsections), 0..) |sect, subs, n_sect| {
         if (subs.items.len == 0) continue;
-        if (sect.addr == addr) return subs.items[0].atom;
+        if (addr == sect.addr) return subs.items[0].atom;
         if (sect.addr < addr and addr < sect.addr + sect.size) {
             return self.findAtomInSection(addr, @intCast(n_sect));
         }
@@ -794,7 +813,19 @@ fn linkNlistToAtom(self: *Object, macho_file: *MachO) !void {
     defer tracy.end();
     for (self.symtab.items(.nlist), self.symtab.items(.atom)) |nlist, *atom| {
         if (!nlist.stab() and nlist.sect()) {
-            if (self.findAtomInSection(nlist.n_value, nlist.n_sect - 1)) |atom_index| {
+            const sect = self.sections.items(.header)[nlist.n_sect - 1];
+            const subs = self.sections.items(.subsections)[nlist.n_sect - 1].items;
+            if (nlist.n_value == sect.addr) {
+                // If the nlist address is the start of the section, return the first atom
+                // since it is guaranteed to always start at section's start address.
+                atom.* = subs[0].atom;
+            } else if (nlist.n_value == sect.addr + sect.size) {
+                // If the nlist address matches section's boundary (address + size),
+                // return the last atom since it is guaranteed to always point
+                // at the section's end boundary.
+                atom.* = subs[subs.len - 1].atom;
+            } else if (self.findAtomInSection(nlist.n_value, nlist.n_sect - 1)) |atom_index| {
+                // In all other cases, do a binary search to find a matching atom for the symbol.
                 atom.* = atom_index;
             } else {
                 try macho_file.reportParseError2(self.index, "symbol {s} not attached to any (sub)section", .{
diff --git a/zig/src/link/MachO/ZigObject.zig b/zig/src/link/MachO/ZigObject.zig
index 2a89e5da56..097be1bc70 100644
--- a/zig/src/link/MachO/ZigObject.zig
+++ b/zig/src/link/MachO/ZigObject.zig
@@ -364,6 +364,8 @@ pub fn scanRelocs(self: *ZigObject, macho_file: *MachO) !void {
 
 pub fn resolveRelocs(self: *ZigObject, macho_file: *MachO) !void {
     const gpa = macho_file.base.comp.gpa;
+    const diags = &macho_file.base.comp.link_diags;
+
     var has_error = false;
     for (self.getAtoms()) |atom_index| {
         const atom = self.getAtom(atom_index) orelse continue;
@@ -379,17 +381,12 @@ pub fn resolveRelocs(self: *ZigObject, macho_file: *MachO) !void {
         defer gpa.free(code);
         self.getAtomData(macho_file, atom.*, code) catch |err| {
             switch (err) {
-                error.InputOutput => {
-                    try macho_file.reportUnexpectedError("fetching code for '{s}' failed", .{
-                        atom.getName(macho_file),
-                    });
-                },
-                else => |e| {
-                    try macho_file.reportUnexpectedError("unexpected error while fetching code for '{s}': {s}", .{
-                        atom.getName(macho_file),
-                        @errorName(e),
-                    });
-                },
+                error.InputOutput => return diags.fail("fetching code for '{s}' failed", .{
+                    atom.getName(macho_file),
+                }),
+                else => |e| return diags.fail("failed to fetch code for '{s}': {s}", .{
+                    atom.getName(macho_file), @errorName(e),
+                }),
             }
             has_error = true;
             continue;
@@ -398,9 +395,7 @@ pub fn resolveRelocs(self: *ZigObject, macho_file: *MachO) !void {
         atom.resolveRelocs(macho_file, code) catch |err| {
             switch (err) {
                 error.ResolveFailed => {},
-                else => |e| {
-                    try macho_file.reportUnexpectedError("unexpected error while resolving relocations: {s}", .{@errorName(e)});
-                },
+                else => |e| return diags.fail("failed to resolve relocations: {s}", .{@errorName(e)}),
             }
             has_error = true;
             continue;
@@ -426,6 +421,7 @@ pub fn calcNumRelocs(self: *ZigObject, macho_file: *MachO) void {
 
 pub fn writeRelocs(self: *ZigObject, macho_file: *MachO) !void {
     const gpa = macho_file.base.comp.gpa;
+    const diags = &macho_file.base.comp.link_diags;
 
     for (self.getAtoms()) |atom_index| {
         const atom = self.getAtom(atom_index) orelse continue;
@@ -439,21 +435,8 @@ pub fn writeRelocs(self: *ZigObject, macho_file: *MachO) !void {
         const atom_size = std.math.cast(usize, atom.size) orelse return error.Overflow;
         const code = try gpa.alloc(u8, atom_size);
         defer gpa.free(code);
-        self.getAtomData(macho_file, atom.*, code) catch |err| switch (err) {
-            error.InputOutput => {
-                try macho_file.reportUnexpectedError("fetching code for '{s}' failed", .{
-                    atom.getName(macho_file),
-                });
-                return error.FlushFailure;
-            },
-            else => |e| {
-                try macho_file.reportUnexpectedError("unexpected error while fetching code for '{s}': {s}", .{
-                    atom.getName(macho_file),
-                    @errorName(e),
-                });
-                return error.FlushFailure;
-            },
-        };
+        self.getAtomData(macho_file, atom.*, code) catch |err|
+            return diags.fail("failed to fetch code for '{s}': {s}", .{ atom.getName(macho_file), @errorName(err) });
         const file_offset = header.offset + atom.value;
         try atom.writeRelocs(macho_file, code, relocs[extra.rel_out_index..][0..extra.rel_out_count]);
         try macho_file.base.file.?.pwriteAll(code, file_offset);
@@ -979,9 +962,11 @@ fn updateNavCode(
 
     log.debug("updateNavCode {} 0x{x}", .{ nav.fqn.fmt(ip), nav_index });
 
-    const required_alignment = pt.navAlignment(nav_index).max(
-        target_util.minFunctionAlignment(zcu.navFileScope(nav_index).mod.resolved_target.result),
-    );
+    const target = zcu.navFileScope(nav_index).mod.resolved_target.result;
+    const required_alignment = switch (pt.navAlignment(nav_index)) {
+        .none => target_util.defaultFunctionAlignment(target),
+        else => |a| a.maxStrict(target_util.minFunctionAlignment(target)),
+    };
 
     const sect = &macho_file.sections.items(.header)[sect_index];
     const sym = &self.symbols.items[sym_index];
diff --git a/zig/src/link/MachO/relocatable.zig b/zig/src/link/MachO/relocatable.zig
index 91bb295ed6..497969ab90 100644
--- a/zig/src/link/MachO/relocatable.zig
+++ b/zig/src/link/MachO/relocatable.zig
@@ -1,17 +1,18 @@
 pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?Path) link.File.FlushError!void {
     const gpa = macho_file.base.comp.gpa;
+    const diags = &macho_file.base.comp.link_diags;
 
     // TODO: "positional arguments" is a CLI concept, not a linker concept. Delete this unnecessary array list.
-    var positionals = std.ArrayList(Compilation.LinkObject).init(gpa);
+    var positionals = std.ArrayList(link.Input).init(gpa);
     defer positionals.deinit();
-    try positionals.ensureUnusedCapacity(comp.objects.len);
-    positionals.appendSliceAssumeCapacity(comp.objects);
+    try positionals.ensureUnusedCapacity(comp.link_inputs.len);
+    positionals.appendSliceAssumeCapacity(comp.link_inputs);
 
     for (comp.c_object_table.keys()) |key| {
-        try positionals.append(.{ .path = key.status.success.object_path });
+        try positionals.append(try link.openObjectInput(diags, key.status.success.object_path));
     }
 
-    if (module_obj_path) |path| try positionals.append(.{ .path = path });
+    if (module_obj_path) |path| try positionals.append(try link.openObjectInput(diags, path));
 
     if (macho_file.getZigObject() == null and positionals.items.len == 1) {
         // Instead of invoking a full-blown `-r` mode on the input which sadly will strip all
@@ -19,7 +20,7 @@ pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?Pat
         // the *only* input file over.
         // TODO: in the future, when we implement `dsymutil` alternative directly in the Zig
         // compiler, investigate if we can get rid of this `if` prong here.
-        const path = positionals.items[0].path;
+        const path = positionals.items[0].path().?;
         const in_file = try path.root_dir.handle.openFile(path.sub_path, .{});
         const stat = try in_file.stat();
         const amt = try in_file.copyRangeAll(0, macho_file.base.file.?, 0, stat.size);
@@ -27,22 +28,16 @@ pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?Pat
         return;
     }
 
-    for (positionals.items) |obj| {
-        macho_file.classifyInputFile(obj.path, .{ .path = obj.path }, obj.must_link) catch |err| switch (err) {
-            error.UnknownFileType => try macho_file.reportParseError(obj.path, "unknown file type for an input file", .{}),
-            else => |e| try macho_file.reportParseError(
-                obj.path,
-                "unexpected error: reading input file failed with error {s}",
-                .{@errorName(e)},
-            ),
-        };
+    for (positionals.items) |link_input| {
+        macho_file.classifyInputFile(link_input) catch |err|
+            diags.addParseError(link_input.path().?, "failed to read input file: {s}", .{@errorName(err)});
     }
 
-    if (macho_file.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
 
     try macho_file.parseInputFiles();
 
-    if (macho_file.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
 
     try macho_file.resolveSymbols();
     try macho_file.dedupLiterals();
@@ -75,39 +70,34 @@ pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?Pat
 
 pub fn flushStaticLib(macho_file: *MachO, comp: *Compilation, module_obj_path: ?Path) link.File.FlushError!void {
     const gpa = comp.gpa;
+    const diags = &macho_file.base.comp.link_diags;
 
-    var positionals = std.ArrayList(Compilation.LinkObject).init(gpa);
+    var positionals = std.ArrayList(link.Input).init(gpa);
     defer positionals.deinit();
 
-    try positionals.ensureUnusedCapacity(comp.objects.len);
-    positionals.appendSliceAssumeCapacity(comp.objects);
+    try positionals.ensureUnusedCapacity(comp.link_inputs.len);
+    positionals.appendSliceAssumeCapacity(comp.link_inputs);
 
     for (comp.c_object_table.keys()) |key| {
-        try positionals.append(.{ .path = key.status.success.object_path });
+        try positionals.append(try link.openObjectInput(diags, key.status.success.object_path));
     }
 
-    if (module_obj_path) |path| try positionals.append(.{ .path = path });
+    if (module_obj_path) |path| try positionals.append(try link.openObjectInput(diags, path));
 
     if (comp.include_compiler_rt) {
-        try positionals.append(.{ .path = comp.compiler_rt_obj.?.full_object_path });
+        try positionals.append(try link.openObjectInput(diags, comp.compiler_rt_obj.?.full_object_path));
     }
 
-    for (positionals.items) |obj| {
-        macho_file.classifyInputFile(obj.path, .{ .path = obj.path }, obj.must_link) catch |err| switch (err) {
-            error.UnknownFileType => try macho_file.reportParseError(obj.path, "unknown file type for an input file", .{}),
-            else => |e| try macho_file.reportParseError(
-                obj.path,
-                "unexpected error: reading input file failed with error {s}",
-                .{@errorName(e)},
-            ),
-        };
+    for (positionals.items) |link_input| {
+        macho_file.classifyInputFile(link_input) catch |err|
+            diags.addParseError(link_input.path().?, "failed to read input file: {s}", .{@errorName(err)});
     }
 
-    if (macho_file.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
 
     try parseInputFilesAr(macho_file);
 
-    if (macho_file.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
 
     // First, we flush relocatable object file generated with our backends.
     if (macho_file.getZigObject()) |zo| {
@@ -228,7 +218,7 @@ pub fn flushStaticLib(macho_file: *MachO, comp: *Compilation, module_obj_path: ?
     try macho_file.base.file.?.setEndPos(total_size);
     try macho_file.base.file.?.pwriteAll(buffer.items, 0);
 
-    if (macho_file.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
 }
 
 fn parseInputFilesAr(macho_file: *MachO) !void {
@@ -293,43 +283,40 @@ fn calcSectionSizes(macho_file: *MachO) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
+    const diags = &macho_file.base.comp.link_diags;
+
     if (macho_file.getZigObject()) |zo| {
         // TODO this will create a race as we need to track merging of debug sections which we currently don't
         zo.calcNumRelocs(macho_file);
     }
 
-    const tp = macho_file.base.comp.thread_pool;
-    var wg: WaitGroup = .{};
     {
-        wg.reset();
-        defer wg.wait();
-
         for (macho_file.sections.items(.atoms), 0..) |atoms, i| {
             if (atoms.items.len == 0) continue;
-            tp.spawnWg(&wg, calcSectionSizeWorker, .{ macho_file, @as(u8, @intCast(i)) });
+            calcSectionSizeWorker(macho_file, @as(u8, @intCast(i)));
         }
 
         if (macho_file.eh_frame_sect_index) |_| {
-            tp.spawnWg(&wg, calcEhFrameSizeWorker, .{macho_file});
+            calcEhFrameSizeWorker(macho_file);
         }
 
         if (macho_file.unwind_info_sect_index) |_| {
             for (macho_file.objects.items) |index| {
-                tp.spawnWg(&wg, Object.calcCompactUnwindSizeRelocatable, .{
+                Object.calcCompactUnwindSizeRelocatable(
                     macho_file.getFile(index).?.object,
                     macho_file,
-                });
+                );
             }
         }
 
         for (macho_file.objects.items) |index| {
-            tp.spawnWg(&wg, File.calcSymtabSize, .{ macho_file.getFile(index).?, macho_file });
+            File.calcSymtabSize(macho_file.getFile(index).?, macho_file);
         }
         if (macho_file.getZigObject()) |zo| {
-            tp.spawnWg(&wg, File.calcSymtabSize, .{ zo.asFile(), macho_file });
+            File.calcSymtabSize(zo.asFile(), macho_file);
         }
 
-        tp.spawnWg(&wg, MachO.updateLinkeditSizeWorker, .{ macho_file, .data_in_code });
+        MachO.updateLinkeditSizeWorker(macho_file, .data_in_code);
     }
 
     if (macho_file.unwind_info_sect_index) |_| {
@@ -337,7 +324,7 @@ fn calcSectionSizes(macho_file: *MachO) !void {
     }
     try calcSymtabSize(macho_file);
 
-    if (macho_file.has_errors.swap(false, .seq_cst)) return error.FlushFailure;
+    if (diags.hasErrors()) return error.LinkFailure;
 }
 
 fn calcSectionSizeWorker(macho_file: *MachO, sect_id: u8) void {
@@ -365,6 +352,8 @@ fn calcEhFrameSizeWorker(macho_file: *MachO) void {
     const tracy = trace(@src());
     defer tracy.end();
 
+    const diags = &macho_file.base.comp.link_diags;
+
     const doWork = struct {
         fn doWork(mfile: *MachO, header: *macho.section_64) !void {
             header.size = try eh_frame.calcSize(mfile);
@@ -374,12 +363,8 @@ fn calcEhFrameSizeWorker(macho_file: *MachO) void {
     }.doWork;
 
     const header = &macho_file.sections.items(.header)[macho_file.eh_frame_sect_index.?];
-    doWork(macho_file, header) catch |err| {
-        macho_file.reportUnexpectedError("failed to calculate size of section '__TEXT,__eh_frame': {s}", .{
-            @errorName(err),
-        }) catch {};
-        _ = macho_file.has_errors.swap(true, .seq_cst);
-    };
+    doWork(macho_file, header) catch |err|
+        diags.addError("failed to calculate size of section '__TEXT,__eh_frame': {s}", .{@errorName(err)});
 }
 
 fn calcCompactUnwindSize(macho_file: *MachO) void {
@@ -592,6 +577,7 @@ fn writeSections(macho_file: *MachO) !void {
     defer tracy.end();
 
     const gpa = macho_file.base.comp.gpa;
+    const diags = &macho_file.base.comp.link_diags;
     const cpu_arch = macho_file.getTarget().cpu.arch;
     const slice = macho_file.sections.slice();
     for (slice.items(.header), slice.items(.out), slice.items(.relocs), 0..) |header, *out, *relocs, n_sect| {
@@ -610,34 +596,29 @@ fn writeSections(macho_file: *MachO) !void {
     try macho_file.strtab.resize(gpa, cmd.strsize);
     macho_file.strtab.items[0] = 0;
 
-    const tp = macho_file.base.comp.thread_pool;
-    var wg: WaitGroup = .{};
     {
-        wg.reset();
-        defer wg.wait();
-
         for (macho_file.objects.items) |index| {
-            tp.spawnWg(&wg, writeAtomsWorker, .{ macho_file, macho_file.getFile(index).? });
-            tp.spawnWg(&wg, File.writeSymtab, .{ macho_file.getFile(index).?, macho_file, macho_file });
+            writeAtomsWorker(macho_file, macho_file.getFile(index).?);
+            File.writeSymtab(macho_file.getFile(index).?, macho_file, macho_file);
         }
 
         if (macho_file.getZigObject()) |zo| {
-            tp.spawnWg(&wg, writeAtomsWorker, .{ macho_file, zo.asFile() });
-            tp.spawnWg(&wg, File.writeSymtab, .{ zo.asFile(), macho_file, macho_file });
+            writeAtomsWorker(macho_file, zo.asFile());
+            File.writeSymtab(zo.asFile(), macho_file, macho_file);
         }
 
         if (macho_file.eh_frame_sect_index) |_| {
-            tp.spawnWg(&wg, writeEhFrameWorker, .{macho_file});
+            writeEhFrameWorker(macho_file);
         }
 
         if (macho_file.unwind_info_sect_index) |_| {
             for (macho_file.objects.items) |index| {
-                tp.spawnWg(&wg, writeCompactUnwindWorker, .{ macho_file, macho_file.getFile(index).?.object });
+                writeCompactUnwindWorker(macho_file, macho_file.getFile(index).?.object);
             }
         }
     }
 
-    if (macho_file.has_errors.swap(false, .seq_cst)) return error.FlushFailure;
+    if (diags.hasErrors()) return error.LinkFailure;
 
     if (macho_file.getZigObject()) |zo| {
         try zo.writeRelocs(macho_file);
@@ -651,33 +632,28 @@ fn writeAtomsWorker(macho_file: *MachO, file: File) void {
         macho_file.reportParseError2(file.getIndex(), "failed to write atoms: {s}", .{
             @errorName(err),
         }) catch {};
-        _ = macho_file.has_errors.swap(true, .seq_cst);
     };
 }
 
 fn writeEhFrameWorker(macho_file: *MachO) void {
     const tracy = trace(@src());
     defer tracy.end();
+
+    const diags = &macho_file.base.comp.link_diags;
     const sect_index = macho_file.eh_frame_sect_index.?;
     const buffer = macho_file.sections.items(.out)[sect_index];
     const relocs = macho_file.sections.items(.relocs)[sect_index];
-    eh_frame.writeRelocs(macho_file, buffer.items, relocs.items) catch |err| {
-        macho_file.reportUnexpectedError("failed to write '__LD,__eh_frame' section: {s}", .{
-            @errorName(err),
-        }) catch {};
-        _ = macho_file.has_errors.swap(true, .seq_cst);
-    };
+    eh_frame.writeRelocs(macho_file, buffer.items, relocs.items) catch |err|
+        diags.addError("failed to write '__LD,__eh_frame' section: {s}", .{@errorName(err)});
 }
 
 fn writeCompactUnwindWorker(macho_file: *MachO, object: *Object) void {
     const tracy = trace(@src());
     defer tracy.end();
-    object.writeCompactUnwindRelocatable(macho_file) catch |err| {
-        macho_file.reportUnexpectedError("failed to write '__LD,__eh_frame' section: {s}", .{
-            @errorName(err),
-        }) catch {};
-        _ = macho_file.has_errors.swap(true, .seq_cst);
-    };
+
+    const diags = &macho_file.base.comp.link_diags;
+    object.writeCompactUnwindRelocatable(macho_file) catch |err|
+        diags.addError("failed to write '__LD,__eh_frame' section: {s}", .{@errorName(err)});
 }
 
 fn writeSectionsToFile(macho_file: *MachO) !void {
@@ -769,20 +745,15 @@ fn writeHeader(macho_file: *MachO, ncmds: usize, sizeofcmds: usize) !void {
     try macho_file.base.file.?.pwriteAll(mem.asBytes(&header), 0);
 }
 
+const std = @import("std");
+const Path = std.Build.Cache.Path;
+const WaitGroup = std.Thread.WaitGroup;
 const assert = std.debug.assert;
-const build_options = @import("build_options");
-const eh_frame = @import("eh_frame.zig");
-const fat = @import("fat.zig");
-const link = @import("../../link.zig");
-const load_commands = @import("load_commands.zig");
 const log = std.log.scoped(.link);
 const macho = std.macho;
 const math = std.math;
 const mem = std.mem;
 const state_log = std.log.scoped(.link_state);
-const std = @import("std");
-const trace = @import("../../tracy.zig").trace;
-const Path = std.Build.Cache.Path;
 
 const Archive = @import("Archive.zig");
 const Atom = @import("Atom.zig");
@@ -791,4 +762,9 @@ const File = @import("file.zig").File;
 const MachO = @import("../MachO.zig");
 const Object = @import("Object.zig");
 const Symbol = @import("Symbol.zig");
-const WaitGroup = std.Thread.WaitGroup;
+const build_options = @import("build_options");
+const eh_frame = @import("eh_frame.zig");
+const fat = @import("fat.zig");
+const link = @import("../../link.zig");
+const load_commands = @import("load_commands.zig");
+const trace = @import("../../tracy.zig").trace;
diff --git a/zig/src/link/Plan9.zig b/zig/src/link/Plan9.zig
index 483f540699..34f2de126a 100644
--- a/zig/src/link/Plan9.zig
+++ b/zig/src/link/Plan9.zig
@@ -931,7 +931,7 @@ fn addNavExports(
                 break;
             }
         }
-        const sym = .{
+        const sym: aout.Sym = .{
             .value = atom.offset.?,
             .type = atom.type.toGlobal(),
             .name = try gpa.dupe(u8, exp_name),
diff --git a/zig/src/link/SpirV.zig b/zig/src/link/SpirV.zig
index bbc267cbc5..b1b8945963 100644
--- a/zig/src/link/SpirV.zig
+++ b/zig/src/link/SpirV.zig
@@ -140,7 +140,7 @@ pub fn updateNav(self: *SpirV, pt: Zcu.PerThread, nav: InternPool.Nav.Index) !vo
     }
 
     const ip = &pt.zcu.intern_pool;
-    log.debug("lowering declaration {}", .{ip.getNav(nav).name.fmt(ip)});
+    log.debug("lowering nav {}({d})", .{ ip.getNav(nav).fqn.fmt(ip), nav });
 
     try self.object.updateNav(pt, nav);
 }
@@ -161,29 +161,35 @@ pub fn updateExports(
         },
     };
     const nav_ty = ip.getNav(nav_index).typeOf(ip);
+    const target = zcu.getTarget();
     if (ip.isFunctionType(nav_ty)) {
-        const target = zcu.getTarget();
         const spv_decl_index = try self.object.resolveNav(zcu, nav_index);
-        const execution_model = switch (Type.fromInterned(nav_ty).fnCallingConvention(zcu)) {
-            .Vertex => spec.ExecutionModel.Vertex,
-            .Fragment => spec.ExecutionModel.Fragment,
-            .Kernel => spec.ExecutionModel.Kernel,
-            .C => return, // TODO: What to do here?
+        const cc = Type.fromInterned(nav_ty).fnCallingConvention(zcu);
+        const execution_model: spec.ExecutionModel = switch (target.os.tag) {
+            .vulkan => switch (cc) {
+                .spirv_vertex => .Vertex,
+                .spirv_fragment => .Fragment,
+                .spirv_kernel => .GLCompute,
+                // TODO: We should integrate with the Linkage capability and export this function
+                .spirv_device => return,
+                else => unreachable,
+            },
+            .opencl => switch (cc) {
+                .spirv_kernel => .Kernel,
+                // TODO: We should integrate with the Linkage capability and export this function
+                .spirv_device => return,
+                else => unreachable,
+            },
             else => unreachable,
         };
-        const is_vulkan = target.os.tag == .vulkan;
-
-        if ((!is_vulkan and execution_model == .Kernel) or
-            (is_vulkan and (execution_model == .Fragment or execution_model == .Vertex)))
-        {
-            for (export_indices) |export_idx| {
-                const exp = zcu.all_exports.items[export_idx];
-                try self.object.spv.declareEntryPoint(
-                    spv_decl_index,
-                    exp.opts.name.toSlice(ip),
-                    execution_model,
-                );
-            }
+
+        for (export_indices) |export_idx| {
+            const exp = zcu.all_exports.items[export_idx];
+            try self.object.spv.declareEntryPoint(
+                spv_decl_index,
+                exp.opts.name.toSlice(ip),
+                execution_model,
+            );
         }
     }
 
@@ -259,7 +265,7 @@ pub fn flushModule(self: *SpirV, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
     const linked_module = self.linkModule(arena, module, sub_prog_node) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
         else => |other| {
-            log.err("error while linking: {s}\n", .{@errorName(other)});
+            log.err("error while linking: {s}", .{@errorName(other)});
             return error.FlushFailure;
         },
     };
@@ -290,9 +296,8 @@ fn writeCapabilities(spv: *SpvModule, target: std.Target) !void {
     // TODO: Integrate with a hypothetical feature system
     const caps: []const spec.Capability = switch (target.os.tag) {
         .opencl => &.{ .Kernel, .Addresses, .Int8, .Int16, .Int64, .Float64, .Float16, .Vector16, .GenericPointer },
-        .opengl => &.{.Shader},
-        .vulkan => &.{ .Shader, .VariablePointersStorageBuffer, .Int8, .Int16, .Int64, .Float64, .Float16 },
-        else => unreachable, // TODO
+        .vulkan => &.{ .Shader, .PhysicalStorageBufferAddresses, .Int8, .Int16, .Int64, .Float64, .Float16, .VariablePointers, .VariablePointersStorageBuffer },
+        else => unreachable,
     };
 
     for (caps) |cap| {
@@ -300,19 +305,32 @@ fn writeCapabilities(spv: *SpvModule, target: std.Target) !void {
             .capability = cap,
         });
     }
+
+    switch (target.os.tag) {
+        .vulkan => {
+            try spv.sections.extensions.emit(gpa, .OpExtension, .{
+                .name = "SPV_KHR_physical_storage_buffer",
+            });
+        },
+        else => {},
+    }
 }
 
 fn writeMemoryModel(spv: *SpvModule, target: std.Target) !void {
     const gpa = spv.gpa;
 
-    const addressing_model = switch (target.os.tag) {
+    const addressing_model: spec.AddressingModel = switch (target.os.tag) {
         .opencl => switch (target.cpu.arch) {
-            .spirv32 => spec.AddressingModel.Physical32,
-            .spirv64 => spec.AddressingModel.Physical64,
-            else => unreachable, // TODO
+            .spirv32 => .Physical32,
+            .spirv64 => .Physical64,
+            else => unreachable,
         },
-        .opengl, .vulkan => spec.AddressingModel.Logical,
-        else => unreachable, // TODO
+        .opengl, .vulkan => switch (target.cpu.arch) {
+            .spirv32 => .Logical, // TODO: I don't think this will ever be implemented.
+            .spirv64 => .PhysicalStorageBuffer64,
+            else => unreachable,
+        },
+        else => unreachable,
     };
 
     const memory_model: spec.MemoryModel = switch (target.os.tag) {
diff --git a/zig/src/link/SpirV/deduplicate.zig b/zig/src/link/SpirV/deduplicate.zig
index f639644f7b..53d79b006f 100644
--- a/zig/src/link/SpirV/deduplicate.zig
+++ b/zig/src/link/SpirV/deduplicate.zig
@@ -511,6 +511,14 @@ pub fn run(parser: *BinaryModule.Parser, binary: *BinaryModule, progress: std.Pr
             }
 
             if (maybe_result_id_offset == null or maybe_result_id_offset.? != i) {
+                // Only emit forward pointers before type, constant, and global instructions.
+                // Debug and Annotation instructions don't need the forward pointer, and it
+                // messes up the logical layout of the module.
+                switch (inst.opcode.class()) {
+                    .TypeDeclaration, .ConstantCreation, .Memory => {},
+                    else => continue,
+                }
+
                 const id: ResultId = @enumFromInt(operand.*);
                 const index = info.entities.getIndex(id) orelse continue;
                 const entity = info.entities.values()[index];
diff --git a/zig/src/link/SpirV/lower_invocation_globals.zig b/zig/src/link/SpirV/lower_invocation_globals.zig
index a06a868e18..9d91a142e4 100644
--- a/zig/src/link/SpirV/lower_invocation_globals.zig
+++ b/zig/src/link/SpirV/lower_invocation_globals.zig
@@ -400,6 +400,15 @@ const ModuleBuilder = struct {
                     self.section.writeWords(inst.operands[2..]);
                     continue;
                 },
+                .OpExecutionMode, .OpExecutionModeId => {
+                    const original_id: ResultId = @enumFromInt(inst.operands[0]);
+                    const new_id_index = info.entry_points.getIndex(original_id).?;
+                    const new_id: ResultId = @enumFromInt(self.entry_point_new_id_base + new_id_index);
+                    try self.section.emitRaw(self.arena, inst.opcode, inst.operands.len);
+                    self.section.writeOperand(ResultId, new_id);
+                    self.section.writeWords(inst.operands[1..]);
+                    continue;
+                },
                 .OpTypeFunction => {
                     // Re-emitted in `emitFunctionTypes()`. We can do this because
                     // OpTypeFunction's may not currently be used anywhere that is not
diff --git a/zig/src/link/Wasm.zig b/zig/src/link/Wasm.zig
index 6a27909b31..ee8e638080 100644
--- a/zig/src/link/Wasm.zig
+++ b/zig/src/link/Wasm.zig
@@ -1,51 +1,52 @@
 const Wasm = @This();
+const build_options = @import("build_options");
 
-const std = @import("std");
+const builtin = @import("builtin");
+const native_endian = builtin.cpu.arch.endian();
 
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const Cache = std.Build.Cache;
+const Path = Cache.Path;
 const assert = std.debug.assert;
-const build_options = @import("build_options");
-const builtin = @import("builtin");
-const codegen = @import("../codegen.zig");
-const dev = @import("../dev.zig");
 const fs = std.fs;
+const gc_log = std.log.scoped(.gc);
 const leb = std.leb;
-const link = @import("../link.zig");
-const lldMain = @import("../main.zig").lldMain;
 const log = std.log.scoped(.link);
-const gc_log = std.log.scoped(.gc);
 const mem = std.mem;
-const trace = @import("../tracy.zig").trace;
-const types = @import("Wasm/types.zig");
-const wasi_libc = @import("../wasi_libc.zig");
 
 const Air = @import("../Air.zig");
-const Allocator = std.mem.Allocator;
 const Archive = @import("Wasm/Archive.zig");
-const Cache = std.Build.Cache;
-const Path = Cache.Path;
 const CodeGen = @import("../arch/wasm/CodeGen.zig");
 const Compilation = @import("../Compilation.zig");
 const Dwarf = @import("Dwarf.zig");
-const File = @import("Wasm/file.zig").File;
 const InternPool = @import("../InternPool.zig");
 const Liveness = @import("../Liveness.zig");
 const LlvmObject = @import("../codegen/llvm.zig").Object;
-const Zcu = @import("../Zcu.zig");
 const Object = @import("Wasm/Object.zig");
 const Symbol = @import("Wasm/Symbol.zig");
 const Type = @import("../Type.zig");
 const Value = @import("../Value.zig");
+const Zcu = @import("../Zcu.zig");
 const ZigObject = @import("Wasm/ZigObject.zig");
-
-pub const Atom = @import("Wasm/Atom.zig");
-pub const Relocation = types.Relocation;
+const codegen = @import("../codegen.zig");
+const dev = @import("../dev.zig");
+const link = @import("../link.zig");
+const lldMain = @import("../main.zig").lldMain;
+const trace = @import("../tracy.zig").trace;
+const wasi_libc = @import("../wasi_libc.zig");
 
 base: link.File,
+/// Null-terminated strings, indexes have type String and string_table provides
+/// lookup.
+string_bytes: std.ArrayListUnmanaged(u8),
+/// Omitted when serializing linker state.
+string_table: String.Table,
 /// Symbol name of the entry function to export
-entry_name: ?[]const u8,
+entry_name: OptionalString,
 /// When true, will allow undefined symbols
 import_symbols: bool,
-/// List of *global* symbol names to export to the host environment.
+/// Set of *global* symbol names to export to the host environment.
 export_symbol_names: []const []const u8,
 /// When defined, sets the start of the data section.
 global_base: ?u64,
@@ -61,41 +62,21 @@ export_table: bool,
 name: []const u8,
 /// If this is not null, an object file is created by LLVM and linked with LLD afterwards.
 llvm_object: ?LlvmObject.Ptr = null,
-/// The file index of a `ZigObject`. This will only contain a valid index when a zcu exists,
-/// and the chosen backend is the Wasm backend.
-zig_object_index: File.Index = .null,
+zig_object: ?*ZigObject,
 /// List of relocatable files to be linked into the final binary.
-files: std.MultiArrayList(File.Entry) = .{},
+objects: std.ArrayListUnmanaged(Object) = .{},
 /// When importing objects from the host environment, a name must be supplied.
 /// LLVM uses "env" by default when none is given. This would be a good default for Zig
 /// to support existing code.
 /// TODO: Allow setting this through a flag?
-host_name: []const u8 = "env",
+host_name: String,
 /// List of symbols generated by the linker.
 synthetic_symbols: std.ArrayListUnmanaged(Symbol) = .empty,
 /// Maps atoms to their segment index
-atoms: std.AutoHashMapUnmanaged(u32, Atom.Index) = .empty,
+atoms: std.AutoHashMapUnmanaged(Segment.Index, Atom.Index) = .empty,
 /// List of all atoms.
 managed_atoms: std.ArrayListUnmanaged(Atom) = .empty,
-/// Represents the index into `segments` where the 'code' section
-/// lives.
-code_section_index: ?u32 = null,
-/// The index of the segment representing the custom '.debug_info' section.
-debug_info_index: ?u32 = null,
-/// The index of the segment representing the custom '.debug_line' section.
-debug_line_index: ?u32 = null,
-/// The index of the segment representing the custom '.debug_loc' section.
-debug_loc_index: ?u32 = null,
-/// The index of the segment representing the custom '.debug_ranges' section.
-debug_ranges_index: ?u32 = null,
-/// The index of the segment representing the custom '.debug_pubnames' section.
-debug_pubnames_index: ?u32 = null,
-/// The index of the segment representing the custom '.debug_pubtypes' section.
-debug_pubtypes_index: ?u32 = null,
-/// The index of the segment representing the custom '.debug_pubtypes' section.
-debug_str_index: ?u32 = null,
-/// The index of the segment representing the custom '.debug_pubtypes' section.
-debug_abbrev_index: ?u32 = null,
+
 /// The count of imported functions. This number will be appended
 /// to the function indexes as their index starts at the lowest non-extern function.
 imported_functions_count: u32 = 0,
@@ -105,19 +86,17 @@ imported_globals_count: u32 = 0,
 /// The count of imported tables. This number will be appended
 /// to the table indexes when sections are merged.
 imported_tables_count: u32 = 0,
-/// Map of symbol locations, represented by its `types.Import`
-imports: std.AutoHashMapUnmanaged(SymbolLoc, types.Import) = .empty,
+/// Map of symbol locations, represented by its `Import`
+imports: std.AutoHashMapUnmanaged(SymbolLoc, Import) = .empty,
 /// Represents non-synthetic section entries.
 /// Used for code, data and custom sections.
 segments: std.ArrayListUnmanaged(Segment) = .empty,
 /// Maps a data segment key (such as .rodata) to the index into `segments`.
-data_segments: std.StringArrayHashMapUnmanaged(u32) = .empty,
-/// A table of `types.Segment` which provide meta data
+data_segments: std.StringArrayHashMapUnmanaged(Segment.Index) = .empty,
+/// A table of `NamedSegment` which provide meta data
 /// about a data symbol such as its name where the key is
 /// the segment index, which can be found from `data_segments`
-segment_info: std.AutoArrayHashMapUnmanaged(u32, types.Segment) = .empty,
-/// Deduplicated string table for strings used by symbols, imports and exports.
-string_table: StringTable = .{},
+segment_info: std.AutoArrayHashMapUnmanaged(Segment.Index, NamedSegment) = .empty,
 
 // Output sections
 /// Output type section
@@ -126,8 +105,15 @@ func_types: std.ArrayListUnmanaged(std.wasm.Type) = .empty,
 /// function index and the value is function.
 /// This allows us to map multiple symbols to the same function.
 functions: std.AutoArrayHashMapUnmanaged(
-    struct { file: File.Index, index: u32 },
-    struct { func: std.wasm.Func, sym_index: Symbol.Index },
+    struct {
+        /// `none` in the case of synthetic sections.
+        file: OptionalObjectId,
+        index: u32,
+    },
+    struct {
+        func: std.wasm.Func,
+        sym_index: Symbol.Index,
+    },
 ) = .{},
 /// Output global section
 wasm_globals: std.ArrayListUnmanaged(std.wasm.Global) = .empty,
@@ -140,7 +126,7 @@ memories: std.wasm.Memory = .{ .limits = .{
 /// Output table section
 tables: std.ArrayListUnmanaged(std.wasm.Table) = .empty,
 /// Output export section
-exports: std.ArrayListUnmanaged(types.Export) = .empty,
+exports: std.ArrayListUnmanaged(Export) = .empty,
 /// List of initialization functions. These must be called in order of priority
 /// by the (synthetic) __wasm_call_ctors function.
 init_funcs: std.ArrayListUnmanaged(InitFuncLoc) = .empty,
@@ -154,14 +140,15 @@ entry: ?u32 = null,
 /// Note: Key is symbol location, value represents the index into the table
 function_table: std.AutoHashMapUnmanaged(SymbolLoc, u32) = .empty,
 
-/// All object files and their data which are linked into the final binary
-objects: std.ArrayListUnmanaged(File.Index) = .empty,
 /// All archive files that are lazy loaded.
 /// e.g. when an undefined symbol references a symbol from the archive.
-archives: std.ArrayListUnmanaged(Archive) = .empty,
+/// None of this data is serialized to disk because it is trivially reloaded
+/// from unchanged archive files on the next start of the compiler process,
+/// or if those files have changed, the prelink phase needs to be restarted.
+lazy_archives: std.ArrayListUnmanaged(LazyArchive) = .empty,
 
-/// A map of global names (read: offset into string table) to their symbol location
-globals: std.AutoHashMapUnmanaged(u32, SymbolLoc) = .empty,
+/// A map of global names to their symbol location
+globals: std.AutoArrayHashMapUnmanaged(String, SymbolLoc) = .empty,
 /// The list of GOT symbols and their location
 got_symbols: std.ArrayListUnmanaged(SymbolLoc) = .empty,
 /// Maps discarded symbols and their positions to the location of the symbol
@@ -171,14 +158,149 @@ discarded: std.AutoHashMapUnmanaged(SymbolLoc, SymbolLoc) = .empty,
 /// into the final binary.
 resolved_symbols: std.AutoArrayHashMapUnmanaged(SymbolLoc, void) = .empty,
 /// Symbols that remain undefined after symbol resolution.
-/// Note: The key represents an offset into the string table, rather than the actual string.
-undefs: std.AutoArrayHashMapUnmanaged(u32, SymbolLoc) = .empty,
+undefs: std.AutoArrayHashMapUnmanaged(String, SymbolLoc) = .empty,
 /// Maps a symbol's location to an atom. This can be used to find meta
 /// data of a symbol, such as its size, or its offset to perform a relocation.
 /// Undefined (and synthetic) symbols do not have an Atom and therefore cannot be mapped.
 symbol_atom: std.AutoHashMapUnmanaged(SymbolLoc, Atom.Index) = .empty,
 
-pub const Alignment = types.Alignment;
+/// `--verbose-link` output.
+/// Initialized on creation, appended to as inputs are added, printed during `flush`.
+/// String data is allocated into Compilation arena.
+dump_argv_list: std.ArrayListUnmanaged([]const u8),
+
+/// Represents the index into `segments` where the 'code' section lives.
+code_section_index: Segment.OptionalIndex = .none,
+custom_sections: CustomSections,
+preloaded_strings: PreloadedStrings,
+
+/// Type reflection is used on the field names to autopopulate each field
+/// during initialization.
+const PreloadedStrings = struct {
+    __heap_base: String,
+    __heap_end: String,
+    __indirect_function_table: String,
+    __linear_memory: String,
+    __stack_pointer: String,
+    __tls_align: String,
+    __tls_base: String,
+    __tls_size: String,
+    __wasm_apply_global_tls_relocs: String,
+    __wasm_call_ctors: String,
+    __wasm_init_memory: String,
+    __wasm_init_memory_flag: String,
+    __wasm_init_tls: String,
+    __zig_err_name_table: String,
+    __zig_err_names: String,
+    __zig_errors_len: String,
+    _initialize: String,
+    _start: String,
+    memory: String,
+};
+
+/// Type reflection is used on the field names to autopopulate each inner `name` field.
+const CustomSections = struct {
+    @".debug_info": CustomSection,
+    @".debug_pubtypes": CustomSection,
+    @".debug_abbrev": CustomSection,
+    @".debug_line": CustomSection,
+    @".debug_str": CustomSection,
+    @".debug_pubnames": CustomSection,
+    @".debug_loc": CustomSection,
+    @".debug_ranges": CustomSection,
+};
+
+const CustomSection = struct {
+    name: String,
+    index: Segment.OptionalIndex,
+};
+
+/// Index into string_bytes
+pub const String = enum(u32) {
+    _,
+
+    const Table = std.HashMapUnmanaged(String, void, TableContext, std.hash_map.default_max_load_percentage);
+
+    const TableContext = struct {
+        bytes: []const u8,
+
+        pub fn eql(_: @This(), a: String, b: String) bool {
+            return a == b;
+        }
+
+        pub fn hash(ctx: @This(), key: String) u64 {
+            return std.hash_map.hashString(mem.sliceTo(ctx.bytes[@intFromEnum(key)..], 0));
+        }
+    };
+
+    const TableIndexAdapter = struct {
+        bytes: []const u8,
+
+        pub fn eql(ctx: @This(), a: []const u8, b: String) bool {
+            return mem.eql(u8, a, mem.sliceTo(ctx.bytes[@intFromEnum(b)..], 0));
+        }
+
+        pub fn hash(_: @This(), adapted_key: []const u8) u64 {
+            assert(mem.indexOfScalar(u8, adapted_key, 0) == null);
+            return std.hash_map.hashString(adapted_key);
+        }
+    };
+
+    pub fn toOptional(i: String) OptionalString {
+        const result: OptionalString = @enumFromInt(@intFromEnum(i));
+        assert(result != .none);
+        return result;
+    }
+};
+
+pub const OptionalString = enum(u32) {
+    none = std.math.maxInt(u32),
+    _,
+
+    pub fn unwrap(i: OptionalString) ?String {
+        if (i == .none) return null;
+        return @enumFromInt(@intFromEnum(i));
+    }
+};
+
+/// Index into objects array or the zig object.
+pub const ObjectId = enum(u16) {
+    zig_object = std.math.maxInt(u16) - 1,
+    _,
+
+    pub fn toOptional(i: ObjectId) OptionalObjectId {
+        const result: OptionalObjectId = @enumFromInt(@intFromEnum(i));
+        assert(result != .none);
+        return result;
+    }
+};
+
+/// Optional index into objects array or the zig object.
+pub const OptionalObjectId = enum(u16) {
+    zig_object = std.math.maxInt(u16) - 1,
+    none = std.math.maxInt(u16),
+    _,
+
+    pub fn unwrap(i: OptionalObjectId) ?ObjectId {
+        if (i == .none) return null;
+        return @enumFromInt(@intFromEnum(i));
+    }
+};
+
+/// None of this data is serialized since it can be re-loaded from disk, or if
+/// it has been changed, the data must be discarded.
+const LazyArchive = struct {
+    path: Path,
+    file_contents: []const u8,
+    archive: Archive,
+
+    fn deinit(la: *LazyArchive, gpa: Allocator) void {
+        la.archive.deinit(gpa);
+        gpa.free(la.path.sub_path);
+        gpa.free(la.file_contents);
+        la.* = undefined;
+    }
+};
 
 pub const Segment = struct {
     alignment: Alignment,
@@ -186,6 +308,26 @@ pub const Segment = struct {
     offset: u32,
     flags: u32,
 
+    const Index = enum(u32) {
+        _,
+
+        pub fn toOptional(i: Index) OptionalIndex {
+            const result: OptionalIndex = @enumFromInt(@intFromEnum(i));
+            assert(result != .none);
+            return result;
+        }
+    };
+
+    const OptionalIndex = enum(u32) {
+        none = std.math.maxInt(u32),
+        _,
+
+        pub fn unwrap(i: OptionalIndex) ?Index {
+            if (i == .none) return null;
+            return @enumFromInt(@intFromEnum(i));
+        }
+    };
+
     pub const Flag = enum(u32) {
         WASM_DATA_SEGMENT_IS_PASSIVE = 0x01,
         WASM_DATA_SEGMENT_HAS_MEMINDEX = 0x02,
@@ -208,43 +350,37 @@ pub const SymbolLoc = struct {
     /// The index of the symbol within the specified file
     index: Symbol.Index,
     /// The index of the object file where the symbol resides.
-    file: File.Index,
+    file: OptionalObjectId,
+};
 
-    /// From a given location, returns the corresponding symbol in the wasm binary
-    pub fn getSymbol(loc: SymbolLoc, wasm_file: *const Wasm) *Symbol {
-        if (wasm_file.discarded.get(loc)) |new_loc| {
-            return new_loc.getSymbol(wasm_file);
-        }
-        if (wasm_file.file(loc.file)) |obj_file| {
-            return obj_file.symbol(loc.index);
-        }
-        return &wasm_file.synthetic_symbols.items[@intFromEnum(loc.index)];
+/// From a given location, returns the corresponding symbol in the wasm binary
+pub fn symbolLocSymbol(wasm: *const Wasm, loc: SymbolLoc) *Symbol {
+    if (wasm.discarded.get(loc)) |new_loc| {
+        return symbolLocSymbol(wasm, new_loc);
     }
+    return switch (loc.file) {
+        .none => &wasm.synthetic_symbols.items[@intFromEnum(loc.index)],
+        .zig_object => wasm.zig_object.?.symbol(loc.index),
+        _ => &wasm.objects.items[@intFromEnum(loc.file)].symtable[@intFromEnum(loc.index)],
+    };
+}
 
-    /// From a given location, returns the name of the symbol.
-    pub fn getName(loc: SymbolLoc, wasm_file: *const Wasm) []const u8 {
-        if (wasm_file.discarded.get(loc)) |new_loc| {
-            return new_loc.getName(wasm_file);
-        }
-        if (wasm_file.file(loc.file)) |obj_file| {
-            return obj_file.symbolName(loc.index);
-        }
-        const sym = wasm_file.synthetic_symbols.items[@intFromEnum(loc.index)];
-        return wasm_file.string_table.get(sym.name);
-    }
+/// From a given location, returns the name of the symbol.
+pub fn symbolLocName(wasm: *const Wasm, loc: SymbolLoc) [:0]const u8 {
+    return wasm.stringSlice(wasm.symbolLocSymbol(loc).name);
+}
 
-    /// From a given symbol location, returns the final location.
-    /// e.g. when a symbol was resolved and replaced by the symbol
-    /// in a different file, this will return said location.
-    /// If the symbol wasn't replaced by another, this will return
-    /// the given location itwasm.
-    pub fn finalLoc(loc: SymbolLoc, wasm_file: *const Wasm) SymbolLoc {
-        if (wasm_file.discarded.get(loc)) |new_loc| {
-            return new_loc.finalLoc(wasm_file);
-        }
-        return loc;
+/// From a given symbol location, returns the final location.
+/// e.g. when a symbol was resolved and replaced by the symbol
+/// in a different file, this will return said location.
+/// If the symbol wasn't replaced by another, this will return
+/// the given location itwasm.
+pub fn symbolLocFinalLoc(wasm: *const Wasm, loc: SymbolLoc) SymbolLoc {
+    if (wasm.discarded.get(loc)) |new_loc| {
+        return symbolLocFinalLoc(wasm, new_loc);
     }
-};
+    return loc;
+}
 
 // Contains the location of the function symbol, as well as
 /// the priority itself of the initialization function.
@@ -252,7 +388,7 @@ pub const InitFuncLoc = struct {
     /// object file index in the list of objects.
     /// Unlike `SymbolLoc` this cannot be `null` as we never define
     /// our own ctors.
-    file: File.Index,
+    file: ObjectId,
     /// Symbol index within the corresponding object file.
     index: Symbol.Index,
     /// The priority in which the constructor must be called.
@@ -260,12 +396,15 @@ pub const InitFuncLoc = struct {
 
     /// From a given `InitFuncLoc` returns the corresponding function symbol
     fn getSymbol(loc: InitFuncLoc, wasm: *const Wasm) *Symbol {
-        return getSymbolLoc(loc).getSymbol(wasm);
+        return wasm.symbolLocSymbol(getSymbolLoc(loc));
     }
 
     /// Turns the given `InitFuncLoc` into a `SymbolLoc`
     fn getSymbolLoc(loc: InitFuncLoc) SymbolLoc {
-        return .{ .file = loc.file, .index = loc.index };
+        return .{
+            .file = loc.file.toOptional(),
+            .index = loc.index,
+        };
     }
 
     /// Returns true when `lhs` has a higher priority (e.i. value closer to 0) than `rhs`.
@@ -274,75 +413,6 @@ pub const InitFuncLoc = struct {
         return lhs.priority < rhs.priority;
     }
 };
-/// Generic string table that duplicates strings
-/// and converts them into offsets instead.
-pub const StringTable = struct {
-    /// Table that maps string offsets, which is used to de-duplicate strings.
-    /// Rather than having the offset map to the data, the `StringContext` holds all bytes of the string.
-    /// The strings are stored as a contigious array where each string is zero-terminated.
-    string_table: std.HashMapUnmanaged(
-        u32,
-        void,
-        std.hash_map.StringIndexContext,
-        std.hash_map.default_max_load_percentage,
-    ) = .{},
-    /// Holds the actual data of the string table.
-    string_data: std.ArrayListUnmanaged(u8) = .empty,
-
-    /// Accepts a string and searches for a corresponding string.
-    /// When found, de-duplicates the string and returns the existing offset instead.
-    /// When the string is not found in the `string_table`, a new entry will be inserted
-    /// and the new offset to its data will be returned.
-    pub fn put(table: *StringTable, allocator: Allocator, string: []const u8) !u32 {
-        const gop = try table.string_table.getOrPutContextAdapted(
-            allocator,
-            string,
-            std.hash_map.StringIndexAdapter{ .bytes = &table.string_data },
-            .{ .bytes = &table.string_data },
-        );
-        if (gop.found_existing) {
-            const off = gop.key_ptr.*;
-            log.debug("reusing string '{s}' at offset 0x{x}", .{ string, off });
-            return off;
-        }
-
-        try table.string_data.ensureUnusedCapacity(allocator, string.len + 1);
-        const offset = @as(u32, @intCast(table.string_data.items.len));
-
-        log.debug("writing new string '{s}' at offset 0x{x}", .{ string, offset });
-
-        table.string_data.appendSliceAssumeCapacity(string);
-        table.string_data.appendAssumeCapacity(0);
-
-        gop.key_ptr.* = offset;
-
-        return offset;
-    }
-
-    /// From a given offset, returns its corresponding string value.
-    /// Asserts offset does not exceed bounds.
-    pub fn get(table: StringTable, off: u32) []const u8 {
-        assert(off < table.string_data.items.len);
-        return mem.sliceTo(@as([*:0]const u8, @ptrCast(table.string_data.items.ptr + off)), 0);
-    }
-
-    /// Returns the offset of a given string when it exists.
-    /// Will return null if the given string does not yet exist within the string table.
-    pub fn getOffset(table: *StringTable, string: []const u8) ?u32 {
-        return table.string_table.getKeyAdapted(
-            string,
-            std.hash_map.StringIndexAdapter{ .bytes = &table.string_data },
-        );
-    }
-
-    /// Frees all resources of the string table. Any references pointing
-    /// to the strings will be invalid.
-    pub fn deinit(table: *StringTable, allocator: Allocator) void {
-        table.string_data.deinit(allocator);
-        table.string_table.deinit(allocator);
-        table.* = undefined;
-    }
-};
 
 pub fn open(
     arena: Allocator,
@@ -400,6 +470,8 @@ pub fn createEmpty(
             .build_id = options.build_id,
         },
         .name = undefined,
+        .string_table = .empty,
+        .string_bytes = .empty,
         .import_table = options.import_table,
         .export_table = options.export_table,
         .import_symbols = options.import_symbols,
@@ -408,18 +480,38 @@ pub fn createEmpty(
         .initial_memory = options.initial_memory,
         .max_memory = options.max_memory,
 
-        .entry_name = switch (options.entry) {
-            .disabled => null,
-            .default => if (output_mode != .Exe) null else defaultEntrySymbolName(wasi_exec_model),
-            .enabled => defaultEntrySymbolName(wasi_exec_model),
-            .named => |name| name,
-        },
+        .entry_name = undefined,
+        .zig_object = null,
+        .dump_argv_list = .empty,
+        .host_name = undefined,
+        .custom_sections = undefined,
+        .preloaded_strings = undefined,
     };
     if (use_llvm and comp.config.have_zcu) {
         wasm.llvm_object = try LlvmObject.create(arena, comp);
     }
     errdefer wasm.base.destroy();
 
+    wasm.host_name = try wasm.internString("env");
+
+    inline for (@typeInfo(CustomSections).@"struct".fields) |field| {
+        @field(wasm.custom_sections, field.name) = .{
+            .index = .none,
+            .name = try wasm.internString(field.name),
+        };
+    }
+
+    inline for (@typeInfo(PreloadedStrings).@"struct".fields) |field| {
+        @field(wasm.preloaded_strings, field.name) = try wasm.internString(field.name);
+    }
+
+    wasm.entry_name = switch (options.entry) {
+        .disabled => .none,
+        .default => if (output_mode != .Exe) .none else defaultEntrySymbolName(&wasm.preloaded_strings, wasi_exec_model).toOptional(),
+        .enabled => defaultEntrySymbolName(&wasm.preloaded_strings, wasi_exec_model).toOptional(),
+        .named => |name| (try wasm.internString(name)).toOptional(),
+    };
+
     if (use_lld and (use_llvm or !comp.config.have_zcu)) {
         // LLVM emits the object file (if any); LLD links it into the final product.
         return wasm;
@@ -445,22 +537,18 @@ pub fn createEmpty(
 
     // create stack pointer symbol
     {
-        const loc = try wasm.createSyntheticSymbol("__stack_pointer", .global);
-        const symbol = loc.getSymbol(wasm);
+        const loc = try wasm.createSyntheticSymbol(wasm.preloaded_strings.__stack_pointer, .global);
+        const symbol = wasm.symbolLocSymbol(loc);
         // For object files we will import the stack pointer symbol
         if (output_mode == .Obj) {
             symbol.setUndefined(true);
             symbol.index = @intCast(wasm.imported_globals_count);
             wasm.imported_globals_count += 1;
-            try wasm.imports.putNoClobber(
-                gpa,
-                loc,
-                .{
-                    .module_name = try wasm.string_table.put(gpa, wasm.host_name),
-                    .name = symbol.name,
-                    .kind = .{ .global = .{ .valtype = .i32, .mutable = true } },
-                },
-            );
+            try wasm.imports.putNoClobber(gpa, loc, .{
+                .module_name = wasm.host_name,
+                .name = symbol.name,
+                .kind = .{ .global = .{ .valtype = .i32, .mutable = true } },
+            });
         } else {
             symbol.index = @intCast(wasm.imported_globals_count + wasm.wasm_globals.items.len);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
@@ -477,8 +565,8 @@ pub fn createEmpty(
 
     // create indirect function pointer symbol
     {
-        const loc = try wasm.createSyntheticSymbol("__indirect_function_table", .table);
-        const symbol = loc.getSymbol(wasm);
+        const loc = try wasm.createSyntheticSymbol(wasm.preloaded_strings.__indirect_function_table, .table);
+        const symbol = wasm.symbolLocSymbol(loc);
         const table: std.wasm.Table = .{
             .limits = .{ .flags = 0, .min = 0, .max = undefined }, // will be overwritten during `mapFunctionTable`
             .reftype = .funcref,
@@ -488,7 +576,7 @@ pub fn createEmpty(
             symbol.index = @intCast(wasm.imported_tables_count);
             wasm.imported_tables_count += 1;
             try wasm.imports.put(gpa, loc, .{
-                .module_name = try wasm.string_table.put(gpa, wasm.host_name),
+                .module_name = wasm.host_name,
                 .name = symbol.name,
                 .kind = .{ .table = table },
             });
@@ -505,8 +593,8 @@ pub fn createEmpty(
 
     // create __wasm_call_ctors
     {
-        const loc = try wasm.createSyntheticSymbol("__wasm_call_ctors", .function);
-        const symbol = loc.getSymbol(wasm);
+        const loc = try wasm.createSyntheticSymbol(wasm.preloaded_strings.__wasm_call_ctors, .function);
+        const symbol = wasm.symbolLocSymbol(loc);
         symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
         // we do not know the function index until after we merged all sections.
         // Therefore we set `symbol.index` and create its corresponding references
@@ -516,8 +604,8 @@ pub fn createEmpty(
     // shared-memory symbols for TLS support
     if (shared_memory) {
         {
-            const loc = try wasm.createSyntheticSymbol("__tls_base", .global);
-            const symbol = loc.getSymbol(wasm);
+            const loc = try wasm.createSyntheticSymbol(wasm.preloaded_strings.__tls_base, .global);
+            const symbol = wasm.symbolLocSymbol(loc);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
             symbol.index = @intCast(wasm.imported_globals_count + wasm.wasm_globals.items.len);
             symbol.mark();
@@ -527,8 +615,8 @@ pub fn createEmpty(
             });
         }
         {
-            const loc = try wasm.createSyntheticSymbol("__tls_size", .global);
-            const symbol = loc.getSymbol(wasm);
+            const loc = try wasm.createSyntheticSymbol(wasm.preloaded_strings.__tls_size, .global);
+            const symbol = wasm.symbolLocSymbol(loc);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
             symbol.index = @intCast(wasm.imported_globals_count + wasm.wasm_globals.items.len);
             symbol.mark();
@@ -538,8 +626,8 @@ pub fn createEmpty(
             });
         }
         {
-            const loc = try wasm.createSyntheticSymbol("__tls_align", .global);
-            const symbol = loc.getSymbol(wasm);
+            const loc = try wasm.createSyntheticSymbol(wasm.preloaded_strings.__tls_align, .global);
+            const symbol = wasm.symbolLocSymbol(loc);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
             symbol.index = @intCast(wasm.imported_globals_count + wasm.wasm_globals.items.len);
             symbol.mark();
@@ -549,43 +637,30 @@ pub fn createEmpty(
             });
         }
         {
-            const loc = try wasm.createSyntheticSymbol("__wasm_init_tls", .function);
-            const symbol = loc.getSymbol(wasm);
+            const loc = try wasm.createSyntheticSymbol(wasm.preloaded_strings.__wasm_init_tls, .function);
+            const symbol = wasm.symbolLocSymbol(loc);
             symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
         }
     }
 
     if (comp.zcu) |zcu| {
         if (!use_llvm) {
-            const index: File.Index = @enumFromInt(wasm.files.len);
-            var zig_object: ZigObject = .{
-                .index = index,
-                .path = try std.fmt.allocPrint(gpa, "{s}.o", .{std.fs.path.stem(zcu.main_mod.root_src_path)}),
+            const zig_object = try arena.create(ZigObject);
+            wasm.zig_object = zig_object;
+            zig_object.* = .{
+                .path = .{
+                    .root_dir = std.Build.Cache.Directory.cwd(),
+                    .sub_path = try std.fmt.allocPrint(gpa, "{s}.o", .{fs.path.stem(zcu.main_mod.root_src_path)}),
+                },
                 .stack_pointer_sym = .null,
             };
             try zig_object.init(wasm);
-            try wasm.files.append(gpa, .{ .zig_object = zig_object });
-            wasm.zig_object_index = index;
         }
     }
 
     return wasm;
 }
 
-pub fn file(wasm: *const Wasm, index: File.Index) ?File {
-    if (index == .null) return null;
-    const tag = wasm.files.items(.tags)[@intFromEnum(index)];
-    return switch (tag) {
-        .zig_object => .{ .zig_object = &wasm.files.items(.data)[@intFromEnum(index)].zig_object },
-        .object => .{ .object = &wasm.files.items(.data)[@intFromEnum(index)].object },
-    };
-}
-
-pub fn zigObjectPtr(wasm: *Wasm) ?*ZigObject {
-    if (wasm.zig_object_index == .null) return null;
-    return &wasm.files.items(.data)[@intFromEnum(wasm.zig_object_index)].zig_object;
-}
-
 pub fn getTypeIndex(wasm: *const Wasm, func_type: std.wasm.Type) ?u32 {
     var index: u32 = 0;
     while (index < wasm.func_types.items.len) : (index += 1) {
@@ -610,20 +685,18 @@ pub fn addOrUpdateImport(
     /// is asserted instead.
     type_index: ?u32,
 ) !void {
-    return wasm.zigObjectPtr().?.addOrUpdateImport(wasm, name, symbol_index, lib_name, type_index);
+    return wasm.zig_object.?.addOrUpdateImport(wasm, name, symbol_index, lib_name, type_index);
 }
 
 /// For a given name, creates a new global synthetic symbol.
 /// Leaves index undefined and the default flags (0).
-fn createSyntheticSymbol(wasm: *Wasm, name: []const u8, tag: Symbol.Tag) !SymbolLoc {
-    const gpa = wasm.base.comp.gpa;
-    const name_offset = try wasm.string_table.put(gpa, name);
-    return wasm.createSyntheticSymbolOffset(name_offset, tag);
+fn createSyntheticSymbol(wasm: *Wasm, name: String, tag: Symbol.Tag) !SymbolLoc {
+    return wasm.createSyntheticSymbolOffset(name, tag);
 }
 
-fn createSyntheticSymbolOffset(wasm: *Wasm, name_offset: u32, tag: Symbol.Tag) !SymbolLoc {
+fn createSyntheticSymbolOffset(wasm: *Wasm, name_offset: String, tag: Symbol.Tag) !SymbolLoc {
     const sym_index: Symbol.Index = @enumFromInt(wasm.synthetic_symbols.items.len);
-    const loc: SymbolLoc = .{ .index = sym_index, .file = .null };
+    const loc: SymbolLoc = .{ .index = sym_index, .file = .none };
     const gpa = wasm.base.comp.gpa;
     try wasm.synthetic_symbols.append(gpa, .{
         .name = name_offset,
@@ -637,93 +710,89 @@ fn createSyntheticSymbolOffset(wasm: *Wasm, name_offset: u32, tag: Symbol.Tag) !
     return loc;
 }
 
-fn parseInputFiles(wasm: *Wasm, files: []const []const u8) !void {
-    for (files) |path| {
-        if (try wasm.parseObjectFile(path)) continue;
-        if (try wasm.parseArchive(path, false)) continue; // load archives lazily
-        log.warn("Unexpected file format at path: '{s}'", .{path});
-    }
+fn openParseObjectReportingFailure(wasm: *Wasm, path: Path) void {
+    const diags = &wasm.base.comp.link_diags;
+    const obj = link.openObject(path, false, false) catch |err| {
+        switch (diags.failParse(path, "failed to open object: {s}", .{@errorName(err)})) {
+            error.LinkFailure => return,
+        }
+    };
+    wasm.parseObject(obj) catch |err| {
+        switch (diags.failParse(path, "failed to parse object: {s}", .{@errorName(err)})) {
+            error.LinkFailure => return,
+        }
+    };
 }
 
-/// Parses the object file from given path. Returns true when the given file was an object
-/// file and parsed successfully. Returns false when file is not an object file.
-/// May return an error instead when parsing failed.
-fn parseObjectFile(wasm: *Wasm, path: []const u8) !bool {
-    const obj_file = try fs.cwd().openFile(path, .{});
-    errdefer obj_file.close();
-
+fn parseObject(wasm: *Wasm, obj: link.Input.Object) !void {
+    defer obj.file.close();
     const gpa = wasm.base.comp.gpa;
-    var object = Object.create(wasm, obj_file, path, null) catch |err| switch (err) {
-        error.InvalidMagicByte, error.NotObjectFile => return false,
-        else => |e| {
-            var err_note = try wasm.base.addErrorWithNotes(1);
-            try err_note.addMsg("Failed parsing object file: {s}", .{@errorName(e)});
-            try err_note.addNote("while parsing '{s}'", .{path});
-            return error.FlushFailure;
-        },
-    };
-    errdefer object.deinit(gpa);
-    object.index = @enumFromInt(wasm.files.len);
-    try wasm.files.append(gpa, .{ .object = object });
-    try wasm.objects.append(gpa, object.index);
-    return true;
+    try wasm.objects.ensureUnusedCapacity(gpa, 1);
+    const stat = try obj.file.stat();
+    const size = std.math.cast(usize, stat.size) orelse return error.FileTooBig;
+
+    const file_contents = try gpa.alloc(u8, size);
+    defer gpa.free(file_contents);
+
+    const n = try obj.file.preadAll(file_contents, 0);
+    if (n != file_contents.len) return error.UnexpectedEndOfFile;
+
+    wasm.objects.appendAssumeCapacity(try Object.create(wasm, file_contents, obj.path, null));
 }
 
 /// Creates a new empty `Atom` and returns its `Atom.Index`
-pub fn createAtom(wasm: *Wasm, sym_index: Symbol.Index, file_index: File.Index) !Atom.Index {
+pub fn createAtom(wasm: *Wasm, sym_index: Symbol.Index, object_index: OptionalObjectId) !Atom.Index {
     const gpa = wasm.base.comp.gpa;
     const index: Atom.Index = @enumFromInt(wasm.managed_atoms.items.len);
     const atom = try wasm.managed_atoms.addOne(gpa);
-    atom.* = .{ .file = file_index, .sym_index = sym_index };
+    atom.* = .{
+        .file = object_index,
+        .sym_index = sym_index,
+    };
     try wasm.symbol_atom.putNoClobber(gpa, atom.symbolLoc(), index);
 
     return index;
 }
 
-pub inline fn getAtom(wasm: *const Wasm, index: Atom.Index) Atom {
+pub fn getAtom(wasm: *const Wasm, index: Atom.Index) Atom {
     return wasm.managed_atoms.items[@intFromEnum(index)];
 }
 
-pub inline fn getAtomPtr(wasm: *Wasm, index: Atom.Index) *Atom {
+pub fn getAtomPtr(wasm: *Wasm, index: Atom.Index) *Atom {
     return &wasm.managed_atoms.items[@intFromEnum(index)];
 }
 
-/// Parses an archive file and will then parse each object file
-/// that was found in the archive file.
-/// Returns false when the file is not an archive file.
-/// May return an error instead when parsing failed.
-///
-/// When `force_load` is `true`, it will for link all object files in the archive.
-/// When false, it will only link with object files that contain symbols that
-/// are referenced by other object files or Zig code.
-fn parseArchive(wasm: *Wasm, path: []const u8, force_load: bool) !bool {
+fn parseArchive(wasm: *Wasm, obj: link.Input.Object) !void {
     const gpa = wasm.base.comp.gpa;
 
-    const archive_file = try fs.cwd().openFile(path, .{});
-    errdefer archive_file.close();
+    defer obj.file.close();
 
-    var archive: Archive = .{
-        .file = archive_file,
-        .name = path,
-    };
-    archive.parse(gpa) catch |err| switch (err) {
-        error.EndOfStream, error.NotArchive => {
-            archive.deinit(gpa);
-            return false;
-        },
-        else => |e| {
-            var err_note = try wasm.base.addErrorWithNotes(1);
-            try err_note.addMsg("Failed parsing archive: {s}", .{@errorName(e)});
-            try err_note.addNote("while parsing archive {s}", .{path});
-            return error.FlushFailure;
-        },
-    };
+    const stat = try obj.file.stat();
+    const size = std.math.cast(usize, stat.size) orelse return error.FileTooBig;
+
+    const file_contents = try gpa.alloc(u8, size);
+    var keep_file_contents = false;
+    defer if (!keep_file_contents) gpa.free(file_contents);
+
+    const n = try obj.file.preadAll(file_contents, 0);
+    if (n != file_contents.len) return error.UnexpectedEndOfFile;
 
-    if (!force_load) {
+    var archive = try Archive.parse(gpa, file_contents);
+
+    if (!obj.must_link) {
         errdefer archive.deinit(gpa);
-        try wasm.archives.append(gpa, archive);
-        return true;
+        try wasm.lazy_archives.append(gpa, .{
+            .path = .{
+                .root_dir = obj.path.root_dir,
+                .sub_path = try gpa.dupe(u8, obj.path.sub_path),
+            },
+            .file_contents = file_contents,
+            .archive = archive,
+        });
+        keep_file_contents = true;
+        return;
     }
+
     defer archive.deinit(gpa);
 
     // In this case we must force link all embedded object files within the archive
@@ -738,72 +807,120 @@ fn parseArchive(wasm: *Wasm, path: []const u8, force_load: bool) !bool {
     }
 
     for (offsets.keys()) |file_offset| {
-        var object = archive.parseObject(wasm, file_offset) catch |e| {
-            var err_note = try wasm.base.addErrorWithNotes(1);
-            try err_note.addMsg("Failed parsing object: {s}", .{@errorName(e)});
-            try err_note.addNote("while parsing object in archive {s}", .{path});
-            return error.FlushFailure;
-        };
-        object.index = @enumFromInt(wasm.files.len);
-        try wasm.files.append(gpa, .{ .object = object });
-        try wasm.objects.append(gpa, object.index);
+        const object = try archive.parseObject(wasm, file_contents[file_offset..], obj.path);
+        try wasm.objects.append(gpa, object);
     }
-
-    return true;
 }
 
 fn requiresTLSReloc(wasm: *const Wasm) bool {
     for (wasm.got_symbols.items) |loc| {
-        if (loc.getSymbol(wasm).isTLS()) {
+        if (wasm.symbolLocSymbol(loc).isTLS()) {
             return true;
         }
     }
     return false;
 }
 
-fn resolveSymbolsInObject(wasm: *Wasm, file_index: File.Index) !void {
+fn objectPath(wasm: *const Wasm, object_id: ObjectId) Path {
+    const obj = wasm.objectById(object_id) orelse return wasm.zig_object.?.path;
+    return obj.path;
+}
+
+fn objectSymbols(wasm: *const Wasm, object_id: ObjectId) []const Symbol {
+    const obj = wasm.objectById(object_id) orelse return wasm.zig_object.?.symbols.items;
+    return obj.symtable;
+}
+
+fn objectSymbol(wasm: *const Wasm, object_id: ObjectId, index: Symbol.Index) *Symbol {
+    const obj = wasm.objectById(object_id) orelse return &wasm.zig_object.?.symbols.items[@intFromEnum(index)];
+    return &obj.symtable[@intFromEnum(index)];
+}
+
+fn objectFunction(wasm: *const Wasm, object_id: ObjectId, sym_index: Symbol.Index) std.wasm.Func {
+    const obj = wasm.objectById(object_id) orelse {
+        const zo = wasm.zig_object.?;
+        const sym = zo.symbols.items[@intFromEnum(sym_index)];
+        return zo.functions.items[sym.index];
+    };
+    const sym = obj.symtable[@intFromEnum(sym_index)];
+    return obj.functions[sym.index - obj.imported_functions_count];
+}
+
+fn objectImportedFunctions(wasm: *const Wasm, object_id: ObjectId) u32 {
+    const obj = wasm.objectById(object_id) orelse return wasm.zig_object.?.imported_functions_count;
+    return obj.imported_functions_count;
+}
+
+fn objectGlobals(wasm: *const Wasm, object_id: ObjectId) []const std.wasm.Global {
+    const obj = wasm.objectById(object_id) orelse return wasm.zig_object.?.globals.items;
+    return obj.globals;
+}
+
+fn objectFuncTypes(wasm: *const Wasm, object_id: ObjectId) []const std.wasm.Type {
+    const obj = wasm.objectById(object_id) orelse return wasm.zig_object.?.func_types.items;
+    return obj.func_types;
+}
+
+fn objectSegmentInfo(wasm: *const Wasm, object_id: ObjectId) []const NamedSegment {
+    const obj = wasm.objectById(object_id) orelse return wasm.zig_object.?.segment_info.items;
+    return obj.segment_info;
+}
+
+/// For a given symbol index, find its corresponding import.
+/// Asserts import exists.
+fn objectImport(wasm: *const Wasm, object_id: ObjectId, symbol_index: Symbol.Index) Import {
+    const obj = wasm.objectById(object_id) orelse return wasm.zig_object.?.imports.get(symbol_index).?;
+    return obj.findImport(obj.symtable[@intFromEnum(symbol_index)]);
+}
+
+/// Returns the object element pointer, or null if it is the ZigObject.
+fn objectById(wasm: *const Wasm, object_id: ObjectId) ?*Object {
+    if (object_id == .zig_object) return null;
+    return &wasm.objects.items[@intFromEnum(object_id)];
+}
+
+fn resolveSymbolsInObject(wasm: *Wasm, object_id: ObjectId) !void {
     const gpa = wasm.base.comp.gpa;
-    const obj_file = wasm.file(file_index).?;
-    log.debug("Resolving symbols in object: '{s}'", .{obj_file.path()});
+    const diags = &wasm.base.comp.link_diags;
+    const obj_path = objectPath(wasm, object_id);
+    log.debug("Resolving symbols in object: '{'}'", .{obj_path});
+    const symbols = objectSymbols(wasm, object_id);
 
-    for (obj_file.symbols(), 0..) |symbol, i| {
+    for (symbols, 0..) |symbol, i| {
         const sym_index: Symbol.Index = @enumFromInt(i);
-        const location: SymbolLoc = .{ .file = file_index, .index = sym_index };
-        const sym_name = obj_file.string(symbol.name);
-        if (mem.eql(u8, sym_name, "__indirect_function_table")) {
-            continue;
-        }
-        const sym_name_index = try wasm.string_table.put(gpa, sym_name);
+        const location: SymbolLoc = .{
+            .file = object_id.toOptional(),
+            .index = sym_index,
+        };
+        if (symbol.name == wasm.preloaded_strings.__indirect_function_table) continue;
 
         if (symbol.isLocal()) {
             if (symbol.isUndefined()) {
-                var err = try wasm.base.addErrorWithNotes(1);
-                try err.addMsg("Local symbols are not allowed to reference imports", .{});
-                try err.addNote("symbol '{s}' defined in '{s}'", .{ sym_name, obj_file.path() });
+                diags.addParseError(obj_path, "local symbol '{s}' references import", .{
+                    wasm.stringSlice(symbol.name),
+                });
             }
             try wasm.resolved_symbols.putNoClobber(gpa, location, {});
             continue;
         }
 
-        const maybe_existing = try wasm.globals.getOrPut(gpa, sym_name_index);
+        const maybe_existing = try wasm.globals.getOrPut(gpa, symbol.name);
         if (!maybe_existing.found_existing) {
             maybe_existing.value_ptr.* = location;
             try wasm.resolved_symbols.putNoClobber(gpa, location, {});
 
             if (symbol.isUndefined()) {
-                try wasm.undefs.putNoClobber(gpa, sym_name_index, location);
+                try wasm.undefs.putNoClobber(gpa, symbol.name, location);
             }
             continue;
         }
 
         const existing_loc = maybe_existing.value_ptr.*;
-        const existing_sym: *Symbol = existing_loc.getSymbol(wasm);
-        const existing_file = wasm.file(existing_loc.file);
-
-        const existing_file_path = if (existing_file) |existing_obj_file|
-            existing_obj_file.path()
-        else
-            wasm.name;
+        const existing_sym: *Symbol = wasm.symbolLocSymbol(existing_loc);
+        const existing_file_path: Path = if (existing_loc.file.unwrap()) |id| objectPath(wasm, id) else .{
+            .root_dir = std.Build.Cache.Directory.cwd(),
+            .sub_path = wasm.name,
+        };
 
         if (!existing_sym.isUndefined()) outer: {
             if (!symbol.isUndefined()) inner: {
@@ -814,10 +931,10 @@ fn resolveSymbolsInObject(wasm: *Wasm, file_index: File.Index) !void {
                     break :outer; // existing is weak, while new one isn't. Replace it.
                 }
                 // both are defined and weak, we have a symbol collision.
-                var err = try wasm.base.addErrorWithNotes(2);
-                try err.addMsg("symbol '{s}' defined multiple times", .{sym_name});
-                try err.addNote("first definition in '{s}'", .{existing_file_path});
-                try err.addNote("next definition in '{s}'", .{obj_file.path()});
+                var err = try diags.addErrorWithNotes(2);
+                try err.addMsg("symbol '{s}' defined multiple times", .{wasm.stringSlice(symbol.name)});
+                try err.addNote("first definition in '{'}'", .{existing_file_path});
+                try err.addNote("next definition in '{'}'", .{obj_path});
             }
 
             try wasm.discarded.put(gpa, location, existing_loc);
@@ -825,34 +942,32 @@ fn resolveSymbolsInObject(wasm: *Wasm, file_index: File.Index) !void {
         }
 
         if (symbol.tag != existing_sym.tag) {
-            var err = try wasm.base.addErrorWithNotes(2);
-            try err.addMsg("symbol '{s}' mismatching types '{s}' and '{s}'", .{ sym_name, @tagName(symbol.tag), @tagName(existing_sym.tag) });
-            try err.addNote("first definition in '{s}'", .{existing_file_path});
-            try err.addNote("next definition in '{s}'", .{obj_file.path()});
+            var err = try diags.addErrorWithNotes(2);
+            try err.addMsg("symbol '{s}' mismatching types '{s}' and '{s}'", .{
+                wasm.stringSlice(symbol.name), @tagName(symbol.tag), @tagName(existing_sym.tag),
+            });
+            try err.addNote("first definition in '{'}'", .{existing_file_path});
+            try err.addNote("next definition in '{'}'", .{obj_path});
         }
 
         if (existing_sym.isUndefined() and symbol.isUndefined()) {
             // only verify module/import name for function symbols
             if (symbol.tag == .function) {
-                const existing_name = if (existing_file) |existing_obj| blk: {
-                    const imp = existing_obj.import(existing_loc.index);
-                    break :blk existing_obj.string(imp.module_name);
-                } else blk: {
-                    const name_index = wasm.imports.get(existing_loc).?.module_name;
-                    break :blk wasm.string_table.get(name_index);
-                };
+                const existing_name = if (existing_loc.file.unwrap()) |existing_obj_id|
+                    objectImport(wasm, existing_obj_id, existing_loc.index).module_name
+                else
+                    wasm.imports.get(existing_loc).?.module_name;
 
-                const imp = obj_file.import(sym_index);
-                const module_name = obj_file.string(imp.module_name);
-                if (!mem.eql(u8, existing_name, module_name)) {
-                    var err = try wasm.base.addErrorWithNotes(2);
+                const module_name = objectImport(wasm, object_id, sym_index).module_name;
+                if (existing_name != module_name) {
+                    var err = try diags.addErrorWithNotes(2);
                     try err.addMsg("symbol '{s}' module name mismatch. Expected '{s}', but found '{s}'", .{
-                        sym_name,
-                        existing_name,
-                        module_name,
+                        wasm.stringSlice(symbol.name),
+                        wasm.stringSlice(existing_name),
+                        wasm.stringSlice(module_name),
                     });
-                    try err.addNote("first definition in '{s}'", .{existing_file_path});
-                    try err.addNote("next definition in '{s}'", .{obj_file.path()});
+                    try err.addNote("first definition in '{'}'", .{existing_file_path});
+                    try err.addNote("next definition in '{'}'", .{obj_path});
                 }
             }
 
@@ -865,10 +980,10 @@ fn resolveSymbolsInObject(wasm: *Wasm, file_index: File.Index) !void {
             const existing_ty = wasm.getGlobalType(existing_loc);
             const new_ty = wasm.getGlobalType(location);
             if (existing_ty.mutable != new_ty.mutable or existing_ty.valtype != new_ty.valtype) {
-                var err = try wasm.base.addErrorWithNotes(2);
-                try err.addMsg("symbol '{s}' mismatching global types", .{sym_name});
-                try err.addNote("first definition in '{s}'", .{existing_file_path});
-                try err.addNote("next definition in '{s}'", .{obj_file.path()});
+                var err = try diags.addErrorWithNotes(2);
+                try err.addMsg("symbol '{s}' mismatching global types", .{wasm.stringSlice(symbol.name)});
+                try err.addNote("first definition in '{'}'", .{existing_file_path});
+                try err.addNote("next definition in '{'}'", .{obj_path});
             }
         }
 
@@ -876,11 +991,11 @@ fn resolveSymbolsInObject(wasm: *Wasm, file_index: File.Index) !void {
             const existing_ty = wasm.getFunctionSignature(existing_loc);
             const new_ty = wasm.getFunctionSignature(location);
             if (!existing_ty.eql(new_ty)) {
-                var err = try wasm.base.addErrorWithNotes(3);
-                try err.addMsg("symbol '{s}' mismatching function signatures.", .{sym_name});
+                var err = try diags.addErrorWithNotes(3);
+                try err.addMsg("symbol '{s}' mismatching function signatures.", .{wasm.stringSlice(symbol.name)});
                 try err.addNote("expected signature {}, but found signature {}", .{ existing_ty, new_ty });
-                try err.addNote("first definition in '{s}'", .{existing_file_path});
-                try err.addNote("next definition in '{s}'", .{obj_file.path()});
+                try err.addNote("first definition in '{'}'", .{existing_file_path});
+                try err.addNote("next definition in '{'}'", .{obj_path});
             }
         }
 
@@ -893,50 +1008,47 @@ fn resolveSymbolsInObject(wasm: *Wasm, file_index: File.Index) !void {
         }
 
         // simply overwrite with the new symbol
-        log.debug("Overwriting symbol '{s}'", .{sym_name});
-        log.debug("  old definition in '{s}'", .{existing_file_path});
-        log.debug("  new definition in '{s}'", .{obj_file.path()});
+        log.debug("Overwriting symbol '{s}'", .{wasm.stringSlice(symbol.name)});
+        log.debug("  old definition in '{'}'", .{existing_file_path});
+        log.debug("  new definition in '{'}'", .{obj_path});
         try wasm.discarded.putNoClobber(gpa, existing_loc, location);
         maybe_existing.value_ptr.* = location;
-        try wasm.globals.put(gpa, sym_name_index, location);
+        try wasm.globals.put(gpa, symbol.name, location);
         try wasm.resolved_symbols.put(gpa, location, {});
         assert(wasm.resolved_symbols.swapRemove(existing_loc));
         if (existing_sym.isUndefined()) {
-            _ = wasm.undefs.swapRemove(sym_name_index);
+            _ = wasm.undefs.swapRemove(symbol.name);
         }
     }
 }
 
 fn resolveSymbolsInArchives(wasm: *Wasm) !void {
+    if (wasm.lazy_archives.items.len == 0) return;
     const gpa = wasm.base.comp.gpa;
-    if (wasm.archives.items.len == 0) return;
+    const diags = &wasm.base.comp.link_diags;
 
-    log.debug("Resolving symbols in archives", .{});
+    log.debug("Resolving symbols in lazy_archives", .{});
     var index: u32 = 0;
     undef_loop: while (index < wasm.undefs.count()) {
         const sym_name_index = wasm.undefs.keys()[index];
 
-        for (wasm.archives.items) |archive| {
-            const sym_name = wasm.string_table.get(sym_name_index);
-            log.debug("Detected symbol '{s}' in archive '{s}', parsing objects..", .{ sym_name, archive.name });
-            const offset = archive.toc.get(sym_name) orelse {
-                // symbol does not exist in this archive
-                continue;
-            };
+        for (wasm.lazy_archives.items) |lazy_archive| {
+            const sym_name = wasm.stringSlice(sym_name_index);
+            log.debug("Detected symbol '{s}' in archive '{'}', parsing objects..", .{
+                sym_name, lazy_archive.path,
+            });
+            const offset = lazy_archive.archive.toc.get(sym_name) orelse continue; // symbol does not exist in this archive
 
             // Symbol is found in unparsed object file within current archive.
             // Parse object and and resolve symbols again before we check remaining
             // undefined symbols.
-            var object = archive.parseObject(wasm, offset.items[0]) catch |e| {
-                var err_note = try wasm.base.addErrorWithNotes(1);
-                try err_note.addMsg("Failed parsing object: {s}", .{@errorName(e)});
-                try err_note.addNote("while parsing object in archive {s}", .{archive.name});
-                return error.FlushFailure;
+            const file_contents = lazy_archive.file_contents[offset.items[0]..];
+            const object = lazy_archive.archive.parseObject(wasm, file_contents, lazy_archive.path) catch |err| {
+                // TODO this fails to include information to identify which object failed
+                return diags.failParse(lazy_archive.path, "failed to parse object in archive: {s}", .{@errorName(err)});
             };
-            object.index = @enumFromInt(wasm.files.len);
-            try wasm.files.append(gpa, .{ .object = object });
-            try wasm.objects.append(gpa, object.index);
-            try wasm.resolveSymbolsInObject(object.index);
+            try wasm.objects.append(gpa, object);
+            try wasm.resolveSymbolsInObject(@enumFromInt(wasm.objects.items.len - 1));
 
             // continue loop for any remaining undefined symbols that still exist
             // after resolving last object file
@@ -966,14 +1078,14 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
     if (!wasm.hasPassiveInitializationSegments()) {
         return;
     }
-    const sym_loc = try wasm.createSyntheticSymbol("__wasm_init_memory", .function);
-    sym_loc.getSymbol(wasm).mark();
+    const sym_loc = try wasm.createSyntheticSymbol(wasm.preloaded_strings.__wasm_init_memory, .function);
+    wasm.symbolLocSymbol(sym_loc).mark();
 
     const flag_address: u32 = if (shared_memory) address: {
         // when we have passive initialization segments and shared memory
         // `setupMemory` will create this symbol and set its virtual address.
-        const loc = wasm.findGlobalSymbol("__wasm_init_memory_flag").?;
-        break :address loc.getSymbol(wasm).virtual_address;
+        const loc = wasm.globals.get(wasm.preloaded_strings.__wasm_init_memory_flag).?;
+        break :address wasm.symbolLocSymbol(loc).virtual_address;
     } else 0;
 
     var function_body = std.ArrayList(u8).init(gpa);
@@ -1013,31 +1125,30 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
         try writer.writeByte(std.wasm.opcode(.end));
     }
 
-    var it = wasm.data_segments.iterator();
-    var segment_index: u32 = 0;
-    while (it.next()) |entry| : (segment_index += 1) {
-        const segment: Segment = wasm.segments.items[entry.value_ptr.*];
-        if (segment.needsPassiveInitialization(import_memory, entry.key_ptr.*)) {
+    for (wasm.data_segments.keys(), wasm.data_segments.values(), 0..) |key, value, segment_index_usize| {
+        const segment_index: u32 = @intCast(segment_index_usize);
+        const segment = wasm.segmentPtr(value);
+        if (segment.needsPassiveInitialization(import_memory, key)) {
             // For passive BSS segments we can simple issue a memory.fill(0).
             // For non-BSS segments we do a memory.init.  Both these
             // instructions take as their first argument the destination
             // address.
             try writeI32Const(writer, segment.offset);
 
-            if (shared_memory and std.mem.eql(u8, entry.key_ptr.*, ".tdata")) {
+            if (shared_memory and std.mem.eql(u8, key, ".tdata")) {
                 // When we initialize the TLS segment we also set the `__tls_base`
                 // global.  This allows the runtime to use this static copy of the
                 // TLS data for the first/main thread.
                 try writeI32Const(writer, segment.offset);
                 try writer.writeByte(std.wasm.opcode(.global_set));
-                const loc = wasm.findGlobalSymbol("__tls_base").?;
-                try leb.writeUleb128(writer, loc.getSymbol(wasm).index);
+                const loc = wasm.globals.get(wasm.preloaded_strings.__tls_base).?;
+                try leb.writeUleb128(writer, wasm.symbolLocSymbol(loc).index);
             }
 
             try writeI32Const(writer, 0);
             try writeI32Const(writer, segment.size);
             try writer.writeByte(std.wasm.opcode(.misc_prefix));
-            if (std.mem.eql(u8, entry.key_ptr.*, ".bss")) {
+            if (std.mem.eql(u8, key, ".bss")) {
                 // fill bss segment with zeroes
                 try leb.writeUleb128(writer, std.wasm.miscOpcode(.memory_fill));
             } else {
@@ -1087,11 +1198,9 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
         try writer.writeByte(std.wasm.opcode(.end)); // end $drop
     }
 
-    it.reset();
-    segment_index = 0;
-    while (it.next()) |entry| : (segment_index += 1) {
-        const name = entry.key_ptr.*;
-        const segment: Segment = wasm.segments.items[entry.value_ptr.*];
+    for (wasm.data_segments.keys(), wasm.data_segments.values(), 0..) |name, value, segment_index_usize| {
+        const segment_index: u32 = @intCast(segment_index_usize);
+        const segment = wasm.segmentPtr(value);
         if (segment.needsPassiveInitialization(import_memory, name) and
             !std.mem.eql(u8, name, ".bss"))
         {
@@ -1111,7 +1220,7 @@ fn setupInitMemoryFunction(wasm: *Wasm) !void {
     try writer.writeByte(std.wasm.opcode(.end));
 
     try wasm.createSyntheticFunction(
-        "__wasm_init_memory",
+        wasm.preloaded_strings.__wasm_init_memory,
         std.wasm.Type{ .params = &.{}, .returns = &.{} },
         &function_body,
     );
@@ -1130,8 +1239,8 @@ fn setupTLSRelocationsFunction(wasm: *Wasm) !void {
         return;
     }
 
-    const loc = try wasm.createSyntheticSymbol("__wasm_apply_global_tls_relocs", .function);
-    loc.getSymbol(wasm).mark();
+    const loc = try wasm.createSyntheticSymbol(wasm.preloaded_strings.__wasm_apply_global_tls_relocs, .function);
+    wasm.symbolLocSymbol(loc).mark();
     var function_body = std.ArrayList(u8).init(gpa);
     defer function_body.deinit();
     const writer = function_body.writer();
@@ -1139,12 +1248,12 @@ fn setupTLSRelocationsFunction(wasm: *Wasm) !void {
     // locals (we have none)
     try writer.writeByte(0);
     for (wasm.got_symbols.items, 0..) |got_loc, got_index| {
-        const sym: *Symbol = got_loc.getSymbol(wasm);
+        const sym: *Symbol = wasm.symbolLocSymbol(got_loc);
         if (!sym.isTLS()) continue; // only relocate TLS symbols
         if (sym.tag == .data and sym.isDefined()) {
             // get __tls_base
             try writer.writeByte(std.wasm.opcode(.global_get));
-            try leb.writeUleb128(writer, wasm.findGlobalSymbol("__tls_base").?.getSymbol(wasm).index);
+            try leb.writeUleb128(writer, wasm.symbolLocSymbol(wasm.globals.get(wasm.preloaded_strings.__tls_base).?).index);
 
             // add the virtual address of the symbol
             try writer.writeByte(std.wasm.opcode(.i32_const));
@@ -1160,7 +1269,7 @@ fn setupTLSRelocationsFunction(wasm: *Wasm) !void {
     try writer.writeByte(std.wasm.opcode(.end));
 
     try wasm.createSyntheticFunction(
-        "__wasm_apply_global_tls_relocs",
+        wasm.preloaded_strings.__wasm_apply_global_tls_relocs,
         std.wasm.Type{ .params = &.{}, .returns = &.{} },
         &function_body,
     );
@@ -1168,15 +1277,16 @@ fn setupTLSRelocationsFunction(wasm: *Wasm) !void {
 
 fn validateFeatures(
     wasm: *const Wasm,
-    to_emit: *[@typeInfo(types.Feature.Tag).@"enum".fields.len]bool,
+    to_emit: *[@typeInfo(Feature.Tag).@"enum".fields.len]bool,
     emit_features_count: *u32,
 ) !void {
     const comp = wasm.base.comp;
+    const diags = &wasm.base.comp.link_diags;
     const target = comp.root_mod.resolved_target.result;
     const shared_memory = comp.config.shared_memory;
     const cpu_features = target.cpu.features;
     const infer = cpu_features.isEmpty(); // when the user did not define any features, we infer them from linked objects.
-    const known_features_count = @typeInfo(types.Feature.Tag).@"enum".fields.len;
+    const known_features_count = @typeInfo(Feature.Tag).@"enum".fields.len;
 
     var allowed = [_]bool{false} ** known_features_count;
     var used = [_]u17{0} ** known_features_count;
@@ -1201,10 +1311,9 @@ fn validateFeatures(
 
     // extract all the used, disallowed and required features from each
     // linked object file so we can test them.
-    for (wasm.objects.items) |file_index| {
-        const object: Object = wasm.files.items(.data)[@intFromEnum(file_index)].object;
+    for (wasm.objects.items, 0..) |*object, file_index| {
         for (object.features) |feature| {
-            const value = @as(u16, @intFromEnum(file_index)) << 1 | @as(u1, 1);
+            const value = (@as(u16, @intCast(file_index)) << 1) | 1;
             switch (feature.prefix) {
                 .used => {
                     used[@intFromEnum(feature.tag)] = value;
@@ -1235,9 +1344,11 @@ fn validateFeatures(
             allowed[used_index] = is_enabled;
             emit_features_count.* += @intFromBool(is_enabled);
         } else if (is_enabled and !allowed[used_index]) {
-            var err = try wasm.base.addErrorWithNotes(1);
-            try err.addMsg("feature '{}' not allowed, but used by linked object", .{@as(types.Feature.Tag, @enumFromInt(used_index))});
-            try err.addNote("defined in '{s}'", .{wasm.files.items(.data)[used_set >> 1].object.path});
+            diags.addParseError(
+                wasm.objects.items[used_set >> 1].path,
+                "feature '{}' not allowed, but used by linked object",
+                .{@as(Feature.Tag, @enumFromInt(used_index))},
+            );
             valid_feature_set = false;
         }
     }
@@ -1247,45 +1358,44 @@ fn validateFeatures(
     }
 
     if (shared_memory) {
-        const disallowed_feature = disallowed[@intFromEnum(types.Feature.Tag.shared_mem)];
+        const disallowed_feature = disallowed[@intFromEnum(Feature.Tag.shared_mem)];
         if (@as(u1, @truncate(disallowed_feature)) != 0) {
-            var err = try wasm.base.addErrorWithNotes(0);
-            try err.addMsg(
-                "shared-memory is disallowed by '{s}' because it wasn't compiled with 'atomics' and 'bulk-memory' features enabled",
-                .{wasm.files.items(.data)[disallowed_feature >> 1].object.path},
+            diags.addParseError(
+                wasm.objects.items[disallowed_feature >> 1].path,
+                "shared-memory is disallowed because it wasn't compiled with 'atomics' and 'bulk-memory' features enabled",
+                .{},
             );
             valid_feature_set = false;
         }
 
-        for ([_]types.Feature.Tag{ .atomics, .bulk_memory }) |feature| {
+        for ([_]Feature.Tag{ .atomics, .bulk_memory }) |feature| {
             if (!allowed[@intFromEnum(feature)]) {
-                var err = try wasm.base.addErrorWithNotes(0);
+                var err = try diags.addErrorWithNotes(0);
                 try err.addMsg("feature '{}' is not used but is required for shared-memory", .{feature});
             }
         }
     }
 
     if (has_tls) {
-        for ([_]types.Feature.Tag{ .atomics, .bulk_memory }) |feature| {
+        for ([_]Feature.Tag{ .atomics, .bulk_memory }) |feature| {
             if (!allowed[@intFromEnum(feature)]) {
-                var err = try wasm.base.addErrorWithNotes(0);
+                var err = try diags.addErrorWithNotes(0);
                 try err.addMsg("feature '{}' is not used but is required for thread-local storage", .{feature});
             }
         }
     }
     // For each linked object, validate the required and disallowed features
-    for (wasm.objects.items) |file_index| {
+    for (wasm.objects.items) |*object| {
         var object_used_features = [_]bool{false} ** known_features_count;
-        const object = wasm.files.items(.data)[@intFromEnum(file_index)].object;
         for (object.features) |feature| {
             if (feature.prefix == .disallowed) continue; // already defined in 'disallowed' set.
             // from here a feature is always used
             const disallowed_feature = disallowed[@intFromEnum(feature.tag)];
             if (@as(u1, @truncate(disallowed_feature)) != 0) {
-                var err = try wasm.base.addErrorWithNotes(2);
+                var err = try diags.addErrorWithNotes(2);
                 try err.addMsg("feature '{}' is disallowed, but used by linked object", .{feature.tag});
-                try err.addNote("disallowed by '{s}'", .{wasm.files.items(.data)[disallowed_feature >> 1].object.path});
-                try err.addNote("used in '{s}'", .{object.path});
+                try err.addNote("disallowed by '{'}'", .{wasm.objects.items[disallowed_feature >> 1].path});
+                try err.addNote("used in '{'}'", .{object.path});
                 valid_feature_set = false;
             }
 
@@ -1296,10 +1406,10 @@ fn validateFeatures(
         for (required, 0..) |required_feature, feature_index| {
             const is_required = @as(u1, @truncate(required_feature)) != 0;
             if (is_required and !object_used_features[feature_index]) {
-                var err = try wasm.base.addErrorWithNotes(2);
-                try err.addMsg("feature '{}' is required but not used in linked object", .{@as(types.Feature.Tag, @enumFromInt(feature_index))});
-                try err.addNote("required by '{s}'", .{wasm.files.items(.data)[required_feature >> 1].object.path});
-                try err.addNote("missing in '{s}'", .{object.path});
+                var err = try diags.addErrorWithNotes(2);
+                try err.addMsg("feature '{}' is required but not used in linked object", .{@as(Feature.Tag, @enumFromInt(feature_index))});
+                try err.addNote("required by '{'}'", .{wasm.objects.items[required_feature >> 1].path});
+                try err.addNote("missing in '{'}'", .{object.path});
                 valid_feature_set = false;
             }
         }
@@ -1321,7 +1431,7 @@ fn resolveLazySymbols(wasm: *Wasm) !void {
     const gpa = comp.gpa;
     const shared_memory = comp.config.shared_memory;
 
-    if (wasm.string_table.getOffset("__heap_base")) |name_offset| {
+    if (wasm.getExistingString("__heap_base")) |name_offset| {
         if (wasm.undefs.fetchSwapRemove(name_offset)) |kv| {
             const loc = try wasm.createSyntheticSymbolOffset(name_offset, .data);
             try wasm.discarded.putNoClobber(gpa, kv.value, loc);
@@ -1329,7 +1439,7 @@ fn resolveLazySymbols(wasm: *Wasm) !void {
         }
     }
 
-    if (wasm.string_table.getOffset("__heap_end")) |name_offset| {
+    if (wasm.getExistingString("__heap_end")) |name_offset| {
         if (wasm.undefs.fetchSwapRemove(name_offset)) |kv| {
             const loc = try wasm.createSyntheticSymbolOffset(name_offset, .data);
             try wasm.discarded.putNoClobber(gpa, kv.value, loc);
@@ -1338,12 +1448,12 @@ fn resolveLazySymbols(wasm: *Wasm) !void {
     }
 
     if (!shared_memory) {
-        if (wasm.string_table.getOffset("__tls_base")) |name_offset| {
+        if (wasm.getExistingString("__tls_base")) |name_offset| {
             if (wasm.undefs.fetchSwapRemove(name_offset)) |kv| {
                 const loc = try wasm.createSyntheticSymbolOffset(name_offset, .global);
                 try wasm.discarded.putNoClobber(gpa, kv.value, loc);
                 _ = wasm.resolved_symbols.swapRemove(kv.value);
-                const symbol = loc.getSymbol(wasm);
+                const symbol = wasm.symbolLocSymbol(loc);
                 symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
                 symbol.index = @intCast(wasm.imported_globals_count + wasm.wasm_globals.items.len);
                 try wasm.wasm_globals.append(gpa, .{
@@ -1355,35 +1465,41 @@ fn resolveLazySymbols(wasm: *Wasm) !void {
     }
 }
 
-// Tries to find a global symbol by its name. Returns null when not found,
-/// and its location when it is found.
-pub fn findGlobalSymbol(wasm: *Wasm, name: []const u8) ?SymbolLoc {
-    const offset = wasm.string_table.getOffset(name) orelse return null;
-    return wasm.globals.get(offset);
+pub fn findGlobalSymbol(wasm: *const Wasm, name: []const u8) ?SymbolLoc {
+    const name_index = wasm.getExistingString(name) orelse return null;
+    return wasm.globals.get(name_index);
 }
 
 fn checkUndefinedSymbols(wasm: *const Wasm) !void {
     const comp = wasm.base.comp;
+    const diags = &wasm.base.comp.link_diags;
     if (comp.config.output_mode == .Obj) return;
     if (wasm.import_symbols) return;
 
     var found_undefined_symbols = false;
     for (wasm.undefs.values()) |undef| {
-        const symbol = undef.getSymbol(wasm);
+        const symbol = wasm.symbolLocSymbol(undef);
         if (symbol.tag == .data) {
             found_undefined_symbols = true;
-            const file_name = if (wasm.file(undef.file)) |obj_file|
-                obj_file.path()
-            else
-                wasm.name;
-            const symbol_name = undef.getName(wasm);
-            var err = try wasm.base.addErrorWithNotes(1);
-            try err.addMsg("could not resolve undefined symbol '{s}'", .{symbol_name});
-            try err.addNote("defined in '{s}'", .{file_name});
+            const symbol_name = wasm.symbolLocName(undef);
+            switch (undef.file) {
+                .zig_object => {
+                    // TODO: instead of saying the zig compilation unit, attach an actual source location
+                    // to this diagnostic
+                    diags.addError("unresolved symbol in Zig compilation unit: {s}", .{symbol_name});
+                },
+                .none => {
+                    diags.addError("internal linker bug: unresolved synthetic symbol: {s}", .{symbol_name});
+                },
+                _ => {
+                    const path = wasm.objects.items[@intFromEnum(undef.file)].path;
+                    diags.addParseError(path, "unresolved symbol: {s}", .{symbol_name});
+                },
+            }
         }
     }
     if (found_undefined_symbols) {
-        return error.FlushFailure;
+        return error.LinkFailure;
     }
 }
 
@@ -1397,18 +1513,17 @@ pub fn deinit(wasm: *Wasm) void {
     for (wasm.segment_info.values()) |segment_info| {
         gpa.free(segment_info.name);
     }
-    if (wasm.zigObjectPtr()) |zig_obj| {
+    if (wasm.zig_object) |zig_obj| {
         zig_obj.deinit(wasm);
     }
-    for (wasm.objects.items) |obj_index| {
-        wasm.file(obj_index).?.object.deinit(gpa);
+    for (wasm.objects.items) |*object| {
+        object.deinit(gpa);
     }
 
-    for (wasm.archives.items) |*archive| {
-        archive.deinit(gpa);
-    }
+    for (wasm.lazy_archives.items) |*lazy_archive| lazy_archive.deinit(gpa);
+    wasm.lazy_archives.deinit(gpa);
 
-    if (wasm.findGlobalSymbol("__wasm_init_tls")) |loc| {
+    if (wasm.globals.get(wasm.preloaded_strings.__wasm_init_tls)) |loc| {
         const atom = wasm.symbol_atom.get(loc).?;
         wasm.getAtomPtr(atom).deinit(gpa);
     }
@@ -1425,7 +1540,6 @@ pub fn deinit(wasm: *Wasm) void {
     wasm.data_segments.deinit(gpa);
     wasm.segment_info.deinit(gpa);
     wasm.objects.deinit(gpa);
-    wasm.archives.deinit(gpa);
 
     // free output sections
     wasm.imports.deinit(gpa);
@@ -1437,8 +1551,9 @@ pub fn deinit(wasm: *Wasm) void {
     wasm.init_funcs.deinit(gpa);
     wasm.exports.deinit(gpa);
 
+    wasm.string_bytes.deinit(gpa);
     wasm.string_table.deinit(gpa);
-    wasm.files.deinit(gpa);
+    wasm.dump_argv_list.deinit(gpa);
 }
 
 pub fn updateFunc(wasm: *Wasm, pt: Zcu.PerThread, func_index: InternPool.Index, air: Air, liveness: Liveness) !void {
@@ -1446,7 +1561,7 @@ pub fn updateFunc(wasm: *Wasm, pt: Zcu.PerThread, func_index: InternPool.Index,
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
     if (wasm.llvm_object) |llvm_object| return llvm_object.updateFunc(pt, func_index, air, liveness);
-    try wasm.zigObjectPtr().?.updateFunc(wasm, pt, func_index, air, liveness);
+    try wasm.zig_object.?.updateFunc(wasm, pt, func_index, air, liveness);
 }
 
 // Generate code for the "Nav", storing it in memory to be later written to
@@ -1456,51 +1571,84 @@ pub fn updateNav(wasm: *Wasm, pt: Zcu.PerThread, nav: InternPool.Nav.Index) !voi
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
     if (wasm.llvm_object) |llvm_object| return llvm_object.updateNav(pt, nav);
-    try wasm.zigObjectPtr().?.updateNav(wasm, pt, nav);
+    try wasm.zig_object.?.updateNav(wasm, pt, nav);
 }
 
 pub fn updateNavLineNumber(wasm: *Wasm, pt: Zcu.PerThread, nav: InternPool.Nav.Index) !void {
     if (wasm.llvm_object) |_| return;
-    try wasm.zigObjectPtr().?.updateNavLineNumber(pt, nav);
+    try wasm.zig_object.?.updateNavLineNumber(pt, nav);
 }
 
 /// From a given symbol location, returns its `wasm.GlobalType`.
 /// Asserts the Symbol represents a global.
 fn getGlobalType(wasm: *const Wasm, loc: SymbolLoc) std.wasm.GlobalType {
-    const symbol = loc.getSymbol(wasm);
+    const symbol = wasm.symbolLocSymbol(loc);
     assert(symbol.tag == .global);
     const is_undefined = symbol.isUndefined();
-    if (wasm.file(loc.file)) |obj_file| {
-        if (is_undefined) {
-            return obj_file.import(loc.index).kind.global;
-        }
-        return obj_file.globals()[symbol.index - obj_file.importedGlobals()].global_type;
-    }
-    if (is_undefined) {
-        return wasm.imports.get(loc).?.kind.global;
+    switch (loc.file) {
+        .zig_object => {
+            const zo = wasm.zig_object.?;
+            return if (is_undefined)
+                zo.imports.get(loc.index).?.kind.global
+            else
+                zo.globals.items[symbol.index - zo.imported_globals_count].global_type;
+        },
+        .none => {
+            return if (is_undefined)
+                wasm.imports.get(loc).?.kind.global
+            else
+                wasm.wasm_globals.items[symbol.index].global_type;
+        },
+        _ => {
+            const obj = &wasm.objects.items[@intFromEnum(loc.file)];
+            return if (is_undefined)
+                obj.findImport(obj.symtable[@intFromEnum(loc.index)]).kind.global
+            else
+                obj.globals[symbol.index - obj.imported_globals_count].global_type;
+        },
     }
-    return wasm.wasm_globals.items[symbol.index].global_type;
 }
 
 /// From a given symbol location, returns its `wasm.Type`.
 /// Asserts the Symbol represents a function.
 fn getFunctionSignature(wasm: *const Wasm, loc: SymbolLoc) std.wasm.Type {
-    const symbol = loc.getSymbol(wasm);
+    const symbol = wasm.symbolLocSymbol(loc);
     assert(symbol.tag == .function);
     const is_undefined = symbol.isUndefined();
-    if (wasm.file(loc.file)) |obj_file| {
-        if (is_undefined) {
-            const ty_index = obj_file.import(loc.index).kind.function;
-            return obj_file.funcTypes()[ty_index];
-        }
-        const type_index = obj_file.function(loc.index).type_index;
-        return obj_file.funcTypes()[type_index];
-    }
-    if (is_undefined) {
-        const ty_index = wasm.imports.get(loc).?.kind.function;
-        return wasm.func_types.items[ty_index];
+    switch (loc.file) {
+        .zig_object => {
+            const zo = wasm.zig_object.?;
+            if (is_undefined) {
+                const type_index = zo.imports.get(loc.index).?.kind.function;
+                return zo.func_types.items[type_index];
+            }
+            const sym = zo.symbols.items[@intFromEnum(loc.index)];
+            const type_index = zo.functions.items[sym.index].type_index;
+            return zo.func_types.items[type_index];
+        },
+        .none => {
+            if (is_undefined) {
+                const type_index = wasm.imports.get(loc).?.kind.function;
+                return wasm.func_types.items[type_index];
+            }
+            return wasm.func_types.items[
+                wasm.functions.get(.{
+                    .file = .none,
+                    .index = symbol.index,
+                }).?.func.type_index
+            ];
+        },
+        _ => {
+            const obj = &wasm.objects.items[@intFromEnum(loc.file)];
+            if (is_undefined) {
+                const type_index = obj.findImport(obj.symtable[@intFromEnum(loc.index)]).kind.function;
+                return obj.func_types[type_index];
+            }
+            const sym = obj.symtable[@intFromEnum(loc.index)];
+            const type_index = obj.functions[sym.index - obj.imported_functions_count].type_index;
+            return obj.func_types[type_index];
+        },
     }
-    return wasm.func_types.items[wasm.functions.get(.{ .file = loc.file, .index = symbol.index }).?.func.type_index];
 }
 
 /// Returns the symbol index from a symbol of which its flag is set global,
@@ -1509,7 +1657,8 @@ fn getFunctionSignature(wasm: *const Wasm, loc: SymbolLoc) std.wasm.Type {
 /// and then returns the index to it.
 pub fn getGlobalSymbol(wasm: *Wasm, name: []const u8, lib_name: ?[]const u8) !Symbol.Index {
     _ = lib_name;
-    return wasm.zigObjectPtr().?.getGlobalSymbol(wasm.base.comp.gpa, name);
+    const name_index = try wasm.internString(name);
+    return wasm.zig_object.?.getGlobalSymbol(wasm.base.comp.gpa, name_index);
 }
 
 /// For a given `Nav`, find the given symbol index's atom, and create a relocation for the type.
@@ -1520,7 +1669,7 @@ pub fn getNavVAddr(
     nav: InternPool.Nav.Index,
     reloc_info: link.File.RelocInfo,
 ) !u64 {
-    return wasm.zigObjectPtr().?.getNavVAddr(wasm, pt, nav, reloc_info);
+    return wasm.zig_object.?.getNavVAddr(wasm, pt, nav, reloc_info);
 }
 
 pub fn lowerUav(
@@ -1530,11 +1679,11 @@ pub fn lowerUav(
     explicit_alignment: Alignment,
     src_loc: Zcu.LazySrcLoc,
 ) !codegen.GenResult {
-    return wasm.zigObjectPtr().?.lowerUav(wasm, pt, uav, explicit_alignment, src_loc);
+    return wasm.zig_object.?.lowerUav(wasm, pt, uav, explicit_alignment, src_loc);
 }
 
 pub fn getUavVAddr(wasm: *Wasm, uav: InternPool.Index, reloc_info: link.File.RelocInfo) !u64 {
-    return wasm.zigObjectPtr().?.getUavVAddr(wasm, uav, reloc_info);
+    return wasm.zig_object.?.getUavVAddr(wasm, uav, reloc_info);
 }
 
 pub fn deleteExport(
@@ -1543,7 +1692,7 @@ pub fn deleteExport(
     name: InternPool.NullTerminatedString,
 ) void {
     if (wasm.llvm_object) |_| return;
-    return wasm.zigObjectPtr().?.deleteExport(wasm, exported, name);
+    return wasm.zig_object.?.deleteExport(wasm, exported, name);
 }
 
 pub fn updateExports(
@@ -1556,12 +1705,12 @@ pub fn updateExports(
         @panic("Attempted to compile for object format that was disabled by build configuration");
     }
     if (wasm.llvm_object) |llvm_object| return llvm_object.updateExports(pt, exported, export_indices);
-    return wasm.zigObjectPtr().?.updateExports(wasm, pt, exported, export_indices);
+    return wasm.zig_object.?.updateExports(wasm, pt, exported, export_indices);
 }
 
 pub fn freeDecl(wasm: *Wasm, decl_index: InternPool.DeclIndex) void {
     if (wasm.llvm_object) |llvm_object| return llvm_object.freeDecl(decl_index);
-    return wasm.zigObjectPtr().?.freeDecl(wasm, decl_index);
+    return wasm.zig_object.?.freeDecl(wasm, decl_index);
 }
 
 /// Assigns indexes to all indirect functions.
@@ -1571,7 +1720,7 @@ fn mapFunctionTable(wasm: *Wasm) void {
     var it = wasm.function_table.iterator();
     var index: u32 = 1;
     while (it.next()) |entry| {
-        const symbol = entry.key_ptr.*.getSymbol(wasm);
+        const symbol = wasm.symbolLocSymbol(entry.key_ptr.*);
         if (symbol.isAlive()) {
             entry.value_ptr.* = index;
             index += 1;
@@ -1581,13 +1730,13 @@ fn mapFunctionTable(wasm: *Wasm) void {
     }
 
     if (wasm.import_table or wasm.base.comp.config.output_mode == .Obj) {
-        const sym_loc = wasm.findGlobalSymbol("__indirect_function_table").?;
+        const sym_loc = wasm.globals.get(wasm.preloaded_strings.__indirect_function_table).?;
         const import = wasm.imports.getPtr(sym_loc).?;
         import.kind.table.limits.min = index - 1; // we start at index 1.
     } else if (index > 1) {
         log.debug("Appending indirect function table", .{});
-        const sym_loc = wasm.findGlobalSymbol("__indirect_function_table").?;
-        const symbol = sym_loc.getSymbol(wasm);
+        const sym_loc = wasm.globals.get(wasm.preloaded_strings.__indirect_function_table).?;
+        const symbol = wasm.symbolLocSymbol(sym_loc);
         const table = &wasm.tables.items[symbol.index - wasm.imported_tables_count];
         table.limits = .{ .min = index, .max = index, .flags = 0x1 };
     }
@@ -1595,7 +1744,7 @@ fn mapFunctionTable(wasm: *Wasm) void {
 
 /// From a given index, append the given `Atom` at the back of the linked list.
 /// Simply inserts it into the map of atoms when it doesn't exist yet.
-pub fn appendAtomAtIndex(wasm: *Wasm, index: u32, atom_index: Atom.Index) !void {
+pub fn appendAtomAtIndex(wasm: *Wasm, index: Segment.Index, atom_index: Atom.Index) !void {
     const gpa = wasm.base.comp.gpa;
     const atom = wasm.getAtomPtr(atom_index);
     if (wasm.atoms.getPtr(index)) |last_index_ptr| {
@@ -1612,9 +1761,9 @@ fn allocateAtoms(wasm: *Wasm) !void {
 
     var it = wasm.atoms.iterator();
     while (it.next()) |entry| {
-        const segment = &wasm.segments.items[entry.key_ptr.*];
+        const segment = wasm.segmentPtr(entry.key_ptr.*);
         var atom_index = entry.value_ptr.*;
-        if (entry.key_ptr.* == wasm.code_section_index) {
+        if (entry.key_ptr.toOptional() == wasm.code_section_index) {
             // Code section is allocated upon writing as they are required to be ordered
             // to synchronise with the function section.
             continue;
@@ -1626,10 +1775,11 @@ fn allocateAtoms(wasm: *Wasm) !void {
             // Ensure we get the original symbol, so we verify the correct symbol on whether
             // it is dead or not and ensure an atom is removed when dead.
             // This is required as we may have parsed aliases into atoms.
-            const sym = if (wasm.file(symbol_loc.file)) |obj_file|
-                obj_file.symbol(symbol_loc.index).*
-            else
-                wasm.synthetic_symbols.items[@intFromEnum(symbol_loc.index)];
+            const sym = switch (symbol_loc.file) {
+                .zig_object => wasm.zig_object.?.symbols.items[@intFromEnum(symbol_loc.index)],
+                .none => wasm.synthetic_symbols.items[@intFromEnum(symbol_loc.index)],
+                _ => wasm.objects.items[@intFromEnum(symbol_loc.file)].symtable[@intFromEnum(symbol_loc.index)],
+            };
 
             // Dead symbols must be unlinked from the linked-list to prevent them
             // from being emit into the binary.
@@ -1648,7 +1798,7 @@ fn allocateAtoms(wasm: *Wasm) !void {
             offset = @intCast(atom.alignment.forward(offset));
             atom.offset = offset;
             log.debug("Atom '{s}' allocated from 0x{x:0>8} to 0x{x:0>8} size={d}", .{
-                symbol_loc.getName(wasm),
+                wasm.symbolLocName(symbol_loc),
                 offset,
                 offset + atom.size,
                 atom.size,
@@ -1664,7 +1814,7 @@ fn allocateAtoms(wasm: *Wasm) !void {
 /// For each data symbol, sets the virtual address.
 fn allocateVirtualAddresses(wasm: *Wasm) void {
     for (wasm.resolved_symbols.keys()) |loc| {
-        const symbol = loc.getSymbol(wasm);
+        const symbol = wasm.symbolLocSymbol(loc);
         if (symbol.tag != .data or symbol.isDead()) {
             // Only data symbols have virtual addresses.
             // Dead symbols do not get allocated, so we don't need to set their virtual address either.
@@ -1677,13 +1827,14 @@ fn allocateVirtualAddresses(wasm: *Wasm) void {
 
         const atom = wasm.getAtom(atom_index);
         const merge_segment = wasm.base.comp.config.output_mode != .Obj;
-        const segment_info = if (atom.file != .null)
-            wasm.file(atom.file).?.segmentInfo()
-        else
-            wasm.segment_info.values();
+        const segment_info = switch (atom.file) {
+            .zig_object => wasm.zig_object.?.segment_info.items,
+            .none => wasm.segment_info.values(),
+            _ => wasm.objects.items[@intFromEnum(atom.file)].segment_info,
+        };
         const segment_name = segment_info[symbol.index].outputName(merge_segment);
         const segment_index = wasm.data_segments.get(segment_name).?;
-        const segment = wasm.segments.items[segment_index];
+        const segment = wasm.segmentPtr(segment_index);
 
         // TLS symbols have their virtual address set relative to their own TLS segment,
         // rather than the entire Data section.
@@ -1697,7 +1848,7 @@ fn allocateVirtualAddresses(wasm: *Wasm) void {
 
 fn sortDataSegments(wasm: *Wasm) !void {
     const gpa = wasm.base.comp.gpa;
-    var new_mapping: std.StringArrayHashMapUnmanaged(u32) = .empty;
+    var new_mapping: std.StringArrayHashMapUnmanaged(Segment.Index) = .empty;
     try new_mapping.ensureUnusedCapacity(gpa, wasm.data_segments.count());
     errdefer new_mapping.deinit(gpa);
 
@@ -1736,14 +1887,14 @@ fn sortDataSegments(wasm: *Wasm) !void {
 /// contain any parameters.
 fn setupInitFunctions(wasm: *Wasm) !void {
     const gpa = wasm.base.comp.gpa;
+    const diags = &wasm.base.comp.link_diags;
     // There's no constructors for Zig so we can simply search through linked object files only.
-    for (wasm.objects.items) |file_index| {
-        const object: Object = wasm.files.items(.data)[@intFromEnum(file_index)].object;
+    for (wasm.objects.items, 0..) |*object, object_index| {
         try wasm.init_funcs.ensureUnusedCapacity(gpa, object.init_funcs.len);
         for (object.init_funcs) |init_func| {
             const symbol = object.symtable[init_func.symbol_index];
             const ty: std.wasm.Type = if (symbol.isUndefined()) ty: {
-                const imp: types.Import = object.findImport(symbol);
+                const imp: Import = object.findImport(symbol);
                 break :ty object.func_types[imp.kind.function];
             } else ty: {
                 const func_index = symbol.index - object.imported_functions_count;
@@ -1751,16 +1902,19 @@ fn setupInitFunctions(wasm: *Wasm) !void {
                 break :ty object.func_types[func.type_index];
             };
             if (ty.params.len != 0) {
-                var err = try wasm.base.addErrorWithNotes(0);
-                try err.addMsg("constructor functions cannot take arguments: '{s}'", .{object.string_table.get(symbol.name)});
+                var err = try diags.addErrorWithNotes(0);
+                try err.addMsg("constructor functions cannot take arguments: '{s}'", .{wasm.stringSlice(symbol.name)});
             }
-            log.debug("appended init func '{s}'\n", .{object.string_table.get(symbol.name)});
+            log.debug("appended init func '{s}'\n", .{wasm.stringSlice(symbol.name)});
             wasm.init_funcs.appendAssumeCapacity(.{
                 .index = @enumFromInt(init_func.symbol_index),
-                .file = file_index,
+                .file = @enumFromInt(object_index),
                 .priority = init_func.priority,
             });
-            try wasm.mark(.{ .index = @enumFromInt(init_func.symbol_index), .file = file_index });
+            try wasm.mark(.{
+                .index = @enumFromInt(init_func.symbol_index),
+                .file = @enumFromInt(object_index),
+            });
         }
     }
 
@@ -1768,7 +1922,7 @@ fn setupInitFunctions(wasm: *Wasm) !void {
     mem.sort(InitFuncLoc, wasm.init_funcs.items, {}, InitFuncLoc.lessThan);
 
     if (wasm.init_funcs.items.len > 0) {
-        const loc = wasm.findGlobalSymbol("__wasm_call_ctors").?;
+        const loc = wasm.globals.get(wasm.preloaded_strings.__wasm_call_ctors).?;
         try wasm.mark(loc);
     }
 }
@@ -1782,10 +1936,10 @@ fn setupInitFunctions(wasm: *Wasm) !void {
 fn initializeCallCtorsFunction(wasm: *Wasm) !void {
     const gpa = wasm.base.comp.gpa;
     // No code to emit, so also no ctors to call
-    if (wasm.code_section_index == null) {
+    if (wasm.code_section_index == .none) {
         // Make sure to remove it from the resolved symbols so we do not emit
         // it within any section. TODO: Remove this once we implement garbage collection.
-        const loc = wasm.findGlobalSymbol("__wasm_call_ctors").?;
+        const loc = wasm.globals.get(wasm.preloaded_strings.__wasm_call_ctors).?;
         assert(wasm.resolved_symbols.swapRemove(loc));
         return;
     }
@@ -1820,7 +1974,7 @@ fn initializeCallCtorsFunction(wasm: *Wasm) !void {
     }
 
     try wasm.createSyntheticFunction(
-        "__wasm_call_ctors",
+        wasm.preloaded_strings.__wasm_call_ctors,
         std.wasm.Type{ .params = &.{}, .returns = &.{} },
         &function_body,
     );
@@ -1828,13 +1982,13 @@ fn initializeCallCtorsFunction(wasm: *Wasm) !void {
 
 fn createSyntheticFunction(
     wasm: *Wasm,
-    symbol_name: []const u8,
+    symbol_name: String,
     func_ty: std.wasm.Type,
     function_body: *std.ArrayList(u8),
 ) !void {
     const gpa = wasm.base.comp.gpa;
-    const loc = wasm.findGlobalSymbol(symbol_name).?; // forgot to create symbol?
-    const symbol = loc.getSymbol(wasm);
+    const loc = wasm.globals.get(symbol_name).?;
+    const symbol = wasm.symbolLocSymbol(loc);
     if (symbol.isDead()) {
         return;
     }
@@ -1843,17 +1997,17 @@ fn createSyntheticFunction(
     const func_index = wasm.imported_functions_count + @as(u32, @intCast(wasm.functions.count()));
     try wasm.functions.putNoClobber(
         gpa,
-        .{ .file = .null, .index = func_index },
+        .{ .file = .none, .index = func_index },
         .{ .func = .{ .type_index = ty_index }, .sym_index = loc.index },
     );
     symbol.index = func_index;
 
     // create the atom that will be output into the final binary
-    const atom_index = try wasm.createAtom(loc.index, .null);
+    const atom_index = try wasm.createAtom(loc.index, .none);
     const atom = wasm.getAtomPtr(atom_index);
     atom.size = @intCast(function_body.items.len);
     atom.code = function_body.moveToUnmanaged();
-    try wasm.appendAtomAtIndex(wasm.code_section_index.?, atom_index);
+    try wasm.appendAtomAtIndex(wasm.code_section_index.unwrap().?, atom_index);
 }
 
 /// Unlike `createSyntheticFunction` this function is to be called by
@@ -1866,13 +2020,13 @@ pub fn createFunction(
     function_body: *std.ArrayList(u8),
     relocations: *std.ArrayList(Relocation),
 ) !Symbol.Index {
-    return wasm.zigObjectPtr().?.createFunction(wasm, symbol_name, func_ty, function_body, relocations);
+    return wasm.zig_object.?.createFunction(wasm, symbol_name, func_ty, function_body, relocations);
 }
 
 /// If required, sets the function index in the `start` section.
 fn setupStartSection(wasm: *Wasm) !void {
-    if (wasm.findGlobalSymbol("__wasm_init_memory")) |loc| {
-        wasm.entry = loc.getSymbol(wasm).index;
+    if (wasm.globals.get(wasm.preloaded_strings.__wasm_init_memory)) |loc| {
+        wasm.entry = wasm.symbolLocSymbol(loc).index;
     }
 }
 
@@ -1884,7 +2038,7 @@ fn initializeTLSFunction(wasm: *Wasm) !void {
     if (!shared_memory) return;
 
     // ensure function is marked as we must emit it
-    wasm.findGlobalSymbol("__wasm_init_tls").?.getSymbol(wasm).mark();
+    wasm.symbolLocSymbol(wasm.globals.get(wasm.preloaded_strings.__wasm_init_tls).?).mark();
 
     var function_body = std.ArrayList(u8).init(gpa);
     defer function_body.deinit();
@@ -1896,16 +2050,16 @@ fn initializeTLSFunction(wasm: *Wasm) !void {
     // If there's a TLS segment, initialize it during runtime using the bulk-memory feature
     if (wasm.data_segments.getIndex(".tdata")) |data_index| {
         const segment_index = wasm.data_segments.entries.items(.value)[data_index];
-        const segment = wasm.segments.items[segment_index];
+        const segment = wasm.segmentPtr(segment_index);
 
         const param_local: u32 = 0;
 
         try writer.writeByte(std.wasm.opcode(.local_get));
         try leb.writeUleb128(writer, param_local);
 
-        const tls_base_loc = wasm.findGlobalSymbol("__tls_base").?;
+        const tls_base_loc = wasm.globals.get(wasm.preloaded_strings.__tls_base).?;
         try writer.writeByte(std.wasm.opcode(.global_set));
-        try leb.writeUleb128(writer, tls_base_loc.getSymbol(wasm).index);
+        try leb.writeUleb128(writer, wasm.symbolLocSymbol(tls_base_loc).index);
 
         // load stack values for the bulk-memory operation
         {
@@ -1931,16 +2085,16 @@ fn initializeTLSFunction(wasm: *Wasm) !void {
     // If we have to perform any TLS relocations, call the corresponding function
     // which performs all runtime TLS relocations. This is a synthetic function,
     // generated by the linker.
-    if (wasm.findGlobalSymbol("__wasm_apply_global_tls_relocs")) |loc| {
+    if (wasm.globals.get(wasm.preloaded_strings.__wasm_apply_global_tls_relocs)) |loc| {
         try writer.writeByte(std.wasm.opcode(.call));
-        try leb.writeUleb128(writer, loc.getSymbol(wasm).index);
-        loc.getSymbol(wasm).mark();
+        try leb.writeUleb128(writer, wasm.symbolLocSymbol(loc).index);
+        wasm.symbolLocSymbol(loc).mark();
     }
 
     try writer.writeByte(std.wasm.opcode(.end));
 
     try wasm.createSyntheticFunction(
-        "__wasm_init_tls",
+        wasm.preloaded_strings.__wasm_init_tls,
         std.wasm.Type{ .params = &.{.i32}, .returns = &.{} },
         &function_body,
     );
@@ -1950,27 +2104,24 @@ fn setupImports(wasm: *Wasm) !void {
     const gpa = wasm.base.comp.gpa;
     log.debug("Merging imports", .{});
     for (wasm.resolved_symbols.keys()) |symbol_loc| {
-        const obj_file = wasm.file(symbol_loc.file) orelse {
+        const object_id = symbol_loc.file.unwrap() orelse {
             // Synthetic symbols will already exist in the `import` section
             continue;
         };
 
-        const symbol = symbol_loc.getSymbol(wasm);
-        if (symbol.isDead() or
-            !symbol.requiresImport() or
-            std.mem.eql(u8, symbol_loc.getName(wasm), "__indirect_function_table"))
-        {
-            continue;
-        }
+        const symbol = wasm.symbolLocSymbol(symbol_loc);
+        if (symbol.isDead()) continue;
+        if (!symbol.requiresImport()) continue;
+        if (symbol.name == wasm.preloaded_strings.__indirect_function_table) continue;
 
-        log.debug("Symbol '{s}' will be imported from the host", .{symbol_loc.getName(wasm)});
-        const import = obj_file.import(symbol_loc.index);
+        log.debug("Symbol '{s}' will be imported from the host", .{wasm.stringSlice(symbol.name)});
+        const import = objectImport(wasm, object_id, symbol_loc.index);
 
         // We copy the import to a new import to ensure the names contain references
         // to the internal string table, rather than of the object file.
-        const new_imp: types.Import = .{
-            .module_name = try wasm.string_table.put(gpa, obj_file.string(import.module_name)),
-            .name = try wasm.string_table.put(gpa, obj_file.string(import.name)),
+        const new_imp: Import = .{
+            .module_name = import.module_name,
+            .name = import.name,
             .kind = import.kind,
         };
         // TODO: De-duplicate imports when they contain the same names and type
@@ -1983,8 +2134,8 @@ fn setupImports(wasm: *Wasm) !void {
     var table_index: u32 = 0;
     var it = wasm.imports.iterator();
     while (it.next()) |entry| {
-        const symbol = entry.key_ptr.*.getSymbol(wasm);
-        const import: types.Import = entry.value_ptr.*;
+        const symbol = wasm.symbolLocSymbol(entry.key_ptr.*);
+        const import: Import = entry.value_ptr.*;
         switch (import.kind) {
             .function => {
                 symbol.index = function_index;
@@ -2021,12 +2172,12 @@ fn mergeSections(wasm: *Wasm) !void {
     defer removed_duplicates.deinit();
 
     for (wasm.resolved_symbols.keys()) |sym_loc| {
-        const obj_file = wasm.file(sym_loc.file) orelse {
+        const object_id = sym_loc.file.unwrap() orelse {
             // Synthetic symbols already live in the corresponding sections.
             continue;
         };
 
-        const symbol = obj_file.symbol(sym_loc.index);
+        const symbol = objectSymbol(wasm, object_id, sym_loc.index);
         if (symbol.isDead() or symbol.isUndefined()) {
             // Skip undefined symbols as they go in the `import` section
             continue;
@@ -2044,7 +2195,7 @@ fn mergeSections(wasm: *Wasm) !void {
                     // we only emit a single function, instead of duplicates.
                     // we favor keeping the global over a local.
                     const original_loc: SymbolLoc = .{ .file = gop.key_ptr.file, .index = gop.value_ptr.sym_index };
-                    const original_sym = original_loc.getSymbol(wasm);
+                    const original_sym = wasm.symbolLocSymbol(original_loc);
                     if (original_sym.isLocal() and symbol.isGlobal()) {
                         original_sym.unmark();
                         try wasm.discarded.put(gpa, original_loc, sym_loc);
@@ -2056,20 +2207,23 @@ fn mergeSections(wasm: *Wasm) !void {
                         continue;
                     }
                 }
-                gop.value_ptr.* = .{ .func = obj_file.function(sym_loc.index), .sym_index = sym_loc.index };
+                gop.value_ptr.* = .{
+                    .func = objectFunction(wasm, object_id, sym_loc.index),
+                    .sym_index = sym_loc.index,
+                };
                 symbol.index = @as(u32, @intCast(gop.index)) + wasm.imported_functions_count;
             },
             .global => {
-                const index = symbol.index - obj_file.importedFunctions();
-                const original_global = obj_file.globals()[index];
+                const index = symbol.index - objectImportedFunctions(wasm, object_id);
+                const original_global = objectGlobals(wasm, object_id)[index];
                 symbol.index = @as(u32, @intCast(wasm.wasm_globals.items.len)) + wasm.imported_globals_count;
                 try wasm.wasm_globals.append(gpa, original_global);
             },
             .table => {
-                const index = symbol.index - obj_file.importedFunctions();
+                const index = symbol.index - objectImportedFunctions(wasm, object_id);
                 // assert it's a regular relocatable object file as `ZigObject` will never
                 // contain a table.
-                const original_table = obj_file.object.tables[index];
+                const original_table = wasm.objectById(object_id).?.tables[index];
                 symbol.index = @as(u32, @intCast(wasm.tables.items.len)) + wasm.imported_tables_count;
                 try wasm.tables.append(gpa, original_table);
             },
@@ -2081,7 +2235,7 @@ fn mergeSections(wasm: *Wasm) !void {
     // For any removed duplicates, remove them from the resolved symbols list
     for (removed_duplicates.items) |sym_loc| {
         assert(wasm.resolved_symbols.swapRemove(sym_loc));
-        gc_log.debug("Removed duplicate for function '{s}'", .{sym_loc.getName(wasm)});
+        gc_log.debug("Removed duplicate for function '{s}'", .{wasm.symbolLocName(sym_loc)});
     }
 
     log.debug("Merged ({d}) functions", .{wasm.functions.count()});
@@ -2102,26 +2256,26 @@ fn mergeTypes(wasm: *Wasm) !void {
     defer dirty.deinit();
 
     for (wasm.resolved_symbols.keys()) |sym_loc| {
-        const obj_file = wasm.file(sym_loc.file) orelse {
+        const object_id = sym_loc.file.unwrap() orelse {
             // zig code-generated symbols are already present in final type section
             continue;
         };
 
-        const symbol = obj_file.symbol(sym_loc.index);
+        const symbol = objectSymbol(wasm, object_id, sym_loc.index);
         if (symbol.tag != .function or symbol.isDead()) {
             // Only functions have types. Only retrieve the type of referenced functions.
             continue;
         }
 
         if (symbol.isUndefined()) {
-            log.debug("Adding type from extern function '{s}'", .{sym_loc.getName(wasm)});
-            const import: *types.Import = wasm.imports.getPtr(sym_loc) orelse continue;
-            const original_type = obj_file.funcTypes()[import.kind.function];
+            log.debug("Adding type from extern function '{s}'", .{wasm.symbolLocName(sym_loc)});
+            const import: *Import = wasm.imports.getPtr(sym_loc) orelse continue;
+            const original_type = objectFuncTypes(wasm, object_id)[import.kind.function];
             import.kind.function = try wasm.putOrGetFuncType(original_type);
         } else if (!dirty.contains(symbol.index)) {
-            log.debug("Adding type from function '{s}'", .{sym_loc.getName(wasm)});
+            log.debug("Adding type from function '{s}'", .{wasm.symbolLocName(sym_loc)});
             const func = &wasm.functions.values()[symbol.index - wasm.imported_functions_count].func;
-            func.type_index = try wasm.putOrGetFuncType(obj_file.funcTypes()[func.type_index]);
+            func.type_index = try wasm.putOrGetFuncType(objectFuncTypes(wasm, object_id)[func.type_index]);
             dirty.putAssumeCapacityNoClobber(symbol.index, {});
         }
     }
@@ -2130,18 +2284,20 @@ fn mergeTypes(wasm: *Wasm) !void {
 
 fn checkExportNames(wasm: *Wasm) !void {
     const force_exp_names = wasm.export_symbol_names;
+    const diags = &wasm.base.comp.link_diags;
     if (force_exp_names.len > 0) {
         var failed_exports = false;
 
         for (force_exp_names) |exp_name| {
-            const loc = wasm.findGlobalSymbol(exp_name) orelse {
-                var err = try wasm.base.addErrorWithNotes(0);
+            const exp_name_interned = try wasm.internString(exp_name);
+            const loc = wasm.globals.get(exp_name_interned) orelse {
+                var err = try diags.addErrorWithNotes(0);
                 try err.addMsg("could not export '{s}', symbol not found", .{exp_name});
                 failed_exports = true;
                 continue;
             };
 
-            const symbol = loc.getSymbol(wasm);
+            const symbol = wasm.symbolLocSymbol(loc);
             symbol.setFlag(.WASM_SYM_EXPORTED);
         }
 
@@ -2158,33 +2314,28 @@ fn setupExports(wasm: *Wasm) !void {
     log.debug("Building exports from symbols", .{});
 
     for (wasm.resolved_symbols.keys()) |sym_loc| {
-        const symbol = sym_loc.getSymbol(wasm);
+        const symbol = wasm.symbolLocSymbol(sym_loc);
         if (!symbol.isExported(comp.config.rdynamic)) continue;
 
-        const sym_name = sym_loc.getName(wasm);
-        const export_name = if (sym_loc.file == .null)
-            symbol.name
-        else
-            try wasm.string_table.put(gpa, sym_name);
-        const exp: types.Export = if (symbol.tag == .data) exp: {
+        const exp: Export = if (symbol.tag == .data) exp: {
             const global_index = @as(u32, @intCast(wasm.imported_globals_count + wasm.wasm_globals.items.len));
             try wasm.wasm_globals.append(gpa, .{
                 .global_type = .{ .valtype = .i32, .mutable = false },
                 .init = .{ .i32_const = @as(i32, @intCast(symbol.virtual_address)) },
             });
             break :exp .{
-                .name = export_name,
+                .name = symbol.name,
                 .kind = .global,
                 .index = global_index,
             };
         } else .{
-            .name = export_name,
+            .name = symbol.name,
             .kind = symbol.tag.externalType(),
             .index = symbol.index,
         };
         log.debug("Exporting symbol '{s}' as '{s}' at index: ({d})", .{
-            sym_name,
-            wasm.string_table.get(exp.name),
+            wasm.stringSlice(symbol.name),
+            wasm.stringSlice(exp.name),
             exp.index,
         });
         try wasm.exports.append(gpa, exp);
@@ -2195,21 +2346,20 @@ fn setupExports(wasm: *Wasm) !void {
 
 fn setupStart(wasm: *Wasm) !void {
     const comp = wasm.base.comp;
+    const diags = &wasm.base.comp.link_diags;
     // do not export entry point if user set none or no default was set.
-    const entry_name = wasm.entry_name orelse return;
+    const entry_name = wasm.entry_name.unwrap() orelse return;
 
-    const symbol_loc = wasm.findGlobalSymbol(entry_name) orelse {
-        var err = try wasm.base.addErrorWithNotes(0);
-        try err.addMsg("Entry symbol '{s}' missing, use '-fno-entry' to suppress", .{entry_name});
-        return error.FlushFailure;
+    const symbol_loc = wasm.globals.get(entry_name) orelse {
+        var err = try diags.addErrorWithNotes(1);
+        try err.addMsg("entry symbol '{s}' missing", .{wasm.stringSlice(entry_name)});
+        try err.addNote("'-fno-entry' suppresses this error", .{});
+        return error.LinkFailure;
     };
 
-    const symbol = symbol_loc.getSymbol(wasm);
-    if (symbol.tag != .function) {
-        var err = try wasm.base.addErrorWithNotes(0);
-        try err.addMsg("Entry symbol '{s}' is not a function", .{entry_name});
-        return error.FlushFailure;
-    }
+    const symbol = wasm.symbolLocSymbol(symbol_loc);
+    if (symbol.tag != .function)
+        return diags.fail("entry symbol '{s}' is not a function", .{wasm.stringSlice(entry_name)});
 
     // Ensure the symbol is exported so host environment can access it
     if (comp.config.output_mode != .Obj) {
@@ -2220,6 +2370,7 @@ fn setupStart(wasm: *Wasm) !void {
 /// Sets up the memory section of the wasm module, as well as the stack.
 fn setupMemory(wasm: *Wasm) !void {
     const comp = wasm.base.comp;
+    const diags = &wasm.base.comp.link_diags;
     const shared_memory = comp.config.shared_memory;
     log.debug("Setting up memory layout", .{});
     const page_size = std.wasm.page_size; // 64kb
@@ -2236,8 +2387,8 @@ fn setupMemory(wasm: *Wasm) !void {
 
     const is_obj = comp.config.output_mode == .Obj;
 
-    const stack_ptr = if (wasm.findGlobalSymbol("__stack_pointer")) |loc| index: {
-        const sym = loc.getSymbol(wasm);
+    const stack_ptr = if (wasm.globals.get(wasm.preloaded_strings.__stack_pointer)) |loc| index: {
+        const sym = wasm.symbolLocSymbol(loc);
         break :index sym.index - wasm.imported_globals_count;
     } else null;
 
@@ -2253,21 +2404,21 @@ fn setupMemory(wasm: *Wasm) !void {
     var offset: u32 = @as(u32, @intCast(memory_ptr));
     var data_seg_it = wasm.data_segments.iterator();
     while (data_seg_it.next()) |entry| {
-        const segment = &wasm.segments.items[entry.value_ptr.*];
+        const segment = wasm.segmentPtr(entry.value_ptr.*);
         memory_ptr = segment.alignment.forward(memory_ptr);
 
         // set TLS-related symbols
         if (mem.eql(u8, entry.key_ptr.*, ".tdata")) {
-            if (wasm.findGlobalSymbol("__tls_size")) |loc| {
-                const sym = loc.getSymbol(wasm);
+            if (wasm.globals.get(wasm.preloaded_strings.__tls_size)) |loc| {
+                const sym = wasm.symbolLocSymbol(loc);
                 wasm.wasm_globals.items[sym.index - wasm.imported_globals_count].init.i32_const = @intCast(segment.size);
             }
-            if (wasm.findGlobalSymbol("__tls_align")) |loc| {
-                const sym = loc.getSymbol(wasm);
+            if (wasm.globals.get(wasm.preloaded_strings.__tls_align)) |loc| {
+                const sym = wasm.symbolLocSymbol(loc);
                 wasm.wasm_globals.items[sym.index - wasm.imported_globals_count].init.i32_const = @intCast(segment.alignment.toByteUnits().?);
             }
-            if (wasm.findGlobalSymbol("__tls_base")) |loc| {
-                const sym = loc.getSymbol(wasm);
+            if (wasm.globals.get(wasm.preloaded_strings.__tls_base)) |loc| {
+                const sym = wasm.symbolLocSymbol(loc);
                 wasm.wasm_globals.items[sym.index - wasm.imported_globals_count].init.i32_const = if (shared_memory)
                     @as(i32, 0)
                 else
@@ -2284,8 +2435,8 @@ fn setupMemory(wasm: *Wasm) !void {
     if (shared_memory and wasm.hasPassiveInitializationSegments()) {
         // align to pointer size
         memory_ptr = mem.alignForward(u64, memory_ptr, 4);
-        const loc = try wasm.createSyntheticSymbol("__wasm_init_memory_flag", .data);
-        const sym = loc.getSymbol(wasm);
+        const loc = try wasm.createSyntheticSymbol(wasm.preloaded_strings.__wasm_init_memory_flag, .data);
+        const sym = wasm.symbolLocSymbol(loc);
         sym.mark();
         sym.virtual_address = @as(u32, @intCast(memory_ptr));
         memory_ptr += 4;
@@ -2301,8 +2452,8 @@ fn setupMemory(wasm: *Wasm) !void {
 
     // One of the linked object files has a reference to the __heap_base symbol.
     // We must set its virtual address so it can be used in relocations.
-    if (wasm.findGlobalSymbol("__heap_base")) |loc| {
-        const symbol = loc.getSymbol(wasm);
+    if (wasm.globals.get(wasm.preloaded_strings.__heap_base)) |loc| {
+        const symbol = wasm.symbolLocSymbol(loc);
         symbol.virtual_address = @intCast(heap_alignment.forward(memory_ptr));
     }
 
@@ -2312,15 +2463,15 @@ fn setupMemory(wasm: *Wasm) !void {
 
     if (wasm.initial_memory) |initial_memory| {
         if (!std.mem.isAlignedGeneric(u64, initial_memory, page_size)) {
-            var err = try wasm.base.addErrorWithNotes(0);
+            var err = try diags.addErrorWithNotes(0);
             try err.addMsg("Initial memory must be {d}-byte aligned", .{page_size});
         }
         if (memory_ptr > initial_memory) {
-            var err = try wasm.base.addErrorWithNotes(0);
+            var err = try diags.addErrorWithNotes(0);
             try err.addMsg("Initial memory too small, must be at least {d} bytes", .{memory_ptr});
         }
         if (initial_memory > max_memory_allowed) {
-            var err = try wasm.base.addErrorWithNotes(0);
+            var err = try diags.addErrorWithNotes(0);
             try err.addMsg("Initial memory exceeds maximum memory {d}", .{max_memory_allowed});
         }
         memory_ptr = initial_memory;
@@ -2331,22 +2482,22 @@ fn setupMemory(wasm: *Wasm) !void {
     wasm.memories.limits.min = @as(u32, @intCast(memory_ptr / page_size));
     log.debug("Total memory pages: {d}", .{wasm.memories.limits.min});
 
-    if (wasm.findGlobalSymbol("__heap_end")) |loc| {
-        const symbol = loc.getSymbol(wasm);
+    if (wasm.globals.get(wasm.preloaded_strings.__heap_end)) |loc| {
+        const symbol = wasm.symbolLocSymbol(loc);
         symbol.virtual_address = @as(u32, @intCast(memory_ptr));
     }
 
     if (wasm.max_memory) |max_memory| {
         if (!std.mem.isAlignedGeneric(u64, max_memory, page_size)) {
-            var err = try wasm.base.addErrorWithNotes(0);
+            var err = try diags.addErrorWithNotes(0);
             try err.addMsg("Maximum memory must be {d}-byte aligned", .{page_size});
         }
         if (memory_ptr > max_memory) {
-            var err = try wasm.base.addErrorWithNotes(0);
+            var err = try diags.addErrorWithNotes(0);
             try err.addMsg("Maximum memory too small, must be at least {d} bytes", .{memory_ptr});
         }
         if (max_memory > max_memory_allowed) {
-            var err = try wasm.base.addErrorWithNotes(0);
+            var err = try diags.addErrorWithNotes(0);
             try err.addMsg("Maximum memory exceeds maximum amount {d}", .{max_memory_allowed});
         }
         wasm.memories.limits.max = @as(u32, @intCast(max_memory / page_size));
@@ -2361,17 +2512,17 @@ fn setupMemory(wasm: *Wasm) !void {
 /// From a given object's index and the index of the segment, returns the corresponding
 /// index of the segment within the final data section. When the segment does not yet
 /// exist, a new one will be initialized and appended. The new index will be returned in that case.
-pub fn getMatchingSegment(wasm: *Wasm, file_index: File.Index, symbol_index: Symbol.Index) !u32 {
+pub fn getMatchingSegment(wasm: *Wasm, object_id: ObjectId, symbol_index: Symbol.Index) !Segment.Index {
     const comp = wasm.base.comp;
     const gpa = comp.gpa;
-    const obj_file = wasm.file(file_index).?;
-    const symbol = obj_file.symbols()[@intFromEnum(symbol_index)];
-    const index: u32 = @intCast(wasm.segments.items.len);
+    const diags = &wasm.base.comp.link_diags;
+    const symbol = objectSymbols(wasm, object_id)[@intFromEnum(symbol_index)];
+    const index: Segment.Index = @enumFromInt(wasm.segments.items.len);
     const shared_memory = comp.config.shared_memory;
 
     switch (symbol.tag) {
         .data => {
-            const segment_info = obj_file.segmentInfo()[symbol.index];
+            const segment_info = objectSegmentInfo(wasm, object_id)[symbol.index];
             const merge_segment = comp.config.output_mode != .Obj;
             const result = try wasm.data_segments.getOrPut(gpa, segment_info.outputName(merge_segment));
             if (!result.found_existing) {
@@ -2394,66 +2545,27 @@ pub fn getMatchingSegment(wasm: *Wasm, file_index: File.Index, symbol_index: Sym
                 return index;
             } else return result.value_ptr.*;
         },
-        .function => return wasm.code_section_index orelse blk: {
-            wasm.code_section_index = index;
+        .function => return wasm.code_section_index.unwrap() orelse blk: {
+            wasm.code_section_index = index.toOptional();
             try wasm.appendDummySegment();
             break :blk index;
         },
         .section => {
-            const section_name = obj_file.symbolName(symbol_index);
-            if (mem.eql(u8, section_name, ".debug_info")) {
-                return wasm.debug_info_index orelse blk: {
-                    wasm.debug_info_index = index;
-                    try wasm.appendDummySegment();
-                    break :blk index;
-                };
-            } else if (mem.eql(u8, section_name, ".debug_line")) {
-                return wasm.debug_line_index orelse blk: {
-                    wasm.debug_line_index = index;
-                    try wasm.appendDummySegment();
-                    break :blk index;
-                };
-            } else if (mem.eql(u8, section_name, ".debug_loc")) {
-                return wasm.debug_loc_index orelse blk: {
-                    wasm.debug_loc_index = index;
-                    try wasm.appendDummySegment();
-                    break :blk index;
-                };
-            } else if (mem.eql(u8, section_name, ".debug_ranges")) {
-                return wasm.debug_ranges_index orelse blk: {
-                    wasm.debug_ranges_index = index;
-                    try wasm.appendDummySegment();
-                    break :blk index;
-                };
-            } else if (mem.eql(u8, section_name, ".debug_pubnames")) {
-                return wasm.debug_pubnames_index orelse blk: {
-                    wasm.debug_pubnames_index = index;
-                    try wasm.appendDummySegment();
-                    break :blk index;
-                };
-            } else if (mem.eql(u8, section_name, ".debug_pubtypes")) {
-                return wasm.debug_pubtypes_index orelse blk: {
-                    wasm.debug_pubtypes_index = index;
-                    try wasm.appendDummySegment();
-                    break :blk index;
-                };
-            } else if (mem.eql(u8, section_name, ".debug_abbrev")) {
-                return wasm.debug_abbrev_index orelse blk: {
-                    wasm.debug_abbrev_index = index;
-                    try wasm.appendDummySegment();
-                    break :blk index;
-                };
-            } else if (mem.eql(u8, section_name, ".debug_str")) {
-                return wasm.debug_str_index orelse blk: {
-                    wasm.debug_str_index = index;
-                    try wasm.appendDummySegment();
-                    break :blk index;
-                };
+            const section_name = wasm.objectSymbol(object_id, symbol_index).name;
+
+            inline for (@typeInfo(CustomSections).@"struct".fields) |field| {
+                if (@field(wasm.custom_sections, field.name).name == section_name) {
+                    const field_ptr = &@field(wasm.custom_sections, field.name).index;
+                    return field_ptr.unwrap() orelse {
+                        field_ptr.* = index.toOptional();
+                        try wasm.appendDummySegment();
+                        return index;
+                    };
+                }
             } else {
-                var err = try wasm.base.addErrorWithNotes(1);
-                try err.addMsg("found unknown section '{s}'", .{section_name});
-                try err.addNote("defined in '{s}'", .{obj_file.path()});
-                return error.UnexpectedValue;
+                return diags.failParse(objectPath(wasm, object_id), "unknown section: {s}", .{
+                    wasm.stringSlice(section_name),
+                });
             }
         },
         else => unreachable,
@@ -2471,6 +2583,32 @@ fn appendDummySegment(wasm: *Wasm) !void {
     });
 }
 
+pub fn loadInput(wasm: *Wasm, input: link.Input) !void {
+    const comp = wasm.base.comp;
+    const gpa = comp.gpa;
+
+    if (comp.verbose_link) {
+        comp.mutex.lock(); // protect comp.arena
+        defer comp.mutex.unlock();
+
+        const argv = &wasm.dump_argv_list;
+        switch (input) {
+            .res => unreachable,
+            .dso_exact => unreachable,
+            .dso => unreachable,
+            .object, .archive => |obj| try argv.append(gpa, try obj.path.toString(comp.arena)),
+        }
+    }
+
+    switch (input) {
+        .res => unreachable,
+        .dso_exact => unreachable,
+        .dso => unreachable,
+        .object => |obj| try parseObject(wasm, obj),
+        .archive => |obj| try parseArchive(wasm, obj),
+    }
+}
+
 pub fn flush(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
     const comp = wasm.base.comp;
     const use_lld = build_options.have_llvm and comp.config.use_lld;
@@ -2481,111 +2619,55 @@ pub fn flush(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: st
     return wasm.flushModule(arena, tid, prog_node);
 }
 
-/// Uses the in-house linker to link one or multiple object -and archive files into a WebAssembly binary.
 pub fn flushModule(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
     const tracy = trace(@src());
     defer tracy.end();
 
     const comp = wasm.base.comp;
+    const diags = &comp.link_diags;
     if (wasm.llvm_object) |llvm_object| {
         try wasm.base.emitLlvmObject(arena, llvm_object, prog_node);
         const use_lld = build_options.have_llvm and comp.config.use_lld;
         if (use_lld) return;
     }
 
+    if (comp.verbose_link) Compilation.dump_argv(wasm.dump_argv_list.items);
+
     const sub_prog_node = prog_node.start("Wasm Flush", 0);
     defer sub_prog_node.end();
 
-    const directory = wasm.base.emit.root_dir; // Just an alias to make it shorter to type.
-    const full_out_path = try directory.join(arena, &[_][]const u8{wasm.base.emit.sub_path});
-    const module_obj_path: ?[]const u8 = if (wasm.base.zcu_object_sub_path) |path| blk: {
-        if (fs.path.dirname(full_out_path)) |dirname| {
-            break :blk try fs.path.join(arena, &.{ dirname, path });
-        } else {
-            break :blk path;
-        }
+    const module_obj_path: ?Path = if (wasm.base.zcu_object_sub_path) |path| .{
+        .root_dir = wasm.base.emit.root_dir,
+        .sub_path = if (fs.path.dirname(wasm.base.emit.sub_path)) |dirname|
+            try fs.path.join(arena, &.{ dirname, path })
+        else
+            path,
     } else null;
 
-    // Positional arguments to the linker such as object files and static archives.
-    // TODO: "positional arguments" is a CLI concept, not a linker concept. Delete this unnecessary array list.
-    var positionals = std.ArrayList([]const u8).init(arena);
-    try positionals.ensureUnusedCapacity(comp.objects.len);
-
-    const target = comp.root_mod.resolved_target.result;
-    const output_mode = comp.config.output_mode;
-    const link_mode = comp.config.link_mode;
-    const link_libc = comp.config.link_libc;
-    const link_libcpp = comp.config.link_libcpp;
-    const wasi_exec_model = comp.config.wasi_exec_model;
-
-    if (wasm.zigObjectPtr()) |zig_object| {
-        try zig_object.flushModule(wasm, tid);
-    }
-
-    // When the target os is WASI, we allow linking with WASI-LIBC
-    if (target.os.tag == .wasi) {
-        const is_exe_or_dyn_lib = output_mode == .Exe or
-            (output_mode == .Lib and link_mode == .dynamic);
-        if (is_exe_or_dyn_lib) {
-            for (comp.wasi_emulated_libs) |crt_file| {
-                try positionals.append(try comp.crtFileAsString(
-                    arena,
-                    wasi_libc.emulatedLibCRFileLibName(crt_file),
-                ));
-            }
-
-            if (link_libc) {
-                try positionals.append(try comp.crtFileAsString(
-                    arena,
-                    wasi_libc.execModelCrtFileFullName(wasi_exec_model),
-                ));
-                try positionals.append(try comp.crtFileAsString(arena, "libc.a"));
-            }
-
-            if (link_libcpp) {
-                try positionals.append(try comp.libcxx_static_lib.?.full_object_path.toString(arena));
-                try positionals.append(try comp.libcxxabi_static_lib.?.full_object_path.toString(arena));
-            }
-        }
-    }
-
-    if (module_obj_path) |path| {
-        try positionals.append(path);
-    }
+    if (wasm.zig_object) |zig_object| try zig_object.flushModule(wasm, tid);
 
-    for (comp.objects) |object| {
-        try positionals.append(try object.path.toString(arena));
-    }
+    if (module_obj_path) |path| openParseObjectReportingFailure(wasm, path);
 
-    for (comp.c_object_table.keys()) |c_object| {
-        try positionals.append(try c_object.status.success.object_path.toString(arena));
+    if (wasm.zig_object != null) {
+        try wasm.resolveSymbolsInObject(.zig_object);
     }
-
-    if (comp.compiler_rt_lib) |lib| try positionals.append(try lib.full_object_path.toString(arena));
-    if (comp.compiler_rt_obj) |obj| try positionals.append(try obj.full_object_path.toString(arena));
-
-    try wasm.parseInputFiles(positionals.items);
-
-    if (wasm.zig_object_index != .null) {
-        try wasm.resolveSymbolsInObject(wasm.zig_object_index);
-    }
-    if (wasm.base.hasErrors()) return error.FlushFailure;
-    for (wasm.objects.items) |object_index| {
-        try wasm.resolveSymbolsInObject(object_index);
+    if (diags.hasErrors()) return error.FlushFailure;
+    for (0..wasm.objects.items.len) |object_index| {
+        try wasm.resolveSymbolsInObject(@enumFromInt(object_index));
     }
-    if (wasm.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
 
     var emit_features_count: u32 = 0;
-    var enabled_features: [@typeInfo(types.Feature.Tag).@"enum".fields.len]bool = undefined;
+    var enabled_features: [@typeInfo(Feature.Tag).@"enum".fields.len]bool = undefined;
     try wasm.validateFeatures(&enabled_features, &emit_features_count);
     try wasm.resolveSymbolsInArchives();
-    if (wasm.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
     try wasm.resolveLazySymbols();
     try wasm.checkUndefinedSymbols();
     try wasm.checkExportNames();
 
     try wasm.setupInitFunctions();
-    if (wasm.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
     try wasm.setupStart();
 
     try wasm.markReferences();
@@ -2594,7 +2676,7 @@ pub fn flushModule(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
     try wasm.mergeTypes();
     try wasm.allocateAtoms();
     try wasm.setupMemory();
-    if (wasm.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
     wasm.allocateVirtualAddresses();
     wasm.mapFunctionTable();
     try wasm.initializeCallCtorsFunction();
@@ -2604,17 +2686,18 @@ pub fn flushModule(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
     try wasm.setupStartSection();
     try wasm.setupExports();
     try wasm.writeToFile(enabled_features, emit_features_count, arena);
-    if (wasm.base.hasErrors()) return error.FlushFailure;
+    if (diags.hasErrors()) return error.FlushFailure;
 }
 
 /// Writes the WebAssembly in-memory module to the file
 fn writeToFile(
     wasm: *Wasm,
-    enabled_features: [@typeInfo(types.Feature.Tag).@"enum".fields.len]bool,
+    enabled_features: [@typeInfo(Feature.Tag).@"enum".fields.len]bool,
     feature_count: u32,
     arena: Allocator,
 ) !void {
     const comp = wasm.base.comp;
+    const diags = &comp.link_diags;
     const gpa = comp.gpa;
     const use_llvm = comp.config.use_llvm;
     const use_lld = build_options.have_llvm and comp.config.use_lld;
@@ -2675,16 +2758,15 @@ fn writeToFile(
 
         var it = wasm.imports.iterator();
         while (it.next()) |entry| {
-            assert(entry.key_ptr.*.getSymbol(wasm).isUndefined());
+            assert(wasm.symbolLocSymbol(entry.key_ptr.*).isUndefined());
             const import = entry.value_ptr.*;
             try wasm.emitImport(binary_writer, import);
         }
 
         if (import_memory) {
-            const mem_name = if (is_obj) "__linear_memory" else "memory";
-            const mem_imp: types.Import = .{
-                .module_name = try wasm.string_table.put(gpa, wasm.host_name),
-                .name = try wasm.string_table.put(gpa, mem_name),
+            const mem_imp: Import = .{
+                .module_name = wasm.host_name,
+                .name = if (is_obj) wasm.preloaded_strings.__linear_memory else wasm.preloaded_strings.memory,
                 .kind = .{ .memory = wasm.memories.limits },
             };
             try wasm.emitImport(binary_writer, mem_imp);
@@ -2776,7 +2858,7 @@ fn writeToFile(
         const header_offset = try reserveVecSectionHeader(&binary_bytes);
 
         for (wasm.exports.items) |exp| {
-            const name = wasm.string_table.get(exp.name);
+            const name = wasm.stringSlice(exp.name);
             try leb.writeUleb128(binary_writer, @as(u32, @intCast(name.len)));
             try binary_writer.writeAll(name);
             try leb.writeUleb128(binary_writer, @intFromEnum(exp.kind));
@@ -2815,8 +2897,8 @@ fn writeToFile(
     if (wasm.function_table.count() > 0) {
         const header_offset = try reserveVecSectionHeader(&binary_bytes);
 
-        const table_loc = wasm.findGlobalSymbol("__indirect_function_table").?;
-        const table_sym = table_loc.getSymbol(wasm);
+        const table_loc = wasm.globals.get(wasm.preloaded_strings.__indirect_function_table).?;
+        const table_sym = wasm.symbolLocSymbol(table_loc);
 
         const flags: u32 = if (table_sym.index == 0) 0x0 else 0x02; // passive with implicit 0-index table or set table index manually
         try leb.writeUleb128(binary_writer, flags);
@@ -2830,7 +2912,7 @@ fn writeToFile(
         try leb.writeUleb128(binary_writer, @as(u32, @intCast(wasm.function_table.count())));
         var symbol_it = wasm.function_table.keyIterator();
         while (symbol_it.next()) |symbol_loc_ptr| {
-            const sym = symbol_loc_ptr.getSymbol(wasm);
+            const sym = wasm.symbolLocSymbol(symbol_loc_ptr.*);
             std.debug.assert(sym.isAlive());
             std.debug.assert(sym.index < wasm.functions.count() + wasm.imported_functions_count);
             try leb.writeUleb128(binary_writer, sym.index);
@@ -2860,7 +2942,7 @@ fn writeToFile(
     }
 
     // Code section
-    if (wasm.code_section_index != null) {
+    if (wasm.code_section_index != .none) {
         const header_offset = try reserveVecSectionHeader(&binary_bytes);
         const start_offset = binary_bytes.items.len - 5; // minus 5 so start offset is 5 to include entry count
 
@@ -2900,7 +2982,7 @@ fn writeToFile(
             // want to guarantee the data is zero initialized
             if (!import_memory and std.mem.eql(u8, entry.key_ptr.*, ".bss")) continue;
             const segment_index = entry.value_ptr.*;
-            const segment = wasm.segments.items[segment_index];
+            const segment = wasm.segmentPtr(segment_index);
             if (segment.size == 0) continue; // do not emit empty segments
             segment_count += 1;
             var atom_index = wasm.atoms.get(segment_index).?;
@@ -3003,7 +3085,7 @@ fn writeToFile(
                 try emitBuildIdSection(&binary_bytes, str);
             },
             else => |mode| {
-                var err = try wasm.base.addErrorWithNotes(0);
+                var err = try diags.addErrorWithNotes(0);
                 try err.addMsg("build-id '{s}' is not supported for WebAssembly", .{@tagName(mode)});
             },
         }
@@ -3011,24 +3093,8 @@ fn writeToFile(
         var debug_bytes = std.ArrayList(u8).init(gpa);
         defer debug_bytes.deinit();
 
-        const DebugSection = struct {
-            name: []const u8,
-            index: ?u32,
-        };
-
-        const debug_sections: []const DebugSection = &.{
-            .{ .name = ".debug_info", .index = wasm.debug_info_index },
-            .{ .name = ".debug_pubtypes", .index = wasm.debug_pubtypes_index },
-            .{ .name = ".debug_abbrev", .index = wasm.debug_abbrev_index },
-            .{ .name = ".debug_line", .index = wasm.debug_line_index },
-            .{ .name = ".debug_str", .index = wasm.debug_str_index },
-            .{ .name = ".debug_pubnames", .index = wasm.debug_pubnames_index },
-            .{ .name = ".debug_loc", .index = wasm.debug_loc_index },
-            .{ .name = ".debug_ranges", .index = wasm.debug_ranges_index },
-        };
-
-        for (debug_sections) |item| {
-            if (item.index) |index| {
+        inline for (@typeInfo(CustomSections).@"struct".fields) |field| {
+            if (@field(wasm.custom_sections, field.name).index.unwrap()) |index| {
                 var atom = wasm.getAtomPtr(wasm.atoms.get(index).?);
                 while (true) {
                     atom.resolveRelocs(wasm);
@@ -3036,7 +3102,7 @@ fn writeToFile(
                     if (atom.prev == .null) break;
                     atom = wasm.getAtomPtr(atom.prev);
                 }
-                try emitDebugSection(&binary_bytes, debug_bytes.items, item.name);
+                try emitDebugSection(&binary_bytes, debug_bytes.items, field.name);
                 debug_bytes.clearRetainingCapacity();
             }
         }
@@ -3170,7 +3236,7 @@ fn emitFeaturesSection(binary_bytes: *std.ArrayList(u8), enabled_features: []con
     try leb.writeUleb128(writer, features_count);
     for (enabled_features, 0..) |enabled, feature_index| {
         if (enabled) {
-            const feature: types.Feature = .{ .prefix = .used, .tag = @as(types.Feature.Tag, @enumFromInt(feature_index)) };
+            const feature: Feature = .{ .prefix = .used, .tag = @as(Feature.Tag, @enumFromInt(feature_index)) };
             try leb.writeUleb128(writer, @intFromEnum(feature.prefix));
             var buf: [100]u8 = undefined;
             const string = try std.fmt.bufPrint(&buf, "{}", .{feature.tag});
@@ -3206,11 +3272,11 @@ fn emitNameSection(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), arena: std.mem
     var segments = try std.ArrayList(Name).initCapacity(arena, wasm.data_segments.count());
 
     for (wasm.resolved_symbols.keys()) |sym_loc| {
-        const symbol = sym_loc.getSymbol(wasm).*;
+        const symbol = wasm.symbolLocSymbol(sym_loc).*;
         if (symbol.isDead()) {
             continue;
         }
-        const name = sym_loc.getName(wasm);
+        const name = wasm.symbolLocName(sym_loc);
         switch (symbol.tag) {
             .function => {
                 const gop = funcs.getOrPutAssumeCapacity(symbol.index);
@@ -3307,12 +3373,12 @@ fn emitInit(writer: anytype, init_expr: std.wasm.InitExpression) !void {
     try writer.writeByte(std.wasm.opcode(.end));
 }
 
-fn emitImport(wasm: *Wasm, writer: anytype, import: types.Import) !void {
-    const module_name = wasm.string_table.get(import.module_name);
+fn emitImport(wasm: *Wasm, writer: anytype, import: Import) !void {
+    const module_name = wasm.stringSlice(import.module_name);
     try leb.writeUleb128(writer, @as(u32, @intCast(module_name.len)));
     try writer.writeAll(module_name);
 
-    const name = wasm.string_table.get(import.name);
+    const name = wasm.stringSlice(import.name);
     try leb.writeUleb128(writer, @as(u32, @intCast(name.len)));
     try writer.writeAll(name);
 
@@ -3387,16 +3453,13 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
 
         comptime assert(Compilation.link_hash_implementation_version == 14);
 
-        for (comp.objects) |obj| {
-            _ = try man.addFilePath(obj.path, null);
-            man.hash.add(obj.must_link);
-        }
+        try link.hashInputs(&man, comp.link_inputs);
         for (comp.c_object_table.keys()) |key| {
             _ = try man.addFilePath(key.status.success.object_path, null);
         }
         try man.addOptionalFile(module_obj_path);
         try man.addOptionalFilePath(compiler_rt_path);
-        man.hash.addOptionalBytes(wasm.entry_name);
+        man.hash.addOptionalBytes(wasm.optionalStringSlice(wasm.entry_name));
         man.hash.add(wasm.base.stack_size);
         man.hash.add(wasm.base.build_id);
         man.hash.add(import_memory);
@@ -3444,8 +3507,7 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
         // here. TODO: think carefully about how we can avoid this redundant operation when doing
         // build-obj. See also the corresponding TODO in linkAsArchive.
         const the_object_path = blk: {
-            if (comp.objects.len != 0)
-                break :blk comp.objects[0].path;
+            if (link.firstObjectInput(comp.link_inputs)) |obj| break :blk obj.path;
 
             if (comp.c_object_table.count() != 0)
                 break :blk comp.c_object_table.keys()[0].status.success.object_path;
@@ -3457,7 +3519,7 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
             // regarding eliding redundant object -> object transformations.
             return error.NoObjectsToLink;
         };
-        try std.fs.Dir.copyFile(
+        try fs.Dir.copyFile(
             the_object_path.root_dir.handle,
             the_object_path.sub_path,
             directory.handle,
@@ -3546,7 +3608,7 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
             try argv.append("--export-dynamic");
         }
 
-        if (wasm.entry_name) |entry_name| {
+        if (wasm.optionalStringSlice(wasm.entry_name)) |entry_name| {
             try argv.appendSlice(&.{ "--entry", entry_name });
         } else {
             try argv.append("--no-entry");
@@ -3607,16 +3669,23 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
 
         // Positional arguments to the linker such as object files.
         var whole_archive = false;
-        for (comp.objects) |obj| {
-            if (obj.must_link and !whole_archive) {
-                try argv.append("-whole-archive");
-                whole_archive = true;
-            } else if (!obj.must_link and whole_archive) {
-                try argv.append("-no-whole-archive");
-                whole_archive = false;
-            }
-            try argv.append(try obj.path.toString(arena));
-        }
+        for (comp.link_inputs) |link_input| switch (link_input) {
+            .object, .archive => |obj| {
+                if (obj.must_link and !whole_archive) {
+                    try argv.append("-whole-archive");
+                    whole_archive = true;
+                } else if (!obj.must_link and whole_archive) {
+                    try argv.append("-no-whole-archive");
+                    whole_archive = false;
+                }
+                try argv.append(try obj.path.toString(arena));
+            },
+            .dso => |dso| {
+                try argv.append(try dso.path.toString(arena));
+            },
+            .dso_exact => unreachable,
+            .res => unreachable,
+        };
         if (whole_archive) {
             try argv.append("-no-whole-archive");
             whole_archive = false;
@@ -3629,11 +3698,8 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
             try argv.append(p);
         }
 
-        if (comp.config.output_mode != .Obj and
-            !comp.skip_linker_dependencies and
-            !comp.config.link_libc)
-        {
-            try argv.append(try comp.libc_static_lib.?.full_object_path.toString(arena));
+        if (comp.libc_static_lib) |crt_file| {
+            try argv.append(try crt_file.full_object_path.toString(arena));
         }
 
         if (compiler_rt_path) |p| {
@@ -3684,7 +3750,8 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
                 switch (term) {
                     .Exited => |code| {
                         if (code != 0) {
-                            comp.lockAndParseLldStderr(linker_command, stderr);
+                            const diags = &comp.link_diags;
+                            diags.lockAndParseLldStderr(linker_command, stderr);
                             return error.LLDReportedFailure;
                         }
                     },
@@ -3786,7 +3853,7 @@ fn emitLinkSection(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), symbol_table:
     // meta data version, which is currently '2'
     try leb.writeUleb128(writer, @as(u32, 2));
 
-    // For each subsection type (found in types.Subsection) we can emit a section.
+    // For each subsection type (found in Subsection) we can emit a section.
     // Currently, we only support emitting segment info and the symbol table.
     try wasm.emitSymbolTable(binary_bytes, symbol_table);
     try wasm.emitSegmentInfo(binary_bytes);
@@ -3798,12 +3865,12 @@ fn emitLinkSection(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), symbol_table:
 fn emitSymbolTable(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), symbol_table: *std.AutoArrayHashMap(SymbolLoc, u32)) !void {
     const writer = binary_bytes.writer();
 
-    try leb.writeUleb128(writer, @intFromEnum(types.SubsectionType.WASM_SYMBOL_TABLE));
+    try leb.writeUleb128(writer, @intFromEnum(SubsectionType.WASM_SYMBOL_TABLE));
     const table_offset = binary_bytes.items.len;
 
     var symbol_count: u32 = 0;
     for (wasm.resolved_symbols.keys()) |sym_loc| {
-        const symbol = sym_loc.getSymbol(wasm).*;
+        const symbol = wasm.symbolLocSymbol(sym_loc).*;
         if (symbol.tag == .dead) continue; // Do not emit dead symbols
         try symbol_table.putNoClobber(sym_loc, symbol_count);
         symbol_count += 1;
@@ -3811,7 +3878,7 @@ fn emitSymbolTable(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), symbol_table:
         try leb.writeUleb128(writer, @intFromEnum(symbol.tag));
         try leb.writeUleb128(writer, symbol.flags);
 
-        const sym_name = sym_loc.getName(wasm);
+        const sym_name = wasm.symbolLocName(sym_loc);
         switch (symbol.tag) {
             .data => {
                 try leb.writeUleb128(writer, @as(u32, @intCast(sym_name.len)));
@@ -3846,7 +3913,7 @@ fn emitSymbolTable(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), symbol_table:
 
 fn emitSegmentInfo(wasm: *Wasm, binary_bytes: *std.ArrayList(u8)) !void {
     const writer = binary_bytes.writer();
-    try leb.writeUleb128(writer, @intFromEnum(types.SubsectionType.WASM_SEGMENT_INFO));
+    try leb.writeUleb128(writer, @intFromEnum(SubsectionType.WASM_SEGMENT_INFO));
     const segment_offset = binary_bytes.items.len;
 
     try leb.writeUleb128(writer, @as(u32, @intCast(wasm.segment_info.count())));
@@ -3886,7 +3953,7 @@ fn emitCodeRelocations(
     section_index: u32,
     symbol_table: std.AutoArrayHashMap(SymbolLoc, u32),
 ) !void {
-    const code_index = wasm.code_section_index orelse return;
+    const code_index = wasm.code_section_index.unwrap() orelse return;
     const writer = binary_bytes.writer();
     const header_offset = try reserveCustomSectionHeader(binary_bytes);
 
@@ -3983,7 +4050,7 @@ fn hasPassiveInitializationSegments(wasm: *const Wasm) bool {
 
     var it = wasm.data_segments.iterator();
     while (it.next()) |entry| {
-        const segment: Segment = wasm.segments.items[entry.value_ptr.*];
+        const segment = wasm.segmentPtr(entry.value_ptr.*);
         if (segment.needsPassiveInitialization(import_memory, entry.key_ptr.*)) {
             return true;
         }
@@ -4016,22 +4083,22 @@ pub fn putOrGetFuncType(wasm: *Wasm, func_type: std.wasm.Type) !u32 {
 /// Asserts declaration has an associated `Atom`.
 /// Returns the index into the list of types.
 pub fn storeNavType(wasm: *Wasm, nav: InternPool.Nav.Index, func_type: std.wasm.Type) !u32 {
-    return wasm.zigObjectPtr().?.storeDeclType(wasm.base.comp.gpa, nav, func_type);
+    return wasm.zig_object.?.storeDeclType(wasm.base.comp.gpa, nav, func_type);
 }
 
 /// Returns the symbol index of the error name table.
 ///
 /// When the symbol does not yet exist, it will create a new one instead.
-pub fn getErrorTableSymbol(wasm_file: *Wasm, pt: Zcu.PerThread) !u32 {
-    const sym_index = try wasm_file.zigObjectPtr().?.getErrorTableSymbol(wasm_file, pt);
+pub fn getErrorTableSymbol(wasm: *Wasm, pt: Zcu.PerThread) !u32 {
+    const sym_index = try wasm.zig_object.?.getErrorTableSymbol(wasm, pt);
     return @intFromEnum(sym_index);
 }
 
 /// For a given `InternPool.DeclIndex` returns its corresponding `Atom.Index`.
 /// When the index was not found, a new `Atom` will be created, and its index will be returned.
 /// The newly created Atom is empty with default fields as specified by `Atom.empty`.
-pub fn getOrCreateAtomForNav(wasm_file: *Wasm, pt: Zcu.PerThread, nav: InternPool.Nav.Index) !Atom.Index {
-    return wasm_file.zigObjectPtr().?.getOrCreateAtomForNav(wasm_file, pt, nav);
+pub fn getOrCreateAtomForNav(wasm: *Wasm, pt: Zcu.PerThread, nav: InternPool.Nav.Index) !Atom.Index {
+    return wasm.zig_object.?.getOrCreateAtomForNav(wasm, pt, nav);
 }
 
 /// Verifies all resolved symbols and checks whether itself needs to be marked alive,
@@ -4044,7 +4111,7 @@ fn markReferences(wasm: *Wasm) !void {
     const comp = wasm.base.comp;
 
     for (wasm.resolved_symbols.keys()) |sym_loc| {
-        const sym = sym_loc.getSymbol(wasm);
+        const sym = wasm.symbolLocSymbol(sym_loc);
         if (sym.isExported(comp.config.rdynamic) or sym.isNoStrip() or !do_garbage_collect) {
             try wasm.mark(sym_loc);
             continue;
@@ -4053,8 +4120,8 @@ fn markReferences(wasm: *Wasm) !void {
         // Debug sections may require to be parsed and marked when it contains
         // relocations to alive symbols.
         if (sym.tag == .section and comp.config.debug_format != .strip) {
-            const obj_file = wasm.file(sym_loc.file) orelse continue; // Incremental debug info is done independently
-            _ = try obj_file.parseSymbolIntoAtom(wasm, sym_loc.index);
+            const object_id = sym_loc.file.unwrap() orelse continue; // Incremental debug info is done independently
+            _ = try wasm.parseSymbolIntoAtom(object_id, sym_loc.index);
             sym.mark();
         }
     }
@@ -4063,7 +4130,7 @@ fn markReferences(wasm: *Wasm) !void {
 /// Marks a symbol as 'alive' recursively so itself and any references it contains to
 /// other symbols will not be omit from the binary.
 fn mark(wasm: *Wasm, loc: SymbolLoc) !void {
-    const symbol = loc.getSymbol(wasm);
+    const symbol = wasm.symbolLocSymbol(loc);
     if (symbol.isAlive()) {
         // Symbol is already marked alive, including its references.
         // This means we can skip it so we don't end up marking the same symbols
@@ -4071,28 +4138,642 @@ fn mark(wasm: *Wasm, loc: SymbolLoc) !void {
         return;
     }
     symbol.mark();
-    gc_log.debug("Marked symbol '{s}'", .{loc.getName(wasm)});
+    gc_log.debug("Marked symbol '{s}'", .{wasm.symbolLocName(loc)});
     if (symbol.isUndefined()) {
         // undefined symbols do not have an associated `Atom` and therefore also
         // do not contain relocations.
         return;
     }
 
-    const atom_index = if (wasm.file(loc.file)) |obj_file|
-        try obj_file.parseSymbolIntoAtom(wasm, loc.index)
+    const atom_index = if (loc.file.unwrap()) |object_id|
+        try wasm.parseSymbolIntoAtom(object_id, loc.index)
     else
         wasm.symbol_atom.get(loc) orelse return;
 
     const atom = wasm.getAtom(atom_index);
     for (atom.relocs.items) |reloc| {
         const target_loc: SymbolLoc = .{ .index = @enumFromInt(reloc.index), .file = loc.file };
-        try wasm.mark(target_loc.finalLoc(wasm));
+        try wasm.mark(wasm.symbolLocFinalLoc(target_loc));
     }
 }
 
-fn defaultEntrySymbolName(wasi_exec_model: std.builtin.WasiExecModel) []const u8 {
+fn defaultEntrySymbolName(
+    preloaded_strings: *const PreloadedStrings,
+    wasi_exec_model: std.builtin.WasiExecModel,
+) String {
     return switch (wasi_exec_model) {
-        .reactor => "_initialize",
-        .command => "_start",
+        .reactor => preloaded_strings._initialize,
+        .command => preloaded_strings._start,
+    };
+}
+
+pub const Atom = struct {
+    /// Represents the index of the file this atom was generated from.
+    /// This is `none` when the atom was generated by a synthetic linker symbol.
+    file: OptionalObjectId,
+    /// symbol index of the symbol representing this atom
+    sym_index: Symbol.Index,
+    /// Size of the atom, used to calculate section sizes in the final binary
+    size: u32 = 0,
+    /// List of relocations belonging to this atom
+    relocs: std.ArrayListUnmanaged(Relocation) = .empty,
+    /// Contains the binary data of an atom, which can be non-relocated
+    code: std.ArrayListUnmanaged(u8) = .empty,
+    /// For code this is 1, for data this is set to the highest value of all segments
+    alignment: Wasm.Alignment = .@"1",
+    /// Offset into the section where the atom lives, this already accounts
+    /// for alignment.
+    offset: u32 = 0,
+    /// The original offset within the object file. This value is subtracted from
+    /// relocation offsets to determine where in the `data` to rewrite the value
+    original_offset: u32 = 0,
+    /// Previous atom in relation to this atom.
+    /// is null when this atom is the first in its order
+    prev: Atom.Index = .null,
+    /// Contains atoms local to a decl, all managed by this `Atom`.
+    /// When the parent atom is being freed, it will also do so for all local atoms.
+    locals: std.ArrayListUnmanaged(Atom.Index) = .empty,
+
+    /// Represents the index of an Atom where `null` is considered
+    /// an invalid atom.
+    pub const Index = enum(u32) {
+        null = std.math.maxInt(u32),
+        _,
+    };
+
+    /// Frees all resources owned by this `Atom`.
+    pub fn deinit(atom: *Atom, gpa: std.mem.Allocator) void {
+        atom.relocs.deinit(gpa);
+        atom.code.deinit(gpa);
+        atom.locals.deinit(gpa);
+        atom.* = undefined;
+    }
+
+    /// Sets the length of relocations and code to '0',
+    /// effectively resetting them and allowing them to be re-populated.
+    pub fn clear(atom: *Atom) void {
+        atom.relocs.clearRetainingCapacity();
+        atom.code.clearRetainingCapacity();
+    }
+
+    pub fn format(atom: Atom, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+        _ = fmt;
+        _ = options;
+        try writer.print("Atom{{ .sym_index = {d}, .alignment = {d}, .size = {d}, .offset = 0x{x:0>8} }}", .{
+            @intFromEnum(atom.sym_index),
+            atom.alignment,
+            atom.size,
+            atom.offset,
+        });
+    }
+
+    /// Returns the location of the symbol that represents this `Atom`
+    pub fn symbolLoc(atom: Atom) Wasm.SymbolLoc {
+        return .{
+            .file = atom.file,
+            .index = atom.sym_index,
+        };
+    }
+
+    /// Resolves the relocations within the atom, writing the new value
+    /// at the calculated offset.
+    pub fn resolveRelocs(atom: *Atom, wasm: *const Wasm) void {
+        if (atom.relocs.items.len == 0) return;
+        const symbol_name = wasm.symbolLocName(atom.symbolLoc());
+        log.debug("Resolving relocs in atom '{s}' count({d})", .{
+            symbol_name,
+            atom.relocs.items.len,
+        });
+
+        for (atom.relocs.items) |reloc| {
+            const value = atom.relocationValue(reloc, wasm);
+            log.debug("Relocating '{s}' referenced in '{s}' offset=0x{x:0>8} value={d}", .{
+                wasm.symbolLocName(.{
+                    .file = atom.file,
+                    .index = @enumFromInt(reloc.index),
+                }),
+                symbol_name,
+                reloc.offset,
+                value,
+            });
+
+            switch (reloc.relocation_type) {
+                .R_WASM_TABLE_INDEX_I32,
+                .R_WASM_FUNCTION_OFFSET_I32,
+                .R_WASM_GLOBAL_INDEX_I32,
+                .R_WASM_MEMORY_ADDR_I32,
+                .R_WASM_SECTION_OFFSET_I32,
+                => std.mem.writeInt(u32, atom.code.items[reloc.offset - atom.original_offset ..][0..4], @as(u32, @truncate(value)), .little),
+                .R_WASM_TABLE_INDEX_I64,
+                .R_WASM_MEMORY_ADDR_I64,
+                => std.mem.writeInt(u64, atom.code.items[reloc.offset - atom.original_offset ..][0..8], value, .little),
+                .R_WASM_GLOBAL_INDEX_LEB,
+                .R_WASM_EVENT_INDEX_LEB,
+                .R_WASM_FUNCTION_INDEX_LEB,
+                .R_WASM_MEMORY_ADDR_LEB,
+                .R_WASM_MEMORY_ADDR_SLEB,
+                .R_WASM_TABLE_INDEX_SLEB,
+                .R_WASM_TABLE_NUMBER_LEB,
+                .R_WASM_TYPE_INDEX_LEB,
+                .R_WASM_MEMORY_ADDR_TLS_SLEB,
+                => leb.writeUnsignedFixed(5, atom.code.items[reloc.offset - atom.original_offset ..][0..5], @as(u32, @truncate(value))),
+                .R_WASM_MEMORY_ADDR_LEB64,
+                .R_WASM_MEMORY_ADDR_SLEB64,
+                .R_WASM_TABLE_INDEX_SLEB64,
+                .R_WASM_MEMORY_ADDR_TLS_SLEB64,
+                => leb.writeUnsignedFixed(10, atom.code.items[reloc.offset - atom.original_offset ..][0..10], value),
+            }
+        }
+    }
+
+    /// From a given `relocation` will return the new value to be written.
+    /// All values will be represented as a `u64` as all values can fit within it.
+    /// The final value must be casted to the correct size.
+    fn relocationValue(atom: Atom, relocation: Relocation, wasm: *const Wasm) u64 {
+        const target_loc = wasm.symbolLocFinalLoc(.{
+            .file = atom.file,
+            .index = @enumFromInt(relocation.index),
+        });
+        const symbol = wasm.symbolLocSymbol(target_loc);
+        if (relocation.relocation_type != .R_WASM_TYPE_INDEX_LEB and
+            symbol.tag != .section and
+            symbol.isDead())
+        {
+            const val = atom.tombstone(wasm) orelse relocation.addend;
+            return @bitCast(val);
+        }
+        switch (relocation.relocation_type) {
+            .R_WASM_FUNCTION_INDEX_LEB => return symbol.index,
+            .R_WASM_TABLE_NUMBER_LEB => return symbol.index,
+            .R_WASM_TABLE_INDEX_I32,
+            .R_WASM_TABLE_INDEX_I64,
+            .R_WASM_TABLE_INDEX_SLEB,
+            .R_WASM_TABLE_INDEX_SLEB64,
+            => return wasm.function_table.get(.{ .file = atom.file, .index = @enumFromInt(relocation.index) }) orelse 0,
+            .R_WASM_TYPE_INDEX_LEB => {
+                const object_id = atom.file.unwrap() orelse return relocation.index;
+                const original_type = objectFuncTypes(wasm, object_id)[relocation.index];
+                return wasm.getTypeIndex(original_type).?;
+            },
+            .R_WASM_GLOBAL_INDEX_I32,
+            .R_WASM_GLOBAL_INDEX_LEB,
+            => return symbol.index,
+            .R_WASM_MEMORY_ADDR_I32,
+            .R_WASM_MEMORY_ADDR_I64,
+            .R_WASM_MEMORY_ADDR_LEB,
+            .R_WASM_MEMORY_ADDR_LEB64,
+            .R_WASM_MEMORY_ADDR_SLEB,
+            .R_WASM_MEMORY_ADDR_SLEB64,
+            => {
+                std.debug.assert(symbol.tag == .data);
+                if (symbol.isUndefined()) {
+                    return 0;
+                }
+                const va: i33 = @intCast(symbol.virtual_address);
+                return @intCast(va + relocation.addend);
+            },
+            .R_WASM_EVENT_INDEX_LEB => return symbol.index,
+            .R_WASM_SECTION_OFFSET_I32 => {
+                const target_atom_index = wasm.symbol_atom.get(target_loc).?;
+                const target_atom = wasm.getAtom(target_atom_index);
+                const rel_value: i33 = @intCast(target_atom.offset);
+                return @intCast(rel_value + relocation.addend);
+            },
+            .R_WASM_FUNCTION_OFFSET_I32 => {
+                if (symbol.isUndefined()) {
+                    const val = atom.tombstone(wasm) orelse relocation.addend;
+                    return @bitCast(val);
+                }
+                const target_atom_index = wasm.symbol_atom.get(target_loc).?;
+                const target_atom = wasm.getAtom(target_atom_index);
+                const rel_value: i33 = @intCast(target_atom.offset);
+                return @intCast(rel_value + relocation.addend);
+            },
+            .R_WASM_MEMORY_ADDR_TLS_SLEB,
+            .R_WASM_MEMORY_ADDR_TLS_SLEB64,
+            => {
+                const va: i33 = @intCast(symbol.virtual_address);
+                return @intCast(va + relocation.addend);
+            },
+        }
+    }
+
+    // For a given `Atom` returns whether it has a tombstone value or not.
+    /// This defines whether we want a specific value when a section is dead.
+    fn tombstone(atom: Atom, wasm: *const Wasm) ?i64 {
+        const atom_name = wasm.symbolLocSymbol(atom.symbolLoc()).name;
+        if (atom_name == wasm.custom_sections.@".debug_ranges".name or
+            atom_name == wasm.custom_sections.@".debug_loc".name)
+        {
+            return -2;
+        } else if (std.mem.startsWith(u8, wasm.stringSlice(atom_name), ".debug_")) {
+            return -1;
+        } else {
+            return null;
+        }
+    }
+};
+
+pub const Relocation = struct {
+    /// Represents the type of the `Relocation`
+    relocation_type: RelocationType,
+    /// Offset of the value to rewrite relative to the relevant section's contents.
+    /// When `offset` is zero, its position is immediately after the id and size of the section.
+    offset: u32,
+    /// The index of the symbol used.
+    /// When the type is `R_WASM_TYPE_INDEX_LEB`, it represents the index of the type.
+    index: u32,
+    /// Addend to add to the address.
+    /// This field is only non-zero for `R_WASM_MEMORY_ADDR_*`, `R_WASM_FUNCTION_OFFSET_I32` and `R_WASM_SECTION_OFFSET_I32`.
+    addend: i32 = 0,
+
+    /// All possible relocation types currently existing.
+    /// This enum is exhaustive as the spec is WIP and new types
+    /// can be added which means that a generated binary will be invalid,
+    /// so instead we will show an error in such cases.
+    pub const RelocationType = enum(u8) {
+        R_WASM_FUNCTION_INDEX_LEB = 0,
+        R_WASM_TABLE_INDEX_SLEB = 1,
+        R_WASM_TABLE_INDEX_I32 = 2,
+        R_WASM_MEMORY_ADDR_LEB = 3,
+        R_WASM_MEMORY_ADDR_SLEB = 4,
+        R_WASM_MEMORY_ADDR_I32 = 5,
+        R_WASM_TYPE_INDEX_LEB = 6,
+        R_WASM_GLOBAL_INDEX_LEB = 7,
+        R_WASM_FUNCTION_OFFSET_I32 = 8,
+        R_WASM_SECTION_OFFSET_I32 = 9,
+        R_WASM_EVENT_INDEX_LEB = 10,
+        R_WASM_GLOBAL_INDEX_I32 = 13,
+        R_WASM_MEMORY_ADDR_LEB64 = 14,
+        R_WASM_MEMORY_ADDR_SLEB64 = 15,
+        R_WASM_MEMORY_ADDR_I64 = 16,
+        R_WASM_TABLE_INDEX_SLEB64 = 18,
+        R_WASM_TABLE_INDEX_I64 = 19,
+        R_WASM_TABLE_NUMBER_LEB = 20,
+        R_WASM_MEMORY_ADDR_TLS_SLEB = 21,
+        R_WASM_MEMORY_ADDR_TLS_SLEB64 = 25,
+
+        /// Returns true for relocation types where the `addend` field is present.
+        pub fn addendIsPresent(self: RelocationType) bool {
+            return switch (self) {
+                .R_WASM_MEMORY_ADDR_LEB,
+                .R_WASM_MEMORY_ADDR_SLEB,
+                .R_WASM_MEMORY_ADDR_I32,
+                .R_WASM_MEMORY_ADDR_LEB64,
+                .R_WASM_MEMORY_ADDR_SLEB64,
+                .R_WASM_MEMORY_ADDR_I64,
+                .R_WASM_MEMORY_ADDR_TLS_SLEB,
+                .R_WASM_MEMORY_ADDR_TLS_SLEB64,
+                .R_WASM_FUNCTION_OFFSET_I32,
+                .R_WASM_SECTION_OFFSET_I32,
+                => true,
+                else => false,
+            };
+        }
+    };
+
+    /// Verifies the relocation type of a given `Relocation` and returns
+    /// true when the relocation references a function call or address to a function.
+    pub fn isFunction(self: Relocation) bool {
+        return switch (self.relocation_type) {
+            .R_WASM_FUNCTION_INDEX_LEB,
+            .R_WASM_TABLE_INDEX_SLEB,
+            => true,
+            else => false,
+        };
+    }
+
+    pub fn format(self: Relocation, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+        _ = fmt;
+        _ = options;
+        try writer.print("{s} offset=0x{x:0>6} symbol={d}", .{
+            @tagName(self.relocation_type),
+            self.offset,
+            self.index,
+        });
+    }
+};
+
+/// Unlike the `Import` object defined by the wasm spec, and existing
+/// in the std.wasm namespace, this construct saves the 'module name' and 'name'
+/// of the import using offsets into a string table, rather than the slices itself.
+/// This saves us (potentially) 24 bytes per import on 64bit machines.
+pub const Import = struct {
+    module_name: String,
+    name: String,
+    kind: std.wasm.Import.Kind,
+};
+
+/// Unlike the `Export` object defined by the wasm spec, and existing
+/// in the std.wasm namespace, this construct saves the 'name'
+/// of the export using offsets into a string table, rather than the slice itself.
+/// This saves us (potentially) 12 bytes per export on 64bit machines.
+pub const Export = struct {
+    name: String,
+    index: u32,
+    kind: std.wasm.ExternalKind,
+};
+
+pub const SubsectionType = enum(u8) {
+    WASM_SEGMENT_INFO = 5,
+    WASM_INIT_FUNCS = 6,
+    WASM_COMDAT_INFO = 7,
+    WASM_SYMBOL_TABLE = 8,
+};
+
+pub const Alignment = @import("../InternPool.zig").Alignment;
+
+pub const NamedSegment = struct {
+    /// Segment's name, encoded as UTF-8 bytes.
+    name: []const u8,
+    /// The required alignment of the segment, encoded as a power of 2
+    alignment: Alignment,
+    /// Bitfield containing flags for a segment
+    flags: u32,
+
+    pub fn isTLS(segment: NamedSegment) bool {
+        return segment.flags & @intFromEnum(Flags.WASM_SEG_FLAG_TLS) != 0;
+    }
+
+    /// Returns the name as how it will be output into the final object
+    /// file or binary. When `merge_segments` is true, this will return the
+    /// short name. i.e. ".rodata". When false, it returns the entire name instead.
+    pub fn outputName(segment: NamedSegment, merge_segments: bool) []const u8 {
+        if (segment.isTLS()) {
+            return ".tdata";
+        } else if (!merge_segments) {
+            return segment.name;
+        } else if (std.mem.startsWith(u8, segment.name, ".rodata.")) {
+            return ".rodata";
+        } else if (std.mem.startsWith(u8, segment.name, ".text.")) {
+            return ".text";
+        } else if (std.mem.startsWith(u8, segment.name, ".data.")) {
+            return ".data";
+        } else if (std.mem.startsWith(u8, segment.name, ".bss.")) {
+            return ".bss";
+        }
+        return segment.name;
+    }
+
+    pub const Flags = enum(u32) {
+        WASM_SEG_FLAG_STRINGS = 0x1,
+        WASM_SEG_FLAG_TLS = 0x2,
+    };
+};
+
+pub const InitFunc = struct {
+    /// Priority of the init function
+    priority: u32,
+    /// The symbol index of init function (not the function index).
+    symbol_index: u32,
+};
+
+pub const Comdat = struct {
+    name: []const u8,
+    /// Must be zero, no flags are currently defined by the tool-convention.
+    flags: u32,
+    symbols: []const ComdatSym,
+};
+
+pub const ComdatSym = struct {
+    kind: @This().Type,
+    /// Index of the data segment/function/global/event/table within a WASM module.
+    /// The object must not be an import.
+    index: u32,
+
+    pub const Type = enum(u8) {
+        WASM_COMDAT_DATA = 0,
+        WASM_COMDAT_FUNCTION = 1,
+        WASM_COMDAT_GLOBAL = 2,
+        WASM_COMDAT_EVENT = 3,
+        WASM_COMDAT_TABLE = 4,
+        WASM_COMDAT_SECTION = 5,
+    };
+};
+
+pub const Feature = struct {
+    /// Provides information about the usage of the feature.
+    /// - '0x2b' (+): Object uses this feature, and the link fails if feature is not in the allowed set.
+    /// - '0x2d' (-): Object does not use this feature, and the link fails if this feature is in the allowed set.
+    /// - '0x3d' (=): Object uses this feature, and the link fails if this feature is not in the allowed set,
+    /// or if any object does not use this feature.
+    prefix: Prefix,
+    /// Type of the feature, must be unique in the sequence of features.
+    tag: Tag,
+
+    /// Unlike `std.Target.wasm.Feature` this also contains linker-features such as shared-mem
+    pub const Tag = enum {
+        atomics,
+        bulk_memory,
+        exception_handling,
+        extended_const,
+        half_precision,
+        multimemory,
+        multivalue,
+        mutable_globals,
+        nontrapping_fptoint,
+        reference_types,
+        relaxed_simd,
+        sign_ext,
+        simd128,
+        tail_call,
+        shared_mem,
+
+        /// From a given cpu feature, returns its linker feature
+        pub fn fromCpuFeature(feature: std.Target.wasm.Feature) Tag {
+            return @as(Tag, @enumFromInt(@intFromEnum(feature)));
+        }
+
+        pub fn format(tag: Tag, comptime fmt: []const u8, opt: std.fmt.FormatOptions, writer: anytype) !void {
+            _ = fmt;
+            _ = opt;
+            try writer.writeAll(switch (tag) {
+                .atomics => "atomics",
+                .bulk_memory => "bulk-memory",
+                .exception_handling => "exception-handling",
+                .extended_const => "extended-const",
+                .half_precision => "half-precision",
+                .multimemory => "multimemory",
+                .multivalue => "multivalue",
+                .mutable_globals => "mutable-globals",
+                .nontrapping_fptoint => "nontrapping-fptoint",
+                .reference_types => "reference-types",
+                .relaxed_simd => "relaxed-simd",
+                .sign_ext => "sign-ext",
+                .simd128 => "simd128",
+                .tail_call => "tail-call",
+                .shared_mem => "shared-mem",
+            });
+        }
+    };
+
+    pub const Prefix = enum(u8) {
+        used = '+',
+        disallowed = '-',
+        required = '=',
+    };
+
+    pub fn format(feature: Feature, comptime fmt: []const u8, opt: std.fmt.FormatOptions, writer: anytype) !void {
+        _ = opt;
+        _ = fmt;
+        try writer.print("{c} {}", .{ feature.prefix, feature.tag });
+    }
+};
+
+pub const known_features = std.StaticStringMap(Feature.Tag).initComptime(.{
+    .{ "atomics", .atomics },
+    .{ "bulk-memory", .bulk_memory },
+    .{ "exception-handling", .exception_handling },
+    .{ "extended-const", .extended_const },
+    .{ "half-precision", .half_precision },
+    .{ "multimemory", .multimemory },
+    .{ "multivalue", .multivalue },
+    .{ "mutable-globals", .mutable_globals },
+    .{ "nontrapping-fptoint", .nontrapping_fptoint },
+    .{ "reference-types", .reference_types },
+    .{ "relaxed-simd", .relaxed_simd },
+    .{ "sign-ext", .sign_ext },
+    .{ "simd128", .simd128 },
+    .{ "tail-call", .tail_call },
+    .{ "shared-mem", .shared_mem },
+});
+
+/// Parses an object file into atoms, for code and data sections
+fn parseSymbolIntoAtom(wasm: *Wasm, object_id: ObjectId, symbol_index: Symbol.Index) !Atom.Index {
+    const object = wasm.objectById(object_id) orelse
+        return wasm.zig_object.?.parseSymbolIntoAtom(wasm, symbol_index);
+    const comp = wasm.base.comp;
+    const gpa = comp.gpa;
+    const symbol = &object.symtable[@intFromEnum(symbol_index)];
+    const relocatable_data: Object.RelocatableData = switch (symbol.tag) {
+        .function => object.relocatable_data.get(.code).?[symbol.index - object.imported_functions_count],
+        .data => object.relocatable_data.get(.data).?[symbol.index],
+        .section => blk: {
+            const data = object.relocatable_data.get(.custom).?;
+            for (data) |dat| {
+                if (dat.section_index == symbol.index) {
+                    break :blk dat;
+                }
+            }
+            unreachable;
+        },
+        else => unreachable,
     };
+    const final_index = try wasm.getMatchingSegment(object_id, symbol_index);
+    const atom_index = try wasm.createAtom(symbol_index, object_id.toOptional());
+    try wasm.appendAtomAtIndex(final_index, atom_index);
+
+    const atom = wasm.getAtomPtr(atom_index);
+    atom.size = relocatable_data.size;
+    atom.alignment = relocatable_data.getAlignment(object);
+    atom.code = std.ArrayListUnmanaged(u8).fromOwnedSlice(relocatable_data.data[0..relocatable_data.size]);
+    atom.original_offset = relocatable_data.offset;
+
+    const segment = wasm.segmentPtr(final_index);
+    if (relocatable_data.type == .data) { //code section and custom sections are 1-byte aligned
+        segment.alignment = segment.alignment.max(atom.alignment);
+    }
+
+    if (object.relocations.get(relocatable_data.section_index)) |relocations| {
+        const start = searchRelocStart(relocations, relocatable_data.offset);
+        const len = searchRelocEnd(relocations[start..], relocatable_data.offset + atom.size);
+        atom.relocs = std.ArrayListUnmanaged(Wasm.Relocation).fromOwnedSlice(relocations[start..][0..len]);
+        for (atom.relocs.items) |reloc| {
+            switch (reloc.relocation_type) {
+                .R_WASM_TABLE_INDEX_I32,
+                .R_WASM_TABLE_INDEX_I64,
+                .R_WASM_TABLE_INDEX_SLEB,
+                .R_WASM_TABLE_INDEX_SLEB64,
+                => {
+                    try wasm.function_table.put(gpa, .{
+                        .file = object_id.toOptional(),
+                        .index = @enumFromInt(reloc.index),
+                    }, 0);
+                },
+                .R_WASM_GLOBAL_INDEX_I32,
+                .R_WASM_GLOBAL_INDEX_LEB,
+                => {
+                    const sym = object.symtable[reloc.index];
+                    if (sym.tag != .global) {
+                        try wasm.got_symbols.append(gpa, .{
+                            .file = object_id.toOptional(),
+                            .index = @enumFromInt(reloc.index),
+                        });
+                    }
+                },
+                else => {},
+            }
+        }
+    }
+
+    return atom_index;
+}
+
+fn searchRelocStart(relocs: []const Wasm.Relocation, address: u32) usize {
+    var min: usize = 0;
+    var max: usize = relocs.len;
+    while (min < max) {
+        const index = (min + max) / 2;
+        const curr = relocs[index];
+        if (curr.offset < address) {
+            min = index + 1;
+        } else {
+            max = index;
+        }
+    }
+    return min;
+}
+
+fn searchRelocEnd(relocs: []const Wasm.Relocation, address: u32) usize {
+    for (relocs, 0..relocs.len) |reloc, index| {
+        if (reloc.offset > address) {
+            return index;
+        }
+    }
+    return relocs.len;
+}
+
+pub fn internString(wasm: *Wasm, bytes: []const u8) error{OutOfMemory}!String {
+    const gpa = wasm.base.comp.gpa;
+    const gop = try wasm.string_table.getOrPutContextAdapted(
+        gpa,
+        @as([]const u8, bytes),
+        @as(String.TableIndexAdapter, .{ .bytes = wasm.string_bytes.items }),
+        @as(String.TableContext, .{ .bytes = wasm.string_bytes.items }),
+    );
+    if (gop.found_existing) return gop.key_ptr.*;
+
+    try wasm.string_bytes.ensureUnusedCapacity(gpa, bytes.len + 1);
+    const new_off: String = @enumFromInt(wasm.string_bytes.items.len);
+
+    wasm.string_bytes.appendSliceAssumeCapacity(bytes);
+    wasm.string_bytes.appendAssumeCapacity(0);
+
+    gop.key_ptr.* = new_off;
+
+    return new_off;
+}
+
+pub fn getExistingString(wasm: *const Wasm, bytes: []const u8) ?String {
+    return wasm.string_table.getKeyAdapted(bytes, @as(String.TableIndexAdapter, .{
+        .bytes = wasm.string_bytes.items,
+    }));
+}
+
+pub fn stringSlice(wasm: *const Wasm, index: String) [:0]const u8 {
+    const slice = wasm.string_bytes.items[@intFromEnum(index)..];
+    return slice[0..mem.indexOfScalar(u8, slice, 0).? :0];
+}
+
+pub fn optionalStringSlice(wasm: *const Wasm, index: OptionalString) ?[:0]const u8 {
+    return stringSlice(wasm, index.unwrap() orelse return null);
+}
+
+pub fn castToString(wasm: *const Wasm, index: u32) String {
+    assert(index == 0 or wasm.string_bytes.items[index - 1] == 0);
+    return @enumFromInt(index);
+}
+
+fn segmentPtr(wasm: *const Wasm, index: Segment.Index) *Segment {
+    return &wasm.segments.items[@intFromEnum(index)];
 }
diff --git a/zig/src/link/Wasm/Archive.zig b/zig/src/link/Wasm/Archive.zig
index c7e5c7caba..c2078fa525 100644
--- a/zig/src/link/Wasm/Archive.zig
+++ b/zig/src/link/Wasm/Archive.zig
@@ -1,79 +1,65 @@
-file: fs.File,
-name: []const u8,
-
-header: ar_hdr = undefined,
-
 /// A list of long file names, delimited by a LF character (0x0a).
 /// This is stored as a single slice of bytes, as the header-names
 /// point to the character index of a file name, rather than the index
 /// in the list.
-long_file_names: []const u8 = undefined,
+/// Points into `file_contents`.
+long_file_names: RelativeSlice,
 
 /// Parsed table of contents.
 /// Each symbol name points to a list of all definition
 /// sites within the current static archive.
-toc: std.StringArrayHashMapUnmanaged(std.ArrayListUnmanaged(u32)) = .empty,
+toc: Toc,
 
-// Archive files start with the ARMAG identifying string.  Then follows a
-// `struct ar_hdr', and as many bytes of member file data as its `ar_size'
-// member indicates, for each member file.
-/// String that begins an archive file.
-const ARMAG: *const [SARMAG:0]u8 = "!<arch>\n";
-/// Size of that string.
-const SARMAG: u4 = 8;
+/// Key points into `LazyArchive` `file_contents`.
+/// Value is allocated with gpa.
+const Toc = std.StringArrayHashMapUnmanaged(std.ArrayListUnmanaged(u32));
 
-/// String in ar_fmag at the end of each header.
-const ARFMAG: *const [2:0]u8 = "`\n";
+const ARMAG = std.elf.ARMAG;
+const ARFMAG = std.elf.ARFMAG;
 
-const ar_hdr = extern struct {
-    /// Member file name, sometimes / terminated.
-    ar_name: [16]u8,
+const RelativeSlice = struct {
+    off: u32,
+    len: u32,
+};
 
+const Header = extern struct {
+    /// Member file name, sometimes / terminated.
+    name: [16]u8,
     /// File date, decimal seconds since Epoch.
-    ar_date: [12]u8,
-
+    date: [12]u8,
     /// User ID, in ASCII format.
-    ar_uid: [6]u8,
-
+    uid: [6]u8,
     /// Group ID, in ASCII format.
-    ar_gid: [6]u8,
-
+    gid: [6]u8,
     /// File mode, in ASCII octal.
-    ar_mode: [8]u8,
-
+    mode: [8]u8,
     /// File size, in ASCII decimal.
-    ar_size: [10]u8,
-
+    size: [10]u8,
     /// Always contains ARFMAG.
-    ar_fmag: [2]u8,
+    fmag: [2]u8,
 
     const NameOrIndex = union(enum) {
         name: []const u8,
         index: u32,
     };
 
-    fn nameOrIndex(archive: ar_hdr) !NameOrIndex {
-        const value = getValue(&archive.ar_name);
+    fn nameOrIndex(archive: Header) !NameOrIndex {
+        const value = getValue(&archive.name);
         const slash_index = mem.indexOfScalar(u8, value, '/') orelse return error.MalformedArchive;
         const len = value.len;
         if (slash_index == len - 1) {
             // Name stored directly
-            return NameOrIndex{ .name = value };
+            return .{ .name = value };
         } else {
             // Name follows the header directly and its length is encoded in
             // the name field.
             const index = try std.fmt.parseInt(u32, value[slash_index + 1 ..], 10);
-            return NameOrIndex{ .index = index };
+            return .{ .index = index };
         }
     }
 
-    fn date(archive: ar_hdr) !u64 {
-        const value = getValue(&archive.ar_date);
-        return std.fmt.parseInt(u64, value, 10);
-    }
-
-    fn size(archive: ar_hdr) !u32 {
-        const value = getValue(&archive.ar_size);
+    fn parsedSize(archive: Header) !u32 {
+        const value = getValue(&archive.size);
         return std.fmt.parseInt(u32, value, 10);
     }
 
@@ -82,138 +68,108 @@ const ar_hdr = extern struct {
     }
 };
 
-pub fn deinit(archive: *Archive, allocator: Allocator) void {
-    archive.file.close();
-    for (archive.toc.keys()) |*key| {
-        allocator.free(key.*);
-    }
-    for (archive.toc.values()) |*value| {
-        value.deinit(allocator);
-    }
-    archive.toc.deinit(allocator);
-    allocator.free(archive.long_file_names);
+pub fn deinit(archive: *Archive, gpa: Allocator) void {
+    deinitToc(gpa, &archive.toc);
+    archive.* = undefined;
 }
 
-pub fn parse(archive: *Archive, allocator: Allocator) !void {
-    const reader = archive.file.reader();
-
-    const magic = try reader.readBytesNoEof(SARMAG);
-    if (!mem.eql(u8, &magic, ARMAG)) {
-        log.debug("invalid magic: expected '{s}', found '{s}'", .{ ARMAG, magic });
-        return error.NotArchive;
-    }
+fn deinitToc(gpa: Allocator, toc: *Toc) void {
+    for (toc.values()) |*value| value.deinit(gpa);
+    toc.deinit(gpa);
+}
 
-    archive.header = try reader.readStruct(ar_hdr);
-    if (!mem.eql(u8, &archive.header.ar_fmag, ARFMAG)) {
-        log.debug("invalid header delimiter: expected '{s}', found '{s}'", .{ ARFMAG, archive.header.ar_fmag });
-        return error.NotArchive;
-    }
+pub fn parse(gpa: Allocator, file_contents: []const u8) !Archive {
+    var pos: usize = 0;
 
-    try archive.parseTableOfContents(allocator, reader);
-    try archive.parseNameTable(allocator, reader);
-}
+    if (!mem.eql(u8, file_contents[0..ARMAG.len], ARMAG)) return error.BadArchiveMagic;
+    pos += ARMAG.len;
 
-fn parseName(archive: *const Archive, header: ar_hdr) ![]const u8 {
-    const name_or_index = try header.nameOrIndex();
-    switch (name_or_index) {
-        .name => |name| return name,
-        .index => |index| {
-            const name = mem.sliceTo(archive.long_file_names[index..], 0x0a);
-            return mem.trimRight(u8, name, "/");
-        },
-    }
-}
+    const header = mem.bytesAsValue(Header, file_contents[pos..][0..@sizeOf(Header)]);
+    if (!mem.eql(u8, &header.fmag, ARFMAG)) return error.BadHeaderDelimiter;
+    pos += @sizeOf(Header);
 
-fn parseTableOfContents(archive: *Archive, allocator: Allocator, reader: anytype) !void {
-    // size field can have extra spaces padded in front as well as the end,
-    // so we trim those first before parsing the ASCII value.
-    const size_trimmed = mem.trim(u8, &archive.header.ar_size, " ");
+    // The size field can have extra spaces padded in front as well as
+    // the end, so we trim those first before parsing the ASCII value.
+    const size_trimmed = mem.trim(u8, &header.size, " ");
     const sym_tab_size = try std.fmt.parseInt(u32, size_trimmed, 10);
 
-    const num_symbols = try reader.readInt(u32, .big);
-    const symbol_positions = try allocator.alloc(u32, num_symbols);
-    defer allocator.free(symbol_positions);
-    for (symbol_positions) |*index| {
-        index.* = try reader.readInt(u32, .big);
-    }
+    const num_symbols = mem.readInt(u32, file_contents[pos..][0..4], .big);
+    pos += 4;
 
-    const sym_tab = try allocator.alloc(u8, sym_tab_size - 4 - (4 * num_symbols));
-    defer allocator.free(sym_tab);
+    const symbol_positions_size = @sizeOf(u32) * num_symbols;
+    const symbol_positions_be = mem.bytesAsSlice(u32, file_contents[pos..][0..symbol_positions_size]);
+    pos += symbol_positions_size;
 
-    reader.readNoEof(sym_tab) catch return error.IncompleteSymbolTable;
+    const sym_tab = file_contents[pos..][0 .. sym_tab_size - 4 - symbol_positions_size];
+    pos += sym_tab.len;
 
-    var i: usize = 0;
-    var pos: usize = 0;
-    while (i < num_symbols) : (i += 1) {
-        const string = mem.sliceTo(sym_tab[pos..], 0);
-        pos += string.len + 1;
-        if (string.len == 0) continue;
-
-        const name = try allocator.dupe(u8, string);
-        errdefer allocator.free(name);
-        const gop = try archive.toc.getOrPut(allocator, name);
-        if (gop.found_existing) {
-            allocator.free(name);
-        } else {
-            gop.value_ptr.* = .{};
-        }
-        try gop.value_ptr.append(allocator, symbol_positions[i]);
-    }
-}
+    var toc: Toc = .empty;
+    errdefer deinitToc(gpa, &toc);
 
-fn parseNameTable(archive: *Archive, allocator: Allocator, reader: anytype) !void {
-    const header: ar_hdr = try reader.readStruct(ar_hdr);
-    if (!mem.eql(u8, &header.ar_fmag, ARFMAG)) {
-        return error.InvalidHeaderDelimiter;
-    }
-    if (!mem.eql(u8, header.ar_name[0..2], "//")) {
-        return error.MissingTableName;
+    var sym_tab_pos: usize = 0;
+    for (0..num_symbols) |i| {
+        const name = mem.sliceTo(sym_tab[sym_tab_pos..], 0);
+        sym_tab_pos += name.len + 1;
+        if (name.len == 0) continue;
+
+        const gop = try toc.getOrPut(gpa, name);
+        if (!gop.found_existing) gop.value_ptr.* = .empty;
+        try gop.value_ptr.append(gpa, switch (native_endian) {
+            .big => symbol_positions_be[i],
+            .little => @byteSwap(symbol_positions_be[i]),
+        });
     }
-    const table_size = try header.size();
-    const long_file_names = try allocator.alloc(u8, table_size);
-    errdefer allocator.free(long_file_names);
-    try reader.readNoEof(long_file_names);
-    archive.long_file_names = long_file_names;
+
+    const long_file_names: RelativeSlice = s: {
+        const sub_header = mem.bytesAsValue(Header, file_contents[pos..][0..@sizeOf(Header)]);
+        pos += @sizeOf(Header);
+
+        if (!mem.eql(u8, &header.fmag, ARFMAG)) return error.BadHeaderDelimiter;
+        if (!mem.eql(u8, sub_header.name[0..2], "//")) return error.MissingTableName;
+        const table_size = try sub_header.parsedSize();
+
+        break :s .{
+            .off = @intCast(pos),
+            .len = table_size,
+        };
+    };
+
+    return .{
+        .toc = toc,
+        .long_file_names = long_file_names,
+    };
 }
 
 /// From a given file offset, starts reading for a file header.
 /// When found, parses the object file into an `Object` and returns it.
-pub fn parseObject(archive: Archive, wasm_file: *const Wasm, file_offset: u32) !Object {
-    const gpa = wasm_file.base.comp.gpa;
-    try archive.file.seekTo(file_offset);
-    const reader = archive.file.reader();
-    const header = try reader.readStruct(ar_hdr);
-    const current_offset = try archive.file.getPos();
-    try archive.file.seekTo(0);
-
-    if (!mem.eql(u8, &header.ar_fmag, ARFMAG)) {
-        return error.InvalidHeaderDelimiter;
-    }
+pub fn parseObject(archive: Archive, wasm: *Wasm, file_contents: []const u8, path: Path) !Object {
+    const header = mem.bytesAsValue(Header, file_contents[0..@sizeOf(Header)]);
+    if (!mem.eql(u8, &header.fmag, ARFMAG)) return error.BadHeaderDelimiter;
 
-    const object_name = try archive.parseName(header);
-    const name = name: {
-        var buffer: [std.fs.max_path_bytes]u8 = undefined;
-        const path = try std.posix.realpath(archive.name, &buffer);
-        break :name try std.fmt.allocPrint(gpa, "{s}({s})", .{ path, object_name });
+    const name_or_index = try header.nameOrIndex();
+    const object_name = switch (name_or_index) {
+        .name => |name| name,
+        .index => |index| n: {
+            const long_file_names = file_contents[archive.long_file_names.off..][0..archive.long_file_names.len];
+            const name = mem.sliceTo(long_file_names[index..], 0x0a);
+            break :n mem.trimRight(u8, name, "/");
+        },
     };
-    defer gpa.free(name);
 
-    const object_file = try std.fs.cwd().openFile(archive.name, .{});
-    errdefer object_file.close();
+    const object_file_size = try header.parsedSize();
 
-    const object_file_size = try header.size();
-    try object_file.seekTo(current_offset);
-    return Object.create(wasm_file, object_file, name, object_file_size);
+    return Object.create(wasm, file_contents[@sizeOf(Header)..][0..object_file_size], path, object_name);
 }
 
+const Archive = @This();
+
+const builtin = @import("builtin");
+const native_endian = builtin.cpu.arch.endian();
+
 const std = @import("std");
-const assert = std.debug.assert;
-const fs = std.fs;
-const log = std.log.scoped(.archive);
 const mem = std.mem;
+const Allocator = std.mem.Allocator;
+const Path = std.Build.Cache.Path;
 
-const Allocator = mem.Allocator;
-const Object = @import("Object.zig");
 const Wasm = @import("../Wasm.zig");
-
-const Archive = @This();
+const Object = @import("Object.zig");
diff --git a/zig/src/link/Wasm/Atom.zig b/zig/src/link/Wasm/Atom.zig
deleted file mode 100644
index dd373552d5..0000000000
--- a/zig/src/link/Wasm/Atom.zig
+++ /dev/null
@@ -1,204 +0,0 @@
-/// Represents the index of the file this atom was generated from.
-/// This is 'null' when the atom was generated by a synthetic linker symbol.
-file: FileIndex,
-/// symbol index of the symbol representing this atom
-sym_index: Symbol.Index,
-/// Size of the atom, used to calculate section sizes in the final binary
-size: u32 = 0,
-/// List of relocations belonging to this atom
-relocs: std.ArrayListUnmanaged(types.Relocation) = .empty,
-/// Contains the binary data of an atom, which can be non-relocated
-code: std.ArrayListUnmanaged(u8) = .empty,
-/// For code this is 1, for data this is set to the highest value of all segments
-alignment: Wasm.Alignment = .@"1",
-/// Offset into the section where the atom lives, this already accounts
-/// for alignment.
-offset: u32 = 0,
-/// The original offset within the object file. This value is subtracted from
-/// relocation offsets to determine where in the `data` to rewrite the value
-original_offset: u32 = 0,
-/// Previous atom in relation to this atom.
-/// is null when this atom is the first in its order
-prev: Atom.Index = .null,
-/// Contains atoms local to a decl, all managed by this `Atom`.
-/// When the parent atom is being freed, it will also do so for all local atoms.
-locals: std.ArrayListUnmanaged(Atom.Index) = .empty,
-
-/// Represents the index of an Atom where `null` is considered
-/// an invalid atom.
-pub const Index = enum(u32) {
-    null = std.math.maxInt(u32),
-    _,
-};
-
-/// Frees all resources owned by this `Atom`.
-pub fn deinit(atom: *Atom, gpa: std.mem.Allocator) void {
-    atom.relocs.deinit(gpa);
-    atom.code.deinit(gpa);
-    atom.locals.deinit(gpa);
-    atom.* = undefined;
-}
-
-/// Sets the length of relocations and code to '0',
-/// effectively resetting them and allowing them to be re-populated.
-pub fn clear(atom: *Atom) void {
-    atom.relocs.clearRetainingCapacity();
-    atom.code.clearRetainingCapacity();
-}
-
-pub fn format(atom: Atom, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
-    _ = fmt;
-    _ = options;
-    try writer.print("Atom{{ .sym_index = {d}, .alignment = {d}, .size = {d}, .offset = 0x{x:0>8} }}", .{
-        @intFromEnum(atom.sym_index),
-        atom.alignment,
-        atom.size,
-        atom.offset,
-    });
-}
-
-/// Returns the location of the symbol that represents this `Atom`
-pub fn symbolLoc(atom: Atom) Wasm.SymbolLoc {
-    return .{ .file = atom.file, .index = atom.sym_index };
-}
-
-/// Resolves the relocations within the atom, writing the new value
-/// at the calculated offset.
-pub fn resolveRelocs(atom: *Atom, wasm_bin: *const Wasm) void {
-    if (atom.relocs.items.len == 0) return;
-    const symbol_name = atom.symbolLoc().getName(wasm_bin);
-    log.debug("Resolving relocs in atom '{s}' count({d})", .{
-        symbol_name,
-        atom.relocs.items.len,
-    });
-
-    for (atom.relocs.items) |reloc| {
-        const value = atom.relocationValue(reloc, wasm_bin);
-        log.debug("Relocating '{s}' referenced in '{s}' offset=0x{x:0>8} value={d}", .{
-            (Wasm.SymbolLoc{ .file = atom.file, .index = @enumFromInt(reloc.index) }).getName(wasm_bin),
-            symbol_name,
-            reloc.offset,
-            value,
-        });
-
-        switch (reloc.relocation_type) {
-            .R_WASM_TABLE_INDEX_I32,
-            .R_WASM_FUNCTION_OFFSET_I32,
-            .R_WASM_GLOBAL_INDEX_I32,
-            .R_WASM_MEMORY_ADDR_I32,
-            .R_WASM_SECTION_OFFSET_I32,
-            => std.mem.writeInt(u32, atom.code.items[reloc.offset - atom.original_offset ..][0..4], @as(u32, @truncate(value)), .little),
-            .R_WASM_TABLE_INDEX_I64,
-            .R_WASM_MEMORY_ADDR_I64,
-            => std.mem.writeInt(u64, atom.code.items[reloc.offset - atom.original_offset ..][0..8], value, .little),
-            .R_WASM_GLOBAL_INDEX_LEB,
-            .R_WASM_EVENT_INDEX_LEB,
-            .R_WASM_FUNCTION_INDEX_LEB,
-            .R_WASM_MEMORY_ADDR_LEB,
-            .R_WASM_MEMORY_ADDR_SLEB,
-            .R_WASM_TABLE_INDEX_SLEB,
-            .R_WASM_TABLE_NUMBER_LEB,
-            .R_WASM_TYPE_INDEX_LEB,
-            .R_WASM_MEMORY_ADDR_TLS_SLEB,
-            => leb.writeUnsignedFixed(5, atom.code.items[reloc.offset - atom.original_offset ..][0..5], @as(u32, @truncate(value))),
-            .R_WASM_MEMORY_ADDR_LEB64,
-            .R_WASM_MEMORY_ADDR_SLEB64,
-            .R_WASM_TABLE_INDEX_SLEB64,
-            .R_WASM_MEMORY_ADDR_TLS_SLEB64,
-            => leb.writeUnsignedFixed(10, atom.code.items[reloc.offset - atom.original_offset ..][0..10], value),
-        }
-    }
-}
-
-/// From a given `relocation` will return the new value to be written.
-/// All values will be represented as a `u64` as all values can fit within it.
-/// The final value must be casted to the correct size.
-fn relocationValue(atom: Atom, relocation: types.Relocation, wasm_bin: *const Wasm) u64 {
-    const target_loc = (Wasm.SymbolLoc{ .file = atom.file, .index = @enumFromInt(relocation.index) }).finalLoc(wasm_bin);
-    const symbol = target_loc.getSymbol(wasm_bin);
-    if (relocation.relocation_type != .R_WASM_TYPE_INDEX_LEB and
-        symbol.tag != .section and
-        symbol.isDead())
-    {
-        const val = atom.thombstone(wasm_bin) orelse relocation.addend;
-        return @bitCast(val);
-    }
-    switch (relocation.relocation_type) {
-        .R_WASM_FUNCTION_INDEX_LEB => return symbol.index,
-        .R_WASM_TABLE_NUMBER_LEB => return symbol.index,
-        .R_WASM_TABLE_INDEX_I32,
-        .R_WASM_TABLE_INDEX_I64,
-        .R_WASM_TABLE_INDEX_SLEB,
-        .R_WASM_TABLE_INDEX_SLEB64,
-        => return wasm_bin.function_table.get(.{ .file = atom.file, .index = @enumFromInt(relocation.index) }) orelse 0,
-        .R_WASM_TYPE_INDEX_LEB => {
-            const obj_file = wasm_bin.file(atom.file) orelse return relocation.index;
-            const original_type = obj_file.funcTypes()[relocation.index];
-            return wasm_bin.getTypeIndex(original_type).?;
-        },
-        .R_WASM_GLOBAL_INDEX_I32,
-        .R_WASM_GLOBAL_INDEX_LEB,
-        => return symbol.index,
-        .R_WASM_MEMORY_ADDR_I32,
-        .R_WASM_MEMORY_ADDR_I64,
-        .R_WASM_MEMORY_ADDR_LEB,
-        .R_WASM_MEMORY_ADDR_LEB64,
-        .R_WASM_MEMORY_ADDR_SLEB,
-        .R_WASM_MEMORY_ADDR_SLEB64,
-        => {
-            std.debug.assert(symbol.tag == .data);
-            if (symbol.isUndefined()) {
-                return 0;
-            }
-            const va: i33 = @intCast(symbol.virtual_address);
-            return @intCast(va + relocation.addend);
-        },
-        .R_WASM_EVENT_INDEX_LEB => return symbol.index,
-        .R_WASM_SECTION_OFFSET_I32 => {
-            const target_atom_index = wasm_bin.symbol_atom.get(target_loc).?;
-            const target_atom = wasm_bin.getAtom(target_atom_index);
-            const rel_value: i33 = @intCast(target_atom.offset);
-            return @intCast(rel_value + relocation.addend);
-        },
-        .R_WASM_FUNCTION_OFFSET_I32 => {
-            if (symbol.isUndefined()) {
-                const val = atom.thombstone(wasm_bin) orelse relocation.addend;
-                return @bitCast(val);
-            }
-            const target_atom_index = wasm_bin.symbol_atom.get(target_loc).?;
-            const target_atom = wasm_bin.getAtom(target_atom_index);
-            const rel_value: i33 = @intCast(target_atom.offset);
-            return @intCast(rel_value + relocation.addend);
-        },
-        .R_WASM_MEMORY_ADDR_TLS_SLEB,
-        .R_WASM_MEMORY_ADDR_TLS_SLEB64,
-        => {
-            const va: i33 = @intCast(symbol.virtual_address);
-            return @intCast(va + relocation.addend);
-        },
-    }
-}
-
-// For a given `Atom` returns whether it has a thombstone value or not.
-/// This defines whether we want a specific value when a section is dead.
-fn thombstone(atom: Atom, wasm: *const Wasm) ?i64 {
-    const atom_name = atom.symbolLoc().getName(wasm);
-    if (std.mem.eql(u8, atom_name, ".debug_ranges") or std.mem.eql(u8, atom_name, ".debug_loc")) {
-        return -2;
-    } else if (std.mem.startsWith(u8, atom_name, ".debug_")) {
-        return -1;
-    }
-    return null;
-}
-
-const leb = std.leb;
-const log = std.log.scoped(.link);
-const mem = std.mem;
-const std = @import("std");
-const types = @import("types.zig");
-
-const Allocator = mem.Allocator;
-const Atom = @This();
-const FileIndex = @import("file.zig").File.Index;
-const Symbol = @import("Symbol.zig");
-const Wasm = @import("../Wasm.zig");
diff --git a/zig/src/link/Wasm/Object.zig b/zig/src/link/Wasm/Object.zig
index 81a3cac737..fc11f91876 100644
--- a/zig/src/link/Wasm/Object.zig
+++ b/zig/src/link/Wasm/Object.zig
@@ -3,32 +3,32 @@
 //! the data on correctness. The result can then be used by the linker.
 const Object = @This();
 
-const Atom = @import("Atom.zig");
-const types = @import("types.zig");
-const std = @import("std");
 const Wasm = @import("../Wasm.zig");
+const Atom = Wasm.Atom;
+const Alignment = Wasm.Alignment;
 const Symbol = @import("Symbol.zig");
-const Alignment = types.Alignment;
-const File = @import("file.zig").File;
 
+const std = @import("std");
 const Allocator = std.mem.Allocator;
 const leb = std.leb;
 const meta = std.meta;
+const Path = std.Build.Cache.Path;
 
 const log = std.log.scoped(.object);
 
-/// Index into the list of relocatable object files within the linker driver.
-index: File.Index = .null,
 /// Wasm spec version used for this `Object`
 version: u32 = 0,
-/// The file descriptor that represents the wasm object file.
-file: ?std.fs.File = null,
-/// Name (read path) of the object file.
-path: []const u8,
+/// For error reporting purposes only.
+/// Name (read path) of the object or archive file.
+path: Path,
+/// For error reporting purposes only.
+/// If this represents an object in an archive, it's the basename of the
+/// object, and path refers to the archive.
+archive_member_name: ?[]const u8,
 /// Parsed type section
 func_types: []const std.wasm.Type = &.{},
 /// A list of all imports for this module
-imports: []const types.Import = &.{},
+imports: []const Wasm.Import = &.{},
 /// Parsed function section
 functions: []const std.wasm.Func = &.{},
 /// Parsed table section
@@ -38,7 +38,7 @@ memories: []const std.wasm.Memory = &.{},
 /// Parsed global section
 globals: []const std.wasm.Global = &.{},
 /// Parsed export section
-exports: []const types.Export = &.{},
+exports: []const Wasm.Export = &.{},
 /// Parsed element section
 elements: []const std.wasm.Element = &.{},
 /// Represents the function ID that must be called on startup.
@@ -48,25 +48,21 @@ start: ?u32 = null,
 /// A slice of features that tell the linker what features are mandatory,
 /// used (or therefore missing) and must generate an error when another
 /// object uses features that are not supported by the other.
-features: []const types.Feature = &.{},
+features: []const Wasm.Feature = &.{},
 /// A table that maps the relocations we must perform where the key represents
 /// the section that the list of relocations applies to.
-relocations: std.AutoArrayHashMapUnmanaged(u32, []types.Relocation) = .empty,
+relocations: std.AutoArrayHashMapUnmanaged(u32, []Wasm.Relocation) = .empty,
 /// Table of symbols belonging to this Object file
 symtable: []Symbol = &.{},
 /// Extra metadata about the linking section, such as alignment of segments and their name
-segment_info: []const types.Segment = &.{},
+segment_info: []const Wasm.NamedSegment = &.{},
 /// A sequence of function initializers that must be called on startup
-init_funcs: []const types.InitFunc = &.{},
+init_funcs: []const Wasm.InitFunc = &.{},
 /// Comdat information
-comdat_info: []const types.Comdat = &.{},
+comdat_info: []const Wasm.Comdat = &.{},
 /// Represents non-synthetic sections that can essentially be mem-cpy'd into place
 /// after performing relocations.
 relocatable_data: std.AutoHashMapUnmanaged(RelocatableData.Tag, []RelocatableData) = .empty,
-/// String table for all strings required by the object file, such as symbol names,
-/// import name, module name and export names. Each string will be deduplicated
-/// and returns an offset into the table.
-string_table: Wasm.StringTable = .{},
 /// Amount of functions in the `import` sections.
 imported_functions_count: u32 = 0,
 /// Amount of globals in the `import` section.
@@ -75,7 +71,7 @@ imported_globals_count: u32 = 0,
 imported_tables_count: u32 = 0,
 
 /// Represents a single item within a section (depending on its `type`)
-const RelocatableData = struct {
+pub const RelocatableData = struct {
     /// The type of the relocatable data
     type: Tag,
     /// Pointer to the data of the segment, where its length is written to `size`
@@ -121,40 +117,28 @@ const RelocatableData = struct {
     }
 };
 
-pub const InitError = error{NotObjectFile} || ParseError || std.fs.File.ReadError;
-
 /// Initializes a new `Object` from a wasm object file.
 /// This also parses and verifies the object file.
 /// When a max size is given, will only parse up to the given size,
 /// else will read until the end of the file.
-pub fn create(wasm_file: *const Wasm, file: std.fs.File, name: []const u8, maybe_max_size: ?usize) InitError!Object {
-    const gpa = wasm_file.base.comp.gpa;
+pub fn create(
+    wasm: *Wasm,
+    file_contents: []const u8,
+    path: Path,
+    archive_member_name: ?[]const u8,
+) !Object {
+    const gpa = wasm.base.comp.gpa;
     var object: Object = .{
-        .file = file,
-        .path = try gpa.dupe(u8, name),
+        .path = path,
+        .archive_member_name = archive_member_name,
     };
 
-    var is_object_file: bool = false;
-    const size = maybe_max_size orelse size: {
-        errdefer gpa.free(object.path);
-        const stat = try file.stat();
-        break :size @as(usize, @intCast(stat.size));
+    var parser: Parser = .{
+        .object = &object,
+        .wasm = wasm,
+        .reader = std.io.fixedBufferStream(file_contents),
     };
-
-    const file_contents = try gpa.alloc(u8, size);
-    defer gpa.free(file_contents);
-    var file_reader = file.reader();
-    var read: usize = 0;
-    while (read < size) {
-        const n = try file_reader.read(file_contents[read..]);
-        std.debug.assert(n != 0);
-        read += n;
-    }
-    var fbs = std.io.fixedBufferStream(file_contents);
-
-    try object.parse(gpa, wasm_file, fbs.reader(), &is_object_file);
-    errdefer object.deinit(gpa);
-    if (!is_object_file) return error.NotObjectFile;
+    try parser.parseObject(gpa);
 
     return object;
 }
@@ -162,9 +146,6 @@ pub fn create(wasm_file: *const Wasm, file: std.fs.File, name: []const u8, maybe
 /// Frees all memory of `Object` at once. The given `Allocator` must be
 /// the same allocator that was used when `init` was called.
 pub fn deinit(object: *Object, gpa: Allocator) void {
-    if (object.file) |file| {
-        file.close();
-    }
     for (object.func_types) |func_ty| {
         gpa.free(func_ty.params);
         gpa.free(func_ty.returns);
@@ -202,14 +183,12 @@ pub fn deinit(object: *Object, gpa: Allocator) void {
         }
     }
     object.relocatable_data.deinit(gpa);
-    object.string_table.deinit(gpa);
-    gpa.free(object.path);
     object.* = undefined;
 }
 
 /// Finds the import within the list of imports from a given kind and index of that kind.
 /// Asserts the import exists
-pub fn findImport(object: *const Object, sym: Symbol) types.Import {
+pub fn findImport(object: *const Object, sym: Symbol) Wasm.Import {
     var i: u32 = 0;
     return for (object.imports) |import| {
         if (std.meta.activeTag(import.kind) == sym.tag.externalType()) {
@@ -225,7 +204,9 @@ pub fn findImport(object: *const Object, sym: Symbol) types.Import {
 /// we initialize a new table symbol that corresponds to that import and return that symbol.
 ///
 /// When the object file is *NOT* MVP, we return `null`.
-fn checkLegacyIndirectFunctionTable(object: *Object, wasm_file: *const Wasm) !?Symbol {
+fn checkLegacyIndirectFunctionTable(object: *Object, wasm: *const Wasm) !?Symbol {
+    const diags = &wasm.base.comp.link_diags;
+
     var table_count: usize = 0;
     for (object.symtable) |sym| {
         if (sym.tag == .table) table_count += 1;
@@ -235,41 +216,31 @@ fn checkLegacyIndirectFunctionTable(object: *Object, wasm_file: *const Wasm) !?S
     if (object.imported_tables_count == table_count) return null;
 
     if (table_count != 0) {
-        var err = try wasm_file.base.addErrorWithNotes(1);
-        try err.addMsg("Expected a table entry symbol for each of the {d} table(s), but instead got {d} symbols.", .{
+        return diags.failParse(object.path, "expected a table entry symbol for each of the {d} table(s), but instead got {d} symbols.", .{
             object.imported_tables_count,
             table_count,
         });
-        try err.addNote("defined in '{s}'", .{object.path});
-        return error.MissingTableSymbols;
     }
 
     // MVP object files cannot have any table definitions, only imports (for the indirect function table).
     if (object.tables.len > 0) {
-        var err = try wasm_file.base.addErrorWithNotes(1);
-        try err.addMsg("Unexpected table definition without representing table symbols.", .{});
-        try err.addNote("defined in '{s}'", .{object.path});
-        return error.UnexpectedTable;
+        return diags.failParse(object.path, "unexpected table definition without representing table symbols.", .{});
     }
 
     if (object.imported_tables_count != 1) {
-        var err = try wasm_file.base.addErrorWithNotes(1);
-        try err.addMsg("Found more than one table import, but no representing table symbols", .{});
-        try err.addNote("defined in '{s}'", .{object.path});
-        return error.MissingTableSymbols;
+        return diags.failParse(object.path, "found more than one table import, but no representing table symbols", .{});
     }
 
-    const table_import: types.Import = for (object.imports) |imp| {
+    const table_import: Wasm.Import = for (object.imports) |imp| {
         if (imp.kind == .table) {
             break imp;
         }
     } else unreachable;
 
-    if (!std.mem.eql(u8, object.string_table.get(table_import.name), "__indirect_function_table")) {
-        var err = try wasm_file.base.addErrorWithNotes(1);
-        try err.addMsg("Non-indirect function table import '{s}' is missing a corresponding symbol", .{object.string_table.get(table_import.name)});
-        try err.addNote("defined in '{s}'", .{object.path});
-        return error.MissingTableSymbols;
+    if (table_import.name != wasm.preloaded_strings.__indirect_function_table) {
+        return diags.failParse(object.path, "non-indirect function table import '{s}' is missing a corresponding symbol", .{
+            wasm.stringSlice(table_import.name),
+        });
     }
 
     var table_symbol: Symbol = .{
@@ -284,575 +255,525 @@ fn checkLegacyIndirectFunctionTable(object: *Object, wasm_file: *const Wasm) !?S
     return table_symbol;
 }
 
-/// Error set containing parsing errors.
-/// Merged with reader's errorset by `Parser`
-pub const ParseError = error{
-    /// The magic byte is either missing or does not contain \0Asm
-    InvalidMagicByte,
-    /// The wasm version is either missing or does not match the supported version.
-    InvalidWasmVersion,
-    /// Expected the functype byte while parsing the Type section but did not find it.
-    ExpectedFuncType,
-    /// Missing an 'end' opcode when defining a constant expression.
-    MissingEndForExpression,
-    /// Missing an 'end' opcode at the end of a body expression.
-    MissingEndForBody,
-    /// The size defined in the section code mismatches with the actual payload size.
-    MalformedSection,
-    /// Stream has reached the end. Unreachable for caller and must be handled internally
-    /// by the parser.
-    EndOfStream,
-    /// Ran out of memory when allocating.
-    OutOfMemory,
-    /// A non-zero flag was provided for comdat info
-    UnexpectedValue,
-    /// An import symbol contains an index to an import that does
-    /// not exist, or no imports were defined.
-    InvalidIndex,
-    /// The section "linking" contains a version that is not supported.
-    UnsupportedVersion,
-    /// When reading the data in leb128 compressed format, its value was overflown.
-    Overflow,
-    /// Found table definitions but no corresponding table symbols
-    MissingTableSymbols,
-    /// Did not expect a table definition, but did find one
-    UnexpectedTable,
-    /// Object file contains a feature that is unknown to the linker
-    UnknownFeature,
-};
-
-fn parse(object: *Object, gpa: Allocator, wasm_file: *const Wasm, reader: anytype, is_object_file: *bool) Parser(@TypeOf(reader)).Error!void {
-    var parser = Parser(@TypeOf(reader)).init(object, wasm_file, reader);
-    return parser.parseObject(gpa, is_object_file);
-}
-
-fn Parser(comptime ReaderType: type) type {
-    return struct {
-        const ObjectParser = @This();
-        const Error = ReaderType.Error || ParseError;
+const Parser = struct {
+    reader: std.io.FixedBufferStream([]const u8),
+    /// Object file we're building
+    object: *Object,
+    /// Mutable so that the string table can be modified.
+    wasm: *Wasm,
 
-        reader: std.io.CountingReader(ReaderType),
-        /// Object file we're building
-        object: *Object,
-        /// Read-only reference to the WebAssembly linker
-        wasm_file: *const Wasm,
+    fn parseObject(parser: *Parser, gpa: Allocator) anyerror!void {
+        const wasm = parser.wasm;
 
-        fn init(object: *Object, wasm_file: *const Wasm, reader: ReaderType) ObjectParser {
-            return .{ .object = object, .wasm_file = wasm_file, .reader = std.io.countingReader(reader) };
-        }
-
-        /// Verifies that the first 4 bytes contains \0Asm
-        fn verifyMagicBytes(parser: *ObjectParser) Error!void {
+        {
             var magic_bytes: [4]u8 = undefined;
-
             try parser.reader.reader().readNoEof(&magic_bytes);
-            if (!std.mem.eql(u8, &magic_bytes, &std.wasm.magic)) {
-                log.debug("Invalid magic bytes '{s}'", .{&magic_bytes});
-                return error.InvalidMagicByte;
-            }
+            if (!std.mem.eql(u8, &magic_bytes, &std.wasm.magic)) return error.BadObjectMagic;
         }
 
-        fn parseObject(parser: *ObjectParser, gpa: Allocator, is_object_file: *bool) Error!void {
-            errdefer parser.object.deinit(gpa);
-            try parser.verifyMagicBytes();
-            const version = try parser.reader.reader().readInt(u32, .little);
-            parser.object.version = version;
-
-            var section_index: u32 = 0;
-            while (parser.reader.reader().readByte()) |byte| : (section_index += 1) {
-                const len = try readLeb(u32, parser.reader.reader());
-                var limited_reader = std.io.limitedReader(parser.reader.reader(), len);
-                const reader = limited_reader.reader();
-                switch (@as(std.wasm.Section, @enumFromInt(byte))) {
-                    .custom => {
-                        const name_len = try readLeb(u32, reader);
-                        const name = try gpa.alloc(u8, name_len);
-                        defer gpa.free(name);
-                        try reader.readNoEof(name);
+        const version = try parser.reader.reader().readInt(u32, .little);
+        parser.object.version = version;
 
-                        if (std.mem.eql(u8, name, "linking")) {
-                            is_object_file.* = true;
-                            try parser.parseMetadata(gpa, @as(usize, @intCast(reader.context.bytes_left)));
-                        } else if (std.mem.startsWith(u8, name, "reloc")) {
-                            try parser.parseRelocations(gpa);
-                        } else if (std.mem.eql(u8, name, "target_features")) {
-                            try parser.parseFeatures(gpa);
-                        } else if (std.mem.startsWith(u8, name, ".debug")) {
-                            const gop = try parser.object.relocatable_data.getOrPut(gpa, .custom);
-                            var relocatable_data: std.ArrayListUnmanaged(RelocatableData) = .empty;
-                            defer relocatable_data.deinit(gpa);
-                            if (!gop.found_existing) {
-                                gop.value_ptr.* = &.{};
-                            } else {
-                                relocatable_data = std.ArrayListUnmanaged(RelocatableData).fromOwnedSlice(gop.value_ptr.*);
-                            }
-                            const debug_size = @as(u32, @intCast(reader.context.bytes_left));
-                            const debug_content = try gpa.alloc(u8, debug_size);
-                            errdefer gpa.free(debug_content);
-                            try reader.readNoEof(debug_content);
-
-                            try relocatable_data.append(gpa, .{
-                                .type = .custom,
-                                .data = debug_content.ptr,
-                                .size = debug_size,
-                                .index = try parser.object.string_table.put(gpa, name),
-                                .offset = 0, // debug sections only contain 1 entry, so no need to calculate offset
-                                .section_index = section_index,
-                            });
-                            gop.value_ptr.* = try relocatable_data.toOwnedSlice(gpa);
-                        } else {
-                            try reader.skipBytes(reader.context.bytes_left, .{});
-                        }
-                    },
-                    .type => {
-                        for (try readVec(&parser.object.func_types, reader, gpa)) |*type_val| {
-                            if ((try reader.readByte()) != std.wasm.function_type) return error.ExpectedFuncType;
-
-                            for (try readVec(&type_val.params, reader, gpa)) |*param| {
-                                param.* = try readEnum(std.wasm.Valtype, reader);
-                            }
-
-                            for (try readVec(&type_val.returns, reader, gpa)) |*result| {
-                                result.* = try readEnum(std.wasm.Valtype, reader);
-                            }
-                        }
-                        try assertEnd(reader);
-                    },
-                    .import => {
-                        for (try readVec(&parser.object.imports, reader, gpa)) |*import| {
-                            const module_len = try readLeb(u32, reader);
-                            const module_name = try gpa.alloc(u8, module_len);
-                            defer gpa.free(module_name);
-                            try reader.readNoEof(module_name);
-
-                            const name_len = try readLeb(u32, reader);
-                            const name = try gpa.alloc(u8, name_len);
-                            defer gpa.free(name);
-                            try reader.readNoEof(name);
-
-                            const kind = try readEnum(std.wasm.ExternalKind, reader);
-                            const kind_value: std.wasm.Import.Kind = switch (kind) {
-                                .function => val: {
-                                    parser.object.imported_functions_count += 1;
-                                    break :val .{ .function = try readLeb(u32, reader) };
-                                },
-                                .memory => .{ .memory = try readLimits(reader) },
-                                .global => val: {
-                                    parser.object.imported_globals_count += 1;
-                                    break :val .{ .global = .{
-                                        .valtype = try readEnum(std.wasm.Valtype, reader),
-                                        .mutable = (try reader.readByte()) == 0x01,
-                                    } };
-                                },
-                                .table => val: {
-                                    parser.object.imported_tables_count += 1;
-                                    break :val .{ .table = .{
-                                        .reftype = try readEnum(std.wasm.RefType, reader),
-                                        .limits = try readLimits(reader),
-                                    } };
-                                },
-                            };
-
-                            import.* = .{
-                                .module_name = try parser.object.string_table.put(gpa, module_name),
-                                .name = try parser.object.string_table.put(gpa, name),
-                                .kind = kind_value,
-                            };
-                        }
-                        try assertEnd(reader);
-                    },
-                    .function => {
-                        for (try readVec(&parser.object.functions, reader, gpa)) |*func| {
-                            func.* = .{ .type_index = try readLeb(u32, reader) };
-                        }
-                        try assertEnd(reader);
-                    },
-                    .table => {
-                        for (try readVec(&parser.object.tables, reader, gpa)) |*table| {
-                            table.* = .{
-                                .reftype = try readEnum(std.wasm.RefType, reader),
-                                .limits = try readLimits(reader),
-                            };
-                        }
-                        try assertEnd(reader);
-                    },
-                    .memory => {
-                        for (try readVec(&parser.object.memories, reader, gpa)) |*memory| {
-                            memory.* = .{ .limits = try readLimits(reader) };
-                        }
-                        try assertEnd(reader);
-                    },
-                    .global => {
-                        for (try readVec(&parser.object.globals, reader, gpa)) |*global| {
-                            global.* = .{
-                                .global_type = .{
-                                    .valtype = try readEnum(std.wasm.Valtype, reader),
-                                    .mutable = (try reader.readByte()) == 0x01,
-                                },
-                                .init = try readInit(reader),
-                            };
-                        }
-                        try assertEnd(reader);
-                    },
-                    .@"export" => {
-                        for (try readVec(&parser.object.exports, reader, gpa)) |*exp| {
-                            const name_len = try readLeb(u32, reader);
-                            const name = try gpa.alloc(u8, name_len);
-                            defer gpa.free(name);
-                            try reader.readNoEof(name);
-                            exp.* = .{
-                                .name = try parser.object.string_table.put(gpa, name),
-                                .kind = try readEnum(std.wasm.ExternalKind, reader),
-                                .index = try readLeb(u32, reader),
-                            };
-                        }
-                        try assertEnd(reader);
-                    },
-                    .start => {
-                        parser.object.start = try readLeb(u32, reader);
-                        try assertEnd(reader);
-                    },
-                    .element => {
-                        for (try readVec(&parser.object.elements, reader, gpa)) |*elem| {
-                            elem.table_index = try readLeb(u32, reader);
-                            elem.offset = try readInit(reader);
-
-                            for (try readVec(&elem.func_indexes, reader, gpa)) |*idx| {
-                                idx.* = try readLeb(u32, reader);
-                            }
-                        }
-                        try assertEnd(reader);
-                    },
-                    .code => {
-                        const start = reader.context.bytes_left;
-                        var index: u32 = 0;
-                        const count = try readLeb(u32, reader);
-                        const imported_function_count = parser.object.imported_functions_count;
-                        var relocatable_data = try std.ArrayList(RelocatableData).initCapacity(gpa, count);
-                        defer relocatable_data.deinit();
-                        while (index < count) : (index += 1) {
-                            const code_len = try readLeb(u32, reader);
-                            const offset = @as(u32, @intCast(start - reader.context.bytes_left));
-                            const data = try gpa.alloc(u8, code_len);
-                            errdefer gpa.free(data);
-                            try reader.readNoEof(data);
-                            relocatable_data.appendAssumeCapacity(.{
-                                .type = .code,
-                                .data = data.ptr,
-                                .size = code_len,
-                                .index = imported_function_count + index,
-                                .offset = offset,
-                                .section_index = section_index,
-                            });
-                        }
-                        try parser.object.relocatable_data.put(gpa, .code, try relocatable_data.toOwnedSlice());
-                    },
-                    .data => {
-                        const start = reader.context.bytes_left;
-                        var index: u32 = 0;
-                        const count = try readLeb(u32, reader);
-                        var relocatable_data = try std.ArrayList(RelocatableData).initCapacity(gpa, count);
-                        defer relocatable_data.deinit();
-                        while (index < count) : (index += 1) {
-                            const flags = try readLeb(u32, reader);
-                            const data_offset = try readInit(reader);
-                            _ = flags; // TODO: Do we need to check flags to detect passive/active memory?
-                            _ = data_offset;
-                            const data_len = try readLeb(u32, reader);
-                            const offset = @as(u32, @intCast(start - reader.context.bytes_left));
-                            const data = try gpa.alloc(u8, data_len);
-                            errdefer gpa.free(data);
-                            try reader.readNoEof(data);
-                            relocatable_data.appendAssumeCapacity(.{
-                                .type = .data,
-                                .data = data.ptr,
-                                .size = data_len,
-                                .index = index,
-                                .offset = offset,
-                                .section_index = section_index,
-                            });
-                        }
-                        try parser.object.relocatable_data.put(gpa, .data, try relocatable_data.toOwnedSlice());
-                    },
-                    else => try parser.reader.reader().skipBytes(len, .{}),
-                }
-            } else |err| switch (err) {
-                error.EndOfStream => {}, // finished parsing the file
-                else => |e| return e,
-            }
-        }
-
-        /// Based on the "features" custom section, parses it into a list of
-        /// features that tell the linker what features were enabled and may be mandatory
-        /// to be able to link.
-        /// Logs an info message when an undefined feature is detected.
-        fn parseFeatures(parser: *ObjectParser, gpa: Allocator) !void {
-            const reader = parser.reader.reader();
-            for (try readVec(&parser.object.features, reader, gpa)) |*feature| {
-                const prefix = try readEnum(types.Feature.Prefix, reader);
-                const name_len = try leb.readUleb128(u32, reader);
-                const name = try gpa.alloc(u8, name_len);
-                defer gpa.free(name);
-                try reader.readNoEof(name);
-
-                const tag = types.known_features.get(name) orelse {
-                    var err = try parser.wasm_file.base.addErrorWithNotes(1);
-                    try err.addMsg("Object file contains unknown feature: {s}", .{name});
-                    try err.addNote("defined in '{s}'", .{parser.object.path});
-                    return error.UnknownFeature;
-                };
-                feature.* = .{
-                    .prefix = prefix,
-                    .tag = tag,
-                };
-            }
-        }
+        var saw_linking_section = false;
 
-        /// Parses a "reloc" custom section into a list of relocations.
-        /// The relocations are mapped into `Object` where the key is the section
-        /// they apply to.
-        fn parseRelocations(parser: *ObjectParser, gpa: Allocator) !void {
-            const reader = parser.reader.reader();
-            const section = try leb.readUleb128(u32, reader);
-            const count = try leb.readUleb128(u32, reader);
-            const relocations = try gpa.alloc(types.Relocation, count);
-            errdefer gpa.free(relocations);
-
-            log.debug("Found {d} relocations for section ({d})", .{
-                count,
-                section,
-            });
-
-            for (relocations) |*relocation| {
-                const rel_type = try reader.readByte();
-                const rel_type_enum = std.meta.intToEnum(types.Relocation.RelocationType, rel_type) catch return error.MalformedSection;
-                relocation.* = .{
-                    .relocation_type = rel_type_enum,
-                    .offset = try leb.readUleb128(u32, reader),
-                    .index = try leb.readUleb128(u32, reader),
-                    .addend = if (rel_type_enum.addendIsPresent()) try leb.readIleb128(i32, reader) else 0,
-                };
-                log.debug("Found relocation: type({s}) offset({d}) index({d}) addend({?d})", .{
-                    @tagName(relocation.relocation_type),
-                    relocation.offset,
-                    relocation.index,
-                    relocation.addend,
-                });
-            }
-
-            try parser.object.relocations.putNoClobber(gpa, section, relocations);
-        }
+        var section_index: u32 = 0;
+        while (parser.reader.reader().readByte()) |byte| : (section_index += 1) {
+            const len = try readLeb(u32, parser.reader.reader());
+            var limited_reader = std.io.limitedReader(parser.reader.reader(), len);
+            const reader = limited_reader.reader();
+            switch (@as(std.wasm.Section, @enumFromInt(byte))) {
+                .custom => {
+                    const name_len = try readLeb(u32, reader);
+                    const name = try gpa.alloc(u8, name_len);
+                    defer gpa.free(name);
+                    try reader.readNoEof(name);
 
-        /// Parses the "linking" custom section. Versions that are not
-        /// supported will be an error. `payload_size` is required to be able
-        /// to calculate the subsections we need to parse, as that data is not
-        /// available within the section itparser.
-        fn parseMetadata(parser: *ObjectParser, gpa: Allocator, payload_size: usize) !void {
-            var limited = std.io.limitedReader(parser.reader.reader(), payload_size);
-            const limited_reader = limited.reader();
+                    if (std.mem.eql(u8, name, "linking")) {
+                        saw_linking_section = true;
+                        try parser.parseMetadata(gpa, @as(usize, @intCast(reader.context.bytes_left)));
+                    } else if (std.mem.startsWith(u8, name, "reloc")) {
+                        try parser.parseRelocations(gpa);
+                    } else if (std.mem.eql(u8, name, "target_features")) {
+                        try parser.parseFeatures(gpa);
+                    } else if (std.mem.startsWith(u8, name, ".debug")) {
+                        const gop = try parser.object.relocatable_data.getOrPut(gpa, .custom);
+                        var relocatable_data: std.ArrayListUnmanaged(RelocatableData) = .empty;
+                        defer relocatable_data.deinit(gpa);
+                        if (!gop.found_existing) {
+                            gop.value_ptr.* = &.{};
+                        } else {
+                            relocatable_data = std.ArrayListUnmanaged(RelocatableData).fromOwnedSlice(gop.value_ptr.*);
+                        }
+                        const debug_size = @as(u32, @intCast(reader.context.bytes_left));
+                        const debug_content = try gpa.alloc(u8, debug_size);
+                        errdefer gpa.free(debug_content);
+                        try reader.readNoEof(debug_content);
+
+                        try relocatable_data.append(gpa, .{
+                            .type = .custom,
+                            .data = debug_content.ptr,
+                            .size = debug_size,
+                            .index = @intFromEnum(try wasm.internString(name)),
+                            .offset = 0, // debug sections only contain 1 entry, so no need to calculate offset
+                            .section_index = section_index,
+                        });
+                        gop.value_ptr.* = try relocatable_data.toOwnedSlice(gpa);
+                    } else {
+                        try reader.skipBytes(reader.context.bytes_left, .{});
+                    }
+                },
+                .type => {
+                    for (try readVec(&parser.object.func_types, reader, gpa)) |*type_val| {
+                        if ((try reader.readByte()) != std.wasm.function_type) return error.ExpectedFuncType;
 
-            const version = try leb.readUleb128(u32, limited_reader);
-            log.debug("Link meta data version: {d}", .{version});
-            if (version != 2) return error.UnsupportedVersion;
+                        for (try readVec(&type_val.params, reader, gpa)) |*param| {
+                            param.* = try readEnum(std.wasm.Valtype, reader);
+                        }
 
-            while (limited.bytes_left > 0) {
-                try parser.parseSubsection(gpa, limited_reader);
-            }
-        }
+                        for (try readVec(&type_val.returns, reader, gpa)) |*result| {
+                            result.* = try readEnum(std.wasm.Valtype, reader);
+                        }
+                    }
+                    try assertEnd(reader);
+                },
+                .import => {
+                    for (try readVec(&parser.object.imports, reader, gpa)) |*import| {
+                        const module_len = try readLeb(u32, reader);
+                        const module_name = try gpa.alloc(u8, module_len);
+                        defer gpa.free(module_name);
+                        try reader.readNoEof(module_name);
 
-        /// Parses a `spec.Subsection`.
-        /// The `reader` param for this is to provide a `LimitedReader`, which allows
-        /// us to only read until a max length.
-        ///
-        /// `parser` is used to provide access to other sections that may be needed,
-        /// such as access to the `import` section to find the name of a symbol.
-        fn parseSubsection(parser: *ObjectParser, gpa: Allocator, reader: anytype) !void {
-            const sub_type = try leb.readUleb128(u8, reader);
-            log.debug("Found subsection: {s}", .{@tagName(@as(types.SubsectionType, @enumFromInt(sub_type)))});
-            const payload_len = try leb.readUleb128(u32, reader);
-            if (payload_len == 0) return;
-
-            var limited = std.io.limitedReader(reader, payload_len);
-            const limited_reader = limited.reader();
-
-            // every subsection contains a 'count' field
-            const count = try leb.readUleb128(u32, limited_reader);
-
-            switch (@as(types.SubsectionType, @enumFromInt(sub_type))) {
-                .WASM_SEGMENT_INFO => {
-                    const segments = try gpa.alloc(types.Segment, count);
-                    errdefer gpa.free(segments);
-                    for (segments) |*segment| {
-                        const name_len = try leb.readUleb128(u32, reader);
+                        const name_len = try readLeb(u32, reader);
                         const name = try gpa.alloc(u8, name_len);
-                        errdefer gpa.free(name);
+                        defer gpa.free(name);
                         try reader.readNoEof(name);
-                        segment.* = .{
-                            .name = name,
-                            .alignment = @enumFromInt(try leb.readUleb128(u32, reader)),
-                            .flags = try leb.readUleb128(u32, reader),
+
+                        const kind = try readEnum(std.wasm.ExternalKind, reader);
+                        const kind_value: std.wasm.Import.Kind = switch (kind) {
+                            .function => val: {
+                                parser.object.imported_functions_count += 1;
+                                break :val .{ .function = try readLeb(u32, reader) };
+                            },
+                            .memory => .{ .memory = try readLimits(reader) },
+                            .global => val: {
+                                parser.object.imported_globals_count += 1;
+                                break :val .{ .global = .{
+                                    .valtype = try readEnum(std.wasm.Valtype, reader),
+                                    .mutable = (try reader.readByte()) == 0x01,
+                                } };
+                            },
+                            .table => val: {
+                                parser.object.imported_tables_count += 1;
+                                break :val .{ .table = .{
+                                    .reftype = try readEnum(std.wasm.RefType, reader),
+                                    .limits = try readLimits(reader),
+                                } };
+                            },
                         };
-                        log.debug("Found segment: {s} align({d}) flags({b})", .{
-                            segment.name,
-                            segment.alignment,
-                            segment.flags,
-                        });
 
-                        // support legacy object files that specified being TLS by the name instead of the TLS flag.
-                        if (!segment.isTLS() and (std.mem.startsWith(u8, segment.name, ".tdata") or std.mem.startsWith(u8, segment.name, ".tbss"))) {
-                            // set the flag so we can simply check for the flag in the rest of the linker.
-                            segment.flags |= @intFromEnum(types.Segment.Flags.WASM_SEG_FLAG_TLS);
-                        }
+                        import.* = .{
+                            .module_name = try wasm.internString(module_name),
+                            .name = try wasm.internString(name),
+                            .kind = kind_value,
+                        };
+                    }
+                    try assertEnd(reader);
+                },
+                .function => {
+                    for (try readVec(&parser.object.functions, reader, gpa)) |*func| {
+                        func.* = .{ .type_index = try readLeb(u32, reader) };
+                    }
+                    try assertEnd(reader);
+                },
+                .table => {
+                    for (try readVec(&parser.object.tables, reader, gpa)) |*table| {
+                        table.* = .{
+                            .reftype = try readEnum(std.wasm.RefType, reader),
+                            .limits = try readLimits(reader),
+                        };
+                    }
+                    try assertEnd(reader);
+                },
+                .memory => {
+                    for (try readVec(&parser.object.memories, reader, gpa)) |*memory| {
+                        memory.* = .{ .limits = try readLimits(reader) };
                     }
-                    parser.object.segment_info = segments;
+                    try assertEnd(reader);
                 },
-                .WASM_INIT_FUNCS => {
-                    const funcs = try gpa.alloc(types.InitFunc, count);
-                    errdefer gpa.free(funcs);
-                    for (funcs) |*func| {
-                        func.* = .{
-                            .priority = try leb.readUleb128(u32, reader),
-                            .symbol_index = try leb.readUleb128(u32, reader),
+                .global => {
+                    for (try readVec(&parser.object.globals, reader, gpa)) |*global| {
+                        global.* = .{
+                            .global_type = .{
+                                .valtype = try readEnum(std.wasm.Valtype, reader),
+                                .mutable = (try reader.readByte()) == 0x01,
+                            },
+                            .init = try readInit(reader),
                         };
-                        log.debug("Found function - prio: {d}, index: {d}", .{ func.priority, func.symbol_index });
                     }
-                    parser.object.init_funcs = funcs;
+                    try assertEnd(reader);
                 },
-                .WASM_COMDAT_INFO => {
-                    const comdats = try gpa.alloc(types.Comdat, count);
-                    errdefer gpa.free(comdats);
-                    for (comdats) |*comdat| {
-                        const name_len = try leb.readUleb128(u32, reader);
+                .@"export" => {
+                    for (try readVec(&parser.object.exports, reader, gpa)) |*exp| {
+                        const name_len = try readLeb(u32, reader);
                         const name = try gpa.alloc(u8, name_len);
-                        errdefer gpa.free(name);
+                        defer gpa.free(name);
                         try reader.readNoEof(name);
-
-                        const flags = try leb.readUleb128(u32, reader);
-                        if (flags != 0) {
-                            return error.UnexpectedValue;
-                        }
-
-                        const symbol_count = try leb.readUleb128(u32, reader);
-                        const symbols = try gpa.alloc(types.ComdatSym, symbol_count);
-                        errdefer gpa.free(symbols);
-                        for (symbols) |*symbol| {
-                            symbol.* = .{
-                                .kind = @as(types.ComdatSym.Type, @enumFromInt(try leb.readUleb128(u8, reader))),
-                                .index = try leb.readUleb128(u32, reader),
-                            };
-                        }
-
-                        comdat.* = .{
-                            .name = name,
-                            .flags = flags,
-                            .symbols = symbols,
+                        exp.* = .{
+                            .name = try wasm.internString(name),
+                            .kind = try readEnum(std.wasm.ExternalKind, reader),
+                            .index = try readLeb(u32, reader),
                         };
                     }
+                    try assertEnd(reader);
+                },
+                .start => {
+                    parser.object.start = try readLeb(u32, reader);
+                    try assertEnd(reader);
+                },
+                .element => {
+                    for (try readVec(&parser.object.elements, reader, gpa)) |*elem| {
+                        elem.table_index = try readLeb(u32, reader);
+                        elem.offset = try readInit(reader);
 
-                    parser.object.comdat_info = comdats;
+                        for (try readVec(&elem.func_indexes, reader, gpa)) |*idx| {
+                            idx.* = try readLeb(u32, reader);
+                        }
+                    }
+                    try assertEnd(reader);
                 },
-                .WASM_SYMBOL_TABLE => {
-                    var symbols = try std.ArrayList(Symbol).initCapacity(gpa, count);
-
-                    var i: usize = 0;
-                    while (i < count) : (i += 1) {
-                        const symbol = symbols.addOneAssumeCapacity();
-                        symbol.* = try parser.parseSymbol(gpa, reader);
-                        log.debug("Found symbol: type({s}) name({s}) flags(0b{b:0>8})", .{
-                            @tagName(symbol.tag),
-                            parser.object.string_table.get(symbol.name),
-                            symbol.flags,
+                .code => {
+                    const start = reader.context.bytes_left;
+                    var index: u32 = 0;
+                    const count = try readLeb(u32, reader);
+                    const imported_function_count = parser.object.imported_functions_count;
+                    var relocatable_data = try std.ArrayList(RelocatableData).initCapacity(gpa, count);
+                    defer relocatable_data.deinit();
+                    while (index < count) : (index += 1) {
+                        const code_len = try readLeb(u32, reader);
+                        const offset = @as(u32, @intCast(start - reader.context.bytes_left));
+                        const data = try gpa.alloc(u8, code_len);
+                        errdefer gpa.free(data);
+                        try reader.readNoEof(data);
+                        relocatable_data.appendAssumeCapacity(.{
+                            .type = .code,
+                            .data = data.ptr,
+                            .size = code_len,
+                            .index = imported_function_count + index,
+                            .offset = offset,
+                            .section_index = section_index,
                         });
                     }
-
-                    // we found all symbols, check for indirect function table
-                    // in case of an MVP object file
-                    if (try parser.object.checkLegacyIndirectFunctionTable(parser.wasm_file)) |symbol| {
-                        try symbols.append(symbol);
-                        log.debug("Found legacy indirect function table. Created symbol", .{});
-                    }
-
-                    // Not all debug sections may be represented by a symbol, for those sections
-                    // we manually create a symbol.
-                    if (parser.object.relocatable_data.get(.custom)) |custom_sections| {
-                        for (custom_sections) |*data| {
-                            if (!data.represented) {
-                                try symbols.append(.{
-                                    .name = data.index,
-                                    .flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),
-                                    .tag = .section,
-                                    .virtual_address = 0,
-                                    .index = data.section_index,
-                                });
-                                data.represented = true;
-                                log.debug("Created synthetic custom section symbol for '{s}'", .{parser.object.string_table.get(data.index)});
-                            }
-                        }
+                    try parser.object.relocatable_data.put(gpa, .code, try relocatable_data.toOwnedSlice());
+                },
+                .data => {
+                    const start = reader.context.bytes_left;
+                    var index: u32 = 0;
+                    const count = try readLeb(u32, reader);
+                    var relocatable_data = try std.ArrayList(RelocatableData).initCapacity(gpa, count);
+                    defer relocatable_data.deinit();
+                    while (index < count) : (index += 1) {
+                        const flags = try readLeb(u32, reader);
+                        const data_offset = try readInit(reader);
+                        _ = flags; // TODO: Do we need to check flags to detect passive/active memory?
+                        _ = data_offset;
+                        const data_len = try readLeb(u32, reader);
+                        const offset = @as(u32, @intCast(start - reader.context.bytes_left));
+                        const data = try gpa.alloc(u8, data_len);
+                        errdefer gpa.free(data);
+                        try reader.readNoEof(data);
+                        relocatable_data.appendAssumeCapacity(.{
+                            .type = .data,
+                            .data = data.ptr,
+                            .size = data_len,
+                            .index = index,
+                            .offset = offset,
+                            .section_index = section_index,
+                        });
                     }
-
-                    parser.object.symtable = try symbols.toOwnedSlice();
+                    try parser.object.relocatable_data.put(gpa, .data, try relocatable_data.toOwnedSlice());
                 },
+                else => try parser.reader.reader().skipBytes(len, .{}),
             }
+        } else |err| switch (err) {
+            error.EndOfStream => {}, // finished parsing the file
+            else => |e| return e,
         }
+        if (!saw_linking_section) return error.MissingLinkingSection;
+    }
 
-        /// Parses the symbol information based on its kind,
-        /// requires access to `Object` to find the name of a symbol when it's
-        /// an import and flag `WASM_SYM_EXPLICIT_NAME` is not set.
-        fn parseSymbol(parser: *ObjectParser, gpa: Allocator, reader: anytype) !Symbol {
-            const tag = @as(Symbol.Tag, @enumFromInt(try leb.readUleb128(u8, reader)));
-            const flags = try leb.readUleb128(u32, reader);
-            var symbol: Symbol = .{
-                .flags = flags,
+    /// Based on the "features" custom section, parses it into a list of
+    /// features that tell the linker what features were enabled and may be mandatory
+    /// to be able to link.
+    /// Logs an info message when an undefined feature is detected.
+    fn parseFeatures(parser: *Parser, gpa: Allocator) !void {
+        const diags = &parser.wasm.base.comp.link_diags;
+        const reader = parser.reader.reader();
+        for (try readVec(&parser.object.features, reader, gpa)) |*feature| {
+            const prefix = try readEnum(Wasm.Feature.Prefix, reader);
+            const name_len = try leb.readUleb128(u32, reader);
+            const name = try gpa.alloc(u8, name_len);
+            defer gpa.free(name);
+            try reader.readNoEof(name);
+
+            const tag = Wasm.known_features.get(name) orelse {
+                return diags.failParse(parser.object.path, "object file contains unknown feature: {s}", .{name});
+            };
+            feature.* = .{
+                .prefix = prefix,
                 .tag = tag,
-                .name = undefined,
-                .index = undefined,
-                .virtual_address = undefined,
             };
+        }
+    }
 
-            switch (tag) {
-                .data => {
+    /// Parses a "reloc" custom section into a list of relocations.
+    /// The relocations are mapped into `Object` where the key is the section
+    /// they apply to.
+    fn parseRelocations(parser: *Parser, gpa: Allocator) !void {
+        const reader = parser.reader.reader();
+        const section = try leb.readUleb128(u32, reader);
+        const count = try leb.readUleb128(u32, reader);
+        const relocations = try gpa.alloc(Wasm.Relocation, count);
+        errdefer gpa.free(relocations);
+
+        log.debug("Found {d} relocations for section ({d})", .{
+            count,
+            section,
+        });
+
+        for (relocations) |*relocation| {
+            const rel_type = try reader.readByte();
+            const rel_type_enum = std.meta.intToEnum(Wasm.Relocation.RelocationType, rel_type) catch return error.MalformedSection;
+            relocation.* = .{
+                .relocation_type = rel_type_enum,
+                .offset = try leb.readUleb128(u32, reader),
+                .index = try leb.readUleb128(u32, reader),
+                .addend = if (rel_type_enum.addendIsPresent()) try leb.readIleb128(i32, reader) else 0,
+            };
+            log.debug("Found relocation: type({s}) offset({d}) index({d}) addend({?d})", .{
+                @tagName(relocation.relocation_type),
+                relocation.offset,
+                relocation.index,
+                relocation.addend,
+            });
+        }
+
+        try parser.object.relocations.putNoClobber(gpa, section, relocations);
+    }
+
+    /// Parses the "linking" custom section. Versions that are not
+    /// supported will be an error. `payload_size` is required to be able
+    /// to calculate the subsections we need to parse, as that data is not
+    /// available within the section itparser.
+    fn parseMetadata(parser: *Parser, gpa: Allocator, payload_size: usize) !void {
+        var limited = std.io.limitedReader(parser.reader.reader(), payload_size);
+        const limited_reader = limited.reader();
+
+        const version = try leb.readUleb128(u32, limited_reader);
+        log.debug("Link meta data version: {d}", .{version});
+        if (version != 2) return error.UnsupportedVersion;
+
+        while (limited.bytes_left > 0) {
+            try parser.parseSubsection(gpa, limited_reader);
+        }
+    }
+
+    /// Parses a `spec.Subsection`.
+    /// The `reader` param for this is to provide a `LimitedReader`, which allows
+    /// us to only read until a max length.
+    ///
+    /// `parser` is used to provide access to other sections that may be needed,
+    /// such as access to the `import` section to find the name of a symbol.
+    fn parseSubsection(parser: *Parser, gpa: Allocator, reader: anytype) !void {
+        const wasm = parser.wasm;
+        const sub_type = try leb.readUleb128(u8, reader);
+        log.debug("Found subsection: {s}", .{@tagName(@as(Wasm.SubsectionType, @enumFromInt(sub_type)))});
+        const payload_len = try leb.readUleb128(u32, reader);
+        if (payload_len == 0) return;
+
+        var limited = std.io.limitedReader(reader, payload_len);
+        const limited_reader = limited.reader();
+
+        // every subsection contains a 'count' field
+        const count = try leb.readUleb128(u32, limited_reader);
+
+        switch (@as(Wasm.SubsectionType, @enumFromInt(sub_type))) {
+            .WASM_SEGMENT_INFO => {
+                const segments = try gpa.alloc(Wasm.NamedSegment, count);
+                errdefer gpa.free(segments);
+                for (segments) |*segment| {
                     const name_len = try leb.readUleb128(u32, reader);
                     const name = try gpa.alloc(u8, name_len);
-                    defer gpa.free(name);
+                    errdefer gpa.free(name);
                     try reader.readNoEof(name);
-                    symbol.name = try parser.object.string_table.put(gpa, name);
-
-                    // Data symbols only have the following fields if the symbol is defined
-                    if (symbol.isDefined()) {
-                        symbol.index = try leb.readUleb128(u32, reader);
-                        // @TODO: We should verify those values
-                        _ = try leb.readUleb128(u32, reader);
-                        _ = try leb.readUleb128(u32, reader);
+                    segment.* = .{
+                        .name = name,
+                        .alignment = @enumFromInt(try leb.readUleb128(u32, reader)),
+                        .flags = try leb.readUleb128(u32, reader),
+                    };
+                    log.debug("Found segment: {s} align({d}) flags({b})", .{
+                        segment.name,
+                        segment.alignment,
+                        segment.flags,
+                    });
+
+                    // support legacy object files that specified being TLS by the name instead of the TLS flag.
+                    if (!segment.isTLS() and (std.mem.startsWith(u8, segment.name, ".tdata") or std.mem.startsWith(u8, segment.name, ".tbss"))) {
+                        // set the flag so we can simply check for the flag in the rest of the linker.
+                        segment.flags |= @intFromEnum(Wasm.NamedSegment.Flags.WASM_SEG_FLAG_TLS);
                     }
-                },
-                .section => {
-                    symbol.index = try leb.readUleb128(u32, reader);
-                    const section_data = parser.object.relocatable_data.get(.custom).?;
-                    for (section_data) |*data| {
-                        if (data.section_index == symbol.index) {
-                            symbol.name = data.index;
+                }
+                parser.object.segment_info = segments;
+            },
+            .WASM_INIT_FUNCS => {
+                const funcs = try gpa.alloc(Wasm.InitFunc, count);
+                errdefer gpa.free(funcs);
+                for (funcs) |*func| {
+                    func.* = .{
+                        .priority = try leb.readUleb128(u32, reader),
+                        .symbol_index = try leb.readUleb128(u32, reader),
+                    };
+                    log.debug("Found function - prio: {d}, index: {d}", .{ func.priority, func.symbol_index });
+                }
+                parser.object.init_funcs = funcs;
+            },
+            .WASM_COMDAT_INFO => {
+                const comdats = try gpa.alloc(Wasm.Comdat, count);
+                errdefer gpa.free(comdats);
+                for (comdats) |*comdat| {
+                    const name_len = try leb.readUleb128(u32, reader);
+                    const name = try gpa.alloc(u8, name_len);
+                    errdefer gpa.free(name);
+                    try reader.readNoEof(name);
+
+                    const flags = try leb.readUleb128(u32, reader);
+                    if (flags != 0) {
+                        return error.UnexpectedValue;
+                    }
+
+                    const symbol_count = try leb.readUleb128(u32, reader);
+                    const symbols = try gpa.alloc(Wasm.ComdatSym, symbol_count);
+                    errdefer gpa.free(symbols);
+                    for (symbols) |*symbol| {
+                        symbol.* = .{
+                            .kind = @as(Wasm.ComdatSym.Type, @enumFromInt(try leb.readUleb128(u8, reader))),
+                            .index = try leb.readUleb128(u32, reader),
+                        };
+                    }
+
+                    comdat.* = .{
+                        .name = name,
+                        .flags = flags,
+                        .symbols = symbols,
+                    };
+                }
+
+                parser.object.comdat_info = comdats;
+            },
+            .WASM_SYMBOL_TABLE => {
+                var symbols = try std.ArrayList(Symbol).initCapacity(gpa, count);
+
+                var i: usize = 0;
+                while (i < count) : (i += 1) {
+                    const symbol = symbols.addOneAssumeCapacity();
+                    symbol.* = try parser.parseSymbol(gpa, reader);
+                    log.debug("Found symbol: type({s}) name({s}) flags(0b{b:0>8})", .{
+                        @tagName(symbol.tag),
+                        wasm.stringSlice(symbol.name),
+                        symbol.flags,
+                    });
+                }
+
+                // we found all symbols, check for indirect function table
+                // in case of an MVP object file
+                if (try parser.object.checkLegacyIndirectFunctionTable(parser.wasm)) |symbol| {
+                    try symbols.append(symbol);
+                    log.debug("Found legacy indirect function table. Created symbol", .{});
+                }
+
+                // Not all debug sections may be represented by a symbol, for those sections
+                // we manually create a symbol.
+                if (parser.object.relocatable_data.get(.custom)) |custom_sections| {
+                    for (custom_sections) |*data| {
+                        if (!data.represented) {
+                            const name = wasm.castToString(data.index);
+                            try symbols.append(.{
+                                .name = name,
+                                .flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),
+                                .tag = .section,
+                                .virtual_address = 0,
+                                .index = data.section_index,
+                            });
                             data.represented = true;
-                            break;
+                            log.debug("Created synthetic custom section symbol for '{s}'", .{
+                                wasm.stringSlice(name),
+                            });
                         }
                     }
-                },
-                else => {
+                }
+
+                parser.object.symtable = try symbols.toOwnedSlice();
+            },
+        }
+    }
+
+    /// Parses the symbol information based on its kind,
+    /// requires access to `Object` to find the name of a symbol when it's
+    /// an import and flag `WASM_SYM_EXPLICIT_NAME` is not set.
+    fn parseSymbol(parser: *Parser, gpa: Allocator, reader: anytype) !Symbol {
+        const wasm = parser.wasm;
+        const tag: Symbol.Tag = @enumFromInt(try leb.readUleb128(u8, reader));
+        const flags = try leb.readUleb128(u32, reader);
+        var symbol: Symbol = .{
+            .flags = flags,
+            .tag = tag,
+            .name = undefined,
+            .index = undefined,
+            .virtual_address = undefined,
+        };
+
+        switch (tag) {
+            .data => {
+                const name_len = try leb.readUleb128(u32, reader);
+                const name = try gpa.alloc(u8, name_len);
+                defer gpa.free(name);
+                try reader.readNoEof(name);
+                symbol.name = try wasm.internString(name);
+
+                // Data symbols only have the following fields if the symbol is defined
+                if (symbol.isDefined()) {
                     symbol.index = try leb.readUleb128(u32, reader);
-                    const is_undefined = symbol.isUndefined();
-                    const explicit_name = symbol.hasFlag(.WASM_SYM_EXPLICIT_NAME);
-                    symbol.name = if (!is_undefined or (is_undefined and explicit_name)) name: {
-                        const name_len = try leb.readUleb128(u32, reader);
-                        const name = try gpa.alloc(u8, name_len);
-                        defer gpa.free(name);
-                        try reader.readNoEof(name);
-                        break :name try parser.object.string_table.put(gpa, name);
-                    } else parser.object.findImport(symbol).name;
-                },
-            }
-            return symbol;
+                    // @TODO: We should verify those values
+                    _ = try leb.readUleb128(u32, reader);
+                    _ = try leb.readUleb128(u32, reader);
+                }
+            },
+            .section => {
+                symbol.index = try leb.readUleb128(u32, reader);
+                const section_data = parser.object.relocatable_data.get(.custom).?;
+                for (section_data) |*data| {
+                    if (data.section_index == symbol.index) {
+                        symbol.name = wasm.castToString(data.index);
+                        data.represented = true;
+                        break;
+                    }
+                }
+            },
+            else => {
+                symbol.index = try leb.readUleb128(u32, reader);
+                const is_undefined = symbol.isUndefined();
+                const explicit_name = symbol.hasFlag(.WASM_SYM_EXPLICIT_NAME);
+                symbol.name = if (!is_undefined or (is_undefined and explicit_name)) name: {
+                    const name_len = try leb.readUleb128(u32, reader);
+                    const name = try gpa.alloc(u8, name_len);
+                    defer gpa.free(name);
+                    try reader.readNoEof(name);
+                    break :name try wasm.internString(name);
+                } else parser.object.findImport(symbol).name;
+            },
         }
-    };
-}
+        return symbol;
+    }
+};
 
 /// First reads the count from the reader and then allocate
 /// a slice of ptr child's element type.
@@ -918,93 +839,3 @@ fn assertEnd(reader: anytype) !void {
     if (len != 0) return error.MalformedSection;
     if (reader.context.bytes_left != 0) return error.MalformedSection;
 }
-
-/// Parses an object file into atoms, for code and data sections
-pub fn parseSymbolIntoAtom(object: *Object, wasm: *Wasm, symbol_index: Symbol.Index) !Atom.Index {
-    const comp = wasm.base.comp;
-    const gpa = comp.gpa;
-    const symbol = &object.symtable[@intFromEnum(symbol_index)];
-    const relocatable_data: RelocatableData = switch (symbol.tag) {
-        .function => object.relocatable_data.get(.code).?[symbol.index - object.imported_functions_count],
-        .data => object.relocatable_data.get(.data).?[symbol.index],
-        .section => blk: {
-            const data = object.relocatable_data.get(.custom).?;
-            for (data) |dat| {
-                if (dat.section_index == symbol.index) {
-                    break :blk dat;
-                }
-            }
-            unreachable;
-        },
-        else => unreachable,
-    };
-    const final_index = try wasm.getMatchingSegment(object.index, symbol_index);
-    const atom_index = try wasm.createAtom(symbol_index, object.index);
-    try wasm.appendAtomAtIndex(final_index, atom_index);
-
-    const atom = wasm.getAtomPtr(atom_index);
-    atom.size = relocatable_data.size;
-    atom.alignment = relocatable_data.getAlignment(object);
-    atom.code = std.ArrayListUnmanaged(u8).fromOwnedSlice(relocatable_data.data[0..relocatable_data.size]);
-    atom.original_offset = relocatable_data.offset;
-
-    const segment: *Wasm.Segment = &wasm.segments.items[final_index];
-    if (relocatable_data.type == .data) { //code section and custom sections are 1-byte aligned
-        segment.alignment = segment.alignment.max(atom.alignment);
-    }
-
-    if (object.relocations.get(relocatable_data.section_index)) |relocations| {
-        const start = searchRelocStart(relocations, relocatable_data.offset);
-        const len = searchRelocEnd(relocations[start..], relocatable_data.offset + atom.size);
-        atom.relocs = std.ArrayListUnmanaged(types.Relocation).fromOwnedSlice(relocations[start..][0..len]);
-        for (atom.relocs.items) |reloc| {
-            switch (reloc.relocation_type) {
-                .R_WASM_TABLE_INDEX_I32,
-                .R_WASM_TABLE_INDEX_I64,
-                .R_WASM_TABLE_INDEX_SLEB,
-                .R_WASM_TABLE_INDEX_SLEB64,
-                => {
-                    try wasm.function_table.put(gpa, .{
-                        .file = object.index,
-                        .index = @enumFromInt(reloc.index),
-                    }, 0);
-                },
-                .R_WASM_GLOBAL_INDEX_I32,
-                .R_WASM_GLOBAL_INDEX_LEB,
-                => {
-                    const sym = object.symtable[reloc.index];
-                    if (sym.tag != .global) {
-                        try wasm.got_symbols.append(gpa, .{ .file = object.index, .index = @enumFromInt(reloc.index) });
-                    }
-                },
-                else => {},
-            }
-        }
-    }
-
-    return atom_index;
-}
-
-fn searchRelocStart(relocs: []const types.Relocation, address: u32) usize {
-    var min: usize = 0;
-    var max: usize = relocs.len;
-    while (min < max) {
-        const index = (min + max) / 2;
-        const curr = relocs[index];
-        if (curr.offset < address) {
-            min = index + 1;
-        } else {
-            max = index;
-        }
-    }
-    return min;
-}
-
-fn searchRelocEnd(relocs: []const types.Relocation, address: u32) usize {
-    for (relocs, 0..relocs.len) |reloc, index| {
-        if (reloc.offset > address) {
-            return index;
-        }
-    }
-    return relocs.len;
-}
diff --git a/zig/src/link/Wasm/Symbol.zig b/zig/src/link/Wasm/Symbol.zig
index b0d5644b0a..b60b73c46f 100644
--- a/zig/src/link/Wasm/Symbol.zig
+++ b/zig/src/link/Wasm/Symbol.zig
@@ -8,8 +8,8 @@
 /// Can contain any of the flags defined in `Flag`
 flags: u32,
 /// Symbol name, when the symbol is undefined the name will be taken from the import.
-/// Note: This is an index into the string table.
-name: u32,
+/// Note: This is an index into the wasm string table.
+name: wasm.String,
 /// Index into the list of objects based on set `tag`
 /// NOTE: This will be set to `undefined` when `tag` is `data`
 /// and the symbol is undefined.
@@ -206,5 +206,5 @@ pub fn format(symbol: Symbol, comptime fmt: []const u8, options: std.fmt.FormatO
 }
 
 const std = @import("std");
-const types = @import("types.zig");
 const Symbol = @This();
+const wasm = @import("../Wasm.zig");
diff --git a/zig/src/link/Wasm/ZigObject.zig b/zig/src/link/Wasm/ZigObject.zig
index 962024eeef..d82329dda6 100644
--- a/zig/src/link/Wasm/ZigObject.zig
+++ b/zig/src/link/Wasm/ZigObject.zig
@@ -1,11 +1,9 @@
 //! ZigObject encapsulates the state of the incrementally compiled Zig module.
 //! It stores the associated input local and global symbols, allocated atoms,
 //! and any relocations that may have been emitted.
-//! Think about this as fake in-memory Object file for the Zig module.
 
-path: []const u8,
-/// Index within the list of relocatable objects of the linker driver.
-index: File.Index,
+/// For error reporting purposes only.
+path: Path,
 /// Map of all `Nav` that are currently alive.
 /// Each index maps to the corresponding `NavInfo`.
 navs: std.AutoHashMapUnmanaged(InternPool.Nav.Index, NavInfo) = .empty,
@@ -16,8 +14,8 @@ func_types: std.ArrayListUnmanaged(std.wasm.Type) = .empty,
 functions: std.ArrayListUnmanaged(std.wasm.Func) = .empty,
 /// List of indexes pointing to an entry within the `functions` list which has been removed.
 functions_free_list: std.ArrayListUnmanaged(u32) = .empty,
-/// Map of symbol locations, represented by its `types.Import`.
-imports: std.AutoHashMapUnmanaged(Symbol.Index, types.Import) = .empty,
+/// Map of symbol locations, represented by its `Wasm.Import`.
+imports: std.AutoHashMapUnmanaged(Symbol.Index, Wasm.Import) = .empty,
 /// List of WebAssembly globals.
 globals: std.ArrayListUnmanaged(std.wasm.Global) = .empty,
 /// Mapping between an `Atom` and its type index representing the Wasm
@@ -25,16 +23,14 @@ globals: std.ArrayListUnmanaged(std.wasm.Global) = .empty,
 atom_types: std.AutoHashMapUnmanaged(Atom.Index, u32) = .empty,
 /// List of all symbols generated by Zig code.
 symbols: std.ArrayListUnmanaged(Symbol) = .empty,
-/// Map from symbol name offset to their index into the `symbols` list.
-global_syms: std.AutoHashMapUnmanaged(u32, Symbol.Index) = .empty,
+/// Map from symbol name to their index into the `symbols` list.
+global_syms: std.AutoHashMapUnmanaged(Wasm.String, Symbol.Index) = .empty,
 /// List of symbol indexes which are free to be used.
 symbols_free_list: std.ArrayListUnmanaged(Symbol.Index) = .empty,
 /// Extra metadata about the linking section, such as alignment of segments and their name.
-segment_info: std.ArrayListUnmanaged(types.Segment) = .empty,
+segment_info: std.ArrayListUnmanaged(Wasm.NamedSegment) = .empty,
 /// List of indexes which contain a free slot in the `segment_info` list.
 segment_free_list: std.ArrayListUnmanaged(u32) = .empty,
-/// File encapsulated string table, used to deduplicate strings within the generated file.
-string_table: StringTable = .{},
 /// Map for storing anonymous declarations. Each anonymous decl maps to its Atom's index.
 uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Atom.Index) = .empty,
 /// List of atom indexes of functions that are generated by the backend.
@@ -90,13 +86,9 @@ const NavInfo = struct {
     atom: Atom.Index = .null,
     exports: std.ArrayListUnmanaged(Symbol.Index) = .empty,
 
-    fn @"export"(ni: NavInfo, zig_object: *const ZigObject, name: []const u8) ?Symbol.Index {
+    fn @"export"(ni: NavInfo, zo: *const ZigObject, name: Wasm.String) ?Symbol.Index {
         for (ni.exports.items) |sym_index| {
-            const sym_name_index = zig_object.symbol(sym_index).name;
-            const sym_name = zig_object.string_table.getAssumeExists(sym_name_index);
-            if (std.mem.eql(u8, name, sym_name)) {
-                return sym_index;
-            }
+            if (zo.symbol(sym_index).name == name) return sym_index;
         }
         return null;
     }
@@ -117,39 +109,39 @@ const NavInfo = struct {
 };
 
 /// Initializes the `ZigObject` with initial symbols.
-pub fn init(zig_object: *ZigObject, wasm_file: *Wasm) !void {
+pub fn init(zig_object: *ZigObject, wasm: *Wasm) !void {
     // Initialize an undefined global with the name __stack_pointer. Codegen will use
     // this to generate relocations when moving the stack pointer. This symbol will be
     // resolved automatically by the final linking stage.
-    try zig_object.createStackPointer(wasm_file);
+    try zig_object.createStackPointer(wasm);
 
     // TODO: Initialize debug information when we reimplement Dwarf support.
 }
 
-fn createStackPointer(zig_object: *ZigObject, wasm_file: *Wasm) !void {
-    const gpa = wasm_file.base.comp.gpa;
-    const sym_index = try zig_object.getGlobalSymbol(gpa, "__stack_pointer");
+fn createStackPointer(zig_object: *ZigObject, wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
+    const sym_index = try zig_object.getGlobalSymbol(gpa, wasm.preloaded_strings.__stack_pointer);
     const sym = zig_object.symbol(sym_index);
     sym.index = zig_object.imported_globals_count;
     sym.tag = .global;
-    const is_wasm32 = wasm_file.base.comp.root_mod.resolved_target.result.cpu.arch == .wasm32;
+    const is_wasm32 = wasm.base.comp.root_mod.resolved_target.result.cpu.arch == .wasm32;
     try zig_object.imports.putNoClobber(gpa, sym_index, .{
         .name = sym.name,
-        .module_name = try zig_object.string_table.insert(gpa, wasm_file.host_name),
+        .module_name = wasm.host_name,
         .kind = .{ .global = .{ .valtype = if (is_wasm32) .i32 else .i64, .mutable = true } },
     });
     zig_object.imported_globals_count += 1;
     zig_object.stack_pointer_sym = sym_index;
 }
 
-fn symbol(zig_object: *const ZigObject, index: Symbol.Index) *Symbol {
+pub fn symbol(zig_object: *const ZigObject, index: Symbol.Index) *Symbol {
     return &zig_object.symbols.items[@intFromEnum(index)];
 }
 
 /// Frees and invalidates all memory of the incrementally compiled Zig module.
 /// It is illegal behavior to access the `ZigObject` after calling `deinit`.
-pub fn deinit(zig_object: *ZigObject, wasm_file: *Wasm) void {
-    const gpa = wasm_file.base.comp.gpa;
+pub fn deinit(zig_object: *ZigObject, wasm: *Wasm) void {
+    const gpa = wasm.base.comp.gpa;
     for (zig_object.segment_info.items) |segment_info| {
         gpa.free(segment_info.name);
     }
@@ -157,9 +149,9 @@ pub fn deinit(zig_object: *ZigObject, wasm_file: *Wasm) void {
     {
         var it = zig_object.navs.valueIterator();
         while (it.next()) |nav_info| {
-            const atom = wasm_file.getAtomPtr(nav_info.atom);
+            const atom = wasm.getAtomPtr(nav_info.atom);
             for (atom.locals.items) |local_index| {
-                const local_atom = wasm_file.getAtomPtr(local_index);
+                const local_atom = wasm.getAtomPtr(local_index);
                 local_atom.deinit(gpa);
             }
             atom.deinit(gpa);
@@ -168,24 +160,24 @@ pub fn deinit(zig_object: *ZigObject, wasm_file: *Wasm) void {
     }
     {
         for (zig_object.uavs.values()) |atom_index| {
-            const atom = wasm_file.getAtomPtr(atom_index);
+            const atom = wasm.getAtomPtr(atom_index);
             for (atom.locals.items) |local_index| {
-                const local_atom = wasm_file.getAtomPtr(local_index);
+                const local_atom = wasm.getAtomPtr(local_index);
                 local_atom.deinit(gpa);
             }
             atom.deinit(gpa);
         }
     }
-    if (zig_object.findGlobalSymbol("__zig_errors_len")) |sym_index| {
-        const atom_index = wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = sym_index }).?;
-        wasm_file.getAtomPtr(atom_index).deinit(gpa);
+    if (zig_object.global_syms.get(wasm.preloaded_strings.__zig_errors_len)) |sym_index| {
+        const atom_index = wasm.symbol_atom.get(.{ .file = .zig_object, .index = sym_index }).?;
+        wasm.getAtomPtr(atom_index).deinit(gpa);
     }
-    if (wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = zig_object.error_table_symbol })) |atom_index| {
-        const atom = wasm_file.getAtomPtr(atom_index);
+    if (wasm.symbol_atom.get(.{ .file = .zig_object, .index = zig_object.error_table_symbol })) |atom_index| {
+        const atom = wasm.getAtomPtr(atom_index);
         atom.deinit(gpa);
     }
     for (zig_object.synthetic_functions.items) |atom_index| {
-        const atom = wasm_file.getAtomPtr(atom_index);
+        const atom = wasm.getAtomPtr(atom_index);
         atom.deinit(gpa);
     }
     zig_object.synthetic_functions.deinit(gpa);
@@ -193,7 +185,7 @@ pub fn deinit(zig_object: *ZigObject, wasm_file: *Wasm) void {
         ty.deinit(gpa);
     }
     if (zig_object.error_names_atom != .null) {
-        const atom = wasm_file.getAtomPtr(zig_object.error_names_atom);
+        const atom = wasm.getAtomPtr(zig_object.error_names_atom);
         atom.deinit(gpa);
     }
     zig_object.global_syms.deinit(gpa);
@@ -208,11 +200,10 @@ pub fn deinit(zig_object: *ZigObject, wasm_file: *Wasm) void {
     zig_object.segment_info.deinit(gpa);
     zig_object.segment_free_list.deinit(gpa);
 
-    zig_object.string_table.deinit(gpa);
     if (zig_object.dwarf) |*dwarf| {
         dwarf.deinit();
     }
-    gpa.free(zig_object.path);
+    gpa.free(zig_object.path.sub_path);
     zig_object.* = undefined;
 }
 
@@ -221,7 +212,7 @@ pub fn deinit(zig_object: *ZigObject, wasm_file: *Wasm) void {
 pub fn allocateSymbol(zig_object: *ZigObject, gpa: std.mem.Allocator) !Symbol.Index {
     try zig_object.symbols.ensureUnusedCapacity(gpa, 1);
     const sym: Symbol = .{
-        .name = std.math.maxInt(u32), // will be set after updateDecl as well as during atom creation for decls
+        .name = undefined, // will be set after updateDecl as well as during atom creation for decls
         .flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),
         .tag = .undefined, // will be set after updateDecl
         .index = std.math.maxInt(u32), // will be set during atom parsing
@@ -240,7 +231,7 @@ pub fn allocateSymbol(zig_object: *ZigObject, gpa: std.mem.Allocator) !Symbol.In
 // the file on flush().
 pub fn updateNav(
     zig_object: *ZigObject,
-    wasm_file: *Wasm,
+    wasm: *Wasm,
     pt: Zcu.PerThread,
     nav_index: InternPool.Nav.Index,
 ) !void {
@@ -260,19 +251,19 @@ pub fn updateNav(
     };
 
     if (nav_init.typeOf(zcu).hasRuntimeBits(zcu)) {
-        const gpa = wasm_file.base.comp.gpa;
-        const atom_index = try zig_object.getOrCreateAtomForNav(wasm_file, pt, nav_index);
-        const atom = wasm_file.getAtomPtr(atom_index);
+        const gpa = wasm.base.comp.gpa;
+        const atom_index = try zig_object.getOrCreateAtomForNav(wasm, pt, nav_index);
+        const atom = wasm.getAtomPtr(atom_index);
         atom.clear();
 
         if (is_extern)
-            return zig_object.addOrUpdateImport(wasm_file, nav.name.toSlice(ip), atom.sym_index, lib_name.toSlice(ip), null);
+            return zig_object.addOrUpdateImport(wasm, nav.name.toSlice(ip), atom.sym_index, lib_name.toSlice(ip), null);
 
         var code_writer = std.ArrayList(u8).init(gpa);
         defer code_writer.deinit();
 
         const res = try codegen.generateSymbol(
-            &wasm_file.base,
+            &wasm.base,
             pt,
             zcu.navSrcLoc(nav_index),
             nav_init,
@@ -288,13 +279,13 @@ pub fn updateNav(
             },
         };
 
-        try zig_object.finishUpdateNav(wasm_file, pt, nav_index, code);
+        try zig_object.finishUpdateNav(wasm, pt, nav_index, code);
     }
 }
 
 pub fn updateFunc(
     zig_object: *ZigObject,
-    wasm_file: *Wasm,
+    wasm: *Wasm,
     pt: Zcu.PerThread,
     func_index: InternPool.Index,
     air: Air,
@@ -303,14 +294,14 @@ pub fn updateFunc(
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
     const func = pt.zcu.funcInfo(func_index);
-    const atom_index = try zig_object.getOrCreateAtomForNav(wasm_file, pt, func.owner_nav);
-    const atom = wasm_file.getAtomPtr(atom_index);
+    const atom_index = try zig_object.getOrCreateAtomForNav(wasm, pt, func.owner_nav);
+    const atom = wasm.getAtomPtr(atom_index);
     atom.clear();
 
     var code_writer = std.ArrayList(u8).init(gpa);
     defer code_writer.deinit();
     const result = try codegen.generateFunction(
-        &wasm_file.base,
+        &wasm.base,
         pt,
         zcu.navSrcLoc(func.owner_nav),
         func_index,
@@ -328,12 +319,12 @@ pub fn updateFunc(
         },
     };
 
-    return zig_object.finishUpdateNav(wasm_file, pt, func.owner_nav, code);
+    return zig_object.finishUpdateNav(wasm, pt, func.owner_nav, code);
 }
 
 fn finishUpdateNav(
     zig_object: *ZigObject,
-    wasm_file: *Wasm,
+    wasm: *Wasm,
     pt: Zcu.PerThread,
     nav_index: InternPool.Nav.Index,
     code: []const u8,
@@ -345,9 +336,9 @@ fn finishUpdateNav(
     const nav_val = zcu.navValue(nav_index);
     const nav_info = zig_object.navs.get(nav_index).?;
     const atom_index = nav_info.atom;
-    const atom = wasm_file.getAtomPtr(atom_index);
+    const atom = wasm.getAtomPtr(atom_index);
     const sym = zig_object.symbol(atom.sym_index);
-    sym.name = try zig_object.string_table.insert(gpa, nav.fqn.toSlice(ip));
+    sym.name = try wasm.internString(nav.fqn.toSlice(ip));
     try atom.code.appendSlice(gpa, code);
     atom.size = @intCast(code.len);
 
@@ -376,7 +367,7 @@ fn finishUpdateNav(
             }
             break :name ".bss.";
         };
-        if ((wasm_file.base.isObject() or wasm_file.base.comp.config.import_memory) and
+        if ((wasm.base.isObject() or wasm.base.comp.config.import_memory) and
             std.mem.startsWith(u8, segment_name, ".bss"))
         {
             @memset(atom.code.items, 0);
@@ -422,7 +413,7 @@ fn createDataSegment(
 /// The newly created Atom is empty with default fields as specified by `Atom.empty`.
 pub fn getOrCreateAtomForNav(
     zig_object: *ZigObject,
-    wasm_file: *Wasm,
+    wasm: *Wasm,
     pt: Zcu.PerThread,
     nav_index: InternPool.Nav.Index,
 ) !Atom.Index {
@@ -431,23 +422,23 @@ pub fn getOrCreateAtomForNav(
     const gop = try zig_object.navs.getOrPut(gpa, nav_index);
     if (!gop.found_existing) {
         const sym_index = try zig_object.allocateSymbol(gpa);
-        gop.value_ptr.* = .{ .atom = try wasm_file.createAtom(sym_index, zig_object.index) };
+        gop.value_ptr.* = .{ .atom = try wasm.createAtom(sym_index, .zig_object) };
         const nav = ip.getNav(nav_index);
         const sym = zig_object.symbol(sym_index);
-        sym.name = try zig_object.string_table.insert(gpa, nav.fqn.toSlice(ip));
+        sym.name = try wasm.internString(nav.fqn.toSlice(ip));
     }
     return gop.value_ptr.atom;
 }
 
 pub fn lowerUav(
     zig_object: *ZigObject,
-    wasm_file: *Wasm,
+    wasm: *Wasm,
     pt: Zcu.PerThread,
     uav: InternPool.Index,
     explicit_alignment: InternPool.Alignment,
     src_loc: Zcu.LazySrcLoc,
 ) !codegen.GenResult {
-    const gpa = wasm_file.base.comp.gpa;
+    const gpa = wasm.base.comp.gpa;
     const gop = try zig_object.uavs.getOrPut(gpa, uav);
     if (!gop.found_existing) {
         var name_buf: [32]u8 = undefined;
@@ -455,13 +446,13 @@ pub fn lowerUav(
             @intFromEnum(uav),
         }) catch unreachable;
 
-        switch (try zig_object.lowerConst(wasm_file, pt, name, Value.fromInterned(uav), src_loc)) {
+        switch (try zig_object.lowerConst(wasm, pt, name, Value.fromInterned(uav), src_loc)) {
             .ok => |atom_index| zig_object.uavs.values()[gop.index] = atom_index,
             .fail => |em| return .{ .fail = em },
         }
     }
 
-    const atom = wasm_file.getAtomPtr(zig_object.uavs.values()[gop.index]);
+    const atom = wasm.getAtomPtr(zig_object.uavs.values()[gop.index]);
     atom.alignment = switch (atom.alignment) {
         .none => explicit_alignment,
         else => switch (explicit_alignment) {
@@ -479,30 +470,30 @@ const LowerConstResult = union(enum) {
 
 fn lowerConst(
     zig_object: *ZigObject,
-    wasm_file: *Wasm,
+    wasm: *Wasm,
     pt: Zcu.PerThread,
     name: []const u8,
     val: Value,
     src_loc: Zcu.LazySrcLoc,
 ) !LowerConstResult {
-    const gpa = wasm_file.base.comp.gpa;
-    const zcu = wasm_file.base.comp.zcu.?;
+    const gpa = wasm.base.comp.gpa;
+    const zcu = wasm.base.comp.zcu.?;
 
     const ty = val.typeOf(zcu);
 
     // Create and initialize a new local symbol and atom
     const sym_index = try zig_object.allocateSymbol(gpa);
-    const atom_index = try wasm_file.createAtom(sym_index, zig_object.index);
+    const atom_index = try wasm.createAtom(sym_index, .zig_object);
     var value_bytes = std.ArrayList(u8).init(gpa);
     defer value_bytes.deinit();
 
     const code = code: {
-        const atom = wasm_file.getAtomPtr(atom_index);
+        const atom = wasm.getAtomPtr(atom_index);
         atom.alignment = ty.abiAlignment(zcu);
         const segment_name = try std.mem.concat(gpa, u8, &.{ ".rodata.", name });
         errdefer gpa.free(segment_name);
         zig_object.symbol(sym_index).* = .{
-            .name = try zig_object.string_table.insert(gpa, name),
+            .name = try wasm.internString(name),
             .flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),
             .tag = .data,
             .index = try zig_object.createDataSegment(
@@ -514,7 +505,7 @@ fn lowerConst(
         };
 
         const result = try codegen.generateSymbol(
-            &wasm_file.base,
+            &wasm.base,
             pt,
             src_loc,
             val,
@@ -529,7 +520,7 @@ fn lowerConst(
         };
     };
 
-    const atom = wasm_file.getAtomPtr(atom_index);
+    const atom = wasm.getAtomPtr(atom_index);
     atom.size = @intCast(code.len);
     try atom.code.appendSlice(gpa, code);
     return .{ .ok = atom_index };
@@ -538,7 +529,7 @@ fn lowerConst(
 /// Returns the symbol index of the error name table.
 ///
 /// When the symbol does not yet exist, it will create a new one instead.
-pub fn getErrorTableSymbol(zig_object: *ZigObject, wasm_file: *Wasm, pt: Zcu.PerThread) !Symbol.Index {
+pub fn getErrorTableSymbol(zig_object: *ZigObject, wasm: *Wasm, pt: Zcu.PerThread) !Symbol.Index {
     if (zig_object.error_table_symbol != .null) {
         return zig_object.error_table_symbol;
     }
@@ -546,18 +537,17 @@ pub fn getErrorTableSymbol(zig_object: *ZigObject, wasm_file: *Wasm, pt: Zcu.Per
     // no error was referenced yet, so create a new symbol and atom for it
     // and then return said symbol's index. The final table will be populated
     // during `flush` when we know all possible error names.
-    const gpa = wasm_file.base.comp.gpa;
+    const gpa = wasm.base.comp.gpa;
     const sym_index = try zig_object.allocateSymbol(gpa);
-    const atom_index = try wasm_file.createAtom(sym_index, zig_object.index);
-    const atom = wasm_file.getAtomPtr(atom_index);
+    const atom_index = try wasm.createAtom(sym_index, .zig_object);
+    const atom = wasm.getAtomPtr(atom_index);
     const slice_ty = Type.slice_const_u8_sentinel_0;
     atom.alignment = slice_ty.abiAlignment(pt.zcu);
 
-    const sym_name = try zig_object.string_table.insert(gpa, "__zig_err_name_table");
     const segment_name = try gpa.dupe(u8, ".rodata.__zig_err_name_table");
     const sym = zig_object.symbol(sym_index);
     sym.* = .{
-        .name = sym_name,
+        .name = wasm.preloaded_strings.__zig_err_name_table,
         .tag = .data,
         .flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),
         .index = try zig_object.createDataSegment(gpa, segment_name, atom.alignment),
@@ -573,23 +563,22 @@ pub fn getErrorTableSymbol(zig_object: *ZigObject, wasm_file: *Wasm, pt: Zcu.Per
 ///
 /// This creates a table that consists of pointers and length to each error name.
 /// The table is what is being pointed to within the runtime bodies that are generated.
-fn populateErrorNameTable(zig_object: *ZigObject, wasm_file: *Wasm, tid: Zcu.PerThread.Id) !void {
+fn populateErrorNameTable(zig_object: *ZigObject, wasm: *Wasm, tid: Zcu.PerThread.Id) !void {
     if (zig_object.error_table_symbol == .null) return;
-    const gpa = wasm_file.base.comp.gpa;
-    const atom_index = wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = zig_object.error_table_symbol }).?;
+    const gpa = wasm.base.comp.gpa;
+    const atom_index = wasm.symbol_atom.get(.{ .file = .zig_object, .index = zig_object.error_table_symbol }).?;
 
     // Rather than creating a symbol for each individual error name,
     // we create a symbol for the entire region of error names. We then calculate
     // the pointers into the list using addends which are appended to the relocation.
     const names_sym_index = try zig_object.allocateSymbol(gpa);
-    const names_atom_index = try wasm_file.createAtom(names_sym_index, zig_object.index);
-    const names_atom = wasm_file.getAtomPtr(names_atom_index);
+    const names_atom_index = try wasm.createAtom(names_sym_index, .zig_object);
+    const names_atom = wasm.getAtomPtr(names_atom_index);
     names_atom.alignment = .@"1";
-    const sym_name = try zig_object.string_table.insert(gpa, "__zig_err_names");
     const segment_name = try gpa.dupe(u8, ".rodata.__zig_err_names");
     const names_symbol = zig_object.symbol(names_sym_index);
     names_symbol.* = .{
-        .name = sym_name,
+        .name = wasm.preloaded_strings.__zig_err_names,
         .tag = .data,
         .flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),
         .index = try zig_object.createDataSegment(gpa, segment_name, names_atom.alignment),
@@ -600,9 +589,9 @@ fn populateErrorNameTable(zig_object: *ZigObject, wasm_file: *Wasm, tid: Zcu.Per
 
     // Addend for each relocation to the table
     var addend: u32 = 0;
-    const pt: Zcu.PerThread = .{ .zcu = wasm_file.base.comp.zcu.?, .tid = tid };
+    const pt: Zcu.PerThread = .{ .zcu = wasm.base.comp.zcu.?, .tid = tid };
     const slice_ty = Type.slice_const_u8_sentinel_0;
-    const atom = wasm_file.getAtomPtr(atom_index);
+    const atom = wasm.getAtomPtr(atom_index);
     {
         // TODO: remove this unreachable entry
         try atom.code.appendNTimes(gpa, 0, 4);
@@ -646,7 +635,7 @@ fn populateErrorNameTable(zig_object: *ZigObject, wasm_file: *Wasm, tid: Zcu.Per
 /// In all other cases, a data-symbol will be created instead.
 pub fn addOrUpdateImport(
     zig_object: *ZigObject,
-    wasm_file: *Wasm,
+    wasm: *Wasm,
     /// Name of the import
     name: []const u8,
     /// Symbol index that is external
@@ -658,19 +647,19 @@ pub fn addOrUpdateImport(
     /// is asserted instead.
     type_index: ?u32,
 ) !void {
-    const gpa = wasm_file.base.comp.gpa;
+    const gpa = wasm.base.comp.gpa;
     std.debug.assert(symbol_index != .null);
     // For the import name, we use the decl's name, rather than the fully qualified name
     // Also mangle the name when the lib name is set and not equal to "C" so imports with the same
     // name but different module can be resolved correctly.
-    const mangle_name = lib_name != null and
-        !std.mem.eql(u8, lib_name.?, "c");
-    const full_name = if (mangle_name) full_name: {
-        break :full_name try std.fmt.allocPrint(gpa, "{s}|{s}", .{ name, lib_name.? });
-    } else name;
+    const mangle_name = if (lib_name) |n| !std.mem.eql(u8, n, "c") else false;
+    const full_name = if (mangle_name)
+        try std.fmt.allocPrint(gpa, "{s}|{s}", .{ name, lib_name.? })
+    else
+        name;
     defer if (mangle_name) gpa.free(full_name);
 
-    const decl_name_index = try zig_object.string_table.insert(gpa, full_name);
+    const decl_name_index = try wasm.internString(full_name);
     const sym: *Symbol = &zig_object.symbols.items[@intFromEnum(symbol_index)];
     sym.setUndefined(true);
     sym.setGlobal(true);
@@ -682,13 +671,11 @@ pub fn addOrUpdateImport(
 
     if (type_index) |ty_index| {
         const gop = try zig_object.imports.getOrPut(gpa, symbol_index);
-        const module_name = if (lib_name) |l_name| l_name else wasm_file.host_name;
-        if (!gop.found_existing) {
-            zig_object.imported_functions_count += 1;
-        }
+        const module_name = if (lib_name) |n| try wasm.internString(n) else wasm.host_name;
+        if (!gop.found_existing) zig_object.imported_functions_count += 1;
         gop.value_ptr.* = .{
-            .module_name = try zig_object.string_table.insert(gpa, module_name),
-            .name = try zig_object.string_table.insert(gpa, name),
+            .module_name = module_name,
+            .name = try wasm.internString(name),
             .kind = .{ .function = ty_index },
         };
         sym.tag = .function;
@@ -701,8 +688,7 @@ pub fn addOrUpdateImport(
 /// such as an exported or imported symbol.
 /// If the symbol does not yet exist, creates a new one symbol instead
 /// and then returns the index to it.
-pub fn getGlobalSymbol(zig_object: *ZigObject, gpa: std.mem.Allocator, name: []const u8) !Symbol.Index {
-    const name_index = try zig_object.string_table.insert(gpa, name);
+pub fn getGlobalSymbol(zig_object: *ZigObject, gpa: std.mem.Allocator, name_index: Wasm.String) !Symbol.Index {
     const gop = try zig_object.global_syms.getOrPut(gpa, name_index);
     if (gop.found_existing) {
         return gop.value_ptr.*;
@@ -733,7 +719,7 @@ pub fn getGlobalSymbol(zig_object: *ZigObject, gpa: std.mem.Allocator, name: []c
 /// Returns the given pointer address
 pub fn getNavVAddr(
     zig_object: *ZigObject,
-    wasm_file: *Wasm,
+    wasm: *Wasm,
     pt: Zcu.PerThread,
     nav_index: InternPool.Nav.Index,
     reloc_info: link.File.RelocInfo,
@@ -744,12 +730,12 @@ pub fn getNavVAddr(
     const nav = ip.getNav(nav_index);
     const target = &zcu.navFileScope(nav_index).mod.resolved_target.result;
 
-    const target_atom_index = try zig_object.getOrCreateAtomForNav(wasm_file, pt, nav_index);
-    const target_atom = wasm_file.getAtom(target_atom_index);
+    const target_atom_index = try zig_object.getOrCreateAtomForNav(wasm, pt, nav_index);
+    const target_atom = wasm.getAtom(target_atom_index);
     const target_symbol_index = @intFromEnum(target_atom.sym_index);
     switch (ip.indexToKey(nav.status.resolved.val)) {
         .@"extern" => |@"extern"| try zig_object.addOrUpdateImport(
-            wasm_file,
+            wasm,
             nav.name.toSlice(ip),
             target_atom.sym_index,
             @"extern".lib_name.toSlice(ip),
@@ -759,11 +745,11 @@ pub fn getNavVAddr(
     }
 
     std.debug.assert(reloc_info.parent.atom_index != 0);
-    const atom_index = wasm_file.symbol_atom.get(.{
-        .file = zig_object.index,
+    const atom_index = wasm.symbol_atom.get(.{
+        .file = .zig_object,
         .index = @enumFromInt(reloc_info.parent.atom_index),
     }).?;
-    const atom = wasm_file.getAtomPtr(atom_index);
+    const atom = wasm.getAtomPtr(atom_index);
     const is_wasm32 = target.cpu.arch == .wasm32;
     if (ip.isFunctionType(ip.getNav(nav_index).typeOf(ip))) {
         std.debug.assert(reloc_info.addend == 0); // addend not allowed for function relocations
@@ -790,22 +776,22 @@ pub fn getNavVAddr(
 
 pub fn getUavVAddr(
     zig_object: *ZigObject,
-    wasm_file: *Wasm,
+    wasm: *Wasm,
     uav: InternPool.Index,
     reloc_info: link.File.RelocInfo,
 ) !u64 {
-    const gpa = wasm_file.base.comp.gpa;
-    const target = wasm_file.base.comp.root_mod.resolved_target.result;
+    const gpa = wasm.base.comp.gpa;
+    const target = wasm.base.comp.root_mod.resolved_target.result;
     const atom_index = zig_object.uavs.get(uav).?;
-    const target_symbol_index = @intFromEnum(wasm_file.getAtom(atom_index).sym_index);
+    const target_symbol_index = @intFromEnum(wasm.getAtom(atom_index).sym_index);
 
-    const parent_atom_index = wasm_file.symbol_atom.get(.{
-        .file = zig_object.index,
+    const parent_atom_index = wasm.symbol_atom.get(.{
+        .file = .zig_object,
         .index = @enumFromInt(reloc_info.parent.atom_index),
     }).?;
-    const parent_atom = wasm_file.getAtomPtr(parent_atom_index);
+    const parent_atom = wasm.getAtomPtr(parent_atom_index);
     const is_wasm32 = target.cpu.arch == .wasm32;
-    const zcu = wasm_file.base.comp.zcu.?;
+    const zcu = wasm.base.comp.zcu.?;
     const ty = Type.fromInterned(zcu.intern_pool.typeOf(uav));
     if (ty.zigTypeTag(zcu) == .@"fn") {
         std.debug.assert(reloc_info.addend == 0); // addend not allowed for function relocations
@@ -832,29 +818,30 @@ pub fn getUavVAddr(
 
 pub fn deleteExport(
     zig_object: *ZigObject,
-    wasm_file: *Wasm,
+    wasm: *Wasm,
     exported: Zcu.Exported,
     name: InternPool.NullTerminatedString,
 ) void {
-    const zcu = wasm_file.base.comp.zcu.?;
+    const zcu = wasm.base.comp.zcu.?;
     const nav_index = switch (exported) {
         .nav => |nav_index| nav_index,
         .uav => @panic("TODO: implement Wasm linker code for exporting a constant value"),
     };
     const nav_info = zig_object.navs.getPtr(nav_index) orelse return;
-    if (nav_info.@"export"(zig_object, name.toSlice(&zcu.intern_pool))) |sym_index| {
+    const name_interned = wasm.getExistingString(name.toSlice(&zcu.intern_pool)).?;
+    if (nav_info.@"export"(zig_object, name_interned)) |sym_index| {
         const sym = zig_object.symbol(sym_index);
         nav_info.deleteExport(sym_index);
         std.debug.assert(zig_object.global_syms.remove(sym.name));
-        std.debug.assert(wasm_file.symbol_atom.remove(.{ .file = zig_object.index, .index = sym_index }));
-        zig_object.symbols_free_list.append(wasm_file.base.comp.gpa, sym_index) catch {};
+        std.debug.assert(wasm.symbol_atom.remove(.{ .file = .zig_object, .index = sym_index }));
+        zig_object.symbols_free_list.append(wasm.base.comp.gpa, sym_index) catch {};
         sym.tag = .dead;
     }
 }
 
 pub fn updateExports(
     zig_object: *ZigObject,
-    wasm_file: *Wasm,
+    wasm: *Wasm,
     pt: Zcu.PerThread,
     exported: Zcu.Exported,
     export_indices: []const u32,
@@ -869,10 +856,10 @@ pub fn updateExports(
         },
     };
     const nav = ip.getNav(nav_index);
-    const atom_index = try zig_object.getOrCreateAtomForNav(wasm_file, pt, nav_index);
+    const atom_index = try zig_object.getOrCreateAtomForNav(wasm, pt, nav_index);
     const nav_info = zig_object.navs.getPtr(nav_index).?;
-    const atom = wasm_file.getAtom(atom_index);
-    const atom_sym = atom.symbolLoc().getSymbol(wasm_file).*;
+    const atom = wasm.getAtom(atom_index);
+    const atom_sym = wasm.symbolLocSymbol(atom.symbolLoc()).*;
     const gpa = zcu.gpa;
     log.debug("Updating exports for decl '{}'", .{nav.name.fmt(ip)});
 
@@ -888,14 +875,13 @@ pub fn updateExports(
             continue;
         }
 
-        const export_string = exp.opts.name.toSlice(ip);
-        const sym_index = if (nav_info.@"export"(zig_object, export_string)) |idx| idx else index: {
+        const export_name = try wasm.internString(exp.opts.name.toSlice(ip));
+        const sym_index = if (nav_info.@"export"(zig_object, export_name)) |idx| idx else index: {
             const sym_index = try zig_object.allocateSymbol(gpa);
             try nav_info.appendExport(gpa, sym_index);
             break :index sym_index;
         };
 
-        const export_name = try zig_object.string_table.insert(gpa, export_string);
         const sym = zig_object.symbol(sym_index);
         sym.setGlobal(true);
         sym.setUndefined(false);
@@ -924,19 +910,19 @@ pub fn updateExports(
         if (exp.opts.visibility == .hidden) {
             sym.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);
         }
-        log.debug("  with name '{s}' - {}", .{ export_string, sym });
+        log.debug("  with name '{s}' - {}", .{ wasm.stringSlice(export_name), sym });
         try zig_object.global_syms.put(gpa, export_name, sym_index);
-        try wasm_file.symbol_atom.put(gpa, .{ .file = zig_object.index, .index = sym_index }, atom_index);
+        try wasm.symbol_atom.put(gpa, .{ .file = .zig_object, .index = sym_index }, atom_index);
     }
 }
 
-pub fn freeNav(zig_object: *ZigObject, wasm_file: *Wasm, nav_index: InternPool.Nav.Index) void {
-    const gpa = wasm_file.base.comp.gpa;
-    const zcu = wasm_file.base.comp.zcu.?;
+pub fn freeNav(zig_object: *ZigObject, wasm: *Wasm, nav_index: InternPool.Nav.Index) void {
+    const gpa = wasm.base.comp.gpa;
+    const zcu = wasm.base.comp.zcu.?;
     const ip = &zcu.intern_pool;
     const nav_info = zig_object.navs.getPtr(nav_index).?;
     const atom_index = nav_info.atom;
-    const atom = wasm_file.getAtomPtr(atom_index);
+    const atom = wasm.getAtomPtr(atom_index);
     zig_object.symbols_free_list.append(gpa, atom.sym_index) catch {};
     for (nav_info.exports.items) |exp_sym_index| {
         const exp_sym = zig_object.symbol(exp_sym_index);
@@ -947,11 +933,11 @@ pub fn freeNav(zig_object: *ZigObject, wasm_file: *Wasm, nav_index: InternPool.N
     std.debug.assert(zig_object.navs.remove(nav_index));
     const sym = &zig_object.symbols.items[atom.sym_index];
     for (atom.locals.items) |local_atom_index| {
-        const local_atom = wasm_file.getAtom(local_atom_index);
+        const local_atom = wasm.getAtom(local_atom_index);
         const local_symbol = &zig_object.symbols.items[local_atom.sym_index];
         std.debug.assert(local_symbol.tag == .data);
         zig_object.symbols_free_list.append(gpa, local_atom.sym_index) catch {};
-        std.debug.assert(wasm_file.symbol_atom.remove(local_atom.symbolLoc()));
+        std.debug.assert(wasm.symbol_atom.remove(local_atom.symbolLoc()));
         local_symbol.tag = .dead; // also for any local symbol
         const segment = &zig_object.segment_info.items[local_atom.sym_index];
         gpa.free(segment.name);
@@ -962,7 +948,7 @@ pub fn freeNav(zig_object: *ZigObject, wasm_file: *Wasm, nav_index: InternPool.N
     if (ip.indexToKey(nav_val) == .@"extern") {
         std.debug.assert(zig_object.imports.remove(atom.sym_index));
     }
-    std.debug.assert(wasm_file.symbol_atom.remove(atom.symbolLoc()));
+    std.debug.assert(wasm.symbol_atom.remove(atom.symbolLoc()));
 
     // if (wasm.dwarf) |*dwarf| {
     //     dwarf.freeDecl(decl_index);
@@ -1014,15 +1000,15 @@ pub fn putOrGetFuncType(zig_object: *ZigObject, gpa: std.mem.Allocator, func_typ
 
 /// Generates an atom containing the global error set' size.
 /// This will only be generated if the symbol exists.
-fn setupErrorsLen(zig_object: *ZigObject, wasm_file: *Wasm) !void {
-    const gpa = wasm_file.base.comp.gpa;
-    const sym_index = zig_object.findGlobalSymbol("__zig_errors_len") orelse return;
+fn setupErrorsLen(zig_object: *ZigObject, wasm: *Wasm) !void {
+    const gpa = wasm.base.comp.gpa;
+    const sym_index = zig_object.global_syms.get(wasm.preloaded_strings.__zig_errors_len) orelse return;
 
-    const errors_len = 1 + wasm_file.base.comp.zcu.?.intern_pool.global_error_set.getNamesFromMainThread().len;
+    const errors_len = 1 + wasm.base.comp.zcu.?.intern_pool.global_error_set.getNamesFromMainThread().len;
     // overwrite existing atom if it already exists (maybe the error set has increased)
     // if not, allocate a new atom.
-    const atom_index = if (wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = sym_index })) |index| blk: {
-        const atom = wasm_file.getAtomPtr(index);
+    const atom_index = if (wasm.symbol_atom.get(.{ .file = .zig_object, .index = sym_index })) |index| blk: {
+        const atom = wasm.getAtomPtr(index);
         atom.prev = .null;
         atom.deinit(gpa);
         break :blk index;
@@ -1036,10 +1022,10 @@ fn setupErrorsLen(zig_object: *ZigObject, wasm_file: *Wasm) !void {
         sym.tag = .data;
         const segment_name = try gpa.dupe(u8, ".rodata.__zig_errors_len");
         sym.index = try zig_object.createDataSegment(gpa, segment_name, .@"2");
-        break :idx try wasm_file.createAtom(sym_index, zig_object.index);
+        break :idx try wasm.createAtom(sym_index, .zig_object);
     };
 
-    const atom = wasm_file.getAtomPtr(atom_index);
+    const atom = wasm.getAtomPtr(atom_index);
     atom.code.clearRetainingCapacity();
     atom.sym_index = sym_index;
     atom.size = 2;
@@ -1047,11 +1033,6 @@ fn setupErrorsLen(zig_object: *ZigObject, wasm_file: *Wasm) !void {
     try atom.code.writer(gpa).writeInt(u16, @intCast(errors_len), .little);
 }
 
-fn findGlobalSymbol(zig_object: *ZigObject, name: []const u8) ?Symbol.Index {
-    const offset = zig_object.string_table.getOffset(name) orelse return null;
-    return zig_object.global_syms.get(offset);
-}
-
 /// Initializes symbols and atoms for the debug sections
 /// Initialization is only done when compiling Zig code.
 /// When Zig is invoked as a linker instead, the atoms
@@ -1073,18 +1054,18 @@ pub fn initDebugSections(zig_object: *ZigObject) !void {
 /// From a given index variable, creates a new debug section.
 /// This initializes the index, appends a new segment,
 /// and finally, creates a managed `Atom`.
-pub fn createDebugSectionForIndex(zig_object: *ZigObject, wasm_file: *Wasm, index: *?u32, name: []const u8) !Atom.Index {
-    const gpa = wasm_file.base.comp.gpa;
+pub fn createDebugSectionForIndex(zig_object: *ZigObject, wasm: *Wasm, index: *?u32, name: []const u8) !Atom.Index {
+    const gpa = wasm.base.comp.gpa;
     const new_index: u32 = @intCast(zig_object.segments.items.len);
     index.* = new_index;
     try zig_object.appendDummySegment();
 
     const sym_index = try zig_object.allocateSymbol(gpa);
-    const atom_index = try wasm_file.createAtom(sym_index, zig_object.index);
-    const atom = wasm_file.getAtomPtr(atom_index);
+    const atom_index = try wasm.createAtom(sym_index, .zig_object);
+    const atom = wasm.getAtomPtr(atom_index);
     zig_object.symbols.items[sym_index] = .{
         .tag = .section,
-        .name = try zig_object.string_table.put(gpa, name),
+        .name = try wasm.internString(name),
         .index = 0,
         .flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),
     };
@@ -1148,13 +1129,13 @@ pub fn storeDeclType(zig_object: *ZigObject, gpa: std.mem.Allocator, nav_index:
 /// The symbols in ZigObject are already represented by an atom as we need to store its data.
 /// So rather than creating a new Atom and returning its index, we use this opportunity to scan
 /// its relocations and create any GOT symbols or function table indexes it may require.
-pub fn parseSymbolIntoAtom(zig_object: *ZigObject, wasm_file: *Wasm, index: Symbol.Index) !Atom.Index {
-    const gpa = wasm_file.base.comp.gpa;
-    const loc: Wasm.SymbolLoc = .{ .file = zig_object.index, .index = index };
-    const atom_index = wasm_file.symbol_atom.get(loc).?;
-    const final_index = try wasm_file.getMatchingSegment(zig_object.index, index);
-    try wasm_file.appendAtomAtIndex(final_index, atom_index);
-    const atom = wasm_file.getAtom(atom_index);
+pub fn parseSymbolIntoAtom(zig_object: *ZigObject, wasm: *Wasm, index: Symbol.Index) !Atom.Index {
+    const gpa = wasm.base.comp.gpa;
+    const loc: Wasm.SymbolLoc = .{ .file = .zig_object, .index = index };
+    const atom_index = wasm.symbol_atom.get(loc).?;
+    const final_index = try wasm.getMatchingSegment(.zig_object, index);
+    try wasm.appendAtomAtIndex(final_index, atom_index);
+    const atom = wasm.getAtom(atom_index);
     for (atom.relocs.items) |reloc| {
         const reloc_index: Symbol.Index = @enumFromInt(reloc.index);
         switch (reloc.relocation_type) {
@@ -1163,8 +1144,8 @@ pub fn parseSymbolIntoAtom(zig_object: *ZigObject, wasm_file: *Wasm, index: Symb
             .R_WASM_TABLE_INDEX_SLEB,
             .R_WASM_TABLE_INDEX_SLEB64,
             => {
-                try wasm_file.function_table.put(gpa, .{
-                    .file = zig_object.index,
+                try wasm.function_table.put(gpa, .{
+                    .file = .zig_object,
                     .index = reloc_index,
                 }, 0);
             },
@@ -1173,8 +1154,8 @@ pub fn parseSymbolIntoAtom(zig_object: *ZigObject, wasm_file: *Wasm, index: Symb
             => {
                 const sym = zig_object.symbol(reloc_index);
                 if (sym.tag != .global) {
-                    try wasm_file.got_symbols.append(gpa, .{
-                        .file = zig_object.index,
+                    try wasm.got_symbols.append(gpa, .{
+                        .file = .zig_object,
                         .index = reloc_index,
                     });
                 }
@@ -1189,22 +1170,22 @@ pub fn parseSymbolIntoAtom(zig_object: *ZigObject, wasm_file: *Wasm, index: Symb
 /// Returns the symbol index of the new function.
 pub fn createFunction(
     zig_object: *ZigObject,
-    wasm_file: *Wasm,
+    wasm: *Wasm,
     symbol_name: []const u8,
     func_ty: std.wasm.Type,
     function_body: *std.ArrayList(u8),
-    relocations: *std.ArrayList(types.Relocation),
+    relocations: *std.ArrayList(Wasm.Relocation),
 ) !Symbol.Index {
-    const gpa = wasm_file.base.comp.gpa;
+    const gpa = wasm.base.comp.gpa;
     const sym_index = try zig_object.allocateSymbol(gpa);
     const sym = zig_object.symbol(sym_index);
     sym.tag = .function;
-    sym.name = try zig_object.string_table.insert(gpa, symbol_name);
+    sym.name = try wasm.internString(symbol_name);
     const type_index = try zig_object.putOrGetFuncType(gpa, func_ty);
     sym.index = try zig_object.appendFunction(gpa, .{ .type_index = type_index });
 
-    const atom_index = try wasm_file.createAtom(sym_index, zig_object.index);
-    const atom = wasm_file.getAtomPtr(atom_index);
+    const atom_index = try wasm.createAtom(sym_index, .zig_object);
+    const atom = wasm.getAtomPtr(atom_index);
     atom.size = @intCast(function_body.items.len);
     atom.code = function_body.moveToUnmanaged();
     atom.relocs = relocations.moveToUnmanaged();
@@ -1227,9 +1208,9 @@ fn appendFunction(zig_object: *ZigObject, gpa: std.mem.Allocator, func: std.wasm
     return index;
 }
 
-pub fn flushModule(zig_object: *ZigObject, wasm_file: *Wasm, tid: Zcu.PerThread.Id) !void {
-    try zig_object.populateErrorNameTable(wasm_file, tid);
-    try zig_object.setupErrorsLen(wasm_file);
+pub fn flushModule(zig_object: *ZigObject, wasm: *Wasm, tid: Zcu.PerThread.Id) !void {
+    try zig_object.populateErrorNameTable(wasm, tid);
+    try zig_object.setupErrorsLen(wasm);
 }
 
 const build_options = @import("build_options");
@@ -1238,16 +1219,14 @@ const codegen = @import("../../codegen.zig");
 const link = @import("../../link.zig");
 const log = std.log.scoped(.zig_object);
 const std = @import("std");
-const types = @import("types.zig");
+const Path = std.Build.Cache.Path;
 
 const Air = @import("../../Air.zig");
-const Atom = @import("Atom.zig");
+const Atom = Wasm.Atom;
 const Dwarf = @import("../Dwarf.zig");
-const File = @import("file.zig").File;
 const InternPool = @import("../../InternPool.zig");
 const Liveness = @import("../../Liveness.zig");
 const Zcu = @import("../../Zcu.zig");
-const StringTable = @import("../StringTable.zig");
 const Symbol = @import("Symbol.zig");
 const Type = @import("../../Type.zig");
 const Value = @import("../../Value.zig");
diff --git a/zig/src/link/Wasm/file.zig b/zig/src/link/Wasm/file.zig
deleted file mode 100644
index e0ff121322..0000000000
--- a/zig/src/link/Wasm/file.zig
+++ /dev/null
@@ -1,132 +0,0 @@
-pub const File = union(enum) {
-    zig_object: *ZigObject,
-    object: *Object,
-
-    pub const Index = enum(u16) {
-        null = std.math.maxInt(u16),
-        _,
-    };
-
-    pub fn path(file: File) []const u8 {
-        return switch (file) {
-            inline else => |obj| obj.path,
-        };
-    }
-
-    pub fn segmentInfo(file: File) []const types.Segment {
-        return switch (file) {
-            .zig_object => |obj| obj.segment_info.items,
-            .object => |obj| obj.segment_info,
-        };
-    }
-
-    pub fn symbol(file: File, index: Symbol.Index) *Symbol {
-        return switch (file) {
-            .zig_object => |obj| &obj.symbols.items[@intFromEnum(index)],
-            .object => |obj| &obj.symtable[@intFromEnum(index)],
-        };
-    }
-
-    pub fn symbols(file: File) []const Symbol {
-        return switch (file) {
-            .zig_object => |obj| obj.symbols.items,
-            .object => |obj| obj.symtable,
-        };
-    }
-
-    pub fn symbolName(file: File, index: Symbol.Index) []const u8 {
-        switch (file) {
-            .zig_object => |obj| {
-                const sym = obj.symbols.items[@intFromEnum(index)];
-                return obj.string_table.get(sym.name).?;
-            },
-            .object => |obj| {
-                const sym = obj.symtable[@intFromEnum(index)];
-                return obj.string_table.get(sym.name);
-            },
-        }
-    }
-
-    pub fn parseSymbolIntoAtom(file: File, wasm_file: *Wasm, index: Symbol.Index) !AtomIndex {
-        return switch (file) {
-            inline else => |obj| obj.parseSymbolIntoAtom(wasm_file, index),
-        };
-    }
-
-    /// For a given symbol index, find its corresponding import.
-    /// Asserts import exists.
-    pub fn import(file: File, symbol_index: Symbol.Index) types.Import {
-        return switch (file) {
-            .zig_object => |obj| obj.imports.get(symbol_index).?,
-            .object => |obj| obj.findImport(obj.symtable[@intFromEnum(symbol_index)]),
-        };
-    }
-
-    /// For a given offset, returns its string value.
-    /// Asserts string exists in the object string table.
-    pub fn string(file: File, offset: u32) []const u8 {
-        return switch (file) {
-            .zig_object => |obj| obj.string_table.get(offset).?,
-            .object => |obj| obj.string_table.get(offset),
-        };
-    }
-
-    pub fn importedGlobals(file: File) u32 {
-        return switch (file) {
-            inline else => |obj| obj.imported_globals_count,
-        };
-    }
-
-    pub fn importedFunctions(file: File) u32 {
-        return switch (file) {
-            inline else => |obj| obj.imported_functions_count,
-        };
-    }
-
-    pub fn importedTables(file: File) u32 {
-        return switch (file) {
-            inline else => |obj| obj.imported_tables_count,
-        };
-    }
-
-    pub fn function(file: File, sym_index: Symbol.Index) std.wasm.Func {
-        switch (file) {
-            .zig_object => |obj| {
-                const sym = obj.symbols.items[@intFromEnum(sym_index)];
-                return obj.functions.items[sym.index];
-            },
-            .object => |obj| {
-                const sym = obj.symtable[@intFromEnum(sym_index)];
-                return obj.functions[sym.index - obj.imported_functions_count];
-            },
-        }
-    }
-
-    pub fn globals(file: File) []const std.wasm.Global {
-        return switch (file) {
-            .zig_object => |obj| obj.globals.items,
-            .object => |obj| obj.globals,
-        };
-    }
-
-    pub fn funcTypes(file: File) []const std.wasm.Type {
-        return switch (file) {
-            .zig_object => |obj| obj.func_types.items,
-            .object => |obj| obj.func_types,
-        };
-    }
-
-    pub const Entry = union(enum) {
-        zig_object: ZigObject,
-        object: Object,
-    };
-};
-
-const std = @import("std");
-const types = @import("types.zig");
-
-const AtomIndex = @import("Atom.zig").Index;
-const Object = @import("Object.zig");
-const Symbol = @import("Symbol.zig");
-const Wasm = @import("../Wasm.zig");
-const ZigObject = @import("ZigObject.zig");
diff --git a/zig/src/link/Wasm/types.zig b/zig/src/link/Wasm/types.zig
deleted file mode 100644
index 93b6835eae..0000000000
--- a/zig/src/link/Wasm/types.zig
+++ /dev/null
@@ -1,267 +0,0 @@
-//! This file contains all constants and related to wasm's object format.
-
-const std = @import("std");
-
-pub const Relocation = struct {
-    /// Represents the type of the `Relocation`
-    relocation_type: RelocationType,
-    /// Offset of the value to rewrite relative to the relevant section's contents.
-    /// When `offset` is zero, its position is immediately after the id and size of the section.
-    offset: u32,
-    /// The index of the symbol used.
-    /// When the type is `R_WASM_TYPE_INDEX_LEB`, it represents the index of the type.
-    index: u32,
-    /// Addend to add to the address.
-    /// This field is only non-zero for `R_WASM_MEMORY_ADDR_*`, `R_WASM_FUNCTION_OFFSET_I32` and `R_WASM_SECTION_OFFSET_I32`.
-    addend: i32 = 0,
-
-    /// All possible relocation types currently existing.
-    /// This enum is exhaustive as the spec is WIP and new types
-    /// can be added which means that a generated binary will be invalid,
-    /// so instead we will show an error in such cases.
-    pub const RelocationType = enum(u8) {
-        R_WASM_FUNCTION_INDEX_LEB = 0,
-        R_WASM_TABLE_INDEX_SLEB = 1,
-        R_WASM_TABLE_INDEX_I32 = 2,
-        R_WASM_MEMORY_ADDR_LEB = 3,
-        R_WASM_MEMORY_ADDR_SLEB = 4,
-        R_WASM_MEMORY_ADDR_I32 = 5,
-        R_WASM_TYPE_INDEX_LEB = 6,
-        R_WASM_GLOBAL_INDEX_LEB = 7,
-        R_WASM_FUNCTION_OFFSET_I32 = 8,
-        R_WASM_SECTION_OFFSET_I32 = 9,
-        R_WASM_EVENT_INDEX_LEB = 10,
-        R_WASM_GLOBAL_INDEX_I32 = 13,
-        R_WASM_MEMORY_ADDR_LEB64 = 14,
-        R_WASM_MEMORY_ADDR_SLEB64 = 15,
-        R_WASM_MEMORY_ADDR_I64 = 16,
-        R_WASM_TABLE_INDEX_SLEB64 = 18,
-        R_WASM_TABLE_INDEX_I64 = 19,
-        R_WASM_TABLE_NUMBER_LEB = 20,
-        R_WASM_MEMORY_ADDR_TLS_SLEB = 21,
-        R_WASM_MEMORY_ADDR_TLS_SLEB64 = 25,
-
-        /// Returns true for relocation types where the `addend` field is present.
-        pub fn addendIsPresent(self: RelocationType) bool {
-            return switch (self) {
-                .R_WASM_MEMORY_ADDR_LEB,
-                .R_WASM_MEMORY_ADDR_SLEB,
-                .R_WASM_MEMORY_ADDR_I32,
-                .R_WASM_MEMORY_ADDR_LEB64,
-                .R_WASM_MEMORY_ADDR_SLEB64,
-                .R_WASM_MEMORY_ADDR_I64,
-                .R_WASM_MEMORY_ADDR_TLS_SLEB,
-                .R_WASM_MEMORY_ADDR_TLS_SLEB64,
-                .R_WASM_FUNCTION_OFFSET_I32,
-                .R_WASM_SECTION_OFFSET_I32,
-                => true,
-                else => false,
-            };
-        }
-    };
-
-    /// Verifies the relocation type of a given `Relocation` and returns
-    /// true when the relocation references a function call or address to a function.
-    pub fn isFunction(self: Relocation) bool {
-        return switch (self.relocation_type) {
-            .R_WASM_FUNCTION_INDEX_LEB,
-            .R_WASM_TABLE_INDEX_SLEB,
-            => true,
-            else => false,
-        };
-    }
-
-    pub fn format(self: Relocation, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
-        _ = fmt;
-        _ = options;
-        try writer.print("{s} offset=0x{x:0>6} symbol={d}", .{
-            @tagName(self.relocation_type),
-            self.offset,
-            self.index,
-        });
-    }
-};
-
-/// Unlike the `Import` object defined by the wasm spec, and existing
-/// in the std.wasm namespace, this construct saves the 'module name' and 'name'
-/// of the import using offsets into a string table, rather than the slices itself.
-/// This saves us (potentially) 24 bytes per import on 64bit machines.
-pub const Import = struct {
-    module_name: u32,
-    name: u32,
-    kind: std.wasm.Import.Kind,
-};
-
-/// Unlike the `Export` object defined by the wasm spec, and existing
-/// in the std.wasm namespace, this construct saves the 'name'
-/// of the export using offsets into a string table, rather than the slice itself.
-/// This saves us (potentially) 12 bytes per export on 64bit machines.
-pub const Export = struct {
-    name: u32,
-    index: u32,
-    kind: std.wasm.ExternalKind,
-};
-
-pub const SubsectionType = enum(u8) {
-    WASM_SEGMENT_INFO = 5,
-    WASM_INIT_FUNCS = 6,
-    WASM_COMDAT_INFO = 7,
-    WASM_SYMBOL_TABLE = 8,
-};
-
-pub const Alignment = @import("../../InternPool.zig").Alignment;
-
-pub const Segment = struct {
-    /// Segment's name, encoded as UTF-8 bytes.
-    name: []const u8,
-    /// The required alignment of the segment, encoded as a power of 2
-    alignment: Alignment,
-    /// Bitfield containing flags for a segment
-    flags: u32,
-
-    pub fn isTLS(segment: Segment) bool {
-        return segment.flags & @intFromEnum(Flags.WASM_SEG_FLAG_TLS) != 0;
-    }
-
-    /// Returns the name as how it will be output into the final object
-    /// file or binary. When `merge_segments` is true, this will return the
-    /// short name. i.e. ".rodata". When false, it returns the entire name instead.
-    pub fn outputName(segment: Segment, merge_segments: bool) []const u8 {
-        if (segment.isTLS()) {
-            return ".tdata";
-        } else if (!merge_segments) {
-            return segment.name;
-        } else if (std.mem.startsWith(u8, segment.name, ".rodata.")) {
-            return ".rodata";
-        } else if (std.mem.startsWith(u8, segment.name, ".text.")) {
-            return ".text";
-        } else if (std.mem.startsWith(u8, segment.name, ".data.")) {
-            return ".data";
-        } else if (std.mem.startsWith(u8, segment.name, ".bss.")) {
-            return ".bss";
-        }
-        return segment.name;
-    }
-
-    pub const Flags = enum(u32) {
-        WASM_SEG_FLAG_STRINGS = 0x1,
-        WASM_SEG_FLAG_TLS = 0x2,
-    };
-};
-
-pub const InitFunc = struct {
-    /// Priority of the init function
-    priority: u32,
-    /// The symbol index of init function (not the function index).
-    symbol_index: u32,
-};
-
-pub const Comdat = struct {
-    name: []const u8,
-    /// Must be zero, no flags are currently defined by the tool-convention.
-    flags: u32,
-    symbols: []const ComdatSym,
-};
-
-pub const ComdatSym = struct {
-    kind: Type,
-    /// Index of the data segment/function/global/event/table within a WASM module.
-    /// The object must not be an import.
-    index: u32,
-
-    pub const Type = enum(u8) {
-        WASM_COMDAT_DATA = 0,
-        WASM_COMDAT_FUNCTION = 1,
-        WASM_COMDAT_GLOBAL = 2,
-        WASM_COMDAT_EVENT = 3,
-        WASM_COMDAT_TABLE = 4,
-        WASM_COMDAT_SECTION = 5,
-    };
-};
-
-pub const Feature = struct {
-    /// Provides information about the usage of the feature.
-    /// - '0x2b' (+): Object uses this feature, and the link fails if feature is not in the allowed set.
-    /// - '0x2d' (-): Object does not use this feature, and the link fails if this feature is in the allowed set.
-    /// - '0x3d' (=): Object uses this feature, and the link fails if this feature is not in the allowed set,
-    /// or if any object does not use this feature.
-    prefix: Prefix,
-    /// Type of the feature, must be unique in the sequence of features.
-    tag: Tag,
-
-    /// Unlike `std.Target.wasm.Feature` this also contains linker-features such as shared-mem
-    pub const Tag = enum {
-        atomics,
-        bulk_memory,
-        exception_handling,
-        extended_const,
-        half_precision,
-        multimemory,
-        multivalue,
-        mutable_globals,
-        nontrapping_fptoint,
-        reference_types,
-        relaxed_simd,
-        sign_ext,
-        simd128,
-        tail_call,
-        shared_mem,
-
-        /// From a given cpu feature, returns its linker feature
-        pub fn fromCpuFeature(feature: std.Target.wasm.Feature) Tag {
-            return @as(Tag, @enumFromInt(@intFromEnum(feature)));
-        }
-
-        pub fn format(tag: Tag, comptime fmt: []const u8, opt: std.fmt.FormatOptions, writer: anytype) !void {
-            _ = fmt;
-            _ = opt;
-            try writer.writeAll(switch (tag) {
-                .atomics => "atomics",
-                .bulk_memory => "bulk-memory",
-                .exception_handling => "exception-handling",
-                .extended_const => "extended-const",
-                .half_precision => "half-precision",
-                .multimemory => "multimemory",
-                .multivalue => "multivalue",
-                .mutable_globals => "mutable-globals",
-                .nontrapping_fptoint => "nontrapping-fptoint",
-                .reference_types => "reference-types",
-                .relaxed_simd => "relaxed-simd",
-                .sign_ext => "sign-ext",
-                .simd128 => "simd128",
-                .tail_call => "tail-call",
-                .shared_mem => "shared-mem",
-            });
-        }
-    };
-
-    pub const Prefix = enum(u8) {
-        used = '+',
-        disallowed = '-',
-        required = '=',
-    };
-
-    pub fn format(feature: Feature, comptime fmt: []const u8, opt: std.fmt.FormatOptions, writer: anytype) !void {
-        _ = opt;
-        _ = fmt;
-        try writer.print("{c} {}", .{ feature.prefix, feature.tag });
-    }
-};
-
-pub const known_features = std.StaticStringMap(Feature.Tag).initComptime(.{
-    .{ "atomics", .atomics },
-    .{ "bulk-memory", .bulk_memory },
-    .{ "exception-handling", .exception_handling },
-    .{ "extended-const", .extended_const },
-    .{ "half-precision", .half_precision },
-    .{ "multimemory", .multimemory },
-    .{ "multivalue", .multivalue },
-    .{ "mutable-globals", .mutable_globals },
-    .{ "nontrapping-fptoint", .nontrapping_fptoint },
-    .{ "reference-types", .reference_types },
-    .{ "relaxed-simd", .relaxed_simd },
-    .{ "sign-ext", .sign_ext },
-    .{ "simd128", .simd128 },
-    .{ "tail-call", .tail_call },
-    .{ "shared-mem", .shared_mem },
-});
diff --git a/zig/src/main.zig b/zig/src/main.zig
index 4e29611d9c..9b245b3eda 100644
--- a/zig/src/main.zig
+++ b/zig/src/main.zig
@@ -15,6 +15,7 @@ const cleanExit = std.process.cleanExit;
 const native_os = builtin.os.tag;
 const Cache = std.Build.Cache;
 const Path = std.Build.Cache.Path;
+const Directory = std.Build.Cache.Directory;
 const EnvVar = std.zig.EnvVar;
 const LibCInstallation = std.zig.LibCInstallation;
 const AstGen = std.zig.AstGen;
@@ -33,7 +34,7 @@ const Zcu = @import("Zcu.zig");
 const mingw = @import("mingw.zig");
 const dev = @import("dev.zig");
 
-pub const std_options = .{
+pub const std_options: std.Options = .{
     .wasiCwd = wasi_cwd,
     .logFn = log,
     .enable_segfault_handler = false,
@@ -55,7 +56,7 @@ pub fn wasi_cwd() std.os.wasi.fd_t {
     return cwd_fd;
 }
 
-fn getWasiPreopen(name: []const u8) Compilation.Directory {
+fn getWasiPreopen(name: []const u8) Directory {
     return .{
         .path = name,
         .handle = .{
@@ -308,10 +309,7 @@ fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
             .server = use_server,
         });
     } else if (mem.eql(u8, cmd, "fmt")) {
-        return jitCmd(gpa, arena, cmd_args, .{
-            .cmd_name = "fmt",
-            .root_src_path = "fmt.zig",
-        });
+        return @import("fmt.zig").run(gpa, arena, cmd_args);
     } else if (mem.eql(u8, cmd, "objcopy")) {
         return jitCmd(gpa, arena, cmd_args, .{
             .cmd_name = "objcopy",
@@ -555,6 +553,8 @@ const usage_build_generic =
     \\  -fno-each-lib-rpath            Prevent adding rpath for each used dynamic library
     \\  -fallow-shlib-undefined        Allows undefined symbols in shared libraries
     \\  -fno-allow-shlib-undefined     Disallows undefined symbols in shared libraries
+    \\  -fallow-so-scripts             Allows .so files to be GNU ld scripts
+    \\  -fno-allow-so-scripts          (default) .so files must be ELF files
     \\  --build-id[=style]             At a minor link-time expense, coordinates stripped binaries
     \\      fast, uuid, sha1, md5      with debug symbols via a '.note.gnu.build-id' section
     \\      0x[hexstring]              Maximum 32 bytes
@@ -766,27 +766,6 @@ const ArgsIterator = struct {
     }
 };
 
-/// In contrast to `link.SystemLib`, this stores arguments that may need to be
-/// resolved into static libraries so that we can pass only dynamic libraries
-/// as system libs to `Compilation`.
-const SystemLib = struct {
-    needed: bool,
-    weak: bool,
-
-    preferred_mode: std.builtin.LinkMode,
-    search_strategy: SearchStrategy,
-
-    const SearchStrategy = enum { paths_first, mode_first, no_fallback };
-
-    fn fallbackMode(this: SystemLib) std.builtin.LinkMode {
-        assert(this.search_strategy != .no_fallback);
-        return switch (this.preferred_mode) {
-            .dynamic => .static,
-            .static => .dynamic,
-        };
-    }
-};
-
 /// Similar to `link.Framework` except it doesn't store yet unresolved
 /// path to the framework.
 const Framework = struct {
@@ -828,7 +807,6 @@ fn buildOutputType(
     var compatibility_version: ?std.SemanticVersion = null;
     var function_sections = false;
     var data_sections = false;
-    var no_builtin = false;
     var listen: Listen = .none;
     var debug_compile_errors = false;
     var verbose_link = (native_os != .wasi or builtin.link_libc) and
@@ -867,6 +845,7 @@ fn buildOutputType(
     var linker_gc_sections: ?bool = null;
     var linker_compress_debug_sections: ?link.File.Elf.CompressDebugSections = null;
     var linker_allow_shlib_undefined: ?bool = null;
+    var allow_so_scripts: bool = false;
     var linker_bind_global_refs_locally: ?bool = null;
     var linker_import_symbols: bool = false;
     var linker_import_table: bool = false;
@@ -919,7 +898,7 @@ fn buildOutputType(
     var hash_style: link.File.Elf.HashStyle = .both;
     var entitlements: ?[]const u8 = null;
     var pagezero_size: ?u64 = null;
-    var lib_search_strategy: SystemLib.SearchStrategy = .paths_first;
+    var lib_search_strategy: link.UnresolvedInput.SearchStrategy = .paths_first;
     var lib_preferred_mode: std.builtin.LinkMode = .dynamic;
     var headerpad_size: ?u32 = null;
     var headerpad_max_install_names: bool = false;
@@ -983,8 +962,10 @@ fn buildOutputType(
         // Populated in the call to `createModule` for the root module.
         .resolved_options = undefined,
 
-        .system_libs = .{},
-        .resolved_system_libs = .{},
+        .cli_link_inputs = .empty,
+        .windows_libs = .empty,
+        .link_inputs = .empty,
+
         .wasi_emulated_libs = .{},
 
         .c_source_files = .{},
@@ -992,7 +973,7 @@ fn buildOutputType(
 
         .llvm_m_args = .{},
         .sysroot = null,
-        .lib_dirs = .{}, // populated by createModule()
+        .lib_directories = .{}, // populated by createModule()
         .lib_dir_args = .{}, // populated from CLI arg parsing
         .libc_installation = null,
         .want_native_include_dirs = false,
@@ -1001,7 +982,6 @@ fn buildOutputType(
         .rpath_list = .{},
         .each_lib_rpath = null,
         .libc_paths_file = try EnvVar.ZIG_LIBC.get(arena),
-        .link_objects = .{},
         .native_system_include_paths = &.{},
     };
 
@@ -1237,30 +1217,42 @@ fn buildOutputType(
                         // We don't know whether this library is part of libc
                         // or libc++ until we resolve the target, so we append
                         // to the list for now.
-                        try create_module.system_libs.put(arena, args_iter.nextOrFatal(), .{
-                            .needed = false,
-                            .weak = false,
-                            .preferred_mode = lib_preferred_mode,
-                            .search_strategy = lib_search_strategy,
-                        });
+                        try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
+                            .name = args_iter.nextOrFatal(),
+                            .query = .{
+                                .needed = false,
+                                .weak = false,
+                                .preferred_mode = lib_preferred_mode,
+                                .search_strategy = lib_search_strategy,
+                                .allow_so_scripts = allow_so_scripts,
+                            },
+                        } });
                     } else if (mem.eql(u8, arg, "--needed-library") or
                         mem.eql(u8, arg, "-needed-l") or
                         mem.eql(u8, arg, "-needed_library"))
                     {
                         const next_arg = args_iter.nextOrFatal();
-                        try create_module.system_libs.put(arena, next_arg, .{
-                            .needed = true,
-                            .weak = false,
-                            .preferred_mode = lib_preferred_mode,
-                            .search_strategy = lib_search_strategy,
-                        });
+                        try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
+                            .name = next_arg,
+                            .query = .{
+                                .needed = true,
+                                .weak = false,
+                                .preferred_mode = lib_preferred_mode,
+                                .search_strategy = lib_search_strategy,
+                                .allow_so_scripts = allow_so_scripts,
+                            },
+                        } });
                     } else if (mem.eql(u8, arg, "-weak_library") or mem.eql(u8, arg, "-weak-l")) {
-                        try create_module.system_libs.put(arena, args_iter.nextOrFatal(), .{
-                            .needed = false,
-                            .weak = true,
-                            .preferred_mode = lib_preferred_mode,
-                            .search_strategy = lib_search_strategy,
-                        });
+                        try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
+                            .name = args_iter.nextOrFatal(),
+                            .query = .{
+                                .needed = false,
+                                .weak = true,
+                                .preferred_mode = lib_preferred_mode,
+                                .search_strategy = lib_search_strategy,
+                                .allow_so_scripts = allow_so_scripts,
+                            },
+                        } });
                     } else if (mem.eql(u8, arg, "-D")) {
                         try cc_argv.appendSlice(arena, &.{ arg, args_iter.nextOrFatal() });
                     } else if (mem.eql(u8, arg, "-I")) {
@@ -1554,9 +1546,9 @@ fn buildOutputType(
                     } else if (mem.eql(u8, arg, "-fno-data-sections")) {
                         data_sections = false;
                     } else if (mem.eql(u8, arg, "-fbuiltin")) {
-                        no_builtin = false;
+                        mod_opts.no_builtin = false;
                     } else if (mem.eql(u8, arg, "-fno-builtin")) {
-                        no_builtin = true;
+                        mod_opts.no_builtin = true;
                     } else if (mem.startsWith(u8, arg, "-fopt-bisect-limit=")) {
                         const next_arg = arg["-fopt-bisect-limit=".len..];
                         llvm_opt_bisect_limit = std.fmt.parseInt(c_int, next_arg, 0) catch |err|
@@ -1573,6 +1565,10 @@ fn buildOutputType(
                         linker_allow_shlib_undefined = true;
                     } else if (mem.eql(u8, arg, "-fno-allow-shlib-undefined")) {
                         linker_allow_shlib_undefined = false;
+                    } else if (mem.eql(u8, arg, "-fallow-so-scripts")) {
+                        allow_so_scripts = true;
+                    } else if (mem.eql(u8, arg, "-fno-allow-so-scripts")) {
+                        allow_so_scripts = false;
                     } else if (mem.eql(u8, arg, "-z")) {
                         const z_arg = args_iter.nextOrFatal();
                         if (mem.eql(u8, z_arg, "nodelete")) {
@@ -1680,26 +1676,38 @@ fn buildOutputType(
                         // We don't know whether this library is part of libc
                         // or libc++ until we resolve the target, so we append
                         // to the list for now.
-                        try create_module.system_libs.put(arena, arg["-l".len..], .{
-                            .needed = false,
-                            .weak = false,
-                            .preferred_mode = lib_preferred_mode,
-                            .search_strategy = lib_search_strategy,
-                        });
+                        try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
+                            .name = arg["-l".len..],
+                            .query = .{
+                                .needed = false,
+                                .weak = false,
+                                .preferred_mode = lib_preferred_mode,
+                                .search_strategy = lib_search_strategy,
+                                .allow_so_scripts = allow_so_scripts,
+                            },
+                        } });
                     } else if (mem.startsWith(u8, arg, "-needed-l")) {
-                        try create_module.system_libs.put(arena, arg["-needed-l".len..], .{
-                            .needed = true,
-                            .weak = false,
-                            .preferred_mode = lib_preferred_mode,
-                            .search_strategy = lib_search_strategy,
-                        });
+                        try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
+                            .name = arg["-needed-l".len..],
+                            .query = .{
+                                .needed = true,
+                                .weak = false,
+                                .preferred_mode = lib_preferred_mode,
+                                .search_strategy = lib_search_strategy,
+                                .allow_so_scripts = allow_so_scripts,
+                            },
+                        } });
                     } else if (mem.startsWith(u8, arg, "-weak-l")) {
-                        try create_module.system_libs.put(arena, arg["-weak-l".len..], .{
-                            .needed = false,
-                            .weak = true,
-                            .preferred_mode = lib_preferred_mode,
-                            .search_strategy = lib_search_strategy,
-                        });
+                        try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
+                            .name = arg["-weak-l".len..],
+                            .query = .{
+                                .needed = false,
+                                .weak = true,
+                                .preferred_mode = lib_preferred_mode,
+                                .search_strategy = lib_search_strategy,
+                                .allow_so_scripts = allow_so_scripts,
+                            },
+                        } });
                     } else if (mem.startsWith(u8, arg, "-D")) {
                         try cc_argv.append(arena, arg);
                     } else if (mem.startsWith(u8, arg, "-I")) {
@@ -1724,15 +1732,28 @@ fn buildOutputType(
                         fatal("unrecognized parameter: '{s}'", .{arg});
                     }
                 } else switch (file_ext orelse Compilation.classifyFileExt(arg)) {
-                    .shared_library => {
-                        try create_module.link_objects.append(arena, .{ .path = Path.initCwd(arg) });
-                        create_module.opts.any_dyn_libs = true;
-                    },
-                    .object, .static_library => {
-                        try create_module.link_objects.append(arena, .{ .path = Path.initCwd(arg) });
+                    .shared_library, .object, .static_library => {
+                        try create_module.cli_link_inputs.append(arena, .{ .path_query = .{
+                            .path = Path.initCwd(arg),
+                            .query = .{
+                                .preferred_mode = lib_preferred_mode,
+                                .search_strategy = lib_search_strategy,
+                                .allow_so_scripts = allow_so_scripts,
+                            },
+                        } });
+                        // We do not set `any_dyn_libs` yet because a .so file
+                        // may actually resolve to a GNU ld script which ends
+                        // up being a static library.
                     },
                     .res => {
-                        try create_module.link_objects.append(arena, .{ .path = Path.initCwd(arg) });
+                        try create_module.cli_link_inputs.append(arena, .{ .path_query = .{
+                            .path = Path.initCwd(arg),
+                            .query = .{
+                                .preferred_mode = lib_preferred_mode,
+                                .search_strategy = lib_search_strategy,
+                                .allow_so_scripts = allow_so_scripts,
+                            },
+                        } });
                         contains_res_file = true;
                     },
                     .manifest => {
@@ -1785,6 +1806,7 @@ fn buildOutputType(
             // some functionality that depend on it, such as C++ exceptions and
             // DWARF-based stack traces.
             link_eh_frame_hdr = true;
+            allow_so_scripts = true;
 
             const COutMode = enum {
                 link,
@@ -1844,24 +1866,32 @@ fn buildOutputType(
                                 .ext = file_ext, // duped while parsing the args.
                             });
                         },
-                        .shared_library => {
-                            try create_module.link_objects.append(arena, .{
+                        .unknown, .object, .static_library, .shared_library => {
+                            try create_module.cli_link_inputs.append(arena, .{ .path_query = .{
                                 .path = Path.initCwd(it.only_arg),
-                                .must_link = must_link,
-                            });
-                            create_module.opts.any_dyn_libs = true;
-                        },
-                        .unknown, .object, .static_library => {
-                            try create_module.link_objects.append(arena, .{
-                                .path = Path.initCwd(it.only_arg),
-                                .must_link = must_link,
-                            });
+                                .query = .{
+                                    .must_link = must_link,
+                                    .needed = needed,
+                                    .preferred_mode = lib_preferred_mode,
+                                    .search_strategy = lib_search_strategy,
+                                    .allow_so_scripts = allow_so_scripts,
+                                },
+                            } });
+                            // We do not set `any_dyn_libs` yet because a .so file
+                            // may actually resolve to a GNU ld script which ends
+                            // up being a static library.
                         },
                         .res => {
-                            try create_module.link_objects.append(arena, .{
+                            try create_module.cli_link_inputs.append(arena, .{ .path_query = .{
                                 .path = Path.initCwd(it.only_arg),
-                                .must_link = must_link,
-                            });
+                                .query = .{
+                                    .must_link = must_link,
+                                    .needed = needed,
+                                    .preferred_mode = lib_preferred_mode,
+                                    .search_strategy = lib_search_strategy,
+                                    .allow_so_scripts = allow_so_scripts,
+                                },
+                            } });
                             contains_res_file = true;
                         },
                         .manifest => {
@@ -1893,19 +1923,21 @@ fn buildOutputType(
                             // -l :path/to/filename is used when callers need
                             // more control over what's in the resulting
                             // binary: no extra rpaths and DSO filename exactly
-                            // as provided. Hello, Go.
-                            try create_module.link_objects.append(arena, .{
-                                .path = Path.initCwd(it.only_arg),
-                                .must_link = must_link,
-                                .loption = true,
-                            });
+                            // as provided. CGo compilation depends on this.
+                            try create_module.cli_link_inputs.append(arena, .{ .dso_exact = .{
+                                .name = it.only_arg,
+                            } });
                         } else {
-                            try create_module.system_libs.put(arena, it.only_arg, .{
-                                .needed = needed,
-                                .weak = false,
-                                .preferred_mode = lib_preferred_mode,
-                                .search_strategy = lib_search_strategy,
-                            });
+                            try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
+                                .name = it.only_arg,
+                                .query = .{
+                                    .needed = needed,
+                                    .weak = false,
+                                    .preferred_mode = lib_preferred_mode,
+                                    .search_strategy = lib_search_strategy,
+                                    .allow_so_scripts = allow_so_scripts,
+                                },
+                            } });
                         }
                     },
                     .ignore => {},
@@ -1927,8 +1959,8 @@ fn buildOutputType(
                     .no_function_sections => function_sections = false,
                     .data_sections => data_sections = true,
                     .no_data_sections => data_sections = false,
-                    .builtin => no_builtin = false,
-                    .no_builtin => no_builtin = true,
+                    .builtin => mod_opts.no_builtin = false,
+                    .no_builtin => mod_opts.no_builtin = true,
                     .color_diagnostics => color = .on,
                     .no_color_diagnostics => color = .off,
                     .stack_check => mod_opts.stack_check = true,
@@ -2174,12 +2206,16 @@ fn buildOutputType(
                     },
                     .force_load_objc => force_load_objc = true,
                     .mingw_unicode_entry_point => mingw_unicode_entry_point = true,
-                    .weak_library => try create_module.system_libs.put(arena, it.only_arg, .{
-                        .needed = false,
-                        .weak = true,
-                        .preferred_mode = lib_preferred_mode,
-                        .search_strategy = lib_search_strategy,
-                    }),
+                    .weak_library => try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
+                        .name = it.only_arg,
+                        .query = .{
+                            .needed = false,
+                            .weak = true,
+                            .preferred_mode = lib_preferred_mode,
+                            .search_strategy = lib_search_strategy,
+                            .allow_so_scripts = allow_so_scripts,
+                        },
+                    } }),
                     .weak_framework => try create_module.frameworks.put(arena, it.only_arg, .{ .weak = true }),
                     .headerpad_max_install_names => headerpad_max_install_names = true,
                     .compress_debug_sections => {
@@ -2482,26 +2518,38 @@ fn buildOutputType(
                 } else if (mem.eql(u8, arg, "-needed_framework")) {
                     try create_module.frameworks.put(arena, linker_args_it.nextOrFatal(), .{ .needed = true });
                 } else if (mem.eql(u8, arg, "-needed_library")) {
-                    try create_module.system_libs.put(arena, linker_args_it.nextOrFatal(), .{
-                        .weak = false,
-                        .needed = true,
-                        .preferred_mode = lib_preferred_mode,
-                        .search_strategy = lib_search_strategy,
-                    });
+                    try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
+                        .name = linker_args_it.nextOrFatal(),
+                        .query = .{
+                            .weak = false,
+                            .needed = true,
+                            .preferred_mode = lib_preferred_mode,
+                            .search_strategy = lib_search_strategy,
+                            .allow_so_scripts = allow_so_scripts,
+                        },
+                    } });
                 } else if (mem.startsWith(u8, arg, "-weak-l")) {
-                    try create_module.system_libs.put(arena, arg["-weak-l".len..], .{
-                        .weak = true,
-                        .needed = false,
-                        .preferred_mode = lib_preferred_mode,
-                        .search_strategy = lib_search_strategy,
-                    });
+                    try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
+                        .name = arg["-weak-l".len..],
+                        .query = .{
+                            .weak = true,
+                            .needed = false,
+                            .preferred_mode = lib_preferred_mode,
+                            .search_strategy = lib_search_strategy,
+                            .allow_so_scripts = allow_so_scripts,
+                        },
+                    } });
                 } else if (mem.eql(u8, arg, "-weak_library")) {
-                    try create_module.system_libs.put(arena, linker_args_it.nextOrFatal(), .{
-                        .weak = true,
-                        .needed = false,
-                        .preferred_mode = lib_preferred_mode,
-                        .search_strategy = lib_search_strategy,
-                    });
+                    try create_module.cli_link_inputs.append(arena, .{ .name_query = .{
+                        .name = linker_args_it.nextOrFatal(),
+                        .query = .{
+                            .weak = true,
+                            .needed = false,
+                            .preferred_mode = lib_preferred_mode,
+                            .search_strategy = lib_search_strategy,
+                            .allow_so_scripts = allow_so_scripts,
+                        },
+                    } });
                 } else if (mem.eql(u8, arg, "-compatibility_version")) {
                     const compat_version = linker_args_it.nextOrFatal();
                     compatibility_version = std.SemanticVersion.parse(compat_version) catch |err| {
@@ -2532,10 +2580,14 @@ fn buildOutputType(
                 } else if (mem.eql(u8, arg, "-install_name")) {
                     install_name = linker_args_it.nextOrFatal();
                 } else if (mem.eql(u8, arg, "-force_load")) {
-                    try create_module.link_objects.append(arena, .{
+                    try create_module.cli_link_inputs.append(arena, .{ .path_query = .{
                         .path = Path.initCwd(linker_args_it.nextOrFatal()),
-                        .must_link = true,
-                    });
+                        .query = .{
+                            .must_link = true,
+                            .preferred_mode = .static,
+                            .search_strategy = .no_fallback,
+                        },
+                    } });
                 } else if (mem.eql(u8, arg, "-hash-style") or
                     mem.eql(u8, arg, "--hash-style"))
                 {
@@ -2665,7 +2717,7 @@ fn buildOutputType(
                 },
             }
             if (create_module.c_source_files.items.len == 0 and
-                create_module.link_objects.items.len == 0 and
+                !anyObjectLinkInputs(create_module.cli_link_inputs.items) and
                 root_src_file == null)
             {
                 // For example `zig cc` and no args should print the "no input files" message.
@@ -2707,8 +2759,11 @@ fn buildOutputType(
             if (create_module.c_source_files.items.len >= 1)
                 break :b create_module.c_source_files.items[0].src_path;
 
-            if (create_module.link_objects.items.len >= 1)
-                break :b create_module.link_objects.items[0].path.sub_path;
+            for (create_module.cli_link_inputs.items) |unresolved_link_input| switch (unresolved_link_input) {
+                // Intentionally includes dynamic libraries provided by file path.
+                .path_query => |pq| break :b pq.path.sub_path,
+                else => continue,
+            };
 
             if (emit_bin == .yes)
                 break :b emit_bin.yes;
@@ -2794,7 +2849,7 @@ fn buildOutputType(
             fatal("unable to find zig self exe path: {s}", .{@errorName(err)});
         };
 
-    var zig_lib_directory: Compilation.Directory = d: {
+    var zig_lib_directory: Directory = d: {
         if (override_lib_dir) |unresolved_lib_dir| {
             const lib_dir = try introspect.resolvePath(arena, unresolved_lib_dir);
             break :d .{
@@ -2815,7 +2870,7 @@ fn buildOutputType(
     };
     defer zig_lib_directory.handle.close();
 
-    var global_cache_directory: Compilation.Directory = l: {
+    var global_cache_directory: Directory = l: {
         if (override_global_cache_dir) |p| {
             break :l .{
                 .handle = try fs.cwd().makeOpenPath(p, .{}),
@@ -2845,7 +2900,7 @@ fn buildOutputType(
 
     var builtin_modules: std.StringHashMapUnmanaged(*Package.Module) = .empty;
     // `builtin_modules` allocated into `arena`, so no deinit
-    const main_mod = try createModule(gpa, arena, &create_module, 0, null, zig_lib_directory, &builtin_modules);
+    const main_mod = try createModule(gpa, arena, &create_module, 0, null, zig_lib_directory, &builtin_modules, color);
     for (create_module.modules.keys(), create_module.modules.values()) |key, cli_mod| {
         if (cli_mod.resolved == null)
             fatal("module '{s}' declared but not used", .{key});
@@ -2939,7 +2994,6 @@ fn buildOutputType(
         }
     }
 
-    // We now repeat part of the process for frameworks.
     var resolved_frameworks = std.ArrayList(Compilation.Framework).init(arena);
 
     if (create_module.frameworks.keys().len > 0) {
@@ -2996,7 +3050,7 @@ fn buildOutputType(
         const total_obj_count = create_module.c_source_files.items.len +
             @intFromBool(root_src_file != null) +
             create_module.rc_source_files.items.len +
-            create_module.link_objects.items.len;
+            link.countObjectInputs(create_module.link_inputs.items);
         if (total_obj_count > 1) {
             fatal("{s} does not support linking multiple objects into one", .{@tagName(target.ofmt)});
         }
@@ -3212,7 +3266,7 @@ fn buildOutputType(
     var cleanup_local_cache_dir: ?fs.Dir = null;
     defer if (cleanup_local_cache_dir) |*dir| dir.close();
 
-    var local_cache_directory: Compilation.Directory = l: {
+    var local_cache_directory: Directory = l: {
         if (override_local_cache_dir) |local_cache_dir_path| {
             const dir = try fs.cwd().makeOpenPath(local_cache_dir_path, .{});
             cleanup_local_cache_dir = dir;
@@ -3349,7 +3403,7 @@ fn buildOutputType(
         .emit_llvm_bc = emit_llvm_bc_resolved.data,
         .emit_docs = emit_docs_resolved.data,
         .emit_implib = emit_implib_resolved.data,
-        .lib_dirs = create_module.lib_dirs.items,
+        .lib_directories = create_module.lib_directories.items,
         .rpath_list = create_module.rpath_list.items,
         .symbol_wrap_set = symbol_wrap_set,
         .c_source_files = create_module.c_source_files.items,
@@ -3357,11 +3411,10 @@ fn buildOutputType(
         .manifest_file = manifest_file,
         .rc_includes = rc_includes,
         .mingw_unicode_entry_point = mingw_unicode_entry_point,
-        .link_objects = create_module.link_objects.items,
+        .link_inputs = create_module.link_inputs.items,
         .framework_dirs = create_module.framework_dirs.items,
         .frameworks = resolved_frameworks.items,
-        .system_lib_names = create_module.resolved_system_libs.items(.name),
-        .system_lib_infos = create_module.resolved_system_libs.items(.lib),
+        .windows_lib_names = create_module.windows_libs.keys(),
         .wasi_emulated_libs = create_module.wasi_emulated_libs.items,
         .want_compiler_rt = want_compiler_rt,
         .hash_style = hash_style,
@@ -3411,7 +3464,6 @@ fn buildOutputType(
         .image_base = image_base,
         .function_sections = function_sections,
         .data_sections = data_sections,
-        .no_builtin = no_builtin,
         .clang_passthrough_mode = clang_passthrough_mode,
         .clang_preprocessor_mode = clang_preprocessor_mode,
         .version = optional_version,
@@ -3630,12 +3682,14 @@ const CreateModule = struct {
     /// This one is used while collecting CLI options. The set of libs is used
     /// directly after computing the target and used to compute link_libc,
     /// link_libcpp, and then the libraries are filtered into
-    /// `external_system_libs` and `resolved_system_libs`.
-    system_libs: std.StringArrayHashMapUnmanaged(SystemLib),
-    resolved_system_libs: std.MultiArrayList(struct {
-        name: []const u8,
-        lib: Compilation.SystemLib,
-    }),
+    /// `unresolved_linker_inputs` and `windows_libs`.
+    cli_link_inputs: std.ArrayListUnmanaged(link.UnresolvedInput),
+    windows_libs: std.StringArrayHashMapUnmanaged(void),
+    /// The local variable `unresolved_link_inputs` is fed into library
+    /// resolution, mutating the input array, and producing this data as
+    /// output. Allocated with gpa.
+    link_inputs: std.ArrayListUnmanaged(link.Input),
+
     wasi_emulated_libs: std.ArrayListUnmanaged(wasi_libc.CrtFile),
 
     c_source_files: std.ArrayListUnmanaged(Compilation.CSourceFile),
@@ -3646,7 +3700,7 @@ const CreateModule = struct {
     /// CPU features.
     llvm_m_args: std.ArrayListUnmanaged([]const u8),
     sysroot: ?[]const u8,
-    lib_dirs: std.ArrayListUnmanaged([]const u8),
+    lib_directories: std.ArrayListUnmanaged(Directory),
     lib_dir_args: std.ArrayListUnmanaged([]const u8),
     libc_installation: ?LibCInstallation,
     want_native_include_dirs: bool,
@@ -3656,7 +3710,6 @@ const CreateModule = struct {
     rpath_list: std.ArrayListUnmanaged([]const u8),
     each_lib_rpath: ?bool,
     libc_paths_file: ?[]const u8,
-    link_objects: std.ArrayListUnmanaged(Compilation.LinkObject),
 };
 
 fn createModule(
@@ -3667,6 +3720,7 @@ fn createModule(
     parent: ?*Package.Module,
     zig_lib_directory: Cache.Directory,
     builtin_modules: *std.StringHashMapUnmanaged(*Package.Module),
+    color: std.zig.Color,
 ) Allocator.Error!*Package.Module {
     const cli_mod = &create_module.modules.values()[index];
     if (cli_mod.resolved) |m| return m;
@@ -3760,85 +3814,83 @@ fn createModule(
         // First, remove libc, libc++, and compiler_rt libraries from the system libraries list.
         // We need to know whether the set of system libraries contains anything besides these
         // to decide whether to trigger native path detection logic.
-        var external_system_libs: std.MultiArrayList(struct {
-            name: []const u8,
-            info: SystemLib,
-        }) = .{};
-        for (create_module.system_libs.keys(), create_module.system_libs.values()) |lib_name, info| {
-            if (target.is_libc_lib_name(lib_name)) {
-                create_module.opts.link_libc = true;
-                continue;
-            }
-            if (target.is_libcpp_lib_name(lib_name)) {
-                create_module.opts.link_libcpp = true;
-                continue;
-            }
-            switch (target_util.classifyCompilerRtLibName(target, lib_name)) {
-                .none => {},
-                .only_libunwind, .both => {
-                    create_module.opts.link_libunwind = true;
+        // Preserves linker input order.
+        var unresolved_link_inputs: std.ArrayListUnmanaged(link.UnresolvedInput) = .empty;
+        try unresolved_link_inputs.ensureUnusedCapacity(arena, create_module.cli_link_inputs.items.len);
+        var any_name_queries_remaining = false;
+        for (create_module.cli_link_inputs.items) |cli_link_input| switch (cli_link_input) {
+            .name_query => |nq| {
+                const lib_name = nq.name;
+                if (std.zig.target.isLibCLibName(target, lib_name)) {
+                    create_module.opts.link_libc = true;
                     continue;
-                },
-                .only_compiler_rt => {
-                    warn("ignoring superfluous library '{s}': this dependency is fulfilled instead by compiler-rt which zig unconditionally provides", .{lib_name});
+                }
+                if (std.zig.target.isLibCxxLibName(target, lib_name)) {
+                    create_module.opts.link_libcpp = true;
                     continue;
-                },
-            }
+                }
+                switch (target_util.classifyCompilerRtLibName(target, lib_name)) {
+                    .none => {},
+                    .only_libunwind, .both => {
+                        create_module.opts.link_libunwind = true;
+                        continue;
+                    },
+                    .only_compiler_rt => {
+                        warn("ignoring superfluous library '{s}': this dependency is fulfilled instead by compiler-rt which zig unconditionally provides", .{lib_name});
+                        continue;
+                    },
+                }
 
-            if (target.isMinGW()) {
-                const exists = mingw.libExists(arena, target, zig_lib_directory, lib_name) catch |err| {
-                    fatal("failed to check zig installation for DLL import libs: {s}", .{
-                        @errorName(err),
-                    });
-                };
-                if (exists) {
-                    try create_module.resolved_system_libs.append(arena, .{
-                        .name = lib_name,
-                        .lib = .{
-                            .needed = true,
-                            .weak = false,
-                            .path = null,
-                        },
-                    });
-                    continue;
+                if (target.isMinGW()) {
+                    const exists = mingw.libExists(arena, target, zig_lib_directory, lib_name) catch |err| {
+                        fatal("failed to check zig installation for DLL import libs: {s}", .{
+                            @errorName(err),
+                        });
+                    };
+                    if (exists) {
+                        try create_module.windows_libs.put(arena, lib_name, {});
+                        continue;
+                    }
                 }
-            }
 
-            if (fs.path.isAbsolute(lib_name)) {
-                fatal("cannot use absolute path as a system library: {s}", .{lib_name});
-            }
+                if (fs.path.isAbsolute(lib_name)) {
+                    fatal("cannot use absolute path as a system library: {s}", .{lib_name});
+                }
 
-            if (target.os.tag == .wasi) {
-                if (wasi_libc.getEmulatedLibCrtFile(lib_name)) |crt_file| {
-                    try create_module.wasi_emulated_libs.append(arena, crt_file);
-                    continue;
+                if (target.os.tag == .wasi) {
+                    if (wasi_libc.getEmulatedLibCrtFile(lib_name)) |crt_file| {
+                        try create_module.wasi_emulated_libs.append(arena, crt_file);
+                        continue;
+                    }
                 }
-            }
+                unresolved_link_inputs.appendAssumeCapacity(cli_link_input);
+                any_name_queries_remaining = true;
+            },
+            else => {
+                unresolved_link_inputs.appendAssumeCapacity(cli_link_input);
+            },
+        }; // After this point, unresolved_link_inputs is used instead of cli_link_inputs.
 
-            try external_system_libs.append(arena, .{
-                .name = lib_name,
-                .info = info,
-            });
-        }
-        // After this point, external_system_libs is used instead of system_libs.
-        if (external_system_libs.len != 0)
-            create_module.want_native_include_dirs = true;
+        if (any_name_queries_remaining) create_module.want_native_include_dirs = true;
 
         // Resolve the library path arguments with respect to sysroot.
+        try create_module.lib_directories.ensureUnusedCapacity(arena, create_module.lib_dir_args.items.len);
         if (create_module.sysroot) |root| {
-            try create_module.lib_dirs.ensureUnusedCapacity(arena, create_module.lib_dir_args.items.len * 2);
-            for (create_module.lib_dir_args.items) |dir| {
-                if (fs.path.isAbsolute(dir)) {
-                    const stripped_dir = dir[fs.path.diskDesignator(dir).len..];
+            for (create_module.lib_dir_args.items) |lib_dir_arg| {
+                if (fs.path.isAbsolute(lib_dir_arg)) {
+                    const stripped_dir = lib_dir_arg[fs.path.diskDesignator(lib_dir_arg).len..];
                     const full_path = try fs.path.join(arena, &[_][]const u8{ root, stripped_dir });
-                    create_module.lib_dirs.appendAssumeCapacity(full_path);
+                    addLibDirectoryWarn(&create_module.lib_directories, full_path);
+                } else {
+                    addLibDirectoryWarn(&create_module.lib_directories, lib_dir_arg);
                 }
-                create_module.lib_dirs.appendAssumeCapacity(dir);
             }
         } else {
-            create_module.lib_dirs = create_module.lib_dir_args;
+            for (create_module.lib_dir_args.items) |lib_dir_arg| {
+                addLibDirectoryWarn(&create_module.lib_directories, lib_dir_arg);
+            }
         }
-        create_module.lib_dir_args = undefined; // From here we use lib_dirs instead.
+        create_module.lib_dir_args = undefined; // From here we use lib_directories instead.
 
         if (resolved_target.is_native_os and target.isDarwin()) {
             // If we want to link against frameworks, we need system headers.
@@ -3847,7 +3899,10 @@ fn createModule(
         }
 
         if (create_module.each_lib_rpath orelse resolved_target.is_native_os) {
-            try create_module.rpath_list.appendSlice(arena, create_module.lib_dirs.items);
+            try create_module.rpath_list.ensureUnusedCapacity(arena, create_module.lib_directories.items.len);
+            for (create_module.lib_directories.items) |lib_directory| {
+                create_module.rpath_list.appendAssumeCapacity(lib_directory.path.?);
+            }
         }
 
         // Trigger native system library path detection if necessary.
@@ -3865,8 +3920,10 @@ fn createModule(
             create_module.native_system_include_paths = try paths.include_dirs.toOwnedSlice(arena);
 
             try create_module.framework_dirs.appendSlice(arena, paths.framework_dirs.items);
-            try create_module.lib_dirs.appendSlice(arena, paths.lib_dirs.items);
             try create_module.rpath_list.appendSlice(arena, paths.rpaths.items);
+
+            try create_module.lib_directories.ensureUnusedCapacity(arena, paths.lib_dirs.items.len);
+            for (paths.lib_dirs.items) |path| addLibDirectoryWarn2(&create_module.lib_directories, path, true);
         }
 
         if (create_module.libc_paths_file) |paths_file| {
@@ -3878,7 +3935,7 @@ fn createModule(
         }
 
         if (builtin.target.os.tag == .windows and (target.abi == .msvc or target.abi == .itanium) and
-            external_system_libs.len != 0)
+            any_name_queries_remaining)
         {
             if (create_module.libc_installation == null) {
                 create_module.libc_installation = LibCInstallation.findNative(.{
@@ -3889,181 +3946,31 @@ fn createModule(
                     fatal("unable to find native libc installation: {s}", .{@errorName(err)});
                 };
 
-                try create_module.lib_dirs.appendSlice(arena, &.{
-                    create_module.libc_installation.?.msvc_lib_dir.?,
-                    create_module.libc_installation.?.kernel32_lib_dir.?,
-                });
-            }
-        }
-
-        // If any libs in this list are statically provided, we omit them from the
-        // resolved list and populate the link_objects array instead.
-        {
-            var test_path = std.ArrayList(u8).init(gpa);
-            defer test_path.deinit();
-
-            var checked_paths = std.ArrayList(u8).init(gpa);
-            defer checked_paths.deinit();
-
-            var failed_libs = std.ArrayList(struct {
-                name: []const u8,
-                strategy: SystemLib.SearchStrategy,
-                checked_paths: []const u8,
-                preferred_mode: std.builtin.LinkMode,
-            }).init(arena);
-
-            syslib: for (external_system_libs.items(.name), external_system_libs.items(.info)) |lib_name, info| {
-                // Checked in the first pass above while looking for libc libraries.
-                assert(!fs.path.isAbsolute(lib_name));
-
-                checked_paths.clearRetainingCapacity();
-
-                switch (info.search_strategy) {
-                    .mode_first, .no_fallback => {
-                        // check for preferred mode
-                        for (create_module.lib_dirs.items) |lib_dir_path| {
-                            if (try accessLibPath(
-                                &test_path,
-                                &checked_paths,
-                                lib_dir_path,
-                                lib_name,
-                                target,
-                                info.preferred_mode,
-                            )) {
-                                const path = Path.initCwd(try arena.dupe(u8, test_path.items));
-                                switch (info.preferred_mode) {
-                                    .static => try create_module.link_objects.append(arena, .{ .path = path }),
-                                    .dynamic => try create_module.resolved_system_libs.append(arena, .{
-                                        .name = lib_name,
-                                        .lib = .{
-                                            .needed = info.needed,
-                                            .weak = info.weak,
-                                            .path = path,
-                                        },
-                                    }),
-                                }
-                                continue :syslib;
-                            }
-                        }
-                        // check for fallback mode
-                        if (info.search_strategy == .no_fallback) {
-                            try failed_libs.append(.{
-                                .name = lib_name,
-                                .strategy = info.search_strategy,
-                                .checked_paths = try arena.dupe(u8, checked_paths.items),
-                                .preferred_mode = info.preferred_mode,
-                            });
-                            continue :syslib;
-                        }
-                        for (create_module.lib_dirs.items) |lib_dir_path| {
-                            if (try accessLibPath(
-                                &test_path,
-                                &checked_paths,
-                                lib_dir_path,
-                                lib_name,
-                                target,
-                                info.fallbackMode(),
-                            )) {
-                                const path = Path.initCwd(try arena.dupe(u8, test_path.items));
-                                switch (info.fallbackMode()) {
-                                    .static => try create_module.link_objects.append(arena, .{ .path = path }),
-                                    .dynamic => try create_module.resolved_system_libs.append(arena, .{
-                                        .name = lib_name,
-                                        .lib = .{
-                                            .needed = info.needed,
-                                            .weak = info.weak,
-                                            .path = path,
-                                        },
-                                    }),
-                                }
-                                continue :syslib;
-                            }
-                        }
-                        try failed_libs.append(.{
-                            .name = lib_name,
-                            .strategy = info.search_strategy,
-                            .checked_paths = try arena.dupe(u8, checked_paths.items),
-                            .preferred_mode = info.preferred_mode,
-                        });
-                        continue :syslib;
-                    },
-                    .paths_first => {
-                        for (create_module.lib_dirs.items) |lib_dir_path| {
-                            // check for preferred mode
-                            if (try accessLibPath(
-                                &test_path,
-                                &checked_paths,
-                                lib_dir_path,
-                                lib_name,
-                                target,
-                                info.preferred_mode,
-                            )) {
-                                const path = Path.initCwd(try arena.dupe(u8, test_path.items));
-                                switch (info.preferred_mode) {
-                                    .static => try create_module.link_objects.append(arena, .{ .path = path }),
-                                    .dynamic => try create_module.resolved_system_libs.append(arena, .{
-                                        .name = lib_name,
-                                        .lib = .{
-                                            .needed = info.needed,
-                                            .weak = info.weak,
-                                            .path = path,
-                                        },
-                                    }),
-                                }
-                                continue :syslib;
-                            }
-
-                            // check for fallback mode
-                            if (try accessLibPath(
-                                &test_path,
-                                &checked_paths,
-                                lib_dir_path,
-                                lib_name,
-                                target,
-                                info.fallbackMode(),
-                            )) {
-                                const path = Path.initCwd(try arena.dupe(u8, test_path.items));
-                                switch (info.fallbackMode()) {
-                                    .static => try create_module.link_objects.append(arena, .{ .path = path }),
-                                    .dynamic => try create_module.resolved_system_libs.append(arena, .{
-                                        .name = lib_name,
-                                        .lib = .{
-                                            .needed = info.needed,
-                                            .weak = info.weak,
-                                            .path = path,
-                                        },
-                                    }),
-                                }
-                                continue :syslib;
-                            }
-                        }
-                        try failed_libs.append(.{
-                            .name = lib_name,
-                            .strategy = info.search_strategy,
-                            .checked_paths = try arena.dupe(u8, checked_paths.items),
-                            .preferred_mode = info.preferred_mode,
-                        });
-                        continue :syslib;
-                    },
-                }
-                @compileError("unreachable");
-            }
-
-            if (failed_libs.items.len > 0) {
-                for (failed_libs.items) |f| {
-                    const searched_paths = if (f.checked_paths.len == 0) " none" else f.checked_paths;
-                    std.log.err("unable to find {s} system library '{s}' using strategy '{s}'. searched paths:{s}", .{
-                        @tagName(f.preferred_mode), f.name, @tagName(f.strategy), searched_paths,
-                    });
-                }
-                process.exit(1);
+                try create_module.lib_directories.ensureUnusedCapacity(arena, 2);
+                addLibDirectoryWarn(&create_module.lib_directories, create_module.libc_installation.?.msvc_lib_dir.?);
+                addLibDirectoryWarn(&create_module.lib_directories, create_module.libc_installation.?.kernel32_lib_dir.?);
             }
         }
-        // After this point, create_module.resolved_system_libs is used instead of
-        // create_module.external_system_libs.
 
-        if (create_module.resolved_system_libs.len != 0)
-            create_module.opts.any_dyn_libs = true;
+        // Destructively mutates but does not transfer ownership of `unresolved_link_inputs`.
+        link.resolveInputs(
+            gpa,
+            arena,
+            target,
+            &unresolved_link_inputs,
+            &create_module.link_inputs,
+            create_module.lib_directories.items,
+            color,
+        ) catch |err| fatal("failed to resolve link inputs: {s}", .{@errorName(err)});
+
+        if (create_module.windows_libs.count() != 0) create_module.opts.any_dyn_libs = true;
+        if (!create_module.opts.any_dyn_libs) for (create_module.link_inputs.items) |item| switch (item) {
+            .dso, .dso_exact => {
+                create_module.opts.any_dyn_libs = true;
+                break;
+            },
+            else => {},
+        };
 
         create_module.resolved_options = Compilation.Config.resolve(create_module.opts) catch |err| switch (err) {
             error.WasiExecModelRequiresWasi => fatal("only WASI OS targets support execution model", .{}),
@@ -4131,7 +4038,7 @@ fn createModule(
     for (cli_mod.deps) |dep| {
         const dep_index = create_module.modules.getIndex(dep.value) orelse
             fatal("module '{s}' depends on non-existent module '{s}'", .{ name, dep.key });
-        const dep_mod = try createModule(gpa, arena, create_module, dep_index, mod, zig_lib_directory, builtin_modules);
+        const dep_mod = try createModule(gpa, arena, create_module, dep_index, mod, zig_lib_directory, builtin_modules, color);
         try mod.deps.put(arena, dep.key, dep_mod);
     }
 
@@ -4996,7 +4903,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
 
     process.raiseFileDescriptorLimit();
 
-    var zig_lib_directory: Compilation.Directory = if (override_lib_dir) |lib_dir| .{
+    var zig_lib_directory: Directory = if (override_lib_dir) |lib_dir| .{
         .path = lib_dir,
         .handle = fs.cwd().openDir(lib_dir, .{}) catch |err| {
             fatal("unable to open zig lib directory from 'zig-lib-dir' argument: '{s}': {s}", .{ lib_dir, @errorName(err) });
@@ -5015,7 +4922,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
     });
     child_argv.items[argv_index_build_file] = build_root.directory.path orelse cwd_path;
 
-    var global_cache_directory: Compilation.Directory = l: {
+    var global_cache_directory: Directory = l: {
         const p = override_global_cache_dir orelse try introspect.resolveGlobalCacheDir(arena);
         break :l .{
             .handle = try fs.cwd().makeOpenPath(p, .{}),
@@ -5026,7 +4933,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
 
     child_argv.items[argv_index_global_cache_dir] = global_cache_directory.path orelse cwd_path;
 
-    var local_cache_directory: Compilation.Directory = l: {
+    var local_cache_directory: Directory = l: {
         if (override_local_cache_dir) |local_cache_dir_path| {
             break :l .{
                 .handle = try fs.cwd().makeOpenPath(local_cache_dir_path, .{}),
@@ -5460,7 +5367,7 @@ fn jitCmd(
     const override_lib_dir: ?[]const u8 = try EnvVar.ZIG_LIB_DIR.get(arena);
     const override_global_cache_dir: ?[]const u8 = try EnvVar.ZIG_GLOBAL_CACHE_DIR.get(arena);
 
-    var zig_lib_directory: Compilation.Directory = if (override_lib_dir) |lib_dir| .{
+    var zig_lib_directory: Directory = if (override_lib_dir) |lib_dir| .{
         .path = lib_dir,
         .handle = fs.cwd().openDir(lib_dir, .{}) catch |err| {
             fatal("unable to open zig lib directory from 'zig-lib-dir' argument: '{s}': {s}", .{ lib_dir, @errorName(err) });
@@ -5470,7 +5377,7 @@ fn jitCmd(
     };
     defer zig_lib_directory.handle.close();
 
-    var global_cache_directory: Compilation.Directory = l: {
+    var global_cache_directory: Directory = l: {
         const p = override_global_cache_dir orelse try introspect.resolveGlobalCacheDir(arena);
         break :l .{
             .handle = try fs.cwd().makeOpenPath(p, .{}),
@@ -6118,6 +6025,7 @@ fn cmdAstCheck(
 
     var file: Zcu.File = .{
         .status = .never_loaded,
+        .prev_status = .never_loaded,
         .source_loaded = false,
         .tree_loaded = false,
         .zir_loaded = false,
@@ -6299,7 +6207,7 @@ fn detectNativeCpuWithLLVM(
     llvm_cpu_name_z: ?[*:0]const u8,
     llvm_cpu_features_opt: ?[*:0]const u8,
 ) !std.Target.Cpu {
-    var result = std.Target.Cpu.baseline(arch);
+    var result = std.Target.Cpu.baseline(arch, builtin.os);
 
     if (llvm_cpu_name_z) |cpu_name_z| {
         const llvm_cpu_name = mem.span(cpu_name_z);
@@ -6441,6 +6349,7 @@ fn cmdDumpZir(
 
     var file: Zcu.File = .{
         .status = .never_loaded,
+        .prev_status = .never_loaded,
         .source_loaded = false,
         .tree_loaded = false,
         .zir_loaded = true,
@@ -6508,6 +6417,7 @@ fn cmdChangelist(
 
     var file: Zcu.File = .{
         .status = .never_loaded,
+        .prev_status = .never_loaded,
         .source_loaded = false,
         .tree_loaded = false,
         .zir_loaded = false,
@@ -6854,86 +6764,6 @@ const ClangSearchSanitizer = struct {
     };
 };
 
-fn accessLibPath(
-    test_path: *std.ArrayList(u8),
-    checked_paths: *std.ArrayList(u8),
-    lib_dir_path: []const u8,
-    lib_name: []const u8,
-    target: std.Target,
-    link_mode: std.builtin.LinkMode,
-) !bool {
-    const sep = fs.path.sep_str;
-
-    if (target.isDarwin() and link_mode == .dynamic) tbd: {
-        // Prefer .tbd over .dylib.
-        test_path.clearRetainingCapacity();
-        try test_path.writer().print("{s}" ++ sep ++ "lib{s}.tbd", .{ lib_dir_path, lib_name });
-        try checked_paths.writer().print("\n  {s}", .{test_path.items});
-        fs.cwd().access(test_path.items, .{}) catch |err| switch (err) {
-            error.FileNotFound => break :tbd,
-            else => |e| fatal("unable to search for tbd library '{s}': {s}", .{
-                test_path.items, @errorName(e),
-            }),
-        };
-        return true;
-    }
-
-    main_check: {
-        test_path.clearRetainingCapacity();
-        try test_path.writer().print("{s}" ++ sep ++ "{s}{s}{s}", .{
-            lib_dir_path,
-            target.libPrefix(),
-            lib_name,
-            switch (link_mode) {
-                .static => target.staticLibSuffix(),
-                .dynamic => target.dynamicLibSuffix(),
-            },
-        });
-        try checked_paths.writer().print("\n  {s}", .{test_path.items});
-        fs.cwd().access(test_path.items, .{}) catch |err| switch (err) {
-            error.FileNotFound => break :main_check,
-            else => |e| fatal("unable to search for {s} library '{s}': {s}", .{
-                @tagName(link_mode), test_path.items, @errorName(e),
-            }),
-        };
-        return true;
-    }
-
-    // In the case of Darwin, the main check will be .dylib, so here we
-    // additionally check for .so files.
-    if (target.isDarwin() and link_mode == .dynamic) so: {
-        test_path.clearRetainingCapacity();
-        try test_path.writer().print("{s}" ++ sep ++ "lib{s}.so", .{ lib_dir_path, lib_name });
-        try checked_paths.writer().print("\n  {s}", .{test_path.items});
-        fs.cwd().access(test_path.items, .{}) catch |err| switch (err) {
-            error.FileNotFound => break :so,
-            else => |e| fatal("unable to search for so library '{s}': {s}", .{
-                test_path.items, @errorName(e),
-            }),
-        };
-        return true;
-    }
-
-    // In the case of MinGW, the main check will be .lib but we also need to
-    // look for `libfoo.a`.
-    if (target.isMinGW() and link_mode == .static) mingw: {
-        test_path.clearRetainingCapacity();
-        try test_path.writer().print("{s}" ++ sep ++ "lib{s}.a", .{
-            lib_dir_path, lib_name,
-        });
-        try checked_paths.writer().print("\n  {s}", .{test_path.items});
-        fs.cwd().access(test_path.items, .{}) catch |err| switch (err) {
-            error.FileNotFound => break :mingw,
-            else => |e| fatal("unable to search for static library '{s}': {s}", .{
-                test_path.items, @errorName(e),
-            }),
-        };
-        return true;
-    }
-
-    return false;
-}
-
 fn accessFrameworkPath(
     test_path: *std.ArrayList(u8),
     checked_paths: *std.ArrayList(u8),
@@ -7054,7 +6884,7 @@ fn cmdFetch(
     });
     defer root_prog_node.end();
 
-    var global_cache_directory: Compilation.Directory = l: {
+    var global_cache_directory: Directory = l: {
         const p = override_global_cache_dir orelse try introspect.resolveGlobalCacheDir(arena);
         break :l .{
             .handle = try fs.cwd().makeOpenPath(p, .{}),
@@ -7631,3 +7461,33 @@ fn handleModArg(
     c_source_files_owner_index.* = create_module.c_source_files.items.len;
     rc_source_files_owner_index.* = create_module.rc_source_files.items.len;
 }
+
+fn anyObjectLinkInputs(link_inputs: []const link.UnresolvedInput) bool {
+    for (link_inputs) |link_input| switch (link_input) {
+        .path_query => |pq| switch (Compilation.classifyFileExt(pq.path.sub_path)) {
+            .object, .static_library, .res => return true,
+            else => continue,
+        },
+        else => continue,
+    };
+    return false;
+}
+
+fn addLibDirectoryWarn(lib_directories: *std.ArrayListUnmanaged(Directory), path: []const u8) void {
+    return addLibDirectoryWarn2(lib_directories, path, false);
+}
+
+fn addLibDirectoryWarn2(
+    lib_directories: *std.ArrayListUnmanaged(Directory),
+    path: []const u8,
+    ignore_not_found: bool,
+) void {
+    lib_directories.appendAssumeCapacity(.{
+        .handle = fs.cwd().openDir(path, .{}) catch |err| {
+            if (err == error.FileNotFound and ignore_not_found) return;
+            warn("unable to open library directory '{s}': {s}", .{ path, @errorName(err) });
+            return;
+        },
+        .path = path,
+    });
+}
diff --git a/zig/src/mingw.zig b/zig/src/mingw.zig
index d26358450c..cdee9acb07 100644
--- a/zig/src/mingw.zig
+++ b/zig/src/mingw.zig
@@ -41,7 +41,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 },
             };
-            return comp.build_crt_file("crt2", .Obj, .@"mingw-w64 crt2.o", prog_node, &files);
+            return comp.build_crt_file("crt2", .Obj, .@"mingw-w64 crt2.o", prog_node, &files, .{});
         },
 
         .dllcrt2_o => {
@@ -56,7 +56,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 },
             };
-            return comp.build_crt_file("dllcrt2", .Obj, .@"mingw-w64 dllcrt2.o", prog_node, &files);
+            return comp.build_crt_file("dllcrt2", .Obj, .@"mingw-w64 dllcrt2.o", prog_node, &files, .{});
         },
 
         .mingw32_lib => {
@@ -118,7 +118,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
             } else {
                 @panic("unsupported arch");
             }
-            return comp.build_crt_file("mingw32", .Lib, .@"mingw-w64 mingw32.lib", prog_node, c_source_files.items);
+            return comp.build_crt_file("mingw32", .Lib, .@"mingw-w64 mingw32.lib", prog_node, c_source_files.items, .{});
         },
     }
 }
@@ -279,11 +279,14 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
 
     if (!build_options.have_llvm) return error.ZigCompilerNotBuiltWithLLVMExtensions;
     const llvm_bindings = @import("codegen/llvm/bindings.zig");
-    const llvm = @import("codegen/llvm.zig");
-    const arch_tag = llvm.targetArch(target.cpu.arch);
     const def_final_path_z = try arena.dupeZ(u8, def_final_path);
     const lib_final_path_z = try comp.global_cache_directory.joinZ(arena, &.{lib_final_path});
-    if (llvm_bindings.WriteImportLibrary(def_final_path_z.ptr, arch_tag, lib_final_path_z.ptr, true)) {
+    if (llvm_bindings.WriteImportLibrary(
+        def_final_path_z.ptr,
+        @intFromEnum(target.toCoffMachine()),
+        lib_final_path_z.ptr,
+        true,
+    )) {
         // TODO surface a proper error here
         log.err("unable to turn {s}.def into {s}.lib", .{ lib_name, lib_name });
         return error.WritingImportLibFailed;
diff --git a/zig/src/musl.zig b/zig/src/musl.zig
index 48717dc5a1..d1b2fd2e2d 100644
--- a/zig/src/musl.zig
+++ b/zig/src/musl.zig
@@ -4,7 +4,6 @@ const mem = std.mem;
 const path = std.fs.path;
 const assert = std.debug.assert;
 const Module = @import("Package/Module.zig");
-const archName = std.zig.target.muslArchName;
 
 const Compilation = @import("Compilation.zig");
 const build_options = @import("build_options");
@@ -19,7 +18,7 @@ pub const CrtFile = enum {
     libc_so,
 };
 
-pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progress.Node) !void {
+pub fn buildCrtFile(comp: *Compilation, in_crt_file: CrtFile, prog_node: std.Progress.Node) !void {
     if (!build_options.have_llvm) {
         return error.ZigCompilerNotBuiltWithLLVMExtensions;
     }
@@ -28,7 +27,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
 
-    switch (crt_file) {
+    switch (in_crt_file) {
         .crti_o => {
             var args = std.ArrayList([]const u8).init(arena);
             try addCcArgs(comp, arena, &args, false);
@@ -39,7 +38,12 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 },
             };
-            return comp.build_crt_file("crti", .Obj, .@"musl crti.o", prog_node, &files);
+            return comp.build_crt_file("crti", .Obj, .@"musl crti.o", prog_node, &files, .{
+                .function_sections = true,
+                .data_sections = true,
+                .omit_frame_pointer = true,
+                .no_builtin = true,
+            });
         },
         .crtn_o => {
             var args = std.ArrayList([]const u8).init(arena);
@@ -51,15 +55,17 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 },
             };
-            return comp.build_crt_file("crtn", .Obj, .@"musl crtn.o", prog_node, &files);
+            return comp.build_crt_file("crtn", .Obj, .@"musl crtn.o", prog_node, &files, .{
+                .function_sections = true,
+                .data_sections = true,
+                .omit_frame_pointer = true,
+                .no_builtin = true,
+            });
         },
         .crt1_o => {
             var args = std.ArrayList([]const u8).init(arena);
             try addCcArgs(comp, arena, &args, false);
-            try args.appendSlice(&[_][]const u8{
-                "-fno-stack-protector",
-                "-DCRT",
-            });
+            try args.append("-DCRT");
             var files = [_]Compilation.CSourceFile{
                 .{
                     .src_path = try comp.zig_lib_directory.join(arena, &[_][]const u8{
@@ -69,16 +75,17 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 },
             };
-            return comp.build_crt_file("crt1", .Obj, .@"musl crt1.o", prog_node, &files);
+            return comp.build_crt_file("crt1", .Obj, .@"musl crt1.o", prog_node, &files, .{
+                .function_sections = true,
+                .data_sections = true,
+                .omit_frame_pointer = true,
+                .no_builtin = true,
+            });
         },
         .rcrt1_o => {
             var args = std.ArrayList([]const u8).init(arena);
             try addCcArgs(comp, arena, &args, false);
-            try args.appendSlice(&[_][]const u8{
-                "-fPIC",
-                "-fno-stack-protector",
-                "-DCRT",
-            });
+            try args.append("-DCRT");
             var files = [_]Compilation.CSourceFile{
                 .{
                     .src_path = try comp.zig_lib_directory.join(arena, &[_][]const u8{
@@ -88,16 +95,18 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 },
             };
-            return comp.build_crt_file("rcrt1", .Obj, .@"musl rcrt1.o", prog_node, &files);
+            return comp.build_crt_file("rcrt1", .Obj, .@"musl rcrt1.o", prog_node, &files, .{
+                .function_sections = true,
+                .data_sections = true,
+                .omit_frame_pointer = true,
+                .pic = true,
+                .no_builtin = true,
+            });
         },
         .scrt1_o => {
             var args = std.ArrayList([]const u8).init(arena);
             try addCcArgs(comp, arena, &args, false);
-            try args.appendSlice(&[_][]const u8{
-                "-fPIC",
-                "-fno-stack-protector",
-                "-DCRT",
-            });
+            try args.append("-DCRT");
             var files = [_]Compilation.CSourceFile{
                 .{
                     .src_path = try comp.zig_lib_directory.join(arena, &[_][]const u8{
@@ -107,13 +116,19 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 },
             };
-            return comp.build_crt_file("Scrt1", .Obj, .@"musl Scrt1.o", prog_node, &files);
+            return comp.build_crt_file("Scrt1", .Obj, .@"musl Scrt1.o", prog_node, &files, .{
+                .function_sections = true,
+                .data_sections = true,
+                .omit_frame_pointer = true,
+                .pic = true,
+                .no_builtin = true,
+            });
         },
         .libc_a => {
             // When there is a src/<arch>/foo.* then it should substitute for src/foo.*
             // Even a .s file can substitute for a .c file.
             const target = comp.getTarget();
-            const arch_name = archName(target.cpu.arch);
+            const arch_name = std.zig.target.muslArchName(target.cpu.arch, target.abi);
             var source_table = std.StringArrayHashMap(Ext).init(comp.gpa);
             defer source_table.deinit();
 
@@ -123,7 +138,17 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                 try addSrcFile(arena, &source_table, src_file);
             }
 
-            const time32_compat_arch_list = [_][]const u8{ "arm", "i386", "mips", "powerpc", "m68k" };
+            const time32_compat_arch_list = [_][]const u8{
+                "arm",
+                "i386",
+                "m68k",
+                "microblaze",
+                "mips",
+                "mipsn32",
+                "or1k",
+                "powerpc",
+                "sh",
+            };
             for (time32_compat_arch_list) |time32_compat_arch| {
                 if (mem.eql(u8, arch_name, time32_compat_arch)) {
                     for (compat_time32_files) |compat_time32_file| {
@@ -152,7 +177,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
 
                 var is_arch_specific = false;
                 // Architecture-specific implementations are under a <arch>/ folder.
-                if (isMuslArchName(dirbasename)) {
+                if (isArchName(dirbasename)) {
                     if (!mem.eql(u8, dirbasename, arch_name))
                         continue; // Not the architecture we're compiling for.
                     is_arch_specific = true;
@@ -190,13 +215,19 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 };
             }
-            return comp.build_crt_file("c", .Lib, .@"musl libc.a", prog_node, c_source_files.items);
+            return comp.build_crt_file("c", .Lib, .@"musl libc.a", prog_node, c_source_files.items, .{
+                .function_sections = true,
+                .data_sections = true,
+                .omit_frame_pointer = true,
+                .no_builtin = true,
+            });
         },
         .libc_so => {
             const optimize_mode = comp.compilerRtOptMode();
             const strip = comp.compilerRtStrip();
+            const output_mode: std.builtin.OutputMode = .Lib;
             const config = try Compilation.Config.resolve(.{
-                .output_mode = .Lib,
+                .output_mode = output_mode,
                 .link_mode = .dynamic,
                 .resolved_target = comp.root_mod.resolved_target,
                 .is_test = false,
@@ -276,31 +307,47 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
 
             try comp.updateSubCompilation(sub_compilation, .@"musl libc.so", prog_node);
 
-            try comp.crt_files.ensureUnusedCapacity(comp.gpa, 1);
-
             const basename = try comp.gpa.dupe(u8, "libc.so");
             errdefer comp.gpa.free(basename);
 
-            comp.crt_files.putAssumeCapacityNoClobber(basename, try sub_compilation.toCrtFile());
+            const crt_file = try sub_compilation.toCrtFile();
+            comp.queueLinkTaskMode(crt_file.full_object_path, output_mode);
+            {
+                comp.mutex.lock();
+                defer comp.mutex.unlock();
+                try comp.crt_files.ensureUnusedCapacity(comp.gpa, 1);
+                comp.crt_files.putAssumeCapacityNoClobber(basename, crt_file);
+            }
         },
     }
 }
 
-// Return true if musl has arch-specific crti/crtn sources.
-// See lib/libc/musl/crt/ARCH/crt?.s .
+/// Return true if musl has arch-specific crti/crtn sources.
+/// See lib/libc/musl/crt/ARCH/crt?.s .
 pub fn needsCrtiCrtn(target: std.Target) bool {
-    // zig fmt: off
     return switch (target.cpu.arch) {
+        .loongarch64,
+        .m68k,
         .riscv32,
         .riscv64,
-        .wasm32, .wasm64 => false,
-        .loongarch64 => false,
+        .wasm32,
+        .wasm64,
+        => false,
         else => true,
     };
-    // zig fmt: on
 }
 
-fn isMuslArchName(name: []const u8) bool {
+pub fn needsCrt0(output_mode: std.builtin.OutputMode, link_mode: std.builtin.LinkMode, pie: bool) ?CrtFile {
+    return switch (output_mode) {
+        .Obj, .Lib => null,
+        .Exe => switch (link_mode) {
+            .dynamic => if (pie) .scrt1_o else .crt1_o,
+            .static => if (pie) .rcrt1_o else .crt1_o,
+        },
+    };
+}
+
+fn isArchName(name: []const u8) bool {
     const musl_arch_names = [_][]const u8{
         "aarch64",
         "arm",
@@ -374,17 +421,18 @@ fn addCcArgs(
     want_O3: bool,
 ) error{OutOfMemory}!void {
     const target = comp.getTarget();
-    const arch_name = archName(target.cpu.arch);
+    const arch_name = std.zig.target.muslArchName(target.cpu.arch, target.abi);
     const os_name = @tagName(target.os.tag);
-    const triple = try std.fmt.allocPrint(arena, "{s}-{s}-musl", .{
-        std.zig.target.muslArchNameHeaders(target.cpu.arch), os_name,
+    const triple = try std.fmt.allocPrint(arena, "{s}-{s}-{s}", .{
+        std.zig.target.muslArchNameHeaders(target.cpu.arch),
+        os_name,
+        std.zig.target.muslAbiNameHeaders(target.abi),
     });
     const o_arg = if (want_O3) "-O3" else "-Os";
 
     try args.appendSlice(&[_][]const u8{
         "-std=c99",
         "-ffreestanding",
-        "-fno-builtin",
         "-fexcess-precision=standard",
         "-frounding-math",
         "-ffp-contract=off",
@@ -415,12 +463,6 @@ fn addCcArgs(
 
         o_arg,
 
-        "-fomit-frame-pointer",
-        "-fno-unwind-tables",
-        "-fno-asynchronous-unwind-tables",
-        "-ffunction-sections",
-        "-fdata-sections",
-
         "-Qunused-arguments",
         "-w", // disable all warnings
     });
@@ -433,7 +475,7 @@ fn addCcArgs(
 fn start_asm_path(comp: *Compilation, arena: Allocator, basename: []const u8) ![]const u8 {
     const target = comp.getTarget();
     return comp.zig_lib_directory.join(arena, &[_][]const u8{
-        "libc", "musl", "crt", archName(target.cpu.arch), basename,
+        "libc", "musl", "crt", std.zig.target.muslArchName(target.cpu.arch, target.abi), basename,
     });
 }
 
@@ -441,8 +483,6 @@ const src_files = [_][]const u8{
     "musl/src/aio/aio.c",
     "musl/src/aio/aio_suspend.c",
     "musl/src/aio/lio_listio.c",
-    "musl/src/complex/__cexp.c",
-    "musl/src/complex/__cexpf.c",
     "musl/src/complex/cabs.c",
     "musl/src/complex/cabsf.c",
     "musl/src/complex/cabsl.c",
@@ -473,7 +513,9 @@ const src_files = [_][]const u8{
     "musl/src/complex/ccoshf.c",
     "musl/src/complex/ccoshl.c",
     "musl/src/complex/ccosl.c",
+    "musl/src/complex/__cexp.c",
     "musl/src/complex/cexp.c",
+    "musl/src/complex/__cexpf.c",
     "musl/src/complex/cexpf.c",
     "musl/src/complex/cexpl.c",
     "musl/src/complex/cimag.c",
@@ -514,8 +556,8 @@ const src_files = [_][]const u8{
     "musl/src/conf/legacy.c",
     "musl/src/conf/pathconf.c",
     "musl/src/conf/sysconf.c",
-    "musl/src/crypt/crypt.c",
     "musl/src/crypt/crypt_blowfish.c",
+    "musl/src/crypt/crypt.c",
     "musl/src/crypt/crypt_des.c",
     "musl/src/crypt/crypt_md5.c",
     "musl/src/crypt/crypt_r.c",
@@ -571,60 +613,60 @@ const src_files = [_][]const u8{
     "musl/src/dirent/seekdir.c",
     "musl/src/dirent/telldir.c",
     "musl/src/dirent/versionsort.c",
+    "musl/src/env/clearenv.c",
     "musl/src/env/__environ.c",
+    "musl/src/env/getenv.c",
     "musl/src/env/__init_tls.c",
     "musl/src/env/__libc_start_main.c",
-    "musl/src/env/__reset_tls.c",
-    "musl/src/env/__stack_chk_fail.c",
-    "musl/src/env/clearenv.c",
-    "musl/src/env/getenv.c",
     "musl/src/env/putenv.c",
+    "musl/src/env/__reset_tls.c",
     "musl/src/env/secure_getenv.c",
     "musl/src/env/setenv.c",
+    "musl/src/env/__stack_chk_fail.c",
     "musl/src/env/unsetenv.c",
     "musl/src/errno/__errno_location.c",
     "musl/src/errno/strerror.c",
-    "musl/src/exit/_Exit.c",
     "musl/src/exit/abort.c",
     "musl/src/exit/abort_lock.c",
     "musl/src/exit/arm/__aeabi_atexit.c",
     "musl/src/exit/assert.c",
-    "musl/src/exit/at_quick_exit.c",
     "musl/src/exit/atexit.c",
+    "musl/src/exit/at_quick_exit.c",
     "musl/src/exit/exit.c",
+    "musl/src/exit/_Exit.c",
     "musl/src/exit/quick_exit.c",
     "musl/src/fcntl/creat.c",
     "musl/src/fcntl/fcntl.c",
-    "musl/src/fcntl/open.c",
     "musl/src/fcntl/openat.c",
+    "musl/src/fcntl/open.c",
     "musl/src/fcntl/posix_fadvise.c",
     "musl/src/fcntl/posix_fallocate.c",
-    "musl/src/fenv/__flt_rounds.c",
     "musl/src/fenv/aarch64/fenv.s",
-    "musl/src/fenv/arm/fenv-hf.S",
     "musl/src/fenv/arm/fenv.c",
+    "musl/src/fenv/arm/fenv-hf.S",
     "musl/src/fenv/fegetexceptflag.c",
     "musl/src/fenv/feholdexcept.c",
     "musl/src/fenv/fenv.c",
     "musl/src/fenv/fesetexceptflag.c",
     "musl/src/fenv/fesetround.c",
     "musl/src/fenv/feupdateenv.c",
+    "musl/src/fenv/__flt_rounds.c",
     "musl/src/fenv/i386/fenv.s",
     "musl/src/fenv/loongarch64/fenv.S",
     "musl/src/fenv/m68k/fenv.c",
-    "musl/src/fenv/mips/fenv-sf.c",
-    "musl/src/fenv/mips/fenv.S",
-    "musl/src/fenv/mips64/fenv-sf.c",
     "musl/src/fenv/mips64/fenv.S",
-    "musl/src/fenv/mipsn32/fenv-sf.c",
+    "musl/src/fenv/mips64/fenv-sf.c",
+    "musl/src/fenv/mips/fenv.S",
+    "musl/src/fenv/mips/fenv-sf.c",
     "musl/src/fenv/mipsn32/fenv.S",
-    "musl/src/fenv/powerpc/fenv-sf.c",
-    "musl/src/fenv/powerpc/fenv.S",
+    "musl/src/fenv/mipsn32/fenv-sf.c",
     "musl/src/fenv/powerpc64/fenv.c",
-    "musl/src/fenv/riscv32/fenv-sf.c",
+    "musl/src/fenv/powerpc/fenv.S",
+    "musl/src/fenv/powerpc/fenv-sf.c",
     "musl/src/fenv/riscv32/fenv.S",
-    "musl/src/fenv/riscv64/fenv-sf.c",
+    "musl/src/fenv/riscv32/fenv-sf.c",
     "musl/src/fenv/riscv64/fenv.S",
+    "musl/src/fenv/riscv64/fenv-sf.c",
     "musl/src/fenv/s390x/fenv.c",
     "musl/src/fenv/sh/fenv-nofpu.c",
     "musl/src/fenv/sh/fenv.S",
@@ -637,8 +679,8 @@ const src_files = [_][]const u8{
     "musl/src/internal/intscan.c",
     "musl/src/internal/libc.c",
     "musl/src/internal/procfdname.c",
-    "musl/src/internal/sh/__shcall.c",
     "musl/src/internal/shgetc.c",
+    "musl/src/internal/sh/__shcall.c",
     "musl/src/internal/syscall_ret.c",
     "musl/src/internal/vdso.c",
     "musl/src/internal/version.c",
@@ -655,19 +697,19 @@ const src_files = [_][]const u8{
     "musl/src/ipc/shmctl.c",
     "musl/src/ipc/shmdt.c",
     "musl/src/ipc/shmget.c",
-    "musl/src/ldso/__dlsym.c",
     "musl/src/ldso/aarch64/dlsym.s",
     "musl/src/ldso/aarch64/tlsdesc.s",
     "musl/src/ldso/arm/dlsym.s",
     "musl/src/ldso/arm/dlsym_time64.S",
     "musl/src/ldso/arm/find_exidx.c",
     "musl/src/ldso/arm/tlsdesc.S",
-    "musl/src/ldso/dl_iterate_phdr.c",
     "musl/src/ldso/dladdr.c",
     "musl/src/ldso/dlclose.c",
     "musl/src/ldso/dlerror.c",
     "musl/src/ldso/dlinfo.c",
+    "musl/src/ldso/dl_iterate_phdr.c",
     "musl/src/ldso/dlopen.c",
+    "musl/src/ldso/__dlsym.c",
     "musl/src/ldso/dlsym.c",
     "musl/src/ldso/i386/dlsym.s",
     "musl/src/ldso/i386/dlsym_time64.S",
@@ -677,16 +719,16 @@ const src_files = [_][]const u8{
     "musl/src/ldso/m68k/dlsym_time64.S",
     "musl/src/ldso/microblaze/dlsym.s",
     "musl/src/ldso/microblaze/dlsym_time64.S",
+    "musl/src/ldso/mips64/dlsym.s",
     "musl/src/ldso/mips/dlsym.s",
     "musl/src/ldso/mips/dlsym_time64.S",
-    "musl/src/ldso/mips64/dlsym.s",
     "musl/src/ldso/mipsn32/dlsym.s",
     "musl/src/ldso/mipsn32/dlsym_time64.S",
     "musl/src/ldso/or1k/dlsym.s",
     "musl/src/ldso/or1k/dlsym_time64.S",
+    "musl/src/ldso/powerpc64/dlsym.s",
     "musl/src/ldso/powerpc/dlsym.s",
     "musl/src/ldso/powerpc/dlsym_time64.S",
-    "musl/src/ldso/powerpc64/dlsym.s",
     "musl/src/ldso/riscv32/dlsym.s",
     "musl/src/ldso/riscv64/dlsym.s",
     "musl/src/ldso/riscv64/tlsdesc.s",
@@ -780,21 +822,21 @@ const src_files = [_][]const u8{
     "musl/src/linux/wait4.c",
     "musl/src/linux/x32/sysinfo.c",
     "musl/src/linux/xattr.c",
-    "musl/src/locale/__lctrans.c",
-    "musl/src/locale/__mo_lookup.c",
     "musl/src/locale/bind_textdomain_codeset.c",
-    "musl/src/locale/c_locale.c",
     "musl/src/locale/catclose.c",
     "musl/src/locale/catgets.c",
     "musl/src/locale/catopen.c",
+    "musl/src/locale/c_locale.c",
     "musl/src/locale/dcngettext.c",
     "musl/src/locale/duplocale.c",
     "musl/src/locale/freelocale.c",
     "musl/src/locale/iconv.c",
     "musl/src/locale/iconv_close.c",
     "musl/src/locale/langinfo.c",
-    "musl/src/locale/locale_map.c",
+    "musl/src/locale/__lctrans.c",
     "musl/src/locale/localeconv.c",
+    "musl/src/locale/locale_map.c",
+    "musl/src/locale/__mo_lookup.c",
     "musl/src/locale/newlocale.c",
     "musl/src/locale/pleval.c",
     "musl/src/locale/setlocale.c",
@@ -821,43 +863,9 @@ const src_files = [_][]const u8{
     "musl/src/malloc/oldmalloc/malloc.c",
     "musl/src/malloc/oldmalloc/malloc_usable_size.c",
     "musl/src/malloc/posix_memalign.c",
-    "musl/src/malloc/realloc.c",
     "musl/src/malloc/reallocarray.c",
+    "musl/src/malloc/realloc.c",
     "musl/src/malloc/replaced.c",
-    "musl/src/math/__cos.c",
-    "musl/src/math/__cosdf.c",
-    "musl/src/math/__cosl.c",
-    "musl/src/math/__expo2.c",
-    "musl/src/math/__expo2f.c",
-    "musl/src/math/__fpclassify.c",
-    "musl/src/math/__fpclassifyf.c",
-    "musl/src/math/__fpclassifyl.c",
-    "musl/src/math/__invtrigl.c",
-    "musl/src/math/__math_divzero.c",
-    "musl/src/math/__math_divzerof.c",
-    "musl/src/math/__math_invalid.c",
-    "musl/src/math/__math_invalidf.c",
-    "musl/src/math/__math_invalidl.c",
-    "musl/src/math/__math_oflow.c",
-    "musl/src/math/__math_oflowf.c",
-    "musl/src/math/__math_uflow.c",
-    "musl/src/math/__math_uflowf.c",
-    "musl/src/math/__math_xflow.c",
-    "musl/src/math/__math_xflowf.c",
-    "musl/src/math/__polevll.c",
-    "musl/src/math/__rem_pio2.c",
-    "musl/src/math/__rem_pio2_large.c",
-    "musl/src/math/__rem_pio2f.c",
-    "musl/src/math/__rem_pio2l.c",
-    "musl/src/math/__signbit.c",
-    "musl/src/math/__signbitf.c",
-    "musl/src/math/__signbitl.c",
-    "musl/src/math/__sin.c",
-    "musl/src/math/__sindf.c",
-    "musl/src/math/__sinl.c",
-    "musl/src/math/__tan.c",
-    "musl/src/math/__tandf.c",
-    "musl/src/math/__tanl.c",
     "musl/src/math/aarch64/ceil.c",
     "musl/src/math/aarch64/ceilf.c",
     "musl/src/math/aarch64/fabs.c",
@@ -906,10 +914,10 @@ const src_files = [_][]const u8{
     "musl/src/math/asinhf.c",
     "musl/src/math/asinhl.c",
     "musl/src/math/asinl.c",
-    "musl/src/math/atan.c",
     "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",
@@ -924,16 +932,18 @@ const src_files = [_][]const u8{
     "musl/src/math/copysign.c",
     "musl/src/math/copysignf.c",
     "musl/src/math/copysignl.c",
+    "musl/src/math/__cos.c",
     "musl/src/math/cos.c",
+    "musl/src/math/__cosdf.c",
     "musl/src/math/cosf.c",
     "musl/src/math/cosh.c",
     "musl/src/math/coshf.c",
     "musl/src/math/coshl.c",
+    "musl/src/math/__cosl.c",
     "musl/src/math/cosl.c",
     "musl/src/math/erf.c",
     "musl/src/math/erff.c",
     "musl/src/math/erfl.c",
-    "musl/src/math/exp.c",
     "musl/src/math/exp10.c",
     "musl/src/math/exp10f.c",
     "musl/src/math/exp10l.c",
@@ -941,12 +951,15 @@ const src_files = [_][]const u8{
     "musl/src/math/exp2f.c",
     "musl/src/math/exp2f_data.c",
     "musl/src/math/exp2l.c",
+    "musl/src/math/exp.c",
     "musl/src/math/exp_data.c",
     "musl/src/math/expf.c",
     "musl/src/math/expl.c",
     "musl/src/math/expm1.c",
     "musl/src/math/expm1f.c",
     "musl/src/math/expm1l.c",
+    "musl/src/math/__expo2.c",
+    "musl/src/math/__expo2f.c",
     "musl/src/math/fabs.c",
     "musl/src/math/fabsf.c",
     "musl/src/math/fabsl.c",
@@ -970,28 +983,30 @@ const src_files = [_][]const u8{
     "musl/src/math/fmod.c",
     "musl/src/math/fmodf.c",
     "musl/src/math/fmodl.c",
+    "musl/src/math/__fpclassify.c",
+    "musl/src/math/__fpclassifyf.c",
+    "musl/src/math/__fpclassifyl.c",
     "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/__invtrigl.s",
-    "musl/src/math/i386/acos.s",
     "musl/src/math/i386/acosf.s",
     "musl/src/math/i386/acosl.s",
-    "musl/src/math/i386/asin.s",
+    "musl/src/math/i386/acos.s",
     "musl/src/math/i386/asinf.s",
     "musl/src/math/i386/asinl.s",
-    "musl/src/math/i386/atan.s",
-    "musl/src/math/i386/atan2.s",
+    "musl/src/math/i386/asin.s",
     "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/ceil.s",
+    "musl/src/math/i386/atan.s",
     "musl/src/math/i386/ceilf.s",
     "musl/src/math/i386/ceill.s",
+    "musl/src/math/i386/ceil.s",
     "musl/src/math/i386/exp2l.s",
     "musl/src/math/i386/exp_ld.s",
     "musl/src/math/i386/expl.s",
@@ -999,59 +1014,61 @@ const src_files = [_][]const u8{
     "musl/src/math/i386/fabs.c",
     "musl/src/math/i386/fabsf.c",
     "musl/src/math/i386/fabsl.c",
-    "musl/src/math/i386/floor.s",
     "musl/src/math/i386/floorf.s",
     "musl/src/math/i386/floorl.s",
+    "musl/src/math/i386/floor.s",
     "musl/src/math/i386/fmod.c",
     "musl/src/math/i386/fmodf.c",
     "musl/src/math/i386/fmodl.c",
-    "musl/src/math/i386/hypot.s",
     "musl/src/math/i386/hypotf.s",
-    "musl/src/math/i386/ldexp.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",
+    "musl/src/math/i386/ldexp.s",
     "musl/src/math/i386/llrint.c",
     "musl/src/math/i386/llrintf.c",
     "musl/src/math/i386/llrintl.c",
-    "musl/src/math/i386/log.s",
-    "musl/src/math/i386/log10.s",
     "musl/src/math/i386/log10f.s",
     "musl/src/math/i386/log10l.s",
-    "musl/src/math/i386/log1p.s",
+    "musl/src/math/i386/log10.s",
     "musl/src/math/i386/log1pf.s",
     "musl/src/math/i386/log1pl.s",
-    "musl/src/math/i386/log2.s",
+    "musl/src/math/i386/log1p.s",
     "musl/src/math/i386/log2f.s",
     "musl/src/math/i386/log2l.s",
+    "musl/src/math/i386/log2.s",
     "musl/src/math/i386/logf.s",
     "musl/src/math/i386/logl.s",
+    "musl/src/math/i386/log.s",
     "musl/src/math/i386/lrint.c",
     "musl/src/math/i386/lrintf.c",
     "musl/src/math/i386/lrintl.c",
     "musl/src/math/i386/remainder.c",
     "musl/src/math/i386/remainderf.c",
     "musl/src/math/i386/remainderl.c",
-    "musl/src/math/i386/remquo.s",
     "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/scalbln.s",
     "musl/src/math/i386/scalblnf.s",
     "musl/src/math/i386/scalblnl.s",
-    "musl/src/math/i386/scalbn.s",
+    "musl/src/math/i386/scalbln.s",
     "musl/src/math/i386/scalbnf.s",
     "musl/src/math/i386/scalbnl.s",
+    "musl/src/math/i386/scalbn.s",
     "musl/src/math/i386/sqrt.c",
     "musl/src/math/i386/sqrtf.c",
     "musl/src/math/i386/sqrtl.c",
-    "musl/src/math/i386/trunc.s",
     "musl/src/math/i386/truncf.s",
     "musl/src/math/i386/truncl.s",
+    "musl/src/math/i386/trunc.s",
     "musl/src/math/ilogb.c",
     "musl/src/math/ilogbf.c",
     "musl/src/math/ilogbl.c",
+    "musl/src/math/__invtrigl.c",
     "musl/src/math/j0.c",
     "musl/src/math/j0f.c",
     "musl/src/math/j1.c",
@@ -1062,17 +1079,16 @@ const src_files = [_][]const u8{
     "musl/src/math/ldexpf.c",
     "musl/src/math/ldexpl.c",
     "musl/src/math/lgamma.c",
-    "musl/src/math/lgamma_r.c",
     "musl/src/math/lgammaf.c",
     "musl/src/math/lgammaf_r.c",
     "musl/src/math/lgammal.c",
+    "musl/src/math/lgamma_r.c",
     "musl/src/math/llrint.c",
     "musl/src/math/llrintf.c",
     "musl/src/math/llrintl.c",
     "musl/src/math/llround.c",
     "musl/src/math/llroundf.c",
     "musl/src/math/llroundl.c",
-    "musl/src/math/log.c",
     "musl/src/math/log10.c",
     "musl/src/math/log10f.c",
     "musl/src/math/log10l.c",
@@ -1084,10 +1100,11 @@ const src_files = [_][]const u8{
     "musl/src/math/log2f.c",
     "musl/src/math/log2f_data.c",
     "musl/src/math/log2l.c",
-    "musl/src/math/log_data.c",
     "musl/src/math/logb.c",
     "musl/src/math/logbf.c",
     "musl/src/math/logbl.c",
+    "musl/src/math/log.c",
+    "musl/src/math/log_data.c",
     "musl/src/math/logf.c",
     "musl/src/math/logf_data.c",
     "musl/src/math/logl.c",
@@ -1098,6 +1115,17 @@ const src_files = [_][]const u8{
     "musl/src/math/lroundf.c",
     "musl/src/math/lroundl.c",
     "musl/src/math/m68k/sqrtl.c",
+    "musl/src/math/__math_divzero.c",
+    "musl/src/math/__math_divzerof.c",
+    "musl/src/math/__math_invalid.c",
+    "musl/src/math/__math_invalidf.c",
+    "musl/src/math/__math_invalidl.c",
+    "musl/src/math/__math_oflow.c",
+    "musl/src/math/__math_oflowf.c",
+    "musl/src/math/__math_uflow.c",
+    "musl/src/math/__math_uflowf.c",
+    "musl/src/math/__math_xflow.c",
+    "musl/src/math/__math_xflowf.c",
     "musl/src/math/mips/fabs.c",
     "musl/src/math/mips/fabsf.c",
     "musl/src/math/mips/sqrt.c",
@@ -1117,14 +1145,9 @@ const src_files = [_][]const u8{
     "musl/src/math/nexttoward.c",
     "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/powerpc/fabs.c",
-    "musl/src/math/powerpc/fabsf.c",
-    "musl/src/math/powerpc/fma.c",
-    "musl/src/math/powerpc/fmaf.c",
-    "musl/src/math/powerpc/sqrt.c",
-    "musl/src/math/powerpc/sqrtf.c",
     "musl/src/math/powerpc64/ceil.c",
     "musl/src/math/powerpc64/ceilf.c",
     "musl/src/math/powerpc64/fabs.c",
@@ -1147,12 +1170,22 @@ const src_files = [_][]const u8{
     "musl/src/math/powerpc64/sqrtf.c",
     "musl/src/math/powerpc64/trunc.c",
     "musl/src/math/powerpc64/truncf.c",
+    "musl/src/math/powerpc/fabs.c",
+    "musl/src/math/powerpc/fabsf.c",
+    "musl/src/math/powerpc/fma.c",
+    "musl/src/math/powerpc/fmaf.c",
+    "musl/src/math/powerpc/sqrt.c",
+    "musl/src/math/powerpc/sqrtf.c",
     "musl/src/math/powf.c",
     "musl/src/math/powf_data.c",
     "musl/src/math/powl.c",
     "musl/src/math/remainder.c",
     "musl/src/math/remainderf.c",
     "musl/src/math/remainderl.c",
+    "musl/src/math/__rem_pio2.c",
+    "musl/src/math/__rem_pio2f.c",
+    "musl/src/math/__rem_pio2_large.c",
+    "musl/src/math/__rem_pio2l.c",
     "musl/src/math/remquo.c",
     "musl/src/math/remquof.c",
     "musl/src/math/remquol.c",
@@ -1220,27 +1253,36 @@ const src_files = [_][]const u8{
     "musl/src/math/scalbn.c",
     "musl/src/math/scalbnf.c",
     "musl/src/math/scalbnl.c",
+    "musl/src/math/__signbit.c",
+    "musl/src/math/__signbitf.c",
+    "musl/src/math/__signbitl.c",
     "musl/src/math/signgam.c",
     "musl/src/math/significand.c",
     "musl/src/math/significandf.c",
+    "musl/src/math/__sin.c",
     "musl/src/math/sin.c",
     "musl/src/math/sincos.c",
     "musl/src/math/sincosf.c",
     "musl/src/math/sincosl.c",
+    "musl/src/math/__sindf.c",
     "musl/src/math/sinf.c",
     "musl/src/math/sinh.c",
     "musl/src/math/sinhf.c",
     "musl/src/math/sinhl.c",
+    "musl/src/math/__sinl.c",
     "musl/src/math/sinl.c",
     "musl/src/math/sqrt.c",
     "musl/src/math/sqrt_data.c",
     "musl/src/math/sqrtf.c",
     "musl/src/math/sqrtl.c",
+    "musl/src/math/__tan.c",
     "musl/src/math/tan.c",
+    "musl/src/math/__tandf.c",
     "musl/src/math/tanf.c",
     "musl/src/math/tanh.c",
     "musl/src/math/tanhf.c",
     "musl/src/math/tanhl.c",
+    "musl/src/math/__tanl.c",
     "musl/src/math/tanl.c",
     "musl/src/math/tgamma.c",
     "musl/src/math/tgammaf.c",
@@ -1248,7 +1290,6 @@ const src_files = [_][]const u8{
     "musl/src/math/trunc.c",
     "musl/src/math/truncf.c",
     "musl/src/math/truncl.c",
-    "musl/src/math/x32/__invtrigl.s",
     "musl/src/math/x32/acosl.s",
     "musl/src/math/x32/asinl.s",
     "musl/src/math/x32/atan2l.s",
@@ -1257,30 +1298,30 @@ const src_files = [_][]const u8{
     "musl/src/math/x32/exp2l.s",
     "musl/src/math/x32/expl.s",
     "musl/src/math/x32/expm1l.s",
-    "musl/src/math/x32/fabs.s",
     "musl/src/math/x32/fabsf.s",
     "musl/src/math/x32/fabsl.s",
+    "musl/src/math/x32/fabs.s",
     "musl/src/math/x32/floorl.s",
     "musl/src/math/x32/fma.c",
     "musl/src/math/x32/fmaf.c",
     "musl/src/math/x32/fmodl.s",
-    "musl/src/math/x32/llrint.s",
+    "musl/src/math/x32/__invtrigl.s",
     "musl/src/math/x32/llrintf.s",
     "musl/src/math/x32/llrintl.s",
+    "musl/src/math/x32/llrint.s",
     "musl/src/math/x32/log10l.s",
     "musl/src/math/x32/log1pl.s",
     "musl/src/math/x32/log2l.s",
     "musl/src/math/x32/logl.s",
-    "musl/src/math/x32/lrint.s",
     "musl/src/math/x32/lrintf.s",
     "musl/src/math/x32/lrintl.s",
+    "musl/src/math/x32/lrint.s",
     "musl/src/math/x32/remainderl.s",
     "musl/src/math/x32/rintl.s",
-    "musl/src/math/x32/sqrt.s",
     "musl/src/math/x32/sqrtf.s",
     "musl/src/math/x32/sqrtl.s",
+    "musl/src/math/x32/sqrt.s",
     "musl/src/math/x32/truncl.s",
-    "musl/src/math/x86_64/__invtrigl.s",
     "musl/src/math/x86_64/acosl.s",
     "musl/src/math/x86_64/asinl.s",
     "musl/src/math/x86_64/atan2l.s",
@@ -1296,6 +1337,7 @@ const src_files = [_][]const u8{
     "musl/src/math/x86_64/fma.c",
     "musl/src/math/x86_64/fmaf.c",
     "musl/src/math/x86_64/fmodl.c",
+    "musl/src/math/x86_64/__invtrigl.s",
     "musl/src/math/x86_64/llrint.c",
     "musl/src/math/x86_64/llrintf.c",
     "musl/src/math/x86_64/llrintl.c",
@@ -1321,8 +1363,8 @@ const src_files = [_][]const u8{
     "musl/src/misc/ffsll.c",
     "musl/src/misc/fmtmsg.c",
     "musl/src/misc/forkpty.c",
-    "musl/src/misc/get_current_dir_name.c",
     "musl/src/misc/getauxval.c",
+    "musl/src/misc/get_current_dir_name.c",
     "musl/src/misc/getdomainname.c",
     "musl/src/misc/getentropy.c",
     "musl/src/misc/gethostid.c",
@@ -1354,14 +1396,14 @@ const src_files = [_][]const u8{
     "musl/src/misc/wordexp.c",
     "musl/src/mman/madvise.c",
     "musl/src/mman/mincore.c",
-    "musl/src/mman/mlock.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/munlock.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",
@@ -1395,8 +1437,8 @@ const src_files = [_][]const u8{
     "musl/src/multibyte/wcstombs.c",
     "musl/src/multibyte/wctob.c",
     "musl/src/multibyte/wctomb.c",
-    "musl/src/network/accept.c",
     "musl/src/network/accept4.c",
+    "musl/src/network/accept.c",
     "musl/src/network/bind.c",
     "musl/src/network/connect.c",
     "musl/src/network/dn_comp.c",
@@ -1410,9 +1452,9 @@ const src_files = [_][]const u8{
     "musl/src/network/getaddrinfo.c",
     "musl/src/network/gethostbyaddr.c",
     "musl/src/network/gethostbyaddr_r.c",
-    "musl/src/network/gethostbyname.c",
     "musl/src/network/gethostbyname2.c",
     "musl/src/network/gethostbyname2_r.c",
+    "musl/src/network/gethostbyname.c",
     "musl/src/network/gethostbyname_r.c",
     "musl/src/network/getifaddrs.c",
     "musl/src/network/getnameinfo.c",
@@ -1457,11 +1499,11 @@ const src_files = [_][]const u8{
     "musl/src/network/res_init.c",
     "musl/src/network/res_mkquery.c",
     "musl/src/network/res_msend.c",
+    "musl/src/network/resolvconf.c",
     "musl/src/network/res_query.c",
     "musl/src/network/res_querydomain.c",
     "musl/src/network/res_send.c",
     "musl/src/network/res_state.c",
-    "musl/src/network/resolvconf.c",
     "musl/src/network/send.c",
     "musl/src/network/sendmmsg.c",
     "musl/src/network/sendmsg.c",
@@ -1476,14 +1518,14 @@ const src_files = [_][]const u8{
     "musl/src/passwd/fgetpwent.c",
     "musl/src/passwd/fgetspent.c",
     "musl/src/passwd/getgr_a.c",
-    "musl/src/passwd/getgr_r.c",
-    "musl/src/passwd/getgrent.c",
     "musl/src/passwd/getgrent_a.c",
+    "musl/src/passwd/getgrent.c",
     "musl/src/passwd/getgrouplist.c",
+    "musl/src/passwd/getgr_r.c",
     "musl/src/passwd/getpw_a.c",
-    "musl/src/passwd/getpw_r.c",
-    "musl/src/passwd/getpwent.c",
     "musl/src/passwd/getpwent_a.c",
+    "musl/src/passwd/getpwent.c",
+    "musl/src/passwd/getpw_r.c",
     "musl/src/passwd/getspent.c",
     "musl/src/passwd/getspnam.c",
     "musl/src/passwd/getspnam_r.c",
@@ -1492,18 +1534,17 @@ const src_files = [_][]const u8{
     "musl/src/passwd/putgrent.c",
     "musl/src/passwd/putpwent.c",
     "musl/src/passwd/putspent.c",
-    "musl/src/prng/__rand48_step.c",
-    "musl/src/prng/__seed48.c",
     "musl/src/prng/drand48.c",
     "musl/src/prng/lcong48.c",
     "musl/src/prng/lrand48.c",
     "musl/src/prng/mrand48.c",
+    "musl/src/prng/__rand48_step.c",
     "musl/src/prng/rand.c",
-    "musl/src/prng/rand_r.c",
     "musl/src/prng/random.c",
+    "musl/src/prng/rand_r.c",
+    "musl/src/prng/__seed48.c",
     "musl/src/prng/seed48.c",
     "musl/src/prng/srand48.c",
-    "musl/src/process/_Fork.c",
     "musl/src/process/aarch64/vfork.s",
     "musl/src/process/arm/vfork.s",
     "musl/src/process/execl.c",
@@ -1514,15 +1555,8 @@ const src_files = [_][]const u8{
     "musl/src/process/execvp.c",
     "musl/src/process/fexecve.c",
     "musl/src/process/fork.c",
+    "musl/src/process/_Fork.c",
     "musl/src/process/i386/vfork.s",
-    "musl/src/process/posix_spawn.c",
-    "musl/src/process/posix_spawn_file_actions_addchdir.c",
-    "musl/src/process/posix_spawn_file_actions_addclose.c",
-    "musl/src/process/posix_spawn_file_actions_adddup2.c",
-    "musl/src/process/posix_spawn_file_actions_addfchdir.c",
-    "musl/src/process/posix_spawn_file_actions_addopen.c",
-    "musl/src/process/posix_spawn_file_actions_destroy.c",
-    "musl/src/process/posix_spawn_file_actions_init.c",
     "musl/src/process/posix_spawnattr_destroy.c",
     "musl/src/process/posix_spawnattr_getflags.c",
     "musl/src/process/posix_spawnattr_getpgroup.c",
@@ -1534,6 +1568,14 @@ const src_files = [_][]const u8{
     "musl/src/process/posix_spawnattr_setpgroup.c",
     "musl/src/process/posix_spawnattr_setsigdefault.c",
     "musl/src/process/posix_spawnattr_setsigmask.c",
+    "musl/src/process/posix_spawn.c",
+    "musl/src/process/posix_spawn_file_actions_addchdir.c",
+    "musl/src/process/posix_spawn_file_actions_addclose.c",
+    "musl/src/process/posix_spawn_file_actions_adddup2.c",
+    "musl/src/process/posix_spawn_file_actions_addfchdir.c",
+    "musl/src/process/posix_spawn_file_actions_addopen.c",
+    "musl/src/process/posix_spawn_file_actions_destroy.c",
+    "musl/src/process/posix_spawn_file_actions_init.c",
     "musl/src/process/posix_spawnp.c",
     "musl/src/process/riscv64/vfork.s",
     "musl/src/process/s390x/vfork.s",
@@ -1553,9 +1595,9 @@ const src_files = [_][]const u8{
     "musl/src/regex/tre-mem.c",
     "musl/src/sched/affinity.c",
     "musl/src/sched/sched_cpucount.c",
-    "musl/src/sched/sched_get_priority_max.c",
     "musl/src/sched/sched_getcpu.c",
     "musl/src/sched/sched_getparam.c",
+    "musl/src/sched/sched_get_priority_max.c",
     "musl/src/sched/sched_getscheduler.c",
     "musl/src/sched/sched_rr_get_interval.c",
     "musl/src/sched/sched_setparam.c",
@@ -1586,18 +1628,18 @@ const src_files = [_][]const u8{
     "musl/src/setjmp/m68k/setjmp.s",
     "musl/src/setjmp/microblaze/longjmp.s",
     "musl/src/setjmp/microblaze/setjmp.s",
-    "musl/src/setjmp/mips/longjmp.S",
-    "musl/src/setjmp/mips/setjmp.S",
     "musl/src/setjmp/mips64/longjmp.S",
     "musl/src/setjmp/mips64/setjmp.S",
+    "musl/src/setjmp/mips/longjmp.S",
     "musl/src/setjmp/mipsn32/longjmp.S",
     "musl/src/setjmp/mipsn32/setjmp.S",
+    "musl/src/setjmp/mips/setjmp.S",
     "musl/src/setjmp/or1k/longjmp.s",
     "musl/src/setjmp/or1k/setjmp.s",
-    "musl/src/setjmp/powerpc/longjmp.S",
-    "musl/src/setjmp/powerpc/setjmp.S",
     "musl/src/setjmp/powerpc64/longjmp.s",
     "musl/src/setjmp/powerpc64/setjmp.s",
+    "musl/src/setjmp/powerpc/longjmp.S",
+    "musl/src/setjmp/powerpc/setjmp.S",
     "musl/src/setjmp/riscv32/longjmp.S",
     "musl/src/setjmp/riscv32/setjmp.S",
     "musl/src/setjmp/riscv64/longjmp.S",
@@ -1626,14 +1668,14 @@ const src_files = [_][]const u8{
     "musl/src/signal/m68k/sigsetjmp.s",
     "musl/src/signal/microblaze/restore.s",
     "musl/src/signal/microblaze/sigsetjmp.s",
-    "musl/src/signal/mips/sigsetjmp.s",
     "musl/src/signal/mips64/sigsetjmp.s",
     "musl/src/signal/mipsn32/sigsetjmp.s",
+    "musl/src/signal/mips/sigsetjmp.s",
     "musl/src/signal/or1k/sigsetjmp.s",
-    "musl/src/signal/powerpc/restore.s",
-    "musl/src/signal/powerpc/sigsetjmp.s",
     "musl/src/signal/powerpc64/restore.s",
     "musl/src/signal/powerpc64/sigsetjmp.s",
+    "musl/src/signal/powerpc/restore.s",
+    "musl/src/signal/powerpc/sigsetjmp.s",
     "musl/src/signal/psiginfo.c",
     "musl/src/signal/psignal.c",
     "musl/src/signal/raise.c",
@@ -1682,47 +1724,34 @@ const src_files = [_][]const u8{
     "musl/src/signal/x32/sigsetjmp.s",
     "musl/src/signal/x86_64/restore.s",
     "musl/src/signal/x86_64/sigsetjmp.s",
-    "musl/src/stat/__xstat.c",
     "musl/src/stat/chmod.c",
-    "musl/src/stat/fchmod.c",
     "musl/src/stat/fchmodat.c",
-    "musl/src/stat/fstat.c",
+    "musl/src/stat/fchmod.c",
     "musl/src/stat/fstatat.c",
+    "musl/src/stat/fstat.c",
     "musl/src/stat/futimens.c",
     "musl/src/stat/futimesat.c",
     "musl/src/stat/lchmod.c",
     "musl/src/stat/lstat.c",
-    "musl/src/stat/mkdir.c",
     "musl/src/stat/mkdirat.c",
-    "musl/src/stat/mkfifo.c",
+    "musl/src/stat/mkdir.c",
     "musl/src/stat/mkfifoat.c",
-    "musl/src/stat/mknod.c",
+    "musl/src/stat/mkfifo.c",
     "musl/src/stat/mknodat.c",
+    "musl/src/stat/mknod.c",
     "musl/src/stat/stat.c",
     "musl/src/stat/statvfs.c",
     "musl/src/stat/umask.c",
     "musl/src/stat/utimensat.c",
-    "musl/src/stdio/__fclose_ca.c",
-    "musl/src/stdio/__fdopen.c",
-    "musl/src/stdio/__fmodeflags.c",
-    "musl/src/stdio/__fopen_rb_ca.c",
-    "musl/src/stdio/__lockfile.c",
-    "musl/src/stdio/__overflow.c",
-    "musl/src/stdio/__stdio_close.c",
-    "musl/src/stdio/__stdio_exit.c",
-    "musl/src/stdio/__stdio_read.c",
-    "musl/src/stdio/__stdio_seek.c",
-    "musl/src/stdio/__stdio_write.c",
-    "musl/src/stdio/__stdout_write.c",
-    "musl/src/stdio/__toread.c",
-    "musl/src/stdio/__towrite.c",
-    "musl/src/stdio/__uflow.c",
+    "musl/src/stat/__xstat.c",
     "musl/src/stdio/asprintf.c",
     "musl/src/stdio/clearerr.c",
     "musl/src/stdio/dprintf.c",
-    "musl/src/stdio/ext.c",
     "musl/src/stdio/ext2.c",
+    "musl/src/stdio/ext.c",
     "musl/src/stdio/fclose.c",
+    "musl/src/stdio/__fclose_ca.c",
+    "musl/src/stdio/__fdopen.c",
     "musl/src/stdio/feof.c",
     "musl/src/stdio/ferror.c",
     "musl/src/stdio/fflush.c",
@@ -1735,8 +1764,10 @@ const src_files = [_][]const u8{
     "musl/src/stdio/fileno.c",
     "musl/src/stdio/flockfile.c",
     "musl/src/stdio/fmemopen.c",
+    "musl/src/stdio/__fmodeflags.c",
     "musl/src/stdio/fopen.c",
     "musl/src/stdio/fopencookie.c",
+    "musl/src/stdio/__fopen_rb_ca.c",
     "musl/src/stdio/fprintf.c",
     "musl/src/stdio/fputc.c",
     "musl/src/stdio/fputs.c",
@@ -1755,27 +1786,29 @@ const src_files = [_][]const u8{
     "musl/src/stdio/fwrite.c",
     "musl/src/stdio/fwscanf.c",
     "musl/src/stdio/getc.c",
-    "musl/src/stdio/getc_unlocked.c",
     "musl/src/stdio/getchar.c",
     "musl/src/stdio/getchar_unlocked.c",
+    "musl/src/stdio/getc_unlocked.c",
     "musl/src/stdio/getdelim.c",
     "musl/src/stdio/getline.c",
     "musl/src/stdio/gets.c",
     "musl/src/stdio/getw.c",
     "musl/src/stdio/getwc.c",
     "musl/src/stdio/getwchar.c",
-    "musl/src/stdio/ofl.c",
+    "musl/src/stdio/__lockfile.c",
     "musl/src/stdio/ofl_add.c",
+    "musl/src/stdio/ofl.c",
     "musl/src/stdio/open_memstream.c",
     "musl/src/stdio/open_wmemstream.c",
+    "musl/src/stdio/__overflow.c",
     "musl/src/stdio/pclose.c",
     "musl/src/stdio/perror.c",
     "musl/src/stdio/popen.c",
     "musl/src/stdio/printf.c",
     "musl/src/stdio/putc.c",
-    "musl/src/stdio/putc_unlocked.c",
     "musl/src/stdio/putchar.c",
     "musl/src/stdio/putchar_unlocked.c",
+    "musl/src/stdio/putc_unlocked.c",
     "musl/src/stdio/puts.c",
     "musl/src/stdio/putw.c",
     "musl/src/stdio/putwc.c",
@@ -1793,12 +1826,21 @@ const src_files = [_][]const u8{
     "musl/src/stdio/sscanf.c",
     "musl/src/stdio/stderr.c",
     "musl/src/stdio/stdin.c",
+    "musl/src/stdio/__stdio_close.c",
+    "musl/src/stdio/__stdio_exit.c",
+    "musl/src/stdio/__stdio_read.c",
+    "musl/src/stdio/__stdio_seek.c",
+    "musl/src/stdio/__stdio_write.c",
     "musl/src/stdio/stdout.c",
+    "musl/src/stdio/__stdout_write.c",
     "musl/src/stdio/swprintf.c",
     "musl/src/stdio/swscanf.c",
     "musl/src/stdio/tempnam.c",
     "musl/src/stdio/tmpfile.c",
     "musl/src/stdio/tmpnam.c",
+    "musl/src/stdio/__toread.c",
+    "musl/src/stdio/__towrite.c",
+    "musl/src/stdio/__uflow.c",
     "musl/src/stdio/ungetc.c",
     "musl/src/stdio/ungetwc.c",
     "musl/src/stdio/vasprintf.c",
@@ -1925,13 +1967,13 @@ const src_files = [_][]const u8{
     "musl/src/string/x86_64/memcpy.s",
     "musl/src/string/x86_64/memmove.s",
     "musl/src/string/x86_64/memset.s",
-    "musl/src/temp/__randname.c",
     "musl/src/temp/mkdtemp.c",
     "musl/src/temp/mkostemp.c",
     "musl/src/temp/mkostemps.c",
     "musl/src/temp/mkstemp.c",
     "musl/src/temp/mkstemps.c",
     "musl/src/temp/mktemp.c",
+    "musl/src/temp/__randname.c",
     "musl/src/termios/cfgetospeed.c",
     "musl/src/termios/cfmakeraw.c",
     "musl/src/termios/cfsetospeed.c",
@@ -1944,23 +1986,16 @@ const src_files = [_][]const u8{
     "musl/src/termios/tcsendbreak.c",
     "musl/src/termios/tcsetattr.c",
     "musl/src/termios/tcsetwinsize.c",
-    "musl/src/thread/__lock.c",
-    "musl/src/thread/__set_thread_area.c",
-    "musl/src/thread/__syscall_cp.c",
-    "musl/src/thread/__timedwait.c",
-    "musl/src/thread/__tls_get_addr.c",
-    "musl/src/thread/__unmapself.c",
-    "musl/src/thread/__wait.c",
-    "musl/src/thread/aarch64/__set_thread_area.s",
-    "musl/src/thread/aarch64/__unmapself.s",
     "musl/src/thread/aarch64/clone.s",
+    "musl/src/thread/aarch64/__set_thread_area.s",
     "musl/src/thread/aarch64/syscall_cp.s",
+    "musl/src/thread/aarch64/__unmapself.s",
     "musl/src/thread/arm/__aeabi_read_tp.s",
-    "musl/src/thread/arm/__set_thread_area.c",
-    "musl/src/thread/arm/__unmapself.s",
     "musl/src/thread/arm/atomics.s",
     "musl/src/thread/arm/clone.s",
+    "musl/src/thread/arm/__set_thread_area.c",
     "musl/src/thread/arm/syscall_cp.s",
+    "musl/src/thread/arm/__unmapself.s",
     "musl/src/thread/call_once.c",
     "musl/src/thread/clone.c",
     "musl/src/thread/cnd_broadcast.c",
@@ -1970,50 +2005,51 @@ const src_files = [_][]const u8{
     "musl/src/thread/cnd_timedwait.c",
     "musl/src/thread/cnd_wait.c",
     "musl/src/thread/default_attr.c",
-    "musl/src/thread/i386/__set_thread_area.s",
-    "musl/src/thread/i386/__unmapself.s",
     "musl/src/thread/i386/clone.s",
+    "musl/src/thread/i386/__set_thread_area.s",
     "musl/src/thread/i386/syscall_cp.s",
     "musl/src/thread/i386/tls.s",
+    "musl/src/thread/i386/__unmapself.s",
+    "musl/src/thread/__lock.c",
     "musl/src/thread/lock_ptc.c",
-    "musl/src/thread/loongarch64/__set_thread_area.s",
-    "musl/src/thread/loongarch64/__unmapself.s",
     "musl/src/thread/loongarch64/clone.s",
+    "musl/src/thread/loongarch64/__set_thread_area.s",
     "musl/src/thread/loongarch64/syscall_cp.s",
-    "musl/src/thread/m68k/__m68k_read_tp.s",
+    "musl/src/thread/loongarch64/__unmapself.s",
     "musl/src/thread/m68k/clone.s",
+    "musl/src/thread/m68k/__m68k_read_tp.s",
     "musl/src/thread/m68k/syscall_cp.s",
-    "musl/src/thread/microblaze/__set_thread_area.s",
-    "musl/src/thread/microblaze/__unmapself.s",
     "musl/src/thread/microblaze/clone.s",
+    "musl/src/thread/microblaze/__set_thread_area.s",
     "musl/src/thread/microblaze/syscall_cp.s",
-    "musl/src/thread/mips/__unmapself.s",
-    "musl/src/thread/mips/clone.s",
-    "musl/src/thread/mips/syscall_cp.s",
-    "musl/src/thread/mips64/__unmapself.s",
+    "musl/src/thread/microblaze/__unmapself.s",
     "musl/src/thread/mips64/clone.s",
     "musl/src/thread/mips64/syscall_cp.s",
-    "musl/src/thread/mipsn32/__unmapself.s",
+    "musl/src/thread/mips64/__unmapself.s",
+    "musl/src/thread/mips/clone.s",
     "musl/src/thread/mipsn32/clone.s",
     "musl/src/thread/mipsn32/syscall_cp.s",
+    "musl/src/thread/mipsn32/__unmapself.s",
+    "musl/src/thread/mips/syscall_cp.s",
+    "musl/src/thread/mips/__unmapself.s",
     "musl/src/thread/mtx_destroy.c",
     "musl/src/thread/mtx_init.c",
     "musl/src/thread/mtx_lock.c",
     "musl/src/thread/mtx_timedlock.c",
     "musl/src/thread/mtx_trylock.c",
     "musl/src/thread/mtx_unlock.c",
-    "musl/src/thread/or1k/__set_thread_area.s",
-    "musl/src/thread/or1k/__unmapself.s",
     "musl/src/thread/or1k/clone.s",
+    "musl/src/thread/or1k/__set_thread_area.s",
     "musl/src/thread/or1k/syscall_cp.s",
-    "musl/src/thread/powerpc/__set_thread_area.s",
-    "musl/src/thread/powerpc/__unmapself.s",
-    "musl/src/thread/powerpc/clone.s",
-    "musl/src/thread/powerpc/syscall_cp.s",
-    "musl/src/thread/powerpc64/__set_thread_area.s",
-    "musl/src/thread/powerpc64/__unmapself.s",
+    "musl/src/thread/or1k/__unmapself.s",
     "musl/src/thread/powerpc64/clone.s",
+    "musl/src/thread/powerpc64/__set_thread_area.s",
     "musl/src/thread/powerpc64/syscall_cp.s",
+    "musl/src/thread/powerpc64/__unmapself.s",
+    "musl/src/thread/powerpc/clone.s",
+    "musl/src/thread/powerpc/__set_thread_area.s",
+    "musl/src/thread/powerpc/syscall_cp.s",
+    "musl/src/thread/powerpc/__unmapself.s",
     "musl/src/thread/pthread_atfork.c",
     "musl/src/thread/pthread_attr_destroy.c",
     "musl/src/thread/pthread_attr_get.c",
@@ -2026,24 +2062,24 @@ const src_files = [_][]const u8{
     "musl/src/thread/pthread_attr_setscope.c",
     "musl/src/thread/pthread_attr_setstack.c",
     "musl/src/thread/pthread_attr_setstacksize.c",
-    "musl/src/thread/pthread_barrier_destroy.c",
-    "musl/src/thread/pthread_barrier_init.c",
-    "musl/src/thread/pthread_barrier_wait.c",
     "musl/src/thread/pthread_barrierattr_destroy.c",
     "musl/src/thread/pthread_barrierattr_init.c",
     "musl/src/thread/pthread_barrierattr_setpshared.c",
+    "musl/src/thread/pthread_barrier_destroy.c",
+    "musl/src/thread/pthread_barrier_init.c",
+    "musl/src/thread/pthread_barrier_wait.c",
     "musl/src/thread/pthread_cancel.c",
     "musl/src/thread/pthread_cleanup_push.c",
+    "musl/src/thread/pthread_condattr_destroy.c",
+    "musl/src/thread/pthread_condattr_init.c",
+    "musl/src/thread/pthread_condattr_setclock.c",
+    "musl/src/thread/pthread_condattr_setpshared.c",
     "musl/src/thread/pthread_cond_broadcast.c",
     "musl/src/thread/pthread_cond_destroy.c",
     "musl/src/thread/pthread_cond_init.c",
     "musl/src/thread/pthread_cond_signal.c",
     "musl/src/thread/pthread_cond_timedwait.c",
     "musl/src/thread/pthread_cond_wait.c",
-    "musl/src/thread/pthread_condattr_destroy.c",
-    "musl/src/thread/pthread_condattr_init.c",
-    "musl/src/thread/pthread_condattr_setclock.c",
-    "musl/src/thread/pthread_condattr_setpshared.c",
     "musl/src/thread/pthread_create.c",
     "musl/src/thread/pthread_detach.c",
     "musl/src/thread/pthread_equal.c",
@@ -2056,6 +2092,12 @@ const src_files = [_][]const u8{
     "musl/src/thread/pthread_join.c",
     "musl/src/thread/pthread_key_create.c",
     "musl/src/thread/pthread_kill.c",
+    "musl/src/thread/pthread_mutexattr_destroy.c",
+    "musl/src/thread/pthread_mutexattr_init.c",
+    "musl/src/thread/pthread_mutexattr_setprotocol.c",
+    "musl/src/thread/pthread_mutexattr_setpshared.c",
+    "musl/src/thread/pthread_mutexattr_setrobust.c",
+    "musl/src/thread/pthread_mutexattr_settype.c",
     "musl/src/thread/pthread_mutex_consistent.c",
     "musl/src/thread/pthread_mutex_destroy.c",
     "musl/src/thread/pthread_mutex_getprioceiling.c",
@@ -2065,13 +2107,10 @@ const src_files = [_][]const u8{
     "musl/src/thread/pthread_mutex_timedlock.c",
     "musl/src/thread/pthread_mutex_trylock.c",
     "musl/src/thread/pthread_mutex_unlock.c",
-    "musl/src/thread/pthread_mutexattr_destroy.c",
-    "musl/src/thread/pthread_mutexattr_init.c",
-    "musl/src/thread/pthread_mutexattr_setprotocol.c",
-    "musl/src/thread/pthread_mutexattr_setpshared.c",
-    "musl/src/thread/pthread_mutexattr_setrobust.c",
-    "musl/src/thread/pthread_mutexattr_settype.c",
     "musl/src/thread/pthread_once.c",
+    "musl/src/thread/pthread_rwlockattr_destroy.c",
+    "musl/src/thread/pthread_rwlockattr_init.c",
+    "musl/src/thread/pthread_rwlockattr_setpshared.c",
     "musl/src/thread/pthread_rwlock_destroy.c",
     "musl/src/thread/pthread_rwlock_init.c",
     "musl/src/thread/pthread_rwlock_rdlock.c",
@@ -2081,9 +2120,6 @@ const src_files = [_][]const u8{
     "musl/src/thread/pthread_rwlock_trywrlock.c",
     "musl/src/thread/pthread_rwlock_unlock.c",
     "musl/src/thread/pthread_rwlock_wrlock.c",
-    "musl/src/thread/pthread_rwlockattr_destroy.c",
-    "musl/src/thread/pthread_rwlockattr_init.c",
-    "musl/src/thread/pthread_rwlockattr_setpshared.c",
     "musl/src/thread/pthread_self.c",
     "musl/src/thread/pthread_setattr_default_np.c",
     "musl/src/thread/pthread_setcancelstate.c",
@@ -2100,19 +2136,19 @@ const src_files = [_][]const u8{
     "musl/src/thread/pthread_spin_trylock.c",
     "musl/src/thread/pthread_spin_unlock.c",
     "musl/src/thread/pthread_testcancel.c",
-    "musl/src/thread/riscv32/__set_thread_area.s",
-    "musl/src/thread/riscv32/__unmapself.s",
     "musl/src/thread/riscv32/clone.s",
+    "musl/src/thread/riscv32/__set_thread_area.s",
     "musl/src/thread/riscv32/syscall_cp.s",
-    "musl/src/thread/riscv64/__set_thread_area.s",
-    "musl/src/thread/riscv64/__unmapself.s",
+    "musl/src/thread/riscv32/__unmapself.s",
     "musl/src/thread/riscv64/clone.s",
+    "musl/src/thread/riscv64/__set_thread_area.s",
     "musl/src/thread/riscv64/syscall_cp.s",
+    "musl/src/thread/riscv64/__unmapself.s",
+    "musl/src/thread/s390x/clone.s",
     "musl/src/thread/s390x/__set_thread_area.s",
+    "musl/src/thread/s390x/syscall_cp.s",
     "musl/src/thread/s390x/__tls_get_offset.s",
     "musl/src/thread/s390x/__unmapself.s",
-    "musl/src/thread/s390x/clone.s",
-    "musl/src/thread/s390x/syscall_cp.s",
     "musl/src/thread/sem_destroy.c",
     "musl/src/thread/sem_getvalue.c",
     "musl/src/thread/sem_init.c",
@@ -2122,38 +2158,38 @@ const src_files = [_][]const u8{
     "musl/src/thread/sem_trywait.c",
     "musl/src/thread/sem_unlink.c",
     "musl/src/thread/sem_wait.c",
-    "musl/src/thread/sh/__set_thread_area.c",
-    "musl/src/thread/sh/__unmapself.c",
-    "musl/src/thread/sh/__unmapself_mmu.s",
+    "musl/src/thread/__set_thread_area.c",
     "musl/src/thread/sh/atomics.s",
     "musl/src/thread/sh/clone.s",
+    "musl/src/thread/sh/__set_thread_area.c",
     "musl/src/thread/sh/syscall_cp.s",
+    "musl/src/thread/sh/__unmapself.c",
+    "musl/src/thread/sh/__unmapself_mmu.s",
     "musl/src/thread/synccall.c",
+    "musl/src/thread/__syscall_cp.c",
     "musl/src/thread/syscall_cp.c",
     "musl/src/thread/thrd_create.c",
     "musl/src/thread/thrd_exit.c",
     "musl/src/thread/thrd_join.c",
     "musl/src/thread/thrd_sleep.c",
     "musl/src/thread/thrd_yield.c",
+    "musl/src/thread/__timedwait.c",
     "musl/src/thread/tls.c",
+    "musl/src/thread/__tls_get_addr.c",
     "musl/src/thread/tss_create.c",
     "musl/src/thread/tss_delete.c",
     "musl/src/thread/tss_set.c",
+    "musl/src/thread/__unmapself.c",
     "musl/src/thread/vmlock.c",
-    "musl/src/thread/x32/__set_thread_area.s",
-    "musl/src/thread/x32/__unmapself.s",
+    "musl/src/thread/__wait.c",
     "musl/src/thread/x32/clone.s",
+    "musl/src/thread/x32/__set_thread_area.s",
     "musl/src/thread/x32/syscall_cp.s",
-    "musl/src/thread/x86_64/__set_thread_area.s",
-    "musl/src/thread/x86_64/__unmapself.s",
+    "musl/src/thread/x32/__unmapself.s",
     "musl/src/thread/x86_64/clone.s",
+    "musl/src/thread/x86_64/__set_thread_area.s",
     "musl/src/thread/x86_64/syscall_cp.s",
-    "musl/src/time/__map_file.c",
-    "musl/src/time/__month_to_secs.c",
-    "musl/src/time/__secs_to_tm.c",
-    "musl/src/time/__tm_to_secs.c",
-    "musl/src/time/__tz.c",
-    "musl/src/time/__year_to_secs.c",
+    "musl/src/thread/x86_64/__unmapself.s",
     "musl/src/time/asctime.c",
     "musl/src/time/asctime_r.c",
     "musl/src/time/clock.c",
@@ -2172,8 +2208,11 @@ const src_files = [_][]const u8{
     "musl/src/time/gmtime_r.c",
     "musl/src/time/localtime.c",
     "musl/src/time/localtime_r.c",
+    "musl/src/time/__map_file.c",
     "musl/src/time/mktime.c",
+    "musl/src/time/__month_to_secs.c",
     "musl/src/time/nanosleep.c",
+    "musl/src/time/__secs_to_tm.c",
     "musl/src/time/strftime.c",
     "musl/src/time/strptime.c",
     "musl/src/time/time.c",
@@ -2185,9 +2224,11 @@ const src_files = [_][]const u8{
     "musl/src/time/timer_settime.c",
     "musl/src/time/times.c",
     "musl/src/time/timespec_get.c",
+    "musl/src/time/__tm_to_secs.c",
+    "musl/src/time/__tz.c",
     "musl/src/time/utime.c",
     "musl/src/time/wcsftime.c",
-    "musl/src/unistd/_exit.c",
+    "musl/src/time/__year_to_secs.c",
     "musl/src/unistd/access.c",
     "musl/src/unistd/acct.c",
     "musl/src/unistd/alarm.c",
@@ -2195,13 +2236,14 @@ const src_files = [_][]const u8{
     "musl/src/unistd/chown.c",
     "musl/src/unistd/close.c",
     "musl/src/unistd/ctermid.c",
-    "musl/src/unistd/dup.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/fchown.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",
@@ -2221,25 +2263,25 @@ const src_files = [_][]const u8{
     "musl/src/unistd/getuid.c",
     "musl/src/unistd/isatty.c",
     "musl/src/unistd/lchown.c",
-    "musl/src/unistd/link.c",
     "musl/src/unistd/linkat.c",
+    "musl/src/unistd/link.c",
     "musl/src/unistd/lseek.c",
-    "musl/src/unistd/mips/pipe.s",
     "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/pipe.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",
     "musl/src/unistd/pwrite.c",
     "musl/src/unistd/pwritev.c",
     "musl/src/unistd/read.c",
-    "musl/src/unistd/readlink.c",
     "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",
@@ -2257,8 +2299,8 @@ const src_files = [_][]const u8{
     "musl/src/unistd/setxid.c",
     "musl/src/unistd/sh/pipe.s",
     "musl/src/unistd/sleep.c",
-    "musl/src/unistd/symlink.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",
@@ -2266,8 +2308,8 @@ const src_files = [_][]const u8{
     "musl/src/unistd/ttyname.c",
     "musl/src/unistd/ttyname_r.c",
     "musl/src/unistd/ualarm.c",
-    "musl/src/unistd/unlink.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",
@@ -2275,7 +2317,6 @@ const src_files = [_][]const u8{
 };
 
 const compat_time32_files = [_][]const u8{
-    "musl/compat/time32/__xstat.c",
     "musl/compat/time32/adjtime32.c",
     "musl/compat/time32/adjtimex_time32.c",
     "musl/compat/time32/aio_suspend_time32.c",
@@ -2288,12 +2329,12 @@ const compat_time32_files = [_][]const u8{
     "musl/compat/time32/ctime32.c",
     "musl/compat/time32/ctime32_r.c",
     "musl/compat/time32/difftime32.c",
-    "musl/compat/time32/fstat_time32.c",
     "musl/compat/time32/fstatat_time32.c",
+    "musl/compat/time32/fstat_time32.c",
     "musl/compat/time32/ftime32.c",
     "musl/compat/time32/futimens_time32.c",
-    "musl/compat/time32/futimes_time32.c",
     "musl/compat/time32/futimesat_time32.c",
+    "musl/compat/time32/futimes_time32.c",
     "musl/compat/time32/getitimer_time32.c",
     "musl/compat/time32/getrusage_time32.c",
     "musl/compat/time32/gettimeofday_time32.c",
@@ -2318,8 +2359,8 @@ const compat_time32_files = [_][]const u8{
     "musl/compat/time32/recvmmsg_time32.c",
     "musl/compat/time32/sched_rr_get_interval_time32.c",
     "musl/compat/time32/select_time32.c",
-    "musl/compat/time32/sem_timedwait_time32.c",
     "musl/compat/time32/semtimedop_time32.c",
+    "musl/compat/time32/sem_timedwait_time32.c",
     "musl/compat/time32/setitimer_time32.c",
     "musl/compat/time32/settimeofday_time32.c",
     "musl/compat/time32/sigtimedwait_time32.c",
@@ -2328,14 +2369,15 @@ const compat_time32_files = [_][]const u8{
     "musl/compat/time32/thrd_sleep_time32.c",
     "musl/compat/time32/time32.c",
     "musl/compat/time32/time32gm.c",
-    "musl/compat/time32/timer_gettime32.c",
-    "musl/compat/time32/timer_settime32.c",
     "musl/compat/time32/timerfd_gettime32.c",
     "musl/compat/time32/timerfd_settime32.c",
+    "musl/compat/time32/timer_gettime32.c",
+    "musl/compat/time32/timer_settime32.c",
     "musl/compat/time32/timespec_get_time32.c",
-    "musl/compat/time32/utime_time32.c",
     "musl/compat/time32/utimensat_time32.c",
     "musl/compat/time32/utimes_time32.c",
+    "musl/compat/time32/utime_time32.c",
     "musl/compat/time32/wait3_time32.c",
     "musl/compat/time32/wait4_time32.c",
+    "musl/compat/time32/__xstat.c",
 };
diff --git a/zig/src/print_value.zig b/zig/src/print_value.zig
index 9c06c6bcd8..06bd23d03c 100644
--- a/zig/src/print_value.zig
+++ b/zig/src/print_value.zig
@@ -74,7 +74,7 @@ pub fn print(
         .error_union_type,
         .simple_type,
         .struct_type,
-        .anon_struct_type,
+        .tuple_type,
         .union_type,
         .opaque_type,
         .enum_type,
@@ -85,7 +85,7 @@ pub fn print(
         .undef => try writer.writeAll("undefined"),
         .simple_value => |simple_value| switch (simple_value) {
             .void => try writer.writeAll("{}"),
-            .empty_struct => try writer.writeAll(".{}"),
+            .empty_tuple => try writer.writeAll(".{}"),
             .generic_poison => try writer.writeAll("(generic poison)"),
             else => try writer.writeAll(@tagName(simple_value)),
         },
diff --git a/zig/src/print_zir.zig b/zig/src/print_zir.zig
index 5467dcd27a..b8f4432e72 100644
--- a/zig/src/print_zir.zig
+++ b/zig/src/print_zir.zig
@@ -563,11 +563,12 @@ const Writer = struct {
             .enum_decl => try self.writeEnumDecl(stream, extended),
             .opaque_decl => try self.writeOpaqueDecl(stream, extended),
 
+            .tuple_decl => try self.writeTupleDecl(stream, extended),
+
             .await_nosuspend,
             .c_undef,
             .c_include,
             .set_float_mode,
-            .set_align_stack,
             .wasm_memory_size,
             .int_from_error,
             .error_from_int,
@@ -1422,7 +1423,6 @@ const Writer = struct {
 
         try self.writeFlag(stream, "known_non_opv, ", small.known_non_opv);
         try self.writeFlag(stream, "known_comptime_only, ", small.known_comptime_only);
-        try self.writeFlag(stream, "tuple, ", small.is_tuple);
 
         try stream.print("{s}, ", .{@tagName(small.name_strategy)});
 
@@ -1507,11 +1507,8 @@ const Writer = struct {
                     const has_type_body = @as(u1, @truncate(cur_bit_bag)) != 0;
                     cur_bit_bag >>= 1;
 
-                    var field_name_index: Zir.NullTerminatedString = .empty;
-                    if (!small.is_tuple) {
-                        field_name_index = @enumFromInt(self.code.extra[extra_index]);
-                        extra_index += 1;
-                    }
+                    const field_name_index: Zir.NullTerminatedString = @enumFromInt(self.code.extra[extra_index]);
+                    extra_index += 1;
                     const doc_comment_index: Zir.NullTerminatedString = @enumFromInt(self.code.extra[extra_index]);
                     extra_index += 1;
 
@@ -1949,6 +1946,32 @@ const Writer = struct {
         try self.writeSrcNode(stream, 0);
     }
 
+    fn writeTupleDecl(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+        const fields_len = extended.small;
+        assert(fields_len != 0);
+        const extra = self.code.extraData(Zir.Inst.TupleDecl, extended.operand);
+
+        var extra_index = extra.end;
+
+        try stream.writeAll("{ ");
+
+        for (0..fields_len) |field_idx| {
+            if (field_idx != 0) try stream.writeAll(", ");
+
+            const field_ty, const field_init = self.code.extra[extra_index..][0..2].*;
+            extra_index += 2;
+
+            try stream.print("@\"{d}\": ", .{field_idx});
+            try self.writeInstRef(stream, @enumFromInt(field_ty));
+            try stream.writeAll(" = ");
+            try self.writeInstRef(stream, @enumFromInt(field_init));
+        }
+
+        try stream.writeAll(" }) ");
+
+        try self.writeSrcNode(stream, extra.data.src_node);
+    }
+
     fn writeErrorSetDecl(
         self: *Writer,
         stream: anytype,
diff --git a/zig/src/target.zig b/zig/src/target.zig
index 95c9798f65..6297d21bfc 100644
--- a/zig/src/target.zig
+++ b/zig/src/target.zig
@@ -1,4 +1,6 @@
 const std = @import("std");
+const assert = std.debug.assert;
+
 const Type = @import("Type.zig");
 const AddressSpace = std.builtin.AddressSpace;
 const Alignment = @import("InternPool.zig").Alignment;
@@ -77,19 +79,45 @@ pub fn defaultSingleThreaded(target: std.Target) bool {
     return false;
 }
 
-/// Valgrind supports more, but Zig does not support them yet.
 pub fn hasValgrindSupport(target: std.Target) bool {
-    switch (target.cpu.arch) {
-        .x86,
-        .x86_64,
-        .aarch64,
-        .aarch64_be,
-        => {
-            return target.os.tag == .linux or target.os.tag == .solaris or target.os.tag == .illumos or
-                (target.os.tag == .windows and target.abi.isGnu());
+    // We can't currently output the necessary Valgrind client request assembly when using the C
+    // backend and compiling with an MSVC-like compiler.
+    const ofmt_c_msvc = (target.abi == .msvc or target.abi == .itanium) and target.ofmt == .c;
+
+    return switch (target.cpu.arch) {
+        .arm, .armeb, .thumb, .thumbeb => switch (target.os.tag) {
+            .linux => true,
+            else => false,
         },
-        else => return false,
-    }
+        .aarch64, .aarch64_be => switch (target.os.tag) {
+            .linux, .freebsd => true,
+            else => false,
+        },
+        .mips, .mipsel, .mips64, .mips64el => switch (target.os.tag) {
+            .linux => true,
+            else => false,
+        },
+        .powerpc, .powerpcle, .powerpc64, .powerpc64le => switch (target.os.tag) {
+            .linux => true,
+            else => false,
+        },
+        .s390x => switch (target.os.tag) {
+            .linux => true,
+            else => false,
+        },
+        .x86 => switch (target.os.tag) {
+            .linux, .freebsd, .solaris, .illumos => true,
+            .windows => !ofmt_c_msvc,
+            else => false,
+        },
+        .x86_64 => switch (target.os.tag) {
+            .linux => target.abi != .gnux32 and target.abi != .muslx32,
+            .freebsd, .solaris, .illumos => true,
+            .windows => !ofmt_c_msvc,
+            else => false,
+        },
+        else => false,
+    };
 }
 
 /// The set of targets that LLVM has non-experimental support for.
@@ -284,46 +312,23 @@ pub fn hasRedZone(target: std.Target) bool {
 pub fn libcFullLinkFlags(target: std.Target) []const []const u8 {
     // The linking order of these is significant and should match the order other
     // c compilers such as gcc or clang use.
-    return switch (target.os.tag) {
-        .netbsd, .openbsd => &[_][]const u8{
-            "-lm",
-            "-lpthread",
-            "-lc",
-            "-lutil",
-        },
-        .solaris, .illumos => &[_][]const u8{
-            "-lm",
-            "-lsocket",
-            "-lnsl",
-            // Solaris releases after 10 merged the threading libraries into libc.
-            "-lc",
-        },
-        .haiku => &[_][]const u8{
-            "-lm",
-            "-lroot",
-            "-lpthread",
-            "-lc",
-            "-lnetwork",
-        },
-        else => if (target.isAndroid() or target.abi.isOpenHarmony()) &[_][]const u8{
-            "-lm",
-            "-lc",
-            "-ldl",
-        } else &[_][]const u8{
-            "-lm",
-            "-lpthread",
-            "-lc",
-            "-ldl",
-            "-lrt",
-            "-lutil",
+    const result: []const []const u8 = switch (target.os.tag) {
+        .netbsd, .openbsd => &.{ "-lm", "-lpthread", "-lc", "-lutil" },
+        // Solaris releases after 10 merged the threading libraries into libc.
+        .solaris, .illumos => &.{ "-lm", "-lsocket", "-lnsl", "-lc" },
+        .haiku => &.{ "-lm", "-lroot", "-lpthread", "-lc", "-lnetwork" },
+        .linux => switch (target.abi) {
+            .android, .androideabi, .ohos, .ohoseabi => &.{ "-lm", "-lc", "-ldl" },
+            else => &.{ "-lm", "-lpthread", "-lc", "-ldl", "-lrt", "-lutil" },
         },
+        else => &.{},
     };
+    return result;
 }
 
 pub fn clangMightShellOutForAssembly(target: std.Target) bool {
-    // Clang defaults to using the system assembler over the internal one
-    // when targeting a non-BSD OS.
-    return target.cpu.arch.isSPARC();
+    // Clang defaults to using the system assembler in some cases.
+    return target.cpu.arch.isNvptx() or target.cpu.arch == .xcore;
 }
 
 /// Each backend architecture in Clang has a different codepath which may or may not
@@ -335,6 +340,20 @@ pub fn clangAssemblerSupportsMcpuArg(target: std.Target) bool {
     };
 }
 
+/// Some experimental or poorly-maintained LLVM targets do not properly process CPU models in their
+/// Clang driver code. For these, we should omit the `-Xclang -target-cpu -Xclang <model>` flags.
+pub fn clangSupportsTargetCpuArg(target: std.Target) bool {
+    return switch (target.cpu.arch) {
+        .arc,
+        .msp430,
+        .ve,
+        .xcore,
+        .xtensa,
+        => false,
+        else => true,
+    };
+}
+
 pub fn clangSupportsFloatAbiArg(target: std.Target) bool {
     return switch (target.cpu.arch) {
         .arm,
@@ -418,7 +437,42 @@ pub fn addrSpaceCastIsValid(
     }
 }
 
+/// Under SPIR-V with Vulkan, pointers are not 'real' (physical), but rather 'logical'. Effectively,
+/// this means that all such pointers have to be resolvable to a location at compile time, and places
+/// a number of restrictions on usage of such pointers. For example, a logical pointer may not be
+/// part of a merge (result of a branch) and may not be stored in memory at all. This function returns
+/// for a particular architecture and address space wether such pointers are logical.
+pub fn arePointersLogical(target: std.Target, as: AddressSpace) bool {
+    if (target.os.tag != .vulkan) {
+        return false;
+    }
+
+    return switch (as) {
+        // TODO: Vulkan doesn't support pointers in the generic address space, we
+        // should remove this case but this requires a change in defaultAddressSpace().
+        // For now, at least disable them from being regarded as physical.
+        .generic => true,
+        // For now, all global pointers are represented using PhysicalStorageBuffer, so these are real
+        // pointers.
+        .global => false,
+        // TODO: Allowed with VK_KHR_variable_pointers.
+        .shared => true,
+        .constant, .local, .input, .output, .uniform, .push_constant, .storage_buffer => true,
+        else => unreachable,
+    };
+}
+
 pub fn llvmMachineAbi(target: std.Target) ?[:0]const u8 {
+    // This special-casing should be removed with LLVM 20.
+    switch (target.cpu.arch) {
+        .mips, .mipsel => return "o32",
+        .mips64, .mips64el => return switch (target.abi) {
+            .gnuabin32, .muslabin32 => "n32",
+            else => "n64",
+        },
+        else => {},
+    }
+
     // LLD does not support ELFv1. Rather than having LLVM produce ELFv1 code and then linking it
     // into a broken ELFv2 binary, just force LLVM to use ELFv2 as well. This will break when glibc
     // is linked as glibc only supports ELFv2 for little endian, but there's nothing we can do about
@@ -427,17 +481,14 @@ pub fn llvmMachineAbi(target: std.Target) ?[:0]const u8 {
     // Once our self-hosted linker can handle both ABIs, this hack should go away.
     if (target.cpu.arch == .powerpc64) return "elfv2";
 
-    const have_float = switch (target.abi) {
-        .gnueabihf, .musleabihf, .eabihf => true,
-        else => false,
-    };
-
     switch (target.cpu.arch) {
         .riscv64 => {
             const featureSetHas = std.Target.riscv.featureSetHas;
-            if (featureSetHas(target.cpu.features, .d)) {
+            if (featureSetHas(target.cpu.features, .e)) {
+                return "lp64e";
+            } else if (featureSetHas(target.cpu.features, .d)) {
                 return "lp64d";
-            } else if (have_float) {
+            } else if (featureSetHas(target.cpu.features, .f)) {
                 return "lp64f";
             } else {
                 return "lp64";
@@ -445,12 +496,12 @@ pub fn llvmMachineAbi(target: std.Target) ?[:0]const u8 {
         },
         .riscv32 => {
             const featureSetHas = std.Target.riscv.featureSetHas;
-            if (featureSetHas(target.cpu.features, .d)) {
+            if (featureSetHas(target.cpu.features, .e)) {
+                return "ilp32e";
+            } else if (featureSetHas(target.cpu.features, .d)) {
                 return "ilp32d";
-            } else if (have_float) {
+            } else if (featureSetHas(target.cpu.features, .f)) {
                 return "ilp32f";
-            } else if (featureSetHas(target.cpu.features, .e)) {
-                return "ilp32e";
             } else {
                 return "ilp32";
             }
@@ -459,35 +510,88 @@ pub fn llvmMachineAbi(target: std.Target) ?[:0]const u8 {
     }
 }
 
-/// This function returns 1 if function alignment is not observable or settable.
+/// This function returns 1 if function alignment is not observable or settable. Note that this
+/// value will not necessarily match the backend's default function alignment (e.g. for LLVM).
 pub fn defaultFunctionAlignment(target: std.Target) Alignment {
+    // Overrides of the minimum for performance.
     return switch (target.cpu.arch) {
-        .arm, .armeb => .@"4",
-        .aarch64, .aarch64_be => .@"4",
-        .sparc, .sparc64 => .@"4",
-        .riscv64 => .@"2",
-        else => .@"1",
+        .csky,
+        .thumb,
+        .thumbeb,
+        .xcore,
+        => .@"4",
+        .aarch64,
+        .aarch64_be,
+        .hexagon,
+        .powerpc,
+        .powerpcle,
+        .powerpc64,
+        .powerpc64le,
+        .s390x,
+        .x86,
+        .x86_64,
+        => .@"16",
+        .loongarch32,
+        .loongarch64,
+        => .@"32",
+        else => minFunctionAlignment(target),
     };
 }
 
+/// This function returns 1 if function alignment is not observable or settable.
 pub fn minFunctionAlignment(target: std.Target) Alignment {
     return switch (target.cpu.arch) {
+        .riscv32,
+        .riscv64,
+        => if (std.Target.riscv.featureSetHasAny(target.cpu.features, .{ .c, .zca })) .@"2" else .@"4",
+        .thumb,
+        .thumbeb,
+        .csky,
+        .m68k,
+        .msp430,
+        .s390x,
+        .xcore,
+        => .@"2",
+        .arc,
         .arm,
         .armeb,
         .aarch64,
         .aarch64_be,
-        .riscv32,
-        .riscv64,
+        .hexagon,
+        .lanai,
+        .loongarch32,
+        .loongarch64,
+        .mips,
+        .mipsel,
+        .powerpc,
+        .powerpcle,
+        .powerpc64,
+        .powerpc64le,
         .sparc,
         .sparc64,
-        => .@"2",
+        .xtensa,
+        => .@"4",
+        .bpfel,
+        .bpfeb,
+        .mips64,
+        .mips64el,
+        => .@"8",
+        .ve,
+        => .@"16",
         else => .@"1",
     };
 }
 
 pub fn supportsFunctionAlignment(target: std.Target) bool {
     return switch (target.cpu.arch) {
-        .wasm32, .wasm64 => false,
+        .nvptx,
+        .nvptx64,
+        .spirv,
+        .spirv32,
+        .spirv64,
+        .wasm32,
+        .wasm64,
+        => false,
         else => true,
     };
 }
@@ -547,13 +651,13 @@ pub fn compilerRtIntAbbrev(bits: u16) []const u8 {
     };
 }
 
-pub fn fnCallConvAllowsZigTypes(target: std.Target, cc: std.builtin.CallingConvention) bool {
+pub fn fnCallConvAllowsZigTypes(cc: std.builtin.CallingConvention) bool {
     return switch (cc) {
-        .Unspecified, .Async, .Inline => true,
+        .auto, .@"async", .@"inline" => true,
         // 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.
-        .Kernel => target.cpu.arch == .nvptx or target.cpu.arch == .nvptx64,
+        .nvptx_kernel => true,
         else => false,
     };
 }
diff --git a/zig/src/translate_c.zig b/zig/src/translate_c.zig
index 22b03fcb75..6faffde7e2 100644
--- a/zig/src/translate_c.zig
+++ b/zig/src/translate_c.zig
@@ -4,7 +4,6 @@ const assert = std.debug.assert;
 const mem = std.mem;
 const math = std.math;
 const meta = std.meta;
-const CallingConvention = std.builtin.CallingConvention;
 const clang = @import("clang.zig");
 const aro = @import("aro");
 const CToken = aro.Tokenizer.Token;
@@ -2315,8 +2314,11 @@ fn transStringLiteralInitializer(
             while (i < num_inits) : (i += 1) {
                 init_list[i] = try transCreateCharLitNode(c, false, stmt.getCodeUnit(i));
             }
-            const init_args = .{ .len = num_inits, .elem_type = elem_type };
-            const init_array_type = try if (array_type.tag() == .array_type) Tag.array_type.create(c.arena, init_args) else Tag.null_sentinel_array_type.create(c.arena, init_args);
+            const init_args: ast.Payload.Array.ArrayTypeInfo = .{ .len = num_inits, .elem_type = elem_type };
+            const init_array_type = if (array_type.tag() == .array_type)
+                try Tag.array_type.create(c.arena, init_args)
+            else
+                try Tag.null_sentinel_array_type.create(c.arena, init_args);
             break :blk try Tag.array_init.create(c.arena, .{
                 .cond = init_array_type,
                 .cases = init_list,
@@ -3911,7 +3913,7 @@ fn transCreateCompoundAssign(
 
         if ((is_mod or is_div) and is_signed) {
             if (requires_cast) rhs_node = try transCCast(c, scope, loc, lhs_qt, rhs_qt, rhs_node);
-            const operands = .{ .lhs = lhs_node, .rhs = rhs_node };
+            const operands: @FieldType(ast.Payload.BinOp, "data") = .{ .lhs = lhs_node, .rhs = rhs_node };
             const builtin = if (is_mod)
                 try Tag.signed_remainder.create(c.arena, operands)
             else
@@ -3950,7 +3952,7 @@ fn transCreateCompoundAssign(
     if (is_ptr_op_signed) rhs_node = try usizeCastForWrappingPtrArithmetic(c.arena, rhs_node);
     if ((is_mod or is_div) and is_signed) {
         if (requires_cast) rhs_node = try transCCast(c, scope, loc, lhs_qt, rhs_qt, rhs_node);
-        const operands = .{ .lhs = ref_node, .rhs = rhs_node };
+        const operands: @FieldType(ast.Payload.BinOp, "data") = .{ .lhs = ref_node, .rhs = rhs_node };
         const builtin = if (is_mod)
             try Tag.signed_remainder.create(c.arena, operands)
         else
@@ -4778,7 +4780,7 @@ fn transType(c: *Context, scope: *Scope, ty: *const clang.Type, source_loc: clan
             const is_const = is_fn_proto or child_qt.isConstQualified();
             const is_volatile = child_qt.isVolatileQualified();
             const elem_type = try transQualType(c, scope, child_qt, source_loc);
-            const ptr_info = .{
+            const ptr_info: @FieldType(ast.Payload.Pointer, "data") = .{
                 .is_const = is_const,
                 .is_volatile = is_volatile,
                 .elem_type = elem_type,
@@ -5001,17 +5003,20 @@ fn transCC(
     c: *Context,
     fn_ty: *const clang.FunctionType,
     source_loc: clang.SourceLocation,
-) !CallingConvention {
+) !ast.Payload.Func.CallingConvention {
     const clang_cc = fn_ty.getCallConv();
-    switch (clang_cc) {
-        .C => return CallingConvention.C,
-        .X86StdCall => return CallingConvention.Stdcall,
-        .X86FastCall => return CallingConvention.Fastcall,
-        .X86VectorCall, .AArch64VectorCall => return CallingConvention.Vectorcall,
-        .X86ThisCall => return CallingConvention.Thiscall,
-        .AAPCS => return CallingConvention.AAPCS,
-        .AAPCS_VFP => return CallingConvention.AAPCSVFP,
-        .X86_64SysV => return CallingConvention.SysV,
+    return switch (clang_cc) {
+        .C => .c,
+        .X86_64SysV => .x86_64_sysv,
+        .Win64 => .x86_64_win,
+        .X86StdCall => .x86_stdcall,
+        .X86FastCall => .x86_fastcall,
+        .X86ThisCall => .x86_thiscall,
+        .X86VectorCall => .x86_vectorcall,
+        .AArch64VectorCall => .aarch64_vfabi,
+        .AAPCS => .arm_aapcs,
+        .AAPCS_VFP => .arm_aapcs_vfp,
+        .M68kRTD => .m68k_rtd,
         else => return fail(
             c,
             error.UnsupportedType,
@@ -5019,7 +5024,7 @@ fn transCC(
             "unsupported calling convention: {s}",
             .{@tagName(clang_cc)},
         ),
-    }
+    };
 }
 
 fn transFnProto(
@@ -5056,7 +5061,7 @@ fn finishTransFnProto(
     source_loc: clang.SourceLocation,
     fn_decl_context: ?FnDeclContext,
     is_var_args: bool,
-    cc: CallingConvention,
+    cc: ast.Payload.Func.CallingConvention,
     is_pub: bool,
 ) !*ast.Payload.Func {
     const is_export = if (fn_decl_context) |ctx| ctx.is_export else false;
@@ -5104,7 +5109,7 @@ fn finishTransFnProto(
 
     const alignment = if (fn_decl) |decl| ClangAlignment.forFunc(c, decl).zigAlignment() else null;
 
-    const explicit_callconv = if ((is_inline or is_export or is_extern) and cc == .C) null else cc;
+    const explicit_callconv = if ((is_inline or is_export or is_extern) and cc == .c) null else cc;
 
     const return_type_node = blk: {
         if (fn_ty.getNoReturnAttr()) {
diff --git a/zig/src/wasi_libc.zig b/zig/src/wasi_libc.zig
index ce94110b69..ce6131a470 100644
--- a/zig/src/wasi_libc.zig
+++ b/zig/src/wasi_libc.zig
@@ -81,7 +81,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 },
             };
-            return comp.build_crt_file("crt1-reactor", .Obj, .@"wasi crt1-reactor.o", prog_node, &files);
+            return comp.build_crt_file("crt1-reactor", .Obj, .@"wasi crt1-reactor.o", prog_node, &files, .{});
         },
         .crt1_command_o => {
             var args = std.ArrayList([]const u8).init(arena);
@@ -96,7 +96,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 },
             };
-            return comp.build_crt_file("crt1-command", .Obj, .@"wasi crt1-command.o", prog_node, &files);
+            return comp.build_crt_file("crt1-command", .Obj, .@"wasi crt1-command.o", prog_node, &files, .{});
         },
         .libc_a => {
             var libc_sources = std.ArrayList(Compilation.CSourceFile).init(arena);
@@ -150,7 +150,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                 }
             }
 
-            try comp.build_crt_file("c", .Lib, .@"wasi libc.a", prog_node, libc_sources.items);
+            try comp.build_crt_file("c", .Lib, .@"wasi libc.a", prog_node, libc_sources.items, .{});
         },
         .libwasi_emulated_process_clocks_a => {
             var args = std.ArrayList([]const u8).init(arena);
@@ -167,7 +167,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 });
             }
-            try comp.build_crt_file("wasi-emulated-process-clocks", .Lib, .@"libwasi-emulated-process-clocks.a", prog_node, emu_clocks_sources.items);
+            try comp.build_crt_file("wasi-emulated-process-clocks", .Lib, .@"libwasi-emulated-process-clocks.a", prog_node, emu_clocks_sources.items, .{});
         },
         .libwasi_emulated_getpid_a => {
             var args = std.ArrayList([]const u8).init(arena);
@@ -184,7 +184,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 });
             }
-            try comp.build_crt_file("wasi-emulated-getpid", .Lib, .@"libwasi-emulated-getpid.a", prog_node, emu_getpid_sources.items);
+            try comp.build_crt_file("wasi-emulated-getpid", .Lib, .@"libwasi-emulated-getpid.a", prog_node, emu_getpid_sources.items, .{});
         },
         .libwasi_emulated_mman_a => {
             var args = std.ArrayList([]const u8).init(arena);
@@ -201,7 +201,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                     .owner = undefined,
                 });
             }
-            try comp.build_crt_file("wasi-emulated-mman", .Lib, .@"libwasi-emulated-mman.a", prog_node, emu_mman_sources.items);
+            try comp.build_crt_file("wasi-emulated-mman", .Lib, .@"libwasi-emulated-mman.a", prog_node, emu_mman_sources.items, .{});
         },
         .libwasi_emulated_signal_a => {
             var emu_signal_sources = std.ArrayList(Compilation.CSourceFile).init(arena);
@@ -238,7 +238,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
                 }
             }
 
-            try comp.build_crt_file("wasi-emulated-signal", .Lib, .@"libwasi-emulated-signal.a", prog_node, emu_signal_sources.items);
+            try comp.build_crt_file("wasi-emulated-signal", .Lib, .@"libwasi-emulated-signal.a", prog_node, emu_signal_sources.items, .{});
         },
     }
 }
@@ -279,7 +279,6 @@ fn addCCArgs(
     try args.appendSlice(&[_][]const u8{
         "-std=gnu17",
         "-fno-trapping-math",
-        "-fno-stack-protector",
         "-w", // ignore all warnings
 
         o_arg,
diff --git a/zig/src/zig_llvm.cpp b/zig/src/zig_llvm.cpp
index d2f68a6d49..53a0faba8a 100644
--- a/zig/src/zig_llvm.cpp
+++ b/zig/src/zig_llvm.cpp
@@ -50,6 +50,7 @@
 #include <llvm/Support/Timer.h>
 #include <llvm/Support/raw_ostream.h>
 #include <llvm/Target/TargetMachine.h>
+#include <llvm/Target/TargetOptions.h>
 #include <llvm/Target/CodeGenCWrappers.h>
 #include <llvm/Transforms/IPO.h>
 #include <llvm/Transforms/IPO/AlwaysInliner.h>
@@ -81,7 +82,7 @@ static const bool assertions_on = false;
 
 LLVMTargetMachineRef ZigLLVMCreateTargetMachine(LLVMTargetRef T, const char *Triple,
     const char *CPU, const char *Features, LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc,
-    LLVMCodeModel CodeModel, bool function_sections, bool data_sections, ZigLLVMABIType float_abi,
+    LLVMCodeModel CodeModel, bool function_sections, bool data_sections, ZigLLVMFloatABI float_abi,
     const char *abi_name)
 {
     std::optional<Reloc::Model> RM;
@@ -133,13 +134,13 @@ LLVMTargetMachineRef ZigLLVMCreateTargetMachine(LLVMTargetRef T, const char *Tri
     opt.FunctionSections = function_sections;
     opt.DataSections = data_sections;
     switch (float_abi) {
-        case ZigLLVMABITypeDefault:
+        case ZigLLVMFloatABI_Default:
             opt.FloatABIType = FloatABI::Default;
             break;
-        case ZigLLVMABITypeSoft:
+        case ZigLLVMFloatABI_Soft:
             opt.FloatABIType = FloatABI::Soft;
             break;
-        case ZigLLVMABITypeHard:
+        case ZigLLVMFloatABI_Hard:
             opt.FloatABIType = FloatABI::Hard;
             break;
     }
@@ -213,7 +214,7 @@ static SanitizerCoverageOptions getSanCovOptions(ZigLLVMCoverageOptions z) {
 }
 
 ZIG_EXTERN_C bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref,
-        char **error_message, const struct ZigLLVMEmitOptions *options)
+    char **error_message, const ZigLLVMEmitOptions *options)
 {
     TimePassesIsEnabled = options->time_report;
 
@@ -419,7 +420,7 @@ struct ZigDiagnosticHandler : public DiagnosticHandler {
             BrokenDebugInfo = true;
         }
         return false;
-      }
+    }
 };
 
 void ZigLLVMEnableBrokenDebugInfoCheck(LLVMContextRef context_ref) {
@@ -435,35 +436,10 @@ void ZigLLVMParseCommandLineOptions(size_t argc, const char *const *argv) {
     cl::ParseCommandLineOptions(argc, argv);
 }
 
-bool ZigLLVMWriteImportLibrary(const char *def_path, const ZigLLVM_ArchType arch,
-                               const char *output_lib_path, bool kill_at)
+bool ZigLLVMWriteImportLibrary(const char *def_path, unsigned int coff_machine,
+    const char *output_lib_path, bool kill_at)
 {
-    COFF::MachineTypes machine = COFF::IMAGE_FILE_MACHINE_UNKNOWN;
-
-    switch (arch) {
-        case ZigLLVM_x86:
-            machine = COFF::IMAGE_FILE_MACHINE_I386;
-            break;
-        case ZigLLVM_x86_64:
-            machine = COFF::IMAGE_FILE_MACHINE_AMD64;
-            break;
-        case ZigLLVM_arm:
-        case ZigLLVM_armeb:
-        case ZigLLVM_thumb:
-        case ZigLLVM_thumbeb:
-            machine = COFF::IMAGE_FILE_MACHINE_ARMNT;
-            break;
-        case ZigLLVM_aarch64:
-        case ZigLLVM_aarch64_be:
-            machine = COFF::IMAGE_FILE_MACHINE_ARM64;
-            break;
-        default:
-            break;
-    }
-
-    if (machine == COFF::IMAGE_FILE_MACHINE_UNKNOWN) {
-        return true;
-    }
+    COFF::MachineTypes machine = static_cast<COFF::MachineTypes>(coff_machine);
 
     auto bufOrErr = MemoryBuffer::getFile(def_path);
     if (!bufOrErr) {
@@ -515,30 +491,8 @@ bool ZigLLVMWriteImportLibrary(const char *def_path, const ZigLLVM_ArchType arch
 }
 
 bool ZigLLVMWriteArchive(const char *archive_name, const char **file_names, size_t file_name_count,
-        ZigLLVM_OSType os_type)
+    ZigLLVMArchiveKind archive_kind)
 {
-    object::Archive::Kind kind;
-    switch (os_type) {
-        case ZigLLVM_Win32:
-            // For some reason llvm-lib passes K_GNU on windows.
-            // See lib/ToolDrivers/llvm-lib/LibDriver.cpp:168 in libDriverMain
-            kind = object::Archive::K_GNU;
-            break;
-        case ZigLLVM_Linux:
-            kind = object::Archive::K_GNU;
-            break;
-        case ZigLLVM_MacOSX:
-        case ZigLLVM_Darwin:
-        case ZigLLVM_IOS:
-            kind = object::Archive::K_DARWIN;
-            break;
-        case ZigLLVM_OpenBSD:
-        case ZigLLVM_FreeBSD:
-            kind = object::Archive::K_BSD;
-            break;
-        default:
-            kind = object::Archive::K_GNU;
-    }
     SmallVector<NewArchiveMember, 4> new_members;
     for (size_t i = 0; i < file_name_count; i += 1) {
         Expected<NewArchiveMember> new_member = NewArchiveMember::getFile(file_names[i], true);
@@ -547,7 +501,7 @@ bool ZigLLVMWriteArchive(const char *archive_name, const char **file_names, size
         new_members.push_back(std::move(*new_member));
     }
     Error err = writeArchive(archive_name, new_members,
-        SymtabWritingMode::NormalSymtab, kind, true, false, nullptr);
+        SymtabWritingMode::NormalSymtab, static_cast<object::Archive::Kind>(archive_kind), true, false, nullptr);
 
     if (err) return true;
     return false;
@@ -586,236 +540,14 @@ bool ZigLLDLinkWasm(int argc, const char **argv, bool can_exit_early, bool disab
     return lld::wasm::link(args, llvm::outs(), llvm::errs(), can_exit_early, disable_output);
 }
 
-static_assert((Triple::ArchType)ZigLLVM_UnknownArch == Triple::UnknownArch, "");
-static_assert((Triple::ArchType)ZigLLVM_arm == Triple::arm, "");
-static_assert((Triple::ArchType)ZigLLVM_armeb == Triple::armeb, "");
-static_assert((Triple::ArchType)ZigLLVM_aarch64 == Triple::aarch64, "");
-static_assert((Triple::ArchType)ZigLLVM_aarch64_be == Triple::aarch64_be, "");
-static_assert((Triple::ArchType)ZigLLVM_aarch64_32 == Triple::aarch64_32, "");
-static_assert((Triple::ArchType)ZigLLVM_arc == Triple::arc, "");
-static_assert((Triple::ArchType)ZigLLVM_avr == Triple::avr, "");
-static_assert((Triple::ArchType)ZigLLVM_bpfel == Triple::bpfel, "");
-static_assert((Triple::ArchType)ZigLLVM_bpfeb == Triple::bpfeb, "");
-static_assert((Triple::ArchType)ZigLLVM_csky == Triple::csky, "");
-static_assert((Triple::ArchType)ZigLLVM_hexagon == Triple::hexagon, "");
-static_assert((Triple::ArchType)ZigLLVM_m68k == Triple::m68k, "");
-static_assert((Triple::ArchType)ZigLLVM_mips == Triple::mips, "");
-static_assert((Triple::ArchType)ZigLLVM_mipsel == Triple::mipsel, "");
-static_assert((Triple::ArchType)ZigLLVM_mips64 == Triple::mips64, "");
-static_assert((Triple::ArchType)ZigLLVM_mips64el == Triple::mips64el, "");
-static_assert((Triple::ArchType)ZigLLVM_msp430 == Triple::msp430, "");
-static_assert((Triple::ArchType)ZigLLVM_ppc == Triple::ppc, "");
-static_assert((Triple::ArchType)ZigLLVM_ppcle == Triple::ppcle, "");
-static_assert((Triple::ArchType)ZigLLVM_ppc64 == Triple::ppc64, "");
-static_assert((Triple::ArchType)ZigLLVM_ppc64le == Triple::ppc64le, "");
-static_assert((Triple::ArchType)ZigLLVM_r600 == Triple::r600, "");
-static_assert((Triple::ArchType)ZigLLVM_amdgcn == Triple::amdgcn, "");
-static_assert((Triple::ArchType)ZigLLVM_riscv32 == Triple::riscv32, "");
-static_assert((Triple::ArchType)ZigLLVM_riscv64 == Triple::riscv64, "");
-static_assert((Triple::ArchType)ZigLLVM_sparc == Triple::sparc, "");
-static_assert((Triple::ArchType)ZigLLVM_sparcv9 == Triple::sparcv9, "");
-static_assert((Triple::ArchType)ZigLLVM_sparcel == Triple::sparcel, "");
-static_assert((Triple::ArchType)ZigLLVM_systemz == Triple::systemz, "");
-static_assert((Triple::ArchType)ZigLLVM_tce == Triple::tce, "");
-static_assert((Triple::ArchType)ZigLLVM_tcele == Triple::tcele, "");
-static_assert((Triple::ArchType)ZigLLVM_thumb == Triple::thumb, "");
-static_assert((Triple::ArchType)ZigLLVM_thumbeb == Triple::thumbeb, "");
-static_assert((Triple::ArchType)ZigLLVM_x86 == Triple::x86, "");
-static_assert((Triple::ArchType)ZigLLVM_x86_64 == Triple::x86_64, "");
-static_assert((Triple::ArchType)ZigLLVM_xcore == Triple::xcore, "");
-static_assert((Triple::ArchType)ZigLLVM_xtensa == Triple::xtensa, "");
-static_assert((Triple::ArchType)ZigLLVM_nvptx == Triple::nvptx, "");
-static_assert((Triple::ArchType)ZigLLVM_nvptx64 == Triple::nvptx64, "");
-static_assert((Triple::ArchType)ZigLLVM_le32 == Triple::le32, "");
-static_assert((Triple::ArchType)ZigLLVM_le64 == Triple::le64, "");
-static_assert((Triple::ArchType)ZigLLVM_amdil == Triple::amdil, "");
-static_assert((Triple::ArchType)ZigLLVM_amdil64 == Triple::amdil64, "");
-static_assert((Triple::ArchType)ZigLLVM_hsail == Triple::hsail, "");
-static_assert((Triple::ArchType)ZigLLVM_hsail64 == Triple::hsail64, "");
-static_assert((Triple::ArchType)ZigLLVM_spir == Triple::spir, "");
-static_assert((Triple::ArchType)ZigLLVM_spir64 == Triple::spir64, "");
-static_assert((Triple::ArchType)ZigLLVM_spirv == Triple::spirv, "");
-static_assert((Triple::ArchType)ZigLLVM_spirv32 == Triple::spirv32, "");
-static_assert((Triple::ArchType)ZigLLVM_spirv64 == Triple::spirv64, "");
-static_assert((Triple::ArchType)ZigLLVM_kalimba == Triple::kalimba, "");
-static_assert((Triple::ArchType)ZigLLVM_shave == Triple::shave, "");
-static_assert((Triple::ArchType)ZigLLVM_lanai == Triple::lanai, "");
-static_assert((Triple::ArchType)ZigLLVM_wasm32 == Triple::wasm32, "");
-static_assert((Triple::ArchType)ZigLLVM_wasm64 == Triple::wasm64, "");
-static_assert((Triple::ArchType)ZigLLVM_renderscript32 == Triple::renderscript32, "");
-static_assert((Triple::ArchType)ZigLLVM_renderscript64 == Triple::renderscript64, "");
-static_assert((Triple::ArchType)ZigLLVM_ve == Triple::ve, "");
-static_assert((Triple::ArchType)ZigLLVM_LastArchType == Triple::LastArchType, "");
-
-static_assert((Triple::VendorType)ZigLLVM_UnknownVendor == Triple::UnknownVendor, "");
-static_assert((Triple::VendorType)ZigLLVM_Apple == Triple::Apple, "");
-static_assert((Triple::VendorType)ZigLLVM_PC == Triple::PC, "");
-static_assert((Triple::VendorType)ZigLLVM_SCEI == Triple::SCEI, "");
-static_assert((Triple::VendorType)ZigLLVM_Freescale == Triple::Freescale, "");
-static_assert((Triple::VendorType)ZigLLVM_IBM == Triple::IBM, "");
-static_assert((Triple::VendorType)ZigLLVM_ImaginationTechnologies == Triple::ImaginationTechnologies, "");
-static_assert((Triple::VendorType)ZigLLVM_MipsTechnologies == Triple::MipsTechnologies, "");
-static_assert((Triple::VendorType)ZigLLVM_NVIDIA == Triple::NVIDIA, "");
-static_assert((Triple::VendorType)ZigLLVM_CSR == Triple::CSR, "");
-static_assert((Triple::VendorType)ZigLLVM_AMD == Triple::AMD, "");
-static_assert((Triple::VendorType)ZigLLVM_Mesa == Triple::Mesa, "");
-static_assert((Triple::VendorType)ZigLLVM_SUSE == Triple::SUSE, "");
-static_assert((Triple::VendorType)ZigLLVM_OpenEmbedded == Triple::OpenEmbedded, "");
-static_assert((Triple::VendorType)ZigLLVM_LastVendorType == Triple::LastVendorType, "");
-
-static_assert((Triple::OSType)ZigLLVM_UnknownOS == Triple::UnknownOS, "");
-static_assert((Triple::OSType)ZigLLVM_Darwin == Triple::Darwin, "");
-static_assert((Triple::OSType)ZigLLVM_DragonFly == Triple::DragonFly, "");
-static_assert((Triple::OSType)ZigLLVM_FreeBSD == Triple::FreeBSD, "");
-static_assert((Triple::OSType)ZigLLVM_Fuchsia == Triple::Fuchsia, "");
-static_assert((Triple::OSType)ZigLLVM_IOS == Triple::IOS, "");
-// Commented out to work around a Debian/Ubuntu bug.
-// See https://github.com/ziglang/zig/issues/2076
-//static_assert((Triple::OSType)ZigLLVM_KFreeBSD == Triple::KFreeBSD, "");
-static_assert((Triple::OSType)ZigLLVM_Linux == Triple::Linux, "");
-static_assert((Triple::OSType)ZigLLVM_Lv2 == Triple::Lv2, "");
-static_assert((Triple::OSType)ZigLLVM_MacOSX == Triple::MacOSX, "");
-static_assert((Triple::OSType)ZigLLVM_NetBSD == Triple::NetBSD, "");
-static_assert((Triple::OSType)ZigLLVM_OpenBSD == Triple::OpenBSD, "");
-static_assert((Triple::OSType)ZigLLVM_Solaris == Triple::Solaris, "");
-static_assert((Triple::OSType)ZigLLVM_UEFI == Triple::UEFI, "");
-static_assert((Triple::OSType)ZigLLVM_Win32 == Triple::Win32, "");
-static_assert((Triple::OSType)ZigLLVM_ZOS == Triple::ZOS, "");
-static_assert((Triple::OSType)ZigLLVM_Haiku == Triple::Haiku, "");
-static_assert((Triple::OSType)ZigLLVM_RTEMS == Triple::RTEMS, "");
-static_assert((Triple::OSType)ZigLLVM_NaCl == Triple::NaCl, "");
-static_assert((Triple::OSType)ZigLLVM_AIX == Triple::AIX, "");
-static_assert((Triple::OSType)ZigLLVM_CUDA == Triple::CUDA, "");
-static_assert((Triple::OSType)ZigLLVM_NVCL == Triple::NVCL, "");
-static_assert((Triple::OSType)ZigLLVM_AMDHSA == Triple::AMDHSA, "");
-static_assert((Triple::OSType)ZigLLVM_PS4 == Triple::PS4, "");
-static_assert((Triple::OSType)ZigLLVM_ELFIAMCU == Triple::ELFIAMCU, "");
-static_assert((Triple::OSType)ZigLLVM_TvOS == Triple::TvOS, "");
-static_assert((Triple::OSType)ZigLLVM_WatchOS == Triple::WatchOS, "");
-static_assert((Triple::OSType)ZigLLVM_BridgeOS == Triple::BridgeOS, "");
-static_assert((Triple::OSType)ZigLLVM_DriverKit == Triple::DriverKit, "");
-static_assert((Triple::OSType)ZigLLVM_XROS == Triple::XROS, "");
-static_assert((Triple::OSType)ZigLLVM_Mesa3D == Triple::Mesa3D, "");
-static_assert((Triple::OSType)ZigLLVM_AMDPAL == Triple::AMDPAL, "");
-static_assert((Triple::OSType)ZigLLVM_HermitCore == Triple::HermitCore, "");
-static_assert((Triple::OSType)ZigLLVM_Hurd == Triple::Hurd, "");
-static_assert((Triple::OSType)ZigLLVM_WASI == Triple::WASI, "");
-static_assert((Triple::OSType)ZigLLVM_Emscripten == Triple::Emscripten, "");
-static_assert((Triple::OSType)ZigLLVM_ShaderModel == Triple::ShaderModel, "");
-static_assert((Triple::OSType)ZigLLVM_LiteOS == Triple::LiteOS, "");
-static_assert((Triple::OSType)ZigLLVM_Serenity == Triple::Serenity, "");
-static_assert((Triple::OSType)ZigLLVM_Vulkan == Triple::Vulkan, "");
-static_assert((Triple::OSType)ZigLLVM_LastOSType == Triple::LastOSType, "");
-
-static_assert((Triple::EnvironmentType)ZigLLVM_UnknownEnvironment == Triple::UnknownEnvironment, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_GNU == Triple::GNU, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_GNUABIN32 == Triple::GNUABIN32, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_GNUABI64 == Triple::GNUABI64, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_GNUEABI == Triple::GNUEABI, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_GNUEABIHF == Triple::GNUEABIHF, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_GNUF32 == Triple::GNUF32, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_GNUF64 == Triple::GNUF64, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_GNUSF == Triple::GNUSF, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_GNUX32 == Triple::GNUX32, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_GNUILP32 == Triple::GNUILP32, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_CODE16 == Triple::CODE16, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_EABI == Triple::EABI, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_EABIHF == Triple::EABIHF, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Android == Triple::Android, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Musl == Triple::Musl, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_MuslEABI == Triple::MuslEABI, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_MuslEABIHF == Triple::MuslEABIHF, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_MuslX32 == Triple::MuslX32, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_MSVC == Triple::MSVC, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Itanium == Triple::Itanium, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Cygnus == Triple::Cygnus, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_CoreCLR == Triple::CoreCLR, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Simulator == Triple::Simulator, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_MacABI == Triple::MacABI, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Pixel == Triple::Pixel, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Vertex == Triple::Vertex, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Geometry == Triple::Geometry, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Hull == Triple::Hull, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Domain == Triple::Domain, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Compute == Triple::Compute, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Library == Triple::Library, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_RayGeneration == Triple::RayGeneration, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Intersection == Triple::Intersection, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_AnyHit == Triple::AnyHit, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_ClosestHit == Triple::ClosestHit, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Miss == Triple::Miss, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Callable == Triple::Callable, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Mesh == Triple::Mesh, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_Amplification == Triple::Amplification, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_OpenCL == Triple::OpenCL, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_OpenHOS == Triple::OpenHOS, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_PAuthTest == Triple::PAuthTest, "");
-static_assert((Triple::EnvironmentType)ZigLLVM_LastEnvironmentType == Triple::LastEnvironmentType, "");
-
-static_assert((Triple::ObjectFormatType)ZigLLVM_UnknownObjectFormat == Triple::UnknownObjectFormat, "");
-static_assert((Triple::ObjectFormatType)ZigLLVM_COFF == Triple::COFF, "");
-static_assert((Triple::ObjectFormatType)ZigLLVM_ELF == Triple::ELF, "");
-static_assert((Triple::ObjectFormatType)ZigLLVM_GOFF == Triple::GOFF, "");
-static_assert((Triple::ObjectFormatType)ZigLLVM_MachO == Triple::MachO, "");
-static_assert((Triple::ObjectFormatType)ZigLLVM_Wasm == Triple::Wasm, "");
-static_assert((Triple::ObjectFormatType)ZigLLVM_XCOFF == Triple::XCOFF, "");
-
-static_assert((CallingConv::ID)ZigLLVM_C == llvm::CallingConv::C, "");
-static_assert((CallingConv::ID)ZigLLVM_Fast == llvm::CallingConv::Fast, "");
-static_assert((CallingConv::ID)ZigLLVM_Cold == llvm::CallingConv::Cold, "");
-static_assert((CallingConv::ID)ZigLLVM_GHC == llvm::CallingConv::GHC, "");
-static_assert((CallingConv::ID)ZigLLVM_HiPE == llvm::CallingConv::HiPE, "");
-static_assert((CallingConv::ID)ZigLLVM_AnyReg == llvm::CallingConv::AnyReg, "");
-static_assert((CallingConv::ID)ZigLLVM_PreserveMost == llvm::CallingConv::PreserveMost, "");
-static_assert((CallingConv::ID)ZigLLVM_PreserveAll == llvm::CallingConv::PreserveAll, "");
-static_assert((CallingConv::ID)ZigLLVM_Swift == llvm::CallingConv::Swift, "");
-static_assert((CallingConv::ID)ZigLLVM_CXX_FAST_TLS == llvm::CallingConv::CXX_FAST_TLS, "");
-static_assert((CallingConv::ID)ZigLLVM_Tail == llvm::CallingConv::Tail, "");
-static_assert((CallingConv::ID)ZigLLVM_CFGuard_Check == llvm::CallingConv::CFGuard_Check, "");
-static_assert((CallingConv::ID)ZigLLVM_SwiftTail == llvm::CallingConv::SwiftTail, "");
-static_assert((CallingConv::ID)ZigLLVM_FirstTargetCC == llvm::CallingConv::FirstTargetCC, "");
-static_assert((CallingConv::ID)ZigLLVM_X86_StdCall == llvm::CallingConv::X86_StdCall, "");
-static_assert((CallingConv::ID)ZigLLVM_X86_FastCall == llvm::CallingConv::X86_FastCall, "");
-static_assert((CallingConv::ID)ZigLLVM_ARM_APCS == llvm::CallingConv::ARM_APCS, "");
-static_assert((CallingConv::ID)ZigLLVM_ARM_AAPCS == llvm::CallingConv::ARM_AAPCS, "");
-static_assert((CallingConv::ID)ZigLLVM_ARM_AAPCS_VFP == llvm::CallingConv::ARM_AAPCS_VFP, "");
-static_assert((CallingConv::ID)ZigLLVM_MSP430_INTR == llvm::CallingConv::MSP430_INTR, "");
-static_assert((CallingConv::ID)ZigLLVM_X86_ThisCall == llvm::CallingConv::X86_ThisCall, "");
-static_assert((CallingConv::ID)ZigLLVM_PTX_Kernel == llvm::CallingConv::PTX_Kernel, "");
-static_assert((CallingConv::ID)ZigLLVM_PTX_Device == llvm::CallingConv::PTX_Device, "");
-static_assert((CallingConv::ID)ZigLLVM_SPIR_FUNC == llvm::CallingConv::SPIR_FUNC, "");
-static_assert((CallingConv::ID)ZigLLVM_SPIR_KERNEL == llvm::CallingConv::SPIR_KERNEL, "");
-static_assert((CallingConv::ID)ZigLLVM_Intel_OCL_BI == llvm::CallingConv::Intel_OCL_BI, "");
-static_assert((CallingConv::ID)ZigLLVM_X86_64_SysV == llvm::CallingConv::X86_64_SysV, "");
-static_assert((CallingConv::ID)ZigLLVM_Win64 == llvm::CallingConv::Win64, "");
-static_assert((CallingConv::ID)ZigLLVM_X86_VectorCall == llvm::CallingConv::X86_VectorCall, "");
-static_assert((CallingConv::ID)ZigLLVM_DUMMY_HHVM == llvm::CallingConv::DUMMY_HHVM, "");
-static_assert((CallingConv::ID)ZigLLVM_DUMMY_HHVM_C == llvm::CallingConv::DUMMY_HHVM_C, "");
-static_assert((CallingConv::ID)ZigLLVM_X86_INTR == llvm::CallingConv::X86_INTR, "");
-static_assert((CallingConv::ID)ZigLLVM_AVR_INTR == llvm::CallingConv::AVR_INTR, "");
-static_assert((CallingConv::ID)ZigLLVM_AVR_SIGNAL == llvm::CallingConv::AVR_SIGNAL, "");
-static_assert((CallingConv::ID)ZigLLVM_AVR_BUILTIN == llvm::CallingConv::AVR_BUILTIN, "");
-static_assert((CallingConv::ID)ZigLLVM_AMDGPU_VS == llvm::CallingConv::AMDGPU_VS, "");
-static_assert((CallingConv::ID)ZigLLVM_AMDGPU_GS == llvm::CallingConv::AMDGPU_GS, "");
-static_assert((CallingConv::ID)ZigLLVM_AMDGPU_PS == llvm::CallingConv::AMDGPU_PS, "");
-static_assert((CallingConv::ID)ZigLLVM_AMDGPU_CS == llvm::CallingConv::AMDGPU_CS, "");
-static_assert((CallingConv::ID)ZigLLVM_AMDGPU_KERNEL == llvm::CallingConv::AMDGPU_KERNEL, "");
-static_assert((CallingConv::ID)ZigLLVM_X86_RegCall == llvm::CallingConv::X86_RegCall, "");
-static_assert((CallingConv::ID)ZigLLVM_AMDGPU_HS == llvm::CallingConv::AMDGPU_HS, "");
-static_assert((CallingConv::ID)ZigLLVM_MSP430_BUILTIN == llvm::CallingConv::MSP430_BUILTIN, "");
-static_assert((CallingConv::ID)ZigLLVM_AMDGPU_LS == llvm::CallingConv::AMDGPU_LS, "");
-static_assert((CallingConv::ID)ZigLLVM_AMDGPU_ES == llvm::CallingConv::AMDGPU_ES, "");
-static_assert((CallingConv::ID)ZigLLVM_AArch64_VectorCall == llvm::CallingConv::AArch64_VectorCall, "");
-static_assert((CallingConv::ID)ZigLLVM_AArch64_SVE_VectorCall == llvm::CallingConv::AArch64_SVE_VectorCall, "");
-static_assert((CallingConv::ID)ZigLLVM_WASM_EmscriptenInvoke == llvm::CallingConv::WASM_EmscriptenInvoke, "");
-static_assert((CallingConv::ID)ZigLLVM_AMDGPU_Gfx == llvm::CallingConv::AMDGPU_Gfx, "");
-static_assert((CallingConv::ID)ZigLLVM_M68k_INTR == llvm::CallingConv::M68k_INTR, "");
-static_assert((CallingConv::ID)ZigLLVM_AArch64_SME_ABI_Support_Routines_PreserveMost_From_X0 == llvm::CallingConv::AArch64_SME_ABI_Support_Routines_PreserveMost_From_X0, "");
-static_assert((CallingConv::ID)ZigLLVM_AArch64_SME_ABI_Support_Routines_PreserveMost_From_X2 == llvm::CallingConv::AArch64_SME_ABI_Support_Routines_PreserveMost_From_X2, "");
-static_assert((CallingConv::ID)ZigLLVM_AMDGPU_CS_Chain == llvm::CallingConv::AMDGPU_CS_Chain, "");
-static_assert((CallingConv::ID)ZigLLVM_AMDGPU_CS_ChainPreserve == llvm::CallingConv::AMDGPU_CS_ChainPreserve, "");
-static_assert((CallingConv::ID)ZigLLVM_M68k_RTD == llvm::CallingConv::M68k_RTD, "");
-static_assert((CallingConv::ID)ZigLLVM_GRAAL == llvm::CallingConv::GRAAL, "");
-static_assert((CallingConv::ID)ZigLLVM_ARM64EC_Thunk_X64 == llvm::CallingConv::ARM64EC_Thunk_X64, "");
-static_assert((CallingConv::ID)ZigLLVM_ARM64EC_Thunk_Native == llvm::CallingConv::ARM64EC_Thunk_Native, "");
-static_assert((CallingConv::ID)ZigLLVM_MaxID == llvm::CallingConv::MaxID, "");
+static_assert((FloatABI::ABIType)ZigLLVMFloatABI_Default == FloatABI::ABIType::Default, "");
+static_assert((FloatABI::ABIType)ZigLLVMFloatABI_Soft == FloatABI::ABIType::Soft, "");
+static_assert((FloatABI::ABIType)ZigLLVMFloatABI_Hard == FloatABI::ABIType::Hard, "");
+
+static_assert((object::Archive::Kind)ZigLLVMArchiveKind_GNU == object::Archive::Kind::K_GNU, "");
+static_assert((object::Archive::Kind)ZigLLVMArchiveKind_GNU64 == object::Archive::Kind::K_GNU64, "");
+static_assert((object::Archive::Kind)ZigLLVMArchiveKind_BSD == object::Archive::Kind::K_BSD, "");
+static_assert((object::Archive::Kind)ZigLLVMArchiveKind_DARWIN == object::Archive::Kind::K_DARWIN, "");
+static_assert((object::Archive::Kind)ZigLLVMArchiveKind_DARWIN64 == object::Archive::Kind::K_DARWIN64, "");
+static_assert((object::Archive::Kind)ZigLLVMArchiveKind_COFF == object::Archive::Kind::K_COFF, "");
+static_assert((object::Archive::Kind)ZigLLVMArchiveKind_AIXBIG == object::Archive::Kind::K_AIXBIG, "");
diff --git a/zig/src/zig_llvm.h b/zig/src/zig_llvm.h
index 2eb6ae290f..d2a85405e6 100644
--- a/zig/src/zig_llvm.h
+++ b/zig/src/zig_llvm.h
@@ -24,7 +24,8 @@
 // ATTENTION: If you modify this file, be sure to update the corresponding
 // extern function declarations in the self-hosted compiler.
 
-
+// synchronize with llvm/include/Transforms/Instrumentation.h::SanitizerCoverageOptions::Type
+// synchronize with codegen/llvm/bindings.zig::TargetMachine::EmitOptions::Coverage::Type
 enum ZigLLVMCoverageType {
     ZigLLVMCoverageType_None = 0,
     ZigLLVMCoverageType_Function,
@@ -67,18 +68,32 @@ struct ZigLLVMEmitOptions {
     ZigLLVMCoverageOptions coverage;
 };
 
-ZIG_EXTERN_C bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref,
-        char **error_message, const struct ZigLLVMEmitOptions *options);
+// synchronize with llvm/include/Object/Archive.h::Object::Archive::Kind
+// synchronize with codegen/llvm/bindings.zig::ArchiveKind
+enum ZigLLVMArchiveKind {
+    ZigLLVMArchiveKind_GNU,
+    ZigLLVMArchiveKind_GNU64,
+    ZigLLVMArchiveKind_BSD,
+    ZigLLVMArchiveKind_DARWIN,
+    ZigLLVMArchiveKind_DARWIN64,
+    ZigLLVMArchiveKind_COFF,
+    ZigLLVMArchiveKind_AIXBIG,
+};
 
-enum ZigLLVMABIType {
-    ZigLLVMABITypeDefault, // Target-specific (either soft or hard depending on triple, etc).
-    ZigLLVMABITypeSoft,    // Soft float.
-    ZigLLVMABITypeHard     // Hard float.
+// synchronize with llvm/include/Target/TargetOptions.h::FloatABI::ABIType
+// synchronize with codegen/llvm/bindings.zig::TargetMachine::FloatABI
+enum ZigLLVMFloatABI {
+    ZigLLVMFloatABI_Default, // Target-specific (either soft or hard depending on triple, etc).
+    ZigLLVMFloatABI_Soft,    // Soft float.
+    ZigLLVMFloatABI_Hard     // Hard float.
 };
 
+ZIG_EXTERN_C bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref,
+    char **error_message, const ZigLLVMEmitOptions *options);
+
 ZIG_EXTERN_C LLVMTargetMachineRef ZigLLVMCreateTargetMachine(LLVMTargetRef T, const char *Triple,
     const char *CPU, const char *Features, LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc,
-    LLVMCodeModel CodeModel, bool function_sections, bool data_sections, enum ZigLLVMABIType float_abi,
+    LLVMCodeModel CodeModel, bool function_sections, bool data_sections, ZigLLVMFloatABI float_abi,
     const char *abi_name);
 
 ZIG_EXTERN_C void ZigLLVMSetOptBisectLimit(LLVMContextRef context_ref, int limit);
@@ -86,323 +101,16 @@ ZIG_EXTERN_C void ZigLLVMSetOptBisectLimit(LLVMContextRef context_ref, int limit
 ZIG_EXTERN_C void ZigLLVMEnableBrokenDebugInfoCheck(LLVMContextRef context_ref);
 ZIG_EXTERN_C bool ZigLLVMGetBrokenDebugInfo(LLVMContextRef context_ref);
 
-enum ZigLLVMTailCallKind {
-    ZigLLVMTailCallKindNone,
-    ZigLLVMTailCallKindTail,
-    ZigLLVMTailCallKindMustTail,
-    ZigLLVMTailCallKindNoTail,
-};
-
-enum ZigLLVM_CallingConv {
-    ZigLLVM_C = 0,
-    ZigLLVM_Fast = 8,
-    ZigLLVM_Cold = 9,
-    ZigLLVM_GHC = 10,
-    ZigLLVM_HiPE = 11,
-    ZigLLVM_AnyReg = 13,
-    ZigLLVM_PreserveMost = 14,
-    ZigLLVM_PreserveAll = 15,
-    ZigLLVM_Swift = 16,
-    ZigLLVM_CXX_FAST_TLS = 17,
-    ZigLLVM_Tail = 18,
-    ZigLLVM_CFGuard_Check = 19,
-    ZigLLVM_SwiftTail = 20,
-    ZigLLVM_FirstTargetCC = 64,
-    ZigLLVM_X86_StdCall = 64,
-    ZigLLVM_X86_FastCall = 65,
-    ZigLLVM_ARM_APCS = 66,
-    ZigLLVM_ARM_AAPCS = 67,
-    ZigLLVM_ARM_AAPCS_VFP = 68,
-    ZigLLVM_MSP430_INTR = 69,
-    ZigLLVM_X86_ThisCall = 70,
-    ZigLLVM_PTX_Kernel = 71,
-    ZigLLVM_PTX_Device = 72,
-    ZigLLVM_SPIR_FUNC = 75,
-    ZigLLVM_SPIR_KERNEL = 76,
-    ZigLLVM_Intel_OCL_BI = 77,
-    ZigLLVM_X86_64_SysV = 78,
-    ZigLLVM_Win64 = 79,
-    ZigLLVM_X86_VectorCall = 80,
-    ZigLLVM_DUMMY_HHVM = 81,
-    ZigLLVM_DUMMY_HHVM_C = 82,
-    ZigLLVM_X86_INTR = 83,
-    ZigLLVM_AVR_INTR = 84,
-    ZigLLVM_AVR_SIGNAL = 85,
-    ZigLLVM_AVR_BUILTIN = 86,
-    ZigLLVM_AMDGPU_VS = 87,
-    ZigLLVM_AMDGPU_GS = 88,
-    ZigLLVM_AMDGPU_PS = 89,
-    ZigLLVM_AMDGPU_CS = 90,
-    ZigLLVM_AMDGPU_KERNEL = 91,
-    ZigLLVM_X86_RegCall = 92,
-    ZigLLVM_AMDGPU_HS = 93,
-    ZigLLVM_MSP430_BUILTIN = 94,
-    ZigLLVM_AMDGPU_LS = 95,
-    ZigLLVM_AMDGPU_ES = 96,
-    ZigLLVM_AArch64_VectorCall = 97,
-    ZigLLVM_AArch64_SVE_VectorCall = 98,
-    ZigLLVM_WASM_EmscriptenInvoke = 99,
-    ZigLLVM_AMDGPU_Gfx = 100,
-    ZigLLVM_M68k_INTR = 101,
-    ZigLLVM_AArch64_SME_ABI_Support_Routines_PreserveMost_From_X0 = 102,
-    ZigLLVM_AArch64_SME_ABI_Support_Routines_PreserveMost_From_X2 = 103,
-    ZigLLVM_AMDGPU_CS_Chain = 104,
-    ZigLLVM_AMDGPU_CS_ChainPreserve = 105,
-    ZigLLVM_M68k_RTD = 106,
-    ZigLLVM_GRAAL = 107,
-    ZigLLVM_ARM64EC_Thunk_X64 = 108,
-    ZigLLVM_ARM64EC_Thunk_Native = 109,
-    ZigLLVM_MaxID = 1023,
-};
-
 ZIG_EXTERN_C void ZigLLVMParseCommandLineOptions(size_t argc, const char *const *argv);
 
-// synchronize with llvm/include/ADT/Triple.h::ArchType
-// synchronize with std.Target.Cpu.Arch
-// synchronize with codegen/llvm/bindings.zig::ArchType
-enum ZigLLVM_ArchType {
-    ZigLLVM_UnknownArch,
-
-    ZigLLVM_arm,            // ARM (little endian): arm, armv.*, xscale
-    ZigLLVM_armeb,          // ARM (big endian): armeb
-    ZigLLVM_aarch64,        // AArch64 (little endian): aarch64
-    ZigLLVM_aarch64_be,     // AArch64 (big endian): aarch64_be
-    ZigLLVM_aarch64_32,     // AArch64 (little endian) ILP32: aarch64_32
-    ZigLLVM_arc,            // ARC: Synopsys ARC
-    ZigLLVM_avr,            // AVR: Atmel AVR microcontroller
-    ZigLLVM_bpfel,          // eBPF or extended BPF or 64-bit BPF (little endian)
-    ZigLLVM_bpfeb,          // eBPF or extended BPF or 64-bit BPF (big endian)
-    ZigLLVM_csky,           // CSKY: csky
-    ZigLLVM_dxil,           // DXIL 32-bit DirectX bytecode
-    ZigLLVM_hexagon,        // Hexagon: hexagon
-    ZigLLVM_loongarch32,    // LoongArch (32-bit): loongarch32
-    ZigLLVM_loongarch64,    // LoongArch (64-bit): loongarch64
-    ZigLLVM_m68k,           // M68k: Motorola 680x0 family
-    ZigLLVM_mips,           // MIPS: mips, mipsallegrex, mipsr6
-    ZigLLVM_mipsel,         // MIPSEL: mipsel, mipsallegrexe, mipsr6el
-    ZigLLVM_mips64,         // MIPS64: mips64, mips64r6, mipsn32, mipsn32r6
-    ZigLLVM_mips64el,       // MIPS64EL: mips64el, mips64r6el, mipsn32el, mipsn32r6el
-    ZigLLVM_msp430,         // MSP430: msp430
-    ZigLLVM_ppc,            // PPC: powerpc
-    ZigLLVM_ppcle,          // PPCLE: powerpc (little endian)
-    ZigLLVM_ppc64,          // PPC64: powerpc64, ppu
-    ZigLLVM_ppc64le,        // PPC64LE: powerpc64le
-    ZigLLVM_r600,           // R600: AMD GPUs HD2XXX - HD6XXX
-    ZigLLVM_amdgcn,         // AMDGCN: AMD GCN GPUs
-    ZigLLVM_riscv32,        // RISC-V (32-bit): riscv32
-    ZigLLVM_riscv64,        // RISC-V (64-bit): riscv64
-    ZigLLVM_sparc,          // Sparc: sparc
-    ZigLLVM_sparcv9,        // Sparcv9: Sparcv9
-    ZigLLVM_sparcel,        // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant
-    ZigLLVM_systemz,        // SystemZ: s390x
-    ZigLLVM_tce,            // TCE (http://tce.cs.tut.fi/): tce
-    ZigLLVM_tcele,          // TCE little endian (http://tce.cs.tut.fi/): tcele
-    ZigLLVM_thumb,          // Thumb (little endian): thumb, thumbv.*
-    ZigLLVM_thumbeb,        // Thumb (big endian): thumbeb
-    ZigLLVM_x86,            // X86: i[3-9]86
-    ZigLLVM_x86_64,         // X86-64: amd64, x86_64
-    ZigLLVM_xcore,          // XCore: xcore
-    ZigLLVM_xtensa,         // Tensilica: Xtensa
-    ZigLLVM_nvptx,          // NVPTX: 32-bit
-    ZigLLVM_nvptx64,        // NVPTX: 64-bit
-    ZigLLVM_le32,           // le32: generic little-endian 32-bit CPU (PNaCl)
-    ZigLLVM_le64,           // le64: generic little-endian 64-bit CPU (PNaCl)
-    ZigLLVM_amdil,          // AMDIL
-    ZigLLVM_amdil64,        // AMDIL with 64-bit pointers
-    ZigLLVM_hsail,          // AMD HSAIL
-    ZigLLVM_hsail64,        // AMD HSAIL with 64-bit pointers
-    ZigLLVM_spir,           // SPIR: standard portable IR for OpenCL 32-bit version
-    ZigLLVM_spir64,         // SPIR: standard portable IR for OpenCL 64-bit version
-    ZigLLVM_spirv,          // SPIR-V with logical memory layout.
-    ZigLLVM_spirv32,        // SPIR-V with 32-bit pointers
-    ZigLLVM_spirv64,        // SPIR-V with 64-bit pointers
-    ZigLLVM_kalimba,        // Kalimba: generic kalimba
-    ZigLLVM_shave,          // SHAVE: Movidius vector VLIW processors
-    ZigLLVM_lanai,          // Lanai: Lanai 32-bit
-    ZigLLVM_wasm32,         // WebAssembly with 32-bit pointers
-    ZigLLVM_wasm64,         // WebAssembly with 64-bit pointers
-    ZigLLVM_renderscript32, // 32-bit RenderScript
-    ZigLLVM_renderscript64, // 64-bit RenderScript
-    ZigLLVM_ve,             // NEC SX-Aurora Vector Engine
-    ZigLLVM_LastArchType = ZigLLVM_ve
-};
-
-enum ZigLLVM_VendorType {
-    ZigLLVM_UnknownVendor,
-
-    ZigLLVM_Apple,
-    ZigLLVM_PC,
-    ZigLLVM_SCEI,
-    ZigLLVM_Freescale,
-    ZigLLVM_IBM,
-    ZigLLVM_ImaginationTechnologies,
-    ZigLLVM_MipsTechnologies,
-    ZigLLVM_NVIDIA,
-    ZigLLVM_CSR,
-    ZigLLVM_AMD,
-    ZigLLVM_Mesa,
-    ZigLLVM_SUSE,
-    ZigLLVM_OpenEmbedded,
-
-    ZigLLVM_LastVendorType = ZigLLVM_OpenEmbedded
-};
-
-// synchronize with llvm/include/ADT/Triple.h::OsType
-// synchronize with std.Target.Os.Tag
-// synchronize with codegen/llvm/bindings.zig::OsType
-enum ZigLLVM_OSType {
-    ZigLLVM_UnknownOS,
-
-    ZigLLVM_Darwin,
-    ZigLLVM_DragonFly,
-    ZigLLVM_FreeBSD,
-    ZigLLVM_Fuchsia,
-    ZigLLVM_IOS,
-    ZigLLVM_KFreeBSD,
-    ZigLLVM_Linux,
-    ZigLLVM_Lv2,        // PS3
-    ZigLLVM_MacOSX,
-    ZigLLVM_NetBSD,
-    ZigLLVM_OpenBSD,
-    ZigLLVM_Solaris,
-    ZigLLVM_UEFI,
-    ZigLLVM_Win32,
-    ZigLLVM_ZOS,
-    ZigLLVM_Haiku,
-    ZigLLVM_RTEMS,
-    ZigLLVM_NaCl,       // Native Client
-    ZigLLVM_AIX,
-    ZigLLVM_CUDA,       // NVIDIA CUDA
-    ZigLLVM_NVCL,       // NVIDIA OpenCL
-    ZigLLVM_AMDHSA,     // AMD HSA Runtime
-    ZigLLVM_PS4,
-    ZigLLVM_PS5,
-    ZigLLVM_ELFIAMCU,
-    ZigLLVM_TvOS,       // Apple tvOS
-    ZigLLVM_WatchOS,    // Apple watchOS
-    ZigLLVM_BridgeOS,   // Apple bridgeOS
-    ZigLLVM_DriverKit,  // Apple DriverKit
-    ZigLLVM_XROS,       // Apple XROS
-    ZigLLVM_Mesa3D,
-    ZigLLVM_AMDPAL,     // AMD PAL Runtime
-    ZigLLVM_HermitCore, // HermitCore Unikernel/Multikernel
-    ZigLLVM_Hurd,       // GNU/Hurd
-    ZigLLVM_WASI,       // Experimental WebAssembly OS
-    ZigLLVM_Emscripten,
-    ZigLLVM_ShaderModel, // DirectX ShaderModel
-    ZigLLVM_LiteOS,
-    ZigLLVM_Serenity,
-    ZigLLVM_Vulkan,      // Vulkan SPIR-V
-    ZigLLVM_LastOSType = ZigLLVM_Vulkan
-};
-
-// Synchronize with target.cpp::abi_list
-enum ZigLLVM_EnvironmentType {
-    ZigLLVM_UnknownEnvironment,
-
-    ZigLLVM_GNU,
-    ZigLLVM_GNUABIN32,
-    ZigLLVM_GNUABI64,
-    ZigLLVM_GNUEABI,
-    ZigLLVM_GNUEABIHF,
-    ZigLLVM_GNUF32,
-    ZigLLVM_GNUF64,
-    ZigLLVM_GNUSF,
-    ZigLLVM_GNUX32,
-    ZigLLVM_GNUILP32,
-    ZigLLVM_CODE16,
-    ZigLLVM_EABI,
-    ZigLLVM_EABIHF,
-    ZigLLVM_Android,
-    ZigLLVM_Musl,
-    ZigLLVM_MuslEABI,
-    ZigLLVM_MuslEABIHF,
-    ZigLLVM_MuslX32,
-
-    ZigLLVM_MSVC,
-    ZigLLVM_Itanium,
-    ZigLLVM_Cygnus,
-    ZigLLVM_CoreCLR,
-    ZigLLVM_Simulator, // Simulator variants of other systems, e.g., Apple's iOS
-    ZigLLVM_MacABI, // Mac Catalyst variant of Apple's iOS deployment target.
-
-    ZigLLVM_Pixel,
-    ZigLLVM_Vertex,
-    ZigLLVM_Geometry,
-    ZigLLVM_Hull,
-    ZigLLVM_Domain,
-    ZigLLVM_Compute,
-    ZigLLVM_Library,
-    ZigLLVM_RayGeneration,
-    ZigLLVM_Intersection,
-    ZigLLVM_AnyHit,
-    ZigLLVM_ClosestHit,
-    ZigLLVM_Miss,
-    ZigLLVM_Callable,
-    ZigLLVM_Mesh,
-    ZigLLVM_Amplification,
-    ZigLLVM_OpenCL,
-    ZigLLVM_OpenHOS,
-
-    ZigLLVM_PAuthTest,
-
-    ZigLLVM_LastEnvironmentType = ZigLLVM_PAuthTest
-};
-
-enum ZigLLVM_ObjectFormatType {
-    ZigLLVM_UnknownObjectFormat,
-
-    ZigLLVM_COFF,
-    ZigLLVM_DXContainer,
-    ZigLLVM_ELF,
-    ZigLLVM_GOFF,
-    ZigLLVM_MachO,
-    ZigLLVM_SPIRV,
-    ZigLLVM_Wasm,
-    ZigLLVM_XCOFF,
-};
-
-#define ZigLLVM_DIFlags_Zero 0U
-#define ZigLLVM_DIFlags_Private 1U
-#define ZigLLVM_DIFlags_Protected 2U
-#define ZigLLVM_DIFlags_Public 3U
-#define ZigLLVM_DIFlags_FwdDecl (1U << 2)
-#define ZigLLVM_DIFlags_AppleBlock (1U << 3)
-#define ZigLLVM_DIFlags_BlockByrefStruct (1U << 4)
-#define ZigLLVM_DIFlags_Virtual (1U << 5)
-#define ZigLLVM_DIFlags_Artificial (1U << 6)
-#define ZigLLVM_DIFlags_Explicit (1U << 7)
-#define ZigLLVM_DIFlags_Prototyped (1U << 8)
-#define ZigLLVM_DIFlags_ObjcClassComplete (1U << 9)
-#define ZigLLVM_DIFlags_ObjectPointer (1U << 10)
-#define ZigLLVM_DIFlags_Vector (1U << 11)
-#define ZigLLVM_DIFlags_StaticMember (1U << 12)
-#define ZigLLVM_DIFlags_LValueReference (1U << 13)
-#define ZigLLVM_DIFlags_RValueReference (1U << 14)
-#define ZigLLVM_DIFlags_Reserved (1U << 15)
-#define ZigLLVM_DIFlags_SingleInheritance (1U << 16)
-#define ZigLLVM_DIFlags_MultipleInheritance (2 << 16)
-#define ZigLLVM_DIFlags_VirtualInheritance (3 << 16)
-#define ZigLLVM_DIFlags_IntroducedVirtual (1U << 18)
-#define ZigLLVM_DIFlags_BitField (1U << 19)
-#define ZigLLVM_DIFlags_NoReturn (1U << 20)
-#define ZigLLVM_DIFlags_TypePassByValue (1U << 22)
-#define ZigLLVM_DIFlags_TypePassByReference (1U << 23)
-#define ZigLLVM_DIFlags_EnumClass (1U << 24)
-#define ZigLLVM_DIFlags_Thunk (1U << 25)
-#define ZigLLVM_DIFlags_NonTrivial (1U << 26)
-#define ZigLLVM_DIFlags_BigEndian (1U << 27)
-#define ZigLLVM_DIFlags_LittleEndian (1U << 28)
-#define ZigLLVM_DIFlags_AllCallsDescribed (1U << 29)
-
 ZIG_EXTERN_C bool ZigLLDLinkCOFF(int argc, const char **argv, bool can_exit_early, bool disable_output);
 ZIG_EXTERN_C bool ZigLLDLinkELF(int argc, const char **argv, bool can_exit_early, bool disable_output);
 ZIG_EXTERN_C bool ZigLLDLinkWasm(int argc, const char **argv, bool can_exit_early, bool disable_output);
 
 ZIG_EXTERN_C bool ZigLLVMWriteArchive(const char *archive_name, const char **file_names, size_t file_name_count,
-        enum ZigLLVM_OSType os_type);
+    ZigLLVMArchiveKind archive_kind);
 
-ZIG_EXTERN_C bool ZigLLVMWriteImportLibrary(const char *def_path, const enum ZigLLVM_ArchType arch,
-                               const char *output_lib_path, bool kill_at);
+ZIG_EXTERN_C bool ZigLLVMWriteImportLibrary(const char *def_path, unsigned int coff_machine,
+    const char *output_lib_path, bool kill_at);
 
 #endif
diff --git a/zig/stage1/wasi.c b/zig/stage1/wasi.c
index b4533e0a3f..9d35efd280 100644
--- a/zig/stage1/wasi.c
+++ b/zig/stage1/wasi.c
@@ -184,6 +184,26 @@ enum wasi_whence {
     wasi_whence_end = 2,
 };
 
+extern uint16_t load16_align0(const uint8_t *ptr);
+extern uint16_t load16_align1(const uint16_t *ptr);
+extern uint32_t load32_align0(const uint8_t *ptr);
+extern uint32_t load32_align1(const uint16_t *ptr);
+extern uint32_t load32_align2(const uint32_t *ptr);
+extern uint64_t load64_align0(const uint8_t *ptr);
+extern uint64_t load64_align1(const uint16_t *ptr);
+extern uint64_t load64_align2(const uint32_t *ptr);
+extern uint64_t load64_align3(const uint64_t *ptr);
+
+extern void store16_align0(uint8_t *ptr, uint16_t val);
+extern void store16_align1(uint16_t *ptr, uint16_t val);
+extern void store32_align0(uint8_t *ptr, uint32_t val);
+extern void store32_align1(uint16_t *ptr, uint32_t val);
+extern void store32_align2(uint32_t *ptr, uint32_t val);
+extern void store64_align0(uint8_t *ptr, uint64_t val);
+extern void store64_align1(uint16_t *ptr, uint64_t val);
+extern void store64_align2(uint32_t *ptr, uint64_t val);
+extern void store64_align3(uint64_t *ptr, uint64_t val);
+
 extern uint8_t **const wasm_memory;
 extern void wasm__start(void);
 
@@ -362,14 +382,14 @@ static enum wasi_errno DirEntry_lookup(uint32_t dir_fd, uint32_t flags, const ch
 }
 
 static void DirEntry_filestat(uint32_t de, struct wasi_filestat *res_filestat) {
-    res_filestat->dev = 0;
-    res_filestat->ino = de;
-    res_filestat->filetype = des[de].filetype;
-    res_filestat->nlink = 1;
-    res_filestat->size = 0;
-    res_filestat->atim = des[de].atim * UINT64_C(1000000000);
-    res_filestat->mtim = des[de].mtim * UINT64_C(1000000000);
-    res_filestat->ctim = des[de].ctim * UINT64_C(1000000000);
+    store64_align3(&res_filestat->dev, 0);
+    store64_align3(&res_filestat->ino, de);
+    store64_align3(&res_filestat->filetype, des[de].filetype);
+    store64_align3(&res_filestat->nlink, 1);
+    store64_align3(&res_filestat->size, 0);
+    store64_align3(&res_filestat->atim, des[de].atim * UINT64_C(1000000000));
+    store64_align3(&res_filestat->mtim, des[de].mtim * UINT64_C(1000000000));
+    store64_align3(&res_filestat->ctim, des[de].ctim * UINT64_C(1000000000));
 }
 
 static void DirEntry_unlink(uint32_t de) {
@@ -394,8 +414,8 @@ uint32_t wasi_snapshot_preview1_args_sizes_get(uint32_t argv_size, uint32_t argv
         if (i == 1) continue;
         size += strlen(c_argv[i]) + 1;
     }
-    *argv_size_ptr = c_argc - 1;
-    *argv_buf_size_ptr = size;
+    store32_align2(argv_size_ptr, c_argc - 1);
+    store32_align2(argv_buf_size_ptr, size);
     return wasi_errno_success;
 }
 
@@ -413,7 +433,7 @@ uint32_t wasi_snapshot_preview1_args_get(uint32_t argv, uint32_t argv_buf) {
     uint32_t argv_buf_i = 0;
     for (int src_i = 0; src_i < c_argc; src_i += 1) {
         if (src_i == 1) continue;
-        argv_ptr[dst_i] = argv_buf + argv_buf_i;
+        store32_align2(&argv_ptr[dst_i], argv_buf + argv_buf_i);
         dst_i += 1;
         strcpy(&argv_buf_ptr[argv_buf_i], c_argv[src_i]);
         argv_buf_i += strlen(c_argv[src_i]) + 1;
@@ -430,8 +450,8 @@ uint32_t wasi_snapshot_preview1_fd_prestat_get(uint32_t fd, uint32_t res_prestat
 
     if (fd >= fd_len || fds[fd].de >= de_len) return wasi_errno_badf;
 
-    res_prestat_ptr[0] = 0;
-    res_prestat_ptr[1] = strlen(des[fds[fd].de].guest_path);
+    store32_align2(&res_prestat_ptr[0], 0);
+    store32_align2(&res_prestat_ptr[1], strlen(des[fds[fd].de].guest_path));
     return wasi_errno_success;
 }
 
@@ -443,7 +463,7 @@ uint32_t wasi_snapshot_preview1_fd_prestat_dir_name(uint32_t fd, uint32_t path,
 #endif
 
     if (fd >= fd_len || fds[fd].de >= de_len) return wasi_errno_badf;
-    strncpy(path_ptr, des[fds[fd].de].guest_path, path_len);
+        strncpy(path_ptr, des[fds[fd].de].guest_path, path_len);
     return wasi_errno_success;
 }
 
@@ -502,15 +522,16 @@ uint32_t wasi_snapshot_preview1_fd_read(uint32_t fd, uint32_t iovs, uint32_t iov
 
     size_t size = 0;
     for (uint32_t i = 0; i < iovs_len; i += 1) {
+        uint32_t len = load32_align2(&iovs_ptr[i].len);
         size_t read_size = 0;
         if (fds[fd].stream != NULL)
-            read_size = fread(&m[iovs_ptr[i].ptr], 1, iovs_ptr[i].len, fds[fd].stream);
+            read_size = fread(&m[load32_align2(&iovs_ptr[i].ptr)], 1, len, fds[fd].stream);
         size += read_size;
-        if (read_size < iovs_ptr[i].len) break;
+        if (read_size < len) break;
     }
 
     if (size > 0) des[fds[fd].de].atim = time(NULL);
-    *res_size_ptr = size;
+    store32_align2(res_size_ptr, size);
     return wasi_errno_success;
 }
 
@@ -530,7 +551,7 @@ uint32_t wasi_snapshot_preview1_fd_filestat_get(uint32_t fd, uint32_t res_filest
     if (fseek(fds[fd].stream, 0, SEEK_END) < 0) return wasi_errno_io;
     long size = ftell(fds[fd].stream);
     if (size < 0) return wasi_errno_io;
-    res_filestat_ptr->size = size;
+    store64_align3(&res_filestat_ptr->size, size);
     if (fsetpos(fds[fd].stream, &pos) < 0) return wasi_errno_io;
     return wasi_errno_success;
 }
@@ -617,13 +638,14 @@ uint32_t wasi_snapshot_preview1_fd_pwrite(uint32_t fd, uint32_t iovs, uint32_t i
 
     size_t size = 0;
     for (uint32_t i = 0; i < iovs_len; i += 1) {
+        uint32_t len = load32_align2(&iovs_ptr[i].len);
         size_t written_size = 0;
         if (fds[fd].stream != NULL)
-            written_size = fwrite(&m[iovs_ptr[i].ptr], 1, iovs_ptr[i].len, fds[fd].stream);
+            written_size = fwrite(&m[load32_align2(&iovs_ptr[i].ptr)], 1, len, fds[fd].stream);
         else
-            written_size = iovs_ptr[i].len;
+            written_size = len;
         size += written_size;
-        if (written_size < iovs_ptr[i].len) break;
+        if (written_size < len) break;
     }
 
     if (fsetpos(fds[fd].stream, &pos) < 0) return wasi_errno_io;
@@ -633,7 +655,7 @@ uint32_t wasi_snapshot_preview1_fd_pwrite(uint32_t fd, uint32_t iovs, uint32_t i
         des[fds[fd].de].atim = now;
         des[fds[fd].de].mtim = now;
     }
-    *res_size_ptr = size;
+    store32_align2(res_size_ptr, size);
     return wasi_errno_success;
 }
 
@@ -669,8 +691,8 @@ uint32_t wasi_snapshot_preview1_environ_sizes_get(uint32_t environ_size, uint32_
     fprintf(stderr, "wasi_snapshot_preview1_environ_sizes_get()\n");
 #endif
 
-    *environ_size_ptr = 0;
-    *environ_buf_size_ptr = 0;
+    store32_align2(environ_size_ptr, 0);
+    store32_align2(environ_buf_size_ptr, 0);
     return wasi_errno_success;
 }
 
@@ -702,7 +724,7 @@ uint32_t wasi_snapshot_preview1_path_filestat_get(uint32_t fd, uint32_t flags, u
         if (stream != NULL) {
             if (fseek(stream, 0, SEEK_END) >= 0) {
                 long size = ftell(stream);
-                if (size >= 0) res_filestat_ptr->size = size;
+                if (size >= 0) store64_align3(&res_filestat_ptr->size, size);
             }
             fclose(stream);
         }
@@ -718,10 +740,10 @@ uint32_t wasi_snapshot_preview1_fd_fdstat_get(uint32_t fd, uint32_t res_fdstat)
 #endif
 
     if (fd >= fd_len || fds[fd].de >= de_len) return wasi_errno_badf;
-    res_fdstat_ptr->fs_filetype = des[fds[fd].de].filetype;
-    res_fdstat_ptr->fs_flags = fds[fd].fdflags;
-    res_fdstat_ptr->padding = 0;
-    res_fdstat_ptr->fs_rights_inheriting = fds[fd].fs_rights_inheriting;
+    store16_align1(&res_fdstat_ptr->fs_filetype, des[fds[fd].de].filetype);
+    store16_align1(&res_fdstat_ptr->fs_flags, fds[fd].fdflags);
+    store32_align2(&res_fdstat_ptr->padding, 0);
+    store64_align3(&res_fdstat_ptr->fs_rights_inheriting, fds[fd].fs_rights_inheriting);
     return wasi_errno_success;
 }
 
@@ -757,13 +779,14 @@ uint32_t wasi_snapshot_preview1_fd_write(uint32_t fd, uint32_t iovs, uint32_t io
 
     size_t size = 0;
     for (uint32_t i = 0; i < iovs_len; i += 1) {
+        uint32_t len = load32_align2(&iovs_ptr[i].len);
         size_t written_size = 0;
         if (fds[fd].stream != NULL)
-            written_size = fwrite(&m[iovs_ptr[i].ptr], 1, iovs_ptr[i].len, fds[fd].stream);
+            written_size = fwrite(&m[load32_align2(&iovs_ptr[i].ptr)], 1, len, fds[fd].stream);
         else
-            written_size = iovs_ptr[i].len;
+            written_size = len;
         size += written_size;
-        if (written_size < iovs_ptr[i].len) break;
+        if (written_size < len) break;
     }
 
     if (size > 0) {
@@ -771,7 +794,7 @@ uint32_t wasi_snapshot_preview1_fd_write(uint32_t fd, uint32_t iovs, uint32_t io
         des[fds[fd].de].atim = now;
         des[fds[fd].de].mtim = now;
     }
-    *res_size_ptr = size;
+    store32_align2(res_size_ptr, size);
     return wasi_errno_success;
 }
 
@@ -809,7 +832,7 @@ uint32_t wasi_snapshot_preview1_path_open(uint32_t fd, uint32_t dirflags, uint32
 #if LOG_TRACE
         fprintf(stderr, "fd = %u\n", fd_len);
 #endif
-        *res_fd_ptr = fd_len;
+        store32_align2(res_fd_ptr, fd_len);
         fd_len += 1;
     }
     if (lookup_errno != wasi_errno_noent) return lookup_errno;
@@ -867,7 +890,7 @@ uint32_t wasi_snapshot_preview1_path_open(uint32_t fd, uint32_t dirflags, uint32
     fds[fd_len].fdflags = fdflags;
     fds[fd_len].stream = stream;
     fds[fd_len].fs_rights_inheriting = fs_rights_inheriting;
-    *res_fd_ptr = fd_len;
+    store32_align2(res_fd_ptr, fd_len);
     fd_len += 1;
     return wasi_errno_success;
 }
@@ -882,12 +905,12 @@ uint32_t wasi_snapshot_preview1_clock_time_get(uint32_t id, uint64_t precision,
 
     switch (id) {
         case wasi_clockid_realtime:
-            *res_timestamp_ptr = time(NULL) * UINT64_C(1000000000);
+            store64_align3(res_timestamp_ptr, time(NULL) * UINT64_C(1000000000));
             break;
         case wasi_clockid_monotonic:
         case wasi_clockid_process_cputime_id:
         case wasi_clockid_thread_cputime_id:
-            *res_timestamp_ptr = clock() * (UINT64_C(1000000000) / CLOCKS_PER_SEC);
+            store64_align3(res_timestamp_ptr, clock() * (UINT64_C(1000000000) / CLOCKS_PER_SEC));
             break;
         default: return wasi_errno_inval;
     }
@@ -947,19 +970,20 @@ uint32_t wasi_snapshot_preview1_fd_pread(uint32_t fd, uint32_t iovs, uint32_t io
 
     size_t size = 0;
     for (uint32_t i = 0; i < iovs_len; i += 1) {
+        uint32_t len = load32_align2(&iovs_ptr[i].len);
         size_t read_size = 0;
         if (fds[fd].stream != NULL)
-            read_size = fread(&m[iovs_ptr[i].ptr], 1, iovs_ptr[i].len, fds[fd].stream);
+            read_size = fread(&m[load32_align2(&iovs_ptr[i].ptr)], 1, len, fds[fd].stream);
         else
             panic("unimplemented");
         size += read_size;
-        if (read_size < iovs_ptr[i].len) break;
+        if (read_size < len) break;
     }
 
     if (fsetpos(fds[fd].stream, &pos) < 0) return wasi_errno_io;
 
     if (size > 0) des[fds[fd].de].atim = time(NULL);
-    *res_size_ptr = size;
+    store32_align2(res_size_ptr, size);
     return wasi_errno_success;
 }
 
@@ -996,7 +1020,7 @@ uint32_t wasi_snapshot_preview1_fd_seek(uint32_t fd, uint64_t in_offset, uint32_
     if (fseek(fds[fd].stream, offset, seek_whence) < 0) return wasi_errno_io;
     long res_offset = ftell(fds[fd].stream);
     if (res_offset < 0) return wasi_errno_io;
-    *res_filesize_ptr = (uint64_t)res_offset;
+    store64_align3(res_filesize_ptr, res_offset);
     return wasi_errno_success;
 }
 
diff --git a/zig/stage1/wasm2c.c b/zig/stage1/wasm2c.c
index 10c0a0c3de..48484f5712 100644
--- a/zig/stage1/wasm2c.c
+++ b/zig/stage1/wasm2c.c
@@ -73,14 +73,30 @@ static void renderExpr(FILE *out, struct InputStream *in) {
     }
 }
 
+static const uint32_t big_endian = 0xff000000;
+
 int main(int argc, char **argv) {
-    if (argc != 3) {
-        fprintf(stderr, "usage: %s in.wasm.zst out.c\n", argv[0]);
+    if (argc != 3 && argc != 4) {
+        fprintf(stderr, "usage: %s <in.wasm.zst> <out.c> [endian]\n", argv[0]);
         return 1;
     }
 
+    bool is_big_endian;
+
+    if (argc >= 4) {
+        if (!strcmp(argv[3], "big")) {
+            is_big_endian = true;
+        } else if (!strcmp(argv[3], "little")) {
+            is_big_endian = false;
+        } else {
+            fprintf(stderr, "endianness must be 'big' or 'little'\n");
+            return 1;
+        }
+    } else {
+        is_big_endian = *(uint8_t *)&big_endian; // Infer from host endianness.
+    }
+
     const char *mod = "wasm";
-    bool is_big_endian = false; // TODO
 
     struct InputStream in;
     InputStream_open(&in, argv[1]);
@@ -111,55 +127,55 @@ int main(int argc, char **argv) {
           "           (uint64_t)i32_byteswap(src >> 32) <<  0;\n"
           "}\n"
           "\n", out);
-    fputs("static uint16_t load16_align0(const uint8_t *ptr) {\n"
+    fputs("uint16_t load16_align0(const uint8_t *ptr) {\n"
           "    uint16_t val;\n"
           "    memcpy(&val, ptr, sizeof(val));\n", out);
     if (is_big_endian) fputs("    val = i16_byteswap(val);", out);
     fputs("    return val;\n"
           "}\n"
-          "static uint16_t load16_align1(const uint16_t *ptr) {\n"
+          "uint16_t load16_align1(const uint16_t *ptr) {\n"
           "    uint16_t val;\n"
           "    memcpy(&val, ptr, sizeof(val));\n", out);
     if (is_big_endian) fputs("    val = i16_byteswap(val);", out);
     fputs("    return val;\n"
           "}\n"
-          "static uint32_t load32_align0(const uint8_t *ptr) {\n"
+          "uint32_t load32_align0(const uint8_t *ptr) {\n"
           "    uint32_t val;\n"
           "    memcpy(&val, ptr, sizeof(val));\n", out);
     if (is_big_endian) fputs("    val = i32_byteswap(val);", out);
     fputs("    return val;\n"
           "}\n"
-          "static uint32_t load32_align1(const uint16_t *ptr) {\n"
+          "uint32_t load32_align1(const uint16_t *ptr) {\n"
           "    uint32_t val;\n"
           "    memcpy(&val, ptr, sizeof(val));\n", out);
     if (is_big_endian) fputs("    val = i32_byteswap(val);", out);
     fputs("    return val;\n"
           "}\n"
-          "static uint32_t load32_align2(const uint32_t *ptr) {\n"
+          "uint32_t load32_align2(const uint32_t *ptr) {\n"
           "    uint32_t val;\n"
           "    memcpy(&val, ptr, sizeof(val));\n", out);
     if (is_big_endian) fputs("    val = i32_byteswap(val);", out);
     fputs("    return val;\n"
           "}\n"
-          "static uint64_t load64_align0(const uint8_t *ptr) {\n"
+          "uint64_t load64_align0(const uint8_t *ptr) {\n"
           "    uint64_t val;\n"
           "    memcpy(&val, ptr, sizeof(val));\n", out);
     if (is_big_endian) fputs("    val = i64_byteswap(val);", out);
     fputs("    return val;\n"
           "}\n"
-          "static uint64_t load64_align1(const uint16_t *ptr) {\n"
+          "uint64_t load64_align1(const uint16_t *ptr) {\n"
           "    uint64_t val;\n"
           "    memcpy(&val, ptr, sizeof(val));\n", out);
     if (is_big_endian) fputs("    val = i64_byteswap(val);", out);
     fputs("    return val;\n"
           "}\n"
-          "static uint64_t load64_align2(const uint32_t *ptr) {\n"
+          "uint64_t load64_align2(const uint32_t *ptr) {\n"
           "    uint64_t val;\n"
           "    memcpy(&val, ptr, sizeof(val));\n", out);
     if (is_big_endian) fputs("    val = i64_byteswap(val);", out);
     fputs("    return val;\n"
           "}\n"
-          "static uint64_t load64_align3(const uint64_t *ptr) {\n"
+          "uint64_t load64_align3(const uint64_t *ptr) {\n"
           "    uint64_t val;\n"
           "    memcpy(&val, ptr, sizeof(val));\n", out);
     if (is_big_endian) fputs("    val = i64_byteswap(val);", out);
@@ -199,39 +215,39 @@ int main(int argc, char **argv) {
           "    return i64_ctz(lhs);\n"
           "}\n"
           "\n"
-          "static void store16_align0(uint8_t *ptr, uint16_t val) {\n", out);
+          "void store16_align0(uint8_t *ptr, uint16_t val) {\n", out);
     if (is_big_endian) fputs("    val = i16_byteswap(val);", out);
     fputs("    memcpy(ptr, &val, sizeof(val));\n"
           "}\n"
-          "static void store16_align1(uint16_t *ptr, uint16_t val) {\n", out);
+          "void store16_align1(uint16_t *ptr, uint16_t val) {\n", out);
     if (is_big_endian) fputs("    val = i16_byteswap(val);", out);
     fputs("    memcpy(ptr, &val, sizeof(val));\n"
           "}\n"
-          "static void store32_align0(uint8_t *ptr, uint32_t val) {\n", out);
+          "void store32_align0(uint8_t *ptr, uint32_t val) {\n", out);
     if (is_big_endian) fputs("    val = i32_byteswap(val);", out);
     fputs("    memcpy(ptr, &val, sizeof(val));\n"
           "}\n"
-          "static void store32_align1(uint16_t *ptr, uint32_t val) {\n", out);
+          "void store32_align1(uint16_t *ptr, uint32_t val) {\n", out);
     if (is_big_endian) fputs("    val = i32_byteswap(val);", out);
     fputs("    memcpy(ptr, &val, sizeof(val));\n"
           "}\n"
-          "static void store32_align2(uint32_t *ptr, uint32_t val) {\n", out);
+          "void store32_align2(uint32_t *ptr, uint32_t val) {\n", out);
     if (is_big_endian) fputs("    val = i32_byteswap(val);", out);
     fputs("    memcpy(ptr, &val, sizeof(val));\n"
           "}\n"
-          "static void store64_align0(uint8_t *ptr, uint64_t val) {\n", out);
+          "void store64_align0(uint8_t *ptr, uint64_t val) {\n", out);
     if (is_big_endian) fputs("    val = i64_byteswap(val);", out);
     fputs("    memcpy(ptr, &val, sizeof(val));\n"
           "}\n"
-          "static void store64_align1(uint16_t *ptr, uint64_t val) {\n", out);
+          "void store64_align1(uint16_t *ptr, uint64_t val) {\n", out);
     if (is_big_endian) fputs("    val = i64_byteswap(val);", out);
     fputs("    memcpy(ptr, &val, sizeof(val));\n"
           "}\n"
-          "static void store64_align2(uint32_t *ptr, uint64_t val) {\n", out);
+          "void store64_align2(uint32_t *ptr, uint64_t val) {\n", out);
     if (is_big_endian) fputs("    val = i64_byteswap(val);", out);
     fputs("    memcpy(ptr, &val, sizeof(val));\n"
           "}\n"
-          "static void store64_align3(uint64_t *ptr, uint64_t val) {\n", out);
+          "void store64_align3(uint64_t *ptr, uint64_t val) {\n", out);
     if (is_big_endian) fputs("    val = i64_byteswap(val);", out);
     fputs("    memcpy(ptr, &val, sizeof(val));\n"
           "}\n"
diff --git a/zig/stage1/zig.h b/zig/stage1/zig.h
index 05529feec7..248bb8641c 100644
--- a/zig/stage1/zig.h
+++ b/zig/stage1/zig.h
@@ -248,37 +248,55 @@ typedef char bool;
 
 #if zig_has_builtin(trap)
 #define zig_trap() __builtin_trap()
-#elif _MSC_VER && (_M_IX86 || _M_X64)
+#elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
 #define zig_trap() __ud2()
-#elif _MSC_VER
-#define zig_trap() __fastfail(0)
-#elif defined(__i386__) || defined(__x86_64__)
-#define zig_trap() __asm__ volatile("ud2");
+#elif defined(_MSC_VER)
+#define zig_trap() __fastfail(7)
+#elif defined(__thumb__)
+#define zig_trap() __asm__ volatile("udf #0xfe")
 #elif defined(__arm__) || defined(__aarch64__)
-#define zig_trap() __asm__ volatile("udf #0");
+#define zig_trap() __asm__ volatile("udf #0xfdee")
+#elif defined(__loongarch__) || defined(__powerpc__)
+#define zig_trap() __asm__ volatile(".word 0x0")
+#elif defined(__mips__)
+#define zig_trap() __asm__ volatile(".word 0x3d")
+#elif defined(__riscv)
+#define zig_trap() __asm__ volatile("unimp")
+#elif defined(__s390__)
+#define zig_trap() __asm__ volatile("j 0x2")
+#elif defined(__sparc__)
+#define zig_trap() __asm__ volatile("illtrap")
+#elif defined(__i386__) || defined(__x86_64__)
+#define zig_trap() __asm__ volatile("ud2")
 #else
-#include <stdlib.h>
-#define zig_trap() abort()
+#define zig_trap() zig_trap_unavailable
 #endif
 
 #if zig_has_builtin(debugtrap)
 #define zig_breakpoint() __builtin_debugtrap()
 #elif defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
 #define zig_breakpoint() __debugbreak()
-#elif defined(__i386__) || defined(__x86_64__)
-#define zig_breakpoint() __asm__ volatile("int $0x03");
 #elif defined(__arm__)
-#define zig_breakpoint() __asm__ volatile("bkpt #0");
+#define zig_breakpoint() __asm__ volatile("bkpt #0x0")
 #elif defined(__aarch64__)
-#define zig_breakpoint() __asm__ volatile("brk #0");
-#else
-#include <signal.h>
-#if defined(SIGTRAP)
-#define zig_breakpoint() raise(SIGTRAP)
+#define zig_breakpoint() __asm__ volatile("brk #0xf000")
+#elif defined(__loongarch__)
+#define zig_breakpoint() __asm__ volatile("break 0x0")
+#elif defined(__mips__)
+#define zig_breakpoint() __asm__ volatile("break")
+#elif defined(__powerpc__)
+#define zig_breakpoint() __asm__ volatile("trap")
+#elif defined(__riscv)
+#define zig_breakpoint() __asm__ volatile("ebreak")
+#elif defined(__s390__)
+#define zig_breakpoint() __asm__ volatile("j 0x6")
+#elif defined(__sparc__)
+#define zig_breakpoint() __asm__ volatile("ta 0x1")
+#elif defined(__i386__) || defined(__x86_64__)
+#define zig_breakpoint() __asm__ volatile("int $0x3")
 #else
 #define zig_breakpoint() zig_breakpoint_unavailable
 #endif
-#endif
 
 #if zig_has_builtin(return_address) || defined(zig_gnuc)
 #define zig_return_address() __builtin_extract_return_addr(__builtin_return_address(0))
@@ -3592,7 +3610,6 @@ typedef enum memory_order zig_memory_order;
 #define zig_atomicrmw_add_float zig_atomicrmw_add
 #undef  zig_atomicrmw_sub_float
 #define zig_atomicrmw_sub_float zig_atomicrmw_sub
-#define zig_fence(order) atomic_thread_fence(order)
 #elif defined(__GNUC__)
 typedef int zig_memory_order;
 #define zig_memory_order_relaxed __ATOMIC_RELAXED
@@ -3616,7 +3633,6 @@ typedef int zig_memory_order;
 #define    zig_atomic_load(res, obj,      order, Type, ReprType)       __atomic_load      (obj, &(res), order)
 #undef  zig_atomicrmw_xchg_float
 #define zig_atomicrmw_xchg_float zig_atomicrmw_xchg
-#define zig_fence(order) __atomic_thread_fence(order)
 #elif _MSC_VER && (_M_IX86 || _M_X64)
 #define zig_memory_order_relaxed 0
 #define zig_memory_order_acquire 2
@@ -3637,11 +3653,6 @@ typedef int zig_memory_order;
 #define  zig_atomicrmw_max(res, obj, arg, order, Type, ReprType) res = zig_msvc_atomicrmw_max_ ##Type(obj, arg)
 #define   zig_atomic_store(     obj, arg, order, Type, ReprType)       zig_msvc_atomic_store_  ##Type(obj, arg)
 #define    zig_atomic_load(res, obj,      order, Type, ReprType) res = zig_msvc_atomic_load_   ##order##_##Type(obj)
-#if _M_X64
-#define zig_fence(order) __faststorefence()
-#else
-#define zig_fence(order) zig_msvc_atomic_barrier()
-#endif
 /* TODO: _MSC_VER && (_M_ARM || _M_ARM64) */
 #else
 #define zig_memory_order_relaxed 0
@@ -3663,7 +3674,6 @@ typedef int zig_memory_order;
 #define  zig_atomicrmw_max(res, obj, arg, order, Type, ReprType) zig_atomics_unavailable
 #define   zig_atomic_store(     obj, arg, order, Type, ReprType) zig_atomics_unavailable
 #define    zig_atomic_load(res, obj,      order, Type, ReprType) zig_atomics_unavailable
-#define zig_fence(order) zig_fence_unavailable
 #endif
 
 #if _MSC_VER && (_M_IX86 || _M_X64)
@@ -3916,28 +3926,52 @@ static inline void zig_msvc_atomic_store_i128(zig_i128 volatile* obj, zig_i128 a
 
 /* ======================== Special Case Intrinsics ========================= */
 
-#if (_MSC_VER && _M_X64) || defined(__x86_64__)
+#if defined(_M_ARM) || defined(__thumb__)
 
-static inline void* zig_x86_64_windows_teb(void) {
-#if _MSC_VER
-    return (void*)__readgsqword(0x30);
-#else
-    void* teb;
-    __asm volatile(" movq %%gs:0x30, %[ptr]": [ptr]"=r"(teb)::);
+static inline void* zig_thumb_windows_teb(void) {
+    void* teb = 0;
+#if defined(_MSC_VER)
+    teb = (void*)_MoveFromCoprocessor(15, 0, 13, 0, 2);
+#elif defined(__GNUC__)
+    __asm__ ("mrc p15, 0, %[ptr], c13, c0, 2" : [ptr] "=r" (teb));
+#endif
     return teb;
+}
+
+#elif defined(_M_ARM64) || defined(__arch64__)
+
+static inline void* zig_aarch64_windows_teb(void) {
+    void* teb = 0;
+#if defined(_MSC_VER)
+    teb = (void*)__readx18qword(0x0);
+#elif defined(__GNUC__)
+    __asm__ ("mov %[ptr], x18" : [ptr] "=r" (teb));
 #endif
+    return teb;
 }
 
-#elif (_MSC_VER && _M_IX86) || defined(__i386__) || defined(__X86__)
+#elif defined(_M_IX86) || defined(__i386__)
 
 static inline void* zig_x86_windows_teb(void) {
-#if _MSC_VER
-    return (void*)__readfsdword(0x18);
-#else
-    void* teb;
-    __asm volatile(" movl %%fs:0x18, %[ptr]": [ptr]"=r"(teb)::);
+    void* teb = 0;
+#if defined(_MSC_VER)
+    teb = (void*)__readfsdword(0x18);
+#elif defined(__GNUC__)
+    __asm__ ("movl %%fs:0x18, %[ptr]" : [ptr] "=r" (teb));
+#endif
     return teb;
+}
+
+#elif defined(_M_X64) || defined(__x86_64__)
+
+static inline void* zig_x86_64_windows_teb(void) {
+    void* teb = 0;
+#if defined(_MSC_VER)
+    teb = (void*)__readgsqword(0x30);
+#elif defined(__GNUC__)
+    __asm__ ("movq %%gs:0x30, %[ptr]" : [ptr] "=r" (teb));
 #endif
+    return teb;
 }
 
 #endif
diff --git a/zig/stage1/zig1.wasm b/zig/stage1/zig1.wasm
index 8b9423708f..4ee7f618be 100644
Binary files a/zig/stage1/zig1.wasm and b/zig/stage1/zig1.wasm differ
diff --git a/zig/test/behavior.zig b/zig/test/behavior.zig
index f0d05a146a..48d749146c 100644
--- a/zig/test/behavior.zig
+++ b/zig/test/behavior.zig
@@ -26,7 +26,6 @@ test {
     _ = @import("behavior/duplicated_test_names.zig");
     _ = @import("behavior/defer.zig");
     _ = @import("behavior/destructure.zig");
-    _ = @import("behavior/empty_tuple_fields.zig");
     _ = @import("behavior/empty_union.zig");
     _ = @import("behavior/enum.zig");
     _ = @import("behavior/error.zig");
diff --git a/zig/test/behavior/align.zig b/zig/test/behavior/align.zig
index e0d7634c38..6e6a1ac319 100644
--- a/zig/test/behavior/align.zig
+++ b/zig/test/behavior/align.zig
@@ -210,15 +210,6 @@ test "alignment and size of structs with 128-bit fields" {
     }
 }
 
-test "alignstack" {
-    try expect(fnWithAlignedStack() == 1234);
-}
-
-fn fnWithAlignedStack() i32 {
-    @setAlignStack(256);
-    return 1234;
-}
-
 test "implicitly decreasing slice alignment" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@@ -281,11 +272,6 @@ test "page aligned array on stack" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
-    if (builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) {
-        // https://github.com/ziglang/zig/issues/13679
-        return error.SkipZigTest;
-    }
-
     // Large alignment value to make it hard to accidentally pass.
     var array align(0x1000) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
     var number1: u8 align(16) = 42;
diff --git a/zig/test/behavior/array.zig b/zig/test/behavior/array.zig
index 17b8667238..adcbe49eeb 100644
--- a/zig/test/behavior/array.zig
+++ b/zig/test/behavior/array.zig
@@ -596,7 +596,7 @@ test "type coercion of anon struct literal to array" {
 
             var x2: U = .{ .a = 42 };
             _ = &x2;
-            const t2 = .{ x2, .{ .b = true }, .{ .c = "hello" } };
+            const t2 = .{ x2, U{ .b = true }, U{ .c = "hello" } };
             const arr2: [3]U = t2;
             try expect(arr2[0].a == 42);
             try expect(arr2[1].b == true);
@@ -607,40 +607,6 @@ test "type coercion of anon struct literal to array" {
     try comptime S.doTheTest();
 }
 
-test "type coercion of pointer to anon struct literal to pointer to array" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-
-    const S = struct {
-        const U = union {
-            a: u32,
-            b: bool,
-            c: []const u8,
-        };
-
-        fn doTheTest() !void {
-            var x1: u8 = 42;
-            _ = &x1;
-            const t1 = &.{ x1, 56, 54 };
-            const arr1: *const [3]u8 = t1;
-            try expect(arr1[0] == 42);
-            try expect(arr1[1] == 56);
-            try expect(arr1[2] == 54);
-
-            var x2: U = .{ .a = 42 };
-            _ = &x2;
-            const t2 = &.{ x2, .{ .b = true }, .{ .c = "hello" } };
-            const arr2: *const [3]U = t2;
-            try expect(arr2[0].a == 42);
-            try expect(arr2[1].b == true);
-            try expect(mem.eql(u8, arr2[2].c, "hello"));
-        }
-    };
-    try S.doTheTest();
-    try comptime S.doTheTest();
-}
-
 test "array with comptime-only element type" {
     const a = [_]type{ u32, i32 };
     try testing.expect(a[0] == u32);
diff --git a/zig/test/behavior/atomics.zig b/zig/test/behavior/atomics.zig
index 7d68a41864..8f32168f40 100644
--- a/zig/test/behavior/atomics.zig
+++ b/zig/test/behavior/atomics.zig
@@ -5,7 +5,8 @@ const expectEqual = std.testing.expectEqual;
 
 const supports_128_bit_atomics = switch (builtin.cpu.arch) {
     // TODO: Ideally this could be sync'd with the logic in Sema.
-    .aarch64, .aarch64_be => true,
+    .aarch64 => true,
+    .aarch64_be => false, // Fails due to LLVM issues.
     .x86_64 => std.Target.x86.featureSetHas(builtin.cpu.features, .cx16),
     else => false,
 };
diff --git a/zig/test/behavior/basic.zig b/zig/test/behavior/basic.zig
index d6239889d8..e639ef68b0 100644
--- a/zig/test/behavior/basic.zig
+++ b/zig/test/behavior/basic.zig
@@ -1174,10 +1174,6 @@ test "arrays and vectors with big integers" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
-    // TODO: only aarch64-windows didn't pass in the PR that added this code.
-    //       figure out why if you can run this target.
-    if (builtin.os.tag == .windows and builtin.cpu.arch == .aarch64) return error.SkipZigTest;
-
     inline for (.{ u65528, u65529, u65535 }) |Int| {
         var a: [1]Int = undefined;
         a[0] = std.math.maxInt(Int);
@@ -1260,6 +1256,7 @@ test "integer compare <= 64 bits" {
 
 test "integer compare <= 128 bits" {
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     inline for (.{ u65, u96, u127, u128 }) |T| {
         try testUnsignedCmp(T);
diff --git a/zig/test/behavior/bitcast.zig b/zig/test/behavior/bitcast.zig
index 2ef97c8310..c1e4e3cdf7 100644
--- a/zig/test/behavior/bitcast.zig
+++ b/zig/test/behavior/bitcast.zig
@@ -402,6 +402,7 @@ test "bitcast vector to integer and back" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
 
     const arr: [16]bool = [_]bool{ true, false } ++ [_]bool{true} ** 14;
     var x: @Vector(16, bool) = @splat(true);
diff --git a/zig/test/behavior/builtin_functions_returning_void_or_noreturn.zig b/zig/test/behavior/builtin_functions_returning_void_or_noreturn.zig
index 52a3094f3b..e20e1ed9bf 100644
--- a/zig/test/behavior/builtin_functions_returning_void_or_noreturn.zig
+++ b/zig/test/behavior/builtin_functions_returning_void_or_noreturn.zig
@@ -20,7 +20,6 @@ test {
     try testing.expectEqual({}, @memset(@as([*]u8, @ptrFromInt(1))[0..0], undefined));
     try testing.expectEqual(noreturn, @TypeOf(if (true) @panic("") else {}));
     try testing.expectEqual({}, @prefetch(&val, .{}));
-    try testing.expectEqual({}, @setAlignStack(16));
     try testing.expectEqual({}, @setEvalBranchQuota(0));
     try testing.expectEqual({}, @setFloatMode(.optimized));
     try testing.expectEqual({}, @setRuntimeSafety(true));
diff --git a/zig/test/behavior/cast.zig b/zig/test/behavior/cast.zig
index 7dca19d212..3a9b5157a4 100644
--- a/zig/test/behavior/cast.zig
+++ b/zig/test/behavior/cast.zig
@@ -124,7 +124,7 @@ test "@floatFromInt(f80)" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -1362,7 +1362,7 @@ test "cast f16 to wider types" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -2504,13 +2504,6 @@ test "@intFromBool on vector" {
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_llvm and
-        builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows)
-    {
-        // https://github.com/ziglang/zig/issues/19825
-        return error.SkipZigTest;
-    }
-
     const S = struct {
         fn doTheTest() !void {
             var a: @Vector(3, bool) = .{ false, true, false };
@@ -2607,32 +2600,6 @@ test "result type is preserved into comptime block" {
     try expect(x == 123);
 }
 
-test "implicit cast from ptr to tuple to ptr to struct" {
-    if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
-    const ComptimeReason = union(enum) {
-        c_import: struct {
-            a: u32,
-        },
-    };
-
-    const Block = struct {
-        reason: ?*const ComptimeReason,
-    };
-
-    var a: u32 = 16;
-    _ = &a;
-    var reason = .{ .c_import = .{ .a = a } };
-    var block = Block{
-        .reason = &reason,
-    };
-    _ = &block;
-    try expect(block.reason.?.c_import.a == 16);
-}
-
 test "bitcast vector" {
     if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
diff --git a/zig/test/behavior/decl_literals.zig b/zig/test/behavior/decl_literals.zig
index f2f7f8a81f..b3a066ea66 100644
--- a/zig/test/behavior/decl_literals.zig
+++ b/zig/test/behavior/decl_literals.zig
@@ -73,6 +73,8 @@ test "call decl literal" {
 }
 
 test "call decl literal with error union" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+
     const S = struct {
         x: u32,
         fn init(err: bool) !@This() {
diff --git a/zig/test/behavior/empty_file_level_struct.zig b/zig/test/behavior/empty_file_level_struct.zig
deleted file mode 100644
index 86f0f2b3c7..0000000000
--- a/zig/test/behavior/empty_file_level_struct.zig
+++ /dev/null
@@ -1 +0,0 @@
-struct {}
diff --git a/zig/test/behavior/empty_file_level_union.zig b/zig/test/behavior/empty_file_level_union.zig
deleted file mode 100644
index 0d24797ffb..0000000000
--- a/zig/test/behavior/empty_file_level_union.zig
+++ /dev/null
@@ -1 +0,0 @@
-union {}
diff --git a/zig/test/behavior/empty_tuple_fields.zig b/zig/test/behavior/empty_tuple_fields.zig
deleted file mode 100644
index dc809b0355..0000000000
--- a/zig/test/behavior/empty_tuple_fields.zig
+++ /dev/null
@@ -1,28 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-
-test "empty file level struct" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
-    const T = @import("empty_file_level_struct.zig");
-    const info = @typeInfo(T);
-    try std.testing.expectEqual(@as(usize, 1), info.@"struct".fields.len);
-    try std.testing.expectEqualStrings("0", info.@"struct".fields[0].name);
-    try std.testing.expect(@typeInfo(info.@"struct".fields[0].type) == .@"struct");
-}
-
-test "empty file level union" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
-    const T = @import("empty_file_level_union.zig");
-    const info = @typeInfo(T);
-    try std.testing.expectEqual(@as(usize, 1), info.@"struct".fields.len);
-    try std.testing.expectEqualStrings("0", info.@"struct".fields[0].name);
-    try std.testing.expect(@typeInfo(info.@"struct".fields[0].type) == .@"union");
-}
diff --git a/zig/test/behavior/eval.zig b/zig/test/behavior/eval.zig
index 2d7922d2ba..da39b06d92 100644
--- a/zig/test/behavior/eval.zig
+++ b/zig/test/behavior/eval.zig
@@ -522,7 +522,7 @@ test "runtime 128 bit integer division" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -1618,6 +1618,8 @@ test "struct in comptime false branch is not evaluated" {
 }
 
 test "result of nested switch assigned to variable" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+
     var zds: u32 = 0;
     zds = switch (zds) {
         0 => switch (zds) {
diff --git a/zig/test/behavior/floatop.zig b/zig/test/behavior/floatop.zig
index 69dacb66fd..72b773b76c 100644
--- a/zig/test/behavior/floatop.zig
+++ b/zig/test/behavior/floatop.zig
@@ -126,7 +126,7 @@ test "cmp f16" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.cpu.arch.isArmOrThumb() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
+    if (builtin.cpu.arch.isArm() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
 
     try testCmp(f16);
     try comptime testCmp(f16);
@@ -135,7 +135,7 @@ test "cmp f16" {
 test "cmp f32/f64" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
-    if (builtin.cpu.arch.isArmOrThumb() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
+    if (builtin.cpu.arch.isArm() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
 
     try testCmp(f32);
     try comptime testCmp(f32);
@@ -146,7 +146,7 @@ test "cmp f32/f64" {
 test "cmp f128" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
@@ -1009,7 +1009,7 @@ test "@abs f32/f64" {
 test "@abs f80/f128/c_longdouble" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
@@ -1134,7 +1134,7 @@ test "@floor f32/f64" {
 test "@floor f80/f128/c_longdouble" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
@@ -1232,7 +1232,7 @@ test "@ceil f32/f64" {
 test "@ceil f80/f128/c_longdouble" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
@@ -1330,7 +1330,7 @@ test "@trunc f32/f64" {
 test "@trunc f80/f128/c_longdouble" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
diff --git a/zig/test/behavior/generics.zig b/zig/test/behavior/generics.zig
index 95678e0ea7..f7cc179f5e 100644
--- a/zig/test/behavior/generics.zig
+++ b/zig/test/behavior/generics.zig
@@ -532,8 +532,6 @@ test "call generic function with from function called by the generic function" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_llvm and
-        builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest;
 
     const GET = struct {
         key: []const u8,
diff --git a/zig/test/behavior/inline_switch.zig b/zig/test/behavior/inline_switch.zig
index 59dc7096b9..dc59c3a550 100644
--- a/zig/test/behavior/inline_switch.zig
+++ b/zig/test/behavior/inline_switch.zig
@@ -113,6 +113,7 @@ test "inline else enum" {
 test "inline else int with gaps" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
 
     var a: u8 = 0;
     _ = &a;
diff --git a/zig/test/behavior/math.zig b/zig/test/behavior/math.zig
index 1cd7583abc..21f09a877f 100644
--- a/zig/test/behavior/math.zig
+++ b/zig/test/behavior/math.zig
@@ -780,7 +780,7 @@ test "128-bit multiplication" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     {
@@ -833,6 +833,8 @@ test "@addWithOverflow > 64 bits" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
 
     try testAddWithOverflow(u65, 4, 105, 109, 0);
     try testAddWithOverflow(u65, 1000, 100, 1100, 0);
@@ -986,6 +988,7 @@ test "@mulWithOverflow bitsize 128 bits" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
 
     try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555555, 0xffffffffffffffff_ffffffffffffffff, 0);
     try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555556, 2, 1);
@@ -1065,6 +1068,7 @@ test "@subWithOverflow > 64 bits" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
 
     try testSubWithOverflow(u65, 4, 105, maxInt(u65) - 100, 1);
     try testSubWithOverflow(u65, 1000, 100, 900, 0);
@@ -1365,7 +1369,7 @@ test "remainder division" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) {
@@ -1518,7 +1522,7 @@ test "@round f80" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -1531,7 +1535,7 @@ test "@round f128" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -1575,7 +1579,7 @@ test "NaN comparison" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.cpu.arch.isArmOrThumb() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
+    if (builtin.cpu.arch.isArm() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
 
     try testNanEqNan(f16);
     try testNanEqNan(f32);
@@ -1731,7 +1735,7 @@ test "runtime comparison to NaN is comptime-known" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.cpu.arch.isArmOrThumb() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
+    if (builtin.cpu.arch.isArm() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
 
     const S = struct {
         fn doTheTest(comptime F: type, x: F) void {
@@ -1762,7 +1766,7 @@ test "runtime int comparison to inf is comptime-known" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-    if (builtin.cpu.arch.isArmOrThumb() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
+    if (builtin.cpu.arch.isArm() and builtin.target.floatAbi() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234
 
     const S = struct {
         fn doTheTest(comptime F: type, x: u32) void {
diff --git a/zig/test/behavior/maximum_minimum.zig b/zig/test/behavior/maximum_minimum.zig
index 8994d9d182..d7d494a9ad 100644
--- a/zig/test/behavior/maximum_minimum.zig
+++ b/zig/test/behavior/maximum_minimum.zig
@@ -122,7 +122,7 @@ test "@min/max for floats" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
diff --git a/zig/test/behavior/muladd.zig b/zig/test/behavior/muladd.zig
index 7b45cc9b72..ec07f203ec 100644
--- a/zig/test/behavior/muladd.zig
+++ b/zig/test/behavior/muladd.zig
@@ -58,7 +58,7 @@ test "@mulAdd f80" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -79,7 +79,7 @@ test "@mulAdd f128" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
@@ -189,7 +189,7 @@ test "vector f80" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime vector80();
@@ -216,7 +216,7 @@ test "vector f128" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try comptime vector128();
diff --git a/zig/test/behavior/packed-struct.zig b/zig/test/behavior/packed-struct.zig
index 8386f62f77..f4ece2fe04 100644
--- a/zig/test/behavior/packed-struct.zig
+++ b/zig/test/behavior/packed-struct.zig
@@ -1297,3 +1297,23 @@ test "packed struct contains optional pointer" {
     } = .{};
     try expect(foo.a == null);
 }
+
+test "packed struct equality" {
+    const Foo = packed struct {
+        a: u4,
+        b: u4,
+    };
+
+    const S = struct {
+        fn doTest(x: Foo, y: Foo) !void {
+            try expect(x == y);
+            try expect(!(x != y));
+        }
+    };
+
+    const x: Foo = .{ .a = 1, .b = 2 };
+    const y: Foo = .{ .b = 2, .a = 1 };
+
+    try S.doTest(x, y);
+    comptime try S.doTest(x, y);
+}
diff --git a/zig/test/behavior/pointers.zig b/zig/test/behavior/pointers.zig
index bf0d37cc2b..f16643de42 100644
--- a/zig/test/behavior/pointers.zig
+++ b/zig/test/behavior/pointers.zig
@@ -45,6 +45,7 @@ test "pointer-integer arithmetic" {
 
 test "pointer subtraction" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
 
     {
         const a: *u8 = @ptrFromInt(100);
diff --git a/zig/test/behavior/saturating_arithmetic.zig b/zig/test/behavior/saturating_arithmetic.zig
index 3e41e2fa3f..ea3d51f3e6 100644
--- a/zig/test/behavior/saturating_arithmetic.zig
+++ b/zig/test/behavior/saturating_arithmetic.zig
@@ -164,7 +164,7 @@ test "saturating multiplication <= 32 bits" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .wasm32) {
@@ -264,7 +264,7 @@ test "saturating multiplication" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .wasm32) {
diff --git a/zig/test/behavior/shuffle.zig b/zig/test/behavior/shuffle.zig
index 08b01b5262..8f22021791 100644
--- a/zig/test/behavior/shuffle.zig
+++ b/zig/test/behavior/shuffle.zig
@@ -140,13 +140,6 @@ test "@shuffle bool 1" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_llvm and
-        builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows)
-    {
-        // https://github.com/ziglang/zig/issues/19824
-        return error.SkipZigTest;
-    }
-
     const S = struct {
         fn doTheTest() !void {
             var x: @Vector(4, bool) = [4]bool{ false, true, false, true };
diff --git a/zig/test/behavior/struct.zig b/zig/test/behavior/struct.zig
index 989da34ae7..b45fa171cb 100644
--- a/zig/test/behavior/struct.zig
+++ b/zig/test/behavior/struct.zig
@@ -419,7 +419,7 @@ test "packed struct 24bits" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.cpu.arch == .wasm32) return error.SkipZigTest; // TODO
-    if (comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; // TODO
+    if (comptime builtin.cpu.arch.isArm()) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
@@ -818,7 +818,7 @@ test "non-packed struct with u128 entry in union" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     const U = union(enum) {
@@ -941,7 +941,7 @@ test "tuple assigned to variable" {
 
 test "comptime struct field" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; // TODO
+    if (comptime builtin.cpu.arch.isArm()) return error.SkipZigTest; // TODO
 
     const T = struct {
         a: i32,
@@ -1013,84 +1013,6 @@ test "struct with 0-length union array field" {
     try expectEqual(@as(usize, 0), s.zero_length.len);
 }
 
-test "type coercion of anon struct literal to struct" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    const S = struct {
-        const S2 = struct {
-            A: u32,
-            B: []const u8,
-            C: void,
-            D: Foo = .{},
-        };
-
-        const Foo = struct {
-            field: i32 = 1234,
-        };
-
-        fn doTheTest() !void {
-            var y: u32 = 42;
-            _ = &y;
-            const t0 = .{ .A = 123, .B = "foo", .C = {} };
-            const t1 = .{ .A = y, .B = "foo", .C = {} };
-            const y0: S2 = t0;
-            const y1: S2 = t1;
-            try expect(y0.A == 123);
-            try expect(std.mem.eql(u8, y0.B, "foo"));
-            try expect(y0.C == {});
-            try expect(y0.D.field == 1234);
-            try expect(y1.A == y);
-            try expect(std.mem.eql(u8, y1.B, "foo"));
-            try expect(y1.C == {});
-            try expect(y1.D.field == 1234);
-        }
-    };
-    try S.doTheTest();
-    try comptime S.doTheTest();
-}
-
-test "type coercion of pointer to anon struct literal to pointer to struct" {
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
-    const S = struct {
-        const S2 = struct {
-            A: u32,
-            B: []const u8,
-            C: void,
-            D: Foo = .{},
-        };
-
-        const Foo = struct {
-            field: i32 = 1234,
-        };
-
-        fn doTheTest() !void {
-            var y: u32 = 42;
-            _ = &y;
-            const t0 = &.{ .A = 123, .B = "foo", .C = {} };
-            const t1 = &.{ .A = y, .B = "foo", .C = {} };
-            const y0: *const S2 = t0;
-            const y1: *const S2 = t1;
-            try expect(y0.A == 123);
-            try expect(std.mem.eql(u8, y0.B, "foo"));
-            try expect(y0.C == {});
-            try expect(y0.D.field == 1234);
-            try expect(y1.A == y);
-            try expect(std.mem.eql(u8, y1.B, "foo"));
-            try expect(y1.C == {});
-            try expect(y1.D.field == 1234);
-        }
-    };
-    try S.doTheTest();
-    try comptime S.doTheTest();
-}
-
 test "packed struct with undefined initializers" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -2159,3 +2081,44 @@ test "matching captures causes struct equivalence" {
     comptime assert(@TypeOf(a) == @TypeOf(b));
     try expect(a.x == b.x);
 }
+
+test "struct @FieldType" {
+    const S = struct {
+        a: u32,
+        b: f64,
+        c: *@This(),
+    };
+
+    comptime assert(@FieldType(S, "a") == u32);
+    comptime assert(@FieldType(S, "b") == f64);
+    comptime assert(@FieldType(S, "c") == *S);
+}
+
+test "extern struct @FieldType" {
+    const S = extern struct {
+        a: u32,
+        b: f64,
+        c: *@This(),
+    };
+
+    comptime assert(@FieldType(S, "a") == u32);
+    comptime assert(@FieldType(S, "b") == f64);
+    comptime assert(@FieldType(S, "c") == *S);
+}
+
+test "anonymous struct equivalence" {
+    const S = struct {
+        fn anonStructType(comptime x: anytype) type {
+            const val = .{ .a = "hello", .b = x };
+            return @TypeOf(val);
+        }
+    };
+
+    const A = S.anonStructType(123);
+    const B = S.anonStructType(123);
+    const C = S.anonStructType(456);
+
+    comptime assert(A == B);
+    comptime assert(A != C);
+    comptime assert(B != C);
+}
diff --git a/zig/test/behavior/switch.zig b/zig/test/behavior/switch.zig
index fd1cd41e4b..8ffef186d1 100644
--- a/zig/test/behavior/switch.zig
+++ b/zig/test/behavior/switch.zig
@@ -12,6 +12,8 @@ test "switch with numbers" {
 }
 
 fn testSwitchWithNumbers(x: u32) !void {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+
     const result = switch (x) {
         1, 2, 3, 4...8 => false,
         13 => true,
@@ -22,6 +24,7 @@ fn testSwitchWithNumbers(x: u32) !void {
 
 test "switch with all ranges" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
 
     try expect(testSwitchWithAllRanges(50, 3) == 1);
     try expect(testSwitchWithAllRanges(101, 0) == 2);
@@ -173,6 +176,7 @@ test "undefined.u0" {
 
 test "switch with disjoint range" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
 
     var q: u8 = 0;
     _ = &q;
@@ -184,6 +188,8 @@ test "switch with disjoint range" {
 }
 
 test "switch variable for range and multiple prongs" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn doTheTest() !void {
             try doTheSwitch(16);
@@ -281,6 +287,8 @@ test "switch handles all cases of number" {
 }
 
 fn testSwitchHandleAllCases() !void {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+
     try expect(testSwitchHandleAllCasesExhaustive(0) == 3);
     try expect(testSwitchHandleAllCasesExhaustive(1) == 2);
     try expect(testSwitchHandleAllCasesExhaustive(2) == 1);
@@ -497,6 +505,7 @@ test "switch prongs with error set cases make a new error set type for capture v
 
 test "return result loc and then switch with range implicit casted to error union" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
 
     const S = struct {
         fn doTheTest() !void {
@@ -714,6 +723,7 @@ test "switch capture copies its payload" {
 
 test "capture of integer forwards the switch condition directly" {
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
 
     const S = struct {
         fn foo(x: u8) !void {
@@ -854,6 +864,7 @@ test "inline switch range that includes the maximum value of the switched type"
 
 test "nested break ignores switch conditions and breaks instead" {
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
     const S = struct {
         fn register_to_address(ident: []const u8) !u8 {
@@ -901,6 +912,7 @@ test "peer type resolution on switch captures ignores unused payload bits" {
 test "switch prong captures range" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
 
     const S = struct {
         fn a(b: []u3, c: u3) void {
@@ -935,6 +947,8 @@ test "prong with inline call to unreachable" {
 }
 
 test "block error return trace index is reset between prongs" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+
     const S = struct {
         fn returnError() error{TestFailed} {
             return error.TestFailed;
@@ -963,6 +977,8 @@ test "block error return trace index is reset between prongs" {
 }
 
 test "labeled switch with break" {
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
+
     var six: u32 = undefined;
     six = 6;
 
diff --git a/zig/test/behavior/tuple.zig b/zig/test/behavior/tuple.zig
index a511b1c1b3..becfcce028 100644
--- a/zig/test/behavior/tuple.zig
+++ b/zig/test/behavior/tuple.zig
@@ -150,7 +150,7 @@ test "array-like initializer for tuple types" {
                     .type = u8,
                     .default_value = null,
                     .is_comptime = false,
-                    .alignment = @alignOf(i32),
+                    .alignment = @alignOf(u8),
                 },
             },
         },
@@ -566,16 +566,28 @@ test "comptime fields in tuple can be initialized" {
     _ = &a;
 }
 
-test "tuple default values" {
-    const T = struct {
-        usize,
-        usize = 123,
-        usize = 456,
-    };
+test "empty struct in tuple" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
-    const t: T = .{1};
+    const T = struct { struct {} };
+    const info = @typeInfo(T);
+    try std.testing.expectEqual(@as(usize, 1), info.@"struct".fields.len);
+    try std.testing.expectEqualStrings("0", info.@"struct".fields[0].name);
+    try std.testing.expect(@typeInfo(info.@"struct".fields[0].type) == .@"struct");
+}
+
+test "empty union in tuple" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
-    try expectEqual(1, t[0]);
-    try expectEqual(123, t[1]);
-    try expectEqual(456, t[2]);
+    const T = struct { union {} };
+    const info = @typeInfo(T);
+    try std.testing.expectEqual(@as(usize, 1), info.@"struct".fields.len);
+    try std.testing.expectEqualStrings("0", info.@"struct".fields[0].name);
+    try std.testing.expect(@typeInfo(info.@"struct".fields[0].type) == .@"union");
 }
diff --git a/zig/test/behavior/tuple_declarations.zig b/zig/test/behavior/tuple_declarations.zig
index cf113c0201..907b114aeb 100644
--- a/zig/test/behavior/tuple_declarations.zig
+++ b/zig/test/behavior/tuple_declarations.zig
@@ -9,7 +9,7 @@ test "tuple declaration type info" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     {
-        const T = struct { comptime u32 align(2) = 1, []const u8 };
+        const T = struct { comptime u32 = 1, []const u8 };
         const info = @typeInfo(T).@"struct";
 
         try expect(info.layout == .auto);
@@ -22,7 +22,7 @@ test "tuple declaration type info" {
         try expect(info.fields[0].type == u32);
         try expect(@as(*const u32, @ptrCast(@alignCast(info.fields[0].default_value))).* == 1);
         try expect(info.fields[0].is_comptime);
-        try expect(info.fields[0].alignment == 2);
+        try expect(info.fields[0].alignment == @alignOf(u32));
 
         try expectEqualStrings(info.fields[1].name, "1");
         try expect(info.fields[1].type == []const u8);
@@ -32,7 +32,7 @@ test "tuple declaration type info" {
     }
 }
 
-test "Tuple declaration usage" {
+test "tuple declaration usage" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
diff --git a/zig/test/behavior/type_info.zig b/zig/test/behavior/type_info.zig
index d74c03e436..542d6b31b2 100644
--- a/zig/test/behavior/type_info.zig
+++ b/zig/test/behavior/type_info.zig
@@ -350,6 +350,7 @@ fn testOpaque() !void {
 
 test "type info: function type info" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
 
     try testFunction();
     try comptime testFunction();
@@ -358,7 +359,7 @@ test "type info: function type info" {
 fn testFunction() !void {
     const foo_fn_type = @TypeOf(typeInfoFoo);
     const foo_fn_info = @typeInfo(foo_fn_type);
-    try expect(foo_fn_info.@"fn".calling_convention == .C);
+    try expect(foo_fn_info.@"fn".calling_convention.eql(.c));
     try expect(!foo_fn_info.@"fn".is_generic);
     try expect(foo_fn_info.@"fn".params.len == 2);
     try expect(foo_fn_info.@"fn".is_var_args);
@@ -374,7 +375,7 @@ fn testFunction() !void {
 
     const aligned_foo_fn_type = @TypeOf(typeInfoFooAligned);
     const aligned_foo_fn_info = @typeInfo(aligned_foo_fn_type);
-    try expect(aligned_foo_fn_info.@"fn".calling_convention == .C);
+    try expect(aligned_foo_fn_info.@"fn".calling_convention.eql(.c));
     try expect(!aligned_foo_fn_info.@"fn".is_generic);
     try expect(aligned_foo_fn_info.@"fn".params.len == 2);
     try expect(aligned_foo_fn_info.@"fn".is_var_args);
@@ -390,8 +391,8 @@ fn testFunction() !void {
     try expect(aligned_foo_ptr_fn_info.pointer.sentinel == null);
 }
 
-extern fn typeInfoFoo(a: usize, b: bool, ...) callconv(.C) usize;
-extern fn typeInfoFooAligned(a: usize, b: bool, ...) align(4) callconv(.C) usize;
+extern fn typeInfoFoo(a: usize, b: bool, ...) callconv(.c) usize;
+extern fn typeInfoFooAligned(a: usize, b: bool, ...) align(4) callconv(.c) usize;
 
 test "type info: generic function types" {
     const G1 = @typeInfo(@TypeOf(generic1));
diff --git a/zig/test/behavior/typename.zig b/zig/test/behavior/typename.zig
index dd11723952..6682b99f4d 100644
--- a/zig/test/behavior/typename.zig
+++ b/zig/test/behavior/typename.zig
@@ -79,9 +79,9 @@ test "basic" {
     try expectEqualStrings("fn (comptime u32) void", @typeName(fn (comptime u32) void));
     try expectEqualStrings("fn (noalias []u8) void", @typeName(fn (noalias []u8) void));
 
-    try expectEqualStrings("fn () callconv(.C) void", @typeName(fn () callconv(.C) void));
-    try expectEqualStrings("fn (...) callconv(.C) void", @typeName(fn (...) callconv(.C) void));
-    try expectEqualStrings("fn (u32, ...) callconv(.C) void", @typeName(fn (u32, ...) callconv(.C) void));
+    try expectEqualStrings("fn () callconv(.c) void", @typeName(fn () callconv(.c) void));
+    try expectEqualStrings("fn (...) callconv(.c) void", @typeName(fn (...) callconv(.c) void));
+    try expectEqualStrings("fn (u32, ...) callconv(.c) void", @typeName(fn (u32, ...) callconv(.c) void));
 }
 
 test "top level decl" {
diff --git a/zig/test/behavior/union.zig b/zig/test/behavior/union.zig
index a87631c9e4..a3ce6169a5 100644
--- a/zig/test/behavior/union.zig
+++ b/zig/test/behavior/union.zig
@@ -986,76 +986,6 @@ test "function call result coerces from tagged union to the tag" {
     try comptime S.doTheTest();
 }
 
-test "cast from anonymous struct to union" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
-    const S = struct {
-        const U = union(enum) {
-            A: u32,
-            B: []const u8,
-            C: void,
-        };
-        fn doTheTest() !void {
-            var y: u32 = 42;
-            _ = &y;
-            const t0 = .{ .A = 123 };
-            const t1 = .{ .B = "foo" };
-            const t2 = .{ .C = {} };
-            const t3 = .{ .A = y };
-            const x0: U = t0;
-            var x1: U = t1;
-            _ = &x1;
-            const x2: U = t2;
-            var x3: U = t3;
-            _ = &x3;
-            try expect(x0.A == 123);
-            try expect(std.mem.eql(u8, x1.B, "foo"));
-            try expect(x2 == .C);
-            try expect(x3.A == y);
-        }
-    };
-    try S.doTheTest();
-    try comptime S.doTheTest();
-}
-
-test "cast from pointer to anonymous struct to pointer to union" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
-
-    const S = struct {
-        const U = union(enum) {
-            A: u32,
-            B: []const u8,
-            C: void,
-        };
-        fn doTheTest() !void {
-            var y: u32 = 42;
-            _ = &y;
-            const t0 = &.{ .A = 123 };
-            const t1 = &.{ .B = "foo" };
-            const t2 = &.{ .C = {} };
-            const t3 = &.{ .A = y };
-            const x0: *const U = t0;
-            var x1: *const U = t1;
-            _ = &x1;
-            const x2: *const U = t2;
-            var x3: *const U = t3;
-            _ = &x3;
-            try expect(x0.A == 123);
-            try expect(std.mem.eql(u8, x1.B, "foo"));
-            try expect(x2.* == .C);
-            try expect(x3.A == y);
-        }
-    };
-    try S.doTheTest();
-    try comptime S.doTheTest();
-}
-
 test "switching on non exhaustive union" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -1890,10 +1820,8 @@ test "reinterpret packed union" {
     try comptime S.doTheTest();
 
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21050
-    if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21050
     if (builtin.cpu.arch.isWasm()) return error.SkipZigTest; // TODO
-    if (builtin.cpu.arch == .s390x and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch.endian() == .big) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21050
     try S.doTheTest();
 }
 
@@ -2339,3 +2267,39 @@ test "signed enum tag with negative value" {
 
     try expect(e.a == i);
 }
+
+test "union @FieldType" {
+    const U = union {
+        a: u32,
+        b: f64,
+        c: *@This(),
+    };
+
+    comptime assert(@FieldType(U, "a") == u32);
+    comptime assert(@FieldType(U, "b") == f64);
+    comptime assert(@FieldType(U, "c") == *U);
+}
+
+test "tagged union @FieldType" {
+    const U = union(enum) {
+        a: u32,
+        b: f64,
+        c: *@This(),
+    };
+
+    comptime assert(@FieldType(U, "a") == u32);
+    comptime assert(@FieldType(U, "b") == f64);
+    comptime assert(@FieldType(U, "c") == *U);
+}
+
+test "extern union @FieldType" {
+    const U = extern union {
+        a: u32,
+        b: f64,
+        c: *@This(),
+    };
+
+    comptime assert(@FieldType(U, "a") == u32);
+    comptime assert(@FieldType(U, "b") == f64);
+    comptime assert(@FieldType(U, "c") == *U);
+}
diff --git a/zig/test/behavior/vector.zig b/zig/test/behavior/vector.zig
index 666c45b741..69de2df55e 100644
--- a/zig/test/behavior/vector.zig
+++ b/zig/test/behavior/vector.zig
@@ -101,7 +101,7 @@ test "vector float operators" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
 
     if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
@@ -753,7 +753,7 @@ test "vector reduce operation" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c and comptime builtin.cpu.arch.isArm()) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
     if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21091
 
@@ -1060,6 +1060,7 @@ test "@addWithOverflow" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1108,6 +1109,7 @@ test "@subWithOverflow" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1140,6 +1142,7 @@ test "@mulWithOverflow" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1162,6 +1165,7 @@ test "@shlWithOverflow" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -1245,6 +1249,7 @@ test "byte vector initialized in inline function" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
 
     if (comptime builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and
         builtin.cpu.features.isEnabled(@intFromEnum(std.Target.x86.Feature.avx512f)))
@@ -1370,6 +1375,7 @@ test "store packed vector element" {
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
 
     var v = @Vector(4, u1){ 1, 1, 1, 1 };
     try expectEqual(@Vector(4, u1){ 1, 1, 1, 1 }, v);
@@ -1406,6 +1412,7 @@ test "store vector with memset" {
     if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.cpu.arch == .aarch64_be and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
 
     var a: [5]@Vector(2, i1) = undefined;
     var b: [5]@Vector(2, u2) = undefined;
diff --git a/zig/test/c_abi/main.zig b/zig/test/c_abi/main.zig
index 09b5011665..f18fa4b3d5 100644
--- a/zig/test/c_abi/main.zig
+++ b/zig/test/c_abi/main.zig
@@ -10,7 +10,7 @@ const builtin = @import("builtin");
 const print = std.debug.print;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
-const have_i128 = builtin.cpu.arch != .x86 and !builtin.cpu.arch.isARM() and
+const have_i128 = builtin.cpu.arch != .x86 and !builtin.cpu.arch.isArm() and
     !builtin.cpu.arch.isMIPS() and !builtin.cpu.arch.isPowerPC32();
 
 const have_f128 = builtin.cpu.arch.isX86() and !builtin.os.tag.isDarwin();
@@ -181,7 +181,7 @@ extern fn c_cmultf(a: ComplexFloat, b: ComplexFloat) ComplexFloat;
 extern fn c_cmultd(a: ComplexDouble, b: ComplexDouble) ComplexDouble;
 
 const complex_abi_compatible = builtin.cpu.arch != .x86 and !builtin.cpu.arch.isMIPS() and
-    !builtin.cpu.arch.isARM() and !builtin.cpu.arch.isPowerPC32() and !builtin.cpu.arch.isRISCV();
+    !builtin.cpu.arch.isArm() and !builtin.cpu.arch.isPowerPC32() and !builtin.cpu.arch.isRISCV();
 
 test "C ABI complex float" {
     if (!complex_abi_compatible) return error.SkipZigTest;
@@ -5553,7 +5553,7 @@ extern fn c_f16_struct(f16_struct) f16_struct;
 test "f16 struct" {
     if (builtin.target.cpu.arch.isMIPS64()) return error.SkipZigTest;
     if (builtin.target.cpu.arch.isPowerPC32()) return error.SkipZigTest;
-    if (builtin.cpu.arch.isARM() and builtin.mode != .Debug) return error.SkipZigTest;
+    if (builtin.cpu.arch.isArm() and builtin.mode != .Debug) return error.SkipZigTest;
 
     const a = c_f16_struct(.{ .a = 12 });
     try expect(a.a == 34);
diff --git a/zig/test/cases/adding_numbers_at_runtime_and_comptime.0.zig b/zig/test/cases/adding_numbers_at_runtime_and_comptime.0.zig
deleted file mode 100644
index e8c2196813..0000000000
--- a/zig/test/cases/adding_numbers_at_runtime_and_comptime.0.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    if (a + b != 7) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/adding_numbers_at_runtime_and_comptime.1.zig b/zig/test/cases/adding_numbers_at_runtime_and_comptime.1.zig
deleted file mode 100644
index d90dc6884d..0000000000
--- a/zig/test/cases/adding_numbers_at_runtime_and_comptime.1.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    if (x - 7 != 0) unreachable;
-}
-
-fn add(a: u32, b: u32) u32 {
-    return a + b;
-}
-
-const x = add(3, 4);
-
-// run
-//
diff --git a/zig/test/cases/adding_numbers_at_runtime_and_comptime.2.zig b/zig/test/cases/adding_numbers_at_runtime_and_comptime.2.zig
deleted file mode 100644
index d6d8755dc3..0000000000
--- a/zig/test/cases/adding_numbers_at_runtime_and_comptime.2.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() void {
-    var x: usize = 3;
-    _ = &x;
-    const y = add(1, 2, x);
-    if (y - 6 != 0) unreachable;
-}
-
-inline fn add(a: usize, b: usize, c: usize) usize {
-    return a + b + c;
-}
-
-// run
-//
diff --git a/zig/test/cases/arithmetic_operations.0.zig b/zig/test/cases/arithmetic_operations.0.zig
deleted file mode 100644
index ea22e22216..0000000000
--- a/zig/test/cases/arithmetic_operations.0.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const std = @import("std");
-
-pub fn main() void {
-    print(2, 4);
-    print(1, 7);
-}
-
-fn print(a: u32, b: u32) void {
-    const str = "123456789";
-    const len = a + b;
-    _ = std.posix.write(1, str[0..len]) catch {};
-}
-
-// run
-// target=x86_64-linux,x86_64-macos
-//
-// 12345612345678
diff --git a/zig/test/cases/arithmetic_operations.1.zig b/zig/test/cases/arithmetic_operations.1.zig
deleted file mode 100644
index 31f77317d5..0000000000
--- a/zig/test/cases/arithmetic_operations.1.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const std = @import("std");
-
-pub fn main() void {
-    print(10, 5);
-    print(4, 3);
-}
-
-fn print(a: u32, b: u32) void {
-    const str = "123456789";
-    const len = a - b;
-    _ = std.posix.write(1, str[0..len]) catch {};
-}
-
-// run
-//
-// 123451
diff --git a/zig/test/cases/arithmetic_operations.2.zig b/zig/test/cases/arithmetic_operations.2.zig
deleted file mode 100644
index 4ef5bec8d6..0000000000
--- a/zig/test/cases/arithmetic_operations.2.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const std = @import("std");
-
-pub fn main() void {
-    print(8, 9);
-    print(3, 7);
-}
-
-fn print(a: u32, b: u32) void {
-    const str = "123456789";
-    const len = a & b;
-    _ = std.posix.write(1, str[0..len]) catch {};
-}
-
-// run
-//
-// 12345678123
diff --git a/zig/test/cases/arithmetic_operations.3.zig b/zig/test/cases/arithmetic_operations.3.zig
deleted file mode 100644
index a16fdbc2d1..0000000000
--- a/zig/test/cases/arithmetic_operations.3.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const std = @import("std");
-
-pub fn main() void {
-    print(4, 2);
-    print(3, 7);
-}
-
-fn print(a: u32, b: u32) void {
-    const str = "123456789";
-    const len = a | b;
-    _ = std.posix.write(1, str[0..len]) catch {};
-}
-
-// run
-//
-// 1234561234567
diff --git a/zig/test/cases/arithmetic_operations.4.zig b/zig/test/cases/arithmetic_operations.4.zig
deleted file mode 100644
index 5037ad7485..0000000000
--- a/zig/test/cases/arithmetic_operations.4.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const std = @import("std");
-
-pub fn main() void {
-    print(42, 42);
-    print(3, 5);
-}
-
-fn print(a: u32, b: u32) void {
-    const str = "123456789";
-    const len = a ^ b;
-    _ = std.posix.write(1, str[0..len]) catch {};
-}
-
-// run
-//
-// 123456
diff --git a/zig/test/cases/arithmetic_operations.5.zig b/zig/test/cases/arithmetic_operations.5.zig
deleted file mode 100644
index b1c18ca7da..0000000000
--- a/zig/test/cases/arithmetic_operations.5.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    var x: u32 = 1;
-    assert(x << 1 == 2);
-
-    x <<= 1;
-    assert(x << 2 == 8);
-    assert(x << 3 == 16);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/arithmetic_operations.6.zig b/zig/test/cases/arithmetic_operations.6.zig
deleted file mode 100644
index e03731173c..0000000000
--- a/zig/test/cases/arithmetic_operations.6.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-pub fn main() void {
-    var a: u32 = 1024;
-    assert(a >> 1 == 512);
-
-    a >>= 1;
-    assert(a >> 2 == 128);
-    assert(a >> 3 == 64);
-    assert(a >> 4 == 32);
-    assert(a >> 5 == 16);
-    assert(a >> 6 == 8);
-    assert(a >> 7 == 4);
-    assert(a >> 8 == 2);
-    assert(a >> 9 == 1);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.0.zig b/zig/test/cases/assert_function.0.zig
deleted file mode 100644
index 7a832e522b..0000000000
--- a/zig/test/cases/assert_function.0.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    assert(a + b == 7);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-// target=x86_64-macos,x86_64-linux
-// link_libc=true
diff --git a/zig/test/cases/assert_function.1.zig b/zig/test/cases/assert_function.1.zig
deleted file mode 100644
index ac2df25d85..0000000000
--- a/zig/test/cases/assert_function.1.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    const c = a + b; // 7
-    const d = a + c; // 10
-    const e = d + b; // 14
-    assert(e == 14);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.10.zig b/zig/test/cases/assert_function.10.zig
deleted file mode 100644
index b3f1610cd6..0000000000
--- a/zig/test/cases/assert_function.10.zig
+++ /dev/null
@@ -1,27 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 116);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        break :blk j;
-    };
-    const y = x + a; // 113
-    const z = y + a; // 116
-    return z;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.11.zig b/zig/test/cases/assert_function.11.zig
deleted file mode 100644
index d64130a677..0000000000
--- a/zig/test/cases/assert_function.11.zig
+++ /dev/null
@@ -1,66 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 1221);
-    assert(mul(3, 4) == 21609);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        const k = i + j; // 210
-        const l = j + k; // 320
-        const m = l + c; // 327
-        const n = m + d; // 337
-        const o = n + e; // 351
-        const p = o + f; // 375
-        const q = p + g; // 413
-        const r = q + h; // 475
-        const s = r + i; // 575
-        const t = s + j; // 685
-        const u = t + k; // 895
-        const v = u + l; // 1215
-        break :blk v;
-    };
-    const y = x + a; // 1218
-    const z = y + a; // 1221
-    return z;
-}
-
-fn mul(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a * a * a * a; // 81
-        const d = a * a * a * b; // 108
-        const e = a * a * b * a; // 108
-        const f = a * a * b * b; // 144
-        const g = a * b * a * a; // 108
-        const h = a * b * a * b; // 144
-        const i = a * b * b * a; // 144
-        const j = a * b * b * b; // 192
-        const k = b * a * a * a; // 108
-        const l = b * a * a * b; // 144
-        const m = b * a * b * a; // 144
-        const n = b * a * b * b; // 192
-        const o = b * b * a * a; // 144
-        const p = b * b * a * b; // 192
-        const q = b * b * b * a; // 192
-        const r = b * b * b * b; // 256
-        const s = c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r; // 2401
-        break :blk s;
-    };
-    const y = x * a; // 7203
-    const z = y * a; // 21609
-    return z;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.12.zig b/zig/test/cases/assert_function.12.zig
deleted file mode 100644
index 4f64c1e062..0000000000
--- a/zig/test/cases/assert_function.12.zig
+++ /dev/null
@@ -1,47 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 791);
-    assert(add(4, 3) == 79);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = if (a < b) blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        const k = i + j; // 210
-        const l = k + c; // 217
-        const m = l + d; // 227
-        const n = m + e; // 241
-        const o = n + f; // 265
-        const p = o + g; // 303
-        const q = p + h; // 365
-        const r = q + i; // 465
-        const s = r + j; // 575
-        const t = s + k; // 785
-        break :blk t;
-    } else blk: {
-        const t = b + b + a; // 10
-        const c = a + t; // 14
-        const d = c + t; // 24
-        const e = d + t; // 34
-        const f = e + t; // 44
-        const g = f + t; // 54
-        const h = c + g; // 68
-        break :blk h + b; // 71
-    };
-    const y = x + a; // 788, 75
-    const z = y + a; // 791, 79
-    return z;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.13.zig b/zig/test/cases/assert_function.13.zig
deleted file mode 100644
index 240abf0108..0000000000
--- a/zig/test/cases/assert_function.13.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-pub fn main() void {
-    const ignore =
-        \\ cool thx
-        \\
-    ;
-    _ = ignore;
-    add('ぁ', '\x03');
-}
-
-fn add(a: u32, b: u32) void {
-    assert(a + b == 12356);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.14.zig b/zig/test/cases/assert_function.14.zig
deleted file mode 100644
index d25100dcce..0000000000
--- a/zig/test/cases/assert_function.14.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-pub fn main() void {
-    add(aa, bb);
-}
-
-const aa = 'ぁ';
-const bb = '\x03';
-
-fn add(a: u32, b: u32) void {
-    assert(a + b == 12356);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.15.zig b/zig/test/cases/assert_function.15.zig
deleted file mode 100644
index 33ae1ed5af..0000000000
--- a/zig/test/cases/assert_function.15.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    assert("hello"[0] == 'h');
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.16.zig b/zig/test/cases/assert_function.16.zig
deleted file mode 100644
index eef1136423..0000000000
--- a/zig/test/cases/assert_function.16.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const hello = "hello".*;
-pub fn main() void {
-    assert(hello[1] == 'e');
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.17.zig b/zig/test/cases/assert_function.17.zig
deleted file mode 100644
index 01c4a5ca3c..0000000000
--- a/zig/test/cases/assert_function.17.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    var i: u64 = 0xFFEEDDCCBBAA9988;
-    _ = &i;
-    assert(i == 0xFFEEDDCCBBAA9988);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.18.zig b/zig/test/cases/assert_function.18.zig
deleted file mode 100644
index ac0f97c40f..0000000000
--- a/zig/test/cases/assert_function.18.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-const builtin = @import("builtin");
-
-extern "c" fn write(c_int, usize, usize) usize;
-
-pub fn main() void {
-    for ("hello") |_| print();
-}
-
-fn print() void {
-    _ = write(1, @intFromPtr("hello\n"), 6);
-}
-
-// run
-//
-// hello
-// hello
-// hello
-// hello
-// hello
-//
diff --git a/zig/test/cases/assert_function.2.zig b/zig/test/cases/assert_function.2.zig
deleted file mode 100644
index 8c1c510486..0000000000
--- a/zig/test/cases/assert_function.2.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    const c = a + b; // 7
-    const d = a + c; // 10
-    const e = d + b; // 14
-    const f = d + e; // 24
-    const g = e + f; // 38
-    const h = f + g; // 62
-    const i = g + h; // 100
-    assert(i == 100);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.3.zig b/zig/test/cases/assert_function.3.zig
deleted file mode 100644
index a6829f8e02..0000000000
--- a/zig/test/cases/assert_function.3.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-pub fn main() void {
-    add(3, 4);
-}
-
-fn add(a: u32, b: u32) void {
-    const c = a + b; // 7
-    const d = a + c; // 10
-    const e = d + b; // 14
-    const f = d + e; // 24
-    const g = e + f; // 38
-    const h = f + g; // 62
-    const i = g + h; // 100
-    const j = i + d; // 110
-    assert(j == 110);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.4.zig b/zig/test/cases/assert_function.4.zig
deleted file mode 100644
index 69df4354c3..0000000000
--- a/zig/test/cases/assert_function.4.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 7);
-    assert(add(20, 10) == 30);
-}
-
-fn add(a: u32, b: u32) u32 {
-    return a + b;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.5.zig b/zig/test/cases/assert_function.5.zig
deleted file mode 100644
index 89f3f7df4f..0000000000
--- a/zig/test/cases/assert_function.5.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 7);
-    assert(add(20, 10) == 30);
-}
-
-fn add(a: u32, b: u32) u32 {
-    var x: u32 = undefined;
-    x = 0;
-    x += a;
-    x += b;
-    return x;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.6.zig b/zig/test/cases/assert_function.6.zig
deleted file mode 100644
index 1b1b75e68e..0000000000
--- a/zig/test/cases/assert_function.6.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    const a: u32 = 2;
-    const b: ?u32 = a;
-    const c = b.?;
-    if (c != 2) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/assert_function.7.zig b/zig/test/cases/assert_function.7.zig
deleted file mode 100644
index 9db604d3b9..0000000000
--- a/zig/test/cases/assert_function.7.zig
+++ /dev/null
@@ -1,23 +0,0 @@
-extern "c" fn write(c_int, usize, usize) usize;
-
-pub fn main() void {
-    var i: u32 = 0;
-    while (i < 4) : (i += 1) print();
-    assert(i == 4);
-}
-
-fn print() void {
-    _ = write(1, @intFromPtr("hello\n"), 6);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
-// hello
-// hello
-// hello
-// hello
-//
diff --git a/zig/test/cases/assert_function.8.zig b/zig/test/cases/assert_function.8.zig
deleted file mode 100644
index 02b486a8cb..0000000000
--- a/zig/test/cases/assert_function.8.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-extern "c" fn write(c_int, usize, usize) usize;
-
-pub fn main() void {
-    var i: u32 = 0;
-    inline while (i < 4) : (i += 1) print();
-    assert(i == 4);
-}
-
-fn print() void {
-    _ = write(1, @intFromPtr("hello\n"), 6);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// error
-//
-// :5:21: error: unable to resolve comptime value
-// :5:21: note: condition in comptime branch must be comptime-known
diff --git a/zig/test/cases/assert_function.9.zig b/zig/test/cases/assert_function.9.zig
deleted file mode 100644
index c754bb7711..0000000000
--- a/zig/test/cases/assert_function.9.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 20);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        break :blk e;
-    };
-    const y = x + a; // 17
-    const z = y + a; // 20
-    return z;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.0.zig b/zig/test/cases/binary_operands.0.zig
deleted file mode 100644
index e3688232aa..0000000000
--- a/zig/test/cases/binary_operands.0.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i: u8 = 5;
-    i += 20;
-    if (i != 25) unreachable;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/zig/test/cases/binary_operands.1.zig b/zig/test/cases/binary_operands.1.zig
deleted file mode 100644
index 2b244b194a..0000000000
--- a/zig/test/cases/binary_operands.1.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i: i32 = 2147483647;
-    _ = &i;
-    if (i +% 1 != -2147483648) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.10.zig b/zig/test/cases/binary_operands.10.zig
deleted file mode 100644
index 721a921743..0000000000
--- a/zig/test/cases/binary_operands.10.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn main() void {
-    var i: u32 = 5;
-    i *= 7;
-    var result: u32 = foo(i, 10);
-    _ = &result;
-    if (result != 350) unreachable;
-    return;
-}
-fn foo(x: u32, y: u32) u32 {
-    return x * y;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.11.zig b/zig/test/cases/binary_operands.11.zig
deleted file mode 100644
index f6a8755178..0000000000
--- a/zig/test/cases/binary_operands.11.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    var i: i32 = 2147483647;
-    _ = &i;
-    const result = i *% 2;
-    if (result != -2) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.12.zig b/zig/test/cases/binary_operands.12.zig
deleted file mode 100644
index d8b369764f..0000000000
--- a/zig/test/cases/binary_operands.12.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i: u3 = 3;
-    _ = &i;
-    if (i *% 3 != 1) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.13.zig b/zig/test/cases/binary_operands.13.zig
deleted file mode 100644
index 680d82a919..0000000000
--- a/zig/test/cases/binary_operands.13.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i: i4 = 3;
-    _ = &i;
-    if (i *% 3 != -7) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.14.zig b/zig/test/cases/binary_operands.14.zig
deleted file mode 100644
index aa1d62bcde..0000000000
--- a/zig/test/cases/binary_operands.14.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() void {
-    var i: u32 = 352;
-    i /= 7; // i = 50
-    const result: u32 = foo(i, 7);
-    if (result != 7) unreachable;
-    return;
-}
-fn foo(x: u32, y: u32) u32 {
-    return x / y;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.15.zig b/zig/test/cases/binary_operands.15.zig
deleted file mode 100644
index c709e5dfd2..0000000000
--- a/zig/test/cases/binary_operands.15.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    i &= 6;
-    return i - 4;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.16.zig b/zig/test/cases/binary_operands.16.zig
deleted file mode 100644
index fe1813b877..0000000000
--- a/zig/test/cases/binary_operands.16.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    i |= 6;
-    return i - 7;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.17.zig b/zig/test/cases/binary_operands.17.zig
deleted file mode 100644
index 439d3d6d6b..0000000000
--- a/zig/test/cases/binary_operands.17.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    i ^= 6;
-    return i - 3;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.18.zig b/zig/test/cases/binary_operands.18.zig
deleted file mode 100644
index c21aa586c5..0000000000
--- a/zig/test/cases/binary_operands.18.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = false;
-    b = b or false;
-    if (b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.19.zig b/zig/test/cases/binary_operands.19.zig
deleted file mode 100644
index e95470391c..0000000000
--- a/zig/test/cases/binary_operands.19.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = true;
-    b = b or false;
-    if (!b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.2.zig b/zig/test/cases/binary_operands.2.zig
deleted file mode 100644
index 5b08fecc04..0000000000
--- a/zig/test/cases/binary_operands.2.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i: i4 = 7;
-    _ = &i;
-    if (i +% 1 != -8) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.20.zig b/zig/test/cases/binary_operands.20.zig
deleted file mode 100644
index 9238bf97c0..0000000000
--- a/zig/test/cases/binary_operands.20.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = false;
-    b = b or true;
-    if (!b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.21.zig b/zig/test/cases/binary_operands.21.zig
deleted file mode 100644
index a2d427bda9..0000000000
--- a/zig/test/cases/binary_operands.21.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = true;
-    b = b or true;
-    if (!b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.22.zig b/zig/test/cases/binary_operands.22.zig
deleted file mode 100644
index aa8439a361..0000000000
--- a/zig/test/cases/binary_operands.22.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = false;
-    b = b and false;
-    if (b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.23.zig b/zig/test/cases/binary_operands.23.zig
deleted file mode 100644
index 8596ea7709..0000000000
--- a/zig/test/cases/binary_operands.23.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = true;
-    b = b and false;
-    if (b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.24.zig b/zig/test/cases/binary_operands.24.zig
deleted file mode 100644
index 08dc4430a2..0000000000
--- a/zig/test/cases/binary_operands.24.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = false;
-    b = b and true;
-    if (b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.25.zig b/zig/test/cases/binary_operands.25.zig
deleted file mode 100644
index 8aa0acfdb5..0000000000
--- a/zig/test/cases/binary_operands.25.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var b: bool = true;
-    b = b and true;
-    if (!b) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.3.zig b/zig/test/cases/binary_operands.3.zig
deleted file mode 100644
index 75d78d522a..0000000000
--- a/zig/test/cases/binary_operands.3.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 255;
-    _ = &i;
-    return i +% 1;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.4.zig b/zig/test/cases/binary_operands.4.zig
deleted file mode 100644
index b3fd9fc289..0000000000
--- a/zig/test/cases/binary_operands.4.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    i += 20;
-    const result: u8 = foo(i, 10);
-    return result - 35;
-}
-fn foo(x: u8, y: u8) u8 {
-    return x + y;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.5.zig b/zig/test/cases/binary_operands.5.zig
deleted file mode 100644
index 51ab437475..0000000000
--- a/zig/test/cases/binary_operands.5.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 20;
-    i -= 5;
-    return i - 15;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.6.zig b/zig/test/cases/binary_operands.6.zig
deleted file mode 100644
index b6e04e609e..0000000000
--- a/zig/test/cases/binary_operands.6.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i: i32 = -2147483648;
-    _ = &i;
-    if (i -% 1 != 2147483647) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.7.zig b/zig/test/cases/binary_operands.7.zig
deleted file mode 100644
index ae69df2c55..0000000000
--- a/zig/test/cases/binary_operands.7.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i: i7 = -64;
-    _ = &i;
-    if (i -% 1 != 63) unreachable;
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.8.zig b/zig/test/cases/binary_operands.8.zig
deleted file mode 100644
index fb2741cab6..0000000000
--- a/zig/test/cases/binary_operands.8.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() void {
-    var i: u4 = 0;
-    _ = &i;
-    if (i -% 1 != 15) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/binary_operands.9.zig b/zig/test/cases/binary_operands.9.zig
deleted file mode 100644
index a9d62b96e3..0000000000
--- a/zig/test/cases/binary_operands.9.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    i -= 3;
-    var result: u8 = foo(i, 10);
-    _ = &result;
-    return result - 8;
-}
-fn foo(x: u8, y: u8) u8 {
-    return y - x;
-}
-
-// run
-//
diff --git a/zig/test/cases/break_continue.0.zig b/zig/test/cases/break_continue.0.zig
deleted file mode 100644
index 6684bcb0d0..0000000000
--- a/zig/test/cases/break_continue.0.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    while (true) {
-        break;
-    }
-}
-
-// run
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/zig/test/cases/break_continue.1.zig b/zig/test/cases/break_continue.1.zig
deleted file mode 100644
index 9e4f79bd14..0000000000
--- a/zig/test/cases/break_continue.1.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() void {
-    foo: while (true) {
-        break :foo;
-    }
-}
-
-// run
-//
diff --git a/zig/test/cases/break_continue.2.zig b/zig/test/cases/break_continue.2.zig
deleted file mode 100644
index ba12f33e3f..0000000000
--- a/zig/test/cases/break_continue.2.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    var i: u64 = 0;
-    while (true) : (i += 1) {
-        if (i == 4) return;
-        continue;
-    }
-}
-
-// run
-//
diff --git a/zig/test/cases/break_continue.3.zig b/zig/test/cases/break_continue.3.zig
deleted file mode 100644
index 03e224d265..0000000000
--- a/zig/test/cases/break_continue.3.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    var i: u64 = 0;
-    foo: while (true) : (i += 1) {
-        if (i == 4) return;
-        continue :foo;
-    }
-}
-
-// run
-//
diff --git a/zig/test/cases/catch_at_comptime.0.zig b/zig/test/cases/catch_at_comptime.0.zig
deleted file mode 100644
index af1545832d..0000000000
--- a/zig/test/cases/catch_at_comptime.0.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const i: anyerror!u64 = 0;
-    const caught = i catch 5;
-    assert(caught == 0);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/catch_at_comptime.1.zig b/zig/test/cases/catch_at_comptime.1.zig
deleted file mode 100644
index e05caeae6d..0000000000
--- a/zig/test/cases/catch_at_comptime.1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const i: anyerror!u64 = error.B;
-    const caught = i catch 5;
-    assert(caught == 5);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/catch_at_comptime.2.zig b/zig/test/cases/catch_at_comptime.2.zig
deleted file mode 100644
index 326e6f0b61..0000000000
--- a/zig/test/cases/catch_at_comptime.2.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const a: anyerror!comptime_int = 42;
-    const b: *const comptime_int = &(a catch unreachable);
-    assert(b.* == 42);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/catch_at_comptime.3.zig b/zig/test/cases/catch_at_comptime.3.zig
deleted file mode 100644
index d00317f697..0000000000
--- a/zig/test/cases/catch_at_comptime.3.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    const a: anyerror!u32 = error.B;
-    _ = &(a catch |err| assert(err == error.B));
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/catch_at_comptime.4.zig b/zig/test/cases/catch_at_comptime.4.zig
deleted file mode 100644
index 57cb602641..0000000000
--- a/zig/test/cases/catch_at_comptime.4.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    const a: anyerror!u32 = error.Bar;
-    a catch |err| assert(err == error.Bar);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/compile_errors/array slice sentinel mismatch non-scalar.zig b/zig/test/cases/compile_errors/array slice sentinel mismatch non-scalar.zig
index 085caffc99..8eba014107 100644
--- a/zig/test/cases/compile_errors/array slice sentinel mismatch non-scalar.zig	
+++ b/zig/test/cases/compile_errors/array slice sentinel mismatch non-scalar.zig	
@@ -1,7 +1,8 @@
 export fn foo() void {
     const S = struct { a: u32 };
+    const sentinel: S = .{ .a = 1 };
     var arr = [_]S{ .{ .a = 1 }, .{ .a = 2 } };
-    const s = arr[0..1 :.{ .a = 1 }];
+    const s = arr[0..1 :sentinel];
     _ = s;
 }
 
@@ -9,5 +10,5 @@ export fn foo() void {
 // backend=stage2
 // target=native
 //
-// :4:26: error: non-scalar sentinel type 'tmp.foo.S'
+// :5:25: error: non-scalar sentinel type 'tmp.foo.S'
 // :2:15: note: struct declared here
diff --git a/zig/test/cases/compile_errors/array_in_c_exported_function.zig b/zig/test/cases/compile_errors/array_in_c_exported_function.zig
index e938b6afd4..384f020893 100644
--- a/zig/test/cases/compile_errors/array_in_c_exported_function.zig
+++ b/zig/test/cases/compile_errors/array_in_c_exported_function.zig
@@ -7,10 +7,9 @@ export fn zig_return_array() [10]u8 {
 }
 
 // error
-// backend=stage2
-// target=native
+// target=x86_64-linux
 //
-// :1:21: error: parameter of type '[10]u8' not allowed in function with calling convention 'C'
+// :1:21: error: parameter of type '[10]u8' not allowed in function with calling convention 'x86_64_sysv'
 // :1:21: note: arrays are not allowed as a parameter type
-// :5:30: error: return type '[10]u8' not allowed in function with calling convention 'C'
+// :5:30: error: return type '[10]u8' not allowed in function with calling convention 'x86_64_sysv'
 // :5:30: note: arrays are not allowed as a return type
diff --git a/zig/test/cases/compile_errors/assign_inline_fn_to_non-comptime_var.zig b/zig/test/cases/compile_errors/assign_inline_fn_to_non-comptime_var.zig
index 155df733fb..38360e7ed5 100644
--- a/zig/test/cases/compile_errors/assign_inline_fn_to_non-comptime_var.zig
+++ b/zig/test/cases/compile_errors/assign_inline_fn_to_non-comptime_var.zig
@@ -8,5 +8,5 @@ inline fn b() void {}
 // backend=stage2
 // target=native
 //
-// :2:9: error: variable of type '*const fn () callconv(.Inline) void' must be const or comptime
+// :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/zig/test/cases/compile_errors/bitsize_of_packed_struct_checks_backing_int_ty.zig b/zig/test/cases/compile_errors/bitsize_of_packed_struct_checks_backing_int_ty.zig
index 774a9c3376..e0bf5c2624 100644
--- a/zig/test/cases/compile_errors/bitsize_of_packed_struct_checks_backing_int_ty.zig
+++ b/zig/test/cases/compile_errors/bitsize_of_packed_struct_checks_backing_int_ty.zig
@@ -1,7 +1,7 @@
 const Foo = packed struct(u32) {
     x: u1,
 };
-fn bar(_: Foo) callconv(.C) void {}
+fn bar(_: Foo) callconv(.c) void {}
 pub export fn entry() void {
     bar(.{ .x = 0 });
 }
diff --git a/zig/test/cases/compile_errors/bogus_compile_var.zig b/zig/test/cases/compile_errors/bogus_compile_var.zig
index 3584730205..3562efa4f6 100644
--- a/zig/test/cases/compile_errors/bogus_compile_var.zig
+++ b/zig/test/cases/compile_errors/bogus_compile_var.zig
@@ -7,5 +7,5 @@ export fn entry() usize {
 // backend=stage2
 // target=native
 //
-// :1:29: error: root struct of file 'builtin' has no member named 'bogus'
+// :1:29: error: root source file struct 'builtin' has no member named 'bogus'
 // note: struct declared here
diff --git a/zig/test/cases/compile_errors/bogus_method_call_on_slice.zig b/zig/test/cases/compile_errors/bogus_method_call_on_slice.zig
index 5139b7550d..b796f6dd36 100644
--- a/zig/test/cases/compile_errors/bogus_method_call_on_slice.zig
+++ b/zig/test/cases/compile_errors/bogus_method_call_on_slice.zig
@@ -18,4 +18,5 @@ pub export fn entry2() void {
 //
 // :3:6: error: no field or member function named 'copy' in '[]const u8'
 // :9:8: error: no field or member function named 'bar' in '@TypeOf(.{})'
-// :12:18: error: no field or member function named 'bar' in 'struct{comptime foo: comptime_int = 1}'
+// :12:18: error: no field or member function named 'bar' in 'tmp.entry2__struct_170'
+// :12:6: note: struct declared here
diff --git a/zig/test/cases/compile_errors/builtin_extern_in_comptime_scope.zig b/zig/test/cases/compile_errors/builtin_extern_in_comptime_scope.zig
new file mode 100644
index 0000000000..4a85ee8aab
--- /dev/null
+++ b/zig/test/cases/compile_errors/builtin_extern_in_comptime_scope.zig
@@ -0,0 +1,18 @@
+const foo_tl = @extern(*i32, .{ .name = "foo", .is_thread_local = true });
+const foo_dll = @extern(*i32, .{ .name = "foo", .is_dll_import = true });
+pub export fn entry() void {
+    _ = foo_tl;
+}
+pub export fn entry2() void {
+    _ = foo_dll;
+}
+// error
+// backend=stage2
+// target=native
+//
+// :1:16: error: unable to resolve comptime value
+// :1:16: note: global variable initializer must be comptime-known
+// :1:16: note: thread local and dll imported variables have runtime-known addresses
+// :2:17: error: unable to resolve comptime value
+// :2:17: note: global variable initializer must be comptime-known
+// :2:17: note: thread local and dll imported variables have runtime-known addresses
diff --git a/zig/test/cases/compile_errors/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig b/zig/test/cases/compile_errors/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig
index cc6fc59a1a..ce1c80e9e6 100644
--- a/zig/test/cases/compile_errors/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig
+++ b/zig/test/cases/compile_errors/callconv_apcs_aapcs_aapcsvfp_on_unsupported_platform.zig
@@ -3,9 +3,8 @@ export fn entry2() callconv(.AAPCS) void {}
 export fn entry3() callconv(.AAPCSVFP) void {}
 
 // error
-// backend=stage2
 // target=x86_64-linux-none
 //
-// :1:30: error: callconv 'APCS' is only available on ARM, not x86_64
-// :2:30: error: callconv 'AAPCS' is only available on ARM, not x86_64
-// :3:30: error: callconv 'AAPCSVFP' is only available on ARM, not x86_64
+// :1:30: error: calling convention 'arm_apcs' only available on architectures 'arm', 'armeb', 'thumb', 'thumbeb'
+// :2:30: error: calling convention 'arm_aapcs' only available on architectures 'arm', 'armeb', 'thumb', 'thumbeb'
+// :3:30: error: calling convention 'arm_aapcs_vfp' only available on architectures 'arm', 'armeb', 'thumb', 'thumbeb'
diff --git a/zig/test/cases/compile_errors/callconv_interrupt_on_unsupported_platform.zig b/zig/test/cases/compile_errors/callconv_interrupt_on_unsupported_platform.zig
index 8208e2ffa3..97ef0aa1d6 100644
--- a/zig/test/cases/compile_errors/callconv_interrupt_on_unsupported_platform.zig
+++ b/zig/test/cases/compile_errors/callconv_interrupt_on_unsupported_platform.zig
@@ -4,4 +4,4 @@ export fn entry() callconv(.Interrupt) void {}
 // backend=stage2
 // target=aarch64-linux-none
 //
-// :1:29: error: callconv 'Interrupt' is only available on x86, x86_64, AVR, and MSP430, not aarch64
+// :1:29: error: calling convention 'Interrupt' is only available on x86, x86_64, AVR, and MSP430, not aarch64
diff --git a/zig/test/cases/compile_errors/callconv_signal_on_unsupported_platform.zig b/zig/test/cases/compile_errors/callconv_signal_on_unsupported_platform.zig
index 9233655e35..adc91d04e9 100644
--- a/zig/test/cases/compile_errors/callconv_signal_on_unsupported_platform.zig
+++ b/zig/test/cases/compile_errors/callconv_signal_on_unsupported_platform.zig
@@ -1,7 +1,7 @@
-export fn entry() callconv(.Signal) void {}
+export fn entry() callconv(.avr_signal) void {}
 
 // error
 // backend=stage2
 // target=x86_64-linux-none
 //
-// :1:29: error: callconv 'Signal' is only available on AVR, not x86_64
+// :1:29: error: calling convention 'avr_signal' only available on architectures 'avr'
diff --git a/zig/test/cases/compile_errors/callconv_stdcall_fastcall_thiscall_on_unsupported_platform.zig b/zig/test/cases/compile_errors/callconv_stdcall_fastcall_thiscall_on_unsupported_platform.zig
index 3480dc8aa7..28036c309c 100644
--- a/zig/test/cases/compile_errors/callconv_stdcall_fastcall_thiscall_on_unsupported_platform.zig
+++ b/zig/test/cases/compile_errors/callconv_stdcall_fastcall_thiscall_on_unsupported_platform.zig
@@ -1,6 +1,6 @@
-const F1 = fn () callconv(.Stdcall) void;
-const F2 = fn () callconv(.Fastcall) void;
-const F3 = fn () callconv(.Thiscall) void;
+const F1 = fn () callconv(.{ .x86_stdcall = .{} }) void;
+const F2 = fn () callconv(.{ .x86_fastcall = .{} }) void;
+const F3 = fn () callconv(.{ .x86_thiscall = .{} }) void;
 export fn entry1() void {
     const a: F1 = undefined;
     _ = a;
@@ -18,6 +18,6 @@ export fn entry3() void {
 // backend=stage2
 // target=x86_64-linux-none
 //
-// :1:28: error: callconv 'Stdcall' is only available on x86, not x86_64
-// :2:28: error: callconv 'Fastcall' is only available on x86, not x86_64
-// :3:28: error: callconv 'Thiscall' is only available on x86, not x86_64
+// :1:28: error: calling convention 'x86_stdcall' only available on architectures 'x86'
+// :2:28: error: calling convention 'x86_fastcall' only available on architectures 'x86'
+// :3:28: error: calling convention 'x86_thiscall' only available on architectures 'x86'
diff --git a/zig/test/cases/compile_errors/callconv_vectorcall_on_unsupported_platform.zig b/zig/test/cases/compile_errors/callconv_vectorcall_on_unsupported_platform.zig
deleted file mode 100644
index 9c0d982b3f..0000000000
--- a/zig/test/cases/compile_errors/callconv_vectorcall_on_unsupported_platform.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-export fn entry() callconv(.Vectorcall) void {}
-
-// error
-// backend=stage2
-// target=x86_64-linux-none
-//
-// :1:29: error: callconv 'Vectorcall' is only available on x86 and AArch64, not x86_64
diff --git a/zig/test/cases/compile_errors/calling_function_with_naked_calling_convention.zig b/zig/test/cases/compile_errors/calling_function_with_naked_calling_convention.zig
index 2bd0364d4f..ea4e42f15d 100644
--- a/zig/test/cases/compile_errors/calling_function_with_naked_calling_convention.zig
+++ b/zig/test/cases/compile_errors/calling_function_with_naked_calling_convention.zig
@@ -1,11 +1,11 @@
 export fn entry() void {
     foo();
 }
-fn foo() callconv(.Naked) void {}
+fn foo() callconv(.naked) void {}
 
 // error
 // backend=llvm
 // target=native
 //
-// :2:5: error: unable to call function with naked calling convention
+// :2:5: error: unable to call function with calling convention 'naked'
 // :4:1: note: function declared here
diff --git a/zig/test/cases/compile_errors/closure_get_depends_on_failed_decl.zig b/zig/test/cases/compile_errors/closure_get_depends_on_failed_decl.zig
index be451d2fc8..afe7319f0b 100644
--- a/zig/test/cases/compile_errors/closure_get_depends_on_failed_decl.zig
+++ b/zig/test/cases/compile_errors/closure_get_depends_on_failed_decl.zig
@@ -4,7 +4,7 @@ pub inline fn requestAdapter(
     comptime callbackArg: fn () callconv(.Inline) void,
 ) void {
     _ = &(struct {
-        pub fn callback() callconv(.C) void {
+        pub fn callback() callconv(.c) void {
             callbackArg();
         }
     }).callback;
diff --git a/zig/test/cases/compile_errors/coerce_anon_struct.zig b/zig/test/cases/compile_errors/coerce_anon_struct.zig
new file mode 100644
index 0000000000..84e3c732c8
--- /dev/null
+++ b/zig/test/cases/compile_errors/coerce_anon_struct.zig
@@ -0,0 +1,11 @@
+const T = struct { x: u32 };
+export fn foo() void {
+    const a = .{ .x = 123 };
+    _ = @as(T, a);
+}
+
+// error
+//
+// :4:16: error: expected type 'tmp.T', found 'tmp.foo__struct_159'
+// :3:16: note: struct declared here
+// :1:11: note: struct declared here
diff --git a/zig/test/cases/compile_errors/destructure_error_union.zig b/zig/test/cases/compile_errors/destructure_error_union.zig
index fb5872707d..ebc4823cdf 100644
--- a/zig/test/cases/compile_errors/destructure_error_union.zig
+++ b/zig/test/cases/compile_errors/destructure_error_union.zig
@@ -10,6 +10,6 @@ pub export fn entry() void {
 // backend=stage2
 // target=native
 //
-// :4:28: error: type 'anyerror!tmp.entry.Foo' cannot be destructured
+// :4:28: error: type 'anyerror!struct { u8, u8 }' cannot be destructured
 // :4:26: note: result destructured here
 // :4:28: note: consider using 'try', 'catch', or 'if'
diff --git a/zig/test/cases/compile_errors/explicit_error_set_cast_known_at_comptime_violates_error_sets.zig b/zig/test/cases/compile_errors/explicit_error_set_cast_known_at_comptime_violates_error_sets.zig
index a1beac65f2..0418d327c9 100644
--- a/zig/test/cases/compile_errors/explicit_error_set_cast_known_at_comptime_violates_error_sets.zig
+++ b/zig/test/cases/compile_errors/explicit_error_set_cast_known_at_comptime_violates_error_sets.zig
@@ -10,4 +10,4 @@ comptime {
 // backend=stage2
 // target=native
 //
-// :5:21: error: 'error.B' not a member of error set 'error{C,A}'
+// :5:21: error: 'error.B' not a member of error set 'error{A,C}'
diff --git a/zig/test/cases/compile_errors/export_function_with_comptime_parameter.zig b/zig/test/cases/compile_errors/export_function_with_comptime_parameter.zig
index 8d5dbef1c3..8a360d1629 100644
--- a/zig/test/cases/compile_errors/export_function_with_comptime_parameter.zig
+++ b/zig/test/cases/compile_errors/export_function_with_comptime_parameter.zig
@@ -3,7 +3,6 @@ export fn foo(comptime x: anytype, y: i32) i32 {
 }
 
 // error
-// backend=stage2
-// target=native
+// target=x86_64-linux
 //
-// :1:15: error: comptime parameters not allowed in function with calling convention 'C'
+// :1:15: error: comptime parameters not allowed in function with calling convention 'x86_64_sysv'
diff --git a/zig/test/cases/compile_errors/export_generic_function.zig b/zig/test/cases/compile_errors/export_generic_function.zig
index 4ffbad9df7..075e9b23da 100644
--- a/zig/test/cases/compile_errors/export_generic_function.zig
+++ b/zig/test/cases/compile_errors/export_generic_function.zig
@@ -4,7 +4,6 @@ export fn foo(num: anytype) i32 {
 }
 
 // error
-// backend=stage2
-// target=native
+// target=x86_64-linux
 //
-// :1:15: error: generic parameters not allowed in function with calling convention 'C'
+// :1:15: error: generic parameters not allowed in function with calling convention 'x86_64_sysv'
diff --git a/zig/test/cases/compile_errors/extern_function_pointer_mismatch.zig b/zig/test/cases/compile_errors/extern_function_pointer_mismatch.zig
index 36a548ceb9..204d2dd282 100644
--- a/zig/test/cases/compile_errors/extern_function_pointer_mismatch.zig
+++ b/zig/test/cases/compile_errors/extern_function_pointer_mismatch.zig
@@ -14,8 +14,7 @@ export fn entry() usize {
 }
 
 // error
-// backend=stage2
-// target=native
+// target=x86_64-linux
 //
-// :1:38: error: expected type 'fn (i32) i32', found 'fn (i32) callconv(.C) i32'
-// :1:38: note: calling convention 'C' cannot cast into calling convention 'Unspecified'
+// :1:38: error: expected type 'fn (i32) i32', found 'fn (i32) callconv(.c) i32'
+// :1:38: note: calling convention 'x86_64_sysv' cannot cast into calling convention 'auto'
diff --git a/zig/test/cases/compile_errors/extern_function_with_comptime_parameter.zig b/zig/test/cases/compile_errors/extern_function_with_comptime_parameter.zig
index 07fe34ad7f..a0c3d347f1 100644
--- a/zig/test/cases/compile_errors/extern_function_with_comptime_parameter.zig
+++ b/zig/test/cases/compile_errors/extern_function_with_comptime_parameter.zig
@@ -15,9 +15,8 @@ comptime {
 }
 
 // error
-// backend=stage2
-// target=native
+// target=x86_64-linux
 //
-// :1:15: error: comptime parameters not allowed in function with calling convention 'C'
-// :5:30: error: comptime parameters not allowed in function with calling convention 'C'
-// :6:30: error: generic parameters not allowed in function with calling convention 'C'
+// :1:15: error: comptime parameters not allowed in function with calling convention 'x86_64_sysv'
+// :5:30: error: comptime parameters not allowed in function with calling convention 'x86_64_sysv'
+// :6:30: error: generic parameters not allowed in function with calling convention 'x86_64_sysv'
diff --git a/zig/test/cases/compile_errors/file_level_tuple.zig b/zig/test/cases/compile_errors/file_level_tuple.zig
new file mode 100644
index 0000000000..97d119bb7d
--- /dev/null
+++ b/zig/test/cases/compile_errors/file_level_tuple.zig
@@ -0,0 +1,6 @@
+u32,
+comptime u8 = 123,
+
+// error
+//
+// :1:1: error: file cannot be a tuple
diff --git a/zig/test/cases/compile_errors/function-only_builtins_outside_function.zig b/zig/test/cases/compile_errors/function-only_builtins_outside_function.zig
index a9871e2b59..8178ee51fa 100644
--- a/zig/test/cases/compile_errors/function-only_builtins_outside_function.zig
+++ b/zig/test/cases/compile_errors/function-only_builtins_outside_function.zig
@@ -1,7 +1,3 @@
-comptime {
-    @setAlignStack(1);
-}
-
 comptime {
     @branchHint(.cold);
 }
@@ -54,16 +50,15 @@ comptime {
 // backend=stage2
 // target=native
 //
-// :2:5: error: '@setAlignStack' outside function scope
-// :6:5: error: '@branchHint' outside function scope
-// :10:5: error: '@src' outside function scope
-// :14:5: error: '@returnAddress' outside function scope
-// :18:5: error: '@frameAddress' outside function scope
-// :22:5: error: '@breakpoint' outside function scope
-// :26:5: error: '@cVaArg' outside function scope
-// :30:5: error: '@cVaCopy' outside function scope
-// :34:5: error: '@cVaEnd' outside function scope
-// :38:5: error: '@cVaStart' outside function scope
-// :42:5: error: '@workItemId' outside function scope
-// :46:5: error: '@workGroupSize' outside function scope
-// :50:5: error: '@workGroupId' outside function scope
+// :2:5: error: '@branchHint' outside function scope
+// :6:5: error: '@src' outside function scope
+// :10:5: error: '@returnAddress' outside function scope
+// :14:5: error: '@frameAddress' outside function scope
+// :18:5: error: '@breakpoint' outside function scope
+// :22:5: error: '@cVaArg' outside function scope
+// :26:5: error: '@cVaCopy' outside function scope
+// :30:5: error: '@cVaEnd' outside function scope
+// :34:5: error: '@cVaStart' outside function scope
+// :38:5: error: '@workItemId' outside function scope
+// :42:5: error: '@workGroupSize' outside function scope
+// :46:5: error: '@workGroupId' outside function scope
diff --git a/zig/test/cases/compile_errors/function_alignment_on_unsupported_target.zig b/zig/test/cases/compile_errors/function_alignment_on_unsupported_target.zig
new file mode 100644
index 0000000000..7b033e0f60
--- /dev/null
+++ b/zig/test/cases/compile_errors/function_alignment_on_unsupported_target.zig
@@ -0,0 +1,7 @@
+export fn entry() align(0) void {}
+
+// error
+// backend=stage2
+// target=nvptx-cuda,nvptx64-cuda,spirv-vulkan,spirv32-opencl,spirv64-opencl,wasm32-freestanding,wasm64-freestanding
+//
+// :1:25: error: target does not support function alignment
diff --git a/zig/test/cases/compile_errors/function_with_non-extern_non-packed_enum_parameter.zig b/zig/test/cases/compile_errors/function_with_non-extern_non-packed_enum_parameter.zig
index ab257ead71..8122a89adc 100644
--- a/zig/test/cases/compile_errors/function_with_non-extern_non-packed_enum_parameter.zig
+++ b/zig/test/cases/compile_errors/function_with_non-extern_non-packed_enum_parameter.zig
@@ -4,10 +4,9 @@ export fn entry(foo: Foo) void {
 }
 
 // error
-// backend=stage2
-// target=native
+// target=x86_64-linux
 //
-// :2:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'C'
+// :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: enum declared here
diff --git a/zig/test/cases/compile_errors/function_with_non-extern_non-packed_struct_parameter.zig b/zig/test/cases/compile_errors/function_with_non-extern_non-packed_struct_parameter.zig
index 137037f9e7..bb41a2ddb9 100644
--- a/zig/test/cases/compile_errors/function_with_non-extern_non-packed_struct_parameter.zig
+++ b/zig/test/cases/compile_errors/function_with_non-extern_non-packed_struct_parameter.zig
@@ -8,9 +8,8 @@ export fn entry(foo: Foo) void {
 }
 
 // error
-// backend=stage2
-// target=native
+// target=x86_64-linux
 //
-// :6:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'C'
+// :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
 // :1:13: note: struct declared here
diff --git a/zig/test/cases/compile_errors/function_with_non-extern_non-packed_union_parameter.zig b/zig/test/cases/compile_errors/function_with_non-extern_non-packed_union_parameter.zig
index d651329f72..220dbd146d 100644
--- a/zig/test/cases/compile_errors/function_with_non-extern_non-packed_union_parameter.zig
+++ b/zig/test/cases/compile_errors/function_with_non-extern_non-packed_union_parameter.zig
@@ -8,9 +8,8 @@ export fn entry(foo: Foo) void {
 }
 
 // error
-// backend=stage2
-// target=native
+// target=x86_64-linux
 //
-// :6:17: error: parameter of type 'tmp.Foo' not allowed in function with calling convention 'C'
+// :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
 // :1:13: note: union declared here
diff --git a/zig/test/cases/compile_errors/if_condition_is_bool_not_int.zig b/zig/test/cases/compile_errors/if_condition_is_bool_not_int.zig
index 20262f1b65..7ed2811ccf 100644
--- a/zig/test/cases/compile_errors/if_condition_is_bool_not_int.zig
+++ b/zig/test/cases/compile_errors/if_condition_is_bool_not_int.zig
@@ -1,9 +1,14 @@
-export fn f() void {
+export fn foo() void {
     if (0) {}
 }
 
+export fn bar() void {
+    comptime if (0) {};
+}
+
 // error
 // backend=stage2
 // target=native
 //
 // :2:9: error: expected type 'bool', found 'comptime_int'
+// :6:18: error: expected type 'bool', found 'comptime_int'
diff --git a/zig/test/cases/compile_errors/implicit_cast_of_error_set_not_a_subset.zig b/zig/test/cases/compile_errors/implicit_cast_of_error_set_not_a_subset.zig
index 617e638627..1dab9d81c9 100644
--- a/zig/test/cases/compile_errors/implicit_cast_of_error_set_not_a_subset.zig
+++ b/zig/test/cases/compile_errors/implicit_cast_of_error_set_not_a_subset.zig
@@ -12,5 +12,5 @@ fn foo(set1: Set1) void {
 // backend=stage2
 // target=native
 //
-// :7:21: error: expected type 'error{C,A}', found 'error{A,B}'
+// :7:21: error: expected type 'error{A,C}', found 'error{A,B}'
 // :7:21: note: 'error.B' not a member of destination error set
diff --git a/zig/test/cases/compile_errors/int_to_err_non_global_invalid_number.zig b/zig/test/cases/compile_errors/int_to_err_non_global_invalid_number.zig
index c9f6c1e2e4..829192ab8d 100644
--- a/zig/test/cases/compile_errors/int_to_err_non_global_invalid_number.zig
+++ b/zig/test/cases/compile_errors/int_to_err_non_global_invalid_number.zig
@@ -16,4 +16,4 @@ comptime {
 // backend=llvm
 // target=native
 //
-// :11:21: error: 'error.B' not a member of error set 'error{C,A}'
+// :11:21: error: 'error.B' not a member of error set 'error{A,C}'
diff --git a/zig/test/cases/compile_errors/invalid_extern_function_call.zig b/zig/test/cases/compile_errors/invalid_extern_function_call.zig
index 986b39c498..c270c3bf48 100644
--- a/zig/test/cases/compile_errors/invalid_extern_function_call.zig
+++ b/zig/test/cases/compile_errors/invalid_extern_function_call.zig
@@ -1,4 +1,4 @@
-const x = @extern(*const fn () callconv(.C) void, .{ .name = "foo" });
+const x = @extern(*const fn () callconv(.c) void, .{ .name = "foo" });
 
 export fn entry0() void {
     comptime x();
diff --git a/zig/test/cases/compile_errors/invalid_field_type_usage.zig b/zig/test/cases/compile_errors/invalid_field_type_usage.zig
new file mode 100644
index 0000000000..105e85d1f1
--- /dev/null
+++ b/zig/test/cases/compile_errors/invalid_field_type_usage.zig
@@ -0,0 +1,13 @@
+export fn foo() void {
+    _ = @FieldType(u8, "a");
+}
+export fn bar() void {
+    const S = struct { a: u8 };
+    _ = @FieldType(S, "b");
+}
+
+// error
+//
+// :2:20: error: expected struct or union; found 'u8'
+// :6:23: error: no field named 'b' in struct 'tmp.bar.S'
+// :5:15: note: struct declared here
diff --git a/zig/test/cases/compile_errors/invalid_func_for_callconv.zig b/zig/test/cases/compile_errors/invalid_func_for_callconv.zig
index 490b87bc4b..ef20d0ab8f 100644
--- a/zig/test/cases/compile_errors/invalid_func_for_callconv.zig
+++ b/zig/test/cases/compile_errors/invalid_func_for_callconv.zig
@@ -9,12 +9,11 @@ export fn signal_param(_: u32) callconv(.Signal) void {}
 export fn signal_ret() callconv(.Signal) noreturn {}
 
 // error
-// backend=stage2
 // target=x86_64-linux
-// 
-// :1:28: error: first parameter of function with 'Interrupt' calling convention must be a pointer type
-// :2:43: error: second parameter of function with 'Interrupt' calling convention must be a 64-bit integer
-// :3:51: error: 'Interrupt' calling convention supports up to 2 parameters, found 3
-// :4:69: error: function with calling convention 'Interrupt' must return 'void' or 'noreturn'
-// :8:24: error: parameters are not allowed with 'Signal' calling convention
-// :9:34: error: callconv 'Signal' is only available on AVR, not x86_64
+//
+// :1:28: error: first parameter of function with 'x86_64_interrupt' calling convention must be a pointer type
+// :2:43: error: second parameter of function with 'x86_64_interrupt' calling convention must be a 64-bit integer
+// :3:51: error: 'x86_64_interrupt' calling convention supports up to 2 parameters, found 3
+// :4:69: error: function with calling convention 'x86_64_interrupt' must return 'void' or 'noreturn'
+// :8:24: error: parameters are not allowed with 'avr_signal' calling convention
+// :9:34: error: calling convention 'avr_signal' only available on architectures 'avr'
diff --git a/zig/test/cases/compile_errors/invalid_peer_type_resolution.zig b/zig/test/cases/compile_errors/invalid_peer_type_resolution.zig
index e96caecfb6..c8cef83cac 100644
--- a/zig/test/cases/compile_errors/invalid_peer_type_resolution.zig
+++ b/zig/test/cases/compile_errors/invalid_peer_type_resolution.zig
@@ -10,11 +10,6 @@ export fn badTupleField() void {
     _ = .{ &x, &y };
     _ = @TypeOf(x, y);
 }
-export fn badNestedField() void {
-    const x = .{ .foo = "hi", .bar = .{ 0, 1 } };
-    const y = .{ .foo = "hello", .bar = .{ 2, "hi" } };
-    _ = @TypeOf(x, y);
-}
 export fn incompatiblePointers() void {
     const x: []const u8 = "foo";
     const y: [*:0]const u8 = "bar";
@@ -39,14 +34,9 @@ export fn incompatiblePointers4() void {
 // :11:9: note: incompatible types: 'u32' and '*const [5:0]u8'
 // :11:17: note: type 'u32' here
 // :11:20: note: type '*const [5:0]u8' here
-// :16:9: error: struct field 'bar' has conflicting types
-// :16:9: note: struct field '1' has conflicting types
-// :16:9: note: incompatible types: 'comptime_int' and '*const [2:0]u8'
-// :16:17: note: type 'comptime_int' here
-// :16:20: note: type '*const [2:0]u8' here
-// :21:9: error: incompatible types: '[]const u8' and '[*:0]const u8'
-// :21:17: note: type '[]const u8' here
-// :21:20: note: type '[*:0]const u8' here
-// :28:9: error: incompatible types: '[]const u8' and '[*]const u8'
-// :28:23: note: type '[]const u8' here
-// :28:26: note: type '[*]const u8' here
+// :16:9: error: incompatible types: '[]const u8' and '[*:0]const u8'
+// :16:17: note: type '[]const u8' here
+// :16:20: note: type '[*:0]const u8' here
+// :23:9: error: incompatible types: '[]const u8' and '[*]const u8'
+// :23:23: note: type '[]const u8' here
+// :23:26: note: type '[*]const u8' here
diff --git a/zig/test/cases/compile_errors/invalid_tail_call.zig b/zig/test/cases/compile_errors/invalid_tail_call.zig
index 3d327b948b..77b7ce1177 100644
--- a/zig/test/cases/compile_errors/invalid_tail_call.zig
+++ b/zig/test/cases/compile_errors/invalid_tail_call.zig
@@ -9,4 +9,4 @@ pub export fn entry() void {
 // backend=llvm
 // target=native
 //
-// :5:5: error: unable to perform tail call: type of function being called 'fn (usize) void' does not match type of calling function 'fn () callconv(.C) void'
+// :5:5: error: unable to perform tail call: type of function being called 'fn (usize) void' does not match type of calling function 'fn () callconv(.c) void'
diff --git a/zig/test/cases/compile_errors/invalid_variadic_function.zig b/zig/test/cases/compile_errors/invalid_variadic_function.zig
index ee8fc3439e..9b7a4b40f3 100644
--- a/zig/test/cases/compile_errors/invalid_variadic_function.zig
+++ b/zig/test/cases/compile_errors/invalid_variadic_function.zig
@@ -13,11 +13,10 @@ comptime {
 }
 
 // error
-// backend=stage2
-// target=native
+// target=x86_64-linux
 //
-// :1:1: error: variadic function does not support '.Unspecified' calling convention
-// :1:1: note: supported calling conventions: '.C'
-// :1:1: error: variadic function does not support '.Inline' calling convention
-// :1:1: note: supported calling conventions: '.C'
+// :1:1: error: variadic function does not support 'auto' calling convention
+// :1:1: note: supported calling conventions: 'x86_64_sysv', 'x86_64_win'
+// :1:1: error: variadic function does not support 'inline' calling convention
+// :1:1: note: supported calling conventions: 'x86_64_sysv', 'x86_64_win'
 // :2:1: error: generic function cannot be variadic
diff --git a/zig/test/cases/compile_errors/labeled_block_implicit_value.zig b/zig/test/cases/compile_errors/labeled_block_implicit_value.zig
new file mode 100644
index 0000000000..ce02f6a4ef
--- /dev/null
+++ b/zig/test/cases/compile_errors/labeled_block_implicit_value.zig
@@ -0,0 +1,10 @@
+export fn foo() void {
+    const result: u32 = b: {
+        if (false) break :b 1;
+    };
+    _ = result;
+}
+
+// error
+//
+// :2:28: error: expected type 'u32', found 'void'
diff --git a/zig/test/cases/compile_errors/missing_field_in_struct_value_expression.zig b/zig/test/cases/compile_errors/missing_field_in_struct_value_expression.zig
index 3b09df106f..8c06dc0be6 100644
--- a/zig/test/cases/compile_errors/missing_field_in_struct_value_expression.zig
+++ b/zig/test/cases/compile_errors/missing_field_in_struct_value_expression.zig
@@ -29,7 +29,5 @@ export fn h() void {
 // :9:16: error: missing struct field: x
 // :1:11: note: struct declared here
 // :18:16: error: missing tuple field with index 1
-// :16:11: note: struct declared here
 // :22:16: error: missing tuple field with index 0
 // :22:16: note: missing tuple field with index 1
-// :16:11: note: struct declared here
diff --git a/zig/test/cases/compile_errors/missing_main_fn_in_executable.zig b/zig/test/cases/compile_errors/missing_main_fn_in_executable.zig
index c1af588b99..6eae093846 100644
--- a/zig/test/cases/compile_errors/missing_main_fn_in_executable.zig
+++ b/zig/test/cases/compile_errors/missing_main_fn_in_executable.zig
@@ -3,7 +3,7 @@
 // target=x86_64-linux
 // output_mode=Exe
 //
-// : error: root struct of file 'tmp' has no member named 'main'
+// : error: root source file struct 'tmp' has no member named 'main'
 // : note: struct declared here
 // : note: called from here
 // : note: called from here
diff --git a/zig/test/cases/compile_errors/noinline_fn_cc_inline.zig b/zig/test/cases/compile_errors/noinline_fn_cc_inline.zig
index 3a2d6440c3..eee97e683b 100644
--- a/zig/test/cases/compile_errors/noinline_fn_cc_inline.zig
+++ b/zig/test/cases/compile_errors/noinline_fn_cc_inline.zig
@@ -1,5 +1,4 @@
-const cc = .Inline;
-noinline fn foo() callconv(cc) void {}
+noinline fn foo() callconv(.@"inline") void {}
 
 comptime {
     _ = foo;
@@ -9,4 +8,4 @@ comptime {
 // backend=stage2
 // target=native
 //
-// :2:28: error: 'noinline' function cannot have callconv 'Inline'
+// :1:29: error: 'noinline' function cannot have calling convention 'inline'
diff --git a/zig/test/cases/compile_errors/old_fn_ptr_in_extern_context.zig b/zig/test/cases/compile_errors/old_fn_ptr_in_extern_context.zig
index 7d747ec616..9bd63b6451 100644
--- a/zig/test/cases/compile_errors/old_fn_ptr_in_extern_context.zig
+++ b/zig/test/cases/compile_errors/old_fn_ptr_in_extern_context.zig
@@ -1,20 +1,20 @@
 const S = extern struct {
-    a: fn () callconv(.C) void,
+    a: fn () callconv(.c) void,
 };
 comptime {
     _ = @sizeOf(S) == 1;
 }
 comptime {
-    _ = [*c][4]fn () callconv(.C) void;
+    _ = [*c][4]fn () callconv(.c) void;
 }
 
 // error
 // backend=stage2
 // target=native
 //
-// :2:8: error: extern structs cannot contain fields of type 'fn () callconv(.C) void'
+// :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: 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/zig/test/cases/compile_errors/overflow_arithmetic_on_vector_with_undefined_elems.zig b/zig/test/cases/compile_errors/overflow_arithmetic_on_vector_with_undefined_elems.zig
index 8055756a11..c4223d7727 100644
--- a/zig/test/cases/compile_errors/overflow_arithmetic_on_vector_with_undefined_elems.zig
+++ b/zig/test/cases/compile_errors/overflow_arithmetic_on_vector_with_undefined_elems.zig
@@ -21,6 +21,6 @@ comptime {
 // :14:5: note: also here
 //
 // Compile Log Output:
-// @as(struct{@Vector(3, u8), @Vector(3, u1)}, .{ .{ 2, 144, undefined }, .{ 0, 1, undefined } })
-// @as(struct{@Vector(3, u8), @Vector(3, u1)}, .{ .{ 1, 255, undefined }, .{ 0, 1, undefined } })
-// @as(struct{@Vector(3, u8), @Vector(3, u1)}, .{ .{ 1, 64, undefined }, .{ 0, 1, undefined } })
+// @as(struct { @Vector(3, u8), @Vector(3, u1) }, .{ .{ 2, 144, undefined }, .{ 0, 1, undefined } })
+// @as(struct { @Vector(3, u8), @Vector(3, u1) }, .{ .{ 1, 255, undefined }, .{ 0, 1, undefined } })
+// @as(struct { @Vector(3, u8), @Vector(3, u1) }, .{ .{ 1, 64, undefined }, .{ 0, 1, undefined } })
diff --git a/zig/test/cases/compile_errors/packed_struct_comparison.zig b/zig/test/cases/compile_errors/packed_struct_comparison.zig
new file mode 100644
index 0000000000..8a3af3a8b2
--- /dev/null
+++ b/zig/test/cases/compile_errors/packed_struct_comparison.zig
@@ -0,0 +1,35 @@
+const x: Foo = .{};
+const y: Foo = .{};
+
+export fn a() void {
+    _ = x > y;
+}
+
+export fn b() void {
+    _ = x < y;
+}
+
+export fn c() void {
+    _ = x >= y;
+}
+export fn d() void {
+    _ = x <= y;
+}
+
+const Foo = packed struct {
+    a: u4 = 10,
+    b: u4 = 5,
+};
+
+// error
+// backend=stage2
+// target=native
+//
+// :5:11: error: operator > not allowed for type 'tmp.Foo'
+// :19:20: note: struct declared here
+// :9:11: error: operator < not allowed for type 'tmp.Foo'
+// :19:20: note: struct declared here
+// :13:11: error: operator >= not allowed for type 'tmp.Foo'
+// :19:20: note: struct declared here
+// :16:11: error: operator <= not allowed for type 'tmp.Foo'
+// :19:20: note: struct declared here
diff --git a/zig/test/cases/compile_errors/reify_type.Fn_with_is_var_args_true_and_non-C_callconv.zig b/zig/test/cases/compile_errors/reify_type.Fn_with_is_var_args_true_and_non-C_callconv.zig
index ee53938389..7986f2ef3f 100644
--- a/zig/test/cases/compile_errors/reify_type.Fn_with_is_var_args_true_and_non-C_callconv.zig
+++ b/zig/test/cases/compile_errors/reify_type.Fn_with_is_var_args_true_and_non-C_callconv.zig
@@ -12,8 +12,7 @@ comptime {
 }
 
 // error
-// backend=stage2
-// target=native
+// target=x86_64-linux
 //
-// :1:13: error: variadic function does not support '.Unspecified' calling convention
-// :1:13: note: supported calling conventions: '.C'
+// :1:13: error: variadic function does not support 'auto' calling convention
+// :1:13: note: supported calling conventions: 'x86_64_sysv', 'x86_64_win'
diff --git a/zig/test/cases/compile_errors/ret_coercion_error_in_generic_fn_called_from_non_fn_scope.zig b/zig/test/cases/compile_errors/ret_coercion_error_in_generic_fn_called_from_non_fn_scope.zig
new file mode 100644
index 0000000000..ba17172b42
--- /dev/null
+++ b/zig/test/cases/compile_errors/ret_coercion_error_in_generic_fn_called_from_non_fn_scope.zig
@@ -0,0 +1,14 @@
+fn foo() fn () void {
+    return struct {};
+}
+comptime {
+    _ = foo();
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:12: error: expected type 'fn () void', found 'type'
+// :1:10: note: function return type declared here
+// :5:12: note: called from here
diff --git a/zig/test/cases/compile_errors/return_undefined_from_noreturn.zig b/zig/test/cases/compile_errors/return_undefined_from_noreturn.zig
new file mode 100644
index 0000000000..eabb7769d1
--- /dev/null
+++ b/zig/test/cases/compile_errors/return_undefined_from_noreturn.zig
@@ -0,0 +1,10 @@
+export fn entry() noreturn {
+    return undefined;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:12: error: function declared 'noreturn' returns
+// :1:19: note: 'noreturn' declared here
diff --git a/zig/test/cases/compile_errors/runtime_@ptrFromInt_to_comptime_only_type.zig b/zig/test/cases/compile_errors/runtime_@ptrFromInt_to_comptime_only_type.zig
index 0c4e844e76..fb35590369 100644
--- a/zig/test/cases/compile_errors/runtime_@ptrFromInt_to_comptime_only_type.zig
+++ b/zig/test/cases/compile_errors/runtime_@ptrFromInt_to_comptime_only_type.zig
@@ -1,5 +1,5 @@
 const GuSettings = struct {
-    fin: ?fn (c_int) callconv(.C) void,
+    fin: ?fn (c_int) callconv(.c) void,
 };
 pub export fn callbackFin(id: c_int, arg: ?*anyopaque) void {
     const settings: ?*GuSettings = @as(?*GuSettings, @ptrFromInt(@intFromPtr(arg)));
@@ -13,4 +13,4 @@ pub export fn callbackFin(id: c_int, arg: ?*anyopaque) void {
 //
 // :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
+// :2:10: note: use '*const fn (c_int) callconv(.c) void' for a function pointer type
diff --git a/zig/test/cases/compile_errors/setAlignStack_in_naked_function.zig b/zig/test/cases/compile_errors/setAlignStack_in_naked_function.zig
deleted file mode 100644
index 79c4ba6f5b..0000000000
--- a/zig/test/cases/compile_errors/setAlignStack_in_naked_function.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() callconv(.Naked) void {
-    @setAlignStack(16);
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :2:5: error: @setAlignStack in naked function
diff --git a/zig/test/cases/compile_errors/setAlignStack_too_big.zig b/zig/test/cases/compile_errors/setAlignStack_too_big.zig
deleted file mode 100644
index 5ee96041e0..0000000000
--- a/zig/test/cases/compile_errors/setAlignStack_too_big.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn entry() void {
-    @setAlignStack(511 + 1);
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :2:5: error: attempt to @setAlignStack(512); maximum is 256
diff --git a/zig/test/cases/compile_errors/slice_used_as_extern_fn_param.zig b/zig/test/cases/compile_errors/slice_used_as_extern_fn_param.zig
index e6b065cd62..522e4eba8c 100644
--- a/zig/test/cases/compile_errors/slice_used_as_extern_fn_param.zig
+++ b/zig/test/cases/compile_errors/slice_used_as_extern_fn_param.zig
@@ -1,11 +1,10 @@
-extern fn Text(str: []const u8, num: i32) callconv(.C) void;
+extern fn Text(str: []const u8, num: i32) callconv(.c) void;
 export fn entry() void {
     _ = Text;
 }
 
 // error
-// backend=stage2
-// target=native
+// target=x86_64-linux
 //
-// :1:16: error: parameter of type '[]const u8' not allowed in function with calling convention 'C'
+// :1:16: error: parameter of type '[]const u8' not allowed in function with calling convention 'x86_64_sysv'
 // :1:16: note: slices have no guaranteed in-memory representation
diff --git a/zig/test/cases/compile_errors/spirv_merge_logical_pointers.zig b/zig/test/cases/compile_errors/spirv_merge_logical_pointers.zig
new file mode 100644
index 0000000000..ea81ef903c
--- /dev/null
+++ b/zig/test/cases/compile_errors/spirv_merge_logical_pointers.zig
@@ -0,0 +1,19 @@
+export fn a() void {
+    var x: *i32 = undefined;
+    _ = &x;
+    var y: *i32 = undefined;
+    _ = &y;
+    var rt_cond = false;
+    _ = &rt_cond;
+
+    var z = if (rt_cond) x else y;
+    _ = &z;
+}
+
+// error
+// backend=stage2
+// target=spirv64-vulkan
+//
+// :9:13: error: value with non-mergable pointer type '*i32' depends on runtime control flow
+// :9:17: note: runtime control flow here
+// :9:13: note: pointers with address space 'generic' cannot be returned from a branch on target spirv-vulkan by compiler backend stage2_spirv64
diff --git a/zig/test/cases/compile_errors/tuple_init_edge_cases.zig b/zig/test/cases/compile_errors/tuple_init_edge_cases.zig
index 24f4ff9bdd..7200fb42f1 100644
--- a/zig/test/cases/compile_errors/tuple_init_edge_cases.zig
+++ b/zig/test/cases/compile_errors/tuple_init_edge_cases.zig
@@ -72,6 +72,5 @@ pub export fn entry6() void {
 // :18:14: error: missing tuple field with index 1
 // :25:14: error: missing tuple field with index 1
 // :43:14: error: expected at most 2 tuple fields; found 3
-// :50:30: error: index '2' out of bounds of tuple 'struct{comptime comptime_int = 123, u32}'
+// :50:30: error: index '2' out of bounds of tuple 'struct { comptime comptime_int = 123, u32 }'
 // :63:37: error: missing tuple field with index 3
-// :58:32: note: struct declared here
diff --git a/zig/test/cases/compile_errors/type_mismatch_in_C_prototype_with_varargs.zig b/zig/test/cases/compile_errors/type_mismatch_in_C_prototype_with_varargs.zig
index f64dbc6ee4..3ac73fcb54 100644
--- a/zig/test/cases/compile_errors/type_mismatch_in_C_prototype_with_varargs.zig
+++ b/zig/test/cases/compile_errors/type_mismatch_in_C_prototype_with_varargs.zig
@@ -1,4 +1,4 @@
-const fn_ty = ?fn ([*c]u8, ...) callconv(.C) void;
+const fn_ty = ?fn ([*c]u8, ...) callconv(.c) void;
 extern fn fn_decl(fmt: [*:0]u8, ...) void;
 
 export fn main() void {
@@ -10,6 +10,6 @@ export fn main() void {
 // backend=stage2
 // target=native
 //
-// :5:22: error: expected type '?fn ([*c]u8, ...) callconv(.C) void', found 'fn ([*:0]u8, ...) callconv(.C) void'
+// :5:22: error: expected type '?fn ([*c]u8, ...) callconv(.c) void', found 'fn ([*:0]u8, ...) callconv(.c) void'
 // :5:22: note: parameter 0 '[*:0]u8' cannot cast into '[*c]u8'
 // :5:22: note: '[*c]u8' could have null values which are illegal in type '[*:0]u8'
diff --git a/zig/test/cases/compile_errors/type_mismatch_with_tuple_concatenation.zig b/zig/test/cases/compile_errors/type_mismatch_with_tuple_concatenation.zig
index 9f360e2afe..1efcead765 100644
--- a/zig/test/cases/compile_errors/type_mismatch_with_tuple_concatenation.zig
+++ b/zig/test/cases/compile_errors/type_mismatch_with_tuple_concatenation.zig
@@ -7,4 +7,4 @@ export fn entry() void {
 // backend=stage2
 // target=native
 //
-// :3:11: error: expected type '@TypeOf(.{})', found 'struct{comptime comptime_int = 1, comptime comptime_int = 2, comptime comptime_int = 3}'
+// :3:11: error: expected type '@TypeOf(.{})', found 'struct { comptime comptime_int = 1, comptime comptime_int = 2, comptime comptime_int = 3 }'
diff --git a/zig/test/cases/compile_errors/wrong_types_given_to_export.zig b/zig/test/cases/compile_errors/wrong_types_given_to_export.zig
index 5fe7b6906b..daf03044f8 100644
--- a/zig/test/cases/compile_errors/wrong_types_given_to_export.zig
+++ b/zig/test/cases/compile_errors/wrong_types_given_to_export.zig
@@ -1,4 +1,4 @@
-fn entry() callconv(.C) void {}
+fn entry() callconv(.c) void {}
 comptime {
     @export(&entry, .{ .name = "entry", .linkage = @as(u32, 1234) });
 }
diff --git a/zig/test/cases/compile_log.0.zig b/zig/test/cases/compile_log.0.zig
deleted file mode 100644
index 07b7c71551..0000000000
--- a/zig/test/cases/compile_log.0.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-export fn _start() noreturn {
-    const b = true;
-    var f: u32 = 1;
-    @compileLog(b, 20, f, x);
-    @compileLog(1000);
-    var bruh: usize = true;
-    _ = .{ &f, &bruh };
-    unreachable;
-}
-export fn other() void {
-    @compileLog(1234);
-}
-fn x() void {}
-
-// error
-//
-// :6:23: error: expected type 'usize', found 'bool'
-//
-// Compile Log Output:
-// @as(bool, true), @as(comptime_int, 20), @as(u32, [runtime value]), @as(fn () void, (function 'x'))
-// @as(comptime_int, 1000)
-// @as(comptime_int, 1234)
diff --git a/zig/test/cases/compile_log.1.zig b/zig/test/cases/compile_log.1.zig
deleted file mode 100644
index fa3e93bfbf..0000000000
--- a/zig/test/cases/compile_log.1.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-export fn _start() noreturn {
-    const b = true;
-    var f: u32 = 1;
-    _ = &f;
-    @compileLog(b, 20, f, x);
-    @compileLog(1000);
-    unreachable;
-}
-export fn other() void {
-    @compileLog(1234);
-}
-fn x() void {}
-
-// error
-//
-// :9:5: error: found compile log statement
-// :4:5: note: also here
-//
-// Compile Log Output:
-// @as(bool, true), @as(comptime_int, 20), @as(u32, [runtime value]), @as(fn () void, (function 'x'))
-// @as(comptime_int, 1000)
diff --git a/zig/test/cases/comptime_var.0.zig b/zig/test/cases/comptime_var.0.zig
deleted file mode 100644
index 7044e0fb2a..0000000000
--- a/zig/test/cases/comptime_var.0.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn main() void {
-    var a: u32 = 0;
-    _ = &a;
-    comptime var b: u32 = 0;
-    if (a == 0) b = 3;
-}
-
-// error
-// output_mode=Exe
-// target=x86_64-macos,x86_64-linux
-// link_libc=true
-//
-// :5:19: error: store to comptime variable depends on runtime condition
-// :5:11: note: runtime condition here
diff --git a/zig/test/cases/comptime_var.1.zig b/zig/test/cases/comptime_var.1.zig
deleted file mode 100644
index d914ab45b5..0000000000
--- a/zig/test/cases/comptime_var.1.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn main() void {
-    var a: u32 = 0;
-    _ = &a;
-    comptime var b: u32 = 0;
-    switch (a) {
-        0 => {},
-        else => b = 3,
-    }
-}
-
-// error
-//
-// :6:19: error: store to comptime variable depends on runtime condition
-// :4:13: note: runtime condition here
diff --git a/zig/test/cases/comptime_var.2.zig b/zig/test/cases/comptime_var.2.zig
deleted file mode 100644
index 2d717cb802..0000000000
--- a/zig/test/cases/comptime_var.2.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-extern "c" fn write(c_int, usize, usize) usize;
-
-pub fn main() void {
-    comptime var len: u32 = 5;
-    print(len);
-    len += 9;
-    print(len);
-}
-
-fn print(len: usize) void {
-    _ = write(1, @intFromPtr("Hello, World!\n"), len);
-}
-
-// run
-//
-// HelloHello, World!
-//
diff --git a/zig/test/cases/comptime_var.3.zig b/zig/test/cases/comptime_var.3.zig
deleted file mode 100644
index 5d25d6556e..0000000000
--- a/zig/test/cases/comptime_var.3.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    var x: i32 = 1;
-    x += 1;
-    if (x != 1) unreachable;
-}
-pub fn main() void {}
-
-// error
-//
-// :4:17: error: reached unreachable code
diff --git a/zig/test/cases/comptime_var.4.zig b/zig/test/cases/comptime_var.4.zig
deleted file mode 100644
index 74da6ef448..0000000000
--- a/zig/test/cases/comptime_var.4.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    comptime var i: u64 = 0;
-    while (i < 5) : (i += 1) {}
-}
-
-// error
-//
-// :3:24: error: cannot store to comptime variable in non-inline loop
-// :3:5: note: non-inline loop here
diff --git a/zig/test/cases/comptime_var.5.zig b/zig/test/cases/comptime_var.5.zig
deleted file mode 100644
index bd3d878fa7..0000000000
--- a/zig/test/cases/comptime_var.5.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-pub fn main() void {
-    var a: u32 = 0;
-    _ = &a;
-    if (a == 0) {
-        comptime var b: u32 = 0;
-        b = 1;
-    }
-}
-comptime {
-    var x: i32 = 1;
-    x += 1;
-    if (x != 2) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/comptime_var.6.zig b/zig/test/cases/comptime_var.6.zig
deleted file mode 100644
index d4e96106bb..0000000000
--- a/zig/test/cases/comptime_var.6.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-extern "c" fn write(c_int, usize, usize) usize;
-
-pub fn main() void {
-    comptime var i: u64 = 2;
-    inline while (i < 6) : (i += 1) {
-        print(i);
-    }
-}
-fn print(len: usize) void {
-    _ = write(1, @intFromPtr("Hello"), len);
-}
-
-// run
-//
-// HeHelHellHello
diff --git a/zig/test/cases/conditional_branches.0.zig b/zig/test/cases/conditional_branches.0.zig
deleted file mode 100644
index d1fce95b2c..0000000000
--- a/zig/test/cases/conditional_branches.0.zig
+++ /dev/null
@@ -1,23 +0,0 @@
-extern "c" fn write(c_int, usize, usize) usize;
-
-pub fn main() void {
-    foo(123);
-}
-
-fn foo(x: u64) void {
-    if (x > 42) {
-        print();
-    }
-}
-
-fn print() void {
-    const str = "Hello, World!\n";
-    _ = write(1, @intFromPtr(str.ptr), ptr.len);
-}
-
-// run
-// target=x86_64-linux,x86_64-macos
-// link_libc=true
-//
-// Hello, World!
-//
diff --git a/zig/test/cases/conditional_branches.1.zig b/zig/test/cases/conditional_branches.1.zig
deleted file mode 100644
index f402cd3bd4..0000000000
--- a/zig/test/cases/conditional_branches.1.zig
+++ /dev/null
@@ -1,25 +0,0 @@
-extern "c" fn write(c_int, usize, usize) usize;
-
-pub fn main() void {
-    foo(true);
-}
-
-fn foo(x: bool) void {
-    if (x) {
-        print();
-        print();
-    } else {
-        print();
-    }
-}
-
-fn print() void {
-    const str = "Hello, World!\n";
-    _ = write(1, @intFromPtr(str.ptr), ptr.len);
-}
-
-// run
-//
-// Hello, World!
-// Hello, World!
-//
diff --git a/zig/test/cases/conditions.0.zig b/zig/test/cases/conditions.0.zig
deleted file mode 100644
index 1167ea85a4..0000000000
--- a/zig/test/cases/conditions.0.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    if (i > @as(u8, 4)) {
-        i += 10;
-    }
-    return i - 15;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/zig/test/cases/conditions.1.zig b/zig/test/cases/conditions.1.zig
deleted file mode 100644
index f9f03808b9..0000000000
--- a/zig/test/cases/conditions.1.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    if (i < @as(u8, 4)) {
-        i += 10;
-    } else {
-        i = 2;
-    }
-    return i - 2;
-}
-
-// run
-//
diff --git a/zig/test/cases/conditions.2.zig b/zig/test/cases/conditions.2.zig
deleted file mode 100644
index a80ead9ea5..0000000000
--- a/zig/test/cases/conditions.2.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 5;
-    if (i < @as(u8, 4)) {
-        i += 10;
-    } else if (i == @as(u8, 5)) {
-        i = 20;
-    }
-    return i - 20;
-}
-
-// run
-//
diff --git a/zig/test/cases/conditions.3.zig b/zig/test/cases/conditions.3.zig
deleted file mode 100644
index bd016a47f3..0000000000
--- a/zig/test/cases/conditions.3.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 11;
-    if (i < @as(u8, 4)) {
-        i += 10;
-    } else {
-        if (i > @as(u8, 10)) {
-            i += 20;
-        } else {
-            i = 20;
-        }
-    }
-    return i - 31;
-}
-
-// run
-//
diff --git a/zig/test/cases/conditions.4.zig b/zig/test/cases/conditions.4.zig
deleted file mode 100644
index e1bd9ce0f7..0000000000
--- a/zig/test/cases/conditions.4.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    assert(foo(true) != @as(i32, 30));
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-fn foo(ok: bool) i32 {
-    const x = if (ok) @as(i32, 20) else @as(i32, 10);
-    return x;
-}
-
-// run
-//
diff --git a/zig/test/cases/conditions.5.zig b/zig/test/cases/conditions.5.zig
deleted file mode 100644
index 9b2dfdb58e..0000000000
--- a/zig/test/cases/conditions.5.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-pub fn main() void {
-    assert(foo(false) == @as(i32, 20));
-    assert(foo(true) == @as(i32, 30));
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-fn foo(ok: bool) i32 {
-    const val: i32 = blk: {
-        var x: i32 = 1;
-        _ = &x;
-        if (!ok) break :blk x + @as(i32, 9);
-        break :blk x + @as(i32, 19);
-    };
-    return val + 10;
-}
-
-// run
-//
diff --git a/zig/test/cases/double_ampersand.0.zig b/zig/test/cases/double_ampersand.0.zig
deleted file mode 100644
index b14c30ecb0..0000000000
--- a/zig/test/cases/double_ampersand.0.zig
+++ /dev/null
@@ -1,6 +0,0 @@
-pub const a = if (true && false) 1 else 2;
-
-// error
-// output_mode=Exe
-//
-// :1:24: error: ambiguous use of '&&'; use 'and' for logical AND, or change whitespace to ' & &' for bitwise AND
diff --git a/zig/test/cases/double_ampersand.1.zig b/zig/test/cases/double_ampersand.1.zig
deleted file mode 100644
index cd5bba02fd..0000000000
--- a/zig/test/cases/double_ampersand.1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const a = true;
-    const b = false;
-    _ = a & &b;
-}
-
-// error
-//
-// :4:11: error: incompatible types: 'bool' and '*const bool'
-// :4:9: note: type 'bool' here
-// :4:13: note: type '*const bool' here
diff --git a/zig/test/cases/double_ampersand.2.zig b/zig/test/cases/double_ampersand.2.zig
deleted file mode 100644
index c6f461d661..0000000000
--- a/zig/test/cases/double_ampersand.2.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub fn main() void {
-    const b: u8 = 1;
-    _ = &&b;
-}
-
-// run
-//
diff --git a/zig/test/cases/enum_values.0.zig b/zig/test/cases/enum_values.0.zig
deleted file mode 100644
index 3e4ee60925..0000000000
--- a/zig/test/cases/enum_values.0.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const Number = enum { One, Two, Three };
-
-pub fn main() void {
-    var number1 = Number.One;
-    var number2: Number = .Two;
-    if (false) {
-        &number1;
-        &number2;
-    }
-    const number3: Number = @enumFromInt(2);
-    if (@intFromEnum(number3) != 2) {
-        unreachable;
-    }
-    return;
-}
-
-// run
-//
diff --git a/zig/test/cases/enum_values.1.zig b/zig/test/cases/enum_values.1.zig
deleted file mode 100644
index 7679a87361..0000000000
--- a/zig/test/cases/enum_values.1.zig
+++ /dev/null
@@ -1,25 +0,0 @@
-const Number = enum { One, Two, Three };
-
-pub fn main() void {
-    var number1 = Number.One;
-    _ = &number1;
-    var number2: Number = .Two;
-    _ = &number2;
-    const number3: Number = @enumFromInt(2);
-    assert(number1 != number2);
-    assert(number2 != number3);
-    assert(@intFromEnum(number1) == 0);
-    assert(@intFromEnum(number2) == 1);
-    assert(@intFromEnum(number3) == 2);
-    var x: Number = .Two;
-    _ = &x;
-    assert(number2 == x);
-
-    return;
-}
-fn assert(val: bool) void {
-    if (!val) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/error_unions.0.zig b/zig/test/cases/error_unions.0.zig
deleted file mode 100644
index 89646e4681..0000000000
--- a/zig/test/cases/error_unions.0.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-pub fn main() void {
-    var e1 = error.Foo;
-    var e2 = error.Bar;
-    _ = .{ &e1, &e2 };
-    assert(e1 != e2);
-    assert(e1 == error.Foo);
-    assert(e2 == error.Bar);
-}
-
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/zig/test/cases/error_unions.1.zig b/zig/test/cases/error_unions.1.zig
deleted file mode 100644
index 792bc88412..0000000000
--- a/zig/test/cases/error_unions.1.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() u8 {
-    var e: anyerror!u8 = 5;
-    _ = &e;
-    const i = e catch 10;
-    return i - 5;
-}
-
-// run
-//
diff --git a/zig/test/cases/error_unions.2.zig b/zig/test/cases/error_unions.2.zig
deleted file mode 100644
index cc61263aa7..0000000000
--- a/zig/test/cases/error_unions.2.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() u8 {
-    var e: anyerror!u8 = error.Foo;
-    _ = &e;
-    const i = e catch 10;
-    return i - 10;
-}
-
-// run
-//
diff --git a/zig/test/cases/error_unions.3.zig b/zig/test/cases/error_unions.3.zig
deleted file mode 100644
index 2661e3bc19..0000000000
--- a/zig/test/cases/error_unions.3.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() u8 {
-    var e = foo();
-    _ = &e;
-    const i = e catch 69;
-    return i - 5;
-}
-
-fn foo() anyerror!u8 {
-    return 5;
-}
-
-// run
-//
diff --git a/zig/test/cases/error_unions.4.zig b/zig/test/cases/error_unions.4.zig
deleted file mode 100644
index d6d121e1d6..0000000000
--- a/zig/test/cases/error_unions.4.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() u8 {
-    var e = foo();
-    _ = &e;
-    const i = e catch 69;
-    return i - 69;
-}
-
-fn foo() anyerror!u8 {
-    return error.Bruh;
-}
-
-// run
-//
diff --git a/zig/test/cases/error_unions.5.zig b/zig/test/cases/error_unions.5.zig
deleted file mode 100644
index 0204cef926..0000000000
--- a/zig/test/cases/error_unions.5.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() u8 {
-    var e = foo();
-    _ = &e;
-    const i = e catch 42;
-    return i - 42;
-}
-
-fn foo() anyerror!u8 {
-    return error.Dab;
-}
-
-// run
-//
diff --git a/zig/test/cases/errors.0.zig b/zig/test/cases/errors.0.zig
deleted file mode 100644
index f61ebc42b7..0000000000
--- a/zig/test/cases/errors.0.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const std = @import("std");
-
-pub fn main() void {
-    foo() catch print();
-}
-
-fn foo() anyerror!void {}
-
-fn print() void {
-    _ = std.posix.write(1, "Hello, World!\n") catch {};
-}
-
-// run
-// target=x86_64-macos
-//
diff --git a/zig/test/cases/errors.1.zig b/zig/test/cases/errors.1.zig
deleted file mode 100644
index ead3262f84..0000000000
--- a/zig/test/cases/errors.1.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const std = @import("std");
-
-pub fn main() void {
-    foo() catch print();
-}
-
-fn foo() anyerror!void {
-    return error.Test;
-}
-
-fn print() void {
-    _ = std.posix.write(1, "Hello, World!\n") catch {};
-}
-
-// run
-//
-// Hello, World!
-//
diff --git a/zig/test/cases/errors.2.zig b/zig/test/cases/errors.2.zig
deleted file mode 100644
index a1b9aef97d..0000000000
--- a/zig/test/cases/errors.2.zig
+++ /dev/null
@@ -1,27 +0,0 @@
-pub fn main() void {
-    foo() catch |err| {
-        assert(err == error.Foo);
-        assert(err != error.Bar);
-        assert(err != error.Baz);
-    };
-    bar() catch |err| {
-        assert(err != error.Foo);
-        assert(err == error.Bar);
-        assert(err != error.Baz);
-    };
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-fn foo() anyerror!void {
-    return error.Foo;
-}
-
-fn bar() anyerror!void {
-    return error.Bar;
-}
-
-// run
-//
diff --git a/zig/test/cases/errors.3.zig b/zig/test/cases/errors.3.zig
deleted file mode 100644
index 390696fcfc..0000000000
--- a/zig/test/cases/errors.3.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    foo() catch unreachable;
-}
-
-fn foo() anyerror!void {
-    try bar();
-}
-
-fn bar() anyerror!void {}
-
-// run
-//
diff --git a/zig/test/cases/extern_variable_has_no_type.0.zig b/zig/test/cases/extern_variable_has_no_type.0.zig
deleted file mode 100644
index e141551828..0000000000
--- a/zig/test/cases/extern_variable_has_no_type.0.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    const x = foo + foo;
-    _ = x;
-}
-extern var foo: i32;
-
-// error
-//
-// :2:19: error: unable to evaluate comptime expression
-// :2:15: note: operation is runtime due to this operand
diff --git a/zig/test/cases/extern_variable_has_no_type.1.zig b/zig/test/cases/extern_variable_has_no_type.1.zig
deleted file mode 100644
index f5c31244e5..0000000000
--- a/zig/test/cases/extern_variable_has_no_type.1.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-export fn entry() void {
-    _ = foo;
-}
-extern var foo;
-
-// error
-//
-// :4:8: error: unable to infer variable type
diff --git a/zig/test/cases/function_calls.0.zig b/zig/test/cases/function_calls.0.zig
deleted file mode 100644
index eb388bc49f..0000000000
--- a/zig/test/cases/function_calls.0.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    foo();
-    bar();
-}
-fn foo() void {
-    bar();
-    bar();
-}
-fn bar() void {}
-
-// run
-//
diff --git a/zig/test/cases/function_calls.1.zig b/zig/test/cases/function_calls.1.zig
deleted file mode 100644
index 60bc061bca..0000000000
--- a/zig/test/cases/function_calls.1.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() void {
-    bar();
-    foo();
-    foo();
-    bar();
-    foo();
-    bar();
-}
-fn foo() void {
-    bar();
-}
-fn bar() void {}
-
-// run
-//
diff --git a/zig/test/cases/function_calls.2.zig b/zig/test/cases/function_calls.2.zig
deleted file mode 100644
index ce5627378a..0000000000
--- a/zig/test/cases/function_calls.2.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn main() void {
-    bar();
-    foo();
-    return;
-}
-fn foo() void {
-    bar();
-    bar();
-    bar();
-}
-fn bar() void {}
-
-// run
-//
diff --git a/zig/test/cases/function_calls.3.zig b/zig/test/cases/function_calls.3.zig
deleted file mode 100644
index 0316d9042d..0000000000
--- a/zig/test/cases/function_calls.3.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-pub fn main() void {
-    foo(10, 20);
-}
-fn foo(x: u8, y: u8) void {
-    _ = x;
-    _ = y;
-}
-
-// run
-//
diff --git a/zig/test/cases/hello_world_with_updates.0.zig b/zig/test/cases/hello_world_with_updates.0.zig
deleted file mode 100644
index bcd09204d0..0000000000
--- a/zig/test/cases/hello_world_with_updates.0.zig
+++ /dev/null
@@ -1,6 +0,0 @@
-// error
-// output_mode=Exe
-// target=x86_64-linux,x86_64-macos
-// link_libc=true
-//
-// :?:?: error: root struct of file 'tmp' has no member named 'main'
diff --git a/zig/test/cases/hello_world_with_updates.1.zig b/zig/test/cases/hello_world_with_updates.1.zig
deleted file mode 100644
index dcf18bbf87..0000000000
--- a/zig/test/cases/hello_world_with_updates.1.zig
+++ /dev/null
@@ -1,6 +0,0 @@
-pub export fn main() noreturn {}
-
-// error
-//
-// :1:22: error: function declared 'noreturn' implicitly returns
-// :1:32: note: control flow reaches end of body here
diff --git a/zig/test/cases/hello_world_with_updates.2.zig b/zig/test/cases/hello_world_with_updates.2.zig
deleted file mode 100644
index db5564e3a7..0000000000
--- a/zig/test/cases/hello_world_with_updates.2.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-extern "c" fn write(c_int, usize, usize) usize;
-extern "c" fn exit(c_int) noreturn;
-
-pub export fn main() noreturn {
-    print();
-
-    exit(0);
-}
-
-fn print() void {
-    const msg = @intFromPtr("Hello, World!\n");
-    const len = 14;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// Hello, World!
-//
diff --git a/zig/test/cases/hello_world_with_updates.3.zig b/zig/test/cases/hello_world_with_updates.3.zig
deleted file mode 100644
index 8c57d52924..0000000000
--- a/zig/test/cases/hello_world_with_updates.3.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-extern "c" fn write(c_int, usize, usize) usize;
-
-pub fn main() void {
-    print();
-}
-
-fn print() void {
-    const msg = @intFromPtr("Hello, World!\n");
-    const len = 14;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// Hello, World!
-//
diff --git a/zig/test/cases/hello_world_with_updates.4.zig b/zig/test/cases/hello_world_with_updates.4.zig
deleted file mode 100644
index 54641a3ad5..0000000000
--- a/zig/test/cases/hello_world_with_updates.4.zig
+++ /dev/null
@@ -1,22 +0,0 @@
-extern "c" fn write(c_int, usize, usize) usize;
-
-pub fn main() void {
-    print();
-    print();
-    print();
-    print();
-}
-
-fn print() void {
-    const msg = @intFromPtr("Hello, World!\n");
-    const len = 14;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// Hello, World!
-// Hello, World!
-// Hello, World!
-// Hello, World!
-//
diff --git a/zig/test/cases/hello_world_with_updates.5.zig b/zig/test/cases/hello_world_with_updates.5.zig
deleted file mode 100644
index ae57d9b7b6..0000000000
--- a/zig/test/cases/hello_world_with_updates.5.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-extern "c" fn write(c_int, usize, usize) usize;
-
-pub fn main() void {
-    print();
-}
-
-fn print() void {
-    const msg = @intFromPtr("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n");
-    const len = 104;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// What is up? This is a longer message that will force the data to be relocated in virtual address space.
-//
diff --git a/zig/test/cases/hello_world_with_updates.6.zig b/zig/test/cases/hello_world_with_updates.6.zig
deleted file mode 100644
index 76f006992e..0000000000
--- a/zig/test/cases/hello_world_with_updates.6.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-const builtin = @import("builtin");
-
-extern "c" fn write(c_int, usize, usize) usize;
-
-pub fn main() void {
-    print();
-    print();
-}
-
-fn print() void {
-    const msg = @intFromPtr("What is up? This is a longer message that will force the data to be relocated in virtual address space.\n");
-    const len = 104;
-    _ = write(1, msg, len);
-}
-
-// run
-//
-// What is up? This is a longer message that will force the data to be relocated in virtual address space.
-// What is up? This is a longer message that will force the data to be relocated in virtual address space.
-//
diff --git a/zig/test/cases/int_to_ptr.0.zig b/zig/test/cases/int_to_ptr.0.zig
deleted file mode 100644
index 09efb8b1a5..0000000000
--- a/zig/test/cases/int_to_ptr.0.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() void {
-    _ = @as(*u8, @ptrFromInt(0));
-}
-
-// error
-// output_mode=Exe
-//
-// :2:18: error: pointer type '*u8' does not allow address zero
diff --git a/zig/test/cases/int_to_ptr.1.zig b/zig/test/cases/int_to_ptr.1.zig
deleted file mode 100644
index d5aed471e1..0000000000
--- a/zig/test/cases/int_to_ptr.1.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub fn main() void {
-    _ = @as(*u32, @ptrFromInt(2));
-}
-
-// error
-//
-// :2:19: error: pointer type '*u32' requires aligned address
diff --git a/zig/test/cases/locals.0.zig b/zig/test/cases/locals.0.zig
deleted file mode 100644
index 5698a66dcf..0000000000
--- a/zig/test/cases/locals.0.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn main() void {
-    var i: u8 = 5;
-    var y: f32 = 42.0;
-    var x: u8 = 10;
-    if (false) {
-        &y;
-        &x / &i;
-    }
-    if (i != 5) unreachable;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/zig/test/cases/locals.1.zig b/zig/test/cases/locals.1.zig
deleted file mode 100644
index 0d0b63f636..0000000000
--- a/zig/test/cases/locals.1.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-pub fn main() void {
-    var i: u8 = 5;
-    var y: f32 = 42.0;
-    _ = &y;
-    var x: u8 = 10;
-    _ = &x;
-    foo(i, x);
-    i = x;
-    if (i != 10) unreachable;
-}
-fn foo(x: u8, y: u8) void {
-    _ = y;
-    var i: u8 = 10;
-    i = x;
-}
-
-// run
-//
diff --git a/zig/test/cases/lower_unnamed_consts_structs.0.zig b/zig/test/cases/lower_unnamed_consts_structs.0.zig
deleted file mode 100644
index 3123299646..0000000000
--- a/zig/test/cases/lower_unnamed_consts_structs.0.zig
+++ /dev/null
@@ -1,25 +0,0 @@
-const Foo = struct {
-    a: u8,
-    b: u32,
-
-    fn first(self: *Foo) u8 {
-        return self.a;
-    }
-
-    fn second(self: *Foo) u32 {
-        return self.b;
-    }
-};
-
-pub fn main() void {
-    var foo = Foo{ .a = 1, .b = 5 };
-    assert(foo.first() == 1);
-    assert(foo.second() == 5);
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/lower_unnamed_consts_structs.1.zig b/zig/test/cases/lower_unnamed_consts_structs.1.zig
deleted file mode 100644
index 37afdc8a09..0000000000
--- a/zig/test/cases/lower_unnamed_consts_structs.1.zig
+++ /dev/null
@@ -1,35 +0,0 @@
-const Foo = struct {
-    a: u8,
-    b: u32,
-
-    fn first(self: *Foo) u8 {
-        return self.a;
-    }
-
-    fn second(self: *Foo) u32 {
-        return self.b;
-    }
-};
-
-pub fn main() void {
-    var foo = Foo{ .a = 1, .b = 5 };
-    assert(foo.first() == 1);
-    assert(foo.second() == 5);
-
-    foo.a = 10;
-    foo.b = 255;
-
-    assert(foo.first() == 10);
-    assert(foo.second() == 255);
-
-    var foo2 = Foo{ .a = 15, .b = 255 };
-    assert(foo2.first() == 15);
-    assert(foo2.second() == 255);
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/lower_unnamed_consts_structs.2.zig b/zig/test/cases/lower_unnamed_consts_structs.2.zig
deleted file mode 100644
index b437c4a030..0000000000
--- a/zig/test/cases/lower_unnamed_consts_structs.2.zig
+++ /dev/null
@@ -1,25 +0,0 @@
-const Foo = struct {
-    a: u8,
-    b: u32,
-
-    fn first(self: *Foo) u8 {
-        return self.a;
-    }
-
-    fn second(self: *Foo) u32 {
-        return self.b;
-    }
-};
-
-pub fn main() void {
-    var foo2 = Foo{ .a = 15, .b = 255 };
-    assert(foo2.first() == 15);
-    assert(foo2.second() == 255);
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/merge_error_sets.0.zig b/zig/test/cases/merge_error_sets.0.zig
deleted file mode 100644
index f1f3b96883..0000000000
--- a/zig/test/cases/merge_error_sets.0.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-pub fn main() void {
-    const E = error{ A, B, D } || error{ A, B, C };
-    E.A catch {};
-    E.B catch {};
-    E.C catch {};
-    E.D catch {};
-    const E2 = error{ X, Y } || @TypeOf(error.Z);
-    E2.X catch {};
-    E2.Y catch {};
-    E2.Z catch {};
-    assert(anyerror || error{Z} == anyerror);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/merge_error_sets.1.zig b/zig/test/cases/merge_error_sets.1.zig
deleted file mode 100644
index 81c1cad134..0000000000
--- a/zig/test/cases/merge_error_sets.1.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    const z = true || false;
-    _ = z;
-}
-
-// error
-//
-// :2:15: error: expected error set type, found 'bool'
-// :2:20: note: '||' merges error sets; 'or' performs boolean OR
diff --git a/zig/test/cases/multiplying_numbers_at_runtime_and_comptime.0.zig b/zig/test/cases/multiplying_numbers_at_runtime_and_comptime.0.zig
deleted file mode 100644
index f113928982..0000000000
--- a/zig/test/cases/multiplying_numbers_at_runtime_and_comptime.0.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    mul(3, 4);
-}
-
-fn mul(a: u32, b: u32) void {
-    if (a * b != 12) unreachable;
-}
-
-// run
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/zig/test/cases/multiplying_numbers_at_runtime_and_comptime.1.zig b/zig/test/cases/multiplying_numbers_at_runtime_and_comptime.1.zig
deleted file mode 100644
index 1dff884900..0000000000
--- a/zig/test/cases/multiplying_numbers_at_runtime_and_comptime.1.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    if (x - 12 != 0) unreachable;
-}
-
-fn mul(a: u32, b: u32) u32 {
-    return a * b;
-}
-
-const x = mul(3, 4);
-
-// run
-//
diff --git a/zig/test/cases/multiplying_numbers_at_runtime_and_comptime.2.zig b/zig/test/cases/multiplying_numbers_at_runtime_and_comptime.2.zig
deleted file mode 100644
index 8afbc51f53..0000000000
--- a/zig/test/cases/multiplying_numbers_at_runtime_and_comptime.2.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() void {
-    var x: usize = 5;
-    _ = &x;
-    const y = mul(2, 3, x);
-    if (y - 30 != 0) unreachable;
-}
-
-inline fn mul(a: usize, b: usize, c: usize) usize {
-    return a * b * c;
-}
-
-// run
-//
diff --git a/zig/test/cases/only_1_function_and_it_gets_updated.0.zig b/zig/test/cases/only_1_function_and_it_gets_updated.0.zig
deleted file mode 100644
index eada595db8..0000000000
--- a/zig/test/cases/only_1_function_and_it_gets_updated.0.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub export fn _start() noreturn {
-    while (true) {}
-}
-
-// run
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/zig/test/cases/only_1_function_and_it_gets_updated.1.zig b/zig/test/cases/only_1_function_and_it_gets_updated.1.zig
deleted file mode 100644
index 9982ca9ab8..0000000000
--- a/zig/test/cases/only_1_function_and_it_gets_updated.1.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub export fn _start() noreturn {
-    var dummy: u32 = 10;
-    _ = &dummy;
-    while (true) {}
-}
-
-// run
-//
diff --git a/zig/test/cases/optional_payload.0.zig b/zig/test/cases/optional_payload.0.zig
deleted file mode 100644
index 65296875ff..0000000000
--- a/zig/test/cases/optional_payload.0.zig
+++ /dev/null
@@ -1,19 +0,0 @@
-pub fn main() void {
-    var x: u32 = undefined;
-    const maybe_x = byPtr(&x);
-    assert(maybe_x != null);
-    maybe_x.?.* = 123;
-    assert(x == 123);
-}
-
-fn byPtr(x: *u32) ?*u32 {
-    return x;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/zig/test/cases/optional_payload.1.zig b/zig/test/cases/optional_payload.1.zig
deleted file mode 100644
index 2d4dafffb9..0000000000
--- a/zig/test/cases/optional_payload.1.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-pub fn main() void {
-    var x: u32 = undefined;
-    const maybe_x = byPtr(&x);
-    assert(maybe_x == null);
-}
-
-fn byPtr(x: *u32) ?*u32 {
-    _ = x;
-    return null;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/optional_payload.2.zig b/zig/test/cases/optional_payload.2.zig
deleted file mode 100644
index 608310923b..0000000000
--- a/zig/test/cases/optional_payload.2.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-pub fn main() void {
-    var x: u8 = undefined;
-    const maybe_x = byPtr(&x);
-    assert(maybe_x != null);
-    maybe_x.?.* = 255;
-    assert(x == 255);
-}
-
-fn byPtr(x: *u8) ?*u8 {
-    return x;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/optional_payload.3.zig b/zig/test/cases/optional_payload.3.zig
deleted file mode 100644
index b81ec398c7..0000000000
--- a/zig/test/cases/optional_payload.3.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-pub fn main() void {
-    var x: i8 = undefined;
-    const maybe_x = byPtr(&x);
-    assert(maybe_x != null);
-    maybe_x.?.* = -1;
-    assert(x == -1);
-}
-
-fn byPtr(x: *i8) ?*i8 {
-    return x;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/optionals.0.zig b/zig/test/cases/optionals.0.zig
deleted file mode 100644
index 49841ac593..0000000000
--- a/zig/test/cases/optionals.0.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() u8 {
-    var x: ?u8 = 5;
-    _ = &x;
-    var y: u8 = 0;
-    if (x) |val| {
-        y = val;
-    }
-    return y - 5;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/zig/test/cases/optionals.1.zig b/zig/test/cases/optionals.1.zig
deleted file mode 100644
index 4bba10fc36..0000000000
--- a/zig/test/cases/optionals.1.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var x: ?u8 = null;
-    _ = &x;
-    var y: u8 = 0;
-    if (x) |val| {
-        y = val;
-    }
-    return y;
-}
-
-// run
-//
diff --git a/zig/test/cases/optionals.2.zig b/zig/test/cases/optionals.2.zig
deleted file mode 100644
index 0464db3542..0000000000
--- a/zig/test/cases/optionals.2.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-pub fn main() u8 {
-    var x: ?u8 = 5;
-    _ = &x;
-    return x.? - 5;
-}
-
-// run
-//
diff --git a/zig/test/cases/optionals.3.zig b/zig/test/cases/optionals.3.zig
deleted file mode 100644
index 849914fbb5..0000000000
--- a/zig/test/cases/optionals.3.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() u8 {
-    var x: u8 = 5;
-    var y: ?u8 = x;
-    _ = .{ &x, &y };
-    return y.? - 5;
-}
-
-// run
-//
diff --git a/zig/test/cases/optionals.4.zig b/zig/test/cases/optionals.4.zig
deleted file mode 100644
index af3400b322..0000000000
--- a/zig/test/cases/optionals.4.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() u8 {
-    var val: ?u8 = 5;
-    while (val) |*v| {
-        v.* -= 1;
-        if (v.* == 2) {
-            val = null;
-        }
-    }
-    return 0;
-}
-
-// run
-//
diff --git a/zig/test/cases/orelse_at_comptime.0.zig b/zig/test/cases/orelse_at_comptime.0.zig
deleted file mode 100644
index 5397ca3b0a..0000000000
--- a/zig/test/cases/orelse_at_comptime.0.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const i: ?u64 = 0;
-    const result = i orelse 5;
-    assert(result == 0);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/orelse_at_comptime.1.zig b/zig/test/cases/orelse_at_comptime.1.zig
deleted file mode 100644
index 7d4fcd3178..0000000000
--- a/zig/test/cases/orelse_at_comptime.1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const i: ?u64 = null;
-    const result = i orelse 5;
-    assert(result == 5);
-}
-fn assert(b: bool) void {
-    if (!b) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/parameters_and_return_values.0.zig b/zig/test/cases/parameters_and_return_values.0.zig
deleted file mode 100644
index bf07cf2921..0000000000
--- a/zig/test/cases/parameters_and_return_values.0.zig
+++ /dev/null
@@ -1,20 +0,0 @@
-const std = @import("std");
-
-pub fn main() void {
-    print(id(14));
-}
-
-fn id(x: u32) u32 {
-    return x;
-}
-
-fn print(len: u32) void {
-    const str = "Hello, World!\n";
-    _ = std.posix.write(1, str[0..len]) catch {};
-}
-
-// run
-// target=x86_64-macos
-//
-// Hello, World!
-//
diff --git a/zig/test/cases/parameters_and_return_values.1.zig b/zig/test/cases/parameters_and_return_values.1.zig
deleted file mode 100644
index f2bc35d22e..0000000000
--- a/zig/test/cases/parameters_and_return_values.1.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn main() void {
-    assert(add(1, 2, 3, 4, 5, 6) == 21);
-}
-
-fn add(a: u32, b: u32, c: u32, d: u32, e: u32, f: u32) u32 {
-    return a + b + c + d + e + f;
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/pointers.0.zig b/zig/test/cases/pointers.0.zig
deleted file mode 100644
index 958ee5ac88..0000000000
--- a/zig/test/cases/pointers.0.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn main() u8 {
-    var x: u8 = 0;
-
-    foo(&x);
-    return x - 2;
-}
-
-fn foo(x: *u8) void {
-    x.* = 2;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/zig/test/cases/pointers.1.zig b/zig/test/cases/pointers.1.zig
deleted file mode 100644
index b3649cf520..0000000000
--- a/zig/test/cases/pointers.1.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-pub fn main() u8 {
-    var x: u8 = 0;
-
-    foo(&x);
-    bar(&x);
-    return x - 4;
-}
-
-fn foo(x: *u8) void {
-    x.* = 2;
-}
-
-fn bar(x: *u8) void {
-    x.* += 2;
-}
-
-// run
-//
diff --git a/zig/test/cases/redundant_comptime.0.zig b/zig/test/cases/redundant_comptime.0.zig
deleted file mode 100644
index c1ecbf7ace..0000000000
--- a/zig/test/cases/redundant_comptime.0.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-pub fn main() void {
-    var a: comptime u32 = 0;
-}
-
-// error
-//
-// :2:12: error: redundant comptime keyword in already comptime scope
diff --git a/zig/test/cases/redundant_comptime.1.zig b/zig/test/cases/redundant_comptime.1.zig
deleted file mode 100644
index 79226ae8a6..0000000000
--- a/zig/test/cases/redundant_comptime.1.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    comptime {
-        var a: u32 = comptime 0;
-    }
-}
-
-// error
-//
-// :3:22: error: redundant comptime keyword in already comptime scope
diff --git a/zig/test/cases/spilling_registers.0.zig b/zig/test/cases/spilling_registers.0.zig
deleted file mode 100644
index eb580cf5d8..0000000000
--- a/zig/test/cases/spilling_registers.0.zig
+++ /dev/null
@@ -1,38 +0,0 @@
-pub fn main() void {
-    assert(add(3, 4) == 791);
-}
-
-fn add(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        const k = i + j; // 210
-        const l = k + c; // 217
-        const m = l + d; // 227
-        const n = m + e; // 241
-        const o = n + f; // 265
-        const p = o + g; // 303
-        const q = p + h; // 365
-        const r = q + i; // 465
-        const s = r + j; // 575
-        const t = s + k; // 785
-        break :blk t;
-    };
-    const y = x + a; // 788
-    const z = y + a; // 791
-    return z;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-// target=x86_64-linux,x86_64-macos
-//
diff --git a/zig/test/cases/spilling_registers.1.zig b/zig/test/cases/spilling_registers.1.zig
deleted file mode 100644
index f401a5d7b7..0000000000
--- a/zig/test/cases/spilling_registers.1.zig
+++ /dev/null
@@ -1,37 +0,0 @@
-pub fn main() void {
-    assert(addMul(3, 4) == 357747496);
-}
-
-fn addMul(a: u32, b: u32) u32 {
-    const x: u32 = blk: {
-        const c = a + b; // 7
-        const d = a + c; // 10
-        const e = d + b; // 14
-        const f = d + e; // 24
-        const g = e + f; // 38
-        const h = f + g; // 62
-        const i = g + h; // 100
-        const j = i + d; // 110
-        const k = i + j; // 210
-        const l = k + c; // 217
-        const m = l * d; // 2170
-        const n = m + e; // 2184
-        const o = n * f; // 52416
-        const p = o + g; // 52454
-        const q = p * h; // 3252148
-        const r = q + i; // 3252248
-        const s = r * j; // 357747280
-        const t = s + k; // 357747490
-        break :blk t;
-    };
-    const y = x + a; // 357747493
-    const z = y + a; // 357747496
-    return z;
-}
-
-fn assert(ok: bool) void {
-    if (!ok) unreachable;
-}
-
-// run
-//
diff --git a/zig/test/cases/spirv_mergable_pointers.zig b/zig/test/cases/spirv_mergable_pointers.zig
new file mode 100644
index 0000000000..240c485f9d
--- /dev/null
+++ b/zig/test/cases/spirv_mergable_pointers.zig
@@ -0,0 +1,16 @@
+export fn a() void {
+    var x: *addrspace(.global) i32 = undefined;
+    _ = &x;
+    var y: *addrspace(.global) i32 = undefined;
+    _ = &y;
+    var rt_cond = false;
+    _ = &rt_cond;
+
+    var z = if (rt_cond) x else y;
+    _ = &z;
+}
+
+// compile
+// output_mode=Obj
+// backend=stage2
+// target=spirv64-vulkan
diff --git a/zig/test/cases/structs.0.zig b/zig/test/cases/structs.0.zig
deleted file mode 100644
index 306cf73ebf..0000000000
--- a/zig/test/cases/structs.0.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const Example = struct { x: u8 };
-
-pub fn main() u8 {
-    var example: Example = .{ .x = 5 };
-    _ = &example;
-    return example.x - 5;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/zig/test/cases/structs.1.zig b/zig/test/cases/structs.1.zig
deleted file mode 100644
index 8d4250e4a2..0000000000
--- a/zig/test/cases/structs.1.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const Example = struct { x: u8 };
-
-pub fn main() u8 {
-    var example: Example = .{ .x = 5 };
-    example.x = 10;
-    return example.x - 10;
-}
-
-// run
-//
diff --git a/zig/test/cases/structs.2.zig b/zig/test/cases/structs.2.zig
deleted file mode 100644
index 7593284301..0000000000
--- a/zig/test/cases/structs.2.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const Example = struct { x: u8, y: u8 };
-
-pub fn main() u8 {
-    var example: Example = .{ .x = 5, .y = 10 };
-    _ = &example;
-    return example.y + example.x - 15;
-}
-
-// run
-//
diff --git a/zig/test/cases/structs.3.zig b/zig/test/cases/structs.3.zig
deleted file mode 100644
index cfc064d671..0000000000
--- a/zig/test/cases/structs.3.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-const Example = struct { x: u8, y: u8 };
-
-pub fn main() u8 {
-    var example: Example = .{ .x = 5, .y = 10 };
-    var example2: Example = .{ .x = 10, .y = 20 };
-    _ = &example2;
-
-    example = example2;
-    return example.y + example.x - 30;
-}
-
-// run
-//
diff --git a/zig/test/cases/structs.4.zig b/zig/test/cases/structs.4.zig
deleted file mode 100644
index 2d37446c56..0000000000
--- a/zig/test/cases/structs.4.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const Example = struct { x: u8, y: u8 };
-
-pub fn main() u8 {
-    var example: Example = .{ .x = 5, .y = 10 };
-
-    example = .{ .x = 10, .y = 20 };
-    return example.y + example.x - 30;
-}
-
-// run
-//
diff --git a/zig/test/cases/switch.0.zig b/zig/test/cases/switch.0.zig
deleted file mode 100644
index f4a79fa772..0000000000
--- a/zig/test/cases/switch.0.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-pub fn main() u8 {
-    var val: u8 = 1;
-    _ = &val;
-    const a: u8 = switch (val) {
-        0, 1 => 2,
-        2 => 3,
-        3 => 4,
-        else => 5,
-    };
-
-    return a - 2;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/zig/test/cases/switch.1.zig b/zig/test/cases/switch.1.zig
deleted file mode 100644
index d93e1ccb47..0000000000
--- a/zig/test/cases/switch.1.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-pub fn main() u8 {
-    var val: u8 = 2;
-    _ = &val;
-    var a: u8 = switch (val) {
-        0, 1 => 2,
-        2 => 3,
-        3 => 4,
-        else => 5,
-    };
-    _ = &a;
-
-    return a - 3;
-}
-
-// run
-//
diff --git a/zig/test/cases/switch.2.zig b/zig/test/cases/switch.2.zig
deleted file mode 100644
index 1506d822d1..0000000000
--- a/zig/test/cases/switch.2.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-pub fn main() u8 {
-    var val: u8 = 10;
-    _ = &val;
-    const a: u8 = switch (val) {
-        0, 1 => 2,
-        2 => 3,
-        3 => 4,
-        else => 5,
-    };
-
-    return a - 5;
-}
-
-// run
-//
diff --git a/zig/test/cases/switch.3.zig b/zig/test/cases/switch.3.zig
deleted file mode 100644
index 6225dda3ff..0000000000
--- a/zig/test/cases/switch.3.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-const MyEnum = enum { One, Two, Three };
-
-pub fn main() u8 {
-    var val: MyEnum = .Two;
-    _ = &val;
-    const a: u8 = switch (val) {
-        .One => 1,
-        .Two => 2,
-        .Three => 3,
-    };
-
-    return a - 2;
-}
-
-// run
-//
diff --git a/zig/test/cases/translate_c/static empty struct.c b/zig/test/cases/translate_c/static empty struct.c
index 8300b7c673..222fa48707 100644
--- a/zig/test/cases/translate_c/static empty struct.c	
+++ b/zig/test/cases/translate_c/static empty struct.c	
@@ -9,7 +9,7 @@ static inline void foo() {
 // c_frontend=clang
 //
 // pub const struct_empty_struct = extern struct {};
-// pub fn foo() callconv(.C) void {
+// pub fn foo() callconv(.c) void {
 //     const bar = struct {
 //         var static: struct_empty_struct = @import("std").mem.zeroes(struct_empty_struct);
 //     };
diff --git a/zig/test/cases/type_of.0.zig b/zig/test/cases/type_of.0.zig
deleted file mode 100644
index 823572c863..0000000000
--- a/zig/test/cases/type_of.0.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() void {
-    var x: usize = 0;
-    _ = &x;
-    const z = @TypeOf(x, @as(u128, 5));
-    assert(z == u128);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/type_of.1.zig b/zig/test/cases/type_of.1.zig
deleted file mode 100644
index 86d7d87a19..0000000000
--- a/zig/test/cases/type_of.1.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    const z = @TypeOf(true);
-    assert(z == bool);
-}
-
-pub fn assert(ok: bool) void {
-    if (!ok) unreachable; // assertion failure
-}
-
-// run
-//
diff --git a/zig/test/cases/type_of.2.zig b/zig/test/cases/type_of.2.zig
deleted file mode 100644
index cdbc8121fd..0000000000
--- a/zig/test/cases/type_of.2.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    _ = @TypeOf(true, 1);
-}
-
-// error
-//
-// :2:9: error: incompatible types: 'bool' and 'comptime_int'
-// :2:17: note: type 'bool' here
-// :2:23: note: type 'comptime_int' here
diff --git a/zig/test/cases/unused_labels.0.zig b/zig/test/cases/unused_labels.0.zig
deleted file mode 100644
index 9afa5facdd..0000000000
--- a/zig/test/cases/unused_labels.0.zig
+++ /dev/null
@@ -1,8 +0,0 @@
-comptime {
-    foo: {}
-}
-
-// error
-// output_mode=Exe
-//
-// :2:5: error: unused block label
diff --git a/zig/test/cases/unused_labels.1.zig b/zig/test/cases/unused_labels.1.zig
deleted file mode 100644
index c7ff576875..0000000000
--- a/zig/test/cases/unused_labels.1.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-comptime {
-    foo: while (true) {}
-}
-
-// error
-//
-// :2:5: error: unused while loop label
diff --git a/zig/test/cases/unused_labels.2.zig b/zig/test/cases/unused_labels.2.zig
deleted file mode 100644
index babe3c7b0a..0000000000
--- a/zig/test/cases/unused_labels.2.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-comptime {
-    foo: for ("foo") |_| {}
-}
-
-// error
-//
-// :2:5: error: unused for loop label
diff --git a/zig/test/cases/unused_labels.3.zig b/zig/test/cases/unused_labels.3.zig
deleted file mode 100644
index 36c9aa2319..0000000000
--- a/zig/test/cases/unused_labels.3.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-comptime {
-    blk: {
-        blk: {}
-    }
-}
-
-// error
-//
-// :2:11: error: redefinition of label 'blk'
-// :2:5: note: previous definition here
diff --git a/zig/test/cases/variable_shadowing.0.zig b/zig/test/cases/variable_shadowing.0.zig
deleted file mode 100644
index accfda758f..0000000000
--- a/zig/test/cases/variable_shadowing.0.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    var i: u32 = 10;
-    var i: u32 = 10;
-}
-
-// error
-// backend=stage2
-// target=x86_64-linux,x86_64-macos
-//
-// :3:9: error: redeclaration of local variable 'i'
-// :2:9: note: previous declaration here
diff --git a/zig/test/cases/variable_shadowing.1.zig b/zig/test/cases/variable_shadowing.1.zig
deleted file mode 100644
index 2a2945a65f..0000000000
--- a/zig/test/cases/variable_shadowing.1.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-var testing: i64 = 10;
-pub fn main() void {
-    var testing: i64 = 20;
-}
-
-// error
-//
-// :3:9: error: local variable shadows declaration of 'testing'
-// :1:1: note: declared here
diff --git a/zig/test/cases/variable_shadowing.10.zig b/zig/test/cases/variable_shadowing.10.zig
deleted file mode 100644
index 6aa9f5a9bf..0000000000
--- a/zig/test/cases/variable_shadowing.10.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-fn foo() !void {
-    var i: anyerror!usize = 1;
-    _ = i catch |i| return i;
-}
-
-// error
-//
-// :3:18: error: redeclaration of local variable 'i'
-// :2:9: note: previous declaration here
diff --git a/zig/test/cases/variable_shadowing.2.zig b/zig/test/cases/variable_shadowing.2.zig
deleted file mode 100644
index a44372f9b9..0000000000
--- a/zig/test/cases/variable_shadowing.2.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-fn a() type {
-    return struct {
-        pub fn b() void {
-            const c = 6;
-            const c = 69;
-        }
-    };
-}
-
-// error
-//
-// :5:19: error: redeclaration of local constant 'c'
-// :4:19: note: previous declaration here
diff --git a/zig/test/cases/variable_shadowing.3.zig b/zig/test/cases/variable_shadowing.3.zig
deleted file mode 100644
index af16bccc14..0000000000
--- a/zig/test/cases/variable_shadowing.3.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    for ("n", 0..) |_, i| {}
-}
-
-// error
-//
-// :3:24: error: capture 'i' shadows local variable from outer scope
-// :2:9: note: previous declaration here
diff --git a/zig/test/cases/variable_shadowing.4.zig b/zig/test/cases/variable_shadowing.4.zig
deleted file mode 100644
index 3653c2457d..0000000000
--- a/zig/test/cases/variable_shadowing.4.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    for ("n") |i| {}
-}
-
-// error
-//
-// :3:16: error: capture 'i' shadows local variable from outer scope
-// :2:9: note: previous declaration here
diff --git a/zig/test/cases/variable_shadowing.5.zig b/zig/test/cases/variable_shadowing.5.zig
deleted file mode 100644
index 78247e68fe..0000000000
--- a/zig/test/cases/variable_shadowing.5.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    while ("n") |i| {}
-}
-
-// error
-//
-// :3:18: error: capture 'i' shadows local variable from outer scope
-// :2:9: note: previous declaration here
diff --git a/zig/test/cases/variable_shadowing.6.zig b/zig/test/cases/variable_shadowing.6.zig
deleted file mode 100644
index a3ae7bc346..0000000000
--- a/zig/test/cases/variable_shadowing.6.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    while ("n") |bruh| {
-        _ = bruh;
-    } else |i| {}
-}
-
-// error
-//
-// :5:13: error: capture 'i' shadows local variable from outer scope
-// :2:9: note: previous declaration here
diff --git a/zig/test/cases/variable_shadowing.7.zig b/zig/test/cases/variable_shadowing.7.zig
deleted file mode 100644
index e8368699b4..0000000000
--- a/zig/test/cases/variable_shadowing.7.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    if (true) |i| {}
-}
-
-// error
-//
-// :3:16: error: capture 'i' shadows local variable from outer scope
-// :2:9: note: previous declaration here
diff --git a/zig/test/cases/variable_shadowing.8.zig b/zig/test/cases/variable_shadowing.8.zig
deleted file mode 100644
index 1a3f560589..0000000000
--- a/zig/test/cases/variable_shadowing.8.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    if (true) |i| {} else |e| {}
-}
-
-// error
-//
-// :3:16: error: capture 'i' shadows local variable from outer scope
-// :2:9: note: previous declaration here
diff --git a/zig/test/cases/variable_shadowing.9.zig b/zig/test/cases/variable_shadowing.9.zig
deleted file mode 100644
index 28e2b16834..0000000000
--- a/zig/test/cases/variable_shadowing.9.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-pub fn main() void {
-    var i = 0;
-    if (true) |_| {} else |i| {}
-}
-
-// error
-//
-// :3:28: error: capture 'i' shadows local variable from outer scope
-// :2:9: note: previous declaration here
diff --git a/zig/test/cases/while_loops.0.zig b/zig/test/cases/while_loops.0.zig
deleted file mode 100644
index 721b127ff5..0000000000
--- a/zig/test/cases/while_loops.0.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 0;
-    while (i < @as(u8, 5)) {
-        i += 1;
-    }
-
-    return i - 5;
-}
-
-// run
-// target=wasm32-wasi
-//
diff --git a/zig/test/cases/while_loops.1.zig b/zig/test/cases/while_loops.1.zig
deleted file mode 100644
index 283398adbc..0000000000
--- a/zig/test/cases/while_loops.1.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 0;
-    while (i < @as(u8, 10)) {
-        var x: u8 = 1;
-        _ = &x;
-        i += x;
-    }
-    return i - 10;
-}
-
-// run
-//
diff --git a/zig/test/cases/while_loops.2.zig b/zig/test/cases/while_loops.2.zig
deleted file mode 100644
index fa4f9ed26c..0000000000
--- a/zig/test/cases/while_loops.2.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-pub fn main() u8 {
-    var i: u8 = 0;
-    while (i < @as(u8, 10)) {
-        var x: u8 = 1;
-        _ = &x;
-        i += x;
-        if (i == @as(u8, 5)) break;
-    }
-    return i - 5;
-}
-
-// run
-//
diff --git a/zig/test/cases/x86_64-linux/inline_assembly.0.zig b/zig/test/cases/x86_64-linux/inline_assembly.0.zig
deleted file mode 100644
index 8356e05d80..0000000000
--- a/zig/test/cases/x86_64-linux/inline_assembly.0.zig
+++ /dev/null
@@ -1,16 +0,0 @@
-pub fn main() void {
-    const number = 1234;
-    const x = asm volatile ("syscall"
-        : [o] "{rax}" (-> number),
-        : [number] "{rax}" (231),
-          [arg1] "{rdi}" (60),
-        : "rcx", "r11", "memory"
-    );
-    _ = x;
-}
-
-// error
-// output_mode=Exe
-// target=x86_64-linux
-//
-// :4:27: error: expected type 'type', found 'comptime_int'
diff --git a/zig/test/cases/x86_64-linux/inline_assembly.1.zig b/zig/test/cases/x86_64-linux/inline_assembly.1.zig
deleted file mode 100644
index b35014b0f6..0000000000
--- a/zig/test/cases/x86_64-linux/inline_assembly.1.zig
+++ /dev/null
@@ -1,15 +0,0 @@
-const S = struct {
-    comptime {
-        asm volatile (
-            \\zig_moment:
-            \\syscall
-        );
-    }
-};
-pub fn main() void {
-    _ = S;
-}
-
-// error
-//
-// :3:13: error: volatile is meaningless on global assembly
diff --git a/zig/test/cases/x86_64-linux/inline_assembly.2.zig b/zig/test/cases/x86_64-linux/inline_assembly.2.zig
deleted file mode 100644
index 7958d0df71..0000000000
--- a/zig/test/cases/x86_64-linux/inline_assembly.2.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {
-    var bruh: u32 = 1;
-    asm (""
-        :
-        : [bruh] "{rax}" (4),
-        : "memory"
-    );
-}
-
-// error
-//
-// :3:5: error: assembly expression with no output must be marked volatile
diff --git a/zig/test/cases/x86_64-linux/inline_assembly.3.zig b/zig/test/cases/x86_64-linux/inline_assembly.3.zig
deleted file mode 100644
index a6f57e832a..0000000000
--- a/zig/test/cases/x86_64-linux/inline_assembly.3.zig
+++ /dev/null
@@ -1,12 +0,0 @@
-pub fn main() void {}
-comptime {
-    asm (""
-        :
-        : [bruh] "{rax}" (4),
-        : "memory"
-    );
-}
-
-// error
-//
-// :3:5: error: global assembly cannot have inputs, outputs, or clobbers
diff --git a/zig/test/compare_output.zig b/zig/test/compare_output.zig
index b5c65df889..e766641cde 100644
--- a/zig/test/compare_output.zig
+++ b/zig/test/compare_output.zig
@@ -440,7 +440,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
     cases.add("std.log per scope log level override",
         \\const std = @import("std");
         \\
-        \\pub const std_options = .{
+        \\pub const std_options: std.Options = .{
         \\    .log_level = .debug,
         \\    
         \\    .log_scope_levels = &.{
@@ -497,7 +497,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
     cases.add("std.heap.LoggingAllocator logs to std.log",
         \\const std = @import("std");
         \\
-        \\pub const std_options = .{
+        \\pub const std_options: std.Options = .{
         \\    .log_level = .debug,
         \\    .logFn = log,
         \\};
diff --git a/zig/test/incremental/add_decl b/zig/test/incremental/add_decl
index 6b3a0dad84..a2863d6bde 100644
--- a/zig/test/incremental/add_decl
+++ b/zig/test/incremental/add_decl
@@ -1,4 +1,5 @@
-#target=x86_64-linux-selfhosted
+// Disabled on self-hosted due to linker crash
+// #target=x86_64-linux-selfhosted
 #target=x86_64-linux-cbe
 #target=x86_64-windows-cbe
 #update=initial version
diff --git a/zig/test/incremental/change_fn_type b/zig/test/incremental/change_fn_type
new file mode 100644
index 0000000000..892d0dd9b6
--- /dev/null
+++ b/zig/test/incremental/change_fn_type
@@ -0,0 +1,35 @@
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
+#update=initial version
+#file=main.zig
+pub fn main() !void {
+    try foo(123);
+}
+fn foo(x: u8) !void {
+    return std.io.getStdOut().writer().print("{d}\n", .{x});
+}
+const std = @import("std");
+#expect_stdout="123\n"
+
+#update=change function type
+#file=main.zig
+pub fn main() !void {
+    try foo(123);
+}
+fn foo(x: i64) !void {
+    return std.io.getStdOut().writer().print("{d}\n", .{x});
+}
+const std = @import("std");
+#expect_stdout="123\n"
+
+#update=change function argument
+#file=main.zig
+pub fn main() !void {
+    try foo(-42);
+}
+fn foo(x: i64) !void {
+    return std.io.getStdOut().writer().print("{d}\n", .{x});
+}
+const std = @import("std");
+#expect_stdout="-42\n"
diff --git a/zig/test/incremental/change_shift_op b/zig/test/incremental/change_shift_op
new file mode 100644
index 0000000000..bd88a70def
--- /dev/null
+++ b/zig/test/incremental/change_shift_op
@@ -0,0 +1,23 @@
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
+#update=initial version
+#file=main.zig
+pub fn main() !void {
+    try foo(0x1300);
+}
+fn foo(x: u16) !void {
+    try std.io.getStdOut().writer().print("0x{x}\n", .{x << 4});
+}
+const std = @import("std");
+#expect_stdout="0x3000\n"
+#update=change to right shift
+#file=main.zig
+pub fn main() !void {
+    try foo(0x1300);
+}
+fn foo(x: u16) !void {
+    try std.io.getStdOut().writer().print("0x{x}\n", .{x >> 4});
+}
+const std = @import("std");
+#expect_stdout="0x130\n"
diff --git a/zig/test/incremental/change_struct_same_fields b/zig/test/incremental/change_struct_same_fields
new file mode 100644
index 0000000000..f742bab870
--- /dev/null
+++ b/zig/test/incremental/change_struct_same_fields
@@ -0,0 +1,50 @@
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
+#update=initial version
+#file=main.zig
+const S = extern struct { x: u8, y: u8 };
+pub fn main() !void {
+    const val: S = .{ .x = 100, .y = 200 };
+    try foo(&val);
+}
+fn foo(val: *const S) !void {
+    try std.io.getStdOut().writer().print(
+        "{d} {d}\n",
+        .{ val.x, val.y },
+    );
+}
+const std = @import("std");
+#expect_stdout="100 200\n"
+
+#update=change struct layout
+#file=main.zig
+const S = extern struct { x: u32, y: u32 };
+pub fn main() !void {
+    const val: S = .{ .x = 100, .y = 200 };
+    try foo(&val);
+}
+fn foo(val: *const S) !void {
+    try std.io.getStdOut().writer().print(
+        "{d} {d}\n",
+        .{ val.x, val.y },
+    );
+}
+const std = @import("std");
+#expect_stdout="100 200\n"
+
+#update=change values
+#file=main.zig
+const S = extern struct { x: u32, y: u32 };
+pub fn main() !void {
+    const val: S = .{ .x = 1234, .y = 5678 };
+    try foo(&val);
+}
+fn foo(val: *const S) !void {
+    try std.io.getStdOut().writer().print(
+        "{d} {d}\n",
+        .{ val.x, val.y },
+    );
+}
+const std = @import("std");
+#expect_stdout="1234 5678\n"
diff --git a/zig/test/incremental/compile_error_then_log b/zig/test/incremental/compile_error_then_log
new file mode 100644
index 0000000000..00ccef9290
--- /dev/null
+++ b/zig/test/incremental/compile_error_then_log
@@ -0,0 +1,21 @@
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
+#update=initial version with compile error
+#file=main.zig
+comptime {
+    @compileError("this is an error");
+}
+comptime {
+    @compileLog("this is a log");
+}
+#expect_error=ignored
+#update=remove the compile error
+#file=main.zig
+comptime {
+    //@compileError("this is an error");
+}
+comptime {
+    @compileLog("this is a log");
+}
+#expect_error=ignored
diff --git a/zig/test/incremental/fix_astgen_failure b/zig/test/incremental/fix_astgen_failure
new file mode 100644
index 0000000000..b94c9c77ee
--- /dev/null
+++ b/zig/test/incremental/fix_astgen_failure
@@ -0,0 +1,36 @@
+// Disabled on self-hosted due to linker crash
+// #target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
+#update=initial version with error
+#file=main.zig
+pub fn main() !void {
+    try @import("foo.zig").hello();
+}
+#file=foo.zig
+pub fn hello() !void {
+    try std.io.getStdOut().writeAll("Hello, World!\n");
+}
+#expect_error=ignored
+#update=fix the error
+#file=foo.zig
+const std = @import("std");
+pub fn hello() !void {
+    try std.io.getStdOut().writeAll("Hello, World!\n");
+}
+#expect_stdout="Hello, World!\n"
+#update=add new error
+#file=foo.zig
+const std = @import("std");
+pub fn hello() !void {
+    try std.io.getStdOut().writeAll(hello_str);
+}
+#expect_error=ignored
+#update=fix the new error
+#file=foo.zig
+const std = @import("std");
+const hello_str = "Hello, World! Again!\n";
+pub fn hello() !void {
+    try std.io.getStdOut().writeAll(hello_str);
+}
+#expect_stdout="Hello, World! Again!\n"
diff --git a/zig/test/incremental/function_becomes_inline b/zig/test/incremental/function_becomes_inline
new file mode 100644
index 0000000000..b7e604bfac
--- /dev/null
+++ b/zig/test/incremental/function_becomes_inline
@@ -0,0 +1,35 @@
+//#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
+#update=non-inline version
+#file=main.zig
+pub fn main() !void {
+    try foo();
+}
+fn foo() !void {
+    try std.io.getStdOut().writer().writeAll("Hello, World!\n");
+}
+const std = @import("std");
+#expect_stdout="Hello, World!\n"
+
+#update=make function inline
+#file=main.zig
+pub fn main() !void {
+    try foo();
+}
+inline fn foo() !void {
+    try std.io.getStdOut().writer().writeAll("Hello, World!\n");
+}
+const std = @import("std");
+#expect_stdout="Hello, World!\n"
+
+#update=change string
+#file=main.zig
+pub fn main() !void {
+    try foo();
+}
+inline fn foo() !void {
+    try std.io.getStdOut().writer().writeAll("Hello, `inline` World!\n");
+}
+const std = @import("std");
+#expect_stdout="Hello, `inline` World!\n"
diff --git a/zig/test/incremental/recursive_function_becomes_non_recursive b/zig/test/incremental/recursive_function_becomes_non_recursive
new file mode 100644
index 0000000000..7a9eb5d26f
--- /dev/null
+++ b/zig/test/incremental/recursive_function_becomes_non_recursive
@@ -0,0 +1,28 @@
+//#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
+#update=initial version
+#file=main.zig
+pub fn main() !void {
+    try foo(false);
+}
+fn foo(recurse: bool) !void {
+    const stdout = std.io.getStdOut().writer();
+    if (recurse) return foo(true);
+    try stdout.writeAll("non-recursive path\n");
+}
+const std = @import("std");
+#expect_stdout="non-recursive path\n"
+
+#update=eliminate recursion and change argument
+#file=main.zig
+pub fn main() !void {
+    try foo(true);
+}
+fn foo(recurse: bool) !void {
+    const stdout = std.io.getStdOut().writer();
+    if (recurse) return stdout.writeAll("x==1\n");
+    try stdout.writeAll("non-recursive path\n");
+}
+const std = @import("std");
+#expect_stdout="x==1\n"
diff --git a/zig/test/incremental/remove_invalid_union_backing_enum b/zig/test/incremental/remove_invalid_union_backing_enum
new file mode 100644
index 0000000000..ded6304531
--- /dev/null
+++ b/zig/test/incremental/remove_invalid_union_backing_enum
@@ -0,0 +1,30 @@
+#target=x86_64-linux-selfhosted
+#target=x86_64-linux-cbe
+#target=x86_64-windows-cbe
+#update=initial version
+#file=main.zig
+const E = enum { a, b, c };
+const U = union(E) {
+    a: i32,
+    b: f64,
+    c: f64,
+    d: f64,
+};
+pub fn main() void {
+    const u: U = .{ .a = 123 };
+    _ = u;
+}
+#expect_error=ignored
+#update=remove invalid backing enum
+#file=main.zig
+const U = union {
+    a: i32,
+    b: f64,
+    c: f64,
+    d: f64,
+};
+pub fn main() void {
+    const u: U = .{ .a = 123 };
+    _ = u;
+}
+#expect_stdout=""
diff --git a/zig/test/link/elf.zig b/zig/test/link/elf.zig
index f6891cf17e..5014d20c98 100644
--- a/zig/test/link/elf.zig
+++ b/zig/test/link/elf.zig
@@ -51,6 +51,7 @@ pub fn testAll(b: *Build, build_opts: BuildOptions) *Step {
         elf_step.dependOn(testEmitRelocatable(b, .{ .target = musl_target }));
         elf_step.dependOn(testRelocatableArchive(b, .{ .target = musl_target }));
         elf_step.dependOn(testRelocatableEhFrame(b, .{ .target = musl_target }));
+        elf_step.dependOn(testRelocatableEhFrameComdatHeavy(b, .{ .target = musl_target }));
         elf_step.dependOn(testRelocatableNoEhFrame(b, .{ .target = musl_target }));
 
         // Exercise linker in ar mode
@@ -2145,6 +2146,7 @@ fn testLdScript(b: *Build, opts: Options) *Step {
     exe.addLibraryPath(dso.getEmittedBinDirectory());
     exe.addRPath(dso.getEmittedBinDirectory());
     exe.linkLibC();
+    exe.allow_so_scripts = true;
 
     const run = addRunArtifact(exe);
     run.expectExitCode(0);
@@ -2164,14 +2166,13 @@ fn testLdScriptPathError(b: *Build, opts: Options) *Step {
     exe.linkSystemLibrary2("a", .{});
     exe.addLibraryPath(scripts.getDirectory());
     exe.linkLibC();
+    exe.allow_so_scripts = true;
 
-    expectLinkErrors(
-        exe,
-        test_step,
-        .{
-            .contains = "error: missing library dependency: GNU ld script '/?/liba.so' requires 'libfoo.so', but file not found",
-        },
-    );
+    // TODO: A future enhancement could make this error message also mention
+    // the file that references the missing library.
+    expectLinkErrors(exe, test_step, .{
+        .stderr_contains = "error: unable to find dynamic system library 'foo' using strategy 'no_fallback'. searched paths:",
+    });
 
     return test_step;
 }
@@ -2203,6 +2204,7 @@ fn testLdScriptAllowUndefinedVersion(b: *Build, opts: Options) *Step {
     });
     exe.linkLibrary(so);
     exe.linkLibC();
+    exe.allow_so_scripts = true;
 
     const run = addRunArtifact(exe);
     run.expectStdErrEqual("3\n");
@@ -2225,6 +2227,7 @@ fn testLdScriptDisallowUndefinedVersion(b: *Build, opts: Options) *Step {
     const ld = b.addWriteFiles().add("add.ld", "VERSION { ADD_1.0 { global: add; sub; local: *; }; }");
     so.setLinkerScript(ld);
     so.linker_allow_undefined_version = false;
+    so.allow_so_scripts = true;
 
     expectLinkErrors(
         so,
@@ -2721,38 +2724,49 @@ fn testRelocatableArchive(b: *Build, opts: Options) *Step {
 fn testRelocatableEhFrame(b: *Build, opts: Options) *Step {
     const test_step = addTestStep(b, "relocatable-eh-frame", opts);
 
+    const obj1 = addObject(b, opts, .{
+        .name = "obj1",
+        .cpp_source_bytes =
+        \\#include <stdexcept>
+        \\int try_me() {
+        \\  throw std::runtime_error("Oh no!");
+        \\}
+        ,
+    });
+    obj1.linkLibCpp();
+    const obj2 = addObject(b, opts, .{
+        .name = "obj2",
+        .cpp_source_bytes =
+        \\extern int try_me();
+        \\int try_again() {
+        \\  return try_me();
+        \\}
+        ,
+    });
+    obj2.linkLibCpp();
+    const obj3 = addObject(b, opts, .{ .name = "obj3", .cpp_source_bytes = 
+    \\#include <iostream>
+    \\#include <stdexcept>
+    \\extern int try_again();
+    \\int main() {
+    \\  try {
+    \\    try_again();
+    \\  } catch (const std::exception &e) {
+    \\    std::cout << "exception=" << e.what();
+    \\  }
+    \\  return 0;
+    \\}
+    });
+    obj3.linkLibCpp();
+
     {
-        const obj = addObject(b, opts, .{
-            .name = "obj1",
-            .cpp_source_bytes =
-            \\#include <stdexcept>
-            \\int try_me() {
-            \\  throw std::runtime_error("Oh no!");
-            \\}
-            ,
-        });
-        addCppSourceBytes(obj,
-            \\extern int try_me();
-            \\int try_again() {
-            \\  return try_me();
-            \\}
-        , &.{});
+        const obj = addObject(b, opts, .{ .name = "obj" });
+        obj.addObject(obj1);
+        obj.addObject(obj2);
         obj.linkLibCpp();
 
         const exe = addExecutable(b, opts, .{ .name = "test1" });
-        addCppSourceBytes(exe,
-            \\#include <iostream>
-            \\#include <stdexcept>
-            \\extern int try_again();
-            \\int main() {
-            \\  try {
-            \\    try_again();
-            \\  } catch (const std::exception &e) {
-            \\    std::cout << "exception=" << e.what();
-            \\  }
-            \\  return 0;
-            \\}
-        , &.{});
+        exe.addObject(obj3);
         exe.addObject(obj);
         exe.linkLibCpp();
 
@@ -2760,40 +2774,15 @@ fn testRelocatableEhFrame(b: *Build, opts: Options) *Step {
         run.expectStdOutEqual("exception=Oh no!");
         test_step.dependOn(&run.step);
     }
-
     {
-        // Let's make the object file COMDAT group heavy!
-        const obj = addObject(b, opts, .{
-            .name = "obj2",
-            .cpp_source_bytes =
-            \\#include <stdexcept>
-            \\int try_me() {
-            \\  throw std::runtime_error("Oh no!");
-            \\}
-            ,
-        });
-        addCppSourceBytes(obj,
-            \\extern int try_me();
-            \\int try_again() {
-            \\  return try_me();
-            \\}
-        , &.{});
-        addCppSourceBytes(obj,
-            \\#include <iostream>
-            \\#include <stdexcept>
-            \\extern int try_again();
-            \\int main() {
-            \\  try {
-            \\    try_again();
-            \\  } catch (const std::exception &e) {
-            \\    std::cout << "exception=" << e.what();
-            \\  }
-            \\  return 0;
-            \\}
-        , &.{});
+        // Flipping the order should not influence the end result.
+        const obj = addObject(b, opts, .{ .name = "obj" });
+        obj.addObject(obj2);
+        obj.addObject(obj1);
         obj.linkLibCpp();
 
         const exe = addExecutable(b, opts, .{ .name = "test2" });
+        exe.addObject(obj3);
         exe.addObject(obj);
         exe.linkLibCpp();
 
@@ -2805,6 +2794,64 @@ fn testRelocatableEhFrame(b: *Build, opts: Options) *Step {
     return test_step;
 }
 
+fn testRelocatableEhFrameComdatHeavy(b: *Build, opts: Options) *Step {
+    const test_step = addTestStep(b, "relocatable-eh-frame-comdat-heavy", opts);
+
+    const obj1 = addObject(b, opts, .{
+        .name = "obj1",
+        .cpp_source_bytes =
+        \\#include <stdexcept>
+        \\int try_me() {
+        \\  throw std::runtime_error("Oh no!");
+        \\}
+        ,
+    });
+    obj1.linkLibCpp();
+    const obj2 = addObject(b, opts, .{
+        .name = "obj2",
+        .cpp_source_bytes =
+        \\extern int try_me();
+        \\int try_again() {
+        \\  return try_me();
+        \\}
+        ,
+    });
+    obj2.linkLibCpp();
+    const obj3 = addObject(b, opts, .{
+        .name = "obj3",
+        .cpp_source_bytes =
+        \\#include <iostream>
+        \\#include <stdexcept>
+        \\extern int try_again();
+        \\int main() {
+        \\  try {
+        \\    try_again();
+        \\  } catch (const std::exception &e) {
+        \\    std::cout << "exception=" << e.what();
+        \\  }
+        \\  return 0;
+        \\}
+        ,
+    });
+    obj3.linkLibCpp();
+
+    const obj = addObject(b, opts, .{ .name = "obj" });
+    obj.addObject(obj1);
+    obj.addObject(obj2);
+    obj.addObject(obj3);
+    obj.linkLibCpp();
+
+    const exe = addExecutable(b, opts, .{ .name = "test2" });
+    exe.addObject(obj);
+    exe.linkLibCpp();
+
+    const run = addRunArtifact(exe);
+    run.expectStdOutEqual("exception=Oh no!");
+    test_step.dependOn(&run.step);
+
+    return test_step;
+}
+
 // Adapted from https://github.com/rui314/mold/blob/main/test/elf/relocatable-mergeable-sections.sh
 fn testRelocatableMergeStrings(b: *Build, opts: Options) *Step {
     const test_step = addTestStep(b, "relocatable-merge-strings", opts);
@@ -3730,11 +3777,15 @@ fn testTlsOffsetAlignment(b: *Build, opts: Options) *Step {
         \\#include <pthread.h>
         \\#include <dlfcn.h>
         \\#include <assert.h>
+        \\#include <stdio.h>
         \\void *(*verify)(void *);
         \\
         \\int main() {
         \\  void *handle = dlopen("liba.so", RTLD_NOW);
-        \\  assert(handle);
+        \\  if (!handle) {
+        \\    fprintf(stderr, "dlopen failed: %s\n", dlerror());
+        \\    return 1;
+        \\  }
         \\  *(void**)(&verify) = dlsym(handle, "verify");
         \\  assert(verify);
         \\
@@ -3907,16 +3958,8 @@ fn testUnknownFileTypeError(b: *Build, opts: Options) *Step {
     exe.linkLibrary(dylib);
     exe.linkLibC();
 
-    // TODO: improve the test harness to be able to selectively match lines in error output
-    // while avoiding jankiness
-    // expectLinkErrors(exe, test_step, .{ .exact = &.{
-    //     "error: invalid token in LD script: '\\x00\\x00\\x00\\x0c\\x00\\x00\\x00/usr/lib/dyld\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x0d' (0:989)",
-    //     "note: while parsing /?/liba.dylib",
-    //     "error: unexpected error: parsing input file failed with error InvalidLdScript",
-    //     "note: while parsing /?/liba.dylib",
-    // } });
     expectLinkErrors(exe, test_step, .{
-        .starts_with = "error: invalid token in LD script: '\\x00\\x00\\x00\\x0c\\x00\\x00\\x00/usr/lib/dyld\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x0d' (",
+        .contains = "error: failed to parse shared library: BadMagic",
     });
 
     return test_step;
diff --git a/zig/test/llvm_targets.zig b/zig/test/llvm_targets.zig
index 687903d278..42c5428e06 100644
--- a/zig/test/llvm_targets.zig
+++ b/zig/test/llvm_targets.zig
@@ -108,10 +108,6 @@ const targets = [_]std.Target.Query{
     .{ .cpu_arch = .lanai, .os_tag = .freestanding, .abi = .none },
 
     .{ .cpu_arch = .loongarch32, .os_tag = .freestanding, .abi = .none },
-    .{ .cpu_arch = .loongarch32, .os_tag = .linux, .abi = .gnu },
-    .{ .cpu_arch = .loongarch32, .os_tag = .linux, .abi = .gnuf32 },
-    .{ .cpu_arch = .loongarch32, .os_tag = .linux, .abi = .gnusf },
-    .{ .cpu_arch = .loongarch32, .os_tag = .linux, .abi = .musl },
     .{ .cpu_arch = .loongarch32, .os_tag = .linux, .abi = .none },
     .{ .cpu_arch = .loongarch32, .os_tag = .uefi, .abi = .none },
 
@@ -164,7 +160,8 @@ const targets = [_]std.Target.Query{
     .{ .cpu_arch = .mips64, .os_tag = .freestanding, .abi = .none },
     .{ .cpu_arch = .mips64, .os_tag = .linux, .abi = .gnuabi64 },
     .{ .cpu_arch = .mips64, .os_tag = .linux, .abi = .gnuabin32 },
-    .{ .cpu_arch = .mips64, .os_tag = .linux, .abi = .musl },
+    .{ .cpu_arch = .mips64, .os_tag = .linux, .abi = .muslabi64 },
+    .{ .cpu_arch = .mips64, .os_tag = .linux, .abi = .muslabin32 },
     .{ .cpu_arch = .mips64, .os_tag = .linux, .abi = .none },
     .{ .cpu_arch = .mips64, .os_tag = .netbsd, .abi = .none },
     .{ .cpu_arch = .mips64, .os_tag = .openbsd, .abi = .none },
@@ -173,7 +170,8 @@ const targets = [_]std.Target.Query{
     .{ .cpu_arch = .mips64el, .os_tag = .freestanding, .abi = .none },
     .{ .cpu_arch = .mips64el, .os_tag = .linux, .abi = .gnuabi64 },
     .{ .cpu_arch = .mips64el, .os_tag = .linux, .abi = .gnuabin32 },
-    .{ .cpu_arch = .mips64el, .os_tag = .linux, .abi = .musl },
+    .{ .cpu_arch = .mips64el, .os_tag = .linux, .abi = .muslabi64 },
+    .{ .cpu_arch = .mips64el, .os_tag = .linux, .abi = .muslabin32 },
     .{ .cpu_arch = .mips64el, .os_tag = .linux, .abi = .none },
     .{ .cpu_arch = .mips64el, .os_tag = .netbsd, .abi = .none },
     .{ .cpu_arch = .mips64el, .os_tag = .openbsd, .abi = .none },
@@ -227,7 +225,6 @@ const targets = [_]std.Target.Query{
     .{ .cpu_arch = .riscv32, .os_tag = .linux, .abi = .gnu },
     .{ .cpu_arch = .riscv32, .os_tag = .linux, .abi = .musl },
     .{ .cpu_arch = .riscv32, .os_tag = .linux, .abi = .none },
-    .{ .cpu_arch = .riscv32, .os_tag = .linux, .abi = .ohos },
     .{ .cpu_arch = .riscv32, .os_tag = .rtems, .abi = .none },
     .{ .cpu_arch = .riscv32, .os_tag = .uefi, .abi = .none },
 
@@ -240,7 +237,6 @@ const targets = [_]std.Target.Query{
     .{ .cpu_arch = .riscv64, .os_tag = .linux, .abi = .gnu },
     .{ .cpu_arch = .riscv64, .os_tag = .linux, .abi = .musl },
     .{ .cpu_arch = .riscv64, .os_tag = .linux, .abi = .none },
-    .{ .cpu_arch = .riscv64, .os_tag = .linux, .abi = .ohos },
     .{ .cpu_arch = .riscv64, .os_tag = .netbsd, .abi = .none },
     .{ .cpu_arch = .riscv64, .os_tag = .openbsd, .abi = .none },
     .{ .cpu_arch = .riscv64, .os_tag = .rtems, .abi = .none },
@@ -253,10 +249,12 @@ const targets = [_]std.Target.Query{
     .{ .cpu_arch = .s390x, .os_tag = .zos, .abi = .none },
 
     .{ .cpu_arch = .sparc, .os_tag = .freestanding, .abi = .none },
+    .{ .cpu_arch = .sparc, .os_tag = .illumos, .abi = .none },
     .{ .cpu_arch = .sparc, .os_tag = .linux, .abi = .gnu },
     .{ .cpu_arch = .sparc, .os_tag = .linux, .abi = .none },
     .{ .cpu_arch = .sparc, .os_tag = .netbsd, .abi = .none },
     .{ .cpu_arch = .sparc, .os_tag = .rtems, .abi = .none },
+    .{ .cpu_arch = .sparc, .os_tag = .solaris, .abi = .none },
 
     .{ .cpu_arch = .sparc64, .os_tag = .freebsd, .abi = .none },
     .{ .cpu_arch = .sparc64, .os_tag = .freestanding, .abi = .none },
@@ -273,6 +271,9 @@ const targets = [_]std.Target.Query{
     .{ .cpu_arch = .thumb, .os_tag = .freebsd, .abi = .eabihf },
     .{ .cpu_arch = .thumb, .os_tag = .freestanding, .abi = .eabi },
     .{ .cpu_arch = .thumb, .os_tag = .freestanding, .abi = .eabihf },
+    .{ .cpu_arch = .thumb, .os_tag = .haiku, .abi = .eabi },
+    .{ .cpu_arch = .thumb, .os_tag = .haiku, .abi = .eabihf },
+    .{ .cpu_arch = .thumb, .os_tag = .linux, .abi = .androideabi },
     .{ .cpu_arch = .thumb, .os_tag = .linux, .abi = .eabi },
     .{ .cpu_arch = .thumb, .os_tag = .linux, .abi = .eabihf },
     .{ .cpu_arch = .thumb, .os_tag = .linux, .abi = .musleabi },
@@ -318,14 +319,15 @@ const targets = [_]std.Target.Query{
     .{ .cpu_arch = .x86, .os_tag = .freestanding, .abi = .none },
     .{ .cpu_arch = .x86, .os_tag = .haiku, .abi = .none },
     .{ .cpu_arch = .x86, .os_tag = .hurd, .abi = .gnu },
+    .{ .cpu_arch = .x86, .os_tag = .illumos, .abi = .none },
     .{ .cpu_arch = .x86, .os_tag = .linux, .abi = .android },
     .{ .cpu_arch = .x86, .os_tag = .linux, .abi = .gnu },
     .{ .cpu_arch = .x86, .os_tag = .linux, .abi = .musl },
     .{ .cpu_arch = .x86, .os_tag = .linux, .abi = .none },
-    .{ .cpu_arch = .x86, .os_tag = .linux, .abi = .ohos },
     .{ .cpu_arch = .x86, .os_tag = .netbsd, .abi = .none },
     .{ .cpu_arch = .x86, .os_tag = .openbsd, .abi = .none },
     .{ .cpu_arch = .x86, .os_tag = .rtems, .abi = .none },
+    .{ .cpu_arch = .x86, .os_tag = .solaris, .abi = .none },
     .{ .cpu_arch = .x86, .os_tag = .uefi, .abi = .none },
     .{ .cpu_arch = .x86, .os_tag = .windows, .abi = .gnu },
     .{ .cpu_arch = .x86, .os_tag = .windows, .abi = .itanium },
diff --git a/zig/test/src/Cases.zig b/zig/test/src/Cases.zig
index 0e88bdd133..9314b5677b 100644
--- a/zig/test/src/Cases.zig
+++ b/zig/test/src/Cases.zig
@@ -467,7 +467,7 @@ fn addFromDirInner(
             const target = resolved_target.result;
             for (backends) |backend| {
                 if (backend == .stage2 and
-                    target.cpu.arch != .wasm32 and target.cpu.arch != .x86_64)
+                    target.cpu.arch != .wasm32 and target.cpu.arch != .x86_64 and target.cpu.arch != .spirv64)
                 {
                     // Other backends don't support new liveness format
                     continue;
diff --git a/zig/test/src/Debugger.zig b/zig/test/src/Debugger.zig
index 913c9b632c..91eaa385ba 100644
--- a/zig/test/src/Debugger.zig
+++ b/zig/test/src/Debugger.zig
@@ -1532,18 +1532,18 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
     ,
         &.{
             \\(lldb) frame variable --show-types -- list0 list0.len list0.capacity list0[0] list0[1] list0[2] list0.0 list0.1 list0.2
-            \\(std.multi_array_list.MultiArrayList(main.Elem0)) list0 = len=3 capacity=8 {
-            \\  (root.main.Elem0) [0] = {
+            \\(std.multi_array_list.MultiArrayList(struct { u32, u8, u16 })) list0 = len=3 capacity=8 {
+            \\  (std.struct { u32, u8, u16 }) [0] = {
             \\    (u32) .@"0" = 1
             \\    (u8) .@"1" = 2
             \\    (u16) .@"2" = 3
             \\  }
-            \\  (root.main.Elem0) [1] = {
+            \\  (std.struct { u32, u8, u16 }) [1] = {
             \\    (u32) .@"0" = 4
             \\    (u8) .@"1" = 5
             \\    (u16) .@"2" = 6
             \\  }
-            \\  (root.main.Elem0) [2] = {
+            \\  (std.struct { u32, u8, u16 }) [2] = {
             \\    (u32) .@"0" = 7
             \\    (u8) .@"1" = 8
             \\    (u16) .@"2" = 9
@@ -1551,17 +1551,17 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
             \\}
             \\(usize) list0.len = 3
             \\(usize) list0.capacity = 8
-            \\(root.main.Elem0) list0[0] = {
+            \\(std.struct { u32, u8, u16 }) list0[0] = {
             \\  (u32) .@"0" = 1
             \\  (u8) .@"1" = 2
             \\  (u16) .@"2" = 3
             \\}
-            \\(root.main.Elem0) list0[1] = {
+            \\(std.struct { u32, u8, u16 }) list0[1] = {
             \\  (u32) .@"0" = 4
             \\  (u8) .@"1" = 5
             \\  (u16) .@"2" = 6
             \\}
-            \\(root.main.Elem0) list0[2] = {
+            \\(std.struct { u32, u8, u16 }) list0[2] = {
             \\  (u32) .@"0" = 7
             \\  (u8) .@"1" = 8
             \\  (u16) .@"2" = 9
@@ -1582,18 +1582,18 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
             \\  (u16) [2] = 9
             \\}
             \\(lldb) frame variable --show-types -- slice0 slice0.len slice0.capacity slice0[0] slice0[1] slice0[2] slice0.0 slice0.1 slice0.2
-            \\(std.multi_array_list.MultiArrayList(main.Elem0).Slice) slice0 = len=3 capacity=8 {
-            \\  (root.main.Elem0) [0] = {
+            \\(std.multi_array_list.MultiArrayList(struct { u32, u8, u16 }).Slice) slice0 = len=3 capacity=8 {
+            \\  (std.struct { u32, u8, u16 }) [0] = {
             \\    (u32) .@"0" = 1
             \\    (u8) .@"1" = 2
             \\    (u16) .@"2" = 3
             \\  }
-            \\  (root.main.Elem0) [1] = {
+            \\  (std.struct { u32, u8, u16 }) [1] = {
             \\    (u32) .@"0" = 4
             \\    (u8) .@"1" = 5
             \\    (u16) .@"2" = 6
             \\  }
-            \\  (root.main.Elem0) [2] = {
+            \\  (std.struct { u32, u8, u16 }) [2] = {
             \\    (u32) .@"0" = 7
             \\    (u8) .@"1" = 8
             \\    (u16) .@"2" = 9
@@ -1601,17 +1601,17 @@ pub fn addTestsForTarget(db: *Debugger, target: Target) void {
             \\}
             \\(usize) slice0.len = 3
             \\(usize) slice0.capacity = 8
-            \\(root.main.Elem0) slice0[0] = {
+            \\(std.struct { u32, u8, u16 }) slice0[0] = {
             \\  (u32) .@"0" = 1
             \\  (u8) .@"1" = 2
             \\  (u16) .@"2" = 3
             \\}
-            \\(root.main.Elem0) slice0[1] = {
+            \\(std.struct { u32, u8, u16 }) slice0[1] = {
             \\  (u32) .@"0" = 4
             \\  (u8) .@"1" = 5
             \\  (u16) .@"2" = 6
             \\}
-            \\(root.main.Elem0) slice0[2] = {
+            \\(std.struct { u32, u8, u16 }) slice0[2] = {
             \\  (u32) .@"0" = 7
             \\  (u8) .@"1" = 8
             \\  (u16) .@"2" = 9
diff --git a/zig/test/standalone/c_compiler/build.zig b/zig/test/standalone/c_compiler/build.zig
index d4fcde1198..5328d6e01d 100644
--- a/zig/test/standalone/c_compiler/build.zig
+++ b/zig/test/standalone/c_compiler/build.zig
@@ -5,11 +5,6 @@ pub fn build(b: *std.Build) void {
     const test_step = b.step("test", "Test it");
     b.default_step = test_step;
 
-    if (builtin.os.tag == .windows) {
-        // https://github.com/ziglang/zig/issues/16965
-        return;
-    }
-
     add(b, test_step, "test_c_Debug", "test_cpp_Debug", .Debug);
     add(b, test_step, "test_c_ReleaseFast", "test_cpp_ReleaseFast", .ReleaseFast);
     add(b, test_step, "test_c_ReleaseSmall", "test_cpp_ReleaseSmall", .ReleaseSmall);
diff --git a/zig/test/standalone/coff_dwarf/build.zig b/zig/test/standalone/coff_dwarf/build.zig
index 26a8a87da8..bb9879d089 100644
--- a/zig/test/standalone/coff_dwarf/build.zig
+++ b/zig/test/standalone/coff_dwarf/build.zig
@@ -12,11 +12,6 @@ pub fn build(b: *std.Build) void {
     else
         b.resolveTargetQuery(.{ .os_tag = .windows });
 
-    if (builtin.cpu.arch == .aarch64) {
-        // https://github.com/ziglang/zig/issues/18427
-        return;
-    }
-
     const exe = b.addExecutable(.{
         .name = "main",
         .root_source_file = b.path("main.zig"),
diff --git a/zig/test/standalone/extern/build.zig b/zig/test/standalone/extern/build.zig
index a378735b66..ff8701bf40 100644
--- a/zig/test/standalone/extern/build.zig
+++ b/zig/test/standalone/extern/build.zig
@@ -1,6 +1,9 @@
 const std = @import("std");
 
 pub fn build(b: *std.Build) void {
+    const test_step = b.step("test", "Test it");
+    b.default_step = test_step;
+
     const optimize: std.builtin.OptimizeMode = .Debug;
 
     const obj = b.addObject(.{
@@ -9,12 +12,20 @@ pub fn build(b: *std.Build) void {
         .target = b.graph.host,
         .optimize = optimize,
     });
-    const main = b.addTest(.{
+    const shared = b.addSharedLibrary(.{
+        .name = "shared",
+        .target = b.graph.host,
+        .optimize = optimize,
+        .link_libc = true,
+    });
+    if (b.graph.host.result.abi == .msvc) shared.defineCMacro("API", "__declspec(dllexport)");
+    shared.addCSourceFile(.{ .file = b.path("shared.c"), .flags = &.{} });
+    const test_exe = b.addTest(.{
         .root_source_file = b.path("main.zig"),
         .optimize = optimize,
     });
-    main.addObject(obj);
+    test_exe.addObject(obj);
+    test_exe.linkLibrary(shared);
 
-    const test_step = b.step("test", "Test it");
-    test_step.dependOn(&main.step);
+    test_step.dependOn(&b.addRunArtifact(test_exe).step);
 }
diff --git a/zig/test/standalone/extern/main.zig b/zig/test/standalone/extern/main.zig
index 3f5168f841..d27c40bd80 100644
--- a/zig/test/standalone/extern/main.zig
+++ b/zig/test/standalone/extern/main.zig
@@ -1,4 +1,5 @@
 const assert = @import("std").debug.assert;
+const testing = @import("std").testing;
 
 const updateHidden = @extern(*const fn (u32) callconv(.C) void, .{ .name = "updateHidden" });
 const getHidden = @extern(*const fn () callconv(.C) u32, .{ .name = "getHidden" });
@@ -8,14 +9,18 @@ const T = extern struct { x: u32 };
 test {
     const mut_val_ptr = @extern(*f64, .{ .name = "mut_val" });
     const const_val_ptr = @extern(*const T, .{ .name = "const_val" });
+    const shared_val_ptr = @extern(*c_int, .{ .name = "shared_val", .is_dll_import = true });
 
     assert(getHidden() == 0);
     updateHidden(123);
     assert(getHidden() == 123);
-
     assert(mut_val_ptr.* == 1.23);
     mut_val_ptr.* = 10.0;
     assert(mut_val_ptr.* == 10.0);
 
     assert(const_val_ptr.x == 42);
+
+    assert(shared_val_ptr.* == 1234);
+    shared_val_ptr.* = 1235;
+    assert(shared_val_ptr.* == 1235);
 }
diff --git a/zig/test/standalone/extern/shared.c b/zig/test/standalone/extern/shared.c
new file mode 100644
index 0000000000..845963c848
--- /dev/null
+++ b/zig/test/standalone/extern/shared.c
@@ -0,0 +1,5 @@
+#ifndef API
+#define API
+#endif
+
+API int shared_val = 1234;
diff --git a/zig/test/standalone/load_dynamic_library/build.zig b/zig/test/standalone/load_dynamic_library/build.zig
index 1fe7d6141f..f484d2a6e6 100644
--- a/zig/test/standalone/load_dynamic_library/build.zig
+++ b/zig/test/standalone/load_dynamic_library/build.zig
@@ -10,11 +10,6 @@ pub fn build(b: *std.Build) void {
 
     if (builtin.os.tag == .wasi) return;
 
-    if (builtin.os.tag == .windows) {
-        // https://github.com/ziglang/zig/issues/16960
-        return;
-    }
-
     const lib = b.addSharedLibrary(.{
         .name = "add",
         .root_source_file = b.path("add.zig"),
diff --git a/zig/test/standalone/shared_library/build.zig b/zig/test/standalone/shared_library/build.zig
index c23efd0e92..28c1bdb13e 100644
--- a/zig/test/standalone/shared_library/build.zig
+++ b/zig/test/standalone/shared_library/build.zig
@@ -4,11 +4,6 @@ pub fn build(b: *std.Build) void {
     const test_step = b.step("test", "Test it");
     b.default_step = test_step;
 
-    if (@import("builtin").os.tag == .windows) {
-        // https://github.com/ziglang/zig/issues/16959
-        return;
-    }
-
     const optimize: std.builtin.OptimizeMode = .Debug;
     const target = b.graph.host;
     const lib = b.addSharedLibrary(.{
diff --git a/zig/test/standalone/sigpipe/breakpipe.zig b/zig/test/standalone/sigpipe/breakpipe.zig
index 044a2bc65f..293a6839a1 100644
--- a/zig/test/standalone/sigpipe/breakpipe.zig
+++ b/zig/test/standalone/sigpipe/breakpipe.zig
@@ -1,7 +1,7 @@
 const std = @import("std");
 const build_options = @import("build_options");
 
-pub const std_options = .{
+pub const std_options: std.Options = .{
     .keep_sigpipe = build_options.keep_sigpipe,
 };
 
diff --git a/zig/test/standalone/simple/issue_7030.zig b/zig/test/standalone/simple/issue_7030.zig
index d4732c331c..eb7aa65387 100644
--- a/zig/test/standalone/simple/issue_7030.zig
+++ b/zig/test/standalone/simple/issue_7030.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub const std_options = .{
+pub const std_options: std.Options = .{
     .logFn = log,
 };
 
diff --git a/zig/test/tests.zig b/zig/test/tests.zig
index 017f9478a9..d7b36f522b 100644
--- a/zig/test/tests.zig
+++ b/zig/test/tests.zig
@@ -28,6 +28,7 @@ const TestTarget = struct {
     use_lld: ?bool = null,
     pic: ?bool = null,
     strip: ?bool = null,
+    skip_modules: []const []const u8 = &.{},
 
     // This is intended for targets that are known to be slow to compile. These are acceptable to
     // run in CI, but should not be run on developer machines by default. As an example, at the time
@@ -337,6 +338,70 @@ const test_targets = blk: {
             .link_libc = true,
         },
 
+        .{
+            .target = .{
+                .cpu_arch = .thumb,
+                .os_tag = .linux,
+                .abi = .eabi,
+            },
+        },
+        .{
+            .target = .{
+                .cpu_arch = .thumb,
+                .os_tag = .linux,
+                .abi = .eabihf,
+            },
+        },
+        .{
+            .target = .{
+                .cpu_arch = .thumb,
+                .os_tag = .linux,
+                .abi = .musleabi,
+            },
+            .link_libc = true,
+            .skip_modules = &.{"std"},
+        },
+        .{
+            .target = .{
+                .cpu_arch = .thumb,
+                .os_tag = .linux,
+                .abi = .musleabihf,
+            },
+            .link_libc = true,
+            .skip_modules = &.{"std"},
+        },
+        // Calls are normally lowered to branch instructions that only support +/- 16 MB range when
+        // targeting Thumb. This is not sufficient for the std test binary linked statically with
+        // musl, so use long calls to avoid out-of-range relocations.
+        .{
+            .target = std.Target.Query.parse(.{
+                .arch_os_abi = "thumb-linux-musleabi",
+                .cpu_features = "baseline+long_calls",
+            }) catch @panic("OOM"),
+            .link_libc = true,
+            .pic = false, // Long calls don't work with PIC.
+            .skip_modules = &.{
+                "behavior",
+                "c-import",
+                "compiler-rt",
+                "universal-libc",
+            },
+        },
+        .{
+            .target = std.Target.Query.parse(.{
+                .arch_os_abi = "thumb-linux-musleabihf",
+                .cpu_features = "baseline+long_calls",
+            }) catch @panic("OOM"),
+            .link_libc = true,
+            .pic = false, // Long calls don't work with PIC.
+            .skip_modules = &.{
+                "behavior",
+                "c-import",
+                "compiler-rt",
+                "universal-libc",
+            },
+        },
+
         .{
             .target = .{
                 .cpu_arch = .mips,
@@ -454,7 +519,7 @@ const test_targets = blk: {
             .target = .{
                 .cpu_arch = .mips64,
                 .os_tag = .linux,
-                .abi = .musl,
+                .abi = .muslabi64,
             },
             .link_libc = true,
         },
@@ -478,7 +543,7 @@ const test_targets = blk: {
             .target = .{
                 .cpu_arch = .mips64el,
                 .os_tag = .linux,
-                .abi = .musl,
+                .abi = .muslabi64,
             },
             .link_libc = true,
         },
@@ -579,6 +644,20 @@ const test_targets = blk: {
             .link_libc = true,
         },
 
+        .{
+            .target = std.Target.Query.parse(.{
+                .arch_os_abi = "riscv32-linux-none",
+                .cpu_features = "baseline-d-f",
+            }) catch unreachable,
+        },
+        .{
+            .target = std.Target.Query.parse(.{
+                .arch_os_abi = "riscv32-linux-musl",
+                .cpu_features = "baseline-d-f",
+            }) catch unreachable,
+            .link_libc = true,
+        },
+
         .{
             .target = .{
                 .cpu_arch = .riscv32,
@@ -603,6 +682,20 @@ const test_targets = blk: {
             .link_libc = true,
         },
 
+        .{
+            .target = std.Target.Query.parse(.{
+                .arch_os_abi = "riscv64-linux-none",
+                .cpu_features = "baseline-d-f",
+            }) catch unreachable,
+        },
+        .{
+            .target = std.Target.Query.parse(.{
+                .arch_os_abi = "riscv64-linux-musl",
+                .cpu_features = "baseline-d-f",
+            }) catch unreachable,
+            .link_libc = true,
+        },
+
         .{
             .target = .{
                 .cpu_arch = .riscv64,
@@ -631,7 +724,7 @@ const test_targets = blk: {
             .target = std.Target.Query.parse(.{
                 .arch_os_abi = "riscv64-linux-musl",
                 .cpu_features = "baseline+v+zbb",
-            }) catch @panic("OOM"),
+            }) catch unreachable,
             .use_llvm = false,
             .use_lld = false,
         },
@@ -1197,7 +1290,13 @@ const ModuleTestOptions = struct {
 pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step {
     const step = b.step(b.fmt("test-{s}", .{options.name}), options.desc);
 
-    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;
+            }
+        }
+
         if (!options.test_slow_targets and test_target.slow_backend) continue;
 
         if (options.skip_non_native and !test_target.target.isNative())
diff --git a/zig/test/translate_c.zig b/zig/test/translate_c.zig
index 431289f9e3..933983c364 100644
--- a/zig/test/translate_c.zig
+++ b/zig/test/translate_c.zig
@@ -484,11 +484,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    fnptr_attr_ty qux;
         \\};
     , &[_][]const u8{
-        \\pub const fnptr_ty = ?*const fn () callconv(.C) void;
-        \\pub const fnptr_attr_ty = ?*const fn () callconv(.C) void;
+        \\pub const fnptr_ty = ?*const fn () callconv(.c) void;
+        \\pub const fnptr_attr_ty = ?*const fn () callconv(.c) void;
         \\pub const struct_foo = extern struct {
-        \\    foo: ?*const fn () callconv(.C) void = @import("std").mem.zeroes(?*const fn () callconv(.C) void),
-        \\    bar: ?*const fn () callconv(.C) void = @import("std").mem.zeroes(?*const fn () callconv(.C) void),
+        \\    foo: ?*const fn () callconv(.c) void = @import("std").mem.zeroes(?*const fn () callconv(.c) void),
+        \\    bar: ?*const fn () callconv(.c) void = @import("std").mem.zeroes(?*const fn () callconv(.c) void),
         \\    baz: fnptr_ty = @import("std").mem.zeroes(fnptr_ty),
         \\    qux: fnptr_attr_ty = @import("std").mem.zeroes(fnptr_attr_ty),
         \\};
@@ -735,7 +735,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\static void bar(void) {}
     , &[_][]const u8{
         \\pub export fn foo() void {}
-        \\pub fn bar() callconv(.C) void {}
+        \\pub fn bar() callconv(.c) void {}
     });
 
     cases.add("typedef void",
@@ -769,7 +769,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\pub export fn bar() void {
         \\    var func_ptr: ?*anyopaque = @as(?*anyopaque, @ptrCast(&foo));
         \\    _ = &func_ptr;
-        \\    var typed_func_ptr: ?*const fn () callconv(.C) void = @as(?*const fn () callconv(.C) void, @ptrFromInt(@as(c_ulong, @intCast(@intFromPtr(func_ptr)))));
+        \\    var typed_func_ptr: ?*const fn () callconv(.c) void = @as(?*const fn () callconv(.c) void, @ptrFromInt(@as(c_ulong, @intCast(@intFromPtr(func_ptr)))));
         \\    _ = &typed_func_ptr;
         \\}
     });
@@ -839,9 +839,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    lws_callback_function *callback_http;
         \\};
     , &[_][]const u8{
-        \\pub const lws_callback_function = fn () callconv(.C) void;
+        \\pub const lws_callback_function = fn () callconv(.c) void;
         \\pub const struct_Foo = extern struct {
-        \\    func: ?*const fn () callconv(.C) void = @import("std").mem.zeroes(?*const fn () callconv(.C) void),
+        \\    func: ?*const fn () callconv(.c) void = @import("std").mem.zeroes(?*const fn () callconv(.c) void),
         \\    callback_http: ?*const lws_callback_function = @import("std").mem.zeroes(?*const lws_callback_function),
         \\};
     });
@@ -867,7 +867,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\};
     , &[_][]const u8{
         \\pub const struct_Foo = extern struct {
-        \\    derp: ?*const fn ([*c]struct_Foo) callconv(.C) void = @import("std").mem.zeroes(?*const fn ([*c]struct_Foo) callconv(.C) void),
+        \\    derp: ?*const fn ([*c]struct_Foo) callconv(.c) void = @import("std").mem.zeroes(?*const fn ([*c]struct_Foo) callconv(.c) void),
         \\};
         ,
         \\pub const Foo = struct_Foo;
@@ -1111,7 +1111,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
     cases.add("__cdecl doesn't mess up function pointers",
         \\void foo(void (__cdecl *fn_ptr)(void));
     , &[_][]const u8{
-        \\pub extern fn foo(fn_ptr: ?*const fn () callconv(.C) void) void;
+        \\pub extern fn foo(fn_ptr: ?*const fn () callconv(.c) void) void;
     });
 
     cases.add("void cast",
@@ -1477,8 +1477,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\typedef void (*fn0)();
         \\typedef void (*fn1)(char);
     , &[_][]const u8{
-        \\pub const fn0 = ?*const fn (...) callconv(.C) void;
-        \\pub const fn1 = ?*const fn (u8) callconv(.C) void;
+        \\pub const fn0 = ?*const fn (...) callconv(.c) void;
+        \\pub const fn1 = ?*const fn (u8) callconv(.c) void;
     });
 
     cases.addWithTarget("Calling convention", .{
@@ -1492,11 +1492,11 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\void __attribute__((cdecl)) foo4(float *a);
         \\void __attribute__((thiscall)) foo5(float *a);
     , &[_][]const u8{
-        \\pub extern fn foo1(a: [*c]f32) callconv(.Fastcall) void;
-        \\pub extern fn foo2(a: [*c]f32) callconv(.Stdcall) void;
-        \\pub extern fn foo3(a: [*c]f32) callconv(.Vectorcall) void;
+        \\pub extern fn foo1(a: [*c]f32) callconv(.{ .x86_fastcall = .{} }) void;
+        \\pub extern fn foo2(a: [*c]f32) callconv(.{ .x86_stdcall = .{} }) void;
+        \\pub extern fn foo3(a: [*c]f32) callconv(.{ .x86_vectorcall = .{} }) void;
         \\pub extern fn foo4(a: [*c]f32) void;
-        \\pub extern fn foo5(a: [*c]f32) callconv(.Thiscall) void;
+        \\pub extern fn foo5(a: [*c]f32) callconv(.{ .x86_thiscall = .{} }) void;
     });
 
     cases.addWithTarget("Calling convention", std.Target.Query.parse(.{
@@ -1506,8 +1506,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\void __attribute__((pcs("aapcs"))) foo1(float *a);
         \\void __attribute__((pcs("aapcs-vfp"))) foo2(float *a);
     , &[_][]const u8{
-        \\pub extern fn foo1(a: [*c]f32) callconv(.AAPCS) void;
-        \\pub extern fn foo2(a: [*c]f32) callconv(.AAPCSVFP) void;
+        \\pub extern fn foo1(a: [*c]f32) callconv(.{ .arm_aapcs = .{} }) void;
+        \\pub extern fn foo2(a: [*c]f32) callconv(.{ .arm_aapcs_vfp = .{} }) void;
     });
 
     cases.addWithTarget("Calling convention", std.Target.Query.parse(.{
@@ -1516,7 +1516,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
     }) catch unreachable,
         \\void __attribute__((aarch64_vector_pcs)) foo1(float *a);
     , &[_][]const u8{
-        \\pub extern fn foo1(a: [*c]f32) callconv(.Vectorcall) void;
+        \\pub extern fn foo1(a: [*c]f32) callconv(.{ .aarch64_vfabi = .{} }) void;
     });
 
     cases.add("Parameterless function prototypes",
@@ -1533,8 +1533,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\pub export fn b() void {}
         \\pub extern fn c(...) void;
         \\pub extern fn d() void;
-        \\pub fn e() callconv(.C) void {}
-        \\pub fn f() callconv(.C) void {}
+        \\pub fn e() callconv(.c) void {}
+        \\pub fn f() callconv(.c) void {}
         \\pub extern fn g() void;
         \\pub extern fn h() void;
     });
@@ -1555,7 +1555,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    char *arr1[10] ={0};
         \\}
     , &[_][]const u8{
-        \\pub fn foo() callconv(.C) void {
+        \\pub fn foo() callconv(.c) void {
         \\    var arr: [10]u8 = [1]u8{
         \\        1,
         \\    } ++ [1]u8{0} ** 9;
@@ -1686,13 +1686,13 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\extern char (*fn_ptr2)(int, float);
         \\#define bar fn_ptr2
     , &[_][]const u8{
-        \\pub extern var fn_ptr: ?*const fn () callconv(.C) void;
+        \\pub extern var fn_ptr: ?*const fn () callconv(.c) void;
         ,
         \\pub inline fn foo() void {
         \\    return fn_ptr.?();
         \\}
         ,
-        \\pub extern var fn_ptr2: ?*const fn (c_int, f32) callconv(.C) u8;
+        \\pub extern var fn_ptr2: ?*const fn (c_int, f32) callconv(.c) u8;
         ,
         \\pub inline fn bar(arg_1: c_int, arg_2: f32) u8 {
         \\    return fn_ptr2.?(arg_1, arg_2);
@@ -1714,8 +1714,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\#define glClearPFN PFNGLCLEARPROC
     , &[_][]const u8{
         \\pub const GLbitfield = c_uint;
-        \\pub const PFNGLCLEARPROC = ?*const fn (GLbitfield) callconv(.C) void;
-        \\pub const OpenGLProc = ?*const fn () callconv(.C) void;
+        \\pub const PFNGLCLEARPROC = ?*const fn (GLbitfield) callconv(.c) void;
+        \\pub const OpenGLProc = ?*const fn () callconv(.c) void;
         \\const struct_unnamed_1 = extern struct {
         \\    Clear: PFNGLCLEARPROC = @import("std").mem.zeroes(PFNGLCLEARPROC),
         \\};
@@ -2691,9 +2691,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    return 0;
         \\}
         \\pub export fn bar() void {
-        \\    var f: ?*const fn () callconv(.C) void = &foo;
+        \\    var f: ?*const fn () callconv(.c) void = &foo;
         \\    _ = &f;
-        \\    var b: ?*const fn () callconv(.C) c_int = &baz;
+        \\    var b: ?*const fn () callconv(.c) c_int = &baz;
         \\    _ = &b;
         \\    f.?();
         \\    f.?();
@@ -3048,8 +3048,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\    baz();
         \\}
     , &[_][]const u8{
-        \\pub fn bar() callconv(.C) void {}
-        \\pub export fn foo(arg_baz: ?*const fn () callconv(.C) [*c]c_int) void {
+        \\pub fn bar() callconv(.c) void {}
+        \\pub export fn foo(arg_baz: ?*const fn () callconv(.c) [*c]c_int) void {
         \\    var baz = arg_baz;
         \\    _ = &baz;
         \\    bar();
@@ -3112,7 +3112,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\        do {} while (0);
         \\}
     , &[_][]const u8{
-        \\pub fn foo() callconv(.C) void {
+        \\pub fn foo() callconv(.c) void {
         \\    if (true) while (true) {
         \\        if (!false) break;
         \\    };
@@ -3212,10 +3212,10 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\void c(void) {}
         \\static void foo() {}
     , &[_][]const u8{
-        \\pub fn a() callconv(.C) void {}
-        \\pub fn b() callconv(.C) void {}
+        \\pub fn a() callconv(.c) void {}
+        \\pub fn b() callconv(.c) void {}
         \\pub export fn c() void {}
-        \\pub fn foo() callconv(.C) void {}
+        \\pub fn foo() callconv(.c) void {}
     });
 
     cases.add("casting away const and volatile",
diff --git a/zig/tools/generate_linux_syscalls.zig b/zig/tools/generate_linux_syscalls.zig
index df1b5127df..38726e6501 100644
--- a/zig/tools/generate_linux_syscalls.zig
+++ b/zig/tools/generate_linux_syscalls.zig
@@ -162,6 +162,22 @@ const arch_infos = [_]ArchInfo{
             .additional_enum = null,
         },
     },
+    .{
+        .table = .{
+            .name = "x32",
+            .enum_name = "X32",
+            .file_path = "arch/x86/entry/syscalls/syscall_64.tbl",
+            .process_file = &processTableBasedArch,
+            .filters = .{
+                .abiCheckParams = .{ .abi = "64", .flow = .@"continue" },
+                .fixedName = &fixedName,
+                .isReservedNameOld = null,
+            },
+            .header = null,
+            .extra_values = null,
+            .additional_enum = null,
+        },
+    },
     .{
         .table = .{
             .name = "arm",
diff --git a/zig/tools/migrate_langref.zig b/zig/tools/migrate_langref.zig
index 50a9a294c0..29108c3501 100644
--- a/zig/tools/migrate_langref.zig
+++ b/zig/tools/migrate_langref.zig
@@ -374,7 +374,7 @@ fn walk(arena: Allocator, tokenizer: *Tokenizer, out_dir: std.fs.Dir, w: anytype
                             );
                         }
                         _ = try eatToken(tokenizer, .bracket_close);
-                    } else unreachable; // TODO issue #707
+                    };
 
                     const basename = try std.fmt.allocPrint(arena, "{s}.zig", .{name});
 
diff --git a/zig/tools/process_headers.zig b/zig/tools/process_headers.zig
index 970c383886..ccd4e1ae96 100644
--- a/zig/tools/process_headers.zig
+++ b/zig/tools/process_headers.zig
@@ -19,273 +19,65 @@ const Blake3 = std.crypto.hash.Blake3;
 
 const LibCTarget = struct {
     name: []const u8,
-    arch: MultiArch,
-    abi: MultiAbi,
-};
-
-const MultiArch = union(enum) {
-    aarch64,
-    arm,
-    mips,
-    mips64,
-    powerpc64,
-    specific: Arch,
-
-    fn eql(a: MultiArch, b: MultiArch) bool {
-        if (@intFromEnum(a) != @intFromEnum(b))
-            return false;
-        if (a != .specific)
-            return true;
-        return a.specific == b.specific;
-    }
-};
-
-const MultiAbi = union(enum) {
-    musl,
-    specific: Abi,
-
-    fn eql(a: MultiAbi, b: MultiAbi) bool {
-        if (@intFromEnum(a) != @intFromEnum(b))
-            return false;
-        if (std.meta.Tag(MultiAbi)(a) != .specific)
-            return true;
-        return a.specific == b.specific;
-    }
+    arch: Arch,
+    abi: Abi,
 };
 
 const glibc_targets = [_]LibCTarget{
-    LibCTarget{
-        .name = "aarch64_be-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.aarch64_be },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "aarch64-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.aarch64 },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "armeb-linux-gnueabi",
-        .arch = MultiArch{ .specific = Arch.armeb },
-        .abi = MultiAbi{ .specific = Abi.gnueabi },
-    },
-    LibCTarget{
-        .name = "armeb-linux-gnueabihf",
-        .arch = MultiArch{ .specific = Arch.armeb },
-        .abi = MultiAbi{ .specific = Abi.gnueabihf },
-    },
-    LibCTarget{
-        .name = "arm-linux-gnueabi",
-        .arch = MultiArch{ .specific = Arch.arm },
-        .abi = MultiAbi{ .specific = Abi.gnueabi },
-    },
-    LibCTarget{
-        .name = "arm-linux-gnueabihf",
-        .arch = MultiArch{ .specific = Arch.arm },
-        .abi = MultiAbi{ .specific = Abi.gnueabihf },
-    },
-    LibCTarget{
-        .name = "arc-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.arc },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "csky-linux-gnuabiv2",
-        .arch = MultiArch{ .specific = Arch.csky },
-        .abi = MultiAbi{ .specific = Abi.gnueabihf },
-    },
-    LibCTarget{
-        .name = "csky-linux-gnuabiv2-soft",
-        .arch = MultiArch{ .specific = Arch.csky },
-        .abi = MultiAbi{ .specific = Abi.gnueabi },
-    },
-    LibCTarget{
-        .name = "i686-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.x86 },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "mips64el-linux-gnu-n32",
-        .arch = MultiArch{ .specific = Arch.mips64el },
-        .abi = MultiAbi{ .specific = Abi.gnuabin32 },
-    },
-    LibCTarget{
-        .name = "mips64el-linux-gnu-n64",
-        .arch = MultiArch{ .specific = Arch.mips64el },
-        .abi = MultiAbi{ .specific = Abi.gnuabi64 },
-    },
-    LibCTarget{
-        .name = "mips64-linux-gnu-n32",
-        .arch = MultiArch{ .specific = Arch.mips64 },
-        .abi = MultiAbi{ .specific = Abi.gnuabin32 },
-    },
-    LibCTarget{
-        .name = "mips64-linux-gnu-n64",
-        .arch = MultiArch{ .specific = Arch.mips64 },
-        .abi = MultiAbi{ .specific = Abi.gnuabi64 },
-    },
-    LibCTarget{
-        .name = "mipsel-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.mipsel },
-        .abi = MultiAbi{ .specific = Abi.gnueabihf },
-    },
-    LibCTarget{
-        .name = "mipsel-linux-gnu-soft",
-        .arch = MultiArch{ .specific = Arch.mipsel },
-        .abi = MultiAbi{ .specific = Abi.gnueabi },
-    },
-    LibCTarget{
-        .name = "mips-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.mips },
-        .abi = MultiAbi{ .specific = Abi.gnueabihf },
-    },
-    LibCTarget{
-        .name = "mips-linux-gnu-soft",
-        .arch = MultiArch{ .specific = Arch.mips },
-        .abi = MultiAbi{ .specific = Abi.gnueabi },
-    },
-    LibCTarget{
-        .name = "powerpc64le-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.powerpc64le },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "powerpc64-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.powerpc64 },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "powerpc-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.powerpc },
-        .abi = MultiAbi{ .specific = Abi.gnueabihf },
-    },
-    LibCTarget{
-        .name = "powerpc-linux-gnu-soft",
-        .arch = MultiArch{ .specific = Arch.powerpc },
-        .abi = MultiAbi{ .specific = Abi.gnueabi },
-    },
-    LibCTarget{
-        .name = "riscv32-linux-gnu-rv32imafdc-ilp32d",
-        .arch = MultiArch{ .specific = Arch.riscv32 },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "riscv64-linux-gnu-rv64imafdc-lp64d",
-        .arch = MultiArch{ .specific = Arch.riscv64 },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "s390x-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.s390x },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "sparcv9-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.sparc },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "sparc64-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.sparc64 },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "x86_64-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.x86_64 },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "x86_64-linux-gnu-x32",
-        .arch = MultiArch{ .specific = Arch.x86_64 },
-        .abi = MultiAbi{ .specific = Abi.gnux32 },
-    },
-    LibCTarget{
-        .name = "m68k-linux-gnu",
-        .arch = MultiArch{ .specific = Arch.m68k },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "loongarch64-linux-gnu-lp64d",
-        .arch = MultiArch{ .specific = .loongarch64 },
-        .abi = MultiAbi{ .specific = Abi.gnu },
-    },
-    LibCTarget{
-        .name = "loongarch64-linux-gnu-lp64s",
-        .arch = MultiArch{ .specific = .loongarch64 },
-        .abi = MultiAbi{ .specific = Abi.gnusf },
-    },
+    .{ .name = "arc-linux-gnu", .arch = .arc, .abi = .gnu },
+    .{ .name = "arm-linux-gnueabi", .arch = .arm, .abi = .gnueabi },
+    .{ .name = "arm-linux-gnueabihf", .arch = .arm, .abi = .gnueabihf },
+    .{ .name = "armeb-linux-gnueabi", .arch = .armeb, .abi = .gnueabi },
+    .{ .name = "armeb-linux-gnueabihf", .arch = .armeb, .abi = .gnueabihf },
+    .{ .name = "aarch64-linux-gnu", .arch = .aarch64, .abi = .gnu },
+    .{ .name = "aarch64_be-linux-gnu", .arch = .aarch64_be, .abi = .gnu },
+    .{ .name = "csky-linux-gnuabiv2-soft", .arch = .csky, .abi = .gnueabi },
+    .{ .name = "csky-linux-gnuabiv2", .arch = .csky, .abi = .gnueabihf },
+    .{ .name = "loongarch64-linux-gnu-lp64d", .arch = .loongarch64, .abi = .gnu },
+    .{ .name = "loongarch64-linux-gnu-lp64s", .arch = .loongarch64, .abi = .gnusf },
+    .{ .name = "m68k-linux-gnu", .arch = .m68k, .abi = .gnu },
+    .{ .name = "mips-linux-gnu", .arch = .mips, .abi = .gnueabihf },
+    .{ .name = "mips-linux-gnu-soft", .arch = .mips, .abi = .gnueabi },
+    .{ .name = "mipsel-linux-gnu-soft", .arch = .mipsel, .abi = .gnueabi },
+    .{ .name = "mipsel-linux-gnu", .arch = .mipsel, .abi = .gnueabihf },
+    .{ .name = "mips64-linux-gnu-n64", .arch = .mips64, .abi = .gnuabi64 },
+    .{ .name = "mips64-linux-gnu-n32", .arch = .mips64, .abi = .gnuabin32 },
+    .{ .name = "mips64el-linux-gnu-n64", .arch = .mips64el, .abi = .gnuabi64 },
+    .{ .name = "mips64el-linux-gnu-n32", .arch = .mips64el, .abi = .gnuabin32 },
+    .{ .name = "powerpc-linux-gnu-soft", .arch = .powerpc, .abi = .gnueabi },
+    .{ .name = "powerpc-linux-gnu", .arch = .powerpc, .abi = .gnueabihf },
+    .{ .name = "powerpc64-linux-gnu", .arch = .powerpc64, .abi = .gnu },
+    .{ .name = "powerpc64le-linux-gnu", .arch = .powerpc64le, .abi = .gnu },
+    .{ .name = "riscv32-linux-gnu-rv32imafdc-ilp32d", .arch = .riscv32, .abi = .gnu },
+    .{ .name = "riscv64-linux-gnu-rv64imafdc-lp64d", .arch = .riscv64, .abi = .gnu },
+    .{ .name = "s390x-linux-gnu", .arch = .s390x, .abi = .gnu },
+    .{ .name = "sparcv9-linux-gnu", .arch = .sparc, .abi = .gnu },
+    .{ .name = "sparc64-linux-gnu", .arch = .sparc64, .abi = .gnu },
+    .{ .name = "i686-linux-gnu", .arch = .x86, .abi = .gnu },
+    .{ .name = "x86_64-linux-gnu", .arch = .x86_64, .abi = .gnu },
+    .{ .name = "x86_64-linux-gnu-x32", .arch = .x86_64, .abi = .gnux32 },
 };
 
 const musl_targets = [_]LibCTarget{
-    LibCTarget{
-        .name = "aarch64",
-        .arch = MultiArch.aarch64,
-        .abi = MultiAbi.musl,
-    },
-    LibCTarget{
-        .name = "arm",
-        .arch = MultiArch.arm,
-        .abi = MultiAbi.musl,
-    },
-    LibCTarget{
-        .name = "i386",
-        .arch = MultiArch{ .specific = .x86 },
-        .abi = MultiAbi.musl,
-    },
-    LibCTarget{
-        .name = "loongarch64",
-        .arch = MultiArch{ .specific = .loongarch64 },
-        .abi = MultiAbi.musl,
-    },
-    LibCTarget{
-        .name = "mips",
-        .arch = MultiArch.mips,
-        .abi = MultiAbi.musl,
-    },
-    LibCTarget{
-        .name = "mips64",
-        .arch = MultiArch.mips64,
-        .abi = MultiAbi.musl,
-    },
-    LibCTarget{
-        .name = "powerpc",
-        .arch = MultiArch{ .specific = .powerpc },
-        .abi = MultiAbi.musl,
-    },
-    LibCTarget{
-        .name = "powerpc64",
-        .arch = MultiArch.powerpc64,
-        .abi = MultiAbi.musl,
-    },
-    LibCTarget{
-        .name = "riscv32",
-        .arch = MultiArch{ .specific = .riscv32 },
-        .abi = MultiAbi.musl,
-    },
-    LibCTarget{
-        .name = "riscv64",
-        .arch = MultiArch{ .specific = .riscv64 },
-        .abi = MultiAbi.musl,
-    },
-    LibCTarget{
-        .name = "s390x",
-        .arch = MultiArch{ .specific = .s390x },
-        .abi = MultiAbi.musl,
-    },
-    LibCTarget{
-        .name = "x86_64",
-        .arch = MultiArch{ .specific = .x86_64 },
-        .abi = MultiAbi.musl,
-    },
-    LibCTarget{
-        .name = "m68k",
-        .arch = MultiArch{ .specific = .m68k },
-        .abi = MultiAbi{ .specific = .musl },
-    },
+    .{ .name = "arm", .arch = .arm, .abi = .musl },
+    .{ .name = "aarch64", .arch = .aarch64, .abi = .musl },
+    .{ .name = "loongarch64", .arch = .loongarch64, .abi = .musl },
+    .{ .name = "m68k", .arch = .m68k, .abi = .musl },
+    .{ .name = "mips", .arch = .mips, .abi = .musl },
+    .{ .name = "mips64", .arch = .mips64, .abi = .musl },
+    .{ .name = "mipsn32", .arch = .mips64, .abi = .muslabin32 },
+    .{ .name = "powerpc", .arch = .powerpc, .abi = .musl },
+    .{ .name = "powerpc64", .arch = .powerpc64, .abi = .musl },
+    .{ .name = "riscv32", .arch = .riscv32, .abi = .musl },
+    .{ .name = "riscv64", .arch = .riscv64, .abi = .musl },
+    .{ .name = "s390x", .arch = .s390x, .abi = .musl },
+    .{ .name = "i386", .arch = .x86, .abi = .musl },
+    .{ .name = "x86_64", .arch = .x86_64, .abi = .musl },
+    .{ .name = "x32", .arch = .x86_64, .abi = .muslx32 },
 };
 
 const DestTarget = struct {
-    arch: MultiArch,
+    arch: Arch,
     os: OsTag,
     abi: Abi,
 
@@ -300,7 +92,7 @@ const DestTarget = struct {
         pub fn eql(self: @This(), a: DestTarget, b: DestTarget, b_index: usize) bool {
             _ = self;
             _ = b_index;
-            return a.arch.eql(b.arch) and
+            return a.arch == b.arch and
                 a.os == b.os and
                 a.abi == b.abi;
         }
@@ -363,22 +155,16 @@ pub fn main() !void {
 
     const out_dir = opt_out_dir orelse usageAndExit(args[0]);
     const abi_name = opt_abi orelse usageAndExit(args[0]);
-    const vendor = if (std.mem.eql(u8, abi_name, "musl"))
-        LibCVendor.musl
-    else if (std.mem.eql(u8, abi_name, "glibc"))
-        LibCVendor.glibc
-    else {
+    const vendor = std.meta.stringToEnum(LibCVendor, abi_name) orelse {
         std.debug.print("unrecognized C ABI: {s}\n", .{abi_name});
         usageAndExit(args[0]);
     };
-    const generic_name = try std.fmt.allocPrint(allocator, "generic-{s}", .{abi_name});
 
-    // TODO compiler crashed when I wrote this the canonical way
-    var libc_targets: []const LibCTarget = undefined;
-    switch (vendor) {
-        .musl => libc_targets = &musl_targets,
-        .glibc => libc_targets = &glibc_targets,
-    }
+    const generic_name = try std.fmt.allocPrint(allocator, "generic-{s}", .{abi_name});
+    const libc_targets = switch (vendor) {
+        .glibc => &glibc_targets,
+        .musl => &musl_targets,
+    };
 
     var path_table = PathTable.init(allocator);
     var hash_to_contents = HashToContents.init(allocator);
@@ -390,22 +176,15 @@ pub fn main() !void {
     for (libc_targets) |libc_target| {
         const dest_target = DestTarget{
             .arch = libc_target.arch,
-            .abi = switch (vendor) {
-                .musl => .musl,
-                .glibc => libc_target.abi.specific,
-            },
             .os = .linux,
+            .abi = libc_target.abi,
         };
+
         search: for (search_paths.items) |search_path| {
-            var sub_path: []const []const u8 = undefined;
-            switch (vendor) {
-                .musl => {
-                    sub_path = &[_][]const u8{ search_path, libc_target.name, "usr", "local", "musl", "include" };
-                },
-                .glibc => {
-                    sub_path = &[_][]const u8{ search_path, libc_target.name, "usr", "include" };
-                },
-            }
+            const sub_path = switch (vendor) {
+                .glibc => &[_][]const u8{ search_path, libc_target.name, "usr", "include" },
+                .musl => &[_][]const u8{ search_path, libc_target.name, "usr", "local", "musl", "include" },
+            };
             const target_include_dir = try std.fs.path.join(allocator, sub_path);
             var dir_stack = std.ArrayList([]const u8).init(allocator);
             try dir_stack.append(target_include_dir);
@@ -515,12 +294,8 @@ pub fn main() !void {
             if (contents.is_generic) continue;
 
             const dest_target = hash_kv.key_ptr.*;
-            const arch_name = switch (dest_target.arch) {
-                .specific => |a| @tagName(a),
-                else => @tagName(dest_target.arch),
-            };
             const out_subpath = try std.fmt.allocPrint(allocator, "{s}-{s}-{s}", .{
-                arch_name,
+                @tagName(dest_target.arch),
                 @tagName(dest_target.os),
                 @tagName(dest_target.abi),
             });
diff --git a/zig/tools/update_clang_options.zig b/zig/tools/update_clang_options.zig
index 3d32e4c7e1..637c9a5eaf 100644
--- a/zig/tools/update_clang_options.zig
+++ b/zig/tools/update_clang_options.zig
@@ -576,7 +576,7 @@ fn knownOption(name: []const u8) ?[]const u8 {
 
 const cpu_targets = struct {
     pub const aarch64 = std.Target.aarch64;
-    pub const amdgpu = std.Target.amdgpu;
+    pub const amdgcn = std.Target.amdgcn;
     pub const arc = std.Target.arc;
     pub const arm = std.Target.arm;
     pub const avr = std.Target.avr;
diff --git a/zig/tools/update_cpu_features.zig b/zig/tools/update_cpu_features.zig
index fdc7b02a9e..07d66213ff 100644
--- a/zig/tools/update_cpu_features.zig
+++ b/zig/tools/update_cpu_features.zig
@@ -390,7 +390,7 @@ const llvm_targets = [_]LlvmTarget{
         },
     },
     .{
-        .zig_name = "amdgpu",
+        .zig_name = "amdgcn",
         .llvm_name = "AMDGPU",
         .td_name = "AMDGPU.td",
         .feature_overrides = &.{
@@ -699,11 +699,11 @@ const llvm_targets = [_]LlvmTarget{
             },
             .{
                 .llvm_name = "armv7k",
-                .zig_name = "v7k",
+                .omit = true,
             },
             .{
                 .llvm_name = "armv7s",
-                .zig_name = "v7s",
+                .omit = true,
             },
             .{
                 .llvm_name = "armv7ve",