From cd8070f94f6865959949dbcec6e0e32cd88bb544 Mon Sep 17 00:00:00 2001
From: antlilja <liljaanton2001@gmail.com>
Date: Sat, 30 Jul 2022 11:39:49 +0200
Subject: [PATCH 001/290] Removed param_names from Fn inside Module.zig

Removed the copy of param_names inside of Fn and changed to
implementation of getParamName to fetch to parameter name from the ZIR.
The signature of getParamName was also changed to take an additional
*Module argument.
---
 src/Module.zig               | 38 +++++++++++++++++++-----------------
 src/Sema.zig                 |  6 ------
 src/Zir.zig                  | 21 ++++++++++++++++++++
 src/arch/arm/CodeGen.zig     |  2 +-
 src/arch/riscv64/CodeGen.zig |  2 +-
 src/arch/sparc64/CodeGen.zig |  2 +-
 src/arch/wasm/CodeGen.zig    |  2 +-
 src/arch/x86_64/CodeGen.zig  |  2 +-
 src/codegen/llvm.zig         |  2 +-
 9 files changed, 47 insertions(+), 30 deletions(-)

diff --git a/src/Module.zig b/src/Module.zig
index 4ac2775515901b7a3977d9c17ea25ff3012ffab8..b80e00ad595ffe9153e2ab5b329d0805fef7ea6a 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -1471,14 +1471,6 @@ pub const Fn = struct {
     /// TODO apply the same enhancement for param_names below to this field.
     anytype_args: [*]bool,
 
-    /// Prefer to use `getParamName` to access this because of the future improvement
-    /// we want to do mentioned in the TODO below.
-    /// Stored in gpa.
-    /// TODO: change param ZIR instructions to be embedded inside the function
-    /// ZIR instruction instead of before it, so that `zir_body_inst` can be used to
-    /// determine param names rather than redundantly storing them here.
-    param_names: []const [:0]const u8,
-
     /// Precomputed hash for monomorphed_funcs.
     /// This is important because it may be accessed when resizing monomorphed_funcs
     /// while this Fn has already been added to the set, but does not have the
@@ -1590,18 +1582,28 @@ pub const Fn = struct {
             gpa.destroy(node);
             it = next;
         }
-
-        for (func.param_names) |param_name| {
-            gpa.free(param_name);
-        }
-        gpa.free(func.param_names);
     }
 
-    pub fn getParamName(func: Fn, index: u32) [:0]const u8 {
-        // TODO rework ZIR of parameters so that this function looks up
-        // param names in ZIR instead of redundantly saving them into Fn.
-        // const zir = func.owner_decl.getFileScope().zir;
-        return func.param_names[index];
+    pub fn getParamName(func: Fn, mod: *Module, index: u32) [:0]const u8 {
+        const file = mod.declPtr(func.owner_decl).getFileScope();
+
+        const tags = file.zir.instructions.items(.tag);
+        const data = file.zir.instructions.items(.data);
+
+        const param_body = file.zir.getParamBody(func.zir_body_inst);
+        const param = param_body[index];
+
+        return switch (tags[param]) {
+            .param, .param_comptime => blk: {
+                const extra = file.zir.extraData(Zir.Inst.Param, data[param].pl_tok.payload_index);
+                break :blk file.zir.nullTerminatedString(extra.data.name);
+            },
+            .param_anytype, .param_anytype_comptime => blk: {
+                const param_data = data[param].str_tok;
+                break :blk param_data.get(file.zir);
+            },
+            else => unreachable,
+        };
     }
 
     pub fn hasInferredErrorSet(func: Fn, mod: *Module) bool {
diff --git a/src/Sema.zig b/src/Sema.zig
index a0829d6eb7eae7ef784521c1eb98a2ec503e0be5..07e81dc5beecf3d9309d85abc7aca26cd98ee068 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -7753,11 +7753,6 @@ fn funcCommon(
         break :blk if (sema.comptime_args.len == 0) null else sema.comptime_args.ptr;
     } else null;
 
-    const param_names = try sema.gpa.alloc([:0]const u8, block.params.items.len);
-    for (param_names) |*param_name, i| {
-        param_name.* = try sema.gpa.dupeZ(u8, block.params.items[i].name);
-    }
-
     const hash = new_func.hash;
     const fn_payload = try sema.arena.create(Value.Payload.Function);
     new_func.* = .{
@@ -7771,7 +7766,6 @@ fn funcCommon(
         .rbrace_line = src_locs.rbrace_line,
         .lbrace_column = @truncate(u16, src_locs.columns),
         .rbrace_column = @truncate(u16, src_locs.columns >> 16),
-        .param_names = param_names,
         .branch_quota = default_branch_quota,
         .is_noinline = is_noinline,
     };
diff --git a/src/Zir.zig b/src/Zir.zig
index ccd677df0b19a0619b10ebbec67bd799b3103cc7..5af3c0038d54e4c8bda2f7ba7f8589c31aa45bc1 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -3909,6 +3909,27 @@ pub const FnInfo = struct {
     total_params_len: u32,
 };
 
+pub fn getParamBody(zir: Zir, fn_inst: Inst.Index) []const u32 {
+    const tags = zir.instructions.items(.tag);
+    const datas = zir.instructions.items(.data);
+    const inst_data = datas[fn_inst].pl_node;
+
+    const param_block_index = switch (tags[fn_inst]) {
+        .func, .func_inferred => blk: {
+            const extra = zir.extraData(Inst.Func, inst_data.payload_index);
+            break :blk extra.data.param_block;
+        },
+        .func_fancy => blk: {
+            const extra = zir.extraData(Inst.FuncFancy, inst_data.payload_index);
+            break :blk extra.data.param_block;
+        },
+        else => unreachable,
+    };
+
+    const param_block = zir.extraData(Inst.Block, datas[param_block_index].pl_node.payload_index);
+    return zir.extra[param_block.end..][0..param_block.data.body_len];
+}
+
 pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo {
     const tags = zir.instructions.items(.tag);
     const datas = zir.instructions.items(.data);
diff --git a/src/arch/arm/CodeGen.zig b/src/arch/arm/CodeGen.zig
index 93d98c41d357dce533442884c7d85b898503a885..a603f72d53385a2b9a6d7f379889a8cc1215e8ae 100644
--- a/src/arch/arm/CodeGen.zig
+++ b/src/arch/arm/CodeGen.zig
@@ -3372,7 +3372,7 @@ fn genArgDbgInfo(self: *Self, inst: Air.Inst.Index, arg_index: u32, stack_byte_c
 
     const mcv = self.args[arg_index];
     const ty = self.air.instructions.items(.data)[inst].ty;
-    const name = self.mod_fn.getParamName(arg_index);
+    const name = self.mod_fn.getParamName(self.bin_file.options.module.?, arg_index);
     const name_with_null = name.ptr[0 .. name.len + 1];
 
     switch (mcv) {
diff --git a/src/arch/riscv64/CodeGen.zig b/src/arch/riscv64/CodeGen.zig
index 220fb18699e7aac56b114b20b1ce805cc986124d..d09c6278b5eac0a655ce17fa9357768b520411aa 100644
--- a/src/arch/riscv64/CodeGen.zig
+++ b/src/arch/riscv64/CodeGen.zig
@@ -1619,7 +1619,7 @@ fn airFieldParentPtr(self: *Self, inst: Air.Inst.Index) !void {
 
 fn genArgDbgInfo(self: *Self, inst: Air.Inst.Index, mcv: MCValue, arg_index: u32) !void {
     const ty = self.air.instructions.items(.data)[inst].ty;
-    const name = self.mod_fn.getParamName(arg_index);
+    const name = self.mod_fn.getParamName(self.bin_file.options.module.?, arg_index);
     const name_with_null = name.ptr[0 .. name.len + 1];
 
     switch (mcv) {
diff --git a/src/arch/sparc64/CodeGen.zig b/src/arch/sparc64/CodeGen.zig
index 2c6a322fca946d35b7509e4705ea55aa3d7d377d..bc9fc115b2461bfa72630a0b141f11870ad22297 100644
--- a/src/arch/sparc64/CodeGen.zig
+++ b/src/arch/sparc64/CodeGen.zig
@@ -2959,7 +2959,7 @@ fn finishAir(self: *Self, inst: Air.Inst.Index, result: MCValue, operands: [Live
 
 fn genArgDbgInfo(self: *Self, inst: Air.Inst.Index, mcv: MCValue, arg_index: u32) !void {
     const ty = self.air.instructions.items(.data)[inst].ty;
-    const name = self.mod_fn.getParamName(arg_index);
+    const name = self.mod_fn.getParamName(self.bin_file.options.module.?, arg_index);
     const name_with_null = name.ptr[0 .. name.len + 1];
 
     switch (mcv) {
diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index 91072d0b4c8b4aac4a45fe2368b52da8cdb5a90b..dd9cfba5480b03780a695383d7b24acfce531aeb 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -1991,7 +1991,7 @@ fn airArg(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     switch (self.debug_output) {
         .dwarf => |dwarf| {
             // TODO: Get the original arg index rather than wasm arg index
-            const name = self.mod_fn.getParamName(arg_index);
+            const name = self.mod_fn.getParamName(self.bin_file.base.options.module.?, arg_index);
             const leb_size = link.File.Wasm.getULEB128Size(arg.local);
             const dbg_info = &dwarf.dbg_info;
             try dbg_info.ensureUnusedCapacity(3 + leb_size + 5 + name.len + 1);
diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig
index 09721c661f094597e4950476e3807e4efbc2b242..d59a114e510cf2632f96c672143b72f9f2495fa2 100644
--- a/src/arch/x86_64/CodeGen.zig
+++ b/src/arch/x86_64/CodeGen.zig
@@ -3789,7 +3789,7 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
 
     const ty = self.air.typeOfIndex(inst);
     const mcv = self.args[arg_index];
-    const name = self.mod_fn.getParamName(arg_index);
+    const name = self.mod_fn.getParamName(self.bin_file.options.module.?, arg_index);
     const name_with_null = name.ptr[0 .. name.len + 1];
 
     if (self.liveness.isUnused(inst))
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 664edb0304c878dd9420838ba1d100d1ce2e50cc..5ea7ffad67a8b28f0d4002572743085d3fb29071 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -7313,7 +7313,7 @@ pub const FuncGen = struct {
             const lbrace_col = func.lbrace_column + 1;
             const di_local_var = dib.createParameterVariable(
                 self.di_scope.?,
-                func.getParamName(src_index).ptr, // TODO test 0 bit args
+                func.getParamName(self.dg.module, src_index).ptr, // TODO test 0 bit args
                 self.di_file.?,
                 lbrace_line,
                 try self.dg.object.lowerDebugType(inst_ty, .full),
-- 
2.54.0


From ab3b614a335ffac9eac4f824ee18fba262ad988e Mon Sep 17 00:00:00 2001
From: antlilja <liljaanton2001@gmail.com>
Date: Sat, 30 Jul 2022 18:43:15 +0200
Subject: [PATCH 002/290] Removed anytype_args field from Fn

anytype_args field was replaced with isAnytypeParam function.
---
 src/Module.zig | 21 ++++++++++++++++-----
 src/Sema.zig   | 11 ++---------
 2 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/src/Module.zig b/src/Module.zig
index b80e00ad595ffe9153e2ab5b329d0805fef7ea6a..625af7ca07f3be5b552bb3605f850dddd006d0d5 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -1464,12 +1464,8 @@ pub const Fn = struct {
     /// These never have .generic_poison for the Type
     /// because the Type is needed to pass to `Type.eql` and for inserting comptime arguments
     /// into the inst_map when analyzing the body of a generic function instantiation.
-    /// Instead, the is_anytype knowledge is communicated via `anytype_args`.
+    /// Instead, the is_anytype knowledge is communicated via `isAnytypeParam`.
     comptime_args: ?[*]TypedValue,
-    /// When comptime_args is null, this is undefined. Otherwise, this flags each
-    /// parameter and tells whether it is anytype.
-    /// TODO apply the same enhancement for param_names below to this field.
-    anytype_args: [*]bool,
 
     /// Precomputed hash for monomorphed_funcs.
     /// This is important because it may be accessed when resizing monomorphed_funcs
@@ -1584,6 +1580,21 @@ pub const Fn = struct {
         }
     }
 
+    pub fn isAnytypeParam(func: Fn, mod: *Module, index: u32) bool {
+        const file = mod.declPtr(func.owner_decl).getFileScope();
+
+        const tags = file.zir.instructions.items(.tag);
+
+        const param_body = file.zir.getParamBody(func.zir_body_inst);
+        const param = param_body[index];
+
+        return switch (tags[param]) {
+            .param, .param_comptime => false,
+            .param_anytype, .param_anytype_comptime => true,
+            else => unreachable,
+        };
+    }
+
     pub fn getParamName(func: Fn, mod: *Module, index: u32) [:0]const u8 {
         const file = mod.declPtr(func.owner_decl).getFileScope();
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 07e81dc5beecf3d9309d85abc7aca26cd98ee068..1629b7711a5115b7381f0ac6695b9651f36a7f3b 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -5498,7 +5498,7 @@ const GenericCallAdapter = struct {
             const this_is_comptime = this_arg.val.tag() != .generic_poison;
             const other_is_comptime = other_arg.val.tag() != .generic_poison;
             const this_is_anytype = this_arg.ty.tag() != .generic_poison;
-            const other_is_anytype = other_key.anytype_args[i];
+            const other_is_anytype = other_key.isAnytypeParam(ctx.module, @intCast(u32, i));
 
             if (other_is_anytype != this_is_anytype) return false;
             if (other_is_comptime != this_is_comptime) return false;
@@ -6379,12 +6379,9 @@ fn instantiateGenericCall(
         errdefer new_func.deinit(gpa);
         assert(new_func == new_module_func);
 
-        const anytype_args = try new_decl_arena_allocator.alloc(bool, func_ty_info.param_types.len);
-        new_func.anytype_args = anytype_args.ptr;
         arg_i = 0;
         for (fn_info.param_body) |inst| {
             var is_comptime = false;
-            var is_anytype = false;
             switch (zir_tags[inst]) {
                 .param => {
                     is_comptime = func_ty_info.paramIsComptime(arg_i);
@@ -6393,11 +6390,9 @@ fn instantiateGenericCall(
                     is_comptime = true;
                 },
                 .param_anytype => {
-                    is_anytype = true;
                     is_comptime = func_ty_info.paramIsComptime(arg_i);
                 },
                 .param_anytype_comptime => {
-                    is_anytype = true;
                     is_comptime = true;
                 },
                 else => continue,
@@ -6405,10 +6400,9 @@ fn instantiateGenericCall(
 
             // We populate the Type here regardless because it is needed by
             // `GenericCallAdapter.eql` as well as function body analysis.
-            // Whether it is anytype is communicated by `anytype_args`.
+            // Whether it is anytype is communicated by `isAnytypeParam`.
             const arg = child_sema.inst_map.get(inst).?;
             const copied_arg_ty = try child_sema.typeOf(arg).copy(new_decl_arena_allocator);
-            anytype_args[arg_i] = is_anytype;
 
             if (try sema.typeRequiresComptime(block, .unneeded, copied_arg_ty)) {
                 is_comptime = true;
@@ -7760,7 +7754,6 @@ fn funcCommon(
         .zir_body_inst = func_inst,
         .owner_decl = sema.owner_decl_index,
         .comptime_args = comptime_args,
-        .anytype_args = undefined,
         .hash = hash,
         .lbrace_line = src_locs.lbrace_line,
         .rbrace_line = src_locs.rbrace_line,
-- 
2.54.0


From b3950d4a88425719a642fe71d4739185a8632f89 Mon Sep 17 00:00:00 2001
From: Stephen Gregoratto <dev@sgregoratto.me>
Date: Mon, 1 Aug 2022 22:53:46 +1000
Subject: [PATCH 003/290] Update Linux syscall list for 5.19

New changes: memfd_secret implemented for RISC-V.
---
 lib/std/os/linux/syscalls.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/std/os/linux/syscalls.zig b/lib/std/os/linux/syscalls.zig
index fb0993afe59f38f9d0bb7caaa1ebc21a46ee9faa..6e8cee7b84db143a7eec8bd7f67ce205d4727c65 100644
--- a/lib/std/os/linux/syscalls.zig
+++ b/lib/std/os/linux/syscalls.zig
@@ -3485,6 +3485,7 @@ pub const RiscV64 = enum(usize) {
     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,
-- 
2.54.0


From fd3415ad5e007005f7d568c41967c563e2066e95 Mon Sep 17 00:00:00 2001
From: Meredith Oleander <33614480+em-dash@users.noreply.github.com>
Date: Fri, 5 Aug 2022 22:38:48 +1000
Subject: [PATCH 004/290] translate-c: fix alignment in pointer casts

---
 src/translate_c.zig  |  3 +--
 test/translate_c.zig | 30 +++++++++++++++++++++---------
 2 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/src/translate_c.zig b/src/translate_c.zig
index 97e47d84f372fb598a49ef0b68ae66195117e56f..fa23b861e380a9df9f4be4c02ba79c9eba754791 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -4001,8 +4001,7 @@ fn transCPtrCast(
             // For opaque types a ptrCast is enough
             expr
         else blk: {
-            const child_type_node = try transQualType(c, scope, child_type, loc);
-            const alignof = try Tag.std_meta_alignment.create(c.arena, child_type_node);
+            const alignof = try Tag.std_meta_alignment.create(c.arena, dst_type_node);
             const align_cast = try Tag.align_cast.create(c.arena, .{ .lhs = alignof, .rhs = expr });
             break :blk align_cast;
         };
diff --git a/test/translate_c.zig b/test/translate_c.zig
index 5a640c5b4bb00a639c4b4112b4a3d60b2ad8552b..540c560839bc9043407674086b5051d6e5d813f5 100644
--- a/test/translate_c.zig
+++ b/test/translate_c.zig
@@ -1485,7 +1485,19 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
     , &[_][]const u8{
         \\pub export fn ptrcast() [*c]f32 {
         \\    var a: [*c]c_int = undefined;
-        \\    return @ptrCast([*c]f32, @alignCast(@import("std").meta.alignment(f32), a));
+        \\    return @ptrCast([*c]f32, @alignCast(@import("std").meta.alignment([*c]f32), a));
+        \\}
+    });
+
+    cases.add("casting pointer to pointer",
+        \\float **ptrptrcast() {
+        \\    int **a;
+        \\    return (float **)a;
+        \\}
+    , &[_][]const u8{
+        \\pub export fn ptrptrcast() [*c][*c]f32 {
+        \\    var a: [*c][*c]c_int = undefined;
+        \\    return @ptrCast([*c][*c]f32, @alignCast(@import("std").meta.alignment([*c][*c]f32), a));
         \\}
     });
 
@@ -1509,23 +1521,23 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\pub export fn test_ptr_cast() void {
         \\    var p: ?*anyopaque = undefined;
         \\    {
-        \\        var to_char: [*c]u8 = @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), p));
+        \\        var to_char: [*c]u8 = @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), p));
         \\        _ = to_char;
-        \\        var to_short: [*c]c_short = @ptrCast([*c]c_short, @alignCast(@import("std").meta.alignment(c_short), p));
+        \\        var to_short: [*c]c_short = @ptrCast([*c]c_short, @alignCast(@import("std").meta.alignment([*c]c_short), p));
         \\        _ = to_short;
-        \\        var to_int: [*c]c_int = @ptrCast([*c]c_int, @alignCast(@import("std").meta.alignment(c_int), p));
+        \\        var to_int: [*c]c_int = @ptrCast([*c]c_int, @alignCast(@import("std").meta.alignment([*c]c_int), p));
         \\        _ = to_int;
-        \\        var to_longlong: [*c]c_longlong = @ptrCast([*c]c_longlong, @alignCast(@import("std").meta.alignment(c_longlong), p));
+        \\        var to_longlong: [*c]c_longlong = @ptrCast([*c]c_longlong, @alignCast(@import("std").meta.alignment([*c]c_longlong), p));
         \\        _ = to_longlong;
         \\    }
         \\    {
-        \\        var to_char: [*c]u8 = @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment(u8), p));
+        \\        var to_char: [*c]u8 = @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), p));
         \\        _ = to_char;
-        \\        var to_short: [*c]c_short = @ptrCast([*c]c_short, @alignCast(@import("std").meta.alignment(c_short), p));
+        \\        var to_short: [*c]c_short = @ptrCast([*c]c_short, @alignCast(@import("std").meta.alignment([*c]c_short), p));
         \\        _ = to_short;
-        \\        var to_int: [*c]c_int = @ptrCast([*c]c_int, @alignCast(@import("std").meta.alignment(c_int), p));
+        \\        var to_int: [*c]c_int = @ptrCast([*c]c_int, @alignCast(@import("std").meta.alignment([*c]c_int), p));
         \\        _ = to_int;
-        \\        var to_longlong: [*c]c_longlong = @ptrCast([*c]c_longlong, @alignCast(@import("std").meta.alignment(c_longlong), p));
+        \\        var to_longlong: [*c]c_longlong = @ptrCast([*c]c_longlong, @alignCast(@import("std").meta.alignment([*c]c_longlong), p));
         \\        _ = to_longlong;
         \\    }
         \\}
-- 
2.54.0


From 263b5933d2fd63ae4052c7a29288968cbd8505bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20=22xq=22=20Quei=C3=9Fner?= <xq@random-projects.net>
Date: Wed, 3 Aug 2022 15:17:21 +0200
Subject: [PATCH 005/290] Makes std.meta.Tuple and std.meta.ArgsTuple generate
 a unique type instead of generating one per invocation.

---
 lib/std/meta.zig | 51 +++++++++++++++++++++++++++++++-----------------
 1 file changed, 33 insertions(+), 18 deletions(-)

diff --git a/lib/std/meta.zig b/lib/std/meta.zig
index c6717ad1c0d57b8b6a91c1689a3f2d1298736fcb..d5006bf81fae523f4f7cbaaca70887d5613eefa9 100644
--- a/lib/std/meta.zig
+++ b/lib/std/meta.zig
@@ -1024,28 +1024,13 @@ pub fn ArgsTuple(comptime Function: type) type {
     if (function_info.is_var_args)
         @compileError("Cannot create ArgsTuple for variadic function");
 
-    var argument_field_list: [function_info.args.len]std.builtin.Type.StructField = undefined;
+    var argument_field_list: [function_info.args.len]type = undefined;
     inline for (function_info.args) |arg, i| {
         const T = arg.arg_type.?;
-        @setEvalBranchQuota(10_000);
-        var num_buf: [128]u8 = undefined;
-        argument_field_list[i] = .{
-            .name = std.fmt.bufPrint(&num_buf, "{d}", .{i}) catch unreachable,
-            .field_type = T,
-            .default_value = null,
-            .is_comptime = false,
-            .alignment = if (@sizeOf(T) > 0) @alignOf(T) else 0,
-        };
+        argument_field_list[i] = T;
     }
 
-    return @Type(.{
-        .Struct = .{
-            .is_tuple = true,
-            .layout = .Auto,
-            .decls = &.{},
-            .fields = &argument_field_list,
-        },
-    });
+    return CreateUniqueTuple(argument_field_list.len, argument_field_list);
 }
 
 /// For a given anonymous list of types, returns a new tuple type
@@ -1056,6 +1041,10 @@ pub fn ArgsTuple(comptime Function: type) type {
 /// - `Tuple(&[_]type {f32})` ⇒ `tuple { f32 }`
 /// - `Tuple(&[_]type {f32,u32})` ⇒ `tuple { f32, u32 }`
 pub fn Tuple(comptime types: []const type) type {
+    return CreateUniqueTuple(types.len, types[0..types.len].*);
+}
+
+fn CreateUniqueTuple(comptime N: comptime_int, comptime types: [N]type) type {
     var tuple_fields: [types.len]std.builtin.Type.StructField = undefined;
     inline for (types) |T, i| {
         @setEvalBranchQuota(10_000);
@@ -1118,6 +1107,32 @@ test "Tuple" {
     TupleTester.assertTuple(.{ u32, f16, []const u8, void }, Tuple(&[_]type{ u32, f16, []const u8, void }));
 }
 
+test "Tuple deduplication" {
+    const T1 = std.meta.Tuple(&.{ u32, f32, i8 });
+    const T2 = std.meta.Tuple(&.{ u32, f32, i8 });
+    const T3 = std.meta.Tuple(&.{ u32, f32, i7 });
+
+    if (T1 != T2) {
+        @compileError("std.meta.Tuple doesn't deduplicate tuple types.");
+    }
+    if (T1 == T3) {
+        @compileError("std.meta.Tuple fails to generate different types.");
+    }
+}
+
+test "ArgsTuple forwarding" {
+    const T1 = std.meta.Tuple(&.{ u32, f32, i8 });
+    const T2 = std.meta.ArgsTuple(fn (u32, f32, i8) void);
+    const T3 = std.meta.ArgsTuple(fn (u32, f32, i8) callconv(.C) noreturn);
+
+    if (T1 != T2) {
+        @compileError("std.meta.ArgsTuple produces different types than std.meta.Tuple");
+    }
+    if (T1 != T3) {
+        @compileError("std.meta.ArgsTuple produces different types for the same argument lists.");
+    }
+}
+
 /// TODO: https://github.com/ziglang/zig/issues/425
 pub fn globalOption(comptime name: []const u8, comptime T: type) ?T {
     if (!@hasDecl(root, name))
-- 
2.54.0


From 44c321c05e0f5755bcb9f4b1a33dc23aeef880aa Mon Sep 17 00:00:00 2001
From: Allan Regush <17693494+AllanRegush@users.noreply.github.com>
Date: Wed, 27 Jul 2022 20:49:06 -0600
Subject: [PATCH 006/290] std.enums: make directEnumArrayLen public

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

diff --git a/lib/std/enums.zig b/lib/std/enums.zig
index 31bc367e64375508e86c3275502197972791d57f..08781767de4e27a9baa917d078854f1cc0993148 100644
--- a/lib/std/enums.zig
+++ b/lib/std/enums.zig
@@ -57,7 +57,7 @@ pub fn values(comptime E: type) []const E {
 /// the total number of items which have no matching enum key (holes in the enum
 /// numbering).  So for example, if an enum has values 1, 2, 5, and 6, max_unused_slots
 /// must be at least 3, to allow unused slots 0, 3, and 4.
-fn directEnumArrayLen(comptime E: type, comptime max_unused_slots: comptime_int) comptime_int {
+pub fn directEnumArrayLen(comptime E: type, comptime max_unused_slots: comptime_int) comptime_int {
     var max_value: comptime_int = -1;
     const max_usize: comptime_int = ~@as(usize, 0);
     const fields = std.meta.fields(E);
-- 
2.54.0


From 18440cb239755c983f672b4902147c12e819e029 Mon Sep 17 00:00:00 2001
From: N00byEdge <me@hannesbredberg.se>
Date: Fri, 5 Aug 2022 14:47:52 +0200
Subject: [PATCH 007/290] std.mem.zeroes: Zero sized structs with uninitialized
 members (#12246)

`std.mem.zeroes(struct{handle: void})` Failed with the following error before:
```
/nix/store/l6v4359wc9xrxxmvvp3rynsb5s3d78xf-zig-0.9.1/lib/zig/std/mem.zig:270:42: error: missing field: 'handle'
            if (@sizeOf(T) == 0) return T{};
                                         ^
```
---
 lib/std/mem.zig | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 5decb88ff3de88f3011e53e8fba4585d82b37369..aef0e0eb190128a3e36143edcd6705a2ed7badd4 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -267,7 +267,7 @@ pub fn zeroes(comptime T: type) T {
             return null;
         },
         .Struct => |struct_info| {
-            if (@sizeOf(T) == 0) return T{};
+            if (@sizeOf(T) == 0) return undefined;
             if (struct_info.layout == .Extern) {
                 var item: T = undefined;
                 set(u8, asBytes(&item), 0);
@@ -424,6 +424,9 @@ test "zeroes" {
 
     comptime var comptime_union = zeroes(C_union);
     try testing.expectEqual(@as(u8, 0), comptime_union.a);
+
+    // Ensure zero sized struct with fields is initialized correctly.
+    _ = zeroes(struct { handle: void });
 }
 
 /// Initializes all fields of the struct with their default value, or zero values if no default value is present.
-- 
2.54.0


From 423bef4dfc635a3ca0144cac95384984857a8519 Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Fri, 29 Jul 2022 00:55:00 +0200
Subject: [PATCH 008/290] stage2 AArch64: Fix struct_field_val for
 register_with_overflow

Now mirrors the behavior of the native ARM backend
---
 src/arch/aarch64/CodeGen.zig | 38 +++++++++++++++++-------------------
 1 file changed, 18 insertions(+), 20 deletions(-)

diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig
index a8bafee4f8a632d5e89b8f6b0cadcbf136789af5..b68ae283b57ce616cd97a53be101453703b1fb4d 100644
--- a/src/arch/aarch64/CodeGen.zig
+++ b/src/arch/aarch64/CodeGen.zig
@@ -3016,29 +3016,27 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
                 break :result MCValue{ .memory = addr + struct_field_offset };
             },
             .register_with_overflow => |rwo| {
-                switch (index) {
-                    0 => {
-                        // get wrapped value: return register
-                        break :result MCValue{ .register = rwo.reg };
-                    },
-                    1 => {
-                        // TODO return special MCValue condition flags
-                        // get overflow bit: set register to C flag
-                        // resp. V flag
-                        const raw_dest_reg = try self.register_manager.allocReg(null, gp);
-                        const dest_reg = raw_dest_reg.to32();
+                const reg_lock = self.register_manager.lockRegAssumeUnused(rwo.reg);
+                defer self.register_manager.unlockReg(reg_lock);
 
-                        _ = try self.addInst(.{
-                            .tag = .cset,
-                            .data = .{ .r_cond = .{
-                                .rd = dest_reg,
-                                .cond = rwo.flag,
-                            } },
-                        });
+                const field: MCValue = switch (index) {
+                    // get wrapped value: return register
+                    0 => MCValue{ .register = rwo.reg },
+
+                    // get overflow bit: return C or V flag
+                    1 => MCValue{ .condition_flags = rwo.flag },
 
-                        break :result MCValue{ .register = dest_reg };
-                    },
                     else => unreachable,
+                };
+
+                if (self.reuseOperand(inst, operand, 0, field)) {
+                    break :result field;
+                } else {
+                    // Copy to new register
+                    const dest_reg = try self.register_manager.allocReg(null, gp);
+                    try self.genSetReg(struct_ty.structFieldType(index), dest_reg, field);
+
+                    break :result MCValue{ .register = dest_reg };
                 }
             },
             else => return self.fail("TODO implement codegen struct_field_val for {}", .{mcv}),
-- 
2.54.0


From cf3aaceed9f2a9e1872bdd8b2cccecd1766e2419 Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Sat, 30 Jul 2022 23:17:15 +0200
Subject: [PATCH 009/290] stage2 AArch64: introduce
 MCValue.stack_argument_offset

This new MCValue union member shares the same semantics as the MCValue
type of the same name in the ARM backend.
---
 src/arch/aarch64/CodeGen.zig | 210 +++++++++++++++++++++++++++++++++--
 src/arch/aarch64/Emit.zig    |  64 +++++++++++
 src/arch/aarch64/Mir.zig     |  10 ++
 3 files changed, 275 insertions(+), 9 deletions(-)

diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig
index b68ae283b57ce616cd97a53be101453703b1fb4d..63be9a2220729ac62f8400020a144740f9c1758a 100644
--- a/src/arch/aarch64/CodeGen.zig
+++ b/src/arch/aarch64/CodeGen.zig
@@ -166,10 +166,12 @@ const MCValue = union(enum) {
     /// the type is u1) or true (if the type in bool) iff the
     /// specified condition is true.
     condition_flags: Condition,
+    /// The value is a function argument passed via the stack.
+    stack_argument_offset: u32,
 
     fn isMemory(mcv: MCValue) bool {
         return switch (mcv) {
-            .memory, .stack_offset => true,
+            .memory, .stack_offset, .stack_argument_offset => true,
             else => false,
         };
     }
@@ -192,6 +194,7 @@ const MCValue = union(enum) {
             .condition_flags,
             .ptr_stack_offset,
             .undef,
+            .stack_argument_offset,
             => false,
 
             .register,
@@ -337,6 +340,7 @@ pub fn generate(
         .prev_di_line = module_fn.lbrace_line,
         .prev_di_column = module_fn.lbrace_column,
         .stack_size = mem.alignForwardGeneric(u32, function.max_end_stack, function.stack_align),
+        .prologue_stack_space = call_info.stack_byte_count + function.saved_regs_stack_space,
     };
     defer emit.deinit();
 
@@ -2726,6 +2730,7 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
         },
         .memory,
         .stack_offset,
+        .stack_argument_offset,
         .got_load,
         .direct_load,
         => {
@@ -2927,6 +2932,7 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
         },
         .memory,
         .stack_offset,
+        .stack_argument_offset,
         .got_load,
         .direct_load,
         => {
@@ -3009,6 +3015,9 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
 
         switch (mcv) {
             .dead, .unreach => unreachable,
+            .stack_argument_offset => |off| {
+                break :result MCValue{ .stack_argument_offset = off - struct_field_offset };
+            },
             .stack_offset => |off| {
                 break :result MCValue{ .stack_offset = off - struct_field_offset };
             },
@@ -3152,12 +3161,12 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallOptions.
                 try self.register_manager.getReg(reg, null);
                 try self.genSetReg(arg_ty, reg, arg_mcv);
             },
-            .stack_offset => {
-                return self.fail("TODO implement calling with parameters in memory", .{});
-            },
-            .ptr_stack_offset => {
-                return self.fail("TODO implement calling with MCValue.ptr_stack_offset arg", .{});
-            },
+            .stack_offset => unreachable,
+            .stack_argument_offset => |offset| try self.genSetStackArgument(
+                arg_ty,
+                info.stack_byte_count - offset,
+                arg_mcv,
+            ),
             else => unreachable,
         }
     }
@@ -3884,7 +3893,7 @@ fn br(self: *Self, block: Air.Inst.Index, operand: Air.Inst.Ref) !void {
             block_data.mcv = switch (operand_mcv) {
                 .none, .dead, .unreach => unreachable,
                 .register, .stack_offset, .memory => operand_mcv,
-                .immediate, .condition_flags => blk: {
+                .immediate, .stack_argument_offset, .condition_flags => blk: {
                     const new_mcv = try self.allocRegOrMem(block, true);
                     try self.setRegOrMem(self.air.typeOfIndex(block), new_mcv, operand_mcv);
                     break :blk new_mcv;
@@ -4126,6 +4135,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
         .got_load,
         .direct_load,
         .memory,
+        .stack_argument_offset,
         .stack_offset,
         => {
             switch (mcv) {
@@ -4328,6 +4338,188 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
                 else => unreachable,
             }
         },
+        .stack_argument_offset => |off| {
+            const abi_size = ty.abiSize(self.target.*);
+
+            switch (abi_size) {
+                1, 2, 4, 8 => {
+                    const tag: Mir.Inst.Tag = switch (abi_size) {
+                        1 => if (ty.isSignedInt()) Mir.Inst.Tag.ldrsb_stack_argument else .ldrb_stack_argument,
+                        2 => if (ty.isSignedInt()) Mir.Inst.Tag.ldrsh_stack_argument else .ldrh_stack_argument,
+                        4, 8 => .ldr_stack_argument,
+                        else => unreachable, // unexpected abi size
+                    };
+
+                    _ = try self.addInst(.{
+                        .tag = tag,
+                        .data = .{ .load_store_stack = .{
+                            .rt = reg,
+                            .offset = @intCast(u32, off),
+                        } },
+                    });
+                },
+                3, 5, 6, 7 => return self.fail("TODO implement genSetReg types size {}", .{abi_size}),
+                else => unreachable,
+            }
+        },
+    }
+}
+
+fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerError!void {
+    const abi_size = @intCast(u32, ty.abiSize(self.target.*));
+    switch (mcv) {
+        .dead => unreachable,
+        .none, .unreach => return,
+        .undef => {
+            if (!self.wantSafety())
+                return; // The already existing value will do just fine.
+            // TODO Upgrade this to a memset call when we have that available.
+            switch (ty.abiSize(self.target.*)) {
+                1 => return self.genSetStack(ty, stack_offset, .{ .immediate = 0xaa }),
+                2 => return self.genSetStack(ty, stack_offset, .{ .immediate = 0xaaaa }),
+                4 => return self.genSetStack(ty, stack_offset, .{ .immediate = 0xaaaaaaaa }),
+                8 => return self.genSetStack(ty, stack_offset, .{ .immediate = 0xaaaaaaaaaaaaaaaa }),
+                else => return self.fail("TODO implement memset", .{}),
+            }
+        },
+        .register => |reg| {
+            switch (abi_size) {
+                1, 2, 4, 8 => {
+                    const tag: Mir.Inst.Tag = switch (abi_size) {
+                        1 => .strb_immediate,
+                        2 => .strh_immediate,
+                        4, 8 => .str_immediate,
+                        else => unreachable, // unexpected abi size
+                    };
+                    const rt = registerAlias(reg, abi_size);
+                    const offset = switch (abi_size) {
+                        1 => blk: {
+                            if (math.cast(u12, stack_offset)) |imm| {
+                                break :blk Instruction.LoadStoreOffset.imm(imm);
+                            } else {
+                                return self.fail("TODO genSetStackArgument byte with larger offset", .{});
+                            }
+                        },
+                        2 => blk: {
+                            assert(std.mem.isAlignedGeneric(u32, stack_offset, 2)); // misaligned stack entry
+                            if (math.cast(u12, @divExact(stack_offset, 2))) |imm| {
+                                break :blk Instruction.LoadStoreOffset.imm(imm);
+                            } else {
+                                return self.fail("TODO getSetStackArgument halfword with larger offset", .{});
+                            }
+                        },
+                        4, 8 => blk: {
+                            const alignment = abi_size;
+                            assert(std.mem.isAlignedGeneric(u32, stack_offset, alignment)); // misaligned stack entry
+                            if (math.cast(u12, @divExact(stack_offset, alignment))) |imm| {
+                                break :blk Instruction.LoadStoreOffset.imm(imm);
+                            } else {
+                                return self.fail("TODO genSetStackArgument with larger offset", .{});
+                            }
+                        },
+                        else => unreachable,
+                    };
+
+                    _ = try self.addInst(.{
+                        .tag = tag,
+                        .data = .{ .load_store_register_immediate = .{
+                            .rt = rt,
+                            .rn = .sp,
+                            .offset = offset.immediate,
+                        } },
+                    });
+                },
+                else => return self.fail("TODO genSetStackArgument other types abi_size={}", .{abi_size}),
+            }
+        },
+        .register_with_overflow => {
+            return self.fail("TODO implement genSetStack {}", .{mcv});
+        },
+        .got_load,
+        .direct_load,
+        .memory,
+        .stack_argument_offset,
+        .stack_offset,
+        => {
+            if (abi_size <= 4) {
+                const reg = try self.copyToTmpRegister(ty, mcv);
+                return self.genSetStackArgument(ty, stack_offset, MCValue{ .register = reg });
+            } else {
+                var ptr_ty_payload: Type.Payload.ElemType = .{
+                    .base = .{ .tag = .single_mut_pointer },
+                    .data = ty,
+                };
+                const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
+
+                // TODO call extern memcpy
+                const regs = try self.register_manager.allocRegs(5, .{ null, null, null, null, null }, gp);
+                const regs_locks = self.register_manager.lockRegsAssumeUnused(5, regs);
+                defer for (regs_locks) |reg| {
+                    self.register_manager.unlockReg(reg);
+                };
+
+                const src_reg = regs[0];
+                const dst_reg = regs[1];
+                const len_reg = regs[2];
+                const count_reg = regs[3];
+                const tmp_reg = regs[4];
+
+                switch (mcv) {
+                    .stack_offset => |off| {
+                        // sub src_reg, fp, #off
+                        try self.genSetReg(ptr_ty, src_reg, .{ .ptr_stack_offset = off });
+                    },
+                    .memory => |addr| try self.genSetReg(ptr_ty, src_reg, .{ .immediate = @intCast(u32, addr) }),
+                    .got_load,
+                    .direct_load,
+                    => |sym_index| {
+                        const tag: Mir.Inst.Tag = switch (mcv) {
+                            .got_load => .load_memory_ptr_got,
+                            .direct_load => .load_memory_ptr_direct,
+                            else => unreachable,
+                        };
+                        const mod = self.bin_file.options.module.?;
+                        _ = try self.addInst(.{
+                            .tag = tag,
+                            .data = .{
+                                .payload = try self.addExtra(Mir.LoadMemoryPie{
+                                    .register = @enumToInt(src_reg),
+                                    .atom_index = mod.declPtr(self.mod_fn.owner_decl).link.macho.sym_index,
+                                    .sym_index = sym_index,
+                                }),
+                            },
+                        });
+                    },
+                    .stack_argument_offset => return self.fail("TODO load {}", .{mcv}),
+                    else => unreachable,
+                }
+
+                // add dst_reg, sp, #stack_offset
+                _ = try self.addInst(.{
+                    .tag = .add_immediate,
+                    .data = .{ .rr_imm12_sh = .{
+                        .rd = dst_reg,
+                        .rn = .sp,
+                        .imm12 = math.cast(u12, stack_offset) orelse {
+                            return self.fail("TODO load: set reg to stack offset with all possible offsets", .{});
+                        },
+                    } },
+                });
+
+                // mov len, #abi_size
+                try self.genSetReg(Type.usize, len_reg, .{ .immediate = abi_size });
+
+                // memcpy(src, dst, len)
+                try self.genInlineMemcpy(src_reg, dst_reg, len_reg, count_reg, tmp_reg);
+            }
+        },
+        .condition_flags,
+        .immediate,
+        .ptr_stack_offset,
+        => {
+            const reg = try self.copyToTmpRegister(ty, mcv);
+            return self.genSetStackArgument(ty, stack_offset, MCValue{ .register = reg });
+        },
     }
 }
 
@@ -4835,8 +5027,8 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
                         }
                     }
 
-                    result.args[i] = .{ .stack_offset = nsaa };
                     nsaa += param_size;
+                    result.args[i] = .{ .stack_argument_offset = nsaa };
                 }
             }
 
diff --git a/src/arch/aarch64/Emit.zig b/src/arch/aarch64/Emit.zig
index 47a0c0889306d3176183212fcc901e0020f7c9fa..9320138f65cc93f70bc2201e4f78e08580caa355 100644
--- a/src/arch/aarch64/Emit.zig
+++ b/src/arch/aarch64/Emit.zig
@@ -27,14 +27,21 @@ code: *std.ArrayList(u8),
 
 prev_di_line: u32,
 prev_di_column: u32,
+
 /// Relative to the beginning of `code`.
 prev_di_pc: usize,
 
+/// The amount of stack space consumed by all stack arguments as well
+/// as the saved callee-saved registers
+prologue_stack_space: u32,
+
 /// The branch type of every branch
 branch_types: std.AutoHashMapUnmanaged(Mir.Inst.Index, BranchType) = .{},
+
 /// For every forward branch, maps the target instruction to a list of
 /// branches which branch to this target instruction
 branch_forward_origins: std.AutoHashMapUnmanaged(Mir.Inst.Index, std.ArrayListUnmanaged(Mir.Inst.Index)) = .{},
+
 /// For backward branches: stores the code offset of the target
 /// instruction
 ///
@@ -42,6 +49,8 @@ branch_forward_origins: std.AutoHashMapUnmanaged(Mir.Inst.Index, std.ArrayListUn
 /// instruction
 code_offset_mapping: std.AutoHashMapUnmanaged(Mir.Inst.Index, usize) = .{},
 
+/// The final stack frame size of the function (already aligned to the
+/// respective stack alignment). Does not include prologue stack space.
 stack_size: u32,
 
 const InnerError = error{
@@ -148,6 +157,12 @@ pub fn emitMir(
             .strb_stack => try emit.mirLoadStoreStack(inst),
             .strh_stack => try emit.mirLoadStoreStack(inst),
 
+            .ldr_stack_argument => try emit.mirLoadStackArgument(inst),
+            .ldrb_stack_argument => try emit.mirLoadStackArgument(inst),
+            .ldrh_stack_argument => try emit.mirLoadStackArgument(inst),
+            .ldrsb_stack_argument => try emit.mirLoadStackArgument(inst),
+            .ldrsh_stack_argument => try emit.mirLoadStackArgument(inst),
+
             .ldr_register => try emit.mirLoadStoreRegisterRegister(inst),
             .ldrb_register => try emit.mirLoadStoreRegisterRegister(inst),
             .ldrh_register => try emit.mirLoadStoreRegisterRegister(inst),
@@ -920,6 +935,55 @@ fn mirLoadStoreRegisterPair(emit: *Emit, inst: Mir.Inst.Index) !void {
     }
 }
 
+fn mirLoadStackArgument(emit: *Emit, inst: Mir.Inst.Index) !void {
+    const tag = emit.mir.instructions.items(.tag)[inst];
+    const load_store_stack = emit.mir.instructions.items(.data)[inst].load_store_stack;
+    const rt = load_store_stack.rt;
+
+    const raw_offset = emit.stack_size + emit.prologue_stack_space - load_store_stack.offset;
+    const offset = switch (tag) {
+        .ldrb_stack_argument, .ldrsb_stack_argument => blk: {
+            if (math.cast(u12, raw_offset)) |imm| {
+                break :blk Instruction.LoadStoreOffset.imm(imm);
+            } else {
+                return emit.fail("TODO load stack argument byte with larger offset", .{});
+            }
+        },
+        .ldrh_stack_argument, .ldrsh_stack_argument => blk: {
+            assert(std.mem.isAlignedGeneric(u32, raw_offset, 2)); // misaligned stack entry
+            if (math.cast(u12, @divExact(raw_offset, 2))) |imm| {
+                break :blk Instruction.LoadStoreOffset.imm(imm);
+            } else {
+                return emit.fail("TODO load stack argument halfword with larger offset", .{});
+            }
+        },
+        .ldr_stack_argument => blk: {
+            const alignment: u32 = switch (rt.size()) {
+                32 => 4,
+                64 => 8,
+                else => unreachable,
+            };
+
+            assert(std.mem.isAlignedGeneric(u32, raw_offset, alignment)); // misaligned stack entry
+            if (math.cast(u12, @divExact(raw_offset, alignment))) |imm| {
+                break :blk Instruction.LoadStoreOffset.imm(imm);
+            } else {
+                return emit.fail("TODO load stack argument with larger offset", .{});
+            }
+        },
+        else => unreachable,
+    };
+
+    switch (tag) {
+        .ldr_stack_argument => try emit.writeInstruction(Instruction.ldr(rt, .sp, offset)),
+        .ldrb_stack_argument => try emit.writeInstruction(Instruction.ldrb(rt, .sp, offset)),
+        .ldrh_stack_argument => try emit.writeInstruction(Instruction.ldrh(rt, .sp, offset)),
+        .ldrsb_stack_argument => try emit.writeInstruction(Instruction.ldrsb(rt, .sp, offset)),
+        .ldrsh_stack_argument => try emit.writeInstruction(Instruction.ldrsh(rt, .sp, offset)),
+        else => unreachable,
+    }
+}
+
 fn mirLoadStoreStack(emit: *Emit, inst: Mir.Inst.Index) !void {
     const tag = emit.mir.instructions.items(.tag)[inst];
     const load_store_stack = emit.mir.instructions.items(.data)[inst].load_store_stack;
diff --git a/src/arch/aarch64/Mir.zig b/src/arch/aarch64/Mir.zig
index 2fef069f7acdd269a9e2464508fec9a6f520bfe1..6242026b66c11ff19cf0740a0ec8e5a96766ad05 100644
--- a/src/arch/aarch64/Mir.zig
+++ b/src/arch/aarch64/Mir.zig
@@ -94,18 +94,24 @@ pub const Inst = struct {
         ldp,
         /// Pseudo-instruction: Load from stack
         ldr_stack,
+        /// Pseudo-instruction: Load from stack argument
+        ldr_stack_argument,
         /// Load Register (immediate)
         ldr_immediate,
         /// Load Register (register)
         ldr_register,
         /// Pseudo-instruction: Load byte from stack
         ldrb_stack,
+        /// Pseudo-instruction: Load byte from stack argument
+        ldrb_stack_argument,
         /// Load Register Byte (immediate)
         ldrb_immediate,
         /// Load Register Byte (register)
         ldrb_register,
         /// Pseudo-instruction: Load halfword from stack
         ldrh_stack,
+        /// Pseudo-instruction: Load halfword from stack argument
+        ldrh_stack_argument,
         /// Load Register Halfword (immediate)
         ldrh_immediate,
         /// Load Register Halfword (register)
@@ -114,10 +120,14 @@ pub const Inst = struct {
         ldrsb_immediate,
         /// Pseudo-instruction: Load signed byte from stack
         ldrsb_stack,
+        /// Pseudo-instruction: Load signed byte from stack argument
+        ldrsb_stack_argument,
         /// Load Register Signed Halfword (immediate)
         ldrsh_immediate,
         /// Pseudo-instruction: Load signed halfword from stack
         ldrsh_stack,
+        /// Pseudo-instruction: Load signed halfword from stack argument
+        ldrsh_stack_argument,
         /// Load Register Signed Word (immediate)
         ldrsw_immediate,
         /// Logical Shift Left (immediate)
-- 
2.54.0


From 65b3c27f2457f3d957d83edf13e20e41e84f6dd4 Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Tue, 2 Aug 2022 21:04:54 +0200
Subject: [PATCH 010/290] stage2 AArch64: all arguments passed via stack from
 now on

Only in the Undefined calling convention, not in other calling
conventions
---
 src/arch/aarch64/CodeGen.zig | 142 +++++++++++++++++++++--------------
 src/arch/aarch64/Emit.zig    |  65 +++++++++-------
 src/arch/aarch64/Mir.zig     |   2 +
 3 files changed, 128 insertions(+), 81 deletions(-)

diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig
index 63be9a2220729ac62f8400020a144740f9c1758a..f3a6ad84edcb325445f025733567c39c6c703441 100644
--- a/src/arch/aarch64/CodeGen.zig
+++ b/src/arch/aarch64/CodeGen.zig
@@ -340,7 +340,7 @@ pub fn generate(
         .prev_di_line = module_fn.lbrace_line,
         .prev_di_column = module_fn.lbrace_column,
         .stack_size = mem.alignForwardGeneric(u32, function.max_end_stack, function.stack_align),
-        .prologue_stack_space = call_info.stack_byte_count + function.saved_regs_stack_space,
+        .saved_regs_stack_space = function.saved_regs_stack_space,
     };
     defer emit.deinit();
 
@@ -2317,6 +2317,9 @@ fn errUnionErr(self: *Self, error_union_mcv: MCValue, error_union_ty: Type) !MCV
     const err_offset = @intCast(u32, errUnionErrorOffset(payload_ty, self.target.*));
     switch (error_union_mcv) {
         .register => return self.fail("TODO errUnionErr for registers", .{}),
+        .stack_argument_offset => |off| {
+            return MCValue{ .stack_argument_offset = off + err_offset };
+        },
         .stack_offset => |off| {
             return MCValue{ .stack_offset = off - err_offset };
         },
@@ -2351,6 +2354,9 @@ fn errUnionPayload(self: *Self, error_union_mcv: MCValue, error_union_ty: Type)
     const payload_offset = @intCast(u32, errUnionPayloadOffset(payload_ty, self.target.*));
     switch (error_union_mcv) {
         .register => return self.fail("TODO errUnionPayload for registers", .{}),
+        .stack_argument_offset => |off| {
+            return MCValue{ .stack_argument_offset = off + payload_offset };
+        },
         .stack_offset => |off| {
             return MCValue{ .stack_offset = off - payload_offset };
         },
@@ -3016,7 +3022,7 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
         switch (mcv) {
             .dead, .unreach => unreachable,
             .stack_argument_offset => |off| {
-                break :result MCValue{ .stack_argument_offset = off - struct_field_offset };
+                break :result MCValue{ .stack_argument_offset = off + struct_field_offset };
             },
             .stack_offset => |off| {
                 break :result MCValue{ .stack_offset = off - struct_field_offset };
@@ -3150,6 +3156,9 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallOptions.
     // saving compare flags may require a new caller-saved register
     try self.spillCompareFlagsIfOccupied();
 
+    // Make space for the arguments passed via the stack
+    self.max_end_stack += info.stack_byte_count;
+
     for (info.args) |mc_arg, arg_i| {
         const arg = args[arg_i];
         const arg_ty = self.air.typeOf(arg);
@@ -3164,7 +3173,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallOptions.
             .stack_offset => unreachable,
             .stack_argument_offset => |offset| try self.genSetStackArgument(
                 arg_ty,
-                info.stack_byte_count - offset,
+                offset,
                 arg_mcv,
             ),
             else => unreachable,
@@ -3642,40 +3651,14 @@ fn isNonNull(self: *Self, operand: MCValue) !MCValue {
 
 fn isErr(self: *Self, ty: Type, operand: MCValue) !MCValue {
     const error_type = ty.errorUnionSet();
-    const payload_type = ty.errorUnionPayload();
+    const error_int_type = Type.initTag(.u16);
 
     if (error_type.errorSetIsEmpty()) {
         return MCValue{ .immediate = 0 }; // always false
     }
 
-    const err_off = errUnionErrorOffset(payload_type, self.target.*);
-    switch (operand) {
-        .stack_offset => |off| {
-            const offset = off - @intCast(u32, err_off);
-            const tmp_reg = try self.copyToTmpRegister(Type.anyerror, .{ .stack_offset = offset });
-            _ = try self.addInst(.{
-                .tag = .cmp_immediate,
-                .data = .{ .r_imm12_sh = .{
-                    .rn = tmp_reg,
-                    .imm12 = 0,
-                } },
-            });
-        },
-        .register => |reg| {
-            if (err_off > 0 or payload_type.hasRuntimeBitsIgnoreComptime()) {
-                return self.fail("TODO implement isErr for register operand with payload bits", .{});
-            }
-            _ = try self.addInst(.{
-                .tag = .cmp_immediate,
-                .data = .{ .r_imm12_sh = .{
-                    .rn = reg,
-                    .imm12 = 0,
-                } },
-            });
-        },
-        else => return self.fail("TODO implement isErr for {}", .{operand}),
-    }
-
+    const error_mcv = try self.errUnionErr(operand, ty);
+    _ = try self.binOp(.cmp_eq, error_mcv, .{ .immediate = 0 }, error_int_type, error_int_type, null);
     return MCValue{ .condition_flags = .hi };
 }
 
@@ -4174,6 +4157,15 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
                         // sub src_reg, fp, #off
                         try self.genSetReg(ptr_ty, src_reg, .{ .ptr_stack_offset = off });
                     },
+                    .stack_argument_offset => |off| {
+                        _ = try self.addInst(.{
+                            .tag = .ldr_ptr_stack_argument,
+                            .data = .{ .load_store_stack = .{
+                                .rt = src_reg,
+                                .offset = off,
+                            } },
+                        });
+                    },
                     .memory => |addr| try self.genSetReg(Type.usize, src_reg, .{ .immediate = addr }),
                     .got_load,
                     .direct_load,
@@ -4433,7 +4425,7 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
             }
         },
         .register_with_overflow => {
-            return self.fail("TODO implement genSetStack {}", .{mcv});
+            return self.fail("TODO implement genSetStackArgument {}", .{mcv});
         },
         .got_load,
         .direct_load,
@@ -4469,6 +4461,15 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
                         // sub src_reg, fp, #off
                         try self.genSetReg(ptr_ty, src_reg, .{ .ptr_stack_offset = off });
                     },
+                    .stack_argument_offset => |off| {
+                        _ = try self.addInst(.{
+                            .tag = .ldr_ptr_stack_argument,
+                            .data = .{ .load_store_stack = .{
+                                .rt = src_reg,
+                                .offset = off,
+                            } },
+                        });
+                    },
                     .memory => |addr| try self.genSetReg(ptr_ty, src_reg, .{ .immediate = @intCast(u32, addr) }),
                     .got_load,
                     .direct_load,
@@ -4490,7 +4491,6 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
                             },
                         });
                     },
-                    .stack_argument_offset => return self.fail("TODO load {}", .{mcv}),
                     else => unreachable,
                 }
 
@@ -4989,11 +4989,27 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
             result.stack_align = 1;
             return result;
         },
-        .Unspecified, .C => {
+        .C => {
             // ARM64 Procedure Call Standard
             var ncrn: usize = 0; // Next Core Register Number
             var nsaa: u32 = 0; // Next stacked argument address
 
+            if (ret_ty.zigTypeTag() == .NoReturn) {
+                result.return_value = .{ .unreach = {} };
+            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime() and !ret_ty.isError()) {
+                result.return_value = .{ .none = {} };
+            } else {
+                const ret_ty_size = @intCast(u32, ret_ty.abiSize(self.target.*));
+                if (ret_ty_size == 0) {
+                    assert(ret_ty.isError());
+                    result.return_value = .{ .immediate = 0 };
+                } else if (ret_ty_size <= 8) {
+                    result.return_value = .{ .register = registerAlias(c_abi_int_return_regs[0], ret_ty_size) };
+                } else {
+                    return self.fail("TODO support more return types for ARM backend", .{});
+                }
+            }
+
             for (param_types) |ty, i| {
                 const param_size = @intCast(u32, ty.abiSize(self.target.*));
                 if (param_size == 0) {
@@ -5027,36 +5043,52 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
                         }
                     }
 
-                    nsaa += param_size;
                     result.args[i] = .{ .stack_argument_offset = nsaa };
+                    nsaa += param_size;
                 }
             }
 
             result.stack_byte_count = nsaa;
             result.stack_align = 16;
         },
+        .Unspecified => {
+            if (ret_ty.zigTypeTag() == .NoReturn) {
+                result.return_value = .{ .unreach = {} };
+            } else if (!ret_ty.hasRuntimeBitsIgnoreComptime() and !ret_ty.isError()) {
+                result.return_value = .{ .none = {} };
+            } else {
+                const ret_ty_size = @intCast(u32, ret_ty.abiSize(self.target.*));
+                if (ret_ty_size == 0) {
+                    assert(ret_ty.isError());
+                    result.return_value = .{ .immediate = 0 };
+                } else if (ret_ty_size <= 8) {
+                    result.return_value = .{ .register = registerAlias(c_abi_int_return_regs[0], ret_ty_size) };
+                } else {
+                    return self.fail("TODO support more return types for ARM backend", .{});
+                }
+            }
+
+            var stack_offset: u32 = 0;
+
+            for (param_types) |ty, i| {
+                if (ty.abiSize(self.target.*) > 0) {
+                    const param_size = @intCast(u32, ty.abiSize(self.target.*));
+                    const param_alignment = ty.abiAlignment(self.target.*);
+
+                    stack_offset = std.mem.alignForwardGeneric(u32, stack_offset, param_alignment);
+                    result.args[i] = .{ .stack_argument_offset = stack_offset };
+                    stack_offset += param_size;
+                } else {
+                    result.args[i] = .{ .none = {} };
+                }
+            }
+
+            result.stack_byte_count = stack_offset;
+            result.stack_align = 16;
+        },
         else => return self.fail("TODO implement function parameters for {} on aarch64", .{cc}),
     }
 
-    if (ret_ty.zigTypeTag() == .NoReturn) {
-        result.return_value = .{ .unreach = {} };
-    } else if (!ret_ty.hasRuntimeBitsIgnoreComptime() and !ret_ty.isError()) {
-        result.return_value = .{ .none = {} };
-    } else switch (cc) {
-        .Naked => unreachable,
-        .Unspecified, .C => {
-            const ret_ty_size = @intCast(u32, ret_ty.abiSize(self.target.*));
-            if (ret_ty_size == 0) {
-                assert(ret_ty.isError());
-                result.return_value = .{ .immediate = 0 };
-            } else if (ret_ty_size <= 8) {
-                result.return_value = .{ .register = registerAlias(c_abi_int_return_regs[0], ret_ty_size) };
-            } else {
-                return self.fail("TODO support more return types for ARM backend", .{});
-            }
-        },
-        else => return self.fail("TODO implement function return values for {}", .{cc}),
-    }
     return result;
 }
 
diff --git a/src/arch/aarch64/Emit.zig b/src/arch/aarch64/Emit.zig
index 9320138f65cc93f70bc2201e4f78e08580caa355..1ca198ccd8b11ef322912d50d0f4cf694e2c12fc 100644
--- a/src/arch/aarch64/Emit.zig
+++ b/src/arch/aarch64/Emit.zig
@@ -31,9 +31,9 @@ prev_di_column: u32,
 /// Relative to the beginning of `code`.
 prev_di_pc: usize,
 
-/// The amount of stack space consumed by all stack arguments as well
-/// as the saved callee-saved registers
-prologue_stack_space: u32,
+/// The amount of stack space consumed by the saved callee-saved
+/// registers in bytes
+saved_regs_stack_space: u32,
 
 /// The branch type of every branch
 branch_types: std.AutoHashMapUnmanaged(Mir.Inst.Index, BranchType) = .{},
@@ -158,6 +158,7 @@ pub fn emitMir(
             .strh_stack => try emit.mirLoadStoreStack(inst),
 
             .ldr_stack_argument => try emit.mirLoadStackArgument(inst),
+            .ldr_ptr_stack_argument => try emit.mirLoadStackArgument(inst),
             .ldrb_stack_argument => try emit.mirLoadStackArgument(inst),
             .ldrh_stack_argument => try emit.mirLoadStackArgument(inst),
             .ldrsb_stack_argument => try emit.mirLoadStackArgument(inst),
@@ -940,24 +941,42 @@ fn mirLoadStackArgument(emit: *Emit, inst: Mir.Inst.Index) !void {
     const load_store_stack = emit.mir.instructions.items(.data)[inst].load_store_stack;
     const rt = load_store_stack.rt;
 
-    const raw_offset = emit.stack_size + emit.prologue_stack_space - load_store_stack.offset;
-    const offset = switch (tag) {
-        .ldrb_stack_argument, .ldrsb_stack_argument => blk: {
-            if (math.cast(u12, raw_offset)) |imm| {
-                break :blk Instruction.LoadStoreOffset.imm(imm);
-            } else {
+    const raw_offset = emit.stack_size + emit.saved_regs_stack_space + load_store_stack.offset;
+    switch (tag) {
+        .ldr_ptr_stack_argument => {
+            const offset = if (math.cast(u12, raw_offset)) |imm| imm else {
+                return emit.fail("TODO load stack argument ptr with larger offset", .{});
+            };
+
+            switch (tag) {
+                .ldr_ptr_stack_argument => try emit.writeInstruction(Instruction.add(rt, .sp, offset, false)),
+                else => unreachable,
+            }
+        },
+        .ldrb_stack_argument, .ldrsb_stack_argument => {
+            const offset = if (math.cast(u12, raw_offset)) |imm| Instruction.LoadStoreOffset.imm(imm) else {
                 return emit.fail("TODO load stack argument byte with larger offset", .{});
+            };
+
+            switch (tag) {
+                .ldrb_stack_argument => try emit.writeInstruction(Instruction.ldrb(rt, .sp, offset)),
+                .ldrsb_stack_argument => try emit.writeInstruction(Instruction.ldrsb(rt, .sp, offset)),
+                else => unreachable,
             }
         },
-        .ldrh_stack_argument, .ldrsh_stack_argument => blk: {
+        .ldrh_stack_argument, .ldrsh_stack_argument => {
             assert(std.mem.isAlignedGeneric(u32, raw_offset, 2)); // misaligned stack entry
-            if (math.cast(u12, @divExact(raw_offset, 2))) |imm| {
-                break :blk Instruction.LoadStoreOffset.imm(imm);
-            } else {
+            const offset = if (math.cast(u12, @divExact(raw_offset, 2))) |imm| Instruction.LoadStoreOffset.imm(imm) else {
                 return emit.fail("TODO load stack argument halfword with larger offset", .{});
+            };
+
+            switch (tag) {
+                .ldrh_stack_argument => try emit.writeInstruction(Instruction.ldrh(rt, .sp, offset)),
+                .ldrsh_stack_argument => try emit.writeInstruction(Instruction.ldrsh(rt, .sp, offset)),
+                else => unreachable,
             }
         },
-        .ldr_stack_argument => blk: {
+        .ldr_stack_argument => {
             const alignment: u32 = switch (rt.size()) {
                 32 => 4,
                 64 => 8,
@@ -965,22 +984,16 @@ fn mirLoadStackArgument(emit: *Emit, inst: Mir.Inst.Index) !void {
             };
 
             assert(std.mem.isAlignedGeneric(u32, raw_offset, alignment)); // misaligned stack entry
-            if (math.cast(u12, @divExact(raw_offset, alignment))) |imm| {
-                break :blk Instruction.LoadStoreOffset.imm(imm);
-            } else {
+            const offset = if (math.cast(u12, @divExact(raw_offset, alignment))) |imm| Instruction.LoadStoreOffset.imm(imm) else {
                 return emit.fail("TODO load stack argument with larger offset", .{});
+            };
+
+            switch (tag) {
+                .ldr_stack_argument => try emit.writeInstruction(Instruction.ldr(rt, .sp, offset)),
+                else => unreachable,
             }
         },
         else => unreachable,
-    };
-
-    switch (tag) {
-        .ldr_stack_argument => try emit.writeInstruction(Instruction.ldr(rt, .sp, offset)),
-        .ldrb_stack_argument => try emit.writeInstruction(Instruction.ldrb(rt, .sp, offset)),
-        .ldrh_stack_argument => try emit.writeInstruction(Instruction.ldrh(rt, .sp, offset)),
-        .ldrsb_stack_argument => try emit.writeInstruction(Instruction.ldrsb(rt, .sp, offset)),
-        .ldrsh_stack_argument => try emit.writeInstruction(Instruction.ldrsh(rt, .sp, offset)),
-        else => unreachable,
     }
 }
 
diff --git a/src/arch/aarch64/Mir.zig b/src/arch/aarch64/Mir.zig
index 6242026b66c11ff19cf0740a0ec8e5a96766ad05..c4d6af9db40711d5898ff238a6c52832d71b0e05 100644
--- a/src/arch/aarch64/Mir.zig
+++ b/src/arch/aarch64/Mir.zig
@@ -92,6 +92,8 @@ pub const Inst = struct {
         load_memory_ptr_direct,
         /// Load Pair of Registers
         ldp,
+        /// Pseudo-instruction: Load pointer to stack argument
+        ldr_ptr_stack_argument,
         /// Pseudo-instruction: Load from stack
         ldr_stack,
         /// Pseudo-instruction: Load from stack argument
-- 
2.54.0


From 02738228f24b807c45f9ae7b3b1f3657668aed27 Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Thu, 4 Aug 2022 09:33:04 +0200
Subject: [PATCH 011/290] stage2 AArch64: support returning values by reference

also adds some more support for slices passed as stack arguments
---
 src/arch/aarch64/CodeGen.zig | 153 ++++++++++++++++++++++++++++-------
 1 file changed, 124 insertions(+), 29 deletions(-)

diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig
index f3a6ad84edcb325445f025733567c39c6c703441..c5b71657aa3d44325cb3df5e41ac029044f36125 100644
--- a/src/arch/aarch64/CodeGen.zig
+++ b/src/arch/aarch64/CodeGen.zig
@@ -418,6 +418,23 @@ fn gen(self: *Self) !void {
         // sub sp, sp, #reloc
         const backpatch_reloc = try self.addNop();
 
+        if (self.ret_mcv == .stack_offset) {
+            // The address of where to store the return value is in x0
+            // (or w0 when pointer size is 32 bits). As this register
+            // might get overwritten along the way, save the address
+            // to the stack.
+            const ptr_bits = self.target.cpu.arch.ptrBitWidth();
+            const ptr_bytes = @divExact(ptr_bits, 8);
+            const ret_ptr_reg = registerAlias(.x0, ptr_bytes);
+
+            const stack_offset = mem.alignForwardGeneric(u32, self.next_stack_offset, ptr_bytes) + ptr_bytes;
+            self.next_stack_offset = stack_offset;
+            self.max_end_stack = @maximum(self.max_end_stack, self.next_stack_offset);
+
+            try self.genSetStack(Type.usize, stack_offset, MCValue{ .register = ret_ptr_reg });
+            self.ret_mcv = MCValue{ .stack_offset = stack_offset };
+        }
+
         _ = try self.addInst(.{
             .tag = .dbg_prologue_end,
             .data = .{ .nop = {} },
@@ -2446,21 +2463,28 @@ fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
     return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
 }
 
+fn slicePtr(mcv: MCValue) MCValue {
+    switch (mcv) {
+        .dead, .unreach, .none => unreachable,
+        .register => unreachable, // a slice doesn't fit in one register
+        .stack_argument_offset => |off| {
+            return MCValue{ .stack_argument_offset = off };
+        },
+        .stack_offset => |off| {
+            return MCValue{ .stack_offset = off };
+        },
+        .memory => |addr| {
+            return MCValue{ .memory = addr };
+        },
+        else => unreachable, // invalid MCValue for a slice
+    }
+}
+
 fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
     const ty_op = self.air.instructions.items(.data)[inst].ty_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const mcv = try self.resolveInst(ty_op.operand);
-        switch (mcv) {
-            .dead, .unreach, .none => unreachable,
-            .register => unreachable, // a slice doesn't fit in one register
-            .stack_offset => |off| {
-                break :result MCValue{ .stack_offset = off };
-            },
-            .memory => |addr| {
-                break :result MCValue{ .memory = addr };
-            },
-            else => return self.fail("TODO implement slice_len for {}", .{mcv}),
-        }
+        break :result slicePtr(mcv);
     };
     return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
 }
@@ -2474,6 +2498,9 @@ fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {
         switch (mcv) {
             .dead, .unreach, .none => unreachable,
             .register => unreachable, // a slice doesn't fit in one register
+            .stack_argument_offset => |off| {
+                break :result MCValue{ .stack_argument_offset = off + ptr_bytes };
+            },
             .stack_offset => |off| {
                 break :result MCValue{ .stack_offset = off - ptr_bytes };
             },
@@ -2524,6 +2551,9 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
 
     if (!is_volatile and self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ bin_op.lhs, bin_op.rhs, .none });
     const result: MCValue = result: {
+        const slice_ty = self.air.typeOf(bin_op.lhs);
+        const elem_ty = slice_ty.childType();
+        const elem_size = elem_ty.abiSize(self.target.*);
         const slice_mcv = try self.resolveInst(bin_op.lhs);
 
         // TODO optimize for the case where the index is a constant,
@@ -2531,10 +2561,6 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
         const index_mcv = try self.resolveInst(bin_op.rhs);
         const index_is_register = index_mcv == .register;
 
-        const slice_ty = self.air.typeOf(bin_op.lhs);
-        const elem_ty = slice_ty.childType();
-        const elem_size = elem_ty.abiSize(self.target.*);
-
         var buf: Type.SlicePtrFieldTypeBuffer = undefined;
         const slice_ptr_field_type = slice_ty.slicePtrFieldType(&buf);
 
@@ -2544,15 +2570,17 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
             null;
         defer if (index_lock) |reg| self.register_manager.unlockReg(reg);
 
-        const base_mcv: MCValue = switch (slice_mcv) {
-            .stack_offset => |off| .{ .register = try self.copyToTmpRegister(slice_ptr_field_type, .{ .stack_offset = off }) },
-            else => return self.fail("TODO slice_elem_val when slice is {}", .{slice_mcv}),
-        };
-        const base_lock = self.register_manager.lockRegAssumeUnused(base_mcv.register);
-        defer self.register_manager.unlockReg(base_lock);
+        const base_mcv = slicePtr(slice_mcv);
 
         switch (elem_size) {
             else => {
+                const base_reg = switch (base_mcv) {
+                    .register => |r| r,
+                    else => try self.copyToTmpRegister(slice_ptr_field_type, base_mcv),
+                };
+                const base_reg_lock = self.register_manager.lockRegAssumeUnused(base_reg);
+                defer self.register_manager.unlockReg(base_reg_lock);
+
                 const dest = try self.allocRegOrMem(inst, true);
                 const addr = try self.binOp(.ptr_add, base_mcv, index_mcv, slice_ptr_field_type, Type.usize, null);
                 try self.load(dest, addr, slice_ptr_field_type);
@@ -2567,7 +2595,16 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
 fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) !void {
     const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
     const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
-    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice_elem_ptr for {}", .{self.target.cpu.arch});
+    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
+        const slice_mcv = try self.resolveInst(extra.lhs);
+        const index_mcv = try self.resolveInst(extra.rhs);
+        const base_mcv = slicePtr(slice_mcv);
+
+        const slice_ty = self.air.typeOf(extra.lhs);
+
+        const addr = try self.binOp(.ptr_add, base_mcv, index_mcv, slice_ty, Type.usize, null);
+        break :result addr;
+    };
     return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
 }
 
@@ -3156,6 +3193,28 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallOptions.
     // saving compare flags may require a new caller-saved register
     try self.spillCompareFlagsIfOccupied();
 
+    if (info.return_value == .stack_offset) {
+        log.debug("airCall: return by reference", .{});
+        const ret_ty = fn_ty.fnReturnType();
+        const ret_abi_size = @intCast(u32, ret_ty.abiSize(self.target.*));
+        const ret_abi_align = @intCast(u32, ret_ty.abiAlignment(self.target.*));
+        const stack_offset = try self.allocMem(inst, ret_abi_size, ret_abi_align);
+
+        const ptr_bits = self.target.cpu.arch.ptrBitWidth();
+        const ptr_bytes = @divExact(ptr_bits, 8);
+        const ret_ptr_reg = registerAlias(.x0, ptr_bytes);
+
+        var ptr_ty_payload: Type.Payload.ElemType = .{
+            .base = .{ .tag = .single_mut_pointer },
+            .data = ret_ty,
+        };
+        const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
+        try self.register_manager.getReg(ret_ptr_reg, null);
+        try self.genSetReg(ptr_ty, ret_ptr_reg, .{ .ptr_stack_offset = stack_offset });
+
+        info.return_value = .{ .stack_offset = stack_offset };
+    }
+
     // Make space for the arguments passed via the stack
     self.max_end_stack += info.stack_byte_count;
 
@@ -3319,8 +3378,15 @@ fn airRet(self: *Self, inst: Air.Inst.Index) !void {
         },
         .stack_offset => {
             // Return result by reference
-            // TODO
-            return self.fail("TODO implement airRet for {}", .{self.ret_mcv});
+            //
+            // self.ret_mcv is an address to where this function
+            // should store its result into
+            var ptr_ty_payload: Type.Payload.ElemType = .{
+                .base = .{ .tag = .single_mut_pointer },
+                .data = ret_ty,
+            };
+            const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
+            try self.store(self.ret_mcv, operand, ptr_ty, ret_ty);
         },
         else => unreachable,
     }
@@ -3346,10 +3412,34 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void {
         },
         .stack_offset => {
             // Return result by reference
-            // TODO
-            return self.fail("TODO implement airRetLoad for {}", .{self.ret_mcv});
+            //
+            // self.ret_mcv is an address to where this function
+            // should store its result into
+            //
+            // If the operand is a ret_ptr instruction, we are done
+            // here. Else we need to load the result from the location
+            // pointed to by the operand and store it to the result
+            // location.
+            const op_inst = Air.refToIndex(un_op).?;
+            if (self.air.instructions.items(.tag)[op_inst] != .ret_ptr) {
+                const abi_size = @intCast(u32, ret_ty.abiSize(self.target.*));
+                const abi_align = ret_ty.abiAlignment(self.target.*);
+
+                // This is essentially allocMem without the
+                // instruction tracking
+                if (abi_align > self.stack_align)
+                    self.stack_align = abi_align;
+                // TODO find a free slot instead of always appending
+                const offset = mem.alignForwardGeneric(u32, self.next_stack_offset, abi_align) + abi_size;
+                self.next_stack_offset = offset;
+                self.max_end_stack = @maximum(self.max_end_stack, self.next_stack_offset);
+
+                const tmp_mcv = MCValue{ .stack_offset = offset };
+                try self.load(tmp_mcv, ptr, ptr_ty);
+                try self.store(self.ret_mcv, tmp_mcv, ptr_ty, ret_ty);
+            }
         },
-        else => unreachable,
+        else => unreachable, // invalid return result
     }
 
     try self.exitlude_jump_relocs.append(self.gpa, try self.addNop());
@@ -5062,9 +5152,14 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
                     assert(ret_ty.isError());
                     result.return_value = .{ .immediate = 0 };
                 } else if (ret_ty_size <= 8) {
-                    result.return_value = .{ .register = registerAlias(c_abi_int_return_regs[0], ret_ty_size) };
+                    result.return_value = .{ .register = registerAlias(.x0, ret_ty_size) };
                 } else {
-                    return self.fail("TODO support more return types for ARM backend", .{});
+                    // The result is returned by reference, not by
+                    // value. This means that x0 (or w0 when pointer
+                    // size is 32 bits) will contain the address of
+                    // where this function should write the result
+                    // into.
+                    result.return_value = .{ .stack_offset = 0 };
                 }
             }
 
-- 
2.54.0


From dcb236acf432c1d772b2f7d65074735eeae4c4c2 Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Thu, 4 Aug 2022 17:51:15 +0200
Subject: [PATCH 012/290] stage2 AArch64: memcpy support in store and more
 complete intcast

---
 src/arch/aarch64/CodeGen.zig | 80 +++++++++++++++++++++++++++++++-----
 1 file changed, 70 insertions(+), 10 deletions(-)

diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig
index c5b71657aa3d44325cb3df5e41ac029044f36125..c30b8d97b3a0bffbbc62654c457b41362e197da4 100644
--- a/src/arch/aarch64/CodeGen.zig
+++ b/src/arch/aarch64/CodeGen.zig
@@ -1029,17 +1029,37 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
     if (self.liveness.isUnused(inst))
         return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
 
-    const operand_ty = self.air.typeOf(ty_op.operand);
-    const operand = try self.resolveInst(ty_op.operand);
-    const info_a = operand_ty.intInfo(self.target.*);
-    const info_b = self.air.typeOfIndex(inst).intInfo(self.target.*);
-    if (info_a.signedness != info_b.signedness)
-        return self.fail("TODO gen intcast sign safety in semantic analysis", .{});
+    const operand = ty_op.operand;
+    const operand_mcv = try self.resolveInst(operand);
+    const operand_ty = self.air.typeOf(operand);
+    const operand_info = operand_ty.intInfo(self.target.*);
 
-    if (info_a.bits == info_b.bits)
-        return self.finishAir(inst, operand, .{ ty_op.operand, .none, .none });
+    const dest_ty = self.air.typeOfIndex(inst);
+    const dest_info = dest_ty.intInfo(self.target.*);
 
-    return self.fail("TODO implement intCast for {}", .{self.target.cpu.arch});
+    const result: MCValue = result: {
+        const operand_lock: ?RegisterLock = switch (operand_mcv) {
+            .register => |reg| self.register_manager.lockRegAssumeUnused(reg),
+            else => null,
+        };
+        defer if (operand_lock) |lock| self.register_manager.unlockReg(lock);
+
+        if (dest_info.bits > operand_info.bits) {
+            const dest_mcv = try self.allocRegOrMem(inst, true);
+            try self.setRegOrMem(self.air.typeOfIndex(inst), dest_mcv, operand_mcv);
+            break :result dest_mcv;
+        } else {
+            if (self.reuseOperand(inst, operand, 0, operand_mcv)) {
+                break :result operand_mcv;
+            } else {
+                const dest_mcv = try self.allocRegOrMem(inst, true);
+                try self.setRegOrMem(self.air.typeOfIndex(inst), dest_mcv, operand_mcv);
+                break :result dest_mcv;
+            }
+        }
+    };
+
+    return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
 }
 
 fn truncRegister(
@@ -1065,6 +1085,8 @@ fn truncRegister(
             });
         },
         32, 64 => {
+            assert(dest_reg.size() == operand_reg.size());
+
             _ = try self.addInst(.{
                 .tag = .mov_register,
                 .data = .{ .rr = .{
@@ -2955,6 +2977,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
             defer if (addr_reg_lock) |reg| self.register_manager.unlockReg(reg);
 
             switch (value) {
+                .dead => unreachable,
+                .undef => unreachable,
                 .register => |value_reg| {
                     try self.genStrRegister(value_reg, addr_reg, value_ty);
                 },
@@ -2968,7 +2992,41 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
                         try self.genSetReg(value_ty, tmp_reg, value);
                         try self.store(ptr, .{ .register = tmp_reg }, ptr_ty, value_ty);
                     } else {
-                        return self.fail("TODO implement memcpy", .{});
+                        const regs = try self.register_manager.allocRegs(4, .{ null, null, null, null }, gp);
+                        const regs_locks = self.register_manager.lockRegsAssumeUnused(4, regs);
+                        defer for (regs_locks) |reg| {
+                            self.register_manager.unlockReg(reg);
+                        };
+
+                        const src_reg = addr_reg;
+                        const dst_reg = regs[0];
+                        const len_reg = regs[1];
+                        const count_reg = regs[2];
+                        const tmp_reg = regs[3];
+
+                        switch (value) {
+                            .stack_offset => |off| {
+                                // sub src_reg, fp, #off
+                                try self.genSetReg(ptr_ty, src_reg, .{ .ptr_stack_offset = off });
+                            },
+                            .memory => |addr| try self.genSetReg(Type.usize, src_reg, .{ .immediate = @intCast(u32, addr) }),
+                            .stack_argument_offset => |off| {
+                                _ = try self.addInst(.{
+                                    .tag = .ldr_ptr_stack_argument,
+                                    .data = .{ .load_store_stack = .{
+                                        .rt = src_reg,
+                                        .offset = off,
+                                    } },
+                                });
+                            },
+                            else => return self.fail("TODO store {} to register", .{value}),
+                        }
+
+                        // mov len, #abi_size
+                        try self.genSetReg(Type.usize, len_reg, .{ .immediate = abi_size });
+
+                        // memcpy(src, dst, len)
+                        try self.genInlineMemcpy(src_reg, dst_reg, len_reg, count_reg, tmp_reg);
                     }
                 },
             }
@@ -4359,6 +4417,8 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
             }
         },
         .register => |src_reg| {
+            assert(src_reg.size() == reg.size());
+
             // If the registers are the same, nothing to do.
             if (src_reg.id() == reg.id())
                 return;
-- 
2.54.0


From 8b24c783c5bd417f84beeb2f3736a78c3f595d22 Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Thu, 4 Aug 2022 21:05:11 +0200
Subject: [PATCH 013/290] stage2 AArch64: implement basic integer division

---
 src/arch/aarch64/CodeGen.zig | 130 ++++++++++++++++++++++++-----------
 src/arch/aarch64/Emit.zig    |  12 ++--
 src/arch/aarch64/Mir.zig     |   4 ++
 src/arch/aarch64/bits.zig    |   8 +++
 4 files changed, 109 insertions(+), 45 deletions(-)

diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig
index c30b8d97b3a0bffbbc62654c457b41362e197da4..37c37217098cc7715b315830568e66fb2ab1541a 100644
--- a/src/arch/aarch64/CodeGen.zig
+++ b/src/arch/aarch64/CodeGen.zig
@@ -561,33 +561,38 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
 
         switch (air_tags[inst]) {
             // zig fmt: off
-            .add       => try self.airBinOp(inst, .add),
-            .addwrap   => try self.airBinOp(inst, .addwrap),
-            .sub       => try self.airBinOp(inst, .sub),
-            .subwrap   => try self.airBinOp(inst, .subwrap),
-            .mul       => try self.airBinOp(inst, .mul),
-            .mulwrap   => try self.airBinOp(inst, .mulwrap),
-            .shl       => try self.airBinOp(inst, .shl),
-            .shl_exact => try self.airBinOp(inst, .shl_exact),
-            .bool_and  => try self.airBinOp(inst, .bool_and),
-            .bool_or   => try self.airBinOp(inst, .bool_or),
-            .bit_and   => try self.airBinOp(inst, .bit_and),
-            .bit_or    => try self.airBinOp(inst, .bit_or),
-            .xor       => try self.airBinOp(inst, .xor),
-            .shr       => try self.airBinOp(inst, .shr),
-            .shr_exact => try self.airBinOp(inst, .shr_exact),
+            .add             => try self.airBinOp(inst, .add),
+            .addwrap         => try self.airBinOp(inst, .addwrap),
+            .sub             => try self.airBinOp(inst, .sub),
+            .subwrap         => try self.airBinOp(inst, .subwrap),
+            .mul             => try self.airBinOp(inst, .mul),
+            .mulwrap         => try self.airBinOp(inst, .mulwrap),
+            .shl             => try self.airBinOp(inst, .shl),
+            .shl_exact       => try self.airBinOp(inst, .shl_exact),
+            .bool_and        => try self.airBinOp(inst, .bool_and),
+            .bool_or         => try self.airBinOp(inst, .bool_or),
+            .bit_and         => try self.airBinOp(inst, .bit_and),
+            .bit_or          => try self.airBinOp(inst, .bit_or),
+            .xor             => try self.airBinOp(inst, .xor),
+            .shr             => try self.airBinOp(inst, .shr),
+            .shr_exact       => try self.airBinOp(inst, .shr_exact),
+            .div_float       => try self.airBinOp(inst, .div_float),
+            .div_trunc       => try self.airBinOp(inst, .div_trunc),
+            .div_floor       => try self.airBinOp(inst, .div_floor),
+            .div_exact       => try self.airBinOp(inst, .div_exact),
+            .rem             => try self.airBinOp(inst, .rem),
+            .mod             => try self.airBinOp(inst, .mod),
 
-            .ptr_add => try self.airPtrArithmetic(inst, .ptr_add),
-            .ptr_sub => try self.airPtrArithmetic(inst, .ptr_sub),
+            .ptr_add         => try self.airPtrArithmetic(inst, .ptr_add),
+            .ptr_sub         => try self.airPtrArithmetic(inst, .ptr_sub),
+
+            .min             => try self.airMin(inst),
+            .max             => try self.airMax(inst),
 
             .add_sat         => try self.airAddSat(inst),
             .sub_sat         => try self.airSubSat(inst),
             .mul_sat         => try self.airMulSat(inst),
-            .rem             => try self.airRem(inst),
-            .mod             => try self.airMod(inst),
             .shl_sat         => try self.airShlSat(inst),
-            .min             => try self.airMin(inst),
-            .max             => try self.airMax(inst),
             .slice           => try self.airSlice(inst),
 
             .sqrt,
@@ -612,8 +617,6 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             .mul_with_overflow => try self.airMulWithOverflow(inst),
             .shl_with_overflow => try self.airShlWithOverflow(inst),
 
-            .div_float, .div_trunc, .div_floor, .div_exact => try self.airDiv(inst),
-
             .cmp_lt  => try self.airCmp(inst, .lt),
             .cmp_lte => try self.airCmp(inst, .lte),
             .cmp_eq  => try self.airCmp(inst, .eq),
@@ -1391,6 +1394,8 @@ fn binOpRegister(
         .lsl_register,
         .asr_register,
         .lsr_register,
+        .sdiv,
+        .udiv,
         => .{ .rrr = .{
             .rd = dest_reg,
             .rn = lhs_reg,
@@ -1629,6 +1634,67 @@ fn binOp(
                 else => unreachable,
             }
         },
+        .div_float => {
+            switch (lhs_ty.zigTypeTag()) {
+                .Float => return self.fail("TODO div_float", .{}),
+                .Vector => return self.fail("TODO div_float on vectors", .{}),
+                else => unreachable,
+            }
+        },
+        .div_trunc, .div_floor, .div_exact => {
+            switch (lhs_ty.zigTypeTag()) {
+                .Float => return self.fail("TODO div on floats", .{}),
+                .Vector => return self.fail("TODO div on vectors", .{}),
+                .Int => {
+                    assert(lhs_ty.eql(rhs_ty, mod));
+                    const int_info = lhs_ty.intInfo(self.target.*);
+                    if (int_info.bits <= 64) {
+                        switch (int_info.signedness) {
+                            .signed => {
+                                switch (tag) {
+                                    .div_trunc, .div_exact => {
+                                        // TODO optimize integer division by constants
+                                        return try self.binOpRegister(.sdiv, lhs, rhs, lhs_ty, rhs_ty, metadata);
+                                    },
+                                    .div_floor => return self.fail("TODO div_floor on signed integers", .{}),
+                                    else => unreachable,
+                                }
+                            },
+                            .unsigned => {
+                                // TODO optimize integer division by constants
+                                return try self.binOpRegister(.udiv, lhs, rhs, lhs_ty, rhs_ty, metadata);
+                            },
+                        }
+                    } else {
+                        return self.fail("TODO integer division for ints with bits > 64", .{});
+                    }
+                },
+                else => unreachable,
+            }
+        },
+        .rem, .mod => {
+            switch (lhs_ty.zigTypeTag()) {
+                .Float => return self.fail("TODO rem/mod on floats", .{}),
+                .Vector => return self.fail("TODO rem/mod on vectors", .{}),
+                .Int => {
+                    assert(lhs_ty.eql(rhs_ty, mod));
+                    const int_info = lhs_ty.intInfo(self.target.*);
+                    if (int_info.bits <= 32) {
+                        switch (int_info.signedness) {
+                            .signed => {
+                                return self.fail("TODO rem/mod on signed integers", .{});
+                            },
+                            .unsigned => {
+                                return self.fail("TODO rem/mod on unsigned integers", .{});
+                            },
+                        }
+                    } else {
+                        return self.fail("TODO rem/mod for integers with bits > 64", .{});
+                    }
+                },
+                else => unreachable,
+            }
+        },
         .addwrap,
         .subwrap,
         .mulwrap,
@@ -2300,24 +2366,6 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
     return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
 }
 
-fn airDiv(self: *Self, inst: Air.Inst.Index) !void {
-    const bin_op = self.air.instructions.items(.data)[inst].bin_op;
-    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement div for {}", .{self.target.cpu.arch});
-    return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
-}
-
-fn airRem(self: *Self, inst: Air.Inst.Index) !void {
-    const bin_op = self.air.instructions.items(.data)[inst].bin_op;
-    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement rem for {}", .{self.target.cpu.arch});
-    return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
-}
-
-fn airMod(self: *Self, inst: Air.Inst.Index) !void {
-    const bin_op = self.air.instructions.items(.data)[inst].bin_op;
-    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mod for {}", .{self.target.cpu.arch});
-    return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
-}
-
 fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {
     const bin_op = self.air.instructions.items(.data)[inst].bin_op;
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement shl_sat for {}", .{self.target.cpu.arch});
diff --git a/src/arch/aarch64/Emit.zig b/src/arch/aarch64/Emit.zig
index 1ca198ccd8b11ef322912d50d0f4cf694e2c12fc..ba857302769f3cbb95b675f4310c6c9c4035008d 100644
--- a/src/arch/aarch64/Emit.zig
+++ b/src/arch/aarch64/Emit.zig
@@ -91,9 +91,11 @@ pub fn emitMir(
             .sub_immediate => try emit.mirAddSubtractImmediate(inst),
             .subs_immediate => try emit.mirAddSubtractImmediate(inst),
 
-            .asr_register => try emit.mirShiftRegister(inst),
-            .lsl_register => try emit.mirShiftRegister(inst),
-            .lsr_register => try emit.mirShiftRegister(inst),
+            .asr_register => try emit.mirDataProcessing2Source(inst),
+            .lsl_register => try emit.mirDataProcessing2Source(inst),
+            .lsr_register => try emit.mirDataProcessing2Source(inst),
+            .sdiv => try emit.mirDataProcessing2Source(inst),
+            .udiv => try emit.mirDataProcessing2Source(inst),
 
             .asr_immediate => try emit.mirShiftImmediate(inst),
             .lsl_immediate => try emit.mirShiftImmediate(inst),
@@ -520,7 +522,7 @@ fn mirAddSubtractImmediate(emit: *Emit, inst: Mir.Inst.Index) !void {
     }
 }
 
-fn mirShiftRegister(emit: *Emit, inst: Mir.Inst.Index) !void {
+fn mirDataProcessing2Source(emit: *Emit, inst: Mir.Inst.Index) !void {
     const tag = emit.mir.instructions.items(.tag)[inst];
     const rrr = emit.mir.instructions.items(.data)[inst].rrr;
     const rd = rrr.rd;
@@ -531,6 +533,8 @@ fn mirShiftRegister(emit: *Emit, inst: Mir.Inst.Index) !void {
         .asr_register => try emit.writeInstruction(Instruction.asrRegister(rd, rn, rm)),
         .lsl_register => try emit.writeInstruction(Instruction.lslRegister(rd, rn, rm)),
         .lsr_register => try emit.writeInstruction(Instruction.lsrRegister(rd, rn, rm)),
+        .sdiv => try emit.writeInstruction(Instruction.sdiv(rd, rn, rm)),
+        .udiv => try emit.writeInstruction(Instruction.udiv(rd, rn, rm)),
         else => unreachable,
     }
 }
diff --git a/src/arch/aarch64/Mir.zig b/src/arch/aarch64/Mir.zig
index c4d6af9db40711d5898ff238a6c52832d71b0e05..d1ba38a7792518c47c1998e5007bf6bc44a4adb3 100644
--- a/src/arch/aarch64/Mir.zig
+++ b/src/arch/aarch64/Mir.zig
@@ -164,6 +164,8 @@ pub const Inst = struct {
         ret,
         /// Signed bitfield extract
         sbfx,
+        /// Signed divide
+        sdiv,
         /// Signed multiply high
         smulh,
         /// Signed multiply long
@@ -212,6 +214,8 @@ pub const Inst = struct {
         tst_immediate,
         /// Unsigned bitfield extract
         ubfx,
+        /// Unsigned divide
+        udiv,
         /// Unsigned multiply high
         umulh,
         /// Unsigned multiply long
diff --git a/src/arch/aarch64/bits.zig b/src/arch/aarch64/bits.zig
index a3f5fbac510d499913df33c8799ea3019114652d..ad45661b70d0bcbbc872c774d042ebe413ec2099 100644
--- a/src/arch/aarch64/bits.zig
+++ b/src/arch/aarch64/bits.zig
@@ -1698,6 +1698,14 @@ pub const Instruction = union(enum) {
 
     // Data processing (2 source)
 
+    pub fn udiv(rd: Register, rn: Register, rm: Register) Instruction {
+        return dataProcessing2Source(0b0, 0b000010, rd, rn, rm);
+    }
+
+    pub fn sdiv(rd: Register, rn: Register, rm: Register) Instruction {
+        return dataProcessing2Source(0b0, 0b000011, rd, rn, rm);
+    }
+
     pub fn lslv(rd: Register, rn: Register, rm: Register) Instruction {
         return dataProcessing2Source(0b0, 0b001000, rd, rn, rm);
     }
-- 
2.54.0


From 508b90fcfa4749b50618f947e2c3573edcf29713 Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Fri, 5 Aug 2022 15:22:53 +0200
Subject: [PATCH 014/290] stage2 AArch64: implement basic integer rem/mod

---
 src/arch/aarch64/CodeGen.zig | 85 ++++++++++++++++++++++++++++++------
 src/arch/aarch64/Emit.zig    | 30 ++++++++++---
 src/arch/aarch64/Mir.zig     | 11 +++++
 3 files changed, 107 insertions(+), 19 deletions(-)

diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig
index 37c37217098cc7715b315830568e66fb2ab1541a..4a08a91976b38f30234905d0d0404209006eb8fa 100644
--- a/src/arch/aarch64/CodeGen.zig
+++ b/src/arch/aarch64/CodeGen.zig
@@ -1038,6 +1038,7 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
     const operand_info = operand_ty.intInfo(self.target.*);
 
     const dest_ty = self.air.typeOfIndex(inst);
+    const dest_abi_size = dest_ty.abiSize(self.target.*);
     const dest_info = dest_ty.intInfo(self.target.*);
 
     const result: MCValue = result: {
@@ -1047,16 +1048,21 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
         };
         defer if (operand_lock) |lock| self.register_manager.unlockReg(lock);
 
+        const truncated: MCValue = switch (operand_mcv) {
+            .register => |r| MCValue{ .register = registerAlias(r, dest_abi_size) },
+            else => operand_mcv,
+        };
+
         if (dest_info.bits > operand_info.bits) {
             const dest_mcv = try self.allocRegOrMem(inst, true);
-            try self.setRegOrMem(self.air.typeOfIndex(inst), dest_mcv, operand_mcv);
+            try self.setRegOrMem(self.air.typeOfIndex(inst), dest_mcv, truncated);
             break :result dest_mcv;
         } else {
-            if (self.reuseOperand(inst, operand, 0, operand_mcv)) {
-                break :result operand_mcv;
+            if (self.reuseOperand(inst, operand, 0, truncated)) {
+                break :result truncated;
             } else {
                 const dest_mcv = try self.allocRegOrMem(inst, true);
-                try self.setRegOrMem(self.air.typeOfIndex(inst), dest_mcv, operand_mcv);
+                try self.setRegOrMem(self.air.typeOfIndex(inst), dest_mcv, truncated);
                 break :result dest_mcv;
             }
         }
@@ -1145,7 +1151,7 @@ fn trunc(
 
         return MCValue{ .register = dest_reg };
     } else {
-        return self.fail("TODO: truncate to ints > 32 bits", .{});
+        return self.fail("TODO: truncate to ints > 64 bits", .{});
     }
 }
 
@@ -1679,14 +1685,67 @@ fn binOp(
                 .Int => {
                     assert(lhs_ty.eql(rhs_ty, mod));
                     const int_info = lhs_ty.intInfo(self.target.*);
-                    if (int_info.bits <= 32) {
-                        switch (int_info.signedness) {
-                            .signed => {
-                                return self.fail("TODO rem/mod on signed integers", .{});
-                            },
-                            .unsigned => {
-                                return self.fail("TODO rem/mod on unsigned integers", .{});
-                            },
+                    if (int_info.bits <= 64) {
+                        if (int_info.signedness == .signed and tag == .mod) {
+                            return self.fail("TODO mod on signed integers", .{});
+                        } else {
+                            const lhs_is_register = lhs == .register;
+                            const rhs_is_register = rhs == .register;
+
+                            const lhs_lock: ?RegisterLock = if (lhs_is_register)
+                                self.register_manager.lockReg(lhs.register)
+                            else
+                                null;
+                            defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
+
+                            const lhs_reg = if (lhs_is_register)
+                                lhs.register
+                            else
+                                try self.register_manager.allocReg(null, gp);
+                            const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
+                            defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
+
+                            const rhs_reg = if (rhs_is_register)
+                                rhs.register
+                            else
+                                try self.register_manager.allocReg(null, gp);
+                            const new_rhs_lock = self.register_manager.lockReg(rhs_reg);
+                            defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
+
+                            const dest_regs = try self.register_manager.allocRegs(2, .{ null, null }, gp);
+                            const dest_regs_locks = self.register_manager.lockRegsAssumeUnused(2, dest_regs);
+                            defer for (dest_regs_locks) |reg| {
+                                self.register_manager.unlockReg(reg);
+                            };
+                            const quotient_reg = dest_regs[0];
+                            const remainder_reg = dest_regs[1];
+
+                            if (!lhs_is_register) try self.genSetReg(lhs_ty, lhs_reg, lhs);
+                            if (!rhs_is_register) try self.genSetReg(rhs_ty, rhs_reg, rhs);
+
+                            _ = try self.addInst(.{
+                                .tag = switch (int_info.signedness) {
+                                    .signed => .sdiv,
+                                    .unsigned => .udiv,
+                                },
+                                .data = .{ .rrr = .{
+                                    .rd = quotient_reg,
+                                    .rn = lhs_reg,
+                                    .rm = rhs_reg,
+                                } },
+                            });
+
+                            _ = try self.addInst(.{
+                                .tag = .msub,
+                                .data = .{ .rrrr = .{
+                                    .rd = remainder_reg,
+                                    .rn = quotient_reg,
+                                    .rm = rhs_reg,
+                                    .ra = lhs_reg,
+                                } },
+                            });
+
+                            return MCValue{ .register = remainder_reg };
                         }
                     } else {
                         return self.fail("TODO rem/mod for integers with bits > 64", .{});
diff --git a/src/arch/aarch64/Emit.zig b/src/arch/aarch64/Emit.zig
index ba857302769f3cbb95b675f4310c6c9c4035008d..8abc083a1eecf1f334243d4c104a3eedfb494e1a 100644
--- a/src/arch/aarch64/Emit.zig
+++ b/src/arch/aarch64/Emit.zig
@@ -190,6 +190,7 @@ pub fn emitMir(
             .movk => try emit.mirMoveWideImmediate(inst),
             .movz => try emit.mirMoveWideImmediate(inst),
 
+            .msub => try emit.mirDataProcessing3Source(inst),
             .mul => try emit.mirDataProcessing3Source(inst),
             .smulh => try emit.mirDataProcessing3Source(inst),
             .smull => try emit.mirDataProcessing3Source(inst),
@@ -1140,14 +1141,31 @@ fn mirMoveWideImmediate(emit: *Emit, inst: Mir.Inst.Index) !void {
 
 fn mirDataProcessing3Source(emit: *Emit, inst: Mir.Inst.Index) !void {
     const tag = emit.mir.instructions.items(.tag)[inst];
-    const rrr = emit.mir.instructions.items(.data)[inst].rrr;
 
     switch (tag) {
-        .mul => try emit.writeInstruction(Instruction.mul(rrr.rd, rrr.rn, rrr.rm)),
-        .smulh => try emit.writeInstruction(Instruction.smulh(rrr.rd, rrr.rn, rrr.rm)),
-        .smull => try emit.writeInstruction(Instruction.smull(rrr.rd, rrr.rn, rrr.rm)),
-        .umulh => try emit.writeInstruction(Instruction.umulh(rrr.rd, rrr.rn, rrr.rm)),
-        .umull => try emit.writeInstruction(Instruction.umull(rrr.rd, rrr.rn, rrr.rm)),
+        .mul,
+        .smulh,
+        .smull,
+        .umulh,
+        .umull,
+        => {
+            const rrr = emit.mir.instructions.items(.data)[inst].rrr;
+            switch (tag) {
+                .mul => try emit.writeInstruction(Instruction.mul(rrr.rd, rrr.rn, rrr.rm)),
+                .smulh => try emit.writeInstruction(Instruction.smulh(rrr.rd, rrr.rn, rrr.rm)),
+                .smull => try emit.writeInstruction(Instruction.smull(rrr.rd, rrr.rn, rrr.rm)),
+                .umulh => try emit.writeInstruction(Instruction.umulh(rrr.rd, rrr.rn, rrr.rm)),
+                .umull => try emit.writeInstruction(Instruction.umull(rrr.rd, rrr.rn, rrr.rm)),
+                else => unreachable,
+            }
+        },
+        .msub => {
+            const rrrr = emit.mir.instructions.items(.data)[inst].rrrr;
+            switch (tag) {
+                .msub => try emit.writeInstruction(Instruction.msub(rrrr.rd, rrrr.rn, rrrr.rm, rrrr.ra)),
+                else => unreachable,
+            }
+        },
         else => unreachable,
     }
 }
diff --git a/src/arch/aarch64/Mir.zig b/src/arch/aarch64/Mir.zig
index d1ba38a7792518c47c1998e5007bf6bc44a4adb3..00537e0e38ed97864df1b61511bc1b38819f4397 100644
--- a/src/arch/aarch64/Mir.zig
+++ b/src/arch/aarch64/Mir.zig
@@ -148,6 +148,8 @@ pub const Inst = struct {
         movk,
         /// Move wide with zero
         movz,
+        /// Multiply-subtract
+        msub,
         /// Multiply
         mul,
         /// Bitwise NOT
@@ -446,6 +448,15 @@ pub const Inst = struct {
             rn: Register,
             offset: bits.Instruction.LoadStorePairOffset,
         },
+        /// Four registers
+        ///
+        /// Used by e.g. msub
+        rrrr: struct {
+            rd: Register,
+            rn: Register,
+            rm: Register,
+            ra: Register,
+        },
         /// Debug info: line and column
         ///
         /// Used by e.g. dbg_line
-- 
2.54.0


From f46c80b267396d02b5008bf8c426e0eb886a05d2 Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Fri, 5 Aug 2022 19:59:26 +0200
Subject: [PATCH 015/290] stage2 AArch64: improve correctness of register
 aliases

Also implements ptr_elem_ptr
---
 src/arch/aarch64/CodeGen.zig | 83 ++++++++++++++++++++++++++++++------
 1 file changed, 69 insertions(+), 14 deletions(-)

diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig
index 4a08a91976b38f30234905d0d0404209006eb8fa..ba53c2e757b8f0d85a4d8a1d3535e464b75fd77c 100644
--- a/src/arch/aarch64/CodeGen.zig
+++ b/src/arch/aarch64/CodeGen.zig
@@ -1314,6 +1314,9 @@ fn binOpRegister(
     const lhs_is_register = lhs == .register;
     const rhs_is_register = rhs == .register;
 
+    if (lhs_is_register) assert(lhs.register == registerAlias(lhs.register, lhs_ty.abiSize(self.target.*)));
+    if (rhs_is_register) assert(rhs.register == registerAlias(rhs.register, rhs_ty.abiSize(self.target.*)));
+
     const lhs_lock: ?RegisterLock = if (lhs_is_register)
         self.register_manager.lockReg(lhs.register)
     else
@@ -1343,13 +1346,22 @@ fn binOpRegister(
     const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
     defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
 
-    const rhs_reg = if (rhs_is_register) rhs.register else blk: {
+    const rhs_reg = if (rhs_is_register)
+        // lhs is almost always equal to rhs, except in shifts. In
+        // order to guarantee that registers will have equal sizes, we
+        // use the register alias of rhs corresponding to the size of
+        // lhs.
+        registerAlias(rhs.register, lhs_ty.abiSize(self.target.*))
+    else blk: {
         const track_inst: ?Air.Inst.Index = if (metadata) |md| inst: {
             break :inst Air.refToIndex(md.rhs).?;
         } else null;
 
         const raw_reg = try self.register_manager.allocReg(track_inst, gp);
-        const reg = registerAlias(raw_reg, rhs_ty.abiAlignment(self.target.*));
+
+        // Here, we deliberately use lhs as lhs and rhs may differ in
+        // the case of shifts. See comment above.
+        const reg = registerAlias(raw_reg, lhs_ty.abiSize(self.target.*));
 
         if (track_inst) |inst| branch.inst_table.putAssumeCapacity(inst, .{ .register = reg });
 
@@ -1458,6 +1470,8 @@ fn binOpImmediate(
 ) !MCValue {
     const lhs_is_register = lhs == .register;
 
+    if (lhs_is_register) assert(lhs.register == registerAlias(lhs.register, lhs_ty.abiSize(self.target.*)));
+
     const lhs_lock: ?RegisterLock = if (lhs_is_register)
         self.register_manager.lockReg(lhs.register)
     else
@@ -1698,21 +1712,52 @@ fn binOp(
                                 null;
                             defer if (lhs_lock) |reg| self.register_manager.unlockReg(reg);
 
-                            const lhs_reg = if (lhs_is_register)
-                                lhs.register
+                            const rhs_lock: ?RegisterLock = if (rhs_is_register)
+                                self.register_manager.lockReg(rhs.register)
                             else
-                                try self.register_manager.allocReg(null, gp);
+                                null;
+                            defer if (rhs_lock) |reg| self.register_manager.unlockReg(reg);
+
+                            const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
+
+                            const lhs_reg = if (lhs_is_register) lhs.register else blk: {
+                                const track_inst: ?Air.Inst.Index = if (metadata) |md| inst: {
+                                    break :inst Air.refToIndex(md.lhs).?;
+                                } else null;
+
+                                const raw_reg = try self.register_manager.allocReg(track_inst, gp);
+                                const reg = registerAlias(raw_reg, lhs_ty.abiSize(self.target.*));
+
+                                if (track_inst) |inst| branch.inst_table.putAssumeCapacity(inst, .{ .register = reg });
+
+                                break :blk reg;
+                            };
                             const new_lhs_lock = self.register_manager.lockReg(lhs_reg);
                             defer if (new_lhs_lock) |reg| self.register_manager.unlockReg(reg);
 
-                            const rhs_reg = if (rhs_is_register)
-                                rhs.register
-                            else
-                                try self.register_manager.allocReg(null, gp);
+                            const rhs_reg = if (rhs_is_register) rhs.register else blk: {
+                                const track_inst: ?Air.Inst.Index = if (metadata) |md| inst: {
+                                    break :inst Air.refToIndex(md.rhs).?;
+                                } else null;
+
+                                const raw_reg = try self.register_manager.allocReg(track_inst, gp);
+                                const reg = registerAlias(raw_reg, rhs_ty.abiAlignment(self.target.*));
+
+                                if (track_inst) |inst| branch.inst_table.putAssumeCapacity(inst, .{ .register = reg });
+
+                                break :blk reg;
+                            };
                             const new_rhs_lock = self.register_manager.lockReg(rhs_reg);
                             defer if (new_rhs_lock) |reg| self.register_manager.unlockReg(reg);
 
-                            const dest_regs = try self.register_manager.allocRegs(2, .{ null, null }, gp);
+                            const dest_regs: [2]Register = blk: {
+                                const raw_regs = try self.register_manager.allocRegs(2, .{ null, null }, gp);
+                                const abi_size = lhs_ty.abiSize(self.target.*);
+                                break :blk .{
+                                    registerAlias(raw_regs[0], abi_size),
+                                    registerAlias(raw_regs[1], abi_size),
+                                };
+                            };
                             const dest_regs_locks = self.register_manager.lockRegsAssumeUnused(2, dest_regs);
                             defer for (dest_regs_locks) |reg| {
                                 self.register_manager.unlockReg(reg);
@@ -2037,7 +2082,7 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
                         try self.truncRegister(dest_reg, truncated_reg, int_info.signedness, int_info.bits);
 
                         // cmp dest, truncated
-                        _ = try self.binOp(.cmp_eq, dest, .{ .register = truncated_reg }, Type.usize, Type.usize, null);
+                        _ = try self.binOp(.cmp_eq, dest, .{ .register = truncated_reg }, lhs_ty, lhs_ty, null);
 
                         try self.genSetStack(lhs_ty, stack_offset, .{ .register = truncated_reg });
                         try self.genSetStack(Type.initTag(.u1), stack_offset - overflow_bit_offset, .{ .condition_flags = .ne });
@@ -2753,7 +2798,15 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
 fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
     const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
     const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
-    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_elem_ptr for {}", .{self.target.cpu.arch});
+    const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
+        const ptr_mcv = try self.resolveInst(extra.lhs);
+        const index_mcv = try self.resolveInst(extra.rhs);
+
+        const ptr_ty = self.air.typeOf(extra.lhs);
+
+        const addr = try self.binOp(.ptr_add, ptr_mcv, index_mcv, ptr_ty, Type.usize, null);
+        break :result addr;
+    };
     return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
 }
 
@@ -3219,6 +3272,7 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
         const mcv = try self.resolveInst(operand);
         const struct_ty = self.air.typeOf(operand);
+        const struct_field_ty = struct_ty.structFieldType(index);
         const struct_field_offset = @intCast(u32, struct_ty.structFieldOffset(index, self.target.*));
 
         switch (mcv) {
@@ -3250,8 +3304,9 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
                     break :result field;
                 } else {
                     // Copy to new register
-                    const dest_reg = try self.register_manager.allocReg(null, gp);
-                    try self.genSetReg(struct_ty.structFieldType(index), dest_reg, field);
+                    const raw_dest_reg = try self.register_manager.allocReg(null, gp);
+                    const dest_reg = registerAlias(raw_dest_reg, struct_field_ty.abiSize(self.target.*));
+                    try self.genSetReg(struct_field_ty, dest_reg, field);
 
                     break :result MCValue{ .register = dest_reg };
                 }
-- 
2.54.0


From eec2978fac240f6852873bdd9a3ae03b77df6199 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Fri, 5 Aug 2022 16:49:06 +0300
Subject: [PATCH 016/290] Sema: better safety check on switch on corrupt value

---
 src/Sema.zig                                         | 12 ++++++++----
 test/behavior/switch.zig                             |  1 +
 test/cases/safety/switch on corrupted enum value.zig |  7 ++++---
 .../cases/safety/switch on corrupted union value.zig |  7 ++++---
 4 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index ad8879c59918e6d0f52970ce2f7dbb07e1bf0022..d81d2fa72685adc59a389853aa378eb2ce324c79 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -9692,7 +9692,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     }
 
     var final_else_body: []const Air.Inst.Index = &.{};
-    if (special.body.len != 0 or !is_first) {
+    if (special.body.len != 0 or !is_first or case_block.wantSafety()) {
         var wip_captures = try WipCaptureScope.init(gpa, sema.perm_arena, child_block.wip_capture_scope);
         defer wip_captures.deinit();
 
@@ -9715,9 +9715,11 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         } else {
             // We still need a terminator in this block, but we have proven
             // that it is unreachable.
-            // TODO this should be a special safety panic other than unreachable, something
-            // like "panic: switch operand had corrupt value not allowed by the type"
-            try case_block.addUnreachable(src, true);
+            if (case_block.wantSafety()) {
+                _ = try sema.safetyPanic(&case_block, src, .corrupt_switch);
+            } else {
+                _ = try case_block.addNoOp(.unreach);
+            }
         }
 
         try wip_captures.finalize();
@@ -19970,6 +19972,7 @@ pub const PanicId = enum {
     /// TODO make this call `std.builtin.panicInactiveUnionField`.
     inactive_union_field,
     integer_part_out_of_bounds,
+    corrupt_switch,
 };
 
 fn addSafetyCheck(
@@ -20265,6 +20268,7 @@ fn safetyPanic(
         .exact_division_remainder => "exact division produced remainder",
         .inactive_union_field => "access of inactive union field",
         .integer_part_out_of_bounds => "integer part of floating point value out of bounds",
+        .corrupt_switch => "switch on corrupt value",
     };
 
     const msg_inst = msg_inst: {
diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig
index 4e86bcadeb65cf9b5892fb456536100a8c9a15eb..d218fb6bc61f9ebffb3766b3cbd37d5e5cfdab1d 100644
--- a/test/behavior/switch.zig
+++ b/test/behavior/switch.zig
@@ -531,6 +531,7 @@ test "switch with null and T peer types and inferred result location type" {
 test "switch prongs with cases with identical payload types" {
     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_x86_64) return error.SkipZigTest; // TODO
 
     const Union = union(enum) {
         A: usize,
diff --git a/test/cases/safety/switch on corrupted enum value.zig b/test/cases/safety/switch on corrupted enum value.zig
index dc7b9b3abf69f0388bea61b744fe3b0fbf7faa1f..fd94976763c9a61f5bd8126ddbbaf7b42b8cffc6 100644
--- a/test/cases/safety/switch on corrupted enum value.zig	
+++ b/test/cases/safety/switch on corrupted enum value.zig	
@@ -2,7 +2,7 @@ const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "reached unreachable code")) {
+    if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
@@ -10,17 +10,18 @@ pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noretur
 
 const E = enum(u32) {
     X = 1,
+    Y = 2,
 };
 
 pub fn main() !void {
     var e: E = undefined;
     @memset(@ptrCast([*]u8, &e), 0x55, @sizeOf(E));
     switch (e) {
-        .X => @breakpoint(),
+        .X, .Y => @breakpoint(),
     }
     return error.TestFailed;
 }
 
 // run
-// backend=stage1
+// backend=llvm
 // target=native
diff --git a/test/cases/safety/switch on corrupted union value.zig b/test/cases/safety/switch on corrupted union value.zig
index 0fadad3c7e98bdfb63d99ea1f94b381451a8b92e..059f0dc0427fc39b0e3faf560961f504f2096a24 100644
--- a/test/cases/safety/switch on corrupted union value.zig	
+++ b/test/cases/safety/switch on corrupted union value.zig	
@@ -2,7 +2,7 @@ const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "reached unreachable code")) {
+    if (std.mem.eql(u8, message, "switch on corrupt value")) {
         std.process.exit(0);
     }
     std.process.exit(1);
@@ -10,17 +10,18 @@ pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noretur
 
 const U = union(enum(u32)) {
     X: u8,
+    Y: i8,
 };
 
 pub fn main() !void {
     var u: U = undefined;
     @memset(@ptrCast([*]u8, &u), 0x55, @sizeOf(U));
     switch (u) {
-        .X => @breakpoint(),
+        .X, .Y => @breakpoint(),
     }
     return error.TestFailed;
 }
 
 // run
-// backend=stage1
+// backend=llvm
 // target=native
-- 
2.54.0


From 6aa438f0654569c1713a5c0c49b0bdda20d87c0f Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Fri, 5 Aug 2022 16:50:27 +0300
Subject: [PATCH 017/290] Sema: add null pointer slice safety check when len is
 comptime known

---
 src/Sema.zig                                  |  5 +++++
 .../pointer slice sentinel mismatch.zig       |  6 +++---
 .../slice sentinel mismatch - floats.zig      |  6 +++---
 ... sentinel mismatch - optional pointers.zig |  6 +++---
 .../safety/slice slice sentinel mismatch.zig  |  6 +++---
 .../slicing null C pointer runtime len.zig    | 20 +++++++++++++++++++
 test/cases/safety/slicing null C pointer.zig  |  8 +++++---
 7 files changed, 42 insertions(+), 15 deletions(-)
 create mode 100644 test/cases/safety/slicing null C pointer runtime len.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index d81d2fa72685adc59a389853aa378eb2ce324c79..e964c8f76bbfde6c90f87919dfaa835d6cc0d93b 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -25569,6 +25569,11 @@ fn analyzeSlice(
         const new_ptr_val = opt_new_ptr_val orelse {
             const result = try block.addBitCast(return_ty, new_ptr);
             if (block.wantSafety()) {
+                // requirement: slicing C ptr is non-null
+                if (ptr_ptr_child_ty.isCPtr()) {
+                    const is_non_null = try sema.analyzeIsNull(block, ptr_src, ptr, true);
+                    try sema.addSafetyCheck(block, is_non_null, .unwrap_null);
+                }
                 // requirement: result[new_len] == slice_sentinel
                 try sema.panicSentinelMismatch(block, src, slice_sentinel, elem_ty, result, new_len);
             }
diff --git a/test/cases/safety/pointer slice sentinel mismatch.zig b/test/cases/safety/pointer slice sentinel mismatch.zig
index f79e2a860c0628a850bac647ca3aa4edfd4f8ae0..ec25ec2969e0cf41d719115ac31d99fd26a706a2 100644
--- a/test/cases/safety/pointer slice sentinel mismatch.zig	
+++ b/test/cases/safety/pointer slice sentinel mismatch.zig	
@@ -2,14 +2,14 @@ const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "sentinel mismatch")) {
+    if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
         std.process.exit(0);
     }
     std.process.exit(1);
 }
 
 pub fn main() !void {
-    var buf: [4]u8 = undefined;
+    var buf: [4]u8 = .{ 1, 2, 3, 4 };
     const ptr: [*]u8 = &buf;
     const slice = ptr[0..3 :0];
     _ = slice;
@@ -17,5 +17,5 @@ pub fn main() !void {
 }
 
 // run
-// backend=stage1
+// backend=llvm
 // target=native
diff --git a/test/cases/safety/slice sentinel mismatch - floats.zig b/test/cases/safety/slice sentinel mismatch - floats.zig
index 3295c20db3606a0c296bb3d71070fa26fab3e999..3d08872ca747a50d12db306e754782a03b66a5df 100644
--- a/test/cases/safety/slice sentinel mismatch - floats.zig	
+++ b/test/cases/safety/slice sentinel mismatch - floats.zig	
@@ -2,19 +2,19 @@ const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "sentinel mismatch")) {
+    if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.20000004e+00, found 4.0e+00")) {
         std.process.exit(0);
     }
     std.process.exit(1);
 }
 
 pub fn main() !void {
-    var buf: [4]f32 = undefined;
+    var buf: [4]f32 = .{ 1, 2, 3, 4 };
     const slice = buf[0..3 :1.2];
     _ = slice;
     return error.TestFailed;
 }
 
 // run
-// backend=stage1
+// backend=llvm
 // target=native
diff --git a/test/cases/safety/slice sentinel mismatch - optional pointers.zig b/test/cases/safety/slice sentinel mismatch - optional pointers.zig
index ecb82c61d48bc6a5be63161b486550f3b3a8914f..fbc6fcf42802af988c01ba73d93a4f3fcfccbf4c 100644
--- a/test/cases/safety/slice sentinel mismatch - optional pointers.zig	
+++ b/test/cases/safety/slice sentinel mismatch - optional pointers.zig	
@@ -2,19 +2,19 @@ const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "sentinel mismatch")) {
+    if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) {
         std.process.exit(0);
     }
     std.process.exit(1);
 }
 
 pub fn main() !void {
-    var buf: [4]?*i32 = undefined;
+    var buf: [4]?*i32 = .{ @intToPtr(*i32, 4), @intToPtr(*i32, 8), @intToPtr(*i32, 12), @intToPtr(*i32, 16) };
     const slice = buf[0..3 :null];
     _ = slice;
     return error.TestFailed;
 }
 
 // run
-// backend=stage1
+// backend=llvm
 // target=native
diff --git a/test/cases/safety/slice slice sentinel mismatch.zig b/test/cases/safety/slice slice sentinel mismatch.zig
index 13b331a0f4a99960dcaa7f6539eb7c37faa73279..b1bca1a11f0db83d0f5af731075a4a0b35bf2be8 100644
--- a/test/cases/safety/slice slice sentinel mismatch.zig	
+++ b/test/cases/safety/slice slice sentinel mismatch.zig	
@@ -2,18 +2,18 @@ const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "sentinel mismatch")) {
+    if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
         std.process.exit(0);
     }
     std.process.exit(1);
 }
 pub fn main() !void {
-    var buf: [4]u8 = undefined;
+    var buf: [4]u8 = .{ 1, 2, 3, 4 };
     const slice = buf[0..];
     const slice2 = slice[0..3 :0];
     _ = slice2;
     return error.TestFailed;
 }
 // run
-// backend=stage1
+// backend=llvm
 // target=native
diff --git a/test/cases/safety/slicing null C pointer runtime len.zig b/test/cases/safety/slicing null C pointer runtime len.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e45f9855a7f8893455ecafd14841b3ea1e4b767b
--- /dev/null
+++ b/test/cases/safety/slicing null C pointer runtime len.zig	
@@ -0,0 +1,20 @@
+const std = @import("std");
+
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+    _ = stack_trace;
+    if (std.mem.eql(u8, message, "attempt to use null value")) {
+        std.process.exit(0);
+    }
+    std.process.exit(1);
+}
+
+pub fn main() !void {
+    var ptr: [*c]const u32 = null;
+    var len: usize = 3;
+    var slice = ptr[0..len];
+    _ = slice;
+    return error.TestFailed;
+}
+// run
+// backend=llvm
+// target=native
\ No newline at end of file
diff --git a/test/cases/safety/slicing null C pointer.zig b/test/cases/safety/slicing null C pointer.zig
index db8d235c45c8bb7251d27632a707d7779db0e68f..1a77d859241060633b20f10c43c623b107fdf7e3 100644
--- a/test/cases/safety/slicing null C pointer.zig	
+++ b/test/cases/safety/slicing null C pointer.zig	
@@ -1,9 +1,11 @@
 const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
-    _ = message;
     _ = stack_trace;
-    std.process.exit(0);
+    if (std.mem.eql(u8, message, "attempt to use null value")) {
+        std.process.exit(0);
+    }
+    std.process.exit(1);
 }
 
 pub fn main() !void {
@@ -13,5 +15,5 @@ pub fn main() !void {
     return error.TestFailed;
 }
 // run
-// backend=stage1
+// backend=llvm
 // target=native
\ No newline at end of file
-- 
2.54.0


From 5605f6e0e302cbf345a5229ea58aef6757fe139d Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Fri, 5 Aug 2022 17:08:31 +0300
Subject: [PATCH 018/290] Sema: account for sentinel in bounds check

---
 src/Sema.zig                                  | 22 ++++++++++++++++++-
 ...ast []u8 to bigger slice of wrong size.zig | 10 +++++----
 ...mpty slice with sentinel out of bounds.zig |  4 ++--
 ...h sentinel out of bounds - runtime len.zig | 22 +++++++++++++++++++
 .../slice with sentinel out of bounds.zig     |  4 ++--
 5 files changed, 53 insertions(+), 9 deletions(-)
 create mode 100644 test/cases/safety/slice with sentinel out of bounds - runtime len.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index e964c8f76bbfde6c90f87919dfaa835d6cc0d93b..4bfd6ac1c4a1720cdd8ee76e97ef6cc0084e02be 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -25574,6 +25574,22 @@ fn analyzeSlice(
                     const is_non_null = try sema.analyzeIsNull(block, ptr_src, ptr, true);
                     try sema.addSafetyCheck(block, is_non_null, .unwrap_null);
                 }
+
+                if (slice_ty.isSlice()) {
+                    const slice_len_inst = try block.addTyOp(.slice_len, Type.usize, ptr_or_slice);
+                    const actual_len = if (slice_ty.sentinel() == null)
+                        slice_len_inst
+                    else
+                        try sema.analyzeArithmetic(block, .add, slice_len_inst, .one, src, end_src, end_src);
+
+                    const actual_end = if (slice_sentinel != null)
+                        try sema.analyzeArithmetic(block, .add, end, .one, src, end_src, end_src)
+                    else
+                        end;
+
+                    try sema.panicIndexOutOfBounds(block, src, actual_end, actual_len, .cmp_lte);
+                }
+
                 // requirement: result[new_len] == slice_sentinel
                 try sema.panicSentinelMismatch(block, src, slice_sentinel, elem_ty, result, new_len);
             }
@@ -25635,7 +25651,11 @@ fn analyzeSlice(
             break :blk try sema.analyzeArithmetic(block, .add, slice_len_inst, .one, src, end_src, end_src);
         } else null;
         if (opt_len_inst) |len_inst| {
-            try sema.panicIndexOutOfBounds(block, src, end, len_inst, .cmp_lte);
+            const actual_end = if (slice_sentinel != null)
+                try sema.analyzeArithmetic(block, .add, end, .one, src, end_src, end_src)
+            else
+                end;
+            try sema.panicIndexOutOfBounds(block, src, actual_end, len_inst, .cmp_lte);
         }
 
         // requirement: start <= end
diff --git a/test/cases/safety/cast []u8 to bigger slice of wrong size.zig b/test/cases/safety/cast []u8 to bigger slice of wrong size.zig
index 588801b27e3e3913223883439a9050ea56ee9400..6fddb63bee0c83f37dd4b002399ad39367938c50 100644
--- a/test/cases/safety/cast []u8 to bigger slice of wrong size.zig	
+++ b/test/cases/safety/cast []u8 to bigger slice of wrong size.zig	
@@ -1,9 +1,11 @@
 const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
-    _ = message;
     _ = stack_trace;
-    std.process.exit(0);
+    if (std.mem.eql(u8, message, "exact division produced remainder")) {
+        std.process.exit(0);
+    }
+    std.process.exit(1);
 }
 
 pub fn main() !void {
@@ -15,5 +17,5 @@ fn widenSlice(slice: []align(1) const u8) []align(1) const i32 {
     return std.mem.bytesAsSlice(i32, slice);
 }
 // run
-// backend=stage1
-// target=native
\ No newline at end of file
+// backend=llvm
+// target=native
diff --git a/test/cases/safety/empty slice with sentinel out of bounds.zig b/test/cases/safety/empty slice with sentinel out of bounds.zig
index ad8010868a42ed600bb151e1d395b498906da4e5..835b084740c5ed359f778e10a21389ae417ff552 100644
--- a/test/cases/safety/empty slice with sentinel out of bounds.zig	
+++ b/test/cases/safety/empty slice with sentinel out of bounds.zig	
@@ -2,7 +2,7 @@ const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "index out of bounds")) {
+    if (std.mem.eql(u8, message, "attempt to index out of bound: index 1, len 0")) {
         std.process.exit(0);
     }
     std.process.exit(1);
@@ -17,5 +17,5 @@ pub fn main() !void {
 }
 
 // run
-// backend=stage1
+// backend=llvm
 // target=native
diff --git a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fa2e127107c8bd1af1b0fbd0b259461a4e81e366
--- /dev/null
+++ b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig	
@@ -0,0 +1,22 @@
+const std = @import("std");
+
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+    _ = stack_trace;
+    if (std.mem.eql(u8, message, "attempt to index out of bound: index 5, len 4")) {
+        std.process.exit(0);
+    }
+    std.process.exit(1);
+}
+
+pub fn main() !void {
+    var buf = [4]u8{ 'a', 'b', 'c', 0 };
+    const input: []u8 = &buf;
+    var len: usize = 4;
+    const slice = input[0..len :0];
+    _ = slice;
+    return error.TestFailed;
+}
+
+// run
+// backend=llvm
+// target=native
diff --git a/test/cases/safety/slice with sentinel out of bounds.zig b/test/cases/safety/slice with sentinel out of bounds.zig
index 1ca83ea481592fd0b2f4a963db2c1edfedb1516a..3cc8bfb355a459477c1bf7b8e6172bc342376776 100644
--- a/test/cases/safety/slice with sentinel out of bounds.zig	
+++ b/test/cases/safety/slice with sentinel out of bounds.zig	
@@ -2,7 +2,7 @@ const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "index out of bounds")) {
+    if (std.mem.eql(u8, message, "attempt to index out of bound: index 5, len 4")) {
         std.process.exit(0);
     }
     std.process.exit(1);
@@ -17,5 +17,5 @@ pub fn main() !void {
 }
 
 // run
-// backend=stage1
+// backend=llvm
 // target=native
-- 
2.54.0


From 9116e26c1ffb49cf68bebf3af2a019af08474d12 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Fri, 5 Aug 2022 17:36:45 +0300
Subject: [PATCH 019/290] Sema: add null check for implicit casts

---
 src/Sema.zig                                  | 22 +++++++++++++++----
 ...r casting null to non-optional pointer.zig | 10 ++++++---
 ... slicing null C pointer - runtime len.zig} |  2 +-
 test/cases/safety/slicing null C pointer.zig  |  2 +-
 4 files changed, 27 insertions(+), 9 deletions(-)
 rename test/cases/safety/{slicing null C pointer runtime len.zig => slicing null C pointer - runtime len.zig} (96%)

diff --git a/src/Sema.zig b/src/Sema.zig
index 4bfd6ac1c4a1720cdd8ee76e97ef6cc0084e02be..e04190973b4eb0b8f5d4fa2ef73af1aed0bb55bd 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -1577,8 +1577,7 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize)
 
     // st.index = 0;
     const index_field_ptr = try sema.fieldPtr(&err_trace_block, src, st_ptr, "index", src, true);
-    const zero = try sema.addConstant(Type.usize, Value.zero);
-    try sema.storePtr2(&err_trace_block, src, index_field_ptr, src, zero, src, .store);
+    try sema.storePtr2(&err_trace_block, src, index_field_ptr, src, .zero_usize, src, .store);
 
     // @errorReturnTrace() = &st;
     _ = try err_trace_block.addUnOp(.set_err_return_trace, st_ptr);
@@ -17134,7 +17133,7 @@ fn zirAlignCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         const is_aligned = try block.addBinOp(.cmp_eq, remainder, .zero_usize);
         const ok = if (ptr_ty.isSlice()) ok: {
             const len = try sema.analyzeSliceLen(block, ptr_src, ptr);
-            const len_zero = try block.addBinOp(.cmp_eq, len, try sema.addConstant(Type.usize, Value.zero));
+            const len_zero = try block.addBinOp(.cmp_eq, len, .zero_usize);
             break :ok try block.addBinOp(.bit_or, len_zero, is_aligned);
         } else is_aligned;
         try sema.addSafetyCheck(block, ok, .incorrect_alignment);
@@ -21957,7 +21956,6 @@ fn coerceExtra(
                     .ok => {},
                     else => break :src_c_ptr,
                 }
-                // TODO add safety check for null pointer
                 return sema.coerceCompatiblePtrs(block, dest_ty, inst, inst_src);
             }
 
@@ -24430,6 +24428,22 @@ fn coerceCompatiblePtrs(
         return sema.addConstant(dest_ty, val);
     }
     try sema.requireRuntimeBlock(block, inst_src, null);
+    const inst_ty = sema.typeOf(inst);
+    const inst_allows_zero = (inst_ty.zigTypeTag() == .Pointer and inst_ty.ptrAllowsZero()) or true;
+    if (block.wantSafety() and inst_allows_zero and !dest_ty.ptrAllowsZero()) {
+        const actual_ptr = if (inst_ty.isSlice())
+            try sema.analyzeSlicePtr(block, inst_src, inst, inst_ty)
+        else
+            inst;
+        const ptr_int = try block.addUnOp(.ptrtoint, actual_ptr);
+        const is_non_zero = try block.addBinOp(.cmp_neq, ptr_int, .zero_usize);
+        const ok = if (inst_ty.isSlice()) ok: {
+            const len = try sema.analyzeSliceLen(block, inst_src, inst);
+            const len_zero = try block.addBinOp(.cmp_eq, len, .zero_usize);
+            break :ok try block.addBinOp(.bit_or, len_zero, is_non_zero);
+        } else is_non_zero;
+        try sema.addSafetyCheck(block, ok, .cast_to_null);
+    }
     return sema.bitCast(block, dest_ty, inst, inst_src);
 }
 
diff --git a/test/cases/safety/pointer casting null to non-optional pointer.zig b/test/cases/safety/pointer casting null to non-optional pointer.zig
index 0254e002ad0816183cb4489eef743641ab864904..e46b84f7838cc6eed4394d23b0a01daa9890d4af 100644
--- a/test/cases/safety/pointer casting null to non-optional pointer.zig	
+++ b/test/cases/safety/pointer casting null to non-optional pointer.zig	
@@ -1,16 +1,20 @@
 const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
-    _ = message;
     _ = stack_trace;
-    std.process.exit(0);
+    if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
+        std.process.exit(0);
+    }
+    std.process.exit(1);
 }
+
 pub fn main() !void {
     var c_ptr: [*c]u8 = 0;
     var zig_ptr: *u8 = c_ptr;
     _ = zig_ptr;
     return error.TestFailed;
 }
+
 // run
-// backend=stage1
+// backend=llvm
 // target=native
diff --git a/test/cases/safety/slicing null C pointer runtime len.zig b/test/cases/safety/slicing null C pointer - runtime len.zig
similarity index 96%
rename from test/cases/safety/slicing null C pointer runtime len.zig
rename to test/cases/safety/slicing null C pointer - runtime len.zig
index e45f9855a7f8893455ecafd14841b3ea1e4b767b..276725361235ea4dbc1223fa63d362471e4e9324 100644
--- a/test/cases/safety/slicing null C pointer runtime len.zig	
+++ b/test/cases/safety/slicing null C pointer - runtime len.zig	
@@ -17,4 +17,4 @@ pub fn main() !void {
 }
 // run
 // backend=llvm
-// target=native
\ No newline at end of file
+// target=native
diff --git a/test/cases/safety/slicing null C pointer.zig b/test/cases/safety/slicing null C pointer.zig
index 1a77d859241060633b20f10c43c623b107fdf7e3..f5041adae76faef19ac0b6e73a7da1c63a98b12c 100644
--- a/test/cases/safety/slicing null C pointer.zig	
+++ b/test/cases/safety/slicing null C pointer.zig	
@@ -16,4 +16,4 @@ pub fn main() !void {
 }
 // run
 // backend=llvm
-// target=native
\ No newline at end of file
+// target=native
-- 
2.54.0


From 19d5ffc710faa23cd07a6dff23d4afc43c0c7f63 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Fri, 5 Aug 2022 17:47:01 +0300
Subject: [PATCH 020/290] Sema: add safety check for non-power-of-two shift
 amounts

---
 src/Sema.zig                                  | 126 ++++++++++++------
 .../safety/shift left by huge amount.zig      |   2 +-
 .../safety/shift right by huge amount.zig     |   2 +-
 ...ed integer division overflow - vectors.zig |  10 +-
 .../signed integer division overflow.zig      |  10 +-
 5 files changed, 101 insertions(+), 49 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index e04190973b4eb0b8f5d4fa2ef73af1aed0bb55bd..3b672ecd42c7925a9ac698ef97c76b3b36d679b4 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -10227,34 +10227,57 @@ fn zirShl(
     } else rhs;
 
     try sema.requireRuntimeBlock(block, src, runtime_src);
-    if (block.wantSafety() and air_tag == .shl_exact) {
-        const op_ov_tuple_ty = try sema.overflowArithmeticTupleType(lhs_ty);
-        const op_ov = try block.addInst(.{
-            .tag = .shl_with_overflow,
-            .data = .{ .ty_pl = .{
-                .ty = try sema.addType(op_ov_tuple_ty),
-                .payload = try sema.addExtra(Air.Bin{
-                    .lhs = lhs,
-                    .rhs = rhs,
-                }),
-            } },
-        });
-        const ov_bit = try sema.tupleFieldValByIndex(block, src, op_ov, 1, op_ov_tuple_ty);
-        const any_ov_bit = if (lhs_ty.zigTypeTag() == .Vector)
-            try block.addInst(.{
-                .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,
-                .data = .{ .reduce = .{
-                    .operand = ov_bit,
-                    .operation = .Or,
+    if (block.wantSafety()) {
+        const bit_count = scalar_ty.intInfo(target).bits;
+        if (!std.math.isPowerOfTwo(bit_count)) {
+            const bit_count_val = try Value.Tag.int_u64.create(sema.arena, bit_count);
+
+            const ok = if (rhs_ty.zigTypeTag() == .Vector) ok: {
+                const bit_count_inst = try sema.addConstant(rhs_ty, try Value.Tag.repeated.create(sema.arena, bit_count_val));
+                const lt = try block.addCmpVector(rhs, bit_count_inst, .lt, try sema.addType(rhs_ty));
+                break :ok try block.addInst(.{
+                    .tag = .reduce,
+                    .data = .{ .reduce = .{
+                        .operand = lt,
+                        .operation = .And,
+                    } },
+                });
+            } else ok: {
+                const bit_count_inst = try sema.addConstant(rhs_ty, bit_count_val);
+                break :ok try block.addBinOp(.cmp_lt, rhs, bit_count_inst);
+            };
+            try sema.addSafetyCheck(block, ok, .shift_rhs_too_big);
+        }
+
+        if (air_tag == .shl_exact) {
+            const op_ov_tuple_ty = try sema.overflowArithmeticTupleType(lhs_ty);
+            const op_ov = try block.addInst(.{
+                .tag = .shl_with_overflow,
+                .data = .{ .ty_pl = .{
+                    .ty = try sema.addType(op_ov_tuple_ty),
+                    .payload = try sema.addExtra(Air.Bin{
+                        .lhs = lhs,
+                        .rhs = rhs,
+                    }),
                 } },
-            })
-        else
-            ov_bit;
-        const zero_ov = try sema.addConstant(Type.@"u1", Value.zero);
-        const no_ov = try block.addBinOp(.cmp_eq, any_ov_bit, zero_ov);
+            });
+            const ov_bit = try sema.tupleFieldValByIndex(block, src, op_ov, 1, op_ov_tuple_ty);
+            const any_ov_bit = if (lhs_ty.zigTypeTag() == .Vector)
+                try block.addInst(.{
+                    .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,
+                    .data = .{ .reduce = .{
+                        .operand = ov_bit,
+                        .operation = .Or,
+                    } },
+                })
+            else
+                ov_bit;
+            const zero_ov = try sema.addConstant(Type.@"u1", Value.zero);
+            const no_ov = try block.addBinOp(.cmp_eq, any_ov_bit, zero_ov);
 
-        try sema.addSafetyCheck(block, no_ov, .shl_overflow);
-        return sema.tupleFieldValByIndex(block, src, op_ov, 0, op_ov_tuple_ty);
+            try sema.addSafetyCheck(block, no_ov, .shl_overflow);
+            return sema.tupleFieldValByIndex(block, src, op_ov, 0, op_ov_tuple_ty);
+        }
     }
     return block.addBinOp(air_tag, lhs, new_rhs);
 }
@@ -10333,20 +10356,43 @@ fn zirShr(
 
     try sema.requireRuntimeBlock(block, src, runtime_src);
     const result = try block.addBinOp(air_tag, lhs, rhs);
-    if (block.wantSafety() and air_tag == .shr_exact) {
-        const back = try block.addBinOp(.shl, result, rhs);
+    if (block.wantSafety()) {
+        const bit_count = scalar_ty.intInfo(target).bits;
+        if (!std.math.isPowerOfTwo(bit_count)) {
+            const bit_count_val = try Value.Tag.int_u64.create(sema.arena, bit_count);
 
-        const ok = if (rhs_ty.zigTypeTag() == .Vector) ok: {
-            const eql = try block.addCmpVector(lhs, back, .eq, try sema.addType(rhs_ty));
-            break :ok try block.addInst(.{
-                .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,
-                .data = .{ .reduce = .{
-                    .operand = eql,
-                    .operation = .And,
-                } },
-            });
-        } else try block.addBinOp(.cmp_eq, lhs, back);
-        try sema.addSafetyCheck(block, ok, .shr_overflow);
+            const ok = if (rhs_ty.zigTypeTag() == .Vector) ok: {
+                const bit_count_inst = try sema.addConstant(rhs_ty, try Value.Tag.repeated.create(sema.arena, bit_count_val));
+                const lt = try block.addCmpVector(rhs, bit_count_inst, .lt, try sema.addType(rhs_ty));
+                break :ok try block.addInst(.{
+                    .tag = .reduce,
+                    .data = .{ .reduce = .{
+                        .operand = lt,
+                        .operation = .And,
+                    } },
+                });
+            } else ok: {
+                const bit_count_inst = try sema.addConstant(rhs_ty, bit_count_val);
+                break :ok try block.addBinOp(.cmp_lt, rhs, bit_count_inst);
+            };
+            try sema.addSafetyCheck(block, ok, .shift_rhs_too_big);
+        }
+
+        if (air_tag == .shr_exact) {
+            const back = try block.addBinOp(.shl, result, rhs);
+
+            const ok = if (rhs_ty.zigTypeTag() == .Vector) ok: {
+                const eql = try block.addCmpVector(lhs, back, .eq, try sema.addType(rhs_ty));
+                break :ok try block.addInst(.{
+                    .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,
+                    .data = .{ .reduce = .{
+                        .operand = eql,
+                        .operation = .And,
+                    } },
+                });
+            } else try block.addBinOp(.cmp_eq, lhs, back);
+            try sema.addSafetyCheck(block, ok, .shr_overflow);
+        }
     }
     return result;
 }
@@ -19972,6 +20018,7 @@ pub const PanicId = enum {
     inactive_union_field,
     integer_part_out_of_bounds,
     corrupt_switch,
+    shift_rhs_too_big,
 };
 
 fn addSafetyCheck(
@@ -20268,6 +20315,7 @@ fn safetyPanic(
         .inactive_union_field => "access of inactive union field",
         .integer_part_out_of_bounds => "integer part of floating point value out of bounds",
         .corrupt_switch => "switch on corrupt value",
+        .shift_rhs_too_big => "shift amount is greater than the type size",
     };
 
     const msg_inst = msg_inst: {
diff --git a/test/cases/safety/shift left by huge amount.zig b/test/cases/safety/shift left by huge amount.zig
index b1159b7d750fca63b71e3263ef54390a12a9e339..e786a739d6078920123a205aa2aa76ba873ef2f7 100644
--- a/test/cases/safety/shift left by huge amount.zig	
+++ b/test/cases/safety/shift left by huge amount.zig	
@@ -17,5 +17,5 @@ pub fn main() !void {
 }
 
 // run
-// backend=stage1
+// backend=llvm
 // target=native
diff --git a/test/cases/safety/shift right by huge amount.zig b/test/cases/safety/shift right by huge amount.zig
index 2c39011240ac98fe1434999a6b93da22c53146f5..a45b8c24cebfb0ecf181615728a352a8ebf10379 100644
--- a/test/cases/safety/shift right by huge amount.zig	
+++ b/test/cases/safety/shift right by huge amount.zig	
@@ -17,5 +17,5 @@ pub fn main() !void {
 }
 
 // run
-// backend=stage1
+// backend=llvm
 // target=native
diff --git a/test/cases/safety/signed integer division overflow - vectors.zig b/test/cases/safety/signed integer division overflow - vectors.zig
index d59adeb69856fd11a991b0342dac2263c2f3e648..8bc5be0d630ba0bec1b392ca678405fadd8004b4 100644
--- a/test/cases/safety/signed integer division overflow - vectors.zig	
+++ b/test/cases/safety/signed integer division overflow - vectors.zig	
@@ -1,9 +1,11 @@
 const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
-    _ = message;
     _ = stack_trace;
-    std.process.exit(0);
+    if (std.mem.eql(u8, message, "integer overflow")) {
+        std.process.exit(0);
+    }
+    std.process.exit(1);
 }
 
 pub fn main() !void {
@@ -17,5 +19,5 @@ fn div(a: @Vector(4, i16), b: @Vector(4, i16)) @Vector(4, i16) {
     return @divTrunc(a, b);
 }
 // run
-// backend=stage1
-// target=native
\ No newline at end of file
+// backend=llvm
+// target=native
diff --git a/test/cases/safety/signed integer division overflow.zig b/test/cases/safety/signed integer division overflow.zig
index a46f175487835780d77b64e9bfdbd76c82f0fa04..6d17c284dfc7233e8f5332aeae7205c83fe66385 100644
--- a/test/cases/safety/signed integer division overflow.zig	
+++ b/test/cases/safety/signed integer division overflow.zig	
@@ -1,9 +1,11 @@
 const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
-    _ = message;
     _ = stack_trace;
-    std.process.exit(0);
+    if (std.mem.eql(u8, message, "integer overflow")) {
+        std.process.exit(0);
+    }
+    std.process.exit(1);
 }
 
 pub fn main() !void {
@@ -15,5 +17,5 @@ fn div(a: i16, b: i16) i16 {
     return @divTrunc(a, b);
 }
 // run
-// backend=stage1
-// target=native
\ No newline at end of file
+// backend=llvm
+// target=native
-- 
2.54.0


From f46d7304b176cdc77053225943a7d5030dd0d4ee Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Fri, 5 Aug 2022 18:15:31 +0300
Subject: [PATCH 021/290] stage2: add runtime safety for invalid enum values

---
 src/Air.zig                                   |  5 ++
 src/Liveness.zig                              |  2 +
 src/Sema.zig                                  | 15 +++-
 src/arch/aarch64/CodeGen.zig                  |  2 +
 src/arch/arm/CodeGen.zig                      |  2 +
 src/arch/riscv64/CodeGen.zig                  |  2 +
 src/arch/sparc64/CodeGen.zig                  |  2 +
 src/arch/wasm/CodeGen.zig                     |  1 +
 src/arch/x86_64/CodeGen.zig                   |  2 +
 src/codegen/c.zig                             |  2 +
 src/codegen/llvm.zig                          | 87 +++++++++++++++++++
 src/print_air.zig                             |  1 +
 .../@intToEnum - no matching tag value.zig    |  9 +-
 .../@tagName on corrupted enum value.zig      |  3 +-
 .../@tagName on corrupted union value.zig     |  3 +-
 15 files changed, 131 insertions(+), 7 deletions(-)

diff --git a/src/Air.zig b/src/Air.zig
index 302822fc9917339cbf65d56832c23eaf756a792a..c5734278d338458e549749bccf5462b301d28e97 100644
--- a/src/Air.zig
+++ b/src/Air.zig
@@ -660,6 +660,10 @@ pub const Inst = struct {
         /// Uses the `pl_op` field with payload `AtomicRmw`. Operand is `ptr`.
         atomic_rmw,
 
+        /// Returns true if enum tag value has a name.
+        /// Uses the `un_op` field.
+        is_named_enum_value,
+
         /// Given an enum tag value, returns the tag name. The enum type may be non-exhaustive.
         /// Result type is always `[:0]const u8`.
         /// Uses the `un_op` field.
@@ -1057,6 +1061,7 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
         .is_non_err,
         .is_err_ptr,
         .is_non_err_ptr,
+        .is_named_enum_value,
         => return Type.bool,
 
         .const_ty => return Type.type,
diff --git a/src/Liveness.zig b/src/Liveness.zig
index 435075a411773350737f0a7e2ebfe4fad5fe2ebd..748016d5845d689cd69d0d43a39ee05991c08327 100644
--- a/src/Liveness.zig
+++ b/src/Liveness.zig
@@ -291,6 +291,7 @@ pub fn categorizeOperand(
         .is_non_err_ptr,
         .ptrtoint,
         .bool_to_int,
+        .is_named_enum_value,
         .tag_name,
         .error_name,
         .sqrt,
@@ -858,6 +859,7 @@ fn analyzeInst(
         .bool_to_int,
         .ret,
         .ret_load,
+        .is_named_enum_value,
         .tag_name,
         .error_name,
         .sqrt,
diff --git a/src/Sema.zig b/src/Sema.zig
index 3b672ecd42c7925a9ac698ef97c76b3b36d679b4..56e08d081bddbceeeb1d25365933decfca5bac19 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -6933,8 +6933,12 @@ fn zirIntToEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     }
 
     try sema.requireRuntimeBlock(block, src, operand_src);
-    // TODO insert safety check to make sure the value matches an enum value
-    return block.addTyOp(.intcast, dest_ty, operand);
+    const result = try block.addTyOp(.intcast, dest_ty, operand);
+    if (block.wantSafety() and !dest_ty.isNonexhaustiveEnum() and sema.mod.comp.bin_file.options.use_llvm) {
+        const ok = try block.addUnOp(.is_named_enum_value, result);
+        try sema.addSafetyCheck(block, ok, .invalid_enum_value);
+    }
+    return result;
 }
 
 /// Pointer in, pointer out.
@@ -15887,6 +15891,11 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         const field_name = enum_ty.enumFieldName(field_index);
         return sema.addStrLit(block, field_name);
     }
+    try sema.requireRuntimeBlock(block, src, operand_src);
+    if (block.wantSafety() and sema.mod.comp.bin_file.options.use_llvm) {
+        const ok = try block.addUnOp(.is_named_enum_value, casted_operand);
+        try sema.addSafetyCheck(block, ok, .invalid_enum_value);
+    }
     // In case the value is runtime-known, we have an AIR instruction for this instead
     // of trying to lower it in Sema because an optimization pass may result in the operand
     // being comptime-known, which would let us elide the `tag_name` AIR instruction.
@@ -20019,6 +20028,7 @@ pub const PanicId = enum {
     integer_part_out_of_bounds,
     corrupt_switch,
     shift_rhs_too_big,
+    invalid_enum_value,
 };
 
 fn addSafetyCheck(
@@ -20316,6 +20326,7 @@ fn safetyPanic(
         .integer_part_out_of_bounds => "integer part of floating point value out of bounds",
         .corrupt_switch => "switch on corrupt value",
         .shift_rhs_too_big => "shift amount is greater than the type size",
+        .invalid_enum_value => "invalid enum value",
     };
 
     const msg_inst = msg_inst: {
diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig
index a8bafee4f8a632d5e89b8f6b0cadcbf136789af5..369cabeceab1ab4fbe93bbc9cc9a04385f1b4863 100644
--- a/src/arch/aarch64/CodeGen.zig
+++ b/src/arch/aarch64/CodeGen.zig
@@ -753,6 +753,8 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             .float_to_int_optimized,
             => return self.fail("TODO implement optimized float mode", .{}),
 
+            .is_named_enum_value => return self.fail("TODO implement is_named_enum_value", .{}),
+
             .wasm_memory_size => unreachable,
             .wasm_memory_grow => unreachable,
             // zig fmt: on
diff --git a/src/arch/arm/CodeGen.zig b/src/arch/arm/CodeGen.zig
index a603f72d53385a2b9a6d7f379889a8cc1215e8ae..be2891ef6fc0116e15af4099387ebd2d1eafddb6 100644
--- a/src/arch/arm/CodeGen.zig
+++ b/src/arch/arm/CodeGen.zig
@@ -768,6 +768,8 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             .float_to_int_optimized,
             => return self.fail("TODO implement optimized float mode", .{}),
 
+            .is_named_enum_value => return self.fail("TODO implement is_named_enum_value", .{}),
+
             .wasm_memory_size => unreachable,
             .wasm_memory_grow => unreachable,
             // zig fmt: on
diff --git a/src/arch/riscv64/CodeGen.zig b/src/arch/riscv64/CodeGen.zig
index d09c6278b5eac0a655ce17fa9357768b520411aa..a5007928b639e9a785cafc922b6a4d1819ab215e 100644
--- a/src/arch/riscv64/CodeGen.zig
+++ b/src/arch/riscv64/CodeGen.zig
@@ -693,6 +693,8 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             .float_to_int_optimized,
             => return self.fail("TODO implement optimized float mode", .{}),
 
+            .is_named_enum_value => return self.fail("TODO implement is_named_enum_value", .{}),
+
             .wasm_memory_size => unreachable,
             .wasm_memory_grow => unreachable,
             // zig fmt: on
diff --git a/src/arch/sparc64/CodeGen.zig b/src/arch/sparc64/CodeGen.zig
index bc9fc115b2461bfa72630a0b141f11870ad22297..bf834a36d97a2db27df9e7b993800630a5f034e6 100644
--- a/src/arch/sparc64/CodeGen.zig
+++ b/src/arch/sparc64/CodeGen.zig
@@ -705,6 +705,8 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             .float_to_int_optimized,
             => @panic("TODO implement optimized float mode"),
 
+            .is_named_enum_value => @panic("TODO implement is_named_enum_value"),
+
             .wasm_memory_size => unreachable,
             .wasm_memory_grow => unreachable,
             // zig fmt: on
diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index dd9cfba5480b03780a695383d7b24acfce531aeb..ef92361de2c03e2844524904525a1b6a729c9161 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -1621,6 +1621,7 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
         .tag_name,
         .err_return_trace,
         .set_err_return_trace,
+        .is_named_enum_value,
         => |tag| return self.fail("TODO: Implement wasm inst: {s}", .{@tagName(tag)}),
 
         .add_optimized,
diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig
index d59a114e510cf2632f96c672143b72f9f2495fa2..7f7473bc666484c8b6e3f7fce6995a17df75a1ee 100644
--- a/src/arch/x86_64/CodeGen.zig
+++ b/src/arch/x86_64/CodeGen.zig
@@ -775,6 +775,8 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             .float_to_int_optimized,
             => return self.fail("TODO implement optimized float mode", .{}),
 
+            .is_named_enum_value => return self.fail("TODO implement is_named_enum_value", .{}),
+
             .wasm_memory_size => unreachable,
             .wasm_memory_grow => unreachable,
             // zig fmt: on
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 280b7604bfd25e9516b36b7edb0f238e8781e2e5..b746818142a42468e19bebb7763987586fb93892 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -1952,6 +1952,8 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO
             .reduce_optimized,
             .float_to_int_optimized,
             => return f.fail("TODO implement optimized float mode", .{}),
+
+            .is_named_enum_value => return f.fail("TODO: C backend: implement is_named_enum_value", .{}),
             // zig fmt: on
         };
         switch (result_value) {
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 5ea7ffad67a8b28f0d4002572743085d3fb29071..9c3efa18cd9f4ab556922af6f5c7fddb57681205 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -201,6 +201,8 @@ pub const Object = struct {
     /// * it works for functions not all globals.
     /// Therefore, this table keeps track of the mapping.
     decl_map: std.AutoHashMapUnmanaged(Module.Decl.Index, *const llvm.Value),
+    /// Serves the same purpose as `decl_map` but only used for the `is_named_enum_value` instruction.
+    named_enum_map: std.AutoHashMapUnmanaged(Module.Decl.Index, *const llvm.Value),
     /// Maps Zig types to LLVM types. The table memory itself is backed by the GPA of
     /// the compiler, but the Type/Value memory here is backed by `type_map_arena`.
     /// TODO we need to remove entries from this map in response to incremental compilation
@@ -377,6 +379,7 @@ pub const Object = struct {
             .target_data = target_data,
             .target = options.target,
             .decl_map = .{},
+            .named_enum_map = .{},
             .type_map = .{},
             .type_map_arena = std.heap.ArenaAllocator.init(gpa),
             .di_type_map = .{},
@@ -396,6 +399,7 @@ pub const Object = struct {
         self.llvm_module.dispose();
         self.context.dispose();
         self.decl_map.deinit(gpa);
+        self.named_enum_map.deinit(gpa);
         self.type_map.deinit(gpa);
         self.type_map_arena.deinit();
         self.extern_collisions.deinit(gpa);
@@ -4180,6 +4184,8 @@ pub const FuncGen = struct {
                 .union_init     => try self.airUnionInit(inst),
                 .prefetch       => try self.airPrefetch(inst),
 
+                .is_named_enum_value => try self.airIsNamedEnumValue(inst),
+
                 .reduce           => try self.airReduce(inst, false),
                 .reduce_optimized => try self.airReduce(inst, true),
 
@@ -7882,6 +7888,87 @@ pub const FuncGen = struct {
         }
     }
 
+    fn airIsNamedEnumValue(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst)) return null;
+
+        const un_op = self.air.instructions.items(.data)[inst].un_op;
+        const operand = try self.resolveInst(un_op);
+        const enum_ty = self.air.typeOf(un_op);
+
+        const llvm_fn = try self.getIsNamedEnumValueFunction(enum_ty);
+        const params = [_]*const llvm.Value{operand};
+        return self.builder.buildCall(llvm_fn, &params, params.len, .Fast, .Auto, "");
+    }
+
+    fn getIsNamedEnumValueFunction(self: *FuncGen, enum_ty: Type) !*const llvm.Value {
+        const enum_decl = enum_ty.getOwnerDecl();
+
+        // TODO: detect when the type changes and re-emit this function.
+        const gop = try self.dg.object.named_enum_map.getOrPut(self.dg.gpa, enum_decl);
+        if (gop.found_existing) return gop.value_ptr.*;
+        errdefer assert(self.dg.object.named_enum_map.remove(enum_decl));
+
+        var arena_allocator = std.heap.ArenaAllocator.init(self.gpa);
+        defer arena_allocator.deinit();
+        const arena = arena_allocator.allocator();
+
+        const mod = self.dg.module;
+        const llvm_fn_name = try std.fmt.allocPrintZ(arena, "__zig_is_named_enum_value_{s}", .{
+            try mod.declPtr(enum_decl).getFullyQualifiedName(mod),
+        });
+
+        var int_tag_type_buffer: Type.Payload.Bits = undefined;
+        const int_tag_ty = enum_ty.intTagType(&int_tag_type_buffer);
+        const param_types = [_]*const llvm.Type{try self.dg.lowerType(int_tag_ty)};
+
+        const llvm_ret_ty = try self.dg.lowerType(Type.bool);
+        const fn_type = llvm.functionType(llvm_ret_ty, &param_types, param_types.len, .False);
+        const fn_val = self.dg.object.llvm_module.addFunction(llvm_fn_name, fn_type);
+        fn_val.setLinkage(.Internal);
+        fn_val.setFunctionCallConv(.Fast);
+        self.dg.addCommonFnAttributes(fn_val);
+        gop.value_ptr.* = fn_val;
+
+        const prev_block = self.builder.getInsertBlock();
+        const prev_debug_location = self.builder.getCurrentDebugLocation2();
+        defer {
+            self.builder.positionBuilderAtEnd(prev_block);
+            if (self.di_scope != null) {
+                self.builder.setCurrentDebugLocation2(prev_debug_location);
+            }
+        }
+
+        const entry_block = self.dg.context.appendBasicBlock(fn_val, "Entry");
+        self.builder.positionBuilderAtEnd(entry_block);
+        self.builder.clearCurrentDebugLocation();
+
+        const fields = enum_ty.enumFields();
+        const named_block = self.dg.context.appendBasicBlock(fn_val, "Named");
+        const unnamed_block = self.dg.context.appendBasicBlock(fn_val, "Unnamed");
+        const tag_int_value = fn_val.getParam(0);
+        const switch_instr = self.builder.buildSwitch(tag_int_value, unnamed_block, @intCast(c_uint, fields.count()));
+
+        for (fields.keys()) |_, field_index| {
+            const this_tag_int_value = int: {
+                var tag_val_payload: Value.Payload.U32 = .{
+                    .base = .{ .tag = .enum_field_index },
+                    .data = @intCast(u32, field_index),
+                };
+                break :int try self.dg.lowerValue(.{
+                    .ty = enum_ty,
+                    .val = Value.initPayload(&tag_val_payload.base),
+                });
+            };
+            switch_instr.addCase(this_tag_int_value, named_block);
+        }
+        self.builder.positionBuilderAtEnd(named_block);
+        _ = self.builder.buildRet(self.dg.context.intType(1).constInt(1, .False));
+
+        self.builder.positionBuilderAtEnd(unnamed_block);
+        _ = self.builder.buildRet(self.dg.context.intType(1).constInt(0, .False));
+        return fn_val;
+    }
+
     fn airTagName(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
         if (self.liveness.isUnused(inst)) return null;
 
diff --git a/src/print_air.zig b/src/print_air.zig
index ec4a94b420636f287c9f2092a132cb343fcdfc91..23107946f6fee77767631ced2b2032988b1a77ec 100644
--- a/src/print_air.zig
+++ b/src/print_air.zig
@@ -170,6 +170,7 @@ const Writer = struct {
             .bool_to_int,
             .ret,
             .ret_load,
+            .is_named_enum_value,
             .tag_name,
             .error_name,
             .sqrt,
diff --git a/test/cases/safety/@intToEnum - no matching tag value.zig b/test/cases/safety/@intToEnum - no matching tag value.zig
index 79fcf33bc687ac336aa6556843434d2f13b4748e..0e5f401f6da18c2ce92f9837697d6e0bb1c8f8f1 100644
--- a/test/cases/safety/@intToEnum - no matching tag value.zig	
+++ b/test/cases/safety/@intToEnum - no matching tag value.zig	
@@ -1,9 +1,11 @@
 const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
-    _ = message;
     _ = stack_trace;
-    std.process.exit(0);
+    if (std.mem.eql(u8, message, "invalid enum value")) {
+        std.process.exit(0);
+    }
+    std.process.exit(1);
 }
 const Foo = enum {
     A,
@@ -18,6 +20,7 @@ fn bar(a: u2) Foo {
     return @intToEnum(Foo, a);
 }
 fn baz(_: Foo) void {}
+
 // run
-// backend=stage1
+// backend=llvm
 // target=native
diff --git a/test/cases/safety/@tagName on corrupted enum value.zig b/test/cases/safety/@tagName on corrupted enum value.zig
index 507157911ef5a3a9b7a05cd174b294a93ea88c9a..4081d171c48e523c374666ec034a3090e2e10a60 100644
--- a/test/cases/safety/@tagName on corrupted enum value.zig	
+++ b/test/cases/safety/@tagName on corrupted enum value.zig	
@@ -10,6 +10,7 @@ pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noretur
 
 const E = enum(u32) {
     X = 1,
+    Y = 2,
 };
 
 pub fn main() !void {
@@ -21,5 +22,5 @@ pub fn main() !void {
 }
 
 // run
-// backend=stage1
+// backend=llvm
 // target=native
diff --git a/test/cases/safety/@tagName on corrupted union value.zig b/test/cases/safety/@tagName on corrupted union value.zig
index 0c35b5ef3d964763c591af20b88e28b092c9ff48..eb36fab2620c88f6de98f814a186df81290aa7dd 100644
--- a/test/cases/safety/@tagName on corrupted union value.zig	
+++ b/test/cases/safety/@tagName on corrupted union value.zig	
@@ -10,6 +10,7 @@ pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noretur
 
 const U = union(enum(u32)) {
     X: u8,
+    Y: i8,
 };
 
 pub fn main() !void {
@@ -22,5 +23,5 @@ pub fn main() !void {
 }
 
 // run
-// backend=stage1
+// backend=llvm
 // target=native
-- 
2.54.0


From 0daa77bd63a3ef9666d5ccda40929403a4bb3305 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Fri, 5 Aug 2022 20:53:34 +0300
Subject: [PATCH 022/290] stage2 cbe: correct `airIsNull` ptr operand check

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

diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index b746818142a42468e19bebb7763987586fb93892..74e4404bce2bc3fd86ab1daef83f8dc9ff33885a 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -3252,7 +3252,7 @@ fn airIsNull(
 
     const ty = f.air.typeOf(un_op);
     var opt_buf: Type.Payload.ElemType = undefined;
-    const payload_ty = if (ty.zigTypeTag() == .Pointer)
+    const payload_ty = if (deref_suffix[0] != 0)
         ty.childType().optionalChild(&opt_buf)
     else
         ty.optionalChild(&opt_buf);
-- 
2.54.0


From e02f51762fc9d09caf37c78a0383164ff8f46b81 Mon Sep 17 00:00:00 2001
From: Austin Rude <rudedogg@users.noreply.github.com>
Date: Fri, 5 Aug 2022 16:01:57 -0600
Subject: [PATCH 023/290] autodoc: Run through prettier formatter with default
 settings

---
 lib/docs/main.js | 6235 +++++++++++++++++++++++-----------------------
 1 file changed, 3182 insertions(+), 3053 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 064099e1ad23c5675758f98fdd50a387dd997ff0..41a03322d9afb9b9fdfb38c2cdcb3794f0865614 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1,3259 +1,3388 @@
-'use strict';
+"use strict";
 
 var zigAnalysis;
 
-(function() {
-    let domStatus = (document.getElementById("status"));
-    let domSectNav = (document.getElementById("sectNav"));
-    let domListNav = (document.getElementById("listNav"));
-    let domSectMainPkg = (document.getElementById("sectMainPkg"));
-    let domSectPkgs = (document.getElementById("sectPkgs"));
-    let domListPkgs = (document.getElementById("listPkgs"));
-    let domSectTypes = (document.getElementById("sectTypes"));
-    let domListTypes = (document.getElementById("listTypes"));
-    let domSectTests = (document.getElementById("sectTests"));
-    let domListTests = (document.getElementById("listTests"));
-    let domSectNamespaces = (document.getElementById("sectNamespaces"));
-    let domListNamespaces = (document.getElementById("listNamespaces"));
-    let domSectErrSets = (document.getElementById("sectErrSets"));
-    let domListErrSets = (document.getElementById("listErrSets"));
-    let domSectFns = (document.getElementById("sectFns"));
-    let domListFns = (document.getElementById("listFns"));
-    let domSectFields = (document.getElementById("sectFields"));
-    let domListFields = (document.getElementById("listFields"));
-    let domSectGlobalVars = (document.getElementById("sectGlobalVars"));
-    let domListGlobalVars = (document.getElementById("listGlobalVars"));
-    let domSectValues = (document.getElementById("sectValues"));
-    let domListValues = (document.getElementById("listValues"));
-    let domFnProto = (document.getElementById("fnProto"));
-    let domFnProtoCode = (document.getElementById("fnProtoCode"));
-    let domSectParams = (document.getElementById("sectParams"));
-    let domListParams = (document.getElementById("listParams"));
-    let domTldDocs = (document.getElementById("tldDocs"));
-    let domSectFnErrors = (document.getElementById("sectFnErrors"));
-    let domListFnErrors = (document.getElementById("listFnErrors"));
-    let domTableFnErrors =(document.getElementById("tableFnErrors"));
-    let domFnErrorsAnyError = (document.getElementById("fnErrorsAnyError"));
-    let domFnExamples = (document.getElementById("fnExamples"));
-    // let domListFnExamples = (document.getElementById("listFnExamples"));
-    let domFnNoExamples = (document.getElementById("fnNoExamples"));
-    let domDeclNoRef = (document.getElementById("declNoRef"));
-    let domSearch = (document.getElementById("search"));
-    let domSectSearchResults = (document.getElementById("sectSearchResults"));
-
-    let domListSearchResults = (document.getElementById("listSearchResults"));
-    let domSectSearchNoResults = (document.getElementById("sectSearchNoResults"));
-    let domSectInfo = (document.getElementById("sectInfo"));
-    // let domTdTarget = (document.getElementById("tdTarget"));
-    let domPrivDeclsBox = (document.getElementById("privDeclsBox"));
-    let domTdZigVer = (document.getElementById("tdZigVer"));
-    let domHdrName = (document.getElementById("hdrName"));
-    let domHelpModal = (document.getElementById("helpDialog"));
-
-    
-    let searchTimer = null;
-
-    
-    let escapeHtmlReplacements = { "&": "&amp;", '"': "&quot;", "<": "&lt;", ">": "&gt;" };
-
-    let typeKinds = (indexTypeKinds());
-    let typeTypeId =  (findTypeTypeId());
-    let pointerSizeEnum = { One: 0, Many: 1, Slice: 2, C: 3 };
-
-    // for each package, is an array with packages to get to this one
-    let canonPkgPaths = computeCanonicalPackagePaths();
-
-    
-
-    // for each decl, is an array with {declNames, pkgNames} to get to this one
-    
-    let canonDeclPaths = null; // lazy; use getCanonDeclPath
-
-    // for each type, is an array with {declNames, pkgNames} to get to this one
-    
-    let canonTypeDecls = null; // lazy; use getCanonTypeDecl
-
-    
-
-    
-    let curNav = {
-        showPrivDecls: false,
-        // each element is a package name, e.g. @import("a") then within there @import("b")
-        // starting implicitly from root package
-        pkgNames: [],
-        // same as above except actual packages, not names
-        pkgObjs: [],
-        // Each element is a decl name, `a.b.c`, a is 0, b is 1, c is 2, etc.
-        // empty array means refers to the package itself
-        declNames: [],
-        // these will be all types, except the last one may be a type or a decl
-        declObjs: [],
-
-        // (a, b, c, d) comptime call; result is the value the docs refer to
-        callName: null,
-    };
-
-    let curNavSearch = "";
-    let curSearchIndex = -1;
-    let imFeelingLucky = false;
-
-    let rootIsStd = detectRootIsStd();
-
-    // map of decl index to list of non-generic fn indexes
-    // let nodesToFnsMap = indexNodesToFns();
-    // map of decl index to list of comptime fn calls
-    // let nodesToCallsMap = indexNodesToCalls();
-
-    domSearch.addEventListener('keydown', onSearchKeyDown, false);
-    domPrivDeclsBox.addEventListener('change', function() {
-        if (this.checked != curNav.showPrivDecls) {
-            if (this.checked && location.hash.length > 1 && location.hash[1] != '*'){
-                location.hash = "#*" + location.hash.substring(1);
-                return;
-            }
-            if (!this.checked && location.hash.length > 1 && location.hash[1] == '*') {
-                location.hash = "#" + location.hash.substring(2);
-                return;
-            }
-        }
-    }, false);
-    
-    if (location.hash == "") {
-        location.hash = "#root";
-    }
-    
-    window.addEventListener('hashchange', onHashChange, false);
-    window.addEventListener('keydown', onWindowKeyDown, false);
-    onHashChange();
-
-    function renderTitle() {
-        let list = curNav.pkgNames.concat(curNav.declNames);
-        let suffix = " - Zig";
-        if (list.length === 0) {
-            if (rootIsStd) {
-                document.title = "std" + suffix;
+(function () {
+  let domStatus = document.getElementById("status");
+  let domSectNav = document.getElementById("sectNav");
+  let domListNav = document.getElementById("listNav");
+  let domSectMainPkg = document.getElementById("sectMainPkg");
+  let domSectPkgs = document.getElementById("sectPkgs");
+  let domListPkgs = document.getElementById("listPkgs");
+  let domSectTypes = document.getElementById("sectTypes");
+  let domListTypes = document.getElementById("listTypes");
+  let domSectTests = document.getElementById("sectTests");
+  let domListTests = document.getElementById("listTests");
+  let domSectNamespaces = document.getElementById("sectNamespaces");
+  let domListNamespaces = document.getElementById("listNamespaces");
+  let domSectErrSets = document.getElementById("sectErrSets");
+  let domListErrSets = document.getElementById("listErrSets");
+  let domSectFns = document.getElementById("sectFns");
+  let domListFns = document.getElementById("listFns");
+  let domSectFields = document.getElementById("sectFields");
+  let domListFields = document.getElementById("listFields");
+  let domSectGlobalVars = document.getElementById("sectGlobalVars");
+  let domListGlobalVars = document.getElementById("listGlobalVars");
+  let domSectValues = document.getElementById("sectValues");
+  let domListValues = document.getElementById("listValues");
+  let domFnProto = document.getElementById("fnProto");
+  let domFnProtoCode = document.getElementById("fnProtoCode");
+  let domSectParams = document.getElementById("sectParams");
+  let domListParams = document.getElementById("listParams");
+  let domTldDocs = document.getElementById("tldDocs");
+  let domSectFnErrors = document.getElementById("sectFnErrors");
+  let domListFnErrors = document.getElementById("listFnErrors");
+  let domTableFnErrors = document.getElementById("tableFnErrors");
+  let domFnErrorsAnyError = document.getElementById("fnErrorsAnyError");
+  let domFnExamples = document.getElementById("fnExamples");
+  // let domListFnExamples = (document.getElementById("listFnExamples"));
+  let domFnNoExamples = document.getElementById("fnNoExamples");
+  let domDeclNoRef = document.getElementById("declNoRef");
+  let domSearch = document.getElementById("search");
+  let domSectSearchResults = document.getElementById("sectSearchResults");
+
+  let domListSearchResults = document.getElementById("listSearchResults");
+  let domSectSearchNoResults = document.getElementById("sectSearchNoResults");
+  let domSectInfo = document.getElementById("sectInfo");
+  // let domTdTarget = (document.getElementById("tdTarget"));
+  let domPrivDeclsBox = document.getElementById("privDeclsBox");
+  let domTdZigVer = document.getElementById("tdZigVer");
+  let domHdrName = document.getElementById("hdrName");
+  let domHelpModal = document.getElementById("helpDialog");
+
+  let searchTimer = null;
+
+  let escapeHtmlReplacements = {
+    "&": "&amp;",
+    '"': "&quot;",
+    "<": "&lt;",
+    ">": "&gt;",
+  };
+
+  let typeKinds = indexTypeKinds();
+  let typeTypeId = findTypeTypeId();
+  let pointerSizeEnum = { One: 0, Many: 1, Slice: 2, C: 3 };
+
+  // for each package, is an array with packages to get to this one
+  let canonPkgPaths = computeCanonicalPackagePaths();
+
+  // for each decl, is an array with {declNames, pkgNames} to get to this one
+
+  let canonDeclPaths = null; // lazy; use getCanonDeclPath
+
+  // for each type, is an array with {declNames, pkgNames} to get to this one
+
+  let canonTypeDecls = null; // lazy; use getCanonTypeDecl
+
+  let curNav = {
+    showPrivDecls: false,
+    // each element is a package name, e.g. @import("a") then within there @import("b")
+    // starting implicitly from root package
+    pkgNames: [],
+    // same as above except actual packages, not names
+    pkgObjs: [],
+    // Each element is a decl name, `a.b.c`, a is 0, b is 1, c is 2, etc.
+    // empty array means refers to the package itself
+    declNames: [],
+    // these will be all types, except the last one may be a type or a decl
+    declObjs: [],
+
+    // (a, b, c, d) comptime call; result is the value the docs refer to
+    callName: null,
+  };
+
+  let curNavSearch = "";
+  let curSearchIndex = -1;
+  let imFeelingLucky = false;
+
+  let rootIsStd = detectRootIsStd();
+
+  // map of decl index to list of non-generic fn indexes
+  // let nodesToFnsMap = indexNodesToFns();
+  // map of decl index to list of comptime fn calls
+  // let nodesToCallsMap = indexNodesToCalls();
+
+  domSearch.addEventListener("keydown", onSearchKeyDown, false);
+  domPrivDeclsBox.addEventListener(
+    "change",
+    function () {
+      if (this.checked != curNav.showPrivDecls) {
+        if (
+          this.checked &&
+          location.hash.length > 1 &&
+          location.hash[1] != "*"
+        ) {
+          location.hash = "#*" + location.hash.substring(1);
+          return;
+        }
+        if (
+          !this.checked &&
+          location.hash.length > 1 &&
+          location.hash[1] == "*"
+        ) {
+          location.hash = "#" + location.hash.substring(2);
+          return;
+        }
+      }
+    },
+    false
+  );
+
+  if (location.hash == "") {
+    location.hash = "#root";
+  }
+
+  window.addEventListener("hashchange", onHashChange, false);
+  window.addEventListener("keydown", onWindowKeyDown, false);
+  onHashChange();
+
+  function renderTitle() {
+    let list = curNav.pkgNames.concat(curNav.declNames);
+    let suffix = " - Zig";
+    if (list.length === 0) {
+      if (rootIsStd) {
+        document.title = "std" + suffix;
+      } else {
+        document.title = zigAnalysis.params.rootName + suffix;
+      }
+    } else {
+      document.title = list.join(".") + suffix;
+    }
+  }
+
+  function isDecl(x) {
+    return "value" in x;
+  }
+
+  function isType(x) {
+    return "kind" in x && !("value" in x);
+  }
+
+  function isContainerType(x) {
+    return isType(x) && typeKindIsContainer(x.kind);
+  }
+
+  function typeShorthandName(expr) {
+    let resolvedExpr = resolveValue({ expr: expr });
+    if (!("type" in resolvedExpr)) {
+      return null;
+    }
+    let type = zigAnalysis.types[resolvedExpr.type];
+
+    outer: for (let i = 0; i < 10000; i += 1) {
+      switch (type.kind) {
+        case typeKinds.Optional:
+        case typeKinds.Pointer:
+          let child = type.child;
+          let resolvedChild = resolveValue(child);
+          if ("type" in resolvedChild) {
+            type = zigAnalysis.types[resolvedChild.type];
+            continue;
+          } else {
+            return null;
+          }
+        default:
+          break outer;
+      }
+
+      if (i == 9999) throw "Exhausted typeShorthandName quota";
+    }
+
+    let name = undefined;
+    if (type.kind === typeKinds.Struct) {
+      name = "struct";
+    } else if (type.kind === typeKinds.Enum) {
+      name = "enum";
+    } else if (type.kind === typeKinds.Union) {
+      name = "union";
+    } else {
+      console.log("TODO: unhalndled case in typeShortName");
+      return null;
+    }
+
+    return escapeHtml(name);
+  }
+
+  function typeKindIsContainer(typeKind) {
+    return (
+      typeKind === typeKinds.Struct ||
+      typeKind === typeKinds.Union ||
+      typeKind === typeKinds.Enum
+    );
+  }
+
+  function declCanRepresentTypeKind(typeKind) {
+    return typeKind === typeKinds.ErrorSet || typeKindIsContainer(typeKind);
+  }
+
+  //
+  // function findCteInRefPath(path) {
+  //     for (let i = path.length - 1; i >= 0; i -= 1) {
+  //         const ref = path[i];
+  //         if ("string" in ref) continue;
+  //         if ("comptimeExpr" in ref) return ref;
+  //         if ("refPath" in ref) return findCteInRefPath(ref.refPath);
+  //         return null;
+  //     }
+
+  //     return null;
+  // }
+
+  function resolveValue(value) {
+    let i = 0;
+    while (i < 1000) {
+      i += 1;
+
+      if ("refPath" in value.expr) {
+        value = { expr: value.expr.refPath[value.expr.refPath.length - 1] };
+        continue;
+      }
+
+      if ("declRef" in value.expr) {
+        value = zigAnalysis.decls[value.expr.declRef].value;
+        continue;
+      }
+
+      if ("as" in value.expr) {
+        value = {
+          typeRef: zigAnalysis.exprs[value.expr.as.typeRefArg],
+          expr: zigAnalysis.exprs[value.expr.as.exprArg],
+        };
+        continue;
+      }
+
+      return value;
+    }
+    console.assert(false);
+    return {};
+  }
+
+  //    function typeOfDecl(decl){
+  //        return decl.value.typeRef;
+  //
+  //        let i = 0;
+  //        while(i < 1000) {
+  //            i += 1;
+  //            console.assert(isDecl(decl));
+  //            if ("type" in decl.value) {
+  //                return ({ type: typeTypeId });
+  //            }
+  //
+  ////            if ("string" in decl.value) {
+  ////                return ({ type: {
+  ////                  kind: typeKinds.Pointer,
+  ////                  size: pointerSizeEnum.One,
+  ////                  child: });
+  ////            }
+  //
+  //            if ("refPath" in decl.value) {
+  //                decl =  ({
+  //                  value: decl.value.refPath[decl.value.refPath.length -1]
+  //                });
+  //                continue;
+  //            }
+  //
+  //            if ("declRef" in decl.value) {
+  //                decl = zigAnalysis.decls[decl.value.declRef];
+  //                continue;
+  //            }
+  //
+  //            if ("int" in decl.value) {
+  //                return decl.value.int.typeRef;
+  //            }
+  //
+  //            if ("float" in decl.value) {
+  //                return decl.value.float.typeRef;
+  //            }
+  //
+  //            if ("array" in decl.value) {
+  //                return decl.value.array.typeRef;
+  //            }
+  //
+  //            if ("struct" in decl.value) {
+  //                return decl.value.struct.typeRef;
+  //            }
+  //
+  //            if ("comptimeExpr" in decl.value) {
+  //                const cte = zigAnalysis.comptimeExprs[decl.value.comptimeExpr];
+  //                return cte.typeRef;
+  //            }
+  //
+  //            if ("call" in decl.value) {
+  //                const fn_call = zigAnalysis.calls[decl.value.call];
+  //                let fn_decl = undefined;
+  //                if ("declRef" in fn_call.func) {
+  //                    fn_decl = zigAnalysis.decls[fn_call.func.declRef];
+  //                } else if ("refPath" in fn_call.func) {
+  //                    console.assert("declRef" in fn_call.func.refPath[fn_call.func.refPath.length -1]);
+  //                    fn_decl = zigAnalysis.decls[fn_call.func.refPath[fn_call.func.refPath.length -1].declRef];
+  //                } else throw {};
+  //
+  //                const fn_decl_value = resolveValue(fn_decl.value);
+  //                console.assert("type" in fn_decl_value); //TODO handle comptimeExpr
+  //                const fn_type = (zigAnalysis.types[fn_decl_value.type]);
+  //                console.assert(fn_type.kind === typeKinds.Fn);
+  //                return fn_type.ret;
+  //            }
+  //
+  //            if ("void" in decl.value) {
+  //                return ({ type: typeTypeId });
+  //            }
+  //
+  //            if ("bool" in decl.value) {
+  //                return ({ type: typeKinds.Bool });
+  //            }
+  //
+  //            console.log("TODO: handle in `typeOfDecl` more cases: ", decl);
+  //            console.assert(false);
+  //            throw {};
+  //        }
+  //        console.assert(false);
+  //        return ({});
+  //    }
+
+  function render() {
+    domStatus.classList.add("hidden");
+    domFnProto.classList.add("hidden");
+    domSectParams.classList.add("hidden");
+    domTldDocs.classList.add("hidden");
+    domSectMainPkg.classList.add("hidden");
+    domSectPkgs.classList.add("hidden");
+    domSectTypes.classList.add("hidden");
+    domSectTests.classList.add("hidden");
+    domSectNamespaces.classList.add("hidden");
+    domSectErrSets.classList.add("hidden");
+    domSectFns.classList.add("hidden");
+    domSectFields.classList.add("hidden");
+    domSectSearchResults.classList.add("hidden");
+    domSectSearchNoResults.classList.add("hidden");
+    domSectInfo.classList.add("hidden");
+    domHdrName.classList.add("hidden");
+    domSectNav.classList.add("hidden");
+    domSectFnErrors.classList.add("hidden");
+    domFnExamples.classList.add("hidden");
+    domFnNoExamples.classList.add("hidden");
+    domDeclNoRef.classList.add("hidden");
+    domFnErrorsAnyError.classList.add("hidden");
+    domTableFnErrors.classList.add("hidden");
+    domSectGlobalVars.classList.add("hidden");
+    domSectValues.classList.add("hidden");
+
+    renderTitle();
+    renderInfo();
+    renderPkgList();
+
+    domPrivDeclsBox.checked = curNav.showPrivDecls;
+
+    if (curNavSearch !== "") {
+      return renderSearch();
+    }
+
+    let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
+    let pkg = rootPkg;
+    curNav.pkgObjs = [pkg];
+    for (let i = 0; i < curNav.pkgNames.length; i += 1) {
+      let childPkg = zigAnalysis.packages[pkg.table[curNav.pkgNames[i]]];
+      if (childPkg == null) {
+        return render404();
+      }
+      pkg = childPkg;
+      curNav.pkgObjs.push(pkg);
+    }
+
+    let currentType = zigAnalysis.types[pkg.main];
+    curNav.declObjs = [currentType];
+    for (let i = 0; i < curNav.declNames.length; i += 1) {
+      let childDecl = findSubDecl(currentType, curNav.declNames[i]);
+      if (childDecl == null) {
+        return render404();
+      }
+
+      let childDeclValue = resolveValue(childDecl.value).expr;
+      if ("type" in childDeclValue) {
+        const t = zigAnalysis.types[childDeclValue.type];
+        if (t.kind != typeKinds.Fn) {
+          childDecl = t;
+        }
+      }
+
+      currentType = childDecl;
+      curNav.declObjs.push(currentType);
+    }
+
+    renderNav();
+
+    let last = curNav.declObjs[curNav.declObjs.length - 1];
+    let lastIsDecl = isDecl(last);
+    let lastIsType = isType(last);
+    let lastIsContainerType = isContainerType(last);
+
+    if (lastIsContainerType) {
+      return renderContainer(last);
+    }
+
+    if (!lastIsDecl && !lastIsType) {
+      return renderUnknownDecl(last);
+    }
+
+    if (lastIsType) {
+      return renderType(last);
+    }
+
+    if (lastIsDecl && last.kind === "var") {
+      return renderVar(last);
+    }
+
+    if (lastIsDecl && last.kind === "const") {
+      let typeObj = zigAnalysis.types[resolveValue(last.value).expr.type];
+      if (typeObj && typeObj.kind === typeKinds.Fn) {
+        return renderFn(last);
+      }
+
+      return renderValue(last);
+    }
+  }
+
+  function renderUnknownDecl(decl) {
+    domDeclNoRef.classList.remove("hidden");
+
+    let docs = zigAnalysis.astNodes[decl.src].docs;
+    if (docs != null) {
+      domTldDocs.innerHTML = markdown(docs);
+    } else {
+      domTldDocs.innerHTML =
+        "<p>There are no doc comments for this declaration.</p>";
+    }
+    domTldDocs.classList.remove("hidden");
+  }
+
+  function typeIsErrSet(typeIndex) {
+    let typeObj = zigAnalysis.types[typeIndex];
+    return typeObj.kind === typeKinds.ErrorSet;
+  }
+
+  function typeIsStructWithNoFields(typeIndex) {
+    let typeObj = zigAnalysis.types[typeIndex];
+    if (typeObj.kind !== typeKinds.Struct) return false;
+    return typeObj.fields.length == 0;
+  }
+
+  function typeIsGenericFn(typeIndex) {
+    let typeObj = zigAnalysis.types[typeIndex];
+    if (typeObj.kind !== typeKinds.Fn) {
+      return false;
+    }
+    return typeObj.generic_ret != null;
+  }
+
+  function renderFn(fnDecl) {
+    if ("refPath" in fnDecl.value.expr) {
+      let last = fnDecl.value.expr.refPath.length - 1;
+      let lastExpr = fnDecl.value.expr.refPath[last];
+      console.assert("declRef" in lastExpr);
+      fnDecl = zigAnalysis.decls[lastExpr.declRef];
+    }
+
+    let value = resolveValue(fnDecl.value);
+    console.assert("type" in value.expr);
+    let typeObj = zigAnalysis.types[value.expr.type];
+
+    domFnProtoCode.innerHTML = exprName(value.expr, {
+      wantHtml: true,
+      wantLink: true,
+      fnDecl,
+    });
+
+    let docsSource = null;
+    let srcNode = zigAnalysis.astNodes[fnDecl.src];
+    if (srcNode.docs != null) {
+      docsSource = srcNode.docs;
+    }
+
+    renderFnParamDocs(fnDecl, typeObj);
+
+    let retExpr = resolveValue({ expr: typeObj.ret }).expr;
+    if ("type" in retExpr) {
+      let retIndex = retExpr.type;
+      let errSetTypeIndex = null;
+      let retType = zigAnalysis.types[retIndex];
+      if (retType.kind === typeKinds.ErrorSet) {
+        errSetTypeIndex = retIndex;
+      } else if (retType.kind === typeKinds.ErrorUnion) {
+        errSetTypeIndex = retType.err.type;
+      }
+      if (errSetTypeIndex != null) {
+        let errSetType = zigAnalysis.types[errSetTypeIndex];
+        renderErrorSet(errSetType);
+      }
+    }
+
+    let protoSrcIndex = fnDecl.src;
+    if (typeIsGenericFn(value.expr.type)) {
+      // does the generic_ret contain a container?
+      var resolvedGenericRet = resolveValue({ expr: typeObj.generic_ret });
+
+      if ("call" in resolvedGenericRet.expr) {
+        let call = zigAnalysis.calls[resolvedGenericRet.expr.call];
+        let resolvedFunc = resolveValue({ expr: call.func });
+        if (!("type" in resolvedFunc.expr)) return;
+        let callee = zigAnalysis.types[resolvedFunc.expr.type];
+        if (!callee.generic_ret) return;
+        resolvedGenericRet = resolveValue({ expr: callee.generic_ret });
+      }
+
+      // TODO: see if unwrapping the `as` here is a good idea or not.
+      if ("as" in resolvedGenericRet.expr) {
+        resolvedGenericRet = {
+          expr: zigAnalysis.exprs[resolvedGenericRet.expr.as.exprArg],
+        };
+      }
+
+      if (!("type" in resolvedGenericRet.expr)) return;
+      const genericType = zigAnalysis.types[resolvedGenericRet.expr.type];
+      if (isContainerType(genericType)) {
+        renderContainer(genericType);
+      }
+
+      // old code
+      // let instantiations = nodesToFnsMap[protoSrcIndex];
+      // let calls = nodesToCallsMap[protoSrcIndex];
+      // if (instantiations == null && calls == null) {
+      //     domFnNoExamples.classList.remove("hidden");
+      // } else if (calls != null) {
+      //     // if (fnObj.combined === undefined) fnObj.combined = allCompTimeFnCallsResult(calls);
+      //     if (fnObj.combined != null) renderContainer(fnObj.combined);
+
+      //     resizeDomList(domListFnExamples, calls.length, '<li></li>');
+
+      //     for (let callI = 0; callI < calls.length; callI += 1) {
+      //         let liDom = domListFnExamples.children[callI];
+      //         liDom.innerHTML = getCallHtml(fnDecl, calls[callI]);
+      //     }
+
+      //     domFnExamples.classList.remove("hidden");
+      // } else if (instantiations != null) {
+      //     // TODO
+      // }
+    } else {
+      domFnExamples.classList.add("hidden");
+      domFnNoExamples.classList.add("hidden");
+    }
+
+    let protoSrcNode = zigAnalysis.astNodes[protoSrcIndex];
+    if (
+      docsSource == null &&
+      protoSrcNode != null &&
+      protoSrcNode.docs != null
+    ) {
+      docsSource = protoSrcNode.docs;
+    }
+    if (docsSource != null) {
+      domTldDocs.innerHTML = markdown(docsSource);
+      domTldDocs.classList.remove("hidden");
+    }
+    domFnProto.classList.remove("hidden");
+  }
+
+  function renderFnParamDocs(fnDecl, typeObj) {
+    let docCount = 0;
+
+    let fnNode = zigAnalysis.astNodes[fnDecl.src];
+    let fields = fnNode.fields;
+    let isVarArgs = fnNode.varArgs;
+
+    for (let i = 0; i < fields.length; i += 1) {
+      let field = fields[i];
+      let fieldNode = zigAnalysis.astNodes[field];
+      if (fieldNode.docs != null) {
+        docCount += 1;
+      }
+    }
+    if (docCount == 0) {
+      return;
+    }
+
+    resizeDomList(domListParams, docCount, "<div></div>");
+    let domIndex = 0;
+
+    for (let i = 0; i < fields.length; i += 1) {
+      let field = fields[i];
+      let fieldNode = zigAnalysis.astNodes[field];
+      let docs = fieldNode.docs;
+      if (fieldNode.docs == null) {
+        continue;
+      }
+      let docsNonEmpty = docs !== "";
+      let divDom = domListParams.children[domIndex];
+      domIndex += 1;
+
+      let value = typeObj.params[i];
+      let preClass = docsNonEmpty ? ' class="fieldHasDocs"' : "";
+      let html = "<pre" + preClass + ">" + escapeHtml(fieldNode.name) + ": ";
+      if (isVarArgs && i === typeObj.params.length - 1) {
+        html += "...";
+      } else {
+        let name = exprName(value, { wantHtml: false, wantLink: false });
+        html += '<span class="tok-kw">' + name + "</span>";
+      }
+
+      html += ",</pre>";
+
+      if (docsNonEmpty) {
+        html += '<div class="fieldDocs">' + markdown(docs) + "</div>";
+      }
+      divDom.innerHTML = html;
+    }
+    domSectParams.classList.remove("hidden");
+  }
+
+  function renderNav() {
+    let len = curNav.pkgNames.length + curNav.declNames.length;
+    resizeDomList(domListNav, len, '<li><a href="#"></a></li>');
+    let list = [];
+    let hrefPkgNames = [];
+    let hrefDeclNames = [];
+    for (let i = 0; i < curNav.pkgNames.length; i += 1) {
+      hrefPkgNames.push(curNav.pkgNames[i]);
+      let name = curNav.pkgNames[i];
+      if (name == "root") name = zigAnalysis.rootPkgName;
+      list.push({
+        name: name,
+        link: navLink(hrefPkgNames, hrefDeclNames),
+      });
+    }
+    for (let i = 0; i < curNav.declNames.length; i += 1) {
+      hrefDeclNames.push(curNav.declNames[i]);
+      list.push({
+        name: curNav.declNames[i],
+        link: navLink(hrefPkgNames, hrefDeclNames),
+      });
+    }
+
+    for (let i = 0; i < list.length; i += 1) {
+      let liDom = domListNav.children[i];
+      let aDom = liDom.children[0];
+      aDom.textContent = list[i].name;
+      aDom.setAttribute("href", list[i].link);
+      if (i + 1 == list.length) {
+        aDom.classList.add("active");
+      } else {
+        aDom.classList.remove("active");
+      }
+    }
+
+    domSectNav.classList.remove("hidden");
+  }
+
+  function renderInfo() {
+    domTdZigVer.textContent = zigAnalysis.params.zigVersion;
+    //domTdTarget.textContent = zigAnalysis.params.builds[0].target;
+
+    domSectInfo.classList.remove("hidden");
+  }
+
+  function render404() {
+    domStatus.textContent = "404 Not Found";
+    domStatus.classList.remove("hidden");
+  }
+
+  function renderPkgList() {
+    let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
+    let list = [];
+    for (let key in rootPkg.table) {
+      let pkgIndex = rootPkg.table[key];
+      if (zigAnalysis.packages[pkgIndex] == null) continue;
+      if (key == zigAnalysis.params.rootName) continue;
+      list.push({
+        name: key,
+        pkg: pkgIndex,
+      });
+    }
+
+    {
+      let aDom = domSectMainPkg.children[1].children[0].children[0];
+      aDom.textContent = zigAnalysis.rootPkgName;
+      aDom.setAttribute("href", navLinkPkg(zigAnalysis.rootPkg));
+      if (zigAnalysis.params.rootName === curNav.pkgNames[0]) {
+        aDom.classList.add("active");
+      } else {
+        aDom.classList.remove("active");
+      }
+      domSectMainPkg.classList.remove("hidden");
+    }
+
+    list.sort(function (a, b) {
+      return operatorCompare(a.name.toLowerCase(), b.name.toLowerCase());
+    });
+
+    if (list.length !== 0) {
+      resizeDomList(domListPkgs, list.length, '<li><a href="#"></a></li>');
+      for (let i = 0; i < list.length; i += 1) {
+        let liDom = domListPkgs.children[i];
+        let aDom = liDom.children[0];
+        aDom.textContent = list[i].name;
+        aDom.setAttribute("href", navLinkPkg(list[i].pkg));
+        if (list[i].name === curNav.pkgNames[0]) {
+          aDom.classList.add("active");
+        } else {
+          aDom.classList.remove("active");
+        }
+      }
+
+      domSectPkgs.classList.remove("hidden");
+    }
+  }
+
+  function navLink(pkgNames, declNames, callName) {
+    let base = "#";
+    if (curNav.showPrivDecls) {
+      base += "*";
+    }
+
+    if (pkgNames.length === 0 && declNames.length === 0) {
+      return base;
+    } else if (declNames.length === 0 && callName == null) {
+      return base + pkgNames.join(".");
+    } else if (callName == null) {
+      return base + pkgNames.join(".") + ";" + declNames.join(".");
+    } else {
+      return (
+        base + pkgNames.join(".") + ";" + declNames.join(".") + ";" + callName
+      );
+    }
+  }
+
+  function navLinkPkg(pkgIndex) {
+    return navLink(canonPkgPaths[pkgIndex], []);
+  }
+
+  function navLinkDecl(childName) {
+    return navLink(curNav.pkgNames, curNav.declNames.concat([childName]));
+  }
+
+  //
+  //  function navLinkCall(callObj) {
+  //      let declNamesCopy = curNav.declNames.concat([]);
+  //      let callName = (declNamesCopy.pop());
+
+  //      callName += '(';
+  //          for (let arg_i = 0; arg_i < callObj.args.length; arg_i += 1) {
+  //              if (arg_i !== 0) callName += ',';
+  //              let argObj = callObj.args[arg_i];
+  //              callName += getValueText(argObj, argObj, false, false);
+  //          }
+  //          callName += ')';
+
+  //      declNamesCopy.push(callName);
+  //      return navLink(curNav.pkgNames, declNamesCopy);
+  //  }
+
+  function resizeDomListDl(dlDom, desiredLen) {
+    // add the missing dom entries
+    for (let i = dlDom.childElementCount / 2; i < desiredLen; i += 1) {
+      dlDom.insertAdjacentHTML("beforeend", "<dt></dt><dd></dd>");
+    }
+    // remove extra dom entries
+    while (desiredLen < dlDom.childElementCount / 2) {
+      dlDom.removeChild(dlDom.lastChild);
+      dlDom.removeChild(dlDom.lastChild);
+    }
+  }
+
+  function resizeDomList(listDom, desiredLen, templateHtml) {
+    // add the missing dom entries
+    for (let i = listDom.childElementCount; i < desiredLen; i += 1) {
+      listDom.insertAdjacentHTML("beforeend", templateHtml);
+    }
+    // remove extra dom entries
+    while (desiredLen < listDom.childElementCount) {
+      listDom.removeChild(listDom.lastChild);
+    }
+  }
+
+  function walkResultTypeRef(wr) {
+    if (wr.typeRef) return wr.typeRef;
+    let resolved = resolveValue(wr);
+    if (wr === resolved) {
+      return { type: 0 };
+    }
+    return walkResultTypeRef(resolved);
+  }
+
+  function exprName(expr, opts) {
+    switch (Object.keys(expr)[0]) {
+      default:
+        throw "this expression is not implemented yet";
+      case "bool": {
+        if (expr.bool) {
+          return "true";
+        }
+        return "false";
+      }
+      case "&": {
+        return "&" + exprName(zigAnalysis.exprs[expr["&"]]);
+      }
+      case "compileError": {
+        let compileError = expr.compileError;
+        return compileError;
+      }
+      case "enumLiteral": {
+        let literal = expr.enumLiteral;
+        return "." + literal;
+      }
+      case "void": {
+        return "void";
+      }
+      case "slice": {
+        let payloadHtml = "";
+        const lhsExpr = zigAnalysis.exprs[expr.slice.lhs];
+        const startExpr = zigAnalysis.exprs[expr.slice.start];
+        let decl = exprName(lhsExpr);
+        let start = exprName(startExpr);
+        let end = "";
+        let sentinel = "";
+        if (expr.slice["end"]) {
+          const endExpr = zigAnalysis.exprs[expr.slice.end];
+          let end_ = exprName(endExpr);
+          end += end_;
+        }
+        if (expr.slice["sentinel"]) {
+          const sentinelExpr = zigAnalysis.exprs[expr.slice.sentinel];
+          let sentinel_ = exprName(sentinelExpr);
+          sentinel += " :" + sentinel_;
+        }
+        payloadHtml += decl + "[" + start + ".." + end + sentinel + "]";
+        return payloadHtml;
+      }
+      case "sliceIndex": {
+        const sliceIndex = zigAnalysis.exprs[expr.sliceIndex];
+        return exprName(sliceIndex, opts);
+      }
+      case "cmpxchg": {
+        const typeIndex = zigAnalysis.exprs[expr.cmpxchg.type];
+        const ptrIndex = zigAnalysis.exprs[expr.cmpxchg.ptr];
+        const expectedValueIndex =
+          zigAnalysis.exprs[expr.cmpxchg.expected_value];
+        const newValueIndex = zigAnalysis.exprs[expr.cmpxchg.new_value];
+        const successOrderIndex = zigAnalysis.exprs[expr.cmpxchg.success_order];
+        const failureOrderIndex = zigAnalysis.exprs[expr.cmpxchg.failure_order];
+
+        const type = exprName(typeIndex, opts);
+        const ptr = exprName(ptrIndex, opts);
+        const expectedValue = exprName(expectedValueIndex, opts);
+        const newValue = exprName(newValueIndex, opts);
+        const successOrder = exprName(successOrderIndex, opts);
+        const failureOrder = exprName(failureOrderIndex, opts);
+
+        let fnName = "@";
+
+        switch (expr.cmpxchg.name) {
+          case "cmpxchg_strong": {
+            fnName += "cmpxchgStrong";
+            break;
+          }
+          case "cmpxchg_weak": {
+            fnName += "cmpxchgWeak";
+            break;
+          }
+          default: {
+            console.log("There's only cmpxchg_strong and cmpxchg_weak");
+          }
+        }
+
+        return (
+          fnName +
+          "(" +
+          type +
+          ", " +
+          ptr +
+          ", " +
+          expectedValue +
+          ", " +
+          newValue +
+          ", " +
+          "." +
+          successOrder +
+          ", " +
+          "." +
+          failureOrder +
+          ")"
+        );
+      }
+      case "cmpxchgIndex": {
+        const cmpxchgIndex = zigAnalysis.exprs[expr.cmpxchgIndex];
+        return exprName(cmpxchgIndex, opts);
+      }
+      case "switchOp": {
+        let condExpr = zigAnalysis.exprs[expr.switchOp.cond_index];
+        let ast = zigAnalysis.astNodes[expr.switchOp.ast];
+        let file_name = expr.switchOp.file_name;
+        let outer_decl_index = expr.switchOp.outer_decl;
+        let outer_decl = zigAnalysis.types[outer_decl_index];
+        let line = 0;
+        // console.log(expr.switchOp)
+        // console.log(outer_decl)
+        while (outer_decl_index !== 0 && outer_decl.line_number > 0) {
+          line += outer_decl.line_number;
+          outer_decl_index = outer_decl.outer_decl;
+          outer_decl = zigAnalysis.types[outer_decl_index];
+          // console.log(outer_decl)
+        }
+        line += ast.line + 1;
+        let payloadHtml = "";
+        let cond = exprName(condExpr, opts);
+
+        payloadHtml +=
+          "</br>" +
+          "node_name: " +
+          ast.name +
+          "</br>" +
+          "file: " +
+          file_name +
+          "</br>" +
+          "line: " +
+          line +
+          "</br>";
+        payloadHtml +=
+          "switch(" +
+          cond +
+          ") {" +
+          '<a href="https://github.com/ziglang/zig/tree/master/lib/std/' +
+          file_name +
+          "#L" +
+          line +
+          '">' +
+          "..." +
+          "</a>}";
+        return payloadHtml;
+      }
+      case "switchIndex": {
+        const switchIndex = zigAnalysis.exprs[expr.switchIndex];
+        return exprName(switchIndex, opts);
+      }
+      case "refPath": {
+        let name = exprName(expr.refPath[0]);
+        for (let i = 1; i < expr.refPath.length; i++) {
+          let component = undefined;
+          if ("string" in expr.refPath[i]) {
+            component = expr.refPath[i].string;
+          } else {
+            component = exprName(expr.refPath[i]);
+          }
+          name += "." + component;
+        }
+        return name;
+      }
+      case "fieldRef": {
+        const enumObj = exprName({ type: expr.fieldRef.type }, opts);
+        const field =
+          zigAnalysis.astNodes[enumObj.ast].fields[expr.fieldRef.index];
+        const name = zigAnalysis.astNodes[field].name;
+        return name;
+      }
+      case "enumToInt": {
+        const enumToInt = zigAnalysis.exprs[expr.enumToInt];
+        return "@enumToInt(" + exprName(enumToInt, opts) + ")";
+      }
+      case "bitSizeOf": {
+        const bitSizeOf = zigAnalysis.exprs[expr.bitSizeOf];
+        return "@bitSizeOf(" + exprName(bitSizeOf, opts) + ")";
+      }
+      case "sizeOf": {
+        const sizeOf = zigAnalysis.exprs[expr.sizeOf];
+        return "@sizeOf(" + exprName(sizeOf, opts) + ")";
+      }
+      case "builtinIndex": {
+        const builtinIndex = zigAnalysis.exprs[expr.builtinIndex];
+        return exprName(builtinIndex, opts);
+      }
+      case "builtin": {
+        const param_expr = zigAnalysis.exprs[expr.builtin.param];
+        let param = exprName(param_expr, opts);
+
+        let payloadHtml = "@";
+        switch (expr.builtin.name) {
+          case "align_of": {
+            payloadHtml += "alignOf";
+            break;
+          }
+          case "bool_to_int": {
+            payloadHtml += "boolToInt";
+            break;
+          }
+          case "embed_file": {
+            payloadHtml += "embedFile";
+            break;
+          }
+          case "error_name": {
+            payloadHtml += "errorName";
+            break;
+          }
+          case "panic": {
+            payloadHtml += "panic";
+            break;
+          }
+          case "set_cold": {
+            payloadHtml += "setCold";
+            break;
+          }
+          case "set_runtime_safety": {
+            payloadHtml += "setRuntimeSafety";
+            break;
+          }
+          case "sqrt": {
+            payloadHtml += "sqrt";
+            break;
+          }
+          case "sin": {
+            payloadHtml += "sin";
+            break;
+          }
+          case "cos": {
+            payloadHtml += "cos";
+            break;
+          }
+          case "tan": {
+            payloadHtml += "tan";
+            break;
+          }
+          case "exp": {
+            payloadHtml += "exp";
+            break;
+          }
+          case "exp2": {
+            payloadHtml += "exp2";
+            break;
+          }
+          case "log": {
+            payloadHtml += "log";
+            break;
+          }
+          case "log2": {
+            payloadHtml += "log2";
+            break;
+          }
+          case "log10": {
+            payloadHtml += "log10";
+            break;
+          }
+          case "fabs": {
+            payloadHtml += "fabs";
+            break;
+          }
+          case "floor": {
+            payloadHtml += "floor";
+            break;
+          }
+          case "ceil": {
+            payloadHtml += "ceil";
+            break;
+          }
+          case "trunc": {
+            payloadHtml += "trunc";
+            break;
+          }
+          case "round": {
+            payloadHtml += "round";
+            break;
+          }
+          case "tag_name": {
+            payloadHtml += "tagName";
+            break;
+          }
+          case "reify": {
+            payloadHtml += "Type";
+            break;
+          }
+          case "type_name": {
+            payloadHtml += "typeName";
+            break;
+          }
+          case "frame_type": {
+            payloadHtml += "Frame";
+            break;
+          }
+          case "frame_size": {
+            payloadHtml += "frameSize";
+            break;
+          }
+          case "ptr_to_int": {
+            payloadHtml += "ptrToInt";
+            break;
+          }
+          case "error_to_int": {
+            payloadHtml += "errorToInt";
+            break;
+          }
+          case "int_to_error": {
+            payloadHtml += "intToError";
+            break;
+          }
+          case "maximum": {
+            payloadHtml += "maximum";
+            break;
+          }
+          case "minimum": {
+            payloadHtml += "minimum";
+            break;
+          }
+          case "bit_not": {
+            return "~" + param;
+          }
+          case "clz": {
+            return "@clz(T" + ", " + param + ")";
+          }
+          case "ctz": {
+            return "@ctz(T" + ", " + param + ")";
+          }
+          case "pop_count": {
+            return "@popCount(T" + ", " + param + ")";
+          }
+          case "byte_swap": {
+            return "@byteSwap(T" + ", " + param + ")";
+          }
+          case "bit_reverse": {
+            return "@bitReverse(T" + ", " + param + ")";
+          }
+          default:
+            console.log("builtin function not handled yet or doesn't exist!");
+        }
+        return payloadHtml + "(" + param + ")";
+      }
+      case "builtinBinIndex": {
+        const builtinBinIndex = zigAnalysis.exprs[expr.builtinBinIndex];
+        return exprName(builtinBinIndex, opts);
+      }
+      case "builtinBin": {
+        const lhsOp = zigAnalysis.exprs[expr.builtinBin.lhs];
+        const rhsOp = zigAnalysis.exprs[expr.builtinBin.rhs];
+        let lhs = exprName(lhsOp, opts);
+        let rhs = exprName(rhsOp, opts);
+
+        let payloadHtml = "@";
+        switch (expr.builtinBin.name) {
+          case "float_to_int": {
+            payloadHtml += "floatToInt";
+            break;
+          }
+          case "int_to_float": {
+            payloadHtml += "intToFloat";
+            break;
+          }
+          case "int_to_ptr": {
+            payloadHtml += "intToPtr";
+            break;
+          }
+          case "int_to_enum": {
+            payloadHtml += "intToEnum";
+            break;
+          }
+          case "float_cast": {
+            payloadHtml += "floatCast";
+            break;
+          }
+          case "int_cast": {
+            payloadHtml += "intCast";
+            break;
+          }
+          case "ptr_cast": {
+            payloadHtml += "ptrCast";
+            break;
+          }
+          case "truncate": {
+            payloadHtml += "truncate";
+            break;
+          }
+          case "align_cast": {
+            payloadHtml += "alignCast";
+            break;
+          }
+          case "has_decl": {
+            payloadHtml += "hasDecl";
+            break;
+          }
+          case "has_field": {
+            payloadHtml += "hasField";
+            break;
+          }
+          case "bit_reverse": {
+            payloadHtml += "bitReverse";
+            break;
+          }
+          case "div_exact": {
+            payloadHtml += "divExact";
+            break;
+          }
+          case "div_floor": {
+            payloadHtml += "divFloor";
+            break;
+          }
+          case "div_trunc": {
+            payloadHtml += "divTrunc";
+            break;
+          }
+          case "mod": {
+            payloadHtml += "mod";
+            break;
+          }
+          case "rem": {
+            payloadHtml += "rem";
+            break;
+          }
+          case "mod_rem": {
+            payloadHtml += "rem";
+            break;
+          }
+          case "shl_exact": {
+            payloadHtml += "shlExact";
+            break;
+          }
+          case "shr_exact": {
+            payloadHtml += "shrExact";
+            break;
+          }
+          case "bitcast": {
+            payloadHtml += "bitCast";
+            break;
+          }
+          case "align_cast": {
+            payloadHtml += "alignCast";
+            break;
+          }
+          case "vector_type": {
+            payloadHtml += "Vector";
+            break;
+          }
+          case "reduce": {
+            payloadHtml += "reduce";
+            break;
+          }
+          case "splat": {
+            payloadHtml += "splat";
+            break;
+          }
+          case "offset_of": {
+            payloadHtml += "offsetOf";
+            break;
+          }
+          case "bit_offset_of": {
+            payloadHtml += "bitOffsetOf";
+            break;
+          }
+          default:
+            console.log("builtin function not handled yet or doesn't exist!");
+        }
+        return payloadHtml + "(" + lhs + ", " + rhs + ")";
+      }
+      case "binOpIndex": {
+        const binOpIndex = zigAnalysis.exprs[expr.binOpIndex];
+        return exprName(binOpIndex, opts);
+      }
+      case "binOp": {
+        const lhsOp = zigAnalysis.exprs[expr.binOp.lhs];
+        const rhsOp = zigAnalysis.exprs[expr.binOp.rhs];
+        let lhs = exprName(lhsOp, opts);
+        let rhs = exprName(rhsOp, opts);
+
+        let print_lhs = "";
+        let print_rhs = "";
+
+        if (lhsOp["binOpIndex"]) {
+          print_lhs = "(" + lhs + ")";
+        } else {
+          print_lhs = lhs;
+        }
+        if (rhsOp["binOpIndex"]) {
+          print_rhs = "(" + rhs + ")";
+        } else {
+          print_rhs = rhs;
+        }
+
+        let operator = "";
+
+        switch (expr.binOp.name) {
+          case "add": {
+            operator += "+";
+            break;
+          }
+          case "addwrap": {
+            operator += "+%";
+            break;
+          }
+          case "add_sat": {
+            operator += "+|";
+            break;
+          }
+          case "sub": {
+            operator += "-";
+            break;
+          }
+          case "subwrap": {
+            operator += "-%";
+            break;
+          }
+          case "sub_sat": {
+            operator += "-|";
+            break;
+          }
+          case "mul": {
+            operator += "*";
+            break;
+          }
+          case "mulwrap": {
+            operator += "*%";
+            break;
+          }
+          case "mul_sat": {
+            operator += "*|";
+            break;
+          }
+          case "div": {
+            operator += "/";
+            break;
+          }
+          case "shl": {
+            operator += "<<";
+            break;
+          }
+          case "shl_sat": {
+            operator += "<<|";
+            break;
+          }
+          case "shr": {
+            operator += ">>";
+            break;
+          }
+          case "bit_or": {
+            operator += "|";
+            break;
+          }
+          case "bit_and": {
+            operator += "&";
+            break;
+          }
+          case "array_cat": {
+            operator += "++";
+            break;
+          }
+          case "array_mul": {
+            operator += "**";
+            break;
+          }
+          default:
+            console.log("operator not handled yet or doesn't exist!");
+        }
+
+        return print_lhs + " " + operator + " " + print_rhs;
+      }
+      case "errorSets": {
+        const errUnionObj = zigAnalysis.types[expr.errorSets];
+        let lhs = exprName(errUnionObj.lhs, opts);
+        let rhs = exprName(errUnionObj.rhs, opts);
+        return lhs + " || " + rhs;
+      }
+      case "errorUnion": {
+        const errUnionObj = zigAnalysis.types[expr.errorUnion];
+        let lhs = exprName(errUnionObj.lhs, opts);
+        let rhs = exprName(errUnionObj.rhs, opts);
+        return lhs + "!" + rhs;
+      }
+      case "struct": {
+        const struct_name =
+          zigAnalysis.decls[expr.struct[0].val.typeRef.refPath[0].declRef].name;
+        let struct_body = "";
+        struct_body += struct_name + "{ ";
+        for (let i = 0; i < expr.struct.length; i++) {
+          const val = expr.struct[i].name;
+          const exprArg = zigAnalysis.exprs[expr.struct[i].val.expr.as.exprArg];
+          let value_field = exprArg[Object.keys(exprArg)[0]];
+          if (value_field instanceof Object) {
+            value_field =
+              zigAnalysis.decls[value_field[0].val.typeRef.refPath[0].declRef]
+                .name;
+          }
+          struct_body += "." + val + " = " + value_field;
+          if (i !== expr.struct.length - 1) {
+            struct_body += ", ";
+          } else {
+            struct_body += " ";
+          }
+        }
+        struct_body += "}";
+        return struct_body;
+      }
+      case "typeOf_peer": {
+        let payloadHtml = "@TypeOf(";
+        for (let i = 0; i < expr.typeOf_peer.length; i++) {
+          let elem = zigAnalysis.exprs[expr.typeOf_peer[i]];
+          payloadHtml += exprName(elem, { wantHtml: true, wantLink: true });
+          if (i !== expr.typeOf_peer.length - 1) {
+            payloadHtml += ", ";
+          }
+        }
+        payloadHtml += ")";
+        return payloadHtml;
+      }
+      case "alignOf": {
+        const alignRefArg = zigAnalysis.exprs[expr.alignOf];
+        let payloadHtml =
+          "@alignOf(" +
+          exprName(alignRefArg, { wantHtml: true, wantLink: true }) +
+          ")";
+        return payloadHtml;
+      }
+      case "typeOf": {
+        const typeRefArg = zigAnalysis.exprs[expr.typeOf];
+        let payloadHtml =
+          "@TypeOf(" +
+          exprName(typeRefArg, { wantHtml: true, wantLink: true }) +
+          ")";
+        return payloadHtml;
+      }
+      case "typeInfo": {
+        const typeRefArg = zigAnalysis.exprs[expr.typeInfo];
+        let payloadHtml =
+          "@typeInfo(" +
+          exprName(typeRefArg, { wantHtml: true, wantLink: true }) +
+          ")";
+        return payloadHtml;
+      }
+      case "null": {
+        return "null";
+      }
+      case "array": {
+        let payloadHtml = ".{";
+        for (let i = 0; i < expr.array.length; i++) {
+          if (i != 0) payloadHtml += ", ";
+          let elem = zigAnalysis.exprs[expr.array[i]];
+          payloadHtml += exprName(elem, opts);
+        }
+        return payloadHtml + "}";
+      }
+      case "comptimeExpr": {
+        return zigAnalysis.comptimeExprs[expr.comptimeExpr].code;
+      }
+      case "call": {
+        let call = zigAnalysis.calls[expr.call];
+        let payloadHtml = "";
+
+        switch (Object.keys(call.func)[0]) {
+          default:
+            throw "TODO";
+          case "declRef":
+          case "refPath": {
+            payloadHtml += exprName(call.func, opts);
+            break;
+          }
+        }
+        payloadHtml += "(";
+
+        for (let i = 0; i < call.args.length; i++) {
+          if (i != 0) payloadHtml += ", ";
+          payloadHtml += exprName(call.args[i], opts);
+        }
+
+        payloadHtml += ")";
+        return payloadHtml;
+      }
+      case "as": {
+        // @Check : this should be done in backend because there are legit @as() calls
+        // const typeRefArg = zigAnalysis.exprs[expr.as.typeRefArg];
+        const exprArg = zigAnalysis.exprs[expr.as.exprArg];
+        // return "@as(" + exprName(typeRefArg, opts) +
+        //   ", " + exprName(exprArg, opts) + ")";
+        return exprName(exprArg, opts);
+      }
+      case "declRef": {
+        return zigAnalysis.decls[expr.declRef].name;
+      }
+      case "refPath": {
+        return expr.refPath.map((x) => exprName(x, opts)).join(".");
+      }
+      case "int": {
+        return "" + expr.int;
+      }
+      case "float": {
+        return "" + expr.float.toFixed(2);
+      }
+      case "float128": {
+        return "" + expr.float128.toFixed(2);
+      }
+      case "undefined": {
+        return "undefined";
+      }
+      case "string": {
+        return '"' + escapeHtml(expr.string) + '"';
+      }
+
+      case "anytype": {
+        return "anytype";
+      }
+
+      case "this": {
+        return "@This()";
+      }
+
+      case "type": {
+        let name = "";
+
+        let typeObj = expr.type;
+        if (typeof typeObj === "number") typeObj = zigAnalysis.types[typeObj];
+        switch (typeObj.kind) {
+          default:
+            throw "TODO";
+          case typeKinds.Struct: {
+            let structObj = typeObj;
+            return structObj;
+          }
+          case typeKinds.Enum: {
+            let enumObj = typeObj;
+            return enumObj;
+          }
+          case typeKinds.Opaque: {
+            let opaqueObj = typeObj;
+
+            return opaqueObj.name;
+          }
+          case typeKinds.ComptimeExpr: {
+            return "anyopaque";
+          }
+          case typeKinds.Array: {
+            let arrayObj = typeObj;
+            let name = "[";
+            let lenName = exprName(arrayObj.len, opts);
+            let sentinel = arrayObj.sentinel
+              ? ":" + exprName(arrayObj.sentinel, opts)
+              : "";
+            // let is_mutable = arrayObj.is_multable ? "const " : "";
+
+            if (opts.wantHtml) {
+              name +=
+                '<span class="tok-number">' + lenName + sentinel + "</span>";
             } else {
-                document.title = zigAnalysis.params.rootName + suffix;
+              name += lenName + sentinel;
             }
-        } else {
-            document.title = list.join('.') + suffix;
-        }
-    }
-
-    
-    function isDecl(x) {
-        return "value" in x;
-    }
-
-    
-    function isType(x) {
-        return "kind" in x && !("value" in x);
-    }
-
-    
-    function isContainerType(x) {
-        return isType(x) && typeKindIsContainer((x).kind) ;
-    }
-
-    
-    function typeShorthandName(expr) {
-        let resolvedExpr = resolveValue({expr: expr});
-        if (!("type" in resolvedExpr)) {
-            return null;
-        }
-        let type = (zigAnalysis.types[resolvedExpr.type]);
-
-        outer: for (let i = 0; i < 10000; i += 1) {
-            switch (type.kind) {
-                case typeKinds.Optional:
-                case typeKinds.Pointer:
-                    let child = (type).child;
-                    let resolvedChild = resolveValue(child);
-                    if ("type" in resolvedChild) {
-                        type = zigAnalysis.types[resolvedChild.type];
-                        continue;
-                    } else {
-                        return null;
-                    }
-                default:
-                    break outer;
-            }
-
-            if (i == 9999) throw "Exhausted typeShorthandName quota";
-        }
-
-
-
-        let name = undefined;
-        if (type.kind === typeKinds.Struct) {
-            name = "struct";
-        } else if (type.kind === typeKinds.Enum) {
-            name = "enum";
-        } else if (type.kind === typeKinds.Union) {
-            name = "union";
-        } else {
-            console.log("TODO: unhalndled case in typeShortName");
-            return null;
-        }
-
-        return escapeHtml(name);
-    }
-
-    
-    function typeKindIsContainer(typeKind) {
-        return typeKind === typeKinds.Struct ||
-            typeKind === typeKinds.Union ||
-            typeKind === typeKinds.Enum;
-    }
-
-    
-    function declCanRepresentTypeKind(typeKind) {
-        return typeKind === typeKinds.ErrorSet || typeKindIsContainer(typeKind);
-    }
-
-    // 
-    // function findCteInRefPath(path) {
-    //     for (let i = path.length - 1; i >= 0; i -= 1) {
-    //         const ref = path[i];
-    //         if ("string" in ref) continue;
-    //         if ("comptimeExpr" in ref) return ref;
-    //         if ("refPath" in ref) return findCteInRefPath(ref.refPath);
-    //         return null;
-    //     }
-
-    //     return null;
-    // }
-
-    
-    function resolveValue(value) {
-        let i = 0;
-        while(i < 1000) {
-            i += 1;
-
-            if ("refPath" in value.expr) {
-                value = {expr: value.expr.refPath[value.expr.refPath.length -1]};
-                continue;
-            }
-
-            if ("declRef" in value.expr) {
-                value = zigAnalysis.decls[value.expr.declRef].value;
-                continue;
-            }
-
-            if ("as" in value.expr) {
-                value = {
-                  typeRef: zigAnalysis.exprs[value.expr.as.typeRefArg],
-                  expr: zigAnalysis.exprs[value.expr.as.exprArg],
-                };
-                continue;
-            }
-
-            return value;
-
-        }
-        console.assert(false);
-        return ({});
-    }
-
-    
-//    function typeOfDecl(decl){
-//        return decl.value.typeRef;
-//
-//        let i = 0;
-//        while(i < 1000) {
-//            i += 1;
-//            console.assert(isDecl(decl));
-//            if ("type" in decl.value) {
-//                return ({ type: typeTypeId });
-//            }
-//
-////            if ("string" in decl.value) {
-////                return ({ type: {
-////                  kind: typeKinds.Pointer,
-////                  size: pointerSizeEnum.One,
-////                  child: });
-////            }
-//
-//            if ("refPath" in decl.value) {
-//                decl =  ({
-//                  value: decl.value.refPath[decl.value.refPath.length -1]
-//                });
-//                continue;
-//            }
-//
-//            if ("declRef" in decl.value) {
-//                decl = zigAnalysis.decls[decl.value.declRef];
-//                continue;
-//            }
-//
-//            if ("int" in decl.value) {
-//                return decl.value.int.typeRef;
-//            }
-//
-//            if ("float" in decl.value) {
-//                return decl.value.float.typeRef;
-//            }
-//
-//            if ("array" in decl.value) {
-//                return decl.value.array.typeRef;
-//            }
-//
-//            if ("struct" in decl.value) {
-//                return decl.value.struct.typeRef;
-//            }
-//
-//            if ("comptimeExpr" in decl.value) {
-//                const cte = zigAnalysis.comptimeExprs[decl.value.comptimeExpr];
-//                return cte.typeRef;
-//            }
-//
-//            if ("call" in decl.value) {
-//                const fn_call = zigAnalysis.calls[decl.value.call];
-//                let fn_decl = undefined;
-//                if ("declRef" in fn_call.func) {
-//                    fn_decl = zigAnalysis.decls[fn_call.func.declRef];
-//                } else if ("refPath" in fn_call.func) {
-//                    console.assert("declRef" in fn_call.func.refPath[fn_call.func.refPath.length -1]);
-//                    fn_decl = zigAnalysis.decls[fn_call.func.refPath[fn_call.func.refPath.length -1].declRef];
-//                } else throw {};
-//
-//                const fn_decl_value = resolveValue(fn_decl.value);
-//                console.assert("type" in fn_decl_value); //TODO handle comptimeExpr
-//                const fn_type = (zigAnalysis.types[fn_decl_value.type]);
-//                console.assert(fn_type.kind === typeKinds.Fn);
-//                return fn_type.ret;
-//            }
-//
-//            if ("void" in decl.value) {
-//                return ({ type: typeTypeId });
-//            }
-//
-//            if ("bool" in decl.value) {
-//                return ({ type: typeKinds.Bool });
-//            }
-//
-//            console.log("TODO: handle in `typeOfDecl` more cases: ", decl);
-//            console.assert(false);
-//            throw {};
-//        }
-//        console.assert(false);
-//        return ({});
-//    }
-
-    function render() {
-        domStatus.classList.add("hidden");
-        domFnProto.classList.add("hidden");
-        domSectParams.classList.add("hidden");
-        domTldDocs.classList.add("hidden");
-        domSectMainPkg.classList.add("hidden");
-        domSectPkgs.classList.add("hidden");
-        domSectTypes.classList.add("hidden");
-        domSectTests.classList.add("hidden");
-        domSectNamespaces.classList.add("hidden");
-        domSectErrSets.classList.add("hidden");
-        domSectFns.classList.add("hidden");
-        domSectFields.classList.add("hidden");
-        domSectSearchResults.classList.add("hidden");
-        domSectSearchNoResults.classList.add("hidden");
-        domSectInfo.classList.add("hidden");
-        domHdrName.classList.add("hidden");
-        domSectNav.classList.add("hidden");
-        domSectFnErrors.classList.add("hidden");
-        domFnExamples.classList.add("hidden");
-        domFnNoExamples.classList.add("hidden");
-        domDeclNoRef.classList.add("hidden");
-        domFnErrorsAnyError.classList.add("hidden");
-        domTableFnErrors.classList.add("hidden");
-        domSectGlobalVars.classList.add("hidden");
-        domSectValues.classList.add("hidden");
-
-        renderTitle();
-        renderInfo();
-        renderPkgList();
-
-        domPrivDeclsBox.checked = curNav.showPrivDecls;
-
-        if (curNavSearch !== "") {
-            return renderSearch();
-        }
-
-        let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
-        let pkg = rootPkg;
-        curNav.pkgObjs = [pkg];
-        for (let i = 0; i < curNav.pkgNames.length; i += 1) {
-            let childPkg = zigAnalysis.packages[pkg.table[curNav.pkgNames[i]]];
-            if (childPkg == null) {
-                return render404();
-            }
-            pkg = childPkg;
-            curNav.pkgObjs.push(pkg);
-        }
-
-        
-        let currentType = zigAnalysis.types[pkg.main];
-        curNav.declObjs = [currentType];
-        for (let i = 0; i < curNav.declNames.length; i += 1) {
-
-            
-            let childDecl = findSubDecl((currentType), curNav.declNames[i]);
-            if (childDecl == null) {
-                return render404();
-            }
-
-            let childDeclValue = resolveValue((childDecl).value).expr;
-            if ("type" in childDeclValue) {
-
-                const t = zigAnalysis.types[childDeclValue.type];
-                if (t.kind != typeKinds.Fn) {
-                    childDecl = t;
+            name += "]";
+            // name += is_mutable;
+            name += exprName(arrayObj.child, opts);
+            return name;
+          }
+          case typeKinds.Optional:
+            return "?" + exprName(typeObj.child, opts);
+          case typeKinds.Pointer: {
+            let ptrObj = typeObj;
+            let sentinel = ptrObj.sentinel
+              ? ":" + exprName(ptrObj.sentinel, opts)
+              : "";
+            let is_mutable = !ptrObj.is_mutable ? "const " : "";
+            let name = "";
+            switch (ptrObj.size) {
+              default:
+                console.log("TODO: implement unhandled pointer size case");
+              case pointerSizeEnum.One:
+                name += "*";
+                name += is_mutable;
+                break;
+              case pointerSizeEnum.Many:
+                name += "[*";
+                name += sentinel;
+                name += "]";
+                name += is_mutable;
+                break;
+              case pointerSizeEnum.Slice:
+                if (ptrObj.is_ref) {
+                  name += "*";
                 }
+                name += "[";
+                name += sentinel;
+                name += "]";
+                name += is_mutable;
+                break;
+              case pointerSizeEnum.C:
+                name += "[*c";
+                name += sentinel;
+                name += "]";
+                name += is_mutable;
+                break;
             }
-
-            currentType = (childDecl);
-            curNav.declObjs.push(currentType);
-        }
-
-        renderNav();
-
-        let last = curNav.declObjs[curNav.declObjs.length - 1];
-        let lastIsDecl = isDecl(last);
-        let lastIsType = isType(last);
-        let lastIsContainerType = isContainerType(last);
-
-        if (lastIsContainerType) {
-            return renderContainer((last));
-        }
-
-        if (!lastIsDecl && !lastIsType) {
-            return renderUnknownDecl((last));
-        }
-
-        if (lastIsType) {
-            return renderType((last));
-        }
-
-        if (lastIsDecl && last.kind === 'var') {
-            return renderVar((last));
-        }
-
-        if (lastIsDecl && last.kind === 'const') {
-            let typeObj = zigAnalysis.types[resolveValue((last).value).expr.type];
-            if (typeObj && typeObj.kind === typeKinds.Fn) {
-                return renderFn((last));
-            }
-
-            return renderValue((last));
-        }
-    }
-
-    
-    function renderUnknownDecl(decl) {
-        domDeclNoRef.classList.remove("hidden");
-
-        let docs = zigAnalysis.astNodes[decl.src].docs;
-        if (docs != null) {
-            domTldDocs.innerHTML = markdown(docs);
-        } else {
-            domTldDocs.innerHTML = '<p>There are no doc comments for this declaration.</p>';
-        }
-        domTldDocs.classList.remove("hidden");
-    }
-
-    
-    function typeIsErrSet(typeIndex) {
-        let typeObj = zigAnalysis.types[typeIndex];
-        return typeObj.kind === typeKinds.ErrorSet;
-    }
-
-    
-    function typeIsStructWithNoFields(typeIndex) {
-        let typeObj = zigAnalysis.types[typeIndex];
-        if (typeObj.kind !== typeKinds.Struct)
-            return false;
-        return (typeObj).fields.length == 0;
-    }
-
-    
-    function typeIsGenericFn(typeIndex) {
-        let typeObj = zigAnalysis.types[typeIndex];
-        if (typeObj.kind !== typeKinds.Fn) {
-            return false;
-        }
-        return  (typeObj).generic_ret != null;
-    }
-
-    
-    function renderFn(fnDecl) {
-        if ("refPath" in fnDecl.value.expr) {
-            let last = fnDecl.value.expr.refPath.length - 1;
-            let lastExpr = fnDecl.value.expr.refPath[last];
-            console.assert("declRef" in lastExpr);
-            fnDecl = zigAnalysis.decls[lastExpr.declRef];
-        }
-
-        let value = resolveValue(fnDecl.value);
-        console.assert("type" in value.expr);
-        let typeObj = (zigAnalysis.types[value.expr.type]);
-
-        domFnProtoCode.innerHTML = exprName(value.expr, {
-          wantHtml: true,
-          wantLink: true,
-          fnDecl,
-        });
-
-        let docsSource = null;
-        let srcNode = zigAnalysis.astNodes[fnDecl.src];
-        if (srcNode.docs != null) {
-            docsSource = srcNode.docs;
-        }
-
-        renderFnParamDocs(fnDecl, typeObj);
-
-        let retExpr = resolveValue({expr:typeObj.ret}).expr;
-        if ("type" in retExpr) {
-            let retIndex = retExpr.type;
-            let errSetTypeIndex = (null);
-            let retType = zigAnalysis.types[retIndex];
-            if (retType.kind === typeKinds.ErrorSet) {
-                errSetTypeIndex = retIndex;
-            } else if (retType.kind === typeKinds.ErrorUnion) {
-                errSetTypeIndex = (retType).err.type;
-            }
-            if (errSetTypeIndex != null) {
-                let errSetType = (zigAnalysis.types[errSetTypeIndex]);
-                renderErrorSet(errSetType);
-            }
-        }
-
-        let protoSrcIndex = fnDecl.src;
-        if (typeIsGenericFn(value.expr.type)) {
-            // does the generic_ret contain a container?
-            var resolvedGenericRet = resolveValue({expr: typeObj.generic_ret});
-            
-            if ("call" in resolvedGenericRet.expr){
-                let call  = zigAnalysis.calls[resolvedGenericRet.expr.call];
-                let resolvedFunc = resolveValue({expr: call.func});
-                if (!("type" in resolvedFunc.expr)) return;
-                let callee = zigAnalysis.types[resolvedFunc.expr.type];
-                if (!callee.generic_ret) return;
-                resolvedGenericRet = resolveValue({expr: callee.generic_ret});
-            }
-
-            // TODO: see if unwrapping the `as` here is a good idea or not.
-            if ("as" in resolvedGenericRet.expr) {
-                resolvedGenericRet = {
-                    expr: zigAnalysis.exprs[resolvedGenericRet.expr.as.exprArg]
-                };
-            }
-
-            if (!("type" in resolvedGenericRet.expr)) return;
-            const genericType = zigAnalysis.types[resolvedGenericRet.expr.type];
-            if (isContainerType(genericType)) {
-                renderContainer(genericType)
-            }
-
-
-
-
-
-            // old code
-            // let instantiations = nodesToFnsMap[protoSrcIndex];
-            // let calls = nodesToCallsMap[protoSrcIndex];
-            // if (instantiations == null && calls == null) {
-            //     domFnNoExamples.classList.remove("hidden");
-            // } else if (calls != null) {
-            //     // if (fnObj.combined === undefined) fnObj.combined = allCompTimeFnCallsResult(calls);
-            //     if (fnObj.combined != null) renderContainer(fnObj.combined);
-
-            //     resizeDomList(domListFnExamples, calls.length, '<li></li>');
-
-            //     for (let callI = 0; callI < calls.length; callI += 1) {
-            //         let liDom = domListFnExamples.children[callI];
-            //         liDom.innerHTML = getCallHtml(fnDecl, calls[callI]);
+            // @check: after the major changes in arrays the consts are came from switch above
+            // if (!ptrObj.is_mutable) {
+            //     if (opts.wantHtml) {
+            //         name += '<span class="tok-kw">const</span> ';
+            //     } else {
+            //         name += "const ";
             //     }
-
-            //     domFnExamples.classList.remove("hidden");
-            // } else if (instantiations != null) {
-            //     // TODO
             // }
-        } else {
-
-            domFnExamples.classList.add("hidden");
-            domFnNoExamples.classList.add("hidden");
-        }
-
-        let protoSrcNode = zigAnalysis.astNodes[protoSrcIndex];
-        if (docsSource == null && protoSrcNode != null && protoSrcNode.docs != null) {
-            docsSource = protoSrcNode.docs;
-        }
-        if (docsSource != null) {
-            domTldDocs.innerHTML = markdown(docsSource);
-            domTldDocs.classList.remove("hidden");
-        }
-        domFnProto.classList.remove("hidden");
-    }
-
-    
-    function renderFnParamDocs(fnDecl, typeObj) {
-        let docCount = 0;
-
-        let fnNode = zigAnalysis.astNodes[fnDecl.src];
-        let fields = (fnNode.fields);
-        let isVarArgs = fnNode.varArgs;
-
-        for (let i = 0; i < fields.length; i += 1) {
-            let field = fields[i];
-            let fieldNode = zigAnalysis.astNodes[field];
-            if (fieldNode.docs != null) {
-                docCount += 1;
-            }
-        }
-        if (docCount == 0) {
-            return;
-        }
-
-        resizeDomList(domListParams, docCount, '<div></div>');
-        let domIndex = 0;
-
-        for (let i = 0; i < fields.length; i += 1) {
-            let field = fields[i];
-            let fieldNode = zigAnalysis.astNodes[field];
-            let docs = fieldNode.docs;
-            if (fieldNode.docs == null) {
-                continue;
-            }
-            let docsNonEmpty = docs !== "";
-            let divDom = domListParams.children[domIndex];
-            domIndex += 1;
-
-
-            let value = typeObj.params[i];
-            let preClass = docsNonEmpty ? ' class="fieldHasDocs"' : "";
-            let html = '<pre' + preClass + '>' + escapeHtml((fieldNode.name)) + ": ";
-            if (isVarArgs && i === typeObj.params.length - 1) {
-                html += '...';
-            } else {
-                let name = exprName(value, {wantHtml: false, wantLink: false});
-                html += '<span class="tok-kw">' + name + '</span>';
-            }
-
-            html += ',</pre>';
-
-            if (docsNonEmpty) {
-                html += '<div class="fieldDocs">' + markdown(docs) + '</div>';
-            }
-            divDom.innerHTML = html;
-        }
-        domSectParams.classList.remove("hidden");
-    }
-
-    function renderNav() {
-        let len = curNav.pkgNames.length + curNav.declNames.length;
-        resizeDomList(domListNav, len, '<li><a href="#"></a></li>');
-        let list = [];
-        let hrefPkgNames = [];
-        let hrefDeclNames = ([]);
-        for (let i = 0; i < curNav.pkgNames.length; i += 1) {
-            hrefPkgNames.push(curNav.pkgNames[i]);
-            let name = curNav.pkgNames[i];
-            if (name == "root") name = zigAnalysis.rootPkgName;
-            list.push({
-                name: name,
-                link: navLink(hrefPkgNames, hrefDeclNames),
-            });
-        }
-        for (let i = 0; i < curNav.declNames.length; i += 1) {
-            hrefDeclNames.push(curNav.declNames[i]);
-            list.push({
-                name: curNav.declNames[i],
-                link: navLink(hrefPkgNames, hrefDeclNames),
-            });
-        }
-
-        for (let i = 0; i < list.length; i += 1) {
-            let liDom = domListNav.children[i];
-            let aDom = liDom.children[0];
-            aDom.textContent = list[i].name;
-            aDom.setAttribute('href', list[i].link);
-            if (i + 1 == list.length) {
-                aDom.classList.add("active");
-            } else {
-                aDom.classList.remove("active");
-            }
-        }
-
-        domSectNav.classList.remove("hidden");
-    }
-
-    function renderInfo() {
-        domTdZigVer.textContent = zigAnalysis.params.zigVersion;
-        //domTdTarget.textContent = zigAnalysis.params.builds[0].target;
-
-        domSectInfo.classList.remove("hidden");
-    }
-
-    function render404() {
-        domStatus.textContent = "404 Not Found";
-        domStatus.classList.remove("hidden");
-    }
-
-    function renderPkgList() {
-        let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
-        let list = [];
-        for (let key in rootPkg.table) {
-            let pkgIndex = rootPkg.table[key];
-            if (zigAnalysis.packages[pkgIndex] == null) continue;
-            if (key == zigAnalysis.params.rootName) continue;
-            list.push({
-                name: key,
-                pkg: pkgIndex,
-            });
-        }
-
-        {
-            let aDom = domSectMainPkg.children[1].children[0].children[0];
-            aDom.textContent = zigAnalysis.rootPkgName;
-            aDom.setAttribute('href', navLinkPkg(zigAnalysis.rootPkg));
-            if (zigAnalysis.params.rootName === curNav.pkgNames[0]) {
-                aDom.classList.add("active");
-            } else {
-                aDom.classList.remove("active");
-            }
-            domSectMainPkg.classList.remove("hidden");
-        }
-
-        list.sort(function(a, b) {
-            return operatorCompare(a.name.toLowerCase(), b.name.toLowerCase());
-        });
-
-        if (list.length !== 0) {
-            resizeDomList(domListPkgs, list.length, '<li><a href="#"></a></li>');
-            for (let i = 0; i < list.length; i += 1) {
-                let liDom = domListPkgs.children[i];
-                let aDom = liDom.children[0];
-                aDom.textContent = list[i].name;
-                aDom.setAttribute('href', navLinkPkg(list[i].pkg));
-                if (list[i].name === curNav.pkgNames[0]) {
-                    aDom.classList.add("active");
-                } else {
-                    aDom.classList.remove("active");
-                }
-            }
-
-            domSectPkgs.classList.remove("hidden");
-        }
-    }
-
-    
-
-    function navLink(pkgNames, declNames, callName) {
-        let base = '#';
-        if (curNav.showPrivDecls) {
-            base += "*";
-        }
-
-        if (pkgNames.length === 0 && declNames.length === 0) {
-            return base;
-        } else if (declNames.length === 0 && callName == null) {
-            return base + pkgNames.join('.');
-        } else if (callName == null) {
-            return base + pkgNames.join('.') + ';' + declNames.join('.');
-        } else {
-            return base + pkgNames.join('.') + ';' + declNames.join('.') + ';' + callName;
-        }
-    }
-
-    
-    function navLinkPkg(pkgIndex) {
-        return navLink(canonPkgPaths[pkgIndex], []);
-    }
-
-    
-    function navLinkDecl(childName) {
-        return navLink(curNav.pkgNames, curNav.declNames.concat([childName]));
-    }
-
-   //  
-   //  function navLinkCall(callObj) {
-   //      let declNamesCopy = curNav.declNames.concat([]);
-   //      let callName = (declNamesCopy.pop());
-
-   //      callName += '(';
-   //          for (let arg_i = 0; arg_i < callObj.args.length; arg_i += 1) {
-   //              if (arg_i !== 0) callName += ',';
-   //              let argObj = callObj.args[arg_i];
-   //              callName += getValueText(argObj, argObj, false, false);
-   //          }
-   //          callName += ')';
-
-   //      declNamesCopy.push(callName);
-   //      return navLink(curNav.pkgNames, declNamesCopy);
-   //  }
-
-    
-    function resizeDomListDl(dlDom, desiredLen) {
-        // add the missing dom entries
-        for (let i = dlDom.childElementCount / 2; i < desiredLen; i += 1) {
-            dlDom.insertAdjacentHTML('beforeend', '<dt></dt><dd></dd>');
-        }
-        // remove extra dom entries
-        while (desiredLen < dlDom.childElementCount / 2) {
-            dlDom.removeChild(dlDom.lastChild);
-            dlDom.removeChild(dlDom.lastChild);
-        }
-    }
-
-    
-    function resizeDomList(listDom, desiredLen, templateHtml) {
-        // add the missing dom entries
-        for (let i = listDom.childElementCount; i < desiredLen; i += 1) {
-            listDom.insertAdjacentHTML('beforeend', templateHtml);
-        }
-        // remove extra dom entries
-        while (desiredLen < listDom.childElementCount) {
-            listDom.removeChild(listDom.lastChild);
-        }
-    }
-     
-    function walkResultTypeRef(wr) {
-      if (wr.typeRef) return wr.typeRef;
-      let resolved = resolveValue(wr);
-      if (wr === resolved) {
-        return {type: 0};
-      }
-      return walkResultTypeRef(resolved);
-    }
-     
-    function exprName(expr, opts) {
-        switch (Object.keys(expr)[0]) {
-          default: throw "this expression is not implemented yet";
-          case "bool": {
-            if (expr.bool) {
-                return "true";
-            }
-            return "false";
-          }
-          case "&": {
-            return "&" + exprName(zigAnalysis.exprs[expr["&"]]);
-          }
-          case "compileError": {
-            let compileError = expr.compileError;
-            return compileError;
-          }
-          case "enumLiteral": {
-            let literal = expr.enumLiteral;
-            return "." + literal;
-          }
-          case "void": {
-            return "void";
-          }
-          case "slice":{
-            let payloadHtml = "";
-            const lhsExpr = zigAnalysis.exprs[expr.slice.lhs];
-            const startExpr = zigAnalysis.exprs[expr.slice.start];
-            let decl = exprName(lhsExpr);
-            let start = exprName(startExpr);
-            let end = "";
-            let sentinel = "";
-            if (expr.slice['end']) {
-              const endExpr = zigAnalysis.exprs[expr.slice.end];
-              let end_ = exprName(endExpr);
-              end += end_;
-            }
-            if (expr.slice['sentinel']) {
-              const sentinelExpr = zigAnalysis.exprs[expr.slice.sentinel];
-              let sentinel_ = exprName(sentinelExpr);
-              sentinel += " :" + sentinel_;
-            }
-            payloadHtml += decl + "["+ start + ".." + end + sentinel + "]";
-            return payloadHtml;
-          }
-          case "sliceIndex": {
-            const sliceIndex = zigAnalysis.exprs[expr.sliceIndex];
-            return exprName(sliceIndex, opts);
-          }
-          case "cmpxchg":{
-            const typeIndex = zigAnalysis.exprs[expr.cmpxchg.type];
-            const ptrIndex = zigAnalysis.exprs[expr.cmpxchg.ptr];
-            const expectedValueIndex = zigAnalysis.exprs[expr.cmpxchg.expected_value];
-            const newValueIndex = zigAnalysis.exprs[expr.cmpxchg.new_value];
-            const successOrderIndex = zigAnalysis.exprs[expr.cmpxchg.success_order];
-            const failureOrderIndex = zigAnalysis.exprs[expr.cmpxchg.failure_order];
-
-            const type = exprName(typeIndex, opts);
-            const ptr = exprName(ptrIndex, opts);
-            const expectedValue = exprName(expectedValueIndex, opts);
-            const newValue = exprName(newValueIndex, opts);
-            const successOrder = exprName(successOrderIndex, opts);
-            const failureOrder = exprName(failureOrderIndex, opts);
-
-            let fnName = "@";
-
-            switch (expr.cmpxchg.name) {
-              case "cmpxchg_strong": {
-                fnName += "cmpxchgStrong"
-                break;
+            if (ptrObj.is_allowzero) {
+              name += "allowzero ";
+            }
+            if (ptrObj.is_volatile) {
+              name += "volatile ";
+            }
+            if (ptrObj.has_addrspace) {
+              name += "addrspace(";
+              name += "." + "";
+              name += ") ";
+            }
+            if (ptrObj.has_align) {
+              let align = exprName(ptrObj.align, opts);
+              if (opts.wantHtml) {
+                name += '<span class="tok-kw">align</span>(';
+              } else {
+                name += "align(";
               }
-              case "cmpxchg_weak": {
-                fnName += "cmpxchgWeak"
-                break;
+              if (opts.wantHtml) {
+                name += '<span class="tok-number">' + align + "</span>";
+              } else {
+                name += align;
               }
-              default: {
-                console.log("There's only cmpxchg_strong and cmpxchg_weak");
-              }
-            }
-            
-            return fnName + "(" + type + ", " + ptr + ", " + expectedValue + ", "+  newValue + ", "+"." +successOrder + ", "+ "." +failureOrder + ")";
-          }
-          case "cmpxchgIndex": {
-            const cmpxchgIndex = zigAnalysis.exprs[expr.cmpxchgIndex];
-            return exprName(cmpxchgIndex, opts);
-          }
-          case "switchOp":{
-            let condExpr = zigAnalysis.exprs[expr.switchOp.cond_index];
-            let ast = zigAnalysis.astNodes[expr.switchOp.ast];
-            let file_name = expr.switchOp.file_name;
-            let outer_decl_index = expr.switchOp.outer_decl;
-            let outer_decl = zigAnalysis.types[outer_decl_index];
-            let line = 0;
-            // console.log(expr.switchOp)
-            // console.log(outer_decl)
-            while (outer_decl_index !== 0 && outer_decl.line_number > 0) {
-              line += outer_decl.line_number;
-              outer_decl_index = outer_decl.outer_decl;
-              outer_decl = zigAnalysis.types[outer_decl_index];
-            // console.log(outer_decl)
-            }
-            line += ast.line + 1;
-            let payloadHtml = "";
-            let cond = exprName(condExpr, opts);
-
-            payloadHtml += "</br>" + "node_name: " + ast.name + "</br>" + "file: " + file_name + "</br>" + "line: " + line + "</br>";
-            payloadHtml += "switch(" + cond + ") {" + "<a href=\"https://github.com/ziglang/zig/tree/master/lib/std/" + file_name + "#L" + line + "\">" +"..." + "</a>}";
-            return payloadHtml;
-          }
-          case "switchIndex": {
-            const switchIndex = zigAnalysis.exprs[expr.switchIndex];
-            return exprName(switchIndex, opts);
-          }
-          case "refPath" : {
-            let name = exprName(expr.refPath[0]);
-            for (let i = 1; i < expr.refPath.length; i++) {
-                let component = undefined;
-                if ("string" in expr.refPath[i]) {
-                    component = expr.refPath[i].string;
+              if (ptrObj.hostIntBytes != null) {
+                name += ":";
+                if (opts.wantHtml) {
+                  name +=
+                    '<span class="tok-number">' +
+                    ptrObj.bitOffsetInHost +
+                    "</span>";
+                } else {
+                  name += ptrObj.bitOffsetInHost;
+                }
+                name += ":";
+                if (opts.wantHtml) {
+                  name +=
+                    '<span class="tok-number">' +
+                    ptrObj.hostIntBytes +
+                    "</span>";
                 } else {
-                    component = exprName(expr.refPath[i]);
+                  name += ptrObj.hostIntBytes;
                 }
-                name += "." + component;
+              }
+              name += ") ";
             }
+            //name += typeValueName(ptrObj.child, wantHtml, wantSubLink, null);
+            name += exprName(ptrObj.child, opts);
             return name;
           }
-          case "fieldRef" : {
-            const enumObj = exprName({"type":expr.fieldRef.type} ,opts);
-            const field = zigAnalysis.astNodes[enumObj.ast].fields[expr.fieldRef.index];
-            const name = zigAnalysis.astNodes[field].name;
-            return name
-          }
-          case "enumToInt" : {
-            const enumToInt = zigAnalysis.exprs[expr.enumToInt];
-            return "@enumToInt(" + exprName(enumToInt, opts) + ")";
-          }
-          case "bitSizeOf" : {
-            const bitSizeOf = zigAnalysis.exprs[expr.bitSizeOf];
-            return "@bitSizeOf(" + exprName(bitSizeOf, opts) + ")";
-          }
-          case "sizeOf" : {
-            const sizeOf = zigAnalysis.exprs[expr.sizeOf];
-            return "@sizeOf(" + exprName(sizeOf, opts) + ")";
-          }
-          case "builtinIndex" : {
-            const builtinIndex = zigAnalysis.exprs[expr.builtinIndex];
-            return exprName(builtinIndex, opts);
-          }
-          case "builtin": {
-            const param_expr = zigAnalysis.exprs[expr.builtin.param];
-            let param = exprName(param_expr, opts);
-
-
-            let payloadHtml = "@";
-            switch (expr.builtin.name) {
-              case "align_of": {
-                payloadHtml += "alignOf";
-                break;
-              }
-              case "bool_to_int": {
-                payloadHtml += "boolToInt";
-                break;
-              }
-              case "embed_file": {
-                payloadHtml += "embedFile";
-                break;
-              }
-              case "error_name": {
-                payloadHtml += "errorName";
-                break;
-              }
-              case "panic": {
-                payloadHtml += "panic";
-                break;
-              }
-              case "set_cold": {
-                payloadHtml += "setCold";
-                break;
-              }
-              case "set_runtime_safety": {
-                payloadHtml += "setRuntimeSafety";
-                break;
-              }
-              case "sqrt": {
-                payloadHtml += "sqrt";
-                break;
-              }
-              case "sin": {
-                payloadHtml += "sin";
-                break;
-              }
-              case "cos": {
-                payloadHtml += "cos";
-                break;
-              }
-              case "tan": {
-                payloadHtml += "tan";
-                break;
-              }
-              case "exp": {
-                payloadHtml += "exp";
-                break;
-              }
-              case "exp2": {
-                payloadHtml += "exp2";
-                break;
-              }
-              case "log": {
-                payloadHtml += "log";
-                break;
-              }
-              case "log2": {
-                payloadHtml += "log2";
-                break;
-              }
-              case "log10": {
-                payloadHtml += "log10";
-                break;
-              }
-              case "fabs": {
-                payloadHtml += "fabs";
-                break;
-              }
-              case "floor": {
-                payloadHtml += "floor";
-                break;
-              }
-              case "ceil": {
-                payloadHtml += "ceil";
-                break;
-              }
-              case "trunc": {
-                payloadHtml += "trunc";
-                break;
-              }
-              case "round": {
-                payloadHtml += "round";
-                break;
-              }
-              case "tag_name": {
-                payloadHtml += "tagName";
-                break;
-              }
-              case "reify": {
-                payloadHtml += "Type";
-                break;
-              }
-              case "type_name": {
-                payloadHtml += "typeName";
-                break;
-              }
-              case "frame_type": {
-                payloadHtml += "Frame";
-                break;
-              }
-              case "frame_size": {
-                payloadHtml += "frameSize";
-                break;
-              }
-              case "ptr_to_int": {
-                payloadHtml += "ptrToInt";
-                break;
-              }
-              case "error_to_int": {
-                payloadHtml += "errorToInt";
-                break;
-              }
-              case "int_to_error": {
-                payloadHtml += "intToError";
-                break;
-              }
-              case "maximum": {
-                payloadHtml += "maximum";
-                break;
-              }
-              case "minimum": {
-                payloadHtml += "minimum";
-                break;
-              }
-              case "bit_not": {
-                return "~" + param;
-              }
-              case "clz": {
-                return "@clz(T" + ", " + param + ")";
-              }
-              case "ctz": {
-                return "@ctz(T" + ", " + param + ")";
-              }
-              case "pop_count": {
-                return "@popCount(T" + ", " + param + ")";
-              }
-              case "byte_swap": {
-                return "@byteSwap(T" + ", " + param + ")";
-              }
-              case "bit_reverse": {
-                return "@bitReverse(T" + ", " + param + ")";
-              }
-              default: console.log("builtin function not handled yet or doesn't exist!");
-            };
-            return payloadHtml + "(" + param + ")";
-
-          }
-          case "builtinBinIndex" : {
-            const builtinBinIndex = zigAnalysis.exprs[expr.builtinBinIndex];
-            return exprName(builtinBinIndex, opts);
-          }
-          case "builtinBin": {
-            const lhsOp = zigAnalysis.exprs[expr.builtinBin.lhs];
-            const rhsOp = zigAnalysis.exprs[expr.builtinBin.rhs];
-            let lhs = exprName(lhsOp, opts);
-            let rhs = exprName(rhsOp, opts);
-
-            let payloadHtml = "@";
-            switch (expr.builtinBin.name) {
-              case "float_to_int": {
-                payloadHtml += "floatToInt";
-                break;
-              }
-              case "int_to_float": {
-                payloadHtml += "intToFloat";
-                break;
-              }
-              case "int_to_ptr": {
-                payloadHtml += "intToPtr";
-                break;
-              }
-              case "int_to_enum": {
-                payloadHtml += "intToEnum";
-                break;
-              }
-              case "float_cast": {
-                payloadHtml += "floatCast";
-                break;
-              }
-              case "int_cast": {
-                payloadHtml += "intCast";
-                break;
-              }
-              case "ptr_cast": {
-                payloadHtml += "ptrCast";
-                break;
-              }
-              case "truncate": {
-                payloadHtml += "truncate";
-                break;
-              }
-              case "align_cast": {
-                payloadHtml += "alignCast";
-                break;
-              }
-              case "has_decl": {
-                payloadHtml += "hasDecl";
-                break;
-              }
-              case "has_field": {
-                payloadHtml += "hasField";
-                break;
-              }
-              case "bit_reverse": {
-                payloadHtml += "bitReverse";
-                break;
-              }
-              case "div_exact": {
-                payloadHtml +=  "divExact"; 
-                break;
-              }
-              case "div_floor": {
-                payloadHtml +=  "divFloor"; 
-                break;
-              }
-              case "div_trunc": {
-                payloadHtml +=  "divTrunc"; 
-                break;
-              }
-              case "mod": {
-                payloadHtml +=  "mod"; 
-                break;
-              }
-              case "rem": {
-                payloadHtml +=  "rem"; 
-                break;
-              }
-              case "mod_rem": {
-                payloadHtml +=  "rem"; 
-                break;
-              }
-              case "shl_exact": {
-                payloadHtml +=  "shlExact"; 
-                break;
-              }
-              case "shr_exact": {
-                payloadHtml +=  "shrExact"; 
-                break;
-              }
-              case "bitcast" : {
-                payloadHtml +=  "bitCast"; 
-                break;
-              }
-              case "align_cast" : {
-                payloadHtml +=  "alignCast"; 
-                break;
-              }
-              case "vector_type" : {
-                payloadHtml +=  "Vector"; 
-                break;
-              }
-              case "reduce": {
-                payloadHtml +=  "reduce"; 
-                break;
-              }
-              case "splat": {
-                payloadHtml +=  "splat"; 
-                break;
-              }
-              case "offset_of": {
-                payloadHtml +=  "offsetOf"; 
-                break;
-              }
-              case "bit_offset_of": {
-                payloadHtml +=  "bitOffsetOf"; 
-                break;
-              }
-              default: console.log("builtin function not handled yet or doesn't exist!");
-            };
-            return payloadHtml + "(" + lhs + ", " + rhs + ")";
+          case typeKinds.Float: {
+            let floatObj = typeObj;
 
+            if (opts.wantHtml) {
+              return '<span class="tok-type">' + floatObj.name + "</span>";
+            } else {
+              return floatObj.name;
+            }
           }
-          case "binOpIndex" : {
-            const binOpIndex = zigAnalysis.exprs[expr.binOpIndex];
-            return exprName(binOpIndex, opts);
+          case typeKinds.Int: {
+            let intObj = typeObj;
+            let name = intObj.name;
+            if (opts.wantHtml) {
+              return '<span class="tok-type">' + name + "</span>";
+            } else {
+              return name;
+            }
           }
-          case "binOp": {
-            const lhsOp = zigAnalysis.exprs[expr.binOp.lhs];
-            const rhsOp = zigAnalysis.exprs[expr.binOp.rhs];
-            let lhs = exprName(lhsOp, opts);
-            let rhs = exprName(rhsOp, opts);
-
-            let print_lhs = "";
-            let print_rhs = "";
-
-            if (lhsOp['binOpIndex']) {
-              print_lhs = "(" + lhs + ")";
+          case typeKinds.ComptimeInt:
+            if (opts.wantHtml) {
+              return '<span class="tok-type">comptime_int</span>';
             } else {
-              print_lhs = lhs;
+              return "comptime_int";
             }
-            if (rhsOp['binOpIndex']) {
-              print_rhs = "(" + rhs + ")";
+          case typeKinds.ComptimeFloat:
+            if (opts.wantHtml) {
+              return '<span class="tok-type">comptime_float</span>';
             } else {
-              print_rhs = rhs;
+              return "comptime_float";
+            }
+          case typeKinds.Type:
+            if (opts.wantHtml) {
+              return '<span class="tok-type">type</span>';
+            } else {
+              return "type";
+            }
+          case typeKinds.Bool:
+            if (opts.wantHtml) {
+              return '<span class="tok-type">bool</span>';
+            } else {
+              return "bool";
+            }
+          case typeKinds.Void:
+            if (opts.wantHtml) {
+              return '<span class="tok-type">void</span>';
+            } else {
+              return "void";
+            }
+          case typeKinds.EnumLiteral:
+            if (opts.wantHtml) {
+              return '<span class="tok-type">(enum literal)</span>';
+            } else {
+              return "(enum literal)";
+            }
+          case typeKinds.NoReturn:
+            if (opts.wantHtml) {
+              return '<span class="tok-type">noreturn</span>';
+            } else {
+              return "noreturn";
+            }
+          case typeKinds.ErrorSet: {
+            let errSetObj = typeObj;
+            if (errSetObj.fields == null) {
+              return '<span class="tok-type">anyerror</span>';
+            } else {
+              // throw "TODO";
+              let html = "error{" + errSetObj.fields[0].name + "}";
+              return html;
             }
-
-            let operator = "";
-
-            switch (expr.binOp.name) {
-              case "add": {
-                operator += "+";
-                break;
-              }
-              case "addwrap": {
-                operator += "+%";
-                break;
-              }
-              case "add_sat": {
-                operator += "+|";
-                break;
-              }
-              case "sub": {
-                operator += "-";
-                break;
-              }
-              case "subwrap": {
-                operator += "-%";
-                break;
-              }
-              case "sub_sat": {
-                operator += "-|";
-                break;
-              }
-              case "mul": {
-                operator += "*";
-                break;
-              }
-              case "mulwrap": {
-                operator += "*%";
-                break;
-              }
-              case "mul_sat": {
-                operator += "*|";
-                break;
-              }
-              case "div": {
-                operator += "/";
-                break;
-              }
-              case "shl": {
-                operator += "<<";
-                break;
-              }
-              case "shl_sat": {
-                operator += "<<|";
-                break;
-              }
-              case "shr": {
-                operator += ">>";
-                break;
-              }
-              case "bit_or" : {
-                operator += "|";
-                break;
-              }
-              case "bit_and" : {
-                operator += "&";
-                break;
-              }
-              case "array_cat" : {
-                operator += "++";
-                break;
-              }
-              case "array_mul" : {
-                operator += "**";
-                break;
-              }
-              default: console.log("operator not handled yet or doesn't exist!");
-            };
-
-            return print_lhs + " " + operator + " " + print_rhs;
-
           }
-          case "errorSets": {
-            const errUnionObj = zigAnalysis.types[expr.errorSets];
-            let lhs = exprName(errUnionObj.lhs, opts);
-            let rhs = exprName(errUnionObj.rhs, opts);
-            return lhs + " || " + rhs;
 
-          }
-          case "errorUnion": {
-            const errUnionObj = zigAnalysis.types[expr.errorUnion];
+          case typeKinds.ErrorUnion: {
+            let errUnionObj = typeObj;
             let lhs = exprName(errUnionObj.lhs, opts);
             let rhs = exprName(errUnionObj.rhs, opts);
             return lhs + "!" + rhs;
-
           }
-          case "struct": {
-            const struct_name = zigAnalysis.decls[expr.struct[0].val.typeRef.refPath[0].declRef].name;
-            let struct_body = "";
-            struct_body += struct_name + "{ ";
-            for (let i = 0; i < expr.struct.length; i++) {
-              const val = expr.struct[i].name
-              const exprArg = zigAnalysis.exprs[expr.struct[i].val.expr.as.exprArg];
-              let value_field = exprArg[Object.keys(exprArg)[0]];
-              if (value_field instanceof Object) {
-                value_field = zigAnalysis.decls[value_field[0].val.typeRef.refPath[0].declRef].name;
-              };
-              struct_body += "." + val + " = " + value_field;
-              if (i !== expr.struct.length - 1) {
-                struct_body += ", ";
-              }  else {
-                struct_body += " ";
-              }
-            }
-              struct_body += "}";
-            return struct_body;
+          case typeKinds.InferredErrorUnion: {
+            let errUnionObj = typeObj;
+            let payload = exprName(errUnionObj.payload, opts);
+            return "!" + payload;
           }
-          case "typeOf_peer": {
-            let payloadHtml = "@TypeOf("
-            for (let i = 0; i < expr.typeOf_peer.length; i++) {
-              let elem = zigAnalysis.exprs[expr.typeOf_peer[i]];
-              payloadHtml += exprName(elem, {wantHtml: true, wantLink:true});
-              if (i !== expr.typeOf_peer.length - 1) {
-                payloadHtml += ", ";
+          case typeKinds.Fn: {
+            let fnObj = typeObj;
+            let payloadHtml = "";
+            if (opts.wantHtml) {
+              if (fnObj.is_extern) {
+                payloadHtml += "pub extern ";
               }
-            }
-            payloadHtml += ")";
-            return payloadHtml;
-
-          }
-          case "alignOf": {
-            const alignRefArg = zigAnalysis.exprs[expr.alignOf];
-            let payloadHtml = "@alignOf(" + exprName(alignRefArg, {wantHtml: true, wantLink:true}) + ")";
-            return payloadHtml;
-          }
-          case "typeOf": {
-            const typeRefArg = zigAnalysis.exprs[expr.typeOf];
-            let payloadHtml = "@TypeOf(" + exprName(typeRefArg, {wantHtml: true, wantLink:true}) + ")";
-            return payloadHtml;
-          }
-          case "typeInfo": {
-            const typeRefArg = zigAnalysis.exprs[expr.typeInfo];
-            let payloadHtml = "@typeInfo(" + exprName(typeRefArg, {wantHtml: true, wantLink:true}) + ")";
-            return payloadHtml;
-          }
-          case "null": {
-            return "null";
-          }
-          case "array": {
-            let payloadHtml = ".{";
-            for (let i = 0; i < expr.array.length; i++) {
-                if (i != 0) payloadHtml += ", ";
-                let elem = zigAnalysis.exprs[expr.array[i]];
-                payloadHtml += exprName(elem, opts);
-            }
-            return payloadHtml + "}";
-          }
-          case "comptimeExpr": {
-              return zigAnalysis.comptimeExprs[expr.comptimeExpr].code;
-          }
-          case "call": {
-              let call = zigAnalysis.calls[expr.call];
-              let payloadHtml = "";
-
-
-              switch(Object.keys(call.func)[0]){
-                default: throw "TODO";
-                case "declRef":
-                case "refPath": {
-                    payloadHtml += exprName(call.func, opts);
-                    break;
-                }
+              if (fnObj.has_lib_name) {
+                payloadHtml += '"' + fnObj.lib_name + '" ';
               }
-              payloadHtml += "(";
-
-              for (let i = 0; i < call.args.length; i++) {
-                  if (i != 0) payloadHtml += ", ";
-                  payloadHtml += exprName(call.args[i], opts);
+              payloadHtml += '<span class="tok-kw">fn</span>';
+              if (opts.fnDecl) {
+                payloadHtml += ' <span class="tok-fn">';
+                if (opts.linkFnNameDecl) {
+                  payloadHtml +=
+                    '<a href="' +
+                    opts.linkFnNameDecl +
+                    '">' +
+                    escapeHtml(opts.fnDecl.name) +
+                    "</a>";
+                } else {
+                  payloadHtml += escapeHtml(opts.fnDecl.name);
+                }
+                payloadHtml += "</span>";
               }
+            } else {
+              payloadHtml += "fn ";
+            }
+            payloadHtml += "(";
+            if (fnObj.params) {
+              let fields = null;
+              let isVarArgs = false;
+              let fnNode = zigAnalysis.astNodes[fnObj.src];
+              fields = fnNode.fields;
+              isVarArgs = fnNode.varArgs;
+
+              for (let i = 0; i < fnObj.params.length; i += 1) {
+                if (i != 0) {
+                  payloadHtml += ", ";
+                }
 
-              payloadHtml += ")";
-              return payloadHtml;
-          }
-          case "as": {
-            // @Check : this should be done in backend because there are legit @as() calls
-              // const typeRefArg = zigAnalysis.exprs[expr.as.typeRefArg];
-              const exprArg = zigAnalysis.exprs[expr.as.exprArg];
-              // return "@as(" + exprName(typeRefArg, opts) +
-              //   ", " + exprName(exprArg, opts) + ")";
-              return exprName(exprArg, opts);
-          }
-          case "declRef": {
-            return zigAnalysis.decls[expr.declRef].name;
-          }
-          case "refPath": {
-            return expr.refPath.map(x => exprName(x, opts)).join(".");
-          }
-          case "int": {
-              return "" + expr.int;
-          }
-          case "float": {
-              return "" + expr.float.toFixed(2);
-          }
-          case "float128": {
-              return "" + expr.float128.toFixed(2);
-          }
-          case "undefined": {
-              return "undefined";
-          }
-          case "string": {
-            return "\"" + escapeHtml(expr.string) + "\"";
-          }
-
-          case "anytype": {
-            return "anytype";
-          }
-
-          case "this":{
-            return "@This()";
-          }
+                payloadHtml +=
+                  "<span class='argBreaker'><br>&nbsp;&nbsp;&nbsp;&nbsp;</span>";
+                let value = fnObj.params[i];
+                let paramValue = resolveValue({ expr: value });
 
-          case "type": {
-              let name = "";
+                if (fields != null) {
+                  let paramNode = zigAnalysis.astNodes[fields[i]];
 
-              let typeObj = expr.type;
-              if (typeof typeObj === 'number') typeObj = zigAnalysis.types[typeObj];
-              switch (typeObj.kind) {
-                  default: throw "TODO";
-                  case typeKinds.Struct:
-                  {
-                    let structObj =  (typeObj);
-                    return structObj;
-                  }
-                  case typeKinds.Enum:
-                  {
-                    let enumObj =  (typeObj);
-                    return enumObj;
+                  if (paramNode.varArgs) {
+                    payloadHtml += "...";
+                    continue;
                   }
-                  case typeKinds.Opaque:
-                  {
-                    let opaqueObj =  (typeObj);
 
-                    return opaqueObj.name;
-                  }
-                  case typeKinds.ComptimeExpr:
-                  {
-                      return "anyopaque";
+                  if (paramNode.noalias) {
+                    if (opts.wantHtml) {
+                      payloadHtml += '<span class="tok-kw">noalias</span> ';
+                    } else {
+                      payloadHtml += "noalias ";
+                    }
                   }
-                  case typeKinds.Array:
-                  {
-                    let arrayObj = typeObj;
-                    let name = "[";
-                    let lenName = exprName(arrayObj.len, opts);
-                    let sentinel = arrayObj.sentinel ? ":"+exprName(arrayObj.sentinel, opts) : "";
-                    // let is_mutable = arrayObj.is_multable ? "const " : "";
 
+                  if (paramNode.comptime) {
                     if (opts.wantHtml) {
-                      name +=
-                        '<span class="tok-number">' + lenName + sentinel + "</span>";
+                      payloadHtml += '<span class="tok-kw">comptime</span> ';
                     } else {
-                      name += lenName + sentinel;
+                      payloadHtml += "comptime ";
                     }
-                    name += "]";
-                    // name += is_mutable;
-                    name += exprName(arrayObj.child, opts);
-                    return name;
                   }
-                  case typeKinds.Optional:
-                      return "?" + exprName((typeObj).child, opts);
-                  case typeKinds.Pointer:
-                  {
-                      let ptrObj = (typeObj);
-                    let sentinel = ptrObj.sentinel ? ":"+exprName(ptrObj.sentinel, opts) : "";
-                      let is_mutable = !ptrObj.is_mutable ? "const " : "";
-                      let name = "";
-                      switch (ptrObj.size) {
-                          default:
-                              console.log("TODO: implement unhandled pointer size case");
-                          case pointerSizeEnum.One:
-                              name += "*";
-                              name += is_mutable;
-                              break;
-                          case pointerSizeEnum.Many:
-                              name += "[*";
-                              name += sentinel;
-                              name += "]";
-                              name += is_mutable;
-                              break;
-                          case pointerSizeEnum.Slice:
-                              if (ptrObj.is_ref) {
-                                name += "*";
-                              }
-                              name += "[";
-                              name += sentinel;
-                              name += "]";
-                              name += is_mutable;
-                              break;
-                          case pointerSizeEnum.C:
-                              name += "[*c";
-                              name += sentinel;
-                              name += "]";
-                              name += is_mutable;
-                              break;
-                      }
-                      // @check: after the major changes in arrays the consts are came from switch above
-                      // if (!ptrObj.is_mutable) {
-                      //     if (opts.wantHtml) {
-                      //         name += '<span class="tok-kw">const</span> ';
-                      //     } else {
-                      //         name += "const ";
-                      //     }
-                      // }
-                      if (ptrObj.is_allowzero) {
-                              name += "allowzero ";
-                      }
-                      if (ptrObj.is_volatile) {
-                              name += "volatile ";
-                      }
-                      if (ptrObj.has_addrspace) {
-                              name += "addrspace(";
-                              name += "." + "";
-                              name += ") ";
-                      }
-                      if (ptrObj.has_align) {
-                          let align = exprName(ptrObj.align, opts);
-                          if (opts.wantHtml) {
-                              name += '<span class="tok-kw">align</span>(';
-                          } else {
-                              name += "align(";
-                          }
-                          if (opts.wantHtml) {
-                              name += '<span class="tok-number">' + align + '</span>';
-                          } else {
-                              name += align;
-                          }
-                          if (ptrObj.hostIntBytes != null) {
-                              name += ":";
-                              if (opts.wantHtml) {
-                                  name += '<span class="tok-number">' + ptrObj.bitOffsetInHost + '</span>';
-                              } else {
-                                  name += ptrObj.bitOffsetInHost;
-                              }
-                              name += ":";
-                              if (opts.wantHtml) {
-                                  name += '<span class="tok-number">' + ptrObj.hostIntBytes + '</span>';
-                              } else {
-                                  name += ptrObj.hostIntBytes;
-                              }
-                          }
-                          name += ") ";
-                      }
-                      //name += typeValueName(ptrObj.child, wantHtml, wantSubLink, null);
-                      name += exprName(ptrObj.child, opts);
-                      return name;
+
+                  let paramName = paramNode.name;
+                  if (paramName != null) {
+                    // skip if it matches the type name
+                    if (!shouldSkipParamName(paramValue, paramName)) {
+                      payloadHtml += paramName + ": ";
+                    }
                   }
-                  case typeKinds.Float:
-                  {
-                      let floatObj =  (typeObj);
+                }
 
-                      if (opts.wantHtml) {
-                          return '<span class="tok-type">' + floatObj.name + '</span>';
-                      } else {
-                          return floatObj.name;
-                      }
+                if (isVarArgs && i === fnObj.params.length - 1) {
+                  payloadHtml += "...";
+                } else if ("alignOf" in value) {
+                  if (opts.wantHtml) {
+                    payloadHtml += '<a href="">';
+                    payloadHtml +=
+                      '<span class="tok-kw" style="color:lightblue;">' +
+                      exprName(value, opts) +
+                      "</span>";
+                    payloadHtml += "</a>";
+                  } else {
+                    payloadHtml += exprName(value, opts);
                   }
-                  case typeKinds.Int:
-                  {
-                      let intObj = (typeObj);
-                      let name = intObj.name;
-                      if (opts.wantHtml) {
-                          return '<span class="tok-type">' + name + '</span>';
-                      } else {
-                          return name;
-                      }
+                } else if ("typeOf" in value) {
+                  if (opts.wantHtml) {
+                    payloadHtml += '<a href="">';
+                    payloadHtml +=
+                      '<span class="tok-kw" style="color:lightblue;">' +
+                      exprName(value, opts) +
+                      "</span>";
+                    payloadHtml += "</a>";
+                  } else {
+                    payloadHtml += exprName(value, opts);
                   }
-                  case typeKinds.ComptimeInt:
-                      if (opts.wantHtml) {
-                          return '<span class="tok-type">comptime_int</span>';
-                      } else {
-                          return "comptime_int";
-                      }
-                  case typeKinds.ComptimeFloat:
-                      if (opts.wantHtml) {
-                          return '<span class="tok-type">comptime_float</span>';
-                      } else {
-                          return "comptime_float";
-                      }
-                  case typeKinds.Type:
-                      if (opts.wantHtml) {
-                          return '<span class="tok-type">type</span>';
-                      } else {
-                          return "type";
-                      }
-                  case typeKinds.Bool:
-                      if (opts.wantHtml) {
-                          return '<span class="tok-type">bool</span>';
-                      } else {
-                          return "bool";
-                      }
-                  case typeKinds.Void:
-                      if (opts.wantHtml) {
-                          return '<span class="tok-type">void</span>';
-                      } else {
-                          return "void";
-                      }
-                  case typeKinds.EnumLiteral:
-                      if (opts.wantHtml) {
-                          return '<span class="tok-type">(enum literal)</span>';
-                      } else {
-                          return "(enum literal)";
-                      }
-                  case typeKinds.NoReturn:
-                      if (opts.wantHtml) {
-                          return '<span class="tok-type">noreturn</span>';
-                      } else {
-                          return "noreturn";
-                      }
-                  case typeKinds.ErrorSet:
-                  {
-                      let errSetObj = (typeObj);
-                      if (errSetObj.fields == null) {
-                              return '<span class="tok-type">anyerror</span>';
-                      } else {
-                          // throw "TODO";
-                        let html = "error{" + errSetObj.fields[0].name + "}";
-                        return html;
-                      }
+                } else if ("typeOf_peer" in value) {
+                  if (opts.wantHtml) {
+                    payloadHtml += '<a href="">';
+                    payloadHtml +=
+                      '<span class="tok-kw" style="color:lightblue;">' +
+                      exprName(value, opts) +
+                      "</span>";
+                    payloadHtml += "</a>";
+                  } else {
+                    payloadHtml += exprName(value, opts);
                   }
-
-                  case typeKinds.ErrorUnion:
-                  {
-                    let errUnionObj = (typeObj);
-                    let lhs = exprName(errUnionObj.lhs, opts);
-                    let rhs = exprName(errUnionObj.rhs, opts);
-                    return lhs + "!" + rhs;
+                } else if ("declRef" in value) {
+                  if (opts.wantHtml) {
+                    payloadHtml += '<a href="">';
+                    payloadHtml +=
+                      '<span class="tok-kw" style="color:lightblue;">' +
+                      exprName(value, opts) +
+                      "</span>";
+                    payloadHtml += "</a>";
+                  } else {
+                    payloadHtml += exprName(value, opts);
                   }
-                  case typeKinds.InferredErrorUnion:
-                  {
-                    let errUnionObj = (typeObj);
-                    let payload = exprName(errUnionObj.payload, opts);
-                    return "!" + payload;
+                } else if ("call" in value) {
+                  if (opts.wantHtml) {
+                    payloadHtml += '<a href="">';
+                    payloadHtml +=
+                      '<span class="tok-kw" style="color:lightblue;">' +
+                      exprName(value, opts) +
+                      "</span>";
+                    payloadHtml += "</a>";
+                  } else {
+                    payloadHtml += exprName(value, opts);
                   }
-                  case typeKinds.Fn:
-                  {
-                      let fnObj = (typeObj);
-                      let payloadHtml = "";
-                      if (opts.wantHtml) {
-                          if (fnObj.is_extern) {
-                            payloadHtml += "pub extern ";
-                          }
-                          if (fnObj.has_lib_name) {
-                            payloadHtml += "\"" + fnObj.lib_name +"\" ";
-                          }
-                          payloadHtml += '<span class="tok-kw">fn</span>';
-                          if (opts.fnDecl) {
-                              payloadHtml += ' <span class="tok-fn">';
-                              if (opts.linkFnNameDecl) {
-                                  payloadHtml += '<a href="' + opts.linkFnNameDecl + '">' +
-                                      escapeHtml(opts.fnDecl.name) + '</a>';
-                              } else {
-                                  payloadHtml += escapeHtml(opts.fnDecl.name);
-                              }
-                              payloadHtml += '</span>';
-                          }
-                      } else {
-                          payloadHtml += 'fn ';
-                      }
-                      payloadHtml += '(';
-                          if (fnObj.params) {
-                              let fields = null;
-                              let isVarArgs = false;
-                              let fnNode = zigAnalysis.astNodes[fnObj.src];
-                              fields = fnNode.fields;
-                              isVarArgs = fnNode.varArgs;
-
-                              for (let i = 0; i < fnObj.params.length; i += 1) {
-                                  if (i != 0) {
-                                      payloadHtml += ', ';
-                                  }
-
-                                  payloadHtml += "<span class='argBreaker'><br>&nbsp;&nbsp;&nbsp;&nbsp;</span>"
-                                  let value = fnObj.params[i];
-                                  let paramValue = resolveValue({expr: value});
-
-                                  if (fields != null) {
-                                      let paramNode = zigAnalysis.astNodes[fields[i]];
-
-                                      if (paramNode.varArgs) {
-                                          payloadHtml += '...';
-                                          continue;
-                                      }
-
-                                      if (paramNode.noalias) {
-                                          if (opts.wantHtml) {
-                                              payloadHtml += '<span class="tok-kw">noalias</span> ';
-                                          } else {
-                                              payloadHtml += 'noalias ';
-                                          }
-                                      }
-
-                                      if (paramNode.comptime) {
-                                          if (opts.wantHtml) {
-                                              payloadHtml += '<span class="tok-kw">comptime</span> ';
-                                          } else {
-                                              payloadHtml += 'comptime ';
-                                          }
-                                      }
-
-                                      let paramName = paramNode.name;
-                                      if (paramName != null) {
-                                          // skip if it matches the type name
-                                          if (!shouldSkipParamName(paramValue, paramName)) {
-                                              payloadHtml += paramName + ': ';
-                                          }
-                                      }
-                                  }
-
-                                  if (isVarArgs && i === fnObj.params.length - 1) {
-                                      payloadHtml += '...';
-                                  }
-                                  else if ("alignOf" in value) {
-                                    if (opts.wantHtml) {
-                                      payloadHtml += '<a href="">';
-                                      payloadHtml +=
-                                        '<span class="tok-kw" style="color:lightblue;">'
-                                        + exprName(value, opts) + '</span>';
-                                      payloadHtml += '</a>';
-                                    } else {
-                                      payloadHtml += exprName(value, opts);
-                                    }
-
-                                  }
-                                  else if ("typeOf" in value) {
-                                    if (opts.wantHtml) {
-                                      payloadHtml += '<a href="">';
-                                      payloadHtml +=
-                                        '<span class="tok-kw" style="color:lightblue;">'
-                                        + exprName(value, opts) + '</span>';
-                                      payloadHtml += '</a>';
-                                    } else {
-                                      payloadHtml += exprName(value, opts);
-                                    }
-
-                                  }
-                                  else if ("typeOf_peer" in value) {
-                                    if (opts.wantHtml) {
-                                      payloadHtml += '<a href="">';
-                                      payloadHtml +=
-                                        '<span class="tok-kw" style="color:lightblue;">'
-                                        + exprName(value, opts) + '</span>';
-                                      payloadHtml += '</a>';
-                                    } else {
-                                      payloadHtml += exprName(value, opts);
-                                    }
-
-                                  }
-                                  else if ("declRef" in value) {
-                                    if (opts.wantHtml) {
-                                      payloadHtml += '<a href="">';
-                                      payloadHtml +=
-                                        '<span class="tok-kw" style="color:lightblue;">'
-                                        + exprName(value, opts) + '</span>';
-                                      payloadHtml += '</a>';
-                                    } else {
-                                      payloadHtml += exprName(value, opts);
-                                    }
-
-                                  }
-                                  else if ("call" in value) {
-                                    if (opts.wantHtml) {
-                                      payloadHtml += '<a href="">';
-                                      payloadHtml +=
-                                        '<span class="tok-kw" style="color:lightblue;">'
-                                        + exprName(value, opts) + '</span>';
-                                      payloadHtml += '</a>';
-                                    } else {
-                                      payloadHtml += exprName(value, opts);
-                                    }
-                                  }
-                                  else if ("refPath" in value) {
-                                    if (opts.wantHtml) {
-                                      payloadHtml += '<a href="">';
-                                      payloadHtml +=
-                                        '<span class="tok-kw" style="color:lightblue;">'
-                                        + exprName(value, opts) + '</span>';
-                                      payloadHtml += '</a>';
-                                    } else {
-                                      payloadHtml += exprName(value, opts);
-                                    }
-                                  } else if ("type" in value) {
-                                      let name = exprName(value, {
-                                        wantHtml: false,
-                                        wantLink: false,
-                                        fnDecl: opts.fnDecl,
-                                        linkFnNameDecl: opts.linkFnNameDecl,
-                                      });
-                                      payloadHtml += '<span class="tok-kw">' + name + '</span>';
-                                  } else if ("binOpIndex" in value) {
-                                    payloadHtml += exprName(value, opts);
-                                  }else if ("comptimeExpr" in value) {
-                                      let comptimeExpr = zigAnalysis.comptimeExprs[value.comptimeExpr].code;
-                                      if (opts.wantHtml) {
-                                        payloadHtml += '<span class="tok-kw">' + comptimeExpr + '</span>';
-                                      } else {
-                                        payloadHtml += comptimeExpr;
-                                      }
-                                  } else if (opts.wantHtml) {
-                                      payloadHtml += '<span class="tok-kw">anytype</span>';
-                                  } else {
-                                      payloadHtml += 'anytype';
-                                  }
-                              }
-                          }
-
-                      payloadHtml += "<span class='argBreaker'>,<br></span>"
-                      payloadHtml += ') ';
-
-                    if (fnObj.has_align) {
-                      let align = zigAnalysis.exprs[fnObj.align]
-                      payloadHtml += "align(" + exprName(align, opts) + ") ";
-                    }
-                    if (fnObj.has_cc) {
-                      let cc = zigAnalysis.exprs[fnObj.cc]
-                      if (cc) {
-                        payloadHtml += "callconv(." + cc.enumLiteral + ") ";
-                      }
-                    }
-
-                      if (fnObj.is_inferred_error) {
-                          payloadHtml += "!";
-                      }
-                      if (fnObj.ret != null) {
-                          payloadHtml += exprName(fnObj.ret, opts);
-                      } else if (opts.wantHtml) {
-                          payloadHtml += '<span class="tok-kw">anytype</span>';
-                      } else {
-                          payloadHtml += 'anytype';
-                      }
-                      return payloadHtml;
+                } else if ("refPath" in value) {
+                  if (opts.wantHtml) {
+                    payloadHtml += '<a href="">';
+                    payloadHtml +=
+                      '<span class="tok-kw" style="color:lightblue;">' +
+                      exprName(value, opts) +
+                      "</span>";
+                    payloadHtml += "</a>";
+                  } else {
+                    payloadHtml += exprName(value, opts);
+                  }
+                } else if ("type" in value) {
+                  let name = exprName(value, {
+                    wantHtml: false,
+                    wantLink: false,
+                    fnDecl: opts.fnDecl,
+                    linkFnNameDecl: opts.linkFnNameDecl,
+                  });
+                  payloadHtml += '<span class="tok-kw">' + name + "</span>";
+                } else if ("binOpIndex" in value) {
+                  payloadHtml += exprName(value, opts);
+                } else if ("comptimeExpr" in value) {
+                  let comptimeExpr =
+                    zigAnalysis.comptimeExprs[value.comptimeExpr].code;
+                  if (opts.wantHtml) {
+                    payloadHtml +=
+                      '<span class="tok-kw">' + comptimeExpr + "</span>";
+                  } else {
+                    payloadHtml += comptimeExpr;
                   }
-                      // if (wantHtml) {
-                      //     return escapeHtml(typeObj.name);
-                      // } else {
-                      //     return typeObj.name;
-                      // }
+                } else if (opts.wantHtml) {
+                  payloadHtml += '<span class="tok-kw">anytype</span>';
+                } else {
+                  payloadHtml += "anytype";
+                }
               }
-        }
+            }
 
-        }
-    }
+            payloadHtml += "<span class='argBreaker'>,<br></span>";
+            payloadHtml += ") ";
 
+            if (fnObj.has_align) {
+              let align = zigAnalysis.exprs[fnObj.align];
+              payloadHtml += "align(" + exprName(align, opts) + ") ";
+            }
+            if (fnObj.has_cc) {
+              let cc = zigAnalysis.exprs[fnObj.cc];
+              if (cc) {
+                payloadHtml += "callconv(." + cc.enumLiteral + ") ";
+              }
+            }
 
-    
-    function shouldSkipParamName(typeRef, paramName) {
-        let resolvedTypeRef = resolveValue({expr: typeRef});
-        if ("type" in resolvedTypeRef) {
-            let typeObj = zigAnalysis.types[resolvedTypeRef.type];
-            if (typeObj.kind === typeKinds.Pointer){
-                let ptrObj = (typeObj);
-                if (getPtrSize(ptrObj) === pointerSizeEnum.One) {
-                    const value = resolveValue(ptrObj.child);
-                    return typeValueName(value, false, true).toLowerCase() === paramName;
-                }
+            if (fnObj.is_inferred_error) {
+              payloadHtml += "!";
+            }
+            if (fnObj.ret != null) {
+              payloadHtml += exprName(fnObj.ret, opts);
+            } else if (opts.wantHtml) {
+              payloadHtml += '<span class="tok-kw">anytype</span>';
+            } else {
+              payloadHtml += "anytype";
             }
+            return payloadHtml;
+          }
+          // if (wantHtml) {
+          //     return escapeHtml(typeObj.name);
+          // } else {
+          //     return typeObj.name;
+          // }
         }
-        return false;
+      }
     }
-
-    
-    function getPtrSize(typeObj) {
-        return (typeObj.size == null) ? pointerSizeEnum.One : typeObj.size;
+  }
+
+  function shouldSkipParamName(typeRef, paramName) {
+    let resolvedTypeRef = resolveValue({ expr: typeRef });
+    if ("type" in resolvedTypeRef) {
+      let typeObj = zigAnalysis.types[resolvedTypeRef.type];
+      if (typeObj.kind === typeKinds.Pointer) {
+        let ptrObj = typeObj;
+        if (getPtrSize(ptrObj) === pointerSizeEnum.One) {
+          const value = resolveValue(ptrObj.child);
+          return typeValueName(value, false, true).toLowerCase() === paramName;
+        }
+      }
     }
-
-    
-    function renderType(typeObj) {
-        let name;
-        if (rootIsStd && typeObj === zigAnalysis.types[zigAnalysis.packages[zigAnalysis.rootPkg].main]) {
-            name = "std";
+    return false;
+  }
+
+  function getPtrSize(typeObj) {
+    return typeObj.size == null ? pointerSizeEnum.One : typeObj.size;
+  }
+
+  function renderType(typeObj) {
+    let name;
+    if (
+      rootIsStd &&
+      typeObj ===
+        zigAnalysis.types[zigAnalysis.packages[zigAnalysis.rootPkg].main]
+    ) {
+      name = "std";
+    } else {
+      name = exprName({ type: typeObj }, false, false);
+    }
+    if (name != null && name != "") {
+      domHdrName.innerText =
+        name + " (" + zigAnalysis.typeKinds[typeObj.kind] + ")";
+      domHdrName.classList.remove("hidden");
+    }
+    if (typeObj.kind == typeKinds.ErrorSet) {
+      renderErrorSet(typeObj);
+    }
+  }
+
+  function renderErrorSet(errSetType) {
+    if (errSetType.fields == null) {
+      domFnErrorsAnyError.classList.remove("hidden");
+    } else {
+      let errorList = [];
+      for (let i = 0; i < errSetType.fields.length; i += 1) {
+        let errObj = errSetType.fields[i];
+        //let srcObj = zigAnalysis.astNodes[errObj.src];
+        errorList.push(errObj);
+      }
+      errorList.sort(function (a, b) {
+        return operatorCompare(a.name.toLowerCase(), b.name.toLowerCase());
+      });
+
+      resizeDomListDl(domListFnErrors, errorList.length);
+      for (let i = 0; i < errorList.length; i += 1) {
+        let nameTdDom = domListFnErrors.children[i * 2 + 0];
+        let descTdDom = domListFnErrors.children[i * 2 + 1];
+        nameTdDom.textContent = errorList[i].name;
+        let docs = errorList[i].docs;
+        if (docs != null) {
+          descTdDom.innerHTML = markdown(docs);
         } else {
-            name = exprName({type:typeObj}, false, false);
-        }
-        if (name != null && name != "") {
-            domHdrName.innerText = name + " (" + zigAnalysis.typeKinds[typeObj.kind] + ")";
-            domHdrName.classList.remove("hidden");
-        }
-        if (typeObj.kind == typeKinds.ErrorSet) {
-            renderErrorSet((typeObj));
+          descTdDom.textContent = "";
         }
+      }
+      domTableFnErrors.classList.remove("hidden");
+    }
+    domSectFnErrors.classList.remove("hidden");
+  }
+
+  //     function allCompTimeFnCallsHaveTypeResult(typeIndex, value) {
+  //         let srcIndex = zigAnalysis.fns[value].src;
+  //         let calls = nodesToCallsMap[srcIndex];
+  //         if (calls == null) return false;
+  //         for (let i = 0; i < calls.length; i += 1) {
+  //             let call = zigAnalysis.calls[calls[i]];
+  //             if (call.result.type !== typeTypeId) return false;
+  //         }
+  //         return true;
+  //     }
+  //
+  //     function allCompTimeFnCallsResult(calls) {
+  //         let firstTypeObj = null;
+  //         let containerObj = {
+  //             privDecls: [],
+  //         };
+  //         for (let callI = 0; callI < calls.length; callI += 1) {
+  //             let call = zigAnalysis.calls[calls[callI]];
+  //             if (call.result.type !== typeTypeId) return null;
+  //             let typeObj = zigAnalysis.types[call.result.value];
+  //             if (!typeKindIsContainer(typeObj.kind)) return null;
+  //             if (firstTypeObj == null) {
+  //                 firstTypeObj = typeObj;
+  //                 containerObj.src = typeObj.src;
+  //             } else if (firstTypeObj.src !== typeObj.src) {
+  //                 return null;
+  //             }
+  //
+  //             if (containerObj.fields == null) {
+  //                 containerObj.fields = (typeObj.fields || []).concat([]);
+  //             } else for (let fieldI = 0; fieldI < typeObj.fields.length; fieldI += 1) {
+  //                 let prev = containerObj.fields[fieldI];
+  //                 let next = typeObj.fields[fieldI];
+  //                 if (prev === next) continue;
+  //                 if (typeof(prev) === 'object') {
+  //                     if (prev[next] == null) prev[next] = typeObj;
+  //                 } else {
+  //                     containerObj.fields[fieldI] = {};
+  //                     containerObj.fields[fieldI][prev] = firstTypeObj;
+  //                     containerObj.fields[fieldI][next] = typeObj;
+  //                 }
+  //             }
+  //
+  //             if (containerObj.pubDecls == null) {
+  //                 containerObj.pubDecls = (typeObj.pubDecls || []).concat([]);
+  //             } else for (let declI = 0; declI < typeObj.pubDecls.length; declI += 1) {
+  //                 let prev = containerObj.pubDecls[declI];
+  //                 let next = typeObj.pubDecls[declI];
+  //                 if (prev === next) continue;
+  //                 // TODO instead of showing "examples" as the public declarations,
+  //                     // do logic like this:
+  //                 //if (typeof(prev) !== 'object') {
+  //                     //    let newDeclId = zigAnalysis.decls.length;
+  //                     //    prev = clone(zigAnalysis.decls[prev]);
+  //                     //    prev.id = newDeclId;
+  //                     //    zigAnalysis.decls.push(prev);
+  //                     //    containerObj.pubDecls[declI] = prev;
+  //                     //}
+  //                 //mergeDecls(prev, next, firstTypeObj, typeObj);
+  //             }
+  //         }
+  //         for (let declI = 0; declI < containerObj.pubDecls.length; declI += 1) {
+  //             let decl = containerObj.pubDecls[declI];
+  //             if (typeof(decl) === 'object') {
+  //                 containerObj.pubDecls[declI] = containerObj.pubDecls[declI].id;
+  //             }
+  //         }
+  //         return containerObj;
+  //     }
+
+  function renderValue(decl) {
+    let resolvedValue = resolveValue(decl.value);
+
+    if (resolvedValue.expr.fieldRef) {
+      const declRef = decl.value.expr.refPath[0].declRef;
+      const type = zigAnalysis.decls[declRef];
+      domFnProtoCode.innerHTML =
+        '<span class="tok-kw">const</span> ' +
+        escapeHtml(decl.name) +
+        ": " +
+        type.name +
+        " = " +
+        exprName(decl.value.expr, { wantHtml: true, wantLink: true }) +
+        ";";
+    } else if (
+      resolvedValue.expr.string !== undefined ||
+      resolvedValue.expr.call !== undefined ||
+      resolvedValue.expr.comptimeExpr
+    ) {
+      domFnProtoCode.innerHTML =
+        '<span class="tok-kw">const</span> ' +
+        escapeHtml(decl.name) +
+        ": " +
+        exprName(resolvedValue.expr, { wantHtml: true, wantLink: true }) +
+        " = " +
+        exprName(decl.value.expr, { wantHtml: true, wantLink: true }) +
+        ";";
+    } else if (resolvedValue.expr.compileError) {
+      domFnProtoCode.innerHTML =
+        '<span class="tok-kw">const</span> ' +
+        escapeHtml(decl.name) +
+        " = " +
+        exprName(decl.value.expr, { wantHtml: true, wantLink: true }) +
+        ";";
+    } else {
+      domFnProtoCode.innerHTML =
+        '<span class="tok-kw">const</span> ' +
+        escapeHtml(decl.name) +
+        ": " +
+        exprName(resolvedValue.typeRef, { wantHtml: true, wantLink: true }) +
+        " = " +
+        exprName(decl.value.expr, { wantHtml: true, wantLink: true }) +
+        ";";
     }
 
-    
-    function renderErrorSet(errSetType) {
-        if (errSetType.fields == null) {
-            domFnErrorsAnyError.classList.remove("hidden");
-        } else {
-            let errorList = [];
-            for (let i = 0; i < errSetType.fields.length; i += 1) {
-                let errObj = errSetType.fields[i];
-                //let srcObj = zigAnalysis.astNodes[errObj.src];
-                errorList.push(errObj);
-            }
-            errorList.sort(function(a, b) {
-                return operatorCompare(a.name.toLowerCase(), b.name.toLowerCase());
+    let docs = zigAnalysis.astNodes[decl.src].docs;
+    if (docs != null) {
+      domTldDocs.innerHTML = markdown(docs);
+      domTldDocs.classList.remove("hidden");
+    }
+
+    domFnProto.classList.remove("hidden");
+  }
+
+  function renderVar(decl) {
+    let declTypeRef = typeOfDecl(decl);
+    domFnProtoCode.innerHTML =
+      '<span class="tok-kw">var</span> ' +
+      escapeHtml(decl.name) +
+      ": " +
+      typeValueName(declTypeRef, true, true);
+
+    let docs = zigAnalysis.astNodes[decl.src].docs;
+    if (docs != null) {
+      domTldDocs.innerHTML = markdown(docs);
+      domTldDocs.classList.remove("hidden");
+    }
+
+    domFnProto.classList.remove("hidden");
+  }
+
+  function categorizeDecls(
+    decls,
+    typesList,
+    namespacesList,
+    errSetsList,
+    fnsList,
+    varsList,
+    valsList,
+    testsList
+  ) {
+    for (let i = 0; i < decls.length; i += 1) {
+      let decl = zigAnalysis.decls[decls[i]];
+      let declValue = resolveValue(decl.value);
+
+      if (decl.isTest) {
+        testsList.push(decl);
+        continue;
+      }
+
+      if (decl.kind === "var") {
+        varsList.push(decl);
+        continue;
+      }
+
+      if (decl.kind === "const") {
+        if ("type" in declValue.expr) {
+          // We have the actual type expression at hand.
+          const typeExpr = zigAnalysis.types[declValue.expr.type];
+          if (typeExpr.kind == typeKinds.Fn) {
+            const funcRetExpr = resolveValue({
+              expr: typeExpr.ret,
             });
-
-            resizeDomListDl(domListFnErrors, errorList.length);
-            for (let i = 0; i < errorList.length; i += 1) {
-                let nameTdDom = domListFnErrors.children[i * 2 + 0];
-                let descTdDom = domListFnErrors.children[i * 2 + 1];
-                nameTdDom.textContent = errorList[i].name;
-                let docs = errorList[i].docs;
-                if (docs != null) {
-                    descTdDom.innerHTML = markdown(docs);
-                } else {
-                    descTdDom.textContent = "";
-                }
+            if (
+              "type" in funcRetExpr.expr &&
+              funcRetExpr.expr.type == typeTypeId
+            ) {
+              if (typeIsErrSet(declValue.expr.type)) {
+                errSetsList.push(decl);
+              } else if (typeIsStructWithNoFields(declValue.expr.type)) {
+                namespacesList.push(decl);
+              } else {
+                typesList.push(decl);
+              }
+            } else {
+              fnsList.push(decl);
+            }
+          } else {
+            if (typeIsErrSet(declValue.expr.type)) {
+              errSetsList.push(decl);
+            } else if (typeIsStructWithNoFields(declValue.expr.type)) {
+              namespacesList.push(decl);
+            } else {
+              typesList.push(decl);
             }
-            domTableFnErrors.classList.remove("hidden");
+          }
+        } else if ("typeRef" in declValue) {
+          if ("type" in declValue.typeRef && declValue.typeRef == typeTypeId) {
+            // We don't know what the type expression is, but we know it's a type.
+            typesList.push(decl);
+          } else {
+            valsList.push(decl);
+          }
+        } else {
+          valsList.push(decl);
         }
-        domSectFnErrors.classList.remove("hidden");
+      }
     }
-
-//     function allCompTimeFnCallsHaveTypeResult(typeIndex, value) {
-//         let srcIndex = zigAnalysis.fns[value].src;
-//         let calls = nodesToCallsMap[srcIndex];
-//         if (calls == null) return false;
-//         for (let i = 0; i < calls.length; i += 1) {
-//             let call = zigAnalysis.calls[calls[i]];
-//             if (call.result.type !== typeTypeId) return false;
-//         }
-//         return true;
-//     }
-//
-//     function allCompTimeFnCallsResult(calls) {
-//         let firstTypeObj = null;
-//         let containerObj = {
-//             privDecls: [],
-//         };
-//         for (let callI = 0; callI < calls.length; callI += 1) {
-//             let call = zigAnalysis.calls[calls[callI]];
-//             if (call.result.type !== typeTypeId) return null;
-//             let typeObj = zigAnalysis.types[call.result.value];
-//             if (!typeKindIsContainer(typeObj.kind)) return null;
-//             if (firstTypeObj == null) {
-//                 firstTypeObj = typeObj;
-//                 containerObj.src = typeObj.src;
-//             } else if (firstTypeObj.src !== typeObj.src) {
-//                 return null;
-//             }
-//
-//             if (containerObj.fields == null) {
-//                 containerObj.fields = (typeObj.fields || []).concat([]);
-//             } else for (let fieldI = 0; fieldI < typeObj.fields.length; fieldI += 1) {
-//                 let prev = containerObj.fields[fieldI];
-//                 let next = typeObj.fields[fieldI];
-//                 if (prev === next) continue;
-//                 if (typeof(prev) === 'object') {
-//                     if (prev[next] == null) prev[next] = typeObj;
-//                 } else {
-//                     containerObj.fields[fieldI] = {};
-//                     containerObj.fields[fieldI][prev] = firstTypeObj;
-//                     containerObj.fields[fieldI][next] = typeObj;
-//                 }
-//             }
-//
-//             if (containerObj.pubDecls == null) {
-//                 containerObj.pubDecls = (typeObj.pubDecls || []).concat([]);
-//             } else for (let declI = 0; declI < typeObj.pubDecls.length; declI += 1) {
-//                 let prev = containerObj.pubDecls[declI];
-//                 let next = typeObj.pubDecls[declI];
-//                 if (prev === next) continue;
-//                 // TODO instead of showing "examples" as the public declarations,
-//                     // do logic like this:
-//                 //if (typeof(prev) !== 'object') {
-//                     //    let newDeclId = zigAnalysis.decls.length;
-//                     //    prev = clone(zigAnalysis.decls[prev]);
-//                     //    prev.id = newDeclId;
-//                     //    zigAnalysis.decls.push(prev);
-//                     //    containerObj.pubDecls[declI] = prev;
-//                     //}
-//                 //mergeDecls(prev, next, firstTypeObj, typeObj);
-//             }
-//         }
-//         for (let declI = 0; declI < containerObj.pubDecls.length; declI += 1) {
-//             let decl = containerObj.pubDecls[declI];
-//             if (typeof(decl) === 'object') {
-//                 containerObj.pubDecls[declI] = containerObj.pubDecls[declI].id;
-//             }
-//         }
-//         return containerObj;
-//     }
-
-
-
-    
-    function renderValue(decl) {
-        let resolvedValue = resolveValue(decl.value)
-
-      if (resolvedValue.expr.fieldRef) {
-        const declRef = decl.value.expr.refPath[0].declRef;
-        const type = zigAnalysis.decls[declRef];
-        domFnProtoCode.innerHTML = '<span class="tok-kw">const</span> ' +
-          escapeHtml(decl.name) + ': ' + type.name +
-          " = " + exprName(decl.value.expr, {wantHtml: true, wantLink:true}) + ";";
-      } else if (resolvedValue.expr.string !== undefined || resolvedValue.expr.call !== undefined || resolvedValue.expr.comptimeExpr) {
-        domFnProtoCode.innerHTML = '<span class="tok-kw">const</span> ' +
-          escapeHtml(decl.name) + ': ' + exprName(resolvedValue.expr, {wantHtml: true, wantLink:true}) +
-          " = " + exprName(decl.value.expr, {wantHtml: true, wantLink:true}) + ";";
-      } else if (resolvedValue.expr.compileError) {
-        domFnProtoCode.innerHTML = '<span class="tok-kw">const</span> ' +
-          escapeHtml(decl.name) + " = " + exprName(decl.value.expr, {wantHtml: true, wantLink:true}) + ";";
-      } 
-      else {
-        domFnProtoCode.innerHTML = '<span class="tok-kw">const</span> ' +
-          escapeHtml(decl.name) + ': ' + exprName(resolvedValue.typeRef, {wantHtml: true, wantLink:true}) +
-          " = " + exprName(decl.value.expr, {wantHtml: true, wantLink:true}) + ";";
+  }
+
+  function renderContainer(container) {
+    let typesList = [];
+
+    let namespacesList = [];
+
+    let errSetsList = [];
+
+    let fnsList = [];
+
+    let varsList = [];
+
+    let valsList = [];
+
+    let testsList = [];
+
+    categorizeDecls(
+      container.pubDecls,
+      typesList,
+      namespacesList,
+      errSetsList,
+      fnsList,
+      varsList,
+      valsList,
+      testsList
+    );
+    if (curNav.showPrivDecls)
+      categorizeDecls(
+        container.privDecls,
+        typesList,
+        namespacesList,
+        errSetsList,
+        fnsList,
+        varsList,
+        valsList,
+        testsList
+      );
+
+    typesList.sort(byNameProperty);
+    namespacesList.sort(byNameProperty);
+    errSetsList.sort(byNameProperty);
+    fnsList.sort(byNameProperty);
+    varsList.sort(byNameProperty);
+    valsList.sort(byNameProperty);
+    testsList.sort(byNameProperty);
+
+    if (container.src != null) {
+      let docs = zigAnalysis.astNodes[container.src].docs;
+      if (docs != null) {
+        domTldDocs.innerHTML = markdown(docs);
+        domTldDocs.classList.remove("hidden");
       }
-
-        let docs = zigAnalysis.astNodes[decl.src].docs;
-        if (docs != null) {
-            domTldDocs.innerHTML = markdown(docs);
-            domTldDocs.classList.remove("hidden");
-        }
-
-        domFnProto.classList.remove("hidden");
     }
 
-    
-    function renderVar(decl) {
-        let declTypeRef = typeOfDecl(decl);
-        domFnProtoCode.innerHTML = '<span class="tok-kw">var</span> ' +
-            escapeHtml(decl.name) + ': ' + typeValueName(declTypeRef, true, true);
-
-        let docs = zigAnalysis.astNodes[decl.src].docs;
-        if (docs != null) {
-            domTldDocs.innerHTML = markdown(docs);
-            domTldDocs.classList.remove("hidden");
-        }
+    if (typesList.length !== 0) {
+      window.x = typesList;
+      resizeDomList(
+        domListTypes,
+        typesList.length,
+        '<li><a href="#"></a></li>'
+      );
+      for (let i = 0; i < typesList.length; i += 1) {
+        let liDom = domListTypes.children[i];
+        let aDom = liDom.children[0];
+        let decl = typesList[i];
+        aDom.textContent = decl.name;
+        aDom.setAttribute("href", navLinkDecl(decl.name));
+      }
+      domSectTypes.classList.remove("hidden");
+    }
+    if (namespacesList.length !== 0) {
+      resizeDomList(
+        domListNamespaces,
+        namespacesList.length,
+        '<li><a href="#"></a></li>'
+      );
+      for (let i = 0; i < namespacesList.length; i += 1) {
+        let liDom = domListNamespaces.children[i];
+        let aDom = liDom.children[0];
+        let decl = namespacesList[i];
+        aDom.textContent = decl.name;
+        aDom.setAttribute("href", navLinkDecl(decl.name));
+      }
+      domSectNamespaces.classList.remove("hidden");
+    }
 
-        domFnProto.classList.remove("hidden");
+    if (errSetsList.length !== 0) {
+      resizeDomList(
+        domListErrSets,
+        errSetsList.length,
+        '<li><a href="#"></a></li>'
+      );
+      for (let i = 0; i < errSetsList.length; i += 1) {
+        let liDom = domListErrSets.children[i];
+        let aDom = liDom.children[0];
+        let decl = errSetsList[i];
+        aDom.textContent = decl.name;
+        aDom.setAttribute("href", navLinkDecl(decl.name));
+      }
+      domSectErrSets.classList.remove("hidden");
     }
 
+    if (fnsList.length !== 0) {
+      resizeDomList(
+        domListFns,
+        fnsList.length,
+        "<div><dt></dt><dd></dd></div>"
+      );
 
-    
-    function categorizeDecls(decls,
-        typesList, namespacesList, errSetsList,
-        fnsList, varsList, valsList, testsList) {
+      for (let i = 0; i < fnsList.length; i += 1) {
+        let decl = fnsList[i];
+        let trDom = domListFns.children[i];
 
-        for (let i = 0; i < decls.length; i += 1) {
-            let decl = zigAnalysis.decls[decls[i]];
-            let declValue = resolveValue(decl.value);
+        let tdFnCode = trDom.children[0];
+        let tdDesc = trDom.children[1];
 
-            if (decl.isTest) {
-                testsList.push(decl);
-                continue;
-            }
+        let declType = resolveValue(decl.value);
+        console.assert("type" in declType.expr);
 
-            if (decl.kind === 'var') {
-                varsList.push(decl);
-                continue;
-            }
+        tdFnCode.innerHTML = exprName(declType.expr, {
+          wantHtml: true,
+          wantLink: true,
+          fnDecl: decl,
+          linkFnNameDecl: navLinkDecl(decl.name),
+        });
 
-            if (decl.kind === 'const') {
-                if ("type" in declValue.expr) {
-                    // We have the actual type expression at hand.
-                    const typeExpr = zigAnalysis.types[declValue.expr.type];
-                    if (typeExpr.kind == typeKinds.Fn) {
-                        const funcRetExpr = resolveValue({
-                            expr: (typeExpr).ret
-                        });
-                        if ("type" in funcRetExpr.expr && funcRetExpr.expr.type == typeTypeId) {
-                            if (typeIsErrSet(declValue.expr.type)) {
-                                errSetsList.push(decl);
-                            } else if (typeIsStructWithNoFields(declValue.expr.type)) {
-                                namespacesList.push(decl);
-                            } else {
-                                typesList.push(decl);
-                            }
-                        } else {
-                            fnsList.push(decl);
-                        }
-                    } else {
-                        if (typeIsErrSet(declValue.expr.type)) {
-                            errSetsList.push(decl);
-                        } else if (typeIsStructWithNoFields(declValue.expr.type)) {
-                            namespacesList.push(decl);
-                        } else {
-                            typesList.push(decl);
-                        }
-                    }
-                 } else if ("typeRef" in declValue) {
-                      if ("type" in declValue.typeRef && declValue.typeRef == typeTypeId) {
-                          // We don't know what the type expression is, but we know it's a type.
-                          typesList.push(decl);
-                      } else {
-                          valsList.push(decl);
-                      }
-                } else {
-                    valsList.push(decl);
-                }
-            }
+        let docs = zigAnalysis.astNodes[decl.src].docs;
+        if (docs != null) {
+          tdDesc.innerHTML = shortDescMarkdown(docs);
+        } else {
+          tdDesc.textContent = "";
         }
+      }
+      domSectFns.classList.remove("hidden");
     }
 
-    
-    function renderContainer(container) {
-        
-        let typesList = [];
-        
-        let namespacesList = [];
-        
-        let errSetsList = [];
-        
-        let fnsList = [];
-        
-        let varsList = [];
-        
-        let valsList = [];
-        
-        let testsList = [];
-
-        categorizeDecls(container.pubDecls,
-            typesList, namespacesList, errSetsList,
-            fnsList, varsList, valsList, testsList);
-        if (curNav.showPrivDecls) categorizeDecls(container.privDecls,
-            typesList, namespacesList, errSetsList,
-            fnsList, varsList, valsList, testsList);
-
-
-        typesList.sort(byNameProperty);
-        namespacesList.sort(byNameProperty);
-        errSetsList.sort(byNameProperty);
-        fnsList.sort(byNameProperty);
-        varsList.sort(byNameProperty);
-        valsList.sort(byNameProperty);
-        testsList.sort(byNameProperty);
-
-        if (container.src != null) {
-            let docs = zigAnalysis.astNodes[container.src].docs;
-            if (docs != null) {
-                domTldDocs.innerHTML = markdown(docs);
-                domTldDocs.classList.remove("hidden");
-            }
+    let containerNode = zigAnalysis.astNodes[container.src];
+    if (containerNode.fields && containerNode.fields.length > 0) {
+      resizeDomList(domListFields, containerNode.fields.length, "<div></div>");
+
+      for (let i = 0; i < containerNode.fields.length; i += 1) {
+        let fieldNode = zigAnalysis.astNodes[containerNode.fields[i]];
+        let divDom = domListFields.children[i];
+        let fieldName = fieldNode.name;
+        let docs = fieldNode.docs;
+        let docsNonEmpty = docs != null && docs !== "";
+        let extraPreClass = docsNonEmpty ? " fieldHasDocs" : "";
+
+        let html =
+          '<div class="mobile-scroll-container"><pre class="scroll-item' +
+          extraPreClass +
+          '">' +
+          escapeHtml(fieldName);
+
+        if (container.kind === typeKinds.Enum) {
+          html += ' = <span class="tok-number">' + fieldName + "</span>";
+        } else {
+          let fieldTypeExpr = container.fields[i];
+          html += ": ";
+          let name = exprName(fieldTypeExpr, false, false);
+          html += '<span class="tok-kw">' + name + "</span>";
+          let tsn = typeShorthandName(fieldTypeExpr);
+          if (tsn) {
+            html += "<span> (" + tsn + ")</span>";
+          }
         }
 
-        if (typesList.length !== 0) {
-            window.x = typesList;
-            resizeDomList(domListTypes, typesList.length, '<li><a href="#"></a></li>');
-            for (let i = 0; i < typesList.length; i += 1) {
-                let liDom = domListTypes.children[i];
-                let aDom = liDom.children[0];
-                let decl = typesList[i];
-                aDom.textContent = decl.name;
-                aDom.setAttribute('href', navLinkDecl(decl.name));
-            }
-            domSectTypes.classList.remove("hidden");
-        }
-        if (namespacesList.length !== 0) {
-            resizeDomList(domListNamespaces, namespacesList.length, '<li><a href="#"></a></li>');
-            for (let i = 0; i < namespacesList.length; i += 1) {
-                let liDom = domListNamespaces.children[i];
-                let aDom = liDom.children[0];
-                let decl = namespacesList[i];
-                aDom.textContent = decl.name;
-                aDom.setAttribute('href', navLinkDecl(decl.name));
-            }
-            domSectNamespaces.classList.remove("hidden");
-        }
+        html += ",</pre></div>";
 
-        if (errSetsList.length !== 0) {
-            resizeDomList(domListErrSets, errSetsList.length, '<li><a href="#"></a></li>');
-            for (let i = 0; i < errSetsList.length; i += 1) {
-                let liDom = domListErrSets.children[i];
-                let aDom = liDom.children[0];
-                let decl = errSetsList[i];
-                aDom.textContent = decl.name;
-                aDom.setAttribute('href', navLinkDecl(decl.name));
-            }
-            domSectErrSets.classList.remove("hidden");
+        if (docsNonEmpty) {
+          html += '<div class="fieldDocs">' + markdown(docs) + "</div>";
         }
+        divDom.innerHTML = html;
+      }
+      domSectFields.classList.remove("hidden");
+    }
 
-        if (fnsList.length !== 0) {
-            resizeDomList(domListFns, fnsList.length, '<div><dt></dt><dd></dd></div>');
-
-            for (let i = 0; i < fnsList.length; i += 1) {
-                let decl = fnsList[i];
-                let trDom = domListFns.children[i];
-
-                let tdFnCode = trDom.children[0];
-                let tdDesc = trDom.children[1];
-
-                let declType = resolveValue(decl.value);
-                console.assert("type" in declType.expr);
+    if (varsList.length !== 0) {
+      resizeDomList(
+        domListGlobalVars,
+        varsList.length,
+        '<tr><td><a href="#"></a></td><td></td><td></td></tr>'
+      );
+      for (let i = 0; i < varsList.length; i += 1) {
+        let decl = varsList[i];
+        let trDom = domListGlobalVars.children[i];
 
-                tdFnCode.innerHTML = exprName(declType.expr,{
-                  wantHtml: true,
-                  wantLink: true,
-                  fnDecl: decl,
-                  linkFnNameDecl: navLinkDecl(decl.name),
-                });
+        let tdName = trDom.children[0];
+        let tdNameA = tdName.children[0];
+        let tdType = trDom.children[1];
+        let tdDesc = trDom.children[2];
 
-                let docs = zigAnalysis.astNodes[decl.src].docs;
-                if (docs != null) {
-                    tdDesc.innerHTML = shortDescMarkdown(docs);
-                } else {
-                    tdDesc.textContent = "";
-                }
-            }
-            domSectFns.classList.remove("hidden");
-        }
+        tdNameA.setAttribute("href", navLinkDecl(decl.name));
+        tdNameA.textContent = decl.name;
 
-        let containerNode = zigAnalysis.astNodes[container.src];
-        if (containerNode.fields && containerNode.fields.length > 0) {
-            resizeDomList(domListFields, containerNode.fields.length, '<div></div>');
-
-            for (let i = 0; i < containerNode.fields.length; i += 1) {
-                let fieldNode = zigAnalysis.astNodes[containerNode.fields[i]];
-                let divDom = domListFields.children[i];
-                let fieldName = (fieldNode.name);
-                let docs = fieldNode.docs;
-                let docsNonEmpty = docs != null && docs !== "";
-                let extraPreClass = docsNonEmpty ? " fieldHasDocs" : "";
-
-                let html = '<div class="mobile-scroll-container"><pre class="scroll-item' + extraPreClass + '">' + escapeHtml(fieldName);
-
-                if (container.kind === typeKinds.Enum) {
-                    html += ' = <span class="tok-number">' + fieldName + '</span>';
-                } else {
-                    let fieldTypeExpr = container.fields[i];
-                    html += ": ";
-                    let name = exprName(fieldTypeExpr, false, false);
-                    html += '<span class="tok-kw">'+ name +'</span>';
-                    let tsn = typeShorthandName(fieldTypeExpr);
-                    if (tsn) {
-                        html += '<span> ('+ tsn +')</span>';
-
-                    }
-                }
-
-                html += ',</pre></div>';
-
-                if (docsNonEmpty) {
-                    html += '<div class="fieldDocs">' + markdown(docs) + '</div>';
-                }
-                divDom.innerHTML = html;
-            }
-            domSectFields.classList.remove("hidden");
-        }
+        tdType.innerHTML = typeValueName(typeOfDecl(decl), true, true);
 
-        if (varsList.length !== 0) {
-            resizeDomList(domListGlobalVars, varsList.length,
-                '<tr><td><a href="#"></a></td><td></td><td></td></tr>');
-            for (let i = 0; i < varsList.length; i += 1) {
-                let decl = varsList[i];
-                let trDom = domListGlobalVars.children[i];
-
-                let tdName = trDom.children[0];
-                let tdNameA = tdName.children[0];
-                let tdType = trDom.children[1];
-                let tdDesc = trDom.children[2];
-
-                tdNameA.setAttribute('href', navLinkDecl(decl.name));
-                tdNameA.textContent = decl.name;
-
-                tdType.innerHTML = typeValueName(typeOfDecl(decl), true, true);
-
-                let docs = zigAnalysis.astNodes[decl.src].docs;
-                if (docs != null) {
-                    tdDesc.innerHTML = shortDescMarkdown(docs);
-                } else {
-                    tdDesc.textContent = "";
-                }
-            }
-            domSectGlobalVars.classList.remove("hidden");
+        let docs = zigAnalysis.astNodes[decl.src].docs;
+        if (docs != null) {
+          tdDesc.innerHTML = shortDescMarkdown(docs);
+        } else {
+          tdDesc.textContent = "";
         }
+      }
+      domSectGlobalVars.classList.remove("hidden");
+    }
 
-        if (valsList.length !== 0) {
-            resizeDomList(domListValues, valsList.length,
-                '<tr><td><a href="#"></a></td><td></td><td></td></tr>');
-            for (let i = 0; i < valsList.length; i += 1) {
-                let decl = valsList[i];
-                let trDom = domListValues.children[i];
-
-                let tdName = trDom.children[0];
-                let tdNameA = tdName.children[0];
-                let tdType = trDom.children[1];
-                let tdDesc = trDom.children[2];
-
-                tdNameA.setAttribute('href', navLinkDecl(decl.name));
-                tdNameA.textContent = decl.name;
-
-                tdType.innerHTML = exprName(walkResultTypeRef(decl.value),
-                  {wantHtml:true, wantLink:true});
-
-                let docs = zigAnalysis.astNodes[decl.src].docs;
-                if (docs != null) {
-                    tdDesc.innerHTML = shortDescMarkdown(docs);
-                } else {
-                    tdDesc.textContent = "";
-                }
-            }
-            domSectValues.classList.remove("hidden");
-        }
+    if (valsList.length !== 0) {
+      resizeDomList(
+        domListValues,
+        valsList.length,
+        '<tr><td><a href="#"></a></td><td></td><td></td></tr>'
+      );
+      for (let i = 0; i < valsList.length; i += 1) {
+        let decl = valsList[i];
+        let trDom = domListValues.children[i];
+
+        let tdName = trDom.children[0];
+        let tdNameA = tdName.children[0];
+        let tdType = trDom.children[1];
+        let tdDesc = trDom.children[2];
+
+        tdNameA.setAttribute("href", navLinkDecl(decl.name));
+        tdNameA.textContent = decl.name;
+
+        tdType.innerHTML = exprName(walkResultTypeRef(decl.value), {
+          wantHtml: true,
+          wantLink: true,
+        });
 
-        if (testsList.length !== 0) {
-            resizeDomList(domListTests, testsList.length,
-                '<tr><td><a href="#"></a></td><td></td><td></td></tr>');
-            for (let i = 0; i < testsList.length; i += 1) {
-                let decl = testsList[i];
-                let trDom = domListTests.children[i];
-
-                let tdName = trDom.children[0];
-                let tdNameA = tdName.children[0];
-                let tdType = trDom.children[1];
-                let tdDesc = trDom.children[2];
-
-                tdNameA.setAttribute('href', navLinkDecl(decl.name));
-                tdNameA.textContent = decl.name;
-
-                tdType.innerHTML = exprName(walkResultTypeRef(decl.value),
-                  {wantHtml:true, wantLink:true});
-
-                let docs = zigAnalysis.astNodes[decl.src].docs;
-                if (docs != null) {
-                    tdDesc.innerHTML = shortDescMarkdown(docs);
-                } else {
-                    tdDesc.textContent = "";
-                }
-            }
-            domSectTests.classList.remove("hidden");
+        let docs = zigAnalysis.astNodes[decl.src].docs;
+        if (docs != null) {
+          tdDesc.innerHTML = shortDescMarkdown(docs);
+        } else {
+          tdDesc.textContent = "";
         }
+      }
+      domSectValues.classList.remove("hidden");
     }
 
+    if (testsList.length !== 0) {
+      resizeDomList(
+        domListTests,
+        testsList.length,
+        '<tr><td><a href="#"></a></td><td></td><td></td></tr>'
+      );
+      for (let i = 0; i < testsList.length; i += 1) {
+        let decl = testsList[i];
+        let trDom = domListTests.children[i];
+
+        let tdName = trDom.children[0];
+        let tdNameA = tdName.children[0];
+        let tdType = trDom.children[1];
+        let tdDesc = trDom.children[2];
+
+        tdNameA.setAttribute("href", navLinkDecl(decl.name));
+        tdNameA.textContent = decl.name;
+
+        tdType.innerHTML = exprName(walkResultTypeRef(decl.value), {
+          wantHtml: true,
+          wantLink: true,
+        });
 
-    
-    function operatorCompare(a, b) {
-        if (a === b) {
-            return 0;
-        } else if (a < b) {
-            return -1;
+        let docs = zigAnalysis.astNodes[decl.src].docs;
+        if (docs != null) {
+          tdDesc.innerHTML = shortDescMarkdown(docs);
         } else {
-            return 1;
+          tdDesc.textContent = "";
         }
+      }
+      domSectTests.classList.remove("hidden");
     }
-
-    function detectRootIsStd() {
-        let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
-        if (rootPkg.table["std"] == null) {
-            // no std mapped into the root package
-            return false;
-        }
-        let stdPkg = zigAnalysis.packages[rootPkg.table["std"]];
-        if (stdPkg == null) return false;
-        return rootPkg.file === stdPkg.file;
+  }
+
+  function operatorCompare(a, b) {
+    if (a === b) {
+      return 0;
+    } else if (a < b) {
+      return -1;
+    } else {
+      return 1;
     }
+  }
 
-    function indexTypeKinds() {
-        let map = ({});
-        for (let i = 0; i < zigAnalysis.typeKinds.length; i += 1) {
-            map[zigAnalysis.typeKinds[i]] = i;
-        }
-        // This is just for debugging purposes, not needed to function
-        let assertList = ["Type","Void","Bool","NoReturn","Int","Float","Pointer","Array","Struct",
-            "ComptimeFloat","ComptimeInt","Undefined","Null","Optional","ErrorUnion","ErrorSet","Enum",
-            "Union","Fn","BoundFn","Opaque","Frame","AnyFrame","Vector","EnumLiteral"];
-        for (let i = 0; i < assertList.length; i += 1) {
-            if (map[assertList[i]] == null) throw new Error("No type kind '" + assertList[i] + "' found");
-        }
-        return map;
+  function detectRootIsStd() {
+    let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
+    if (rootPkg.table["std"] == null) {
+      // no std mapped into the root package
+      return false;
+    }
+    let stdPkg = zigAnalysis.packages[rootPkg.table["std"]];
+    if (stdPkg == null) return false;
+    return rootPkg.file === stdPkg.file;
+  }
+
+  function indexTypeKinds() {
+    let map = {};
+    for (let i = 0; i < zigAnalysis.typeKinds.length; i += 1) {
+      map[zigAnalysis.typeKinds[i]] = i;
+    }
+    // This is just for debugging purposes, not needed to function
+    let assertList = [
+      "Type",
+      "Void",
+      "Bool",
+      "NoReturn",
+      "Int",
+      "Float",
+      "Pointer",
+      "Array",
+      "Struct",
+      "ComptimeFloat",
+      "ComptimeInt",
+      "Undefined",
+      "Null",
+      "Optional",
+      "ErrorUnion",
+      "ErrorSet",
+      "Enum",
+      "Union",
+      "Fn",
+      "BoundFn",
+      "Opaque",
+      "Frame",
+      "AnyFrame",
+      "Vector",
+      "EnumLiteral",
+    ];
+    for (let i = 0; i < assertList.length; i += 1) {
+      if (map[assertList[i]] == null)
+        throw new Error("No type kind '" + assertList[i] + "' found");
     }
+    return map;
+  }
 
-    function findTypeTypeId() {
-        for (let i = 0; i < zigAnalysis.types.length; i += 1) {
-            if (zigAnalysis.types[i].kind == typeKinds.Type) {
-                return i;
-            }
-        }
-        throw new Error("No type 'type' found");
+  function findTypeTypeId() {
+    for (let i = 0; i < zigAnalysis.types.length; i += 1) {
+      if (zigAnalysis.types[i].kind == typeKinds.Type) {
+        return i;
+      }
     }
+    throw new Error("No type 'type' found");
+  }
+
+  function updateCurNav() {
+    curNav = {
+      showPrivDecls: false,
+      pkgNames: [],
+      pkgObjs: [],
+      declNames: [],
+      declObjs: [],
+      callName: null,
+    };
+    curNavSearch = "";
+
+    if (location.hash[0] === "#" && location.hash.length > 1) {
+      let query = location.hash.substring(1);
+      if (query[0] === "*") {
+        curNav.showPrivDecls = true;
+        query = query.substring(1);
+      }
 
-    function updateCurNav() {
-
-        curNav = {
-            showPrivDecls: false,
-            pkgNames: [],
-            pkgObjs: [],
-            declNames: [],
-            declObjs: [],
-            callName: null,
-        };
-        curNavSearch = "";
-
-        if (location.hash[0] === '#' && location.hash.length > 1) {
-            let query = location.hash.substring(1);
-            if (query[0] === '*') {
-              curNav.showPrivDecls = true;
-              query = query.substring(1);
-            }
+      let qpos = query.indexOf("?");
+      let nonSearchPart;
+      if (qpos === -1) {
+        nonSearchPart = query;
+      } else {
+        nonSearchPart = query.substring(0, qpos);
+        curNavSearch = decodeURIComponent(query.substring(qpos + 1));
+      }
 
-            let qpos = query.indexOf("?");
-            let nonSearchPart;
-            if (qpos === -1) {
-                nonSearchPart = query;
-            } else {
-                nonSearchPart = query.substring(0, qpos);
-                curNavSearch = decodeURIComponent(query.substring(qpos + 1));
-            }
+      let parts = nonSearchPart.split(";");
+      curNav.pkgNames = decodeURIComponent(parts[0]).split(".");
+      if (parts[1] != null) {
+        curNav.declNames = decodeURIComponent(parts[1]).split(".");
+      }
+    }
+  }
 
-            let parts = nonSearchPart.split(";");
-            curNav.pkgNames = decodeURIComponent(parts[0]).split(".");
-            if (parts[1] != null) {
-                curNav.declNames = decodeURIComponent(parts[1]).split(".");
+  function onHashChange() {
+    updateCurNav();
+    if (domSearch.value !== curNavSearch) {
+      domSearch.value = curNavSearch;
+    }
+    render();
+    if (imFeelingLucky) {
+      imFeelingLucky = false;
+      activateSelectedResult();
+    }
+  }
+
+  function findSubDecl(parentType, childName) {
+    {
+      // Generic functions
+      if ("value" in parentType) {
+        const rv = resolveValue(parentType.value);
+        if ("type" in rv.expr) {
+          const t = zigAnalysis.types[rv.expr.type];
+          if (t.kind == typeKinds.Fn && t.generic_ret != null) {
+            const rgr = resolveValue({ expr: t.generic_ret });
+            if ("type" in rgr.expr) {
+              parentType = zigAnalysis.types[rgr.expr.type];
             }
+          }
         }
+      }
     }
 
-    function onHashChange() {
-        updateCurNav();
-        if (domSearch.value !== curNavSearch) {
-            domSearch.value = curNavSearch;
-        }
-        render();
-        if (imFeelingLucky) {
-            imFeelingLucky = false;
-            activateSelectedResult();
-        }
+    if (!parentType.pubDecls) return null;
+    for (let i = 0; i < parentType.pubDecls.length; i += 1) {
+      let declIndex = parentType.pubDecls[i];
+      let childDecl = zigAnalysis.decls[declIndex];
+      if (childDecl.name === childName) {
+        return childDecl;
+      }
     }
+    if (!parentType.privDecls) return null;
+    for (let i = 0; i < parentType.privDecls.length; i += 1) {
+      let declIndex = parentType.privDecls[i];
+      let childDecl = zigAnalysis.decls[declIndex];
+      if (childDecl.name === childName) {
+        return childDecl;
+      }
+    }
+    return null;
+  }
+
+  function computeCanonicalPackagePaths() {
+    let list = new Array(zigAnalysis.packages.length);
+    // Now we try to find all the packages from root.
+    let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
+    // Breadth-first to keep the path shortest possible.
+    let stack = [
+      {
+        path: [],
+        pkg: rootPkg,
+      },
+    ];
+    while (stack.length !== 0) {
+      let item = stack.shift();
+      for (let key in item.pkg.table) {
+        let childPkgIndex = item.pkg.table[key];
+        if (list[childPkgIndex] != null) continue;
+        let childPkg = zigAnalysis.packages[childPkgIndex];
+        if (childPkg == null) continue;
+
+        let newPath = item.path.concat([key]);
+        list[childPkgIndex] = newPath;
+        stack.push({
+          path: newPath,
+          pkg: childPkg,
+        });
+      }
+    }
+    return list;
+  }
+
+  function computeCanonDeclPaths() {
+    let list = new Array(zigAnalysis.decls.length);
+    canonTypeDecls = new Array(zigAnalysis.types.length);
+
+    for (let pkgI = 0; pkgI < zigAnalysis.packages.length; pkgI += 1) {
+      if (pkgI === zigAnalysis.rootPkg && rootIsStd) continue;
+      let pkg = zigAnalysis.packages[pkgI];
+      let pkgNames = canonPkgPaths[pkgI];
+      if (pkgNames === undefined) continue;
 
-    
-    function findSubDecl(parentType, childName) {
+      let stack = [
         {
-            // Generic functions
-            if ("value" in parentType) {
-                const rv = resolveValue(parentType.value);
-                if ("type" in rv.expr) {
-                    const t = zigAnalysis.types[rv.expr.type];
-                    if (t.kind == typeKinds.Fn && t.generic_ret != null) {
-                        const rgr = resolveValue({expr: t.generic_ret});
-                        if ("type" in rgr.expr) {
-                            parentType = zigAnalysis.types[rgr.expr.type];
-                        }
-                    }
-                }
-            }
-        }
+          declNames: [],
+          type: zigAnalysis.types[pkg.main],
+        },
+      ];
+      while (stack.length !== 0) {
+        let item = stack.shift();
 
+        if (isContainerType(item.type)) {
+          let t = item.type;
 
-        if (!parentType.pubDecls) return null;
-        for (let i = 0; i < parentType.pubDecls.length; i += 1) {
-            let declIndex = parentType.pubDecls[i];
-            let childDecl = zigAnalysis.decls[declIndex];
-            if (childDecl.name === childName) {
-                return childDecl;
-            }
-        }
-        if (!parentType.privDecls) return null;
-        for (let i = 0; i < parentType.privDecls.length; i += 1) {
-            let declIndex = parentType.privDecls[i];
-            let childDecl = zigAnalysis.decls[declIndex];
-            if (childDecl.name === childName) {
-                return childDecl;
-            }
-        }
-        return null;
-    }
+          let len = t.pubDecls ? t.pubDecls.length : 0;
+          for (let declI = 0; declI < len; declI += 1) {
+            let mainDeclIndex = t.pubDecls[declI];
+            if (list[mainDeclIndex] != null) continue;
 
+            let decl = zigAnalysis.decls[mainDeclIndex];
+            let declVal = resolveValue(decl.value);
+            let declNames = item.declNames.concat([decl.name]);
+            list[mainDeclIndex] = {
+              pkgNames: pkgNames,
+              declNames: declNames,
+            };
+            if ("type" in declVal.expr) {
+              let value = zigAnalysis.types[declVal.expr.type];
+              if (declCanRepresentTypeKind(value.kind)) {
+                canonTypeDecls[declVal.type] = mainDeclIndex;
+              }
 
-
-
-    function computeCanonicalPackagePaths() {
-        let list = new Array(zigAnalysis.packages.length);
-        // Now we try to find all the packages from root.
-        let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
-        // Breadth-first to keep the path shortest possible.
-        let stack = [{
-            path: ([]),
-            pkg: rootPkg,
-        }];
-        while (stack.length !== 0) {
-            let item = (stack.shift());
-            for (let key in item.pkg.table) {
-                let childPkgIndex = item.pkg.table[key];
-                if (list[childPkgIndex] != null) continue;
-                let childPkg = zigAnalysis.packages[childPkgIndex];
-                if (childPkg == null) continue;
-
-                let newPath = item.path.concat([key])
-                list[childPkgIndex] = newPath;
+              if (isContainerType(value)) {
                 stack.push({
-                    path: newPath,
-                    pkg: childPkg,
+                  declNames: declNames,
+                  type: value,
                 });
-            }
-        }
-        return list;
-    }
-
-
-    
-    function computeCanonDeclPaths() {
-        let list = new Array(zigAnalysis.decls.length);
-        canonTypeDecls = new Array(zigAnalysis.types.length);
-
-        for (let pkgI = 0; pkgI < zigAnalysis.packages.length; pkgI += 1) {
-            if (pkgI === zigAnalysis.rootPkg && rootIsStd) continue;
-            let pkg = zigAnalysis.packages[pkgI];
-            let pkgNames = canonPkgPaths[pkgI];
-            if (pkgNames === undefined) continue;
-
-            let stack = [{
-                declNames: ([]),
-                type: zigAnalysis.types[pkg.main],
-            }];
-            while (stack.length !== 0) {
-                let item = (stack.shift());
-
-                if (isContainerType(item.type)) {
-                    let t = (item.type);
-
-                    let len = t.pubDecls ? t.pubDecls.length : 0;
-                    for (let declI = 0; declI < len; declI += 1) {
-                        let mainDeclIndex = t.pubDecls[declI];
-                        if (list[mainDeclIndex] != null) continue;
-
-                        let decl = zigAnalysis.decls[mainDeclIndex];
-                        let declVal =  resolveValue(decl.value);
-                        let declNames = item.declNames.concat([decl.name]);
-                        list[mainDeclIndex] = {
-                            pkgNames: pkgNames,
-                            declNames: declNames,
-                        };
-                        if ("type" in declVal.expr) {
-                            let value = zigAnalysis.types[declVal.expr.type];
-                            if (declCanRepresentTypeKind(value.kind))
-                            {
-                                canonTypeDecls[declVal.type] = mainDeclIndex;
-                            }
-
-                            if (isContainerType(value)) {
-                                stack.push({
-                                    declNames: declNames,
-                                    type:value,
-                                });
-                            }
-                            
-                            
-                            // Generic fun/ction
-                            if (value.kind == typeKinds.Fn && value.generic_ret != null) {
-                                let resolvedVal = resolveValue({ expr: value.generic_ret});
-                                if ("type" in resolvedVal.expr) {
-                                    let generic_type = zigAnalysis.types[resolvedVal.expr.type];
-                                    if (isContainerType(generic_type)){
-                                        stack.push({
-                                            declNames: declNames,
-                                            type: generic_type,
-                                        });
-                                    }
-                                }
-                            }
-                        }
-                    }
+              }
+
+              // Generic fun/ction
+              if (value.kind == typeKinds.Fn && value.generic_ret != null) {
+                let resolvedVal = resolveValue({ expr: value.generic_ret });
+                if ("type" in resolvedVal.expr) {
+                  let generic_type = zigAnalysis.types[resolvedVal.expr.type];
+                  if (isContainerType(generic_type)) {
+                    stack.push({
+                      declNames: declNames,
+                      type: generic_type,
+                    });
+                  }
                 }
+              }
             }
+          }
         }
-        return list;
+      }
     }
+    return list;
+  }
 
-    
-    function getCanonDeclPath(index) {
-        if (canonDeclPaths == null) {
-            canonDeclPaths = computeCanonDeclPaths();
-        }
-        //let cd = (canonDeclPaths);
-        return canonDeclPaths[index];
+  function getCanonDeclPath(index) {
+    if (canonDeclPaths == null) {
+      canonDeclPaths = computeCanonDeclPaths();
     }
+    //let cd = (canonDeclPaths);
+    return canonDeclPaths[index];
+  }
 
-    
-    function getCanonTypeDecl(index) {
-        getCanonDeclPath(0);
-        //let ct = (canonTypeDecls);
-        return canonTypeDecls[index];
-    }
+  function getCanonTypeDecl(index) {
+    getCanonDeclPath(0);
+    //let ct = (canonTypeDecls);
+    return canonTypeDecls[index];
+  }
+
+  function escapeHtml(text) {
+    return text.replace(/[&"<>]/g, function (m) {
+      return escapeHtmlReplacements[m];
+    });
+  }
 
-    
-    function escapeHtml(text) {
-        return text.replace(/[&"<>]/g, function (m) {
-            return escapeHtmlReplacements[m];
-        });
+  function shortDescMarkdown(docs) {
+    const trimmed_docs = docs.trim();
+    let index = trimmed_docs.indexOf(".");
+    if (index < 0) {
+      index = trimmed_docs.indexOf("\n");
+      if (index < 0) {
+        index = trimmed_docs.length;
+      }
+    } else {
+      index += 1; // include the period
     }
+    const slice = trimmed_docs.slice(0, index);
+    return markdown(slice);
+  }
 
+  function markdown(input) {
+    const raw_lines = input.split("\n"); // zig allows no '\r', so we don't need to split on CR
 
-    function shortDescMarkdown(docs) {
-        const trimmed_docs = docs.trim();
-        let index = trimmed_docs.indexOf('.');
-        if (index < 0) {
-            index = trimmed_docs.indexOf('\n');
-            if (index < 0) {
-                index = trimmed_docs.length;
-            }
+    const lines = [];
+
+    // PHASE 1:
+    // Dissect lines and determine the type for each line.
+    // Also computes indentation level and removes unnecessary whitespace
+
+    let is_reading_code = false;
+    let code_indent = 0;
+    for (let line_no = 0; line_no < raw_lines.length; line_no++) {
+      const raw_line = raw_lines[line_no];
+
+      const line = {
+        indent: 0,
+        raw_text: raw_line,
+        text: raw_line.trim(),
+        type: "p", // p, h1 … h6, code, ul, ol, blockquote, skip, empty
+        ordered_number: -1, // NOTE: hack to make the type checker happy
+      };
+
+      if (!is_reading_code) {
+        while (
+          line.indent < line.raw_text.length &&
+          line.raw_text[line.indent] == " "
+        ) {
+          line.indent += 1;
+        }
+
+        if (line.text.startsWith("######")) {
+          line.type = "h6";
+          line.text = line.text.substr(6);
+        } else if (line.text.startsWith("#####")) {
+          line.type = "h5";
+          line.text = line.text.substr(5);
+        } else if (line.text.startsWith("####")) {
+          line.type = "h4";
+          line.text = line.text.substr(4);
+        } else if (line.text.startsWith("###")) {
+          line.type = "h3";
+          line.text = line.text.substr(3);
+        } else if (line.text.startsWith("##")) {
+          line.type = "h2";
+          line.text = line.text.substr(2);
+        } else if (line.text.startsWith("#")) {
+          line.type = "h1";
+          line.text = line.text.substr(1);
+        } else if (line.text.startsWith("-")) {
+          line.type = "ul";
+          line.text = line.text.substr(1);
+        } else if (line.text.match(/^\d+\..*$/)) {
+          // if line starts with {number}{dot}
+          const match = line.text.match(/(\d+)\./);
+          line.type = "ul";
+          line.text = line.text.substr(match[0].length);
+          line.ordered_number = Number(match[1].length);
+        } else if (line.text == "```") {
+          line.type = "skip";
+          is_reading_code = true;
+          code_indent = line.indent;
+        } else if (line.text == "") {
+          line.type = "empty";
+        }
+      } else {
+        if (line.text == "```") {
+          is_reading_code = false;
+          line.type = "skip";
         } else {
-            index += 1; // include the period
+          line.type = "code";
+          line.text = line.raw_text.substr(code_indent); // remove the indent of the ``` from all the code block
         }
-        const slice = trimmed_docs.slice(0, index);
-        return markdown(slice);
+      }
+
+      if (line.type != "skip") {
+        lines.push(line);
+      }
     }
 
+    // PHASE 2:
+    // Render HTML from markdown lines.
+    // Look at each line and emit fitting HTML code
 
-    function markdown(input) {
-        const raw_lines = input.split('\n'); // zig allows no '\r', so we don't need to split on CR
-        
-        const lines = [];
+    function markdownInlines(innerText) {
+      // inline types:
+      // **{INLINE}**       : <strong>
+      // __{INLINE}__       : <u>
+      // ~~{INLINE}~~       : <s>
+      //  *{INLINE}*        : <emph>
+      //  _{INLINE}_        : <emph>
+      //  `{TEXT}`          : <code>
+      //  [{INLINE}]({URL}) : <a>
+      // ![{TEXT}]({URL})   : <img>
+      // [[std;format.fmt]] : <a> (inner link)
 
-        // PHASE 1:
-        // Dissect lines and determine the type for each line.
-            // Also computes indentation level and removes unnecessary whitespace
+      const formats = [
+        {
+          marker: "**",
+          tag: "strong",
+        },
+        {
+          marker: "~~",
+          tag: "s",
+        },
+        {
+          marker: "__",
+          tag: "u",
+        },
+        {
+          marker: "*",
+          tag: "em",
+        },
+      ];
 
-        let is_reading_code = false;
-        let code_indent = 0;
-        for (let line_no = 0; line_no < raw_lines.length; line_no++) {
-            const raw_line = raw_lines[line_no];
+      const stack = [];
 
-            const line = {
-                indent: 0,
-                raw_text: raw_line,
-                text: raw_line.trim(),
-                type: "p", // p, h1 … h6, code, ul, ol, blockquote, skip, empty
-                ordered_number: -1, // NOTE: hack to make the type checker happy
-            };
+      let innerHTML = "";
+      let currentRun = "";
 
-            if (!is_reading_code) {
-                while ((line.indent < line.raw_text.length) && line.raw_text[line.indent] == ' ') {
-                    line.indent += 1;
-                }
-
-                if (line.text.startsWith("######")) {
-                    line.type = "h6";
-                    line.text = line.text.substr(6);
-                }
-                else if (line.text.startsWith("#####")) {
-                    line.type = "h5";
-                    line.text = line.text.substr(5);
-                }
-                else if (line.text.startsWith("####")) {
-                    line.type = "h4";
-                    line.text = line.text.substr(4);
-                }
-                else if (line.text.startsWith("###")) {
-                    line.type = "h3";
-                    line.text = line.text.substr(3);
-                }
-                else if (line.text.startsWith("##")) {
-                    line.type = "h2";
-                    line.text = line.text.substr(2);
-                }
-                else if (line.text.startsWith("#")) {
-                    line.type = "h1";
-                    line.text = line.text.substr(1);
-                }
-                else if (line.text.startsWith("-")) {
-                    line.type = "ul";
-                    line.text = line.text.substr(1);
-                }
-                else if (line.text.match(/^\d+\..*$/)) { // if line starts with {number}{dot}
-                    const match = (line.text.match(/(\d+)\./));
-                    line.type = "ul";
-                    line.text = line.text.substr(match[0].length);
-                    line.ordered_number = Number(match[1].length);
-                }
-                else if (line.text == "```") {
-                    line.type = "skip";
-                    is_reading_code = true;
-                    code_indent = line.indent;
-                }
-                else if (line.text == "") {
-                    line.type = "empty";
-                }
-            }
-            else {
-                if (line.text == "```") {
-                    is_reading_code = false;
-                    line.type = "skip";
-                } else {
-                    line.type = "code";
-                    line.text = line.raw_text.substr(code_indent); // remove the indent of the ``` from all the code block
-                }
-            }
-
-            if (line.type != "skip") {
-                lines.push(line);
-            }
+      function flushRun() {
+        if (currentRun != "") {
+          innerHTML += escapeHtml(currentRun);
         }
-
-        // PHASE 2:
-        // Render HTML from markdown lines.
-            // Look at each line and emit fitting HTML code
-
-        
-        function markdownInlines(innerText) {
-
-            // inline types:
-            // **{INLINE}**       : <strong>
-                // __{INLINE}__       : <u>
-                // ~~{INLINE}~~       : <s>
-                //  *{INLINE}*        : <emph>
-                //  _{INLINE}_        : <emph>
-                //  `{TEXT}`          : <code>
-                //  [{INLINE}]({URL}) : <a>
-                // ![{TEXT}]({URL})   : <img>
-                // [[std;format.fmt]] : <a> (inner link)
-
-            
-            
-            const formats = [
-                {
-                    marker: "**",
-                    tag: "strong",
-                },
-                {
-                    marker: "~~",
-                    tag: "s",
-                },
-                {
-                    marker: "__",
-                    tag: "u",
-                },
-                {
-                    marker: "*",
-                    tag: "em",
-                }
-            ];
-
-            
-            const stack = [];
-
-            let innerHTML = "";
-            let currentRun = "";
-
-            function flushRun() {
-                if (currentRun != "") {
-                    innerHTML += escapeHtml(currentRun);
-                }
-                currentRun = "";
-            }
-
-            let parsing_code = false;
-            let codetag = "";
-            let in_code = false;
-
-            for (let i = 0; i < innerText.length; i++) {
-
-                if (parsing_code && in_code) {
-                    if (innerText.substr(i, codetag.length) == codetag) {
-                        // remove leading and trailing whitespace if string both starts and ends with one.
-                            if (currentRun[0] == " " && currentRun[currentRun.length - 1] == " ") {
-                                currentRun = currentRun.substr(1, currentRun.length - 2);
-                            }
-                        flushRun();
-                        i += codetag.length - 1;
-                        in_code = false;
-                        parsing_code = false;
-                        innerHTML += "</code>";
-                        codetag = "";
-                    } else {
-                        currentRun += innerText[i];
-                    }
-                    continue;
-                }
-
-                if (innerText[i] == "`") {
-                    flushRun();
-                    if (!parsing_code) {
-                        innerHTML += "<code>";
-                    }
-                    parsing_code = true;
-                    codetag += "`";
-                    continue;
-                }
-
-                if (parsing_code) {
-                    currentRun += innerText[i];
-                    in_code = true;
-                } else {
-                    let any = false;
-                    for (let idx = (stack.length > 0 ? -1 : 0); idx < formats.length; idx++) {
-                        const fmt = idx >= 0 ? formats[idx] : stack[stack.length - 1];
-                        if (innerText.substr(i, fmt.marker.length) == fmt.marker) {
-                            flushRun();
-                            if (stack[stack.length - 1] == fmt) {
-                                stack.pop();
-                                innerHTML += "</" + fmt.tag + ">";
-                            } else {
-                                stack.push(fmt);
-                                innerHTML += "<" + fmt.tag + ">";
-                            }
-                            i += fmt.marker.length - 1;
-                            any = true;
-                            break;
-                        }
-                    }
-                    if (!any) {
-                        currentRun += innerText[i];
-                    }
-                }
+        currentRun = "";
+      }
+
+      let parsing_code = false;
+      let codetag = "";
+      let in_code = false;
+
+      for (let i = 0; i < innerText.length; i++) {
+        if (parsing_code && in_code) {
+          if (innerText.substr(i, codetag.length) == codetag) {
+            // remove leading and trailing whitespace if string both starts and ends with one.
+            if (
+              currentRun[0] == " " &&
+              currentRun[currentRun.length - 1] == " "
+            ) {
+              currentRun = currentRun.substr(1, currentRun.length - 2);
             }
             flushRun();
+            i += codetag.length - 1;
+            in_code = false;
+            parsing_code = false;
+            innerHTML += "</code>";
+            codetag = "";
+          } else {
+            currentRun += innerText[i];
+          }
+          continue;
+        }
 
-            while (stack.length > 0) {
-                const fmt = (stack.pop());
+        if (innerText[i] == "`") {
+          flushRun();
+          if (!parsing_code) {
+            innerHTML += "<code>";
+          }
+          parsing_code = true;
+          codetag += "`";
+          continue;
+        }
+
+        if (parsing_code) {
+          currentRun += innerText[i];
+          in_code = true;
+        } else {
+          let any = false;
+          for (
+            let idx = stack.length > 0 ? -1 : 0;
+            idx < formats.length;
+            idx++
+          ) {
+            const fmt = idx >= 0 ? formats[idx] : stack[stack.length - 1];
+            if (innerText.substr(i, fmt.marker.length) == fmt.marker) {
+              flushRun();
+              if (stack[stack.length - 1] == fmt) {
+                stack.pop();
                 innerHTML += "</" + fmt.tag + ">";
+              } else {
+                stack.push(fmt);
+                innerHTML += "<" + fmt.tag + ">";
+              }
+              i += fmt.marker.length - 1;
+              any = true;
+              break;
             }
-
-            return innerHTML;
+          }
+          if (!any) {
+            currentRun += innerText[i];
+          }
         }
+      }
+      flushRun();
 
-        
-        function previousLineIs(type, line_no) {
-            if (line_no > 0) {
-                return (lines[line_no - 1].type == type);
-            } else {
-                return false;
-            }
-        }
+      while (stack.length > 0) {
+        const fmt = stack.pop();
+        innerHTML += "</" + fmt.tag + ">";
+      }
 
-        
-        function nextLineIs(type, line_no) {
-            if (line_no < (lines.length - 1)) {
-                return (lines[line_no + 1].type == type);
-            } else {
-                return false;
-            }
-        }
+      return innerHTML;
+    }
 
-        
-        function getPreviousLineIndent(line_no) {
-            if (line_no > 0) {
-                return lines[line_no - 1].indent;
-            } else {
-                return 0;
-            }
-        }
+    function previousLineIs(type, line_no) {
+      if (line_no > 0) {
+        return lines[line_no - 1].type == type;
+      } else {
+        return false;
+      }
+    }
 
-        
-        function getNextLineIndent(line_no) {
-            if (line_no < (lines.length - 1)) {
-                return lines[line_no + 1].indent;
-            } else {
-                return 0;
-            }
-        }
+    function nextLineIs(type, line_no) {
+      if (line_no < lines.length - 1) {
+        return lines[line_no + 1].type == type;
+      } else {
+        return false;
+      }
+    }
 
-        let html = "";
-        for (let line_no = 0; line_no < lines.length; line_no++) {
-            const line = lines[line_no];
-
-
-
-            switch (line.type) {
-                case "h1":
-                case "h2":
-                case "h3":
-                case "h4":
-                case "h5":
-                case "h6":
-                    html += "<" + line.type + ">" + markdownInlines(line.text) + "</" + line.type + ">\n";
-                    break;
-
-                case "ul":
-                case "ol":
-                    if (!previousLineIs("ul", line_no) || getPreviousLineIndent(line_no) < line.indent) {
-                        html += "<" + line.type + ">\n";
-                    }
-
-                    html += "<li>" + markdownInlines(line.text) + "</li>\n";
-
-                    if (!nextLineIs("ul", line_no) || getNextLineIndent(line_no) < line.indent) {
-                        html += "</" + line.type + ">\n";
-                    }
-                    break;
-
-                case "p":
-                    if (!previousLineIs("p", line_no)) {
-                        html += "<p>\n";
-                    }
-                    html += markdownInlines(line.text) + "\n";
-                    if (!nextLineIs("p", line_no)) {
-                        html += "</p>\n";
-                    }
-                    break;
-
-                case "code":
-                    if (!previousLineIs("code", line_no)) {
-                        html += "<pre><code>";
-                    }
-                    html += escapeHtml(line.text) + "\n";
-                    if (!nextLineIs("code", line_no)) {
-                        html += "</code></pre>\n";
-                    }
-                    break;
-            }
-        }
+    function getPreviousLineIndent(line_no) {
+      if (line_no > 0) {
+        return lines[line_no - 1].indent;
+      } else {
+        return 0;
+      }
+    }
 
-        return html;
+    function getNextLineIndent(line_no) {
+      if (line_no < lines.length - 1) {
+        return lines[line_no + 1].indent;
+      } else {
+        return 0;
+      }
     }
 
-    function activateSelectedResult() {
-        if (domSectSearchResults.classList.contains("hidden")) {
-            return;
-        }
+    let html = "";
+    for (let line_no = 0; line_no < lines.length; line_no++) {
+      const line = lines[line_no];
+
+      switch (line.type) {
+        case "h1":
+        case "h2":
+        case "h3":
+        case "h4":
+        case "h5":
+        case "h6":
+          html +=
+            "<" +
+            line.type +
+            ">" +
+            markdownInlines(line.text) +
+            "</" +
+            line.type +
+            ">\n";
+          break;
+
+        case "ul":
+        case "ol":
+          if (
+            !previousLineIs("ul", line_no) ||
+            getPreviousLineIndent(line_no) < line.indent
+          ) {
+            html += "<" + line.type + ">\n";
+          }
+
+          html += "<li>" + markdownInlines(line.text) + "</li>\n";
+
+          if (
+            !nextLineIs("ul", line_no) ||
+            getNextLineIndent(line_no) < line.indent
+          ) {
+            html += "</" + line.type + ">\n";
+          }
+          break;
+
+        case "p":
+          if (!previousLineIs("p", line_no)) {
+            html += "<p>\n";
+          }
+          html += markdownInlines(line.text) + "\n";
+          if (!nextLineIs("p", line_no)) {
+            html += "</p>\n";
+          }
+          break;
+
+        case "code":
+          if (!previousLineIs("code", line_no)) {
+            html += "<pre><code>";
+          }
+          html += escapeHtml(line.text) + "\n";
+          if (!nextLineIs("code", line_no)) {
+            html += "</code></pre>\n";
+          }
+          break;
+      }
+    }
 
-        let liDom = domListSearchResults.children[curSearchIndex];
-        if (liDom == null && domListSearchResults.children.length !== 0) {
-            liDom = domListSearchResults.children[0];
-        }
-        if (liDom != null) {
-            let aDom = liDom.children[0];
-            location.href = (aDom.getAttribute("href"));
-            curSearchIndex = -1;
-        }
+    return html;
+  }
+
+  function activateSelectedResult() {
+    if (domSectSearchResults.classList.contains("hidden")) {
+      return;
+    }
+
+    let liDom = domListSearchResults.children[curSearchIndex];
+    if (liDom == null && domListSearchResults.children.length !== 0) {
+      liDom = domListSearchResults.children[0];
+    }
+    if (liDom != null) {
+      let aDom = liDom.children[0];
+      location.href = aDom.getAttribute("href");
+      curSearchIndex = -1;
+    }
+    domSearch.blur();
+  }
+
+  function onSearchKeyDown(ev) {
+    switch (getKeyString(ev)) {
+      case "Enter":
+        // detect if this search changes anything
+        let terms1 = getSearchTerms();
+        startSearch();
+        updateCurNav();
+        let terms2 = getSearchTerms();
+        // we might have to wait for onHashChange to trigger
+        imFeelingLucky = terms1.join(" ") !== terms2.join(" ");
+        if (!imFeelingLucky) activateSelectedResult();
+
+        ev.preventDefault();
+        ev.stopPropagation();
+        return;
+      case "Esc":
+        domSearch.value = "";
         domSearch.blur();
-    }
-
-    
-    function onSearchKeyDown(ev) {
-        switch (getKeyString(ev)) {
-            case "Enter":
-                // detect if this search changes anything
-                let terms1 = getSearchTerms();
-                startSearch();
-                updateCurNav();
-                let terms2 = getSearchTerms();
-                // we might have to wait for onHashChange to trigger
-                imFeelingLucky = (terms1.join(' ') !== terms2.join(' '));
-                if (!imFeelingLucky) activateSelectedResult();
-
-                ev.preventDefault();
-                ev.stopPropagation();
-                return;
-            case "Esc":
-                domSearch.value = "";
-                domSearch.blur();
-                curSearchIndex = -1;
-                ev.preventDefault();
-                ev.stopPropagation();
-                startSearch();
-                return;
-            case "Up":
-                moveSearchCursor(-1);
-                ev.preventDefault();
-                ev.stopPropagation();
-                return;
-            case "Down":
-                moveSearchCursor(1);
-                ev.preventDefault();
-                ev.stopPropagation();
-                return;
-            default:
-                if (ev.shiftKey || ev.ctrlKey || ev.altKey) return;
+        curSearchIndex = -1;
+        ev.preventDefault();
+        ev.stopPropagation();
+        startSearch();
+        return;
+      case "Up":
+        moveSearchCursor(-1);
+        ev.preventDefault();
+        ev.stopPropagation();
+        return;
+      case "Down":
+        moveSearchCursor(1);
+        ev.preventDefault();
+        ev.stopPropagation();
+        return;
+      default:
+        if (ev.shiftKey || ev.ctrlKey || ev.altKey) return;
 
-                curSearchIndex = -1;
-                ev.stopPropagation();
-                startAsyncSearch();
-                return;
-        }
+        curSearchIndex = -1;
+        ev.stopPropagation();
+        startAsyncSearch();
+        return;
     }
+  }
 
-
-    
-    function moveSearchCursor(dir) {
-        if (curSearchIndex < 0 || curSearchIndex >= domListSearchResults.children.length) {
-            if (dir > 0) {
-                curSearchIndex = -1 + dir;
-            } else if (dir < 0) {
-                curSearchIndex = domListSearchResults.children.length + dir;
-            }
-        } else {
-            curSearchIndex += dir;
-        }
-        if (curSearchIndex < 0) {
-            curSearchIndex = 0;
-        }
-        if (curSearchIndex >= domListSearchResults.children.length) {
-            curSearchIndex = domListSearchResults.children.length - 1;
-        }
-        renderSearchCursor();
+  function moveSearchCursor(dir) {
+    if (
+      curSearchIndex < 0 ||
+      curSearchIndex >= domListSearchResults.children.length
+    ) {
+      if (dir > 0) {
+        curSearchIndex = -1 + dir;
+      } else if (dir < 0) {
+        curSearchIndex = domListSearchResults.children.length + dir;
+      }
+    } else {
+      curSearchIndex += dir;
+    }
+    if (curSearchIndex < 0) {
+      curSearchIndex = 0;
     }
+    if (curSearchIndex >= domListSearchResults.children.length) {
+      curSearchIndex = domListSearchResults.children.length - 1;
+    }
+    renderSearchCursor();
+  }
 
-    
-    function getKeyString(ev) {
-        let name;
-        let ignoreShift = false;
-        switch (ev.which) {
-            case 13:
-                name = "Enter";
-                break;
-            case 27:
-                name = "Esc";
-                break;
-            case 38:
-                name = "Up";
-                break;
-            case 40:
-                name = "Down";
-                break;
-            default:
-                ignoreShift = true;
-                name = (ev.key != null) ? ev.key : String.fromCharCode(ev.charCode || ev.keyCode);
-        }
-        if (!ignoreShift && ev.shiftKey) name = "Shift+" + name;
-        if (ev.altKey) name = "Alt+" + name;
-        if (ev.ctrlKey) name = "Ctrl+" + name;
-        return name;
+  function getKeyString(ev) {
+    let name;
+    let ignoreShift = false;
+    switch (ev.which) {
+      case 13:
+        name = "Enter";
+        break;
+      case 27:
+        name = "Esc";
+        break;
+      case 38:
+        name = "Up";
+        break;
+      case 40:
+        name = "Down";
+        break;
+      default:
+        ignoreShift = true;
+        name =
+          ev.key != null
+            ? ev.key
+            : String.fromCharCode(ev.charCode || ev.keyCode);
     }
+    if (!ignoreShift && ev.shiftKey) name = "Shift+" + name;
+    if (ev.altKey) name = "Alt+" + name;
+    if (ev.ctrlKey) name = "Ctrl+" + name;
+    return name;
+  }
 
-    
-    function onWindowKeyDown(ev) {
-        switch (getKeyString(ev)) {
-            case "Esc":
-                if (!domHelpModal.classList.contains("hidden")) {
-                    domHelpModal.classList.add("hidden");
-                    ev.preventDefault();
-                    ev.stopPropagation();
-                }
-                break;
-            case "s":
-                domSearch.focus();
-                domSearch.select();
-                ev.preventDefault();
-                ev.stopPropagation();
-                startAsyncSearch();
-                break;
-            case "?":
-                    ev.preventDefault();
-                ev.stopPropagation();
-                showHelpModal();
-                break;
+  function onWindowKeyDown(ev) {
+    switch (getKeyString(ev)) {
+      case "Esc":
+        if (!domHelpModal.classList.contains("hidden")) {
+          domHelpModal.classList.add("hidden");
+          ev.preventDefault();
+          ev.stopPropagation();
         }
+        break;
+      case "s":
+        domSearch.focus();
+        domSearch.select();
+        ev.preventDefault();
+        ev.stopPropagation();
+        startAsyncSearch();
+        break;
+      case "?":
+        ev.preventDefault();
+        ev.stopPropagation();
+        showHelpModal();
+        break;
     }
+  }
 
-function showHelpModal() {
+  function showHelpModal() {
     domHelpModal.classList.remove("hidden");
-    domHelpModal.style.left = (window.innerWidth / 2 - domHelpModal.clientWidth / 2) + "px";
-    domHelpModal.style.top = (window.innerHeight / 2 - domHelpModal.clientHeight / 2) + "px";
+    domHelpModal.style.left =
+      window.innerWidth / 2 - domHelpModal.clientWidth / 2 + "px";
+    domHelpModal.style.top =
+      window.innerHeight / 2 - domHelpModal.clientHeight / 2 + "px";
     domHelpModal.focus();
-}
+  }
 
-function clearAsyncSearch() {
+  function clearAsyncSearch() {
     if (searchTimer != null) {
-        clearTimeout(searchTimer);
-        searchTimer = null;
+      clearTimeout(searchTimer);
+      searchTimer = null;
     }
-}
+  }
 
-function startAsyncSearch() {
+  function startAsyncSearch() {
     clearAsyncSearch();
     searchTimer = setTimeout(startSearch, 100);
-}
-function startSearch() {
+  }
+  function startSearch() {
     clearAsyncSearch();
     let oldHash = location.hash;
     let parts = oldHash.split("?");
-    let newPart2 = (domSearch.value === "") ? "" : ("?" + domSearch.value);
-    location.hash = (parts.length === 1) ? (oldHash + newPart2) : (parts[0] + newPart2);
-}
-function getSearchTerms() {
+    let newPart2 = domSearch.value === "" ? "" : "?" + domSearch.value;
+    location.hash =
+      parts.length === 1 ? oldHash + newPart2 : parts[0] + newPart2;
+  }
+  function getSearchTerms() {
     let list = curNavSearch.trim().split(/[ \r\n\t]+/);
     list.sort();
     return list;
-}
-function renderSearch() {
+  }
+  function renderSearch() {
     let matchedItems = [];
-    let ignoreCase = (curNavSearch.toLowerCase() === curNavSearch);
+    let ignoreCase = curNavSearch.toLowerCase() === curNavSearch;
     let terms = getSearchTerms();
 
-    decl_loop: for (let declIndex = 0; declIndex < zigAnalysis.decls.length; declIndex += 1) {
-        let canonPath = getCanonDeclPath(declIndex);
-        if (canonPath == null) continue;
+    decl_loop: for (
+      let declIndex = 0;
+      declIndex < zigAnalysis.decls.length;
+      declIndex += 1
+    ) {
+      let canonPath = getCanonDeclPath(declIndex);
+      if (canonPath == null) continue;
 
-        let decl = zigAnalysis.decls[declIndex];
-        let lastPkgName = canonPath.pkgNames[canonPath.pkgNames.length - 1];
-        let fullPathSearchText = lastPkgName + "." + canonPath.declNames.join('.');
-        let astNode = zigAnalysis.astNodes[decl.src];
-        let fileAndDocs = "" //zigAnalysis.files[astNode.file];
-        // TODO: understand what this piece of code is trying to achieve
-        //       also right now `files` are expressed as a hashmap.
-        if (astNode.docs != null) {
-            fileAndDocs += "\n" + astNode.docs;
-        }
-        let fullPathSearchTextLower = fullPathSearchText;
-        if (ignoreCase) {
-            fullPathSearchTextLower = fullPathSearchTextLower.toLowerCase();
-            fileAndDocs = fileAndDocs.toLowerCase();
-        }
+      let decl = zigAnalysis.decls[declIndex];
+      let lastPkgName = canonPath.pkgNames[canonPath.pkgNames.length - 1];
+      let fullPathSearchText =
+        lastPkgName + "." + canonPath.declNames.join(".");
+      let astNode = zigAnalysis.astNodes[decl.src];
+      let fileAndDocs = ""; //zigAnalysis.files[astNode.file];
+      // TODO: understand what this piece of code is trying to achieve
+      //       also right now `files` are expressed as a hashmap.
+      if (astNode.docs != null) {
+        fileAndDocs += "\n" + astNode.docs;
+      }
+      let fullPathSearchTextLower = fullPathSearchText;
+      if (ignoreCase) {
+        fullPathSearchTextLower = fullPathSearchTextLower.toLowerCase();
+        fileAndDocs = fileAndDocs.toLowerCase();
+      }
 
-        let points = 0;
-        for (let termIndex = 0; termIndex < terms.length; termIndex += 1) {
-            let term = terms[termIndex];
+      let points = 0;
+      for (let termIndex = 0; termIndex < terms.length; termIndex += 1) {
+        let term = terms[termIndex];
 
-            // exact, case sensitive match of full decl path
-            if (fullPathSearchText === term) {
-                points += 4;
-                continue;
-            }
-            // exact, case sensitive match of just decl name
-            if (decl.name == term) {
-                points += 3;
-                continue;
-            }
-            // substring, case insensitive match of full decl path
-            if (fullPathSearchTextLower.indexOf(term) >= 0) {
-                points += 2;
-                continue;
-            }
-            if (fileAndDocs.indexOf(term) >= 0) {
-                points += 1;
-                continue;
-            }
-
-            continue decl_loop;
+        // exact, case sensitive match of full decl path
+        if (fullPathSearchText === term) {
+          points += 4;
+          continue;
+        }
+        // exact, case sensitive match of just decl name
+        if (decl.name == term) {
+          points += 3;
+          continue;
         }
+        // substring, case insensitive match of full decl path
+        if (fullPathSearchTextLower.indexOf(term) >= 0) {
+          points += 2;
+          continue;
+        }
+        if (fileAndDocs.indexOf(term) >= 0) {
+          points += 1;
+          continue;
+        }
+
+        continue decl_loop;
+      }
 
-        matchedItems.push({
-            decl: decl,
-            path: canonPath,
-            points: points,
-        });
+      matchedItems.push({
+        decl: decl,
+        path: canonPath,
+        points: points,
+      });
     }
 
     if (matchedItems.length !== 0) {
-        resizeDomList(domListSearchResults, matchedItems.length, '<li><a href="#"></a></li>');
+      resizeDomList(
+        domListSearchResults,
+        matchedItems.length,
+        '<li><a href="#"></a></li>'
+      );
 
-        matchedItems.sort(function(a, b) {
-            let cmp = operatorCompare(b.points, a.points);
-            if (cmp != 0) return cmp;
-            return operatorCompare(a.decl.name, b.decl.name);
-        });
+      matchedItems.sort(function (a, b) {
+        let cmp = operatorCompare(b.points, a.points);
+        if (cmp != 0) return cmp;
+        return operatorCompare(a.decl.name, b.decl.name);
+      });
 
-        for (let i = 0; i < matchedItems.length; i += 1) {
-            let liDom = domListSearchResults.children[i];
-            let aDom = liDom.children[0];
-            let match = matchedItems[i];
-            let lastPkgName = match.path.pkgNames[match.path.pkgNames.length - 1];
-            aDom.textContent = lastPkgName + "." + match.path.declNames.join('.');
-            aDom.setAttribute('href', navLink(match.path.pkgNames, match.path.declNames));
-        }
-        renderSearchCursor();
+      for (let i = 0; i < matchedItems.length; i += 1) {
+        let liDom = domListSearchResults.children[i];
+        let aDom = liDom.children[0];
+        let match = matchedItems[i];
+        let lastPkgName = match.path.pkgNames[match.path.pkgNames.length - 1];
+        aDom.textContent = lastPkgName + "." + match.path.declNames.join(".");
+        aDom.setAttribute(
+          "href",
+          navLink(match.path.pkgNames, match.path.declNames)
+        );
+      }
+      renderSearchCursor();
 
-        domSectSearchResults.classList.remove("hidden");
+      domSectSearchResults.classList.remove("hidden");
     } else {
-        domSectSearchNoResults.classList.remove("hidden");
+      domSectSearchNoResults.classList.remove("hidden");
     }
-}
+  }
 
-function renderSearchCursor() {
+  function renderSearchCursor() {
     for (let i = 0; i < domListSearchResults.children.length; i += 1) {
-        let liDom = (domListSearchResults.children[i]);
-        if (curSearchIndex === i) {
-            liDom.classList.add("selected");
-        } else {
-            liDom.classList.remove("selected");
-        }
+      let liDom = domListSearchResults.children[i];
+      if (curSearchIndex === i) {
+        liDom.classList.add("selected");
+      } else {
+        liDom.classList.remove("selected");
+      }
     }
-}
+  }
 
+  // function indexNodesToCalls() {
+  //     let map = {};
+  //     for (let i = 0; i < zigAnalysis.calls.length; i += 1) {
+  //         let call = zigAnalysis.calls[i];
+  //         let fn = zigAnalysis.fns[call.fn];
+  //         if (map[fn.src] == null) {
+  //             map[fn.src] = [i];
+  //         } else {
+  //             map[fn.src].push(i);
+  //         }
+  //     }
+  //     return map;
+  // }
 
-
-// function indexNodesToCalls() {
-//     let map = {};
-//     for (let i = 0; i < zigAnalysis.calls.length; i += 1) {
-//         let call = zigAnalysis.calls[i];
-//         let fn = zigAnalysis.fns[call.fn];
-//         if (map[fn.src] == null) {
-//             map[fn.src] = [i];
-//         } else {
-//             map[fn.src].push(i);
-//         }
-//     }
-//     return map;
-// }
-
-
-
-function byNameProperty(a, b) {
+  function byNameProperty(a, b) {
     return operatorCompare(a.name, b.name);
-}
-
-
-
+  }
 })();
-- 
2.54.0


From 7afe7de4f0949a8af0d89ccd4b26808a9c07cc5c Mon Sep 17 00:00:00 2001
From: Austin Rude <rudedogg@users.noreply.github.com>
Date: Fri, 5 Aug 2022 21:45:46 -0600
Subject: [PATCH 024/290] autodoc: only modify the DOM once to display the
 search results

---
 lib/docs/main.js | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 41a03322d9afb9b9fdfb38c2cdcb3794f0865614..2b6417c0152bb0f0a3b7844edd670fae162bb8ff 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -3326,29 +3326,28 @@ var zigAnalysis;
     }
 
     if (matchedItems.length !== 0) {
-      resizeDomList(
-        domListSearchResults,
-        matchedItems.length,
-        '<li><a href="#"></a></li>'
-      );
-
       matchedItems.sort(function (a, b) {
         let cmp = operatorCompare(b.points, a.points);
         if (cmp != 0) return cmp;
         return operatorCompare(a.decl.name, b.decl.name);
       });
 
+      // Build up the list of search results
+      let matchedItemsHTML = "";
+
       for (let i = 0; i < matchedItems.length; i += 1) {
-        let liDom = domListSearchResults.children[i];
-        let aDom = liDom.children[0];
-        let match = matchedItems[i];
-        let lastPkgName = match.path.pkgNames[match.path.pkgNames.length - 1];
-        aDom.textContent = lastPkgName + "." + match.path.declNames.join(".");
-        aDom.setAttribute(
-          "href",
-          navLink(match.path.pkgNames, match.path.declNames)
-        );
+        const match = matchedItems[i];
+        const lastPkgName = match.path.pkgNames[match.path.pkgNames.length - 1];
+
+        const text = lastPkgName + "." + match.path.declNames.join(".");
+        const href = navLink(match.path.pkgNames, match.path.declNames);
+
+        matchedItemsHTML += `<li><a href="${href}">${text}</a></li>`;
       }
+
+      // Replace the search results using our newly constructed HTML string
+      domListSearchResults.innerHTML = matchedItemsHTML;
+
       renderSearchCursor();
 
       domSectSearchResults.classList.remove("hidden");
-- 
2.54.0


From 5c9826630dfb8a2f59663a569bb8e452359c9524 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 5 Aug 2022 17:10:01 -0700
Subject: [PATCH 025/290] Sema: elide safety of modulus and remainder division
 sometimes

Piggybacking on 40f8f0134f5da9baaefd0fdab529d5585fa46199, remainder
division, modulus, and `%` syntax no longer emit safety checks for a
comptime-known denominator.
---
 src/Sema.zig                                  | 573 +++++++++++-------
 test/cases/safety/modrem by zero.zig          |  20 +
 test/cases/safety/modulus by zero.zig         |  20 +
 ...ber.zig => remainder division by zero.zig} |   6 +-
 4 files changed, 382 insertions(+), 237 deletions(-)
 create mode 100644 test/cases/safety/modrem by zero.zig
 create mode 100644 test/cases/safety/modulus by zero.zig
 rename test/cases/safety/{remainder division by negative number.zig => remainder division by zero.zig} (69%)

diff --git a/src/Sema.zig b/src/Sema.zig
index ad8879c59918e6d0f52970ce2f7dbb07e1bf0022..76c077c1033a11c73db5466523a1ca5f64e61b57 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -876,9 +876,6 @@ fn analyzeBodyInner(
             .add       => try sema.zirArithmetic(block, inst, .add),
             .addwrap   => try sema.zirArithmetic(block, inst, .addwrap),
             .add_sat   => try sema.zirArithmetic(block, inst, .add_sat),
-            .mod_rem   => try sema.zirArithmetic(block, inst, .mod_rem),
-            .mod       => try sema.zirArithmetic(block, inst, .mod),
-            .rem       => try sema.zirArithmetic(block, inst, .rem),
             .mul       => try sema.zirArithmetic(block, inst, .mul),
             .mulwrap   => try sema.zirArithmetic(block, inst, .mulwrap),
             .mul_sat   => try sema.zirArithmetic(block, inst, .mul_sat),
@@ -891,6 +888,10 @@ fn analyzeBodyInner(
             .div_floor => try sema.zirDivFloor(block, inst),
             .div_trunc => try sema.zirDivTrunc(block, inst),
 
+            .mod_rem   => try sema.zirModRem(block, inst),
+            .mod       => try sema.zirMod(block, inst),
+            .rem       => try sema.zirRem(block, inst),
+
             .maximum => try sema.zirMinMax(block, inst, .max),
             .minimum => try sema.zirMinMax(block, inst, .min),
 
@@ -11621,6 +11622,341 @@ fn airTag(block: *Block, is_int: bool, normal: Air.Inst.Tag, optimized: Air.Inst
     };
 }
 
+fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+    const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
+    const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
+    const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
+    const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
+    const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
+    const lhs = try sema.resolveInst(extra.lhs);
+    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs_ty = sema.typeOf(lhs);
+    const rhs_ty = sema.typeOf(rhs);
+    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
+    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
+    try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
+    try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .mod_rem);
+
+    const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
+    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
+        .override = &[_]LazySrcLoc{ lhs_src, rhs_src },
+    });
+
+    const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
+    const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
+
+    const lhs_scalar_ty = lhs_ty.scalarType();
+    const rhs_scalar_ty = rhs_ty.scalarType();
+    const scalar_tag = resolved_type.scalarType().zigTypeTag();
+
+    const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt;
+
+    try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .mod_rem);
+
+    const mod = sema.mod;
+    const target = mod.getTarget();
+    const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(block, lhs_src, casted_lhs);
+    const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(block, rhs_src, casted_rhs);
+
+    const runtime_src = rs: {
+        // For integers:
+        // Either operand being undef is a compile error because there exists
+        // a possible value (TODO what is it?) that would invoke illegal behavior.
+        // TODO: can lhs undef be handled better?
+        //
+        // For floats:
+        // If the rhs is zero, compile error for division by zero.
+        // If the rhs is undefined, compile error because there is a possible
+        // value (zero) for which the division would be illegal behavior.
+        // If the lhs is undefined, result is undefined.
+        //
+        // For either one: if the result would be different between @mod and @rem,
+        // then emit a compile error saying you have to pick one.
+        if (is_int) {
+            if (maybe_lhs_val) |lhs_val| {
+                if (lhs_val.isUndef()) {
+                    return sema.failWithUseOfUndef(block, lhs_src);
+                }
+                if (try lhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
+                    return sema.addConstant(resolved_type, Value.zero);
+                }
+            } else if (lhs_scalar_ty.isSignedInt()) {
+                return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
+            }
+            if (maybe_rhs_val) |rhs_val| {
+                if (rhs_val.isUndef()) {
+                    return sema.failWithUseOfUndef(block, rhs_src);
+                }
+                if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
+                    return sema.failWithDivideByZero(block, rhs_src);
+                }
+                if (maybe_lhs_val) |lhs_val| {
+                    const rem_result = try lhs_val.intRem(rhs_val, resolved_type, sema.arena, target);
+                    // If this answer could possibly be different by doing `intMod`,
+                    // we must emit a compile error. Otherwise, it's OK.
+                    if ((try rhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) != (try lhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) and
+                        !(try rem_result.compareWithZeroAdvanced(.eq, sema.kit(block, src))))
+                    {
+                        const bad_src = if (try lhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src)))
+                            lhs_src
+                        else
+                            rhs_src;
+                        return sema.failWithModRemNegative(block, bad_src, lhs_ty, rhs_ty);
+                    }
+                    if (try lhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) {
+                        // Negative
+                        return sema.addConstant(resolved_type, Value.zero);
+                    }
+                    return sema.addConstant(resolved_type, rem_result);
+                }
+                break :rs lhs_src;
+            } else if (rhs_scalar_ty.isSignedInt()) {
+                return sema.failWithModRemNegative(block, rhs_src, lhs_ty, rhs_ty);
+            } else {
+                break :rs rhs_src;
+            }
+        }
+        // float operands
+        if (maybe_rhs_val) |rhs_val| {
+            if (rhs_val.isUndef()) {
+                return sema.failWithUseOfUndef(block, rhs_src);
+            }
+            if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
+                return sema.failWithDivideByZero(block, rhs_src);
+            }
+            if (try rhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) {
+                return sema.failWithModRemNegative(block, rhs_src, lhs_ty, rhs_ty);
+            }
+            if (maybe_lhs_val) |lhs_val| {
+                if (lhs_val.isUndef() or (try lhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src)))) {
+                    return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
+                }
+                return sema.addConstant(
+                    resolved_type,
+                    try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, target),
+                );
+            } else {
+                return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
+            }
+        } else {
+            return sema.failWithModRemNegative(block, rhs_src, lhs_ty, rhs_ty);
+        }
+    };
+
+    try sema.requireRuntimeBlock(block, src, runtime_src);
+
+    if (block.wantSafety()) {
+        try sema.addDivByZeroSafety(block, resolved_type, maybe_rhs_val, casted_rhs, is_int);
+    }
+
+    const air_tag = airTag(block, is_int, .rem, .rem_optimized);
+    return block.addBinOp(air_tag, casted_lhs, casted_rhs);
+}
+
+fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+    const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
+    const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
+    const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
+    const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
+    const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
+    const lhs = try sema.resolveInst(extra.lhs);
+    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs_ty = sema.typeOf(lhs);
+    const rhs_ty = sema.typeOf(rhs);
+    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
+    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
+    try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
+    try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .mod);
+
+    const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
+    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
+        .override = &[_]LazySrcLoc{ lhs_src, rhs_src },
+    });
+
+    const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
+    const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
+
+    const scalar_tag = resolved_type.scalarType().zigTypeTag();
+
+    const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt;
+
+    try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .mod);
+
+    const mod = sema.mod;
+    const target = mod.getTarget();
+    const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(block, lhs_src, casted_lhs);
+    const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(block, rhs_src, casted_rhs);
+
+    const runtime_src = rs: {
+        // For integers:
+        // Either operand being undef is a compile error because there exists
+        // a possible value (TODO what is it?) that would invoke illegal behavior.
+        // TODO: can lhs zero be handled better?
+        // TODO: can lhs undef be handled better?
+        //
+        // For floats:
+        // If the rhs is zero, compile error for division by zero.
+        // If the rhs is undefined, compile error because there is a possible
+        // value (zero) for which the division would be illegal behavior.
+        // If the lhs is undefined, result is undefined.
+        if (is_int) {
+            if (maybe_lhs_val) |lhs_val| {
+                if (lhs_val.isUndef()) {
+                    return sema.failWithUseOfUndef(block, lhs_src);
+                }
+            }
+            if (maybe_rhs_val) |rhs_val| {
+                if (rhs_val.isUndef()) {
+                    return sema.failWithUseOfUndef(block, rhs_src);
+                }
+                if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
+                    return sema.failWithDivideByZero(block, rhs_src);
+                }
+                if (maybe_lhs_val) |lhs_val| {
+                    return sema.addConstant(
+                        resolved_type,
+                        try lhs_val.intMod(rhs_val, resolved_type, sema.arena, target),
+                    );
+                }
+                break :rs lhs_src;
+            } else {
+                break :rs rhs_src;
+            }
+        }
+        // float operands
+        if (maybe_rhs_val) |rhs_val| {
+            if (rhs_val.isUndef()) {
+                return sema.failWithUseOfUndef(block, rhs_src);
+            }
+            if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
+                return sema.failWithDivideByZero(block, rhs_src);
+            }
+        }
+        if (maybe_lhs_val) |lhs_val| {
+            if (lhs_val.isUndef()) {
+                return sema.addConstUndef(resolved_type);
+            }
+            if (maybe_rhs_val) |rhs_val| {
+                return sema.addConstant(
+                    resolved_type,
+                    try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, target),
+                );
+            } else break :rs rhs_src;
+        } else break :rs lhs_src;
+    };
+
+    try sema.requireRuntimeBlock(block, src, runtime_src);
+
+    if (block.wantSafety()) {
+        try sema.addDivByZeroSafety(block, resolved_type, maybe_rhs_val, casted_rhs, is_int);
+    }
+
+    const air_tag = airTag(block, is_int, .mod, .mod_optimized);
+    return block.addBinOp(air_tag, casted_lhs, casted_rhs);
+}
+
+fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+    const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
+    const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
+    const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
+    const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
+    const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
+    const lhs = try sema.resolveInst(extra.lhs);
+    const rhs = try sema.resolveInst(extra.rhs);
+    const lhs_ty = sema.typeOf(lhs);
+    const rhs_ty = sema.typeOf(rhs);
+    const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison();
+    const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison();
+    try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
+    try sema.checkInvalidPtrArithmetic(block, src, lhs_ty, .rem);
+
+    const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
+    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
+        .override = &[_]LazySrcLoc{ lhs_src, rhs_src },
+    });
+
+    const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
+    const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
+
+    const scalar_tag = resolved_type.scalarType().zigTypeTag();
+
+    const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt;
+
+    try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .rem);
+
+    const mod = sema.mod;
+    const target = mod.getTarget();
+    const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(block, lhs_src, casted_lhs);
+    const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(block, rhs_src, casted_rhs);
+
+    const runtime_src = rs: {
+        // For integers:
+        // Either operand being undef is a compile error because there exists
+        // a possible value (TODO what is it?) that would invoke illegal behavior.
+        // TODO: can lhs zero be handled better?
+        // TODO: can lhs undef be handled better?
+        //
+        // For floats:
+        // If the rhs is zero, compile error for division by zero.
+        // If the rhs is undefined, compile error because there is a possible
+        // value (zero) for which the division would be illegal behavior.
+        // If the lhs is undefined, result is undefined.
+        if (is_int) {
+            if (maybe_lhs_val) |lhs_val| {
+                if (lhs_val.isUndef()) {
+                    return sema.failWithUseOfUndef(block, lhs_src);
+                }
+            }
+            if (maybe_rhs_val) |rhs_val| {
+                if (rhs_val.isUndef()) {
+                    return sema.failWithUseOfUndef(block, rhs_src);
+                }
+                if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
+                    return sema.failWithDivideByZero(block, rhs_src);
+                }
+                if (maybe_lhs_val) |lhs_val| {
+                    return sema.addConstant(
+                        resolved_type,
+                        try lhs_val.intRem(rhs_val, resolved_type, sema.arena, target),
+                    );
+                }
+                break :rs lhs_src;
+            } else {
+                break :rs rhs_src;
+            }
+        }
+        // float operands
+        if (maybe_rhs_val) |rhs_val| {
+            if (rhs_val.isUndef()) {
+                return sema.failWithUseOfUndef(block, rhs_src);
+            }
+            if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
+                return sema.failWithDivideByZero(block, rhs_src);
+            }
+        }
+        if (maybe_lhs_val) |lhs_val| {
+            if (lhs_val.isUndef()) {
+                return sema.addConstUndef(resolved_type);
+            }
+            if (maybe_rhs_val) |rhs_val| {
+                return sema.addConstant(
+                    resolved_type,
+                    try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, target),
+                );
+            } else break :rs rhs_src;
+        } else break :rs lhs_src;
+    };
+
+    try sema.requireRuntimeBlock(block, src, runtime_src);
+
+    if (block.wantSafety()) {
+        try sema.addDivByZeroSafety(block, resolved_type, maybe_rhs_val, casted_rhs, is_int);
+    }
+
+    const air_tag = airTag(block, is_int, .rem, .rem_optimized);
+    return block.addBinOp(air_tag, casted_lhs, casted_rhs);
+}
+
 fn zirOverflowArithmetic(
     sema: *Sema,
     block: *Block,
@@ -11882,8 +12218,6 @@ fn analyzeArithmetic(
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
 
-    const lhs_scalar_ty = lhs_ty.scalarType();
-    const rhs_scalar_ty = rhs_ty.scalarType();
     const scalar_tag = resolved_type.scalarType().zigTypeTag();
 
     const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt;
@@ -12229,206 +12563,6 @@ fn analyzeArithmetic(
                     } else break :rs .{ .src = lhs_src, .air_tag = .mul_sat };
                 } else break :rs .{ .src = rhs_src, .air_tag = .mul_sat };
             },
-            .mod_rem => {
-                // For integers:
-                // Either operand being undef is a compile error because there exists
-                // a possible value (TODO what is it?) that would invoke illegal behavior.
-                // TODO: can lhs undef be handled better?
-                //
-                // For floats:
-                // If the rhs is zero, compile error for division by zero.
-                // If the rhs is undefined, compile error because there is a possible
-                // value (zero) for which the division would be illegal behavior.
-                // If the lhs is undefined, result is undefined.
-                //
-                // For either one: if the result would be different between @mod and @rem,
-                // then emit a compile error saying you have to pick one.
-                if (is_int) {
-                    if (maybe_lhs_val) |lhs_val| {
-                        if (lhs_val.isUndef()) {
-                            return sema.failWithUseOfUndef(block, lhs_src);
-                        }
-                        if (try lhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
-                            return sema.addConstant(resolved_type, Value.zero);
-                        }
-                    } else if (lhs_scalar_ty.isSignedInt()) {
-                        return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
-                    }
-                    if (maybe_rhs_val) |rhs_val| {
-                        if (rhs_val.isUndef()) {
-                            return sema.failWithUseOfUndef(block, rhs_src);
-                        }
-                        if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
-                            return sema.failWithDivideByZero(block, rhs_src);
-                        }
-                        if (maybe_lhs_val) |lhs_val| {
-                            const rem_result = try lhs_val.intRem(rhs_val, resolved_type, sema.arena, target);
-                            // If this answer could possibly be different by doing `intMod`,
-                            // we must emit a compile error. Otherwise, it's OK.
-                            if ((try rhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) != (try lhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) and
-                                !(try rem_result.compareWithZeroAdvanced(.eq, sema.kit(block, src))))
-                            {
-                                const bad_src = if (try lhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src)))
-                                    lhs_src
-                                else
-                                    rhs_src;
-                                return sema.failWithModRemNegative(block, bad_src, lhs_ty, rhs_ty);
-                            }
-                            if (try lhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) {
-                                // Negative
-                                return sema.addConstant(resolved_type, Value.zero);
-                            }
-                            return sema.addConstant(resolved_type, rem_result);
-                        }
-                        break :rs .{ .src = lhs_src, .air_tag = .rem };
-                    } else if (rhs_scalar_ty.isSignedInt()) {
-                        return sema.failWithModRemNegative(block, rhs_src, lhs_ty, rhs_ty);
-                    } else {
-                        break :rs .{ .src = rhs_src, .air_tag = .rem };
-                    }
-                }
-                // float operands
-                if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef()) {
-                        return sema.failWithUseOfUndef(block, rhs_src);
-                    }
-                    if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
-                        return sema.failWithDivideByZero(block, rhs_src);
-                    }
-                    if (try rhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) {
-                        return sema.failWithModRemNegative(block, rhs_src, lhs_ty, rhs_ty);
-                    }
-                    if (maybe_lhs_val) |lhs_val| {
-                        if (lhs_val.isUndef() or (try lhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src)))) {
-                            return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
-                        }
-                        return sema.addConstant(
-                            resolved_type,
-                            try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, target),
-                        );
-                    } else {
-                        return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
-                    }
-                } else {
-                    return sema.failWithModRemNegative(block, rhs_src, lhs_ty, rhs_ty);
-                }
-            },
-            .rem => {
-                // For integers:
-                // Either operand being undef is a compile error because there exists
-                // a possible value (TODO what is it?) that would invoke illegal behavior.
-                // TODO: can lhs zero be handled better?
-                // TODO: can lhs undef be handled better?
-                //
-                // For floats:
-                // If the rhs is zero, compile error for division by zero.
-                // If the rhs is undefined, compile error because there is a possible
-                // value (zero) for which the division would be illegal behavior.
-                // If the lhs is undefined, result is undefined.
-                if (is_int) {
-                    if (maybe_lhs_val) |lhs_val| {
-                        if (lhs_val.isUndef()) {
-                            return sema.failWithUseOfUndef(block, lhs_src);
-                        }
-                    }
-                    if (maybe_rhs_val) |rhs_val| {
-                        if (rhs_val.isUndef()) {
-                            return sema.failWithUseOfUndef(block, rhs_src);
-                        }
-                        if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
-                            return sema.failWithDivideByZero(block, rhs_src);
-                        }
-                        if (maybe_lhs_val) |lhs_val| {
-                            return sema.addConstant(
-                                resolved_type,
-                                try lhs_val.intRem(rhs_val, resolved_type, sema.arena, target),
-                            );
-                        }
-                        break :rs .{ .src = lhs_src, .air_tag = .rem };
-                    } else {
-                        break :rs .{ .src = rhs_src, .air_tag = .rem };
-                    }
-                }
-                // float operands
-                if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef()) {
-                        return sema.failWithUseOfUndef(block, rhs_src);
-                    }
-                    if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
-                        return sema.failWithDivideByZero(block, rhs_src);
-                    }
-                }
-                const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .rem_optimized else .rem;
-                if (maybe_lhs_val) |lhs_val| {
-                    if (lhs_val.isUndef()) {
-                        return sema.addConstUndef(resolved_type);
-                    }
-                    if (maybe_rhs_val) |rhs_val| {
-                        return sema.addConstant(
-                            resolved_type,
-                            try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, target),
-                        );
-                    } else break :rs .{ .src = rhs_src, .air_tag = air_tag };
-                } else break :rs .{ .src = lhs_src, .air_tag = air_tag };
-            },
-            .mod => {
-                // For integers:
-                // Either operand being undef is a compile error because there exists
-                // a possible value (TODO what is it?) that would invoke illegal behavior.
-                // TODO: can lhs zero be handled better?
-                // TODO: can lhs undef be handled better?
-                //
-                // For floats:
-                // If the rhs is zero, compile error for division by zero.
-                // If the rhs is undefined, compile error because there is a possible
-                // value (zero) for which the division would be illegal behavior.
-                // If the lhs is undefined, result is undefined.
-                if (is_int) {
-                    if (maybe_lhs_val) |lhs_val| {
-                        if (lhs_val.isUndef()) {
-                            return sema.failWithUseOfUndef(block, lhs_src);
-                        }
-                    }
-                    if (maybe_rhs_val) |rhs_val| {
-                        if (rhs_val.isUndef()) {
-                            return sema.failWithUseOfUndef(block, rhs_src);
-                        }
-                        if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
-                            return sema.failWithDivideByZero(block, rhs_src);
-                        }
-                        if (maybe_lhs_val) |lhs_val| {
-                            return sema.addConstant(
-                                resolved_type,
-                                try lhs_val.intMod(rhs_val, resolved_type, sema.arena, target),
-                            );
-                        }
-                        break :rs .{ .src = lhs_src, .air_tag = .mod };
-                    } else {
-                        break :rs .{ .src = rhs_src, .air_tag = .mod };
-                    }
-                }
-                // float operands
-                if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef()) {
-                        return sema.failWithUseOfUndef(block, rhs_src);
-                    }
-                    if (try rhs_val.compareWithZeroAdvanced(.eq, sema.kit(block, src))) {
-                        return sema.failWithDivideByZero(block, rhs_src);
-                    }
-                }
-                const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .mod_optimized else .mod;
-                if (maybe_lhs_val) |lhs_val| {
-                    if (lhs_val.isUndef()) {
-                        return sema.addConstUndef(resolved_type);
-                    }
-                    if (maybe_rhs_val) |rhs_val| {
-                        return sema.addConstant(
-                            resolved_type,
-                            try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, target),
-                        );
-                    } else break :rs .{ .src = rhs_src, .air_tag = air_tag };
-                } else break :rs .{ .src = lhs_src, .air_tag = air_tag };
-            },
             else => unreachable,
         }
     };
@@ -12472,33 +12606,6 @@ fn analyzeArithmetic(
                 return sema.tupleFieldValByIndex(block, src, op_ov, 0, op_ov_tuple_ty);
             }
         }
-        switch (rs.air_tag) {
-            .rem, .mod, .rem_optimized, .mod_optimized => {
-                const ok = if (resolved_type.zigTypeTag() == .Vector) ok: {
-                    const zero_val = try Value.Tag.repeated.create(sema.arena, Value.zero);
-                    const zero = try sema.addConstant(sema.typeOf(casted_rhs), zero_val);
-                    const ok = try block.addCmpVector(casted_rhs, zero, if (scalar_tag == .Int) .gt else .neq, try sema.addType(resolved_type));
-                    break :ok try block.addInst(.{
-                        .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,
-                        .data = .{ .reduce = .{
-                            .operand = ok,
-                            .operation = .And,
-                        } },
-                    });
-                } else ok: {
-                    const zero = try sema.addConstant(sema.typeOf(casted_rhs), Value.zero);
-                    const air_tag = if (scalar_tag == .Int)
-                        Air.Inst.Tag.cmp_gt
-                    else if (block.float_mode == .Optimized)
-                        Air.Inst.Tag.cmp_neq_optimized
-                    else
-                        Air.Inst.Tag.cmp_neq;
-                    break :ok try block.addBinOp(air_tag, casted_rhs, zero);
-                };
-                try sema.addSafetyCheck(block, ok, .remainder_division_zero_negative);
-            },
-            else => {},
-        }
     }
     return block.addBinOp(rs.air_tag, casted_lhs, casted_rhs);
 }
@@ -19965,7 +20072,6 @@ pub const PanicId = enum {
     shl_overflow,
     shr_overflow,
     divide_by_zero,
-    remainder_division_zero_negative,
     exact_division_remainder,
     /// TODO make this call `std.builtin.panicInactiveUnionField`.
     inactive_union_field,
@@ -20261,7 +20367,6 @@ fn safetyPanic(
         .shl_overflow => "left shift overflowed bits",
         .shr_overflow => "right shift overflowed bits",
         .divide_by_zero => "division by zero",
-        .remainder_division_zero_negative => "remainder division by zero or negative value",
         .exact_division_remainder => "exact division produced remainder",
         .inactive_union_field => "access of inactive union field",
         .integer_part_out_of_bounds => "integer part of floating point value out of bounds",
diff --git a/test/cases/safety/modrem by zero.zig b/test/cases/safety/modrem by zero.zig
new file mode 100644
index 0000000000000000000000000000000000000000..435570f2fbf09ec21c7ec83b174b644c074b34f1
--- /dev/null
+++ b/test/cases/safety/modrem by zero.zig	
@@ -0,0 +1,20 @@
+const std = @import("std");
+
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+    _ = stack_trace;
+    if (std.mem.eql(u8, message, "division by zero")) {
+        std.process.exit(0);
+    }
+    std.process.exit(1);
+}
+pub fn main() !void {
+    const x = div0(999, 0);
+    _ = x;
+    return error.TestFailed;
+}
+fn div0(a: u32, b: u32) u32 {
+    return a / b;
+}
+// run
+// backend=llvm
+// target=native
diff --git a/test/cases/safety/modulus by zero.zig b/test/cases/safety/modulus by zero.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9d57865a87f55207cfbf7c6bf5e5338f1a26ed28
--- /dev/null
+++ b/test/cases/safety/modulus by zero.zig	
@@ -0,0 +1,20 @@
+const std = @import("std");
+
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+    _ = stack_trace;
+    if (std.mem.eql(u8, message, "division by zero")) {
+        std.process.exit(0);
+    }
+    std.process.exit(1);
+}
+pub fn main() !void {
+    const x = mod0(999, 0);
+    _ = x;
+    return error.TestFailed;
+}
+fn mod0(a: i32, b: i32) i32 {
+    return @mod(a, b);
+}
+// run
+// backend=llvm
+// target=native
diff --git a/test/cases/safety/remainder division by negative number.zig b/test/cases/safety/remainder division by zero.zig
similarity index 69%
rename from test/cases/safety/remainder division by negative number.zig
rename to test/cases/safety/remainder division by zero.zig
index 2edbf4509cae33d41445625cd28173cf698a9b11..71e295c4dd6dfd5059c81c85e5851d4753aa68fb 100644
--- a/test/cases/safety/remainder division by negative number.zig	
+++ b/test/cases/safety/remainder division by zero.zig	
@@ -2,17 +2,17 @@ const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "remainder division by zero or negative value")) {
+    if (std.mem.eql(u8, message, "division by zero")) {
         std.process.exit(0);
     }
     std.process.exit(1);
 }
 pub fn main() !void {
-    const x = div0(999, -1);
+    const x = rem0(999, 0);
     _ = x;
     return error.TestFailed;
 }
-fn div0(a: i32, b: i32) i32 {
+fn rem0(a: i32, b: i32) i32 {
     return @rem(a, b);
 }
 // run
-- 
2.54.0


From 86d9c3de2b6b43329c16678f1bd7eaddd3d218d7 Mon Sep 17 00:00:00 2001
From: Anton Lilja <12533691+antlilja@users.noreply.github.com>
Date: Sat, 6 Aug 2022 13:17:09 +0200
Subject: [PATCH 026/290] Sema: fix infinite recursion in
 `explainWhyTypeIsComptime`

Co-authored-by: Veikka Tuominen <git@vexu.eu>
---
 src/Sema.zig                                  | 36 +++++++++++++++----
 ..._known_struct_is_resolved_before_error.zig | 19 ++++++++++
 ...f_referential_struct_requires_comptime.zig | 18 ++++++++++
 ...lf_referential_union_requires_comptime.zig | 17 +++++++++
 4 files changed, 84 insertions(+), 6 deletions(-)
 create mode 100644 test/cases/compile_errors/AstGen_comptime_known_struct_is_resolved_before_error.zig
 create mode 100644 test/cases/compile_errors/self_referential_struct_requires_comptime.zig
 create mode 100644 test/cases/compile_errors/self_referential_union_requires_comptime.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index 76c077c1033a11c73db5466523a1ca5f64e61b57..8c2125026dd442591b091015612a50e006c1d28c 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -19764,6 +19764,8 @@ fn validateRunTimeType(
     };
 }
 
+const TypeSet = std.HashMapUnmanaged(Type, void, Type.HashContext64, std.hash_map.default_max_load_percentage);
+
 fn explainWhyTypeIsComptime(
     sema: *Sema,
     block: *Block,
@@ -19771,6 +19773,22 @@ fn explainWhyTypeIsComptime(
     msg: *Module.ErrorMsg,
     src_loc: Module.SrcLoc,
     ty: Type,
+) CompileError!void {
+    var type_set = TypeSet{};
+    defer type_set.deinit(sema.gpa);
+
+    try sema.resolveTypeFully(block, src, ty);
+    return sema.explainWhyTypeIsComptimeInner(block, src, msg, src_loc, ty, &type_set);
+}
+
+fn explainWhyTypeIsComptimeInner(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    msg: *Module.ErrorMsg,
+    src_loc: Module.SrcLoc,
+    ty: Type,
+    type_set: *TypeSet,
 ) CompileError!void {
     const mod = sema.mod;
     switch (ty.zigTypeTag()) {
@@ -19808,7 +19826,7 @@ fn explainWhyTypeIsComptime(
         },
 
         .Array, .Vector => {
-            try sema.explainWhyTypeIsComptime(block, src, msg, src_loc, ty.elemType());
+            try sema.explainWhyTypeIsComptimeInner(block, src, msg, src_loc, ty.elemType(), type_set);
         },
         .Pointer => {
             const elem_ty = ty.elemType2();
@@ -19826,18 +19844,20 @@ fn explainWhyTypeIsComptime(
                 }
                 return;
             }
-            try sema.explainWhyTypeIsComptime(block, src, msg, src_loc, ty.elemType());
+            try sema.explainWhyTypeIsComptimeInner(block, src, msg, src_loc, ty.elemType(), type_set);
         },
 
         .Optional => {
             var buf: Type.Payload.ElemType = undefined;
-            try sema.explainWhyTypeIsComptime(block, src, msg, src_loc, ty.optionalChild(&buf));
+            try sema.explainWhyTypeIsComptimeInner(block, src, msg, src_loc, ty.optionalChild(&buf), type_set);
         },
         .ErrorUnion => {
-            try sema.explainWhyTypeIsComptime(block, src, msg, src_loc, ty.errorUnionPayload());
+            try sema.explainWhyTypeIsComptimeInner(block, src, msg, src_loc, ty.errorUnionPayload(), type_set);
         },
 
         .Struct => {
+            if ((try type_set.getOrPutContext(sema.gpa, ty, .{ .mod = mod })).found_existing) return;
+
             if (ty.castTag(.@"struct")) |payload| {
                 const struct_obj = payload.data;
                 for (struct_obj.fields.values()) |field, i| {
@@ -19845,9 +19865,10 @@ fn explainWhyTypeIsComptime(
                         .index = i,
                         .range = .type,
                     });
+
                     if (try sema.typeRequiresComptime(block, src, field.ty)) {
                         try mod.errNoteNonLazy(field_src_loc, msg, "struct requires comptime because of this field", .{});
-                        try sema.explainWhyTypeIsComptime(block, src, msg, field_src_loc, field.ty);
+                        try sema.explainWhyTypeIsComptimeInner(block, src, msg, field_src_loc, field.ty, type_set);
                     }
                 }
             }
@@ -19855,6 +19876,8 @@ fn explainWhyTypeIsComptime(
         },
 
         .Union => {
+            if ((try type_set.getOrPutContext(sema.gpa, ty, .{ .mod = mod })).found_existing) return;
+
             if (ty.cast(Type.Payload.Union)) |payload| {
                 const union_obj = payload.data;
                 for (union_obj.fields.values()) |field, i| {
@@ -19862,9 +19885,10 @@ fn explainWhyTypeIsComptime(
                         .index = i,
                         .range = .type,
                     });
+
                     if (try sema.typeRequiresComptime(block, src, field.ty)) {
                         try mod.errNoteNonLazy(field_src_loc, msg, "union requires comptime because of this field", .{});
-                        try sema.explainWhyTypeIsComptime(block, src, msg, field_src_loc, field.ty);
+                        try sema.explainWhyTypeIsComptimeInner(block, src, msg, field_src_loc, field.ty, type_set);
                     }
                 }
             }
diff --git a/test/cases/compile_errors/AstGen_comptime_known_struct_is_resolved_before_error.zig b/test/cases/compile_errors/AstGen_comptime_known_struct_is_resolved_before_error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8e9358c6f44ea0bd64fb94512dcd0b8cc797ba12
--- /dev/null
+++ b/test/cases/compile_errors/AstGen_comptime_known_struct_is_resolved_before_error.zig
@@ -0,0 +1,19 @@
+const S1 = struct {
+    a: S2,
+};
+const S2 = struct {
+    b: fn () void,
+};
+pub export fn entry() void {
+    var s: S1 = undefined;
+    _ = s;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :8:12: error: variable of type 'tmp.S1' must be const or comptime
+// :2:8: note: struct requires comptime because of this field
+// :5:8: note: struct requires comptime because of this field
+// :5:8: note: use '*const fn() void' for a function pointer type
diff --git a/test/cases/compile_errors/self_referential_struct_requires_comptime.zig b/test/cases/compile_errors/self_referential_struct_requires_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3ce75710267c485a69bab33e3d132d2b26b1a836
--- /dev/null
+++ b/test/cases/compile_errors/self_referential_struct_requires_comptime.zig
@@ -0,0 +1,18 @@
+const S = struct {
+    a: fn () void,
+    b: *S,
+};
+pub export fn entry() void {
+    var s: S = undefined;
+    _ = s;
+}
+
+
+// error
+// backend=stage2
+// target=native
+//
+// :6:12: error: variable of type 'tmp.S' must be const or comptime
+// :2:8: note: struct requires comptime because of this field
+// :2:8: note: use '*const fn() void' for a function pointer type
+// :3:8: note: struct requires comptime because of this field
diff --git a/test/cases/compile_errors/self_referential_union_requires_comptime.zig b/test/cases/compile_errors/self_referential_union_requires_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a2433adde9786a283b5deada7f3493d41fb1f688
--- /dev/null
+++ b/test/cases/compile_errors/self_referential_union_requires_comptime.zig
@@ -0,0 +1,17 @@
+const U = union {
+    a: fn () void,
+    b: *U,
+};
+pub export fn entry() void {
+    var u: U = undefined;
+    _ = u;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :6:12: error: variable of type 'tmp.U' must be const or comptime
+// :2:8: note: union requires comptime because of this field
+// :2:8: note: use '*const fn() void' for a function pointer type
+// :3:8: note: union requires comptime because of this field
-- 
2.54.0


From 75275a1514b6954bed09c4c14a325e883a129c7b Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sat, 6 Aug 2022 15:22:14 +0300
Subject: [PATCH 027/290] Sema: do not emit pointer safety checks for pointers
 to zero-bit types

---
 src/Sema.zig | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 56e08d081bddbceeeb1d25365933decfca5bac19..4c11894c247724620225b3c7365939498d195133 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -16877,7 +16877,7 @@ fn zirIntToPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     }
 
     try sema.requireRuntimeBlock(block, src, operand_src);
-    if (block.wantSafety()) {
+    if (block.wantSafety() and try sema.typeHasRuntimeBits(block, sema.src, type_res.elemType2())) {
         if (!type_res.isAllowzeroPtr()) {
             const is_non_zero = try block.addBinOp(.cmp_neq, operand_coerced, .zero_usize);
             try sema.addSafetyCheck(block, is_non_zero, .cast_to_null);
@@ -17169,7 +17169,9 @@ fn zirAlignCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     }
 
     try sema.requireRuntimeBlock(block, inst_data.src(), ptr_src);
-    if (block.wantSafety() and dest_align > 1) {
+    if (block.wantSafety() and dest_align > 1 and
+        try sema.typeHasRuntimeBits(block, sema.src, dest_ty.elemType2()))
+    {
         const val_payload = try sema.arena.create(Value.Payload.U64);
         val_payload.* = .{
             .base = .{ .tag = .int_u64 },
@@ -24489,7 +24491,9 @@ fn coerceCompatiblePtrs(
     try sema.requireRuntimeBlock(block, inst_src, null);
     const inst_ty = sema.typeOf(inst);
     const inst_allows_zero = (inst_ty.zigTypeTag() == .Pointer and inst_ty.ptrAllowsZero()) or true;
-    if (block.wantSafety() and inst_allows_zero and !dest_ty.ptrAllowsZero()) {
+    if (block.wantSafety() and inst_allows_zero and !dest_ty.ptrAllowsZero() and
+        try sema.typeHasRuntimeBits(block, sema.src, dest_ty.elemType2()))
+    {
         const actual_ptr = if (inst_ty.isSlice())
             try sema.analyzeSlicePtr(block, inst_src, inst, inst_ty)
         else
-- 
2.54.0


From 4ef567ba41b7b9f83eb26d52128125b6837beb2f Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sat, 6 Aug 2022 15:01:55 +0200
Subject: [PATCH 028/290] feat: make help modal disappear if you click outside
 it

---
 lib/docs/main.js | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 41a03322d9afb9b9fdfb38c2cdcb3794f0865614..2bb796f49b4b89e8f916e8a269096563e27cbd12 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -132,6 +132,12 @@ var zigAnalysis;
     location.hash = "#root";
   }
 
+  // make the modal disappear if you click outside it
+  domHelpModal.addEventListener("click", ev => {
+    if (ev.target.className == "help-modal")
+      domHelpModal.classList.add("hidden");
+  })
+
   window.addEventListener("hashchange", onHashChange, false);
   window.addEventListener("keydown", onWindowKeyDown, false);
   onHashChange();
-- 
2.54.0


From 6354851909749d9741d520ead2d1f9e517df3548 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sat, 6 Aug 2022 15:05:58 +0200
Subject: [PATCH 029/290] fix: "dialog" -> "modal"

"Dialog" is the incorrect term here because a dialog is a separate window that still lets you use the app
but a modal is a window where you can't continue using the app until you close it.
---
 lib/docs/index.html | 11 +++++------
 lib/docs/main.js    |  2 +-
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index dbcb54288afdb472eae9738755d52724a9fb93d8..5d6f3818639a15c7f56e671e669b712d7d524d2f 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -294,7 +294,6 @@
         padding: 1px 1em;
       }
 
-      /* help dialog */
       .help-modal {
         display: flex;
         width: 100%;
@@ -308,7 +307,7 @@
         backdrop-filter: blur(0.3em);
       }
 
-      .help-modal > .dialog {
+      .help-modal > .modal {
         max-width: 97vw;
         max-height: 97vh;
         overflow: auto;
@@ -707,12 +706,12 @@
         <div class="flex-filler"></div>
       </div>
     </div>
-    <div id="helpDialog" class="hidden">
+    <div id="helpModal" class="hidden">
       <div class="help-modal">
-        <div class="dialog">
+        <div class="modal">
           <h1>Keyboard Shortcuts</h1>
-          <dl><dt><kbd>?</kbd></dt><dd>Show this help dialog</dd></dl>
-          <dl><dt><kbd>Esc</kbd></dt><dd>Clear focus; close this dialog</dd></dl>
+          <dl><dt><kbd>?</kbd></dt><dd>Show this help modal</dd></dl>
+          <dl><dt><kbd>Esc</kbd></dt><dd>Clear focus; close this modal</dd></dl>
           <dl><dt><kbd>s</kbd></dt><dd>Focus the search field</dd></dl>
           <dl><dt><kbd>↑</kbd></dt><dd>Move up in search results</dd></dl>
           <dl><dt><kbd>↓</kbd></dt><dd>Move down in search results</dd></dl>
diff --git a/lib/docs/main.js b/lib/docs/main.js
index 2bb796f49b4b89e8f916e8a269096563e27cbd12..55546ce056b09098304732d4e4b0e525ec2cc34a 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -48,7 +48,7 @@ var zigAnalysis;
   let domPrivDeclsBox = document.getElementById("privDeclsBox");
   let domTdZigVer = document.getElementById("tdZigVer");
   let domHdrName = document.getElementById("hdrName");
-  let domHelpModal = document.getElementById("helpDialog");
+  let domHelpModal = document.getElementById("helpModal");
 
   let searchTimer = null;
 
-- 
2.54.0


From df8cfb1273e7b99ff5de0164c676d291191a72c6 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sat, 6 Aug 2022 15:09:26 +0200
Subject: [PATCH 030/290] feat: new search placeholder

This new search placeholder looks much nicer because it allows HTML inside it which
the `placeholder` attribute on `<input>`s doesn't allow.
I tested it for all kinds of cases and it seems to work pretty well.
---
 lib/docs/index.html | 17 ++++++++++-------
 lib/docs/main.js    | 12 ++++++++++++
 2 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index 5d6f3818639a15c7f56e671e669b712d7d524d2f..48af4ab58512106b936de1ec2d1f8d662894c732 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -190,11 +190,11 @@
         box-shadow: 0 0.3em 1em 0.125em var(--search-sh-color);
       }
 
-      .docs .search::placeholder {
-        font-size: 1rem;
-        font-family: var(--ui);
-        color: var(--tx-color);
-        opacity: 0.5;
+      #searchPlaceholder {
+        position: absolute;
+        pointer-events: none;
+        top: 5px;
+        left: 5px;
       }
 
       .docs a {
@@ -334,7 +334,7 @@
         margin-right: 0.5em;
       }
 
-      .help-modal kbd {
+      kbd {
         display: inline-block;
         padding: 0.3em 0.2em;
         font-size: 1.2em;
@@ -614,7 +614,10 @@
       <div class="flex-right">
         <div class="wrap">
           <section class="docs">
-            <input type="search" class="search" id="search" autocomplete="off" spellcheck="false" placeholder="`s` to search, `?` to see more options">
+            <div style="position: relative">
+              <span id="searchPlaceholder"><kbd>S</kbd> to search, <kbd>?</kbd> for more options</span>
+              <input type="search" class="search" id="search" autocomplete="off" spellcheck="false">
+            </div>
             <p id="status">Loading...</p>
             <div id="sectNav" class="hidden"><ul id="listNav"></ul></div>
             <div id="fnProto" class="hidden">
diff --git a/lib/docs/main.js b/lib/docs/main.js
index 55546ce056b09098304732d4e4b0e525ec2cc34a..ebbae537142f7c999350cdd8ce5cd78d1fa21081 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -49,6 +49,7 @@ var zigAnalysis;
   let domTdZigVer = document.getElementById("tdZigVer");
   let domHdrName = document.getElementById("hdrName");
   let domHelpModal = document.getElementById("helpModal");
+  const domSearchPlaceholder = document.getElementById("searchPlaceholder");
 
   let searchTimer = null;
 
@@ -103,6 +104,13 @@ var zigAnalysis;
   // let nodesToCallsMap = indexNodesToCalls();
 
   domSearch.addEventListener("keydown", onSearchKeyDown, false);
+  domSearch.addEventListener("focus", ev => {
+    domSearchPlaceholder.classList.add("hidden");
+  });
+  domSearch.addEventListener("blur", ev => {
+    if (domSearch.value.length == 0)
+      domSearchPlaceholder.classList.remove("hidden");
+  });
   domPrivDeclsBox.addEventListener(
     "change",
     function () {
@@ -2623,6 +2631,10 @@ var zigAnalysis;
     updateCurNav();
     if (domSearch.value !== curNavSearch) {
       domSearch.value = curNavSearch;
+      if (domSearch.value.length == 0)
+        domSearchPlaceholder.classList.remove("hidden");
+      else
+        domSearchPlaceholder.classList.add("hidden");
     }
     render();
     if (imFeelingLucky) {
-- 
2.54.0


From 2f0abe63d4d630583e2163779bd26aaad13e18ea Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sat, 6 Aug 2022 15:16:27 +0200
Subject: [PATCH 031/290] fix: disable search bar before loading

This fixes the new search placeholder not disappearing if you type before
it finished loading, and maybe some other things.
---
 lib/docs/index.html | 2 +-
 lib/docs/main.js    | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index 48af4ab58512106b936de1ec2d1f8d662894c732..7e8022556f801175ab7eec779518beac2aca3e41 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -616,7 +616,7 @@
           <section class="docs">
             <div style="position: relative">
               <span id="searchPlaceholder"><kbd>S</kbd> to search, <kbd>?</kbd> for more options</span>
-              <input type="search" class="search" id="search" autocomplete="off" spellcheck="false">
+              <input type="search" class="search" id="search" autocomplete="off" spellcheck="false" disabled>
             </div>
             <p id="status">Loading...</p>
             <div id="sectNav" class="hidden"><ul id="listNav"></ul></div>
diff --git a/lib/docs/main.js b/lib/docs/main.js
index ebbae537142f7c999350cdd8ce5cd78d1fa21081..dee8c8a611bd4dbb479634beb833a111673d0696 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -51,6 +51,8 @@ var zigAnalysis;
   let domHelpModal = document.getElementById("helpModal");
   const domSearchPlaceholder = document.getElementById("searchPlaceholder");
 
+  domSearch.disabled = false;
+
   let searchTimer = null;
 
   let escapeHtmlReplacements = {
-- 
2.54.0


From ee72868f923eda2693c8ef624fa04f48606c06f1 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sat, 6 Aug 2022 15:17:59 +0200
Subject: [PATCH 032/290] style: format

This is mostly manually formatted. I couldn't find a good HTML formatter for this file.
It also converts a bunch of tabs to spaces.
---
 lib/docs/index.html | 85 ++++++++++++++++++++++-----------------------
 1 file changed, 42 insertions(+), 43 deletions(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index 7e8022556f801175ab7eec779518beac2aca3e41..2328719caf2857a0dbd2a1230f26894efceaffe3 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -294,6 +294,7 @@
         padding: 1px 1em;
       }
 
+      /* help modal */
       .help-modal {
         display: flex;
         width: 100%;
@@ -351,12 +352,12 @@
         cursor: default;
       }
 
-	  #listFns dt {
-		  font-family: var(--mono);
-	  }
-	  .argBreaker {
-		  display: none;
-	  }
+      #listFns dt {
+        font-family: var(--mono);
+      }
+      .argBreaker {
+        display: none;
+      }
 
       /* tokens */
       .tok-kw {
@@ -390,7 +391,6 @@
 
       /* dark mode */
       @media (prefers-color-scheme: dark) {
-
         :root {
           --tx-color: #bbb;
           --bg-color: #111;
@@ -456,7 +456,6 @@
         .tok-type {
             color: #68f;
         }
-
       }
 
       @media only screen and (max-width: 750px) {
@@ -543,7 +542,7 @@
   <body class="canvas">
     <div class="banner">
       This is a beta autodoc build; expect bugs and missing information.
-      <a href="https://github.com/ziglang/zig/wiki/How-to-contribute-to-Autodoc">Report an Issue</a>, 
+      <a href="https://github.com/ziglang/zig/wiki/How-to-contribute-to-Autodoc">Report an Issue</a>,
       <a href="https://github.com/ziglang/zig/wiki/How-to-contribute-to-Autodoc">Contribute</a>,
       <a href="https://github.com/ziglang/zig/wiki/How-to-read-the-standard-library-source-code">Learn more about stdlib source code</a>.
     </div>
@@ -554,43 +553,43 @@
           <div class="logo">
             <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 140">
             <g fill="#F7A41D">
-            	<g>
-            		<polygon points="46,22 28,44 19,30"/>
-            		<polygon points="46,22 33,33 28,44 22,44 22,95 31,95 20,100 12,117 0,117 0,22" shape-rendering="crispEdges"/>
-            		<polygon points="31,95 12,117 4,106"/>
-            	</g>
-            	<g>
-            		<polygon points="56,22 62,36 37,44"/>
-            		<polygon points="56,22 111,22 111,44 37,44 56,32" shape-rendering="crispEdges"/>
-            		<polygon points="116,95 97,117 90,104"/>
-            		<polygon points="116,95 100,104 97,117 42,117 42,95" shape-rendering="crispEdges"/>
-            		<polygon points="150,0 52,117 3,140 101,22"/>
-            	</g>
-            	<g>
-            		<polygon points="141,22 140,40 122,45"/>
-            		<polygon points="153,22 153,117 106,117 120,105 125,95 131,95 131,45 122,45 132,36 141,22" shape-rendering="crispEdges"/>
-            		<polygon points="125,95 130,110 106,117"/>
-            	</g>
+              <g>
+                <polygon points="46,22 28,44 19,30"/>
+                <polygon points="46,22 33,33 28,44 22,44 22,95 31,95 20,100 12,117 0,117 0,22" shape-rendering="crispEdges"/>
+                <polygon points="31,95 12,117 4,106"/>
+              </g>
+              <g>
+                <polygon points="56,22 62,36 37,44"/>
+                <polygon points="56,22 111,22 111,44 37,44 56,32" shape-rendering="crispEdges"/>
+                <polygon points="116,95 97,117 90,104"/>
+                <polygon points="116,95 100,104 97,117 42,117 42,95" shape-rendering="crispEdges"/>
+                <polygon points="150,0 52,117 3,140 101,22"/>
+              </g>
+              <g>
+                <polygon points="141,22 140,40 122,45"/>
+                <polygon points="153,22 153,117 106,117 120,105 125,95 131,95 131,45 122,45 132,36 141,22" shape-rendering="crispEdges"/>
+                <polygon points="125,95 130,110 106,117"/>
+              </g>
             </g>
             <style>
             #text { fill: #121212 }
             @media (prefers-color-scheme: dark) { #text { fill: #f2f2f2 } }
             </style>
             <g id="text">
-            	<g>
-            		<polygon points="260,22 260,37 229,40 177,40 177,22" shape-rendering="crispEdges"/>
-            		<polygon points="260,37 207,99 207,103 176,103 229,40 229,37"/>
-            		<polygon points="261,99 261,117 176,117 176,103 206,99" shape-rendering="crispEdges"/>
-            	</g>
-            	<rect x="272" y="22" shape-rendering="crispEdges" width="22" height="95"/>
-            	<g>
-            		<polygon points="394,67 394,106 376,106 376,81 360,70 346,67" shape-rendering="crispEdges"/>
-            		<polygon points="360,68 376,81 346,67"/>
-            		<path d="M394,106c-10.2,7.3-24,12-37.7,12c-29,0-51.1-20.8-51.1-48.3c0-27.3,22.5-48.1,52-48.1    c14.3,0,29.2,5.5,38.9,14l-13,15c-7.1-6.3-16.8-10-25.9-10c-17,0-30.2,12.9-30.2,29.5c0,16.8,13.3,29.6,30.3,29.6    c5.7,0,12.8-2.3,19-5.5L394,106z"/>
-            	</g>
+              <g>
+                <polygon points="260,22 260,37 229,40 177,40 177,22" shape-rendering="crispEdges"/>
+                <polygon points="260,37 207,99 207,103 176,103 229,40 229,37"/>
+                <polygon points="261,99 261,117 176,117 176,103 206,99" shape-rendering="crispEdges"/>
+              </g>
+              <rect x="272" y="22" shape-rendering="crispEdges" width="22" height="95"/>
+              <g>
+                <polygon points="394,67 394,106 376,106 376,81 360,70 346,67" shape-rendering="crispEdges"/>
+                <polygon points="360,68 376,81 346,67"/>
+                <path d="M394,106c-10.2,7.3-24,12-37.7,12c-29,0-51.1-20.8-51.1-48.3c0-27.3,22.5-48.1,52-48.1    c14.3,0,29.2,5.5,38.9,14l-13,15c-7.1-6.3-16.8-10-25.9-10c-17,0-30.2,12.9-30.2,29.5c0,16.8,13.3,29.6,30.3,29.6    c5.7,0,12.8-2.3,19-5.5L394,106z"/>
+              </g>
             </g>
             </svg>
-         </div>
+          </div>
           <div id="sectMainPkg" class="hidden">
             <h2><span>Main Package</span></h2>
             <ul class="packages">
@@ -605,10 +604,10 @@
             <h2><span>Zig Version</span></h2>
             <p class="str" id="tdZigVer"></p>
           </div>
-		  <div>
-			  <input id="privDeclsBox" type="checkbox"/>
-        <label for="privDeclsBox">Internal Doc Mode</label>
-		  </div>
+          <div>
+            <input id="privDeclsBox" type="checkbox"/>
+            <label for="privDeclsBox">Internal Doc Mode</label>
+          </div>
         </nav>
       </div>
       <div class="flex-right">
@@ -704,7 +703,7 @@
                 </table>
               </div>
             </div>
-		  </section>
+          </section>
         </div>
         <div class="flex-filler"></div>
       </div>
-- 
2.54.0


From beba29c24f33edcd603050ce65f2f3c358223aab Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sat, 6 Aug 2022 15:34:38 +0200
Subject: [PATCH 033/290] feat: make shadow of `<kbd>`s look nicer

---
 lib/docs/index.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index 2328719caf2857a0dbd2a1230f26894efceaffe3..67412bd7acb9d851b8651788604e03aef6da8ed5 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -348,7 +348,7 @@
         border-bottom-color: #c6cbd1;
         border: solid 0.0625em;
         border-radius: 0.1875em;
-        box-shadow: inset 0 -0.0625em 0 #c6cbd1;
+        box-shadow: inset 0 -0.2em 0 #c6cbd1;
         cursor: default;
       }
 
-- 
2.54.0


From e921dd11361cf62128f4c6417f6d7313dd403455 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sat, 6 Aug 2022 15:38:32 +0200
Subject: [PATCH 034/290] style: missing semi

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

diff --git a/lib/docs/main.js b/lib/docs/main.js
index dee8c8a611bd4dbb479634beb833a111673d0696..77f2e2c550074a979e911fac3f1b5d1dcf503792 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -146,7 +146,7 @@ var zigAnalysis;
   domHelpModal.addEventListener("click", ev => {
     if (ev.target.className == "help-modal")
       domHelpModal.classList.add("hidden");
-  })
+  });
 
   window.addEventListener("hashchange", onHashChange, false);
   window.addEventListener("keydown", onWindowKeyDown, false);
-- 
2.54.0


From 2f5afe119412a53bc6cefb5fa395438231fce829 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sat, 6 Aug 2022 15:53:20 +0200
Subject: [PATCH 035/290] let -> const for dom elements

These should never be reassigned.
---
 lib/docs/main.js | 90 ++++++++++++++++++++++++------------------------
 1 file changed, 45 insertions(+), 45 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 77f2e2c550074a979e911fac3f1b5d1dcf503792..bce1a69ff538e22acc335eda39b59387dec54d40 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -3,52 +3,52 @@
 var zigAnalysis;
 
 (function () {
-  let domStatus = document.getElementById("status");
-  let domSectNav = document.getElementById("sectNav");
-  let domListNav = document.getElementById("listNav");
-  let domSectMainPkg = document.getElementById("sectMainPkg");
-  let domSectPkgs = document.getElementById("sectPkgs");
-  let domListPkgs = document.getElementById("listPkgs");
-  let domSectTypes = document.getElementById("sectTypes");
-  let domListTypes = document.getElementById("listTypes");
-  let domSectTests = document.getElementById("sectTests");
-  let domListTests = document.getElementById("listTests");
-  let domSectNamespaces = document.getElementById("sectNamespaces");
-  let domListNamespaces = document.getElementById("listNamespaces");
-  let domSectErrSets = document.getElementById("sectErrSets");
-  let domListErrSets = document.getElementById("listErrSets");
-  let domSectFns = document.getElementById("sectFns");
-  let domListFns = document.getElementById("listFns");
-  let domSectFields = document.getElementById("sectFields");
-  let domListFields = document.getElementById("listFields");
-  let domSectGlobalVars = document.getElementById("sectGlobalVars");
-  let domListGlobalVars = document.getElementById("listGlobalVars");
-  let domSectValues = document.getElementById("sectValues");
-  let domListValues = document.getElementById("listValues");
-  let domFnProto = document.getElementById("fnProto");
-  let domFnProtoCode = document.getElementById("fnProtoCode");
-  let domSectParams = document.getElementById("sectParams");
-  let domListParams = document.getElementById("listParams");
-  let domTldDocs = document.getElementById("tldDocs");
-  let domSectFnErrors = document.getElementById("sectFnErrors");
-  let domListFnErrors = document.getElementById("listFnErrors");
-  let domTableFnErrors = document.getElementById("tableFnErrors");
-  let domFnErrorsAnyError = document.getElementById("fnErrorsAnyError");
-  let domFnExamples = document.getElementById("fnExamples");
-  // let domListFnExamples = (document.getElementById("listFnExamples"));
-  let domFnNoExamples = document.getElementById("fnNoExamples");
-  let domDeclNoRef = document.getElementById("declNoRef");
-  let domSearch = document.getElementById("search");
-  let domSectSearchResults = document.getElementById("sectSearchResults");
+  const domStatus = document.getElementById("status");
+  const domSectNav = document.getElementById("sectNav");
+  const domListNav = document.getElementById("listNav");
+  const domSectMainPkg = document.getElementById("sectMainPkg");
+  const domSectPkgs = document.getElementById("sectPkgs");
+  const domListPkgs = document.getElementById("listPkgs");
+  const domSectTypes = document.getElementById("sectTypes");
+  const domListTypes = document.getElementById("listTypes");
+  const domSectTests = document.getElementById("sectTests");
+  const domListTests = document.getElementById("listTests");
+  const domSectNamespaces = document.getElementById("sectNamespaces");
+  const domListNamespaces = document.getElementById("listNamespaces");
+  const domSectErrSets = document.getElementById("sectErrSets");
+  const domListErrSets = document.getElementById("listErrSets");
+  const domSectFns = document.getElementById("sectFns");
+  const domListFns = document.getElementById("listFns");
+  const domSectFields = document.getElementById("sectFields");
+  const domListFields = document.getElementById("listFields");
+  const domSectGlobalVars = document.getElementById("sectGlobalVars");
+  const domListGlobalVars = document.getElementById("listGlobalVars");
+  const domSectValues = document.getElementById("sectValues");
+  const domListValues = document.getElementById("listValues");
+  const domFnProto = document.getElementById("fnProto");
+  const domFnProtoCode = document.getElementById("fnProtoCode");
+  const domSectParams = document.getElementById("sectParams");
+  const domListParams = document.getElementById("listParams");
+  const domTldDocs = document.getElementById("tldDocs");
+  const domSectFnErrors = document.getElementById("sectFnErrors");
+  const domListFnErrors = document.getElementById("listFnErrors");
+  const domTableFnErrors = document.getElementById("tableFnErrors");
+  const domFnErrorsAnyError = document.getElementById("fnErrorsAnyError");
+  const domFnExamples = document.getElementById("fnExamples");
+  // const domListFnExamples = (document.getElementById("listFnExamples"));
+  const domFnNoExamples = document.getElementById("fnNoExamples");
+  const domDeclNoRef = document.getElementById("declNoRef");
+  const domSearch = document.getElementById("search");
+  const domSectSearchResults = document.getElementById("sectSearchResults");
 
-  let domListSearchResults = document.getElementById("listSearchResults");
-  let domSectSearchNoResults = document.getElementById("sectSearchNoResults");
-  let domSectInfo = document.getElementById("sectInfo");
-  // let domTdTarget = (document.getElementById("tdTarget"));
-  let domPrivDeclsBox = document.getElementById("privDeclsBox");
-  let domTdZigVer = document.getElementById("tdZigVer");
-  let domHdrName = document.getElementById("hdrName");
-  let domHelpModal = document.getElementById("helpModal");
+  const domListSearchResults = document.getElementById("listSearchResults");
+  const domSectSearchNoResults = document.getElementById("sectSearchNoResults");
+  const domSectInfo = document.getElementById("sectInfo");
+  // const domTdTarget = (document.getElementById("tdTarget"));
+  const domPrivDeclsBox = document.getElementById("privDeclsBox");
+  const domTdZigVer = document.getElementById("tdZigVer");
+  const domHdrName = document.getElementById("hdrName");
+  const domHelpModal = document.getElementById("helpModal");
   const domSearchPlaceholder = document.getElementById("searchPlaceholder");
 
   domSearch.disabled = false;
-- 
2.54.0


From 60b04b0988cdedb4bb9e1c67d0775a317510b703 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sat, 6 Aug 2022 16:00:53 +0200
Subject: [PATCH 036/290] style: some more formatting

---
 lib/docs/index.html | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index 67412bd7acb9d851b8651788604e03aef6da8ed5..848b130705476b1bec753106f877e56a2c84c17a 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -27,7 +27,7 @@
         --help-sh-color: rgba(0, 0, 0, 0.75);
       }
 
-      html, body { margin: 0; padding:0; height: 100%; }
+      html, body { margin: 0; padding: 0; height: 100%; }
 
       a {
         text-decoration: none;
@@ -207,9 +207,9 @@
 
       .docs pre {
         font-family: var(--mono);
-        font-size:1em;
-        background-color:#F5F5F5;
-        padding:1em;
+        font-size: 1em;
+        background-color: #F5F5F5;
+        padding: 1em;
         overflow-x: auto;
       }
 
@@ -225,7 +225,7 @@
         border-bottom: 0.0625rem dashed;
       }
 
-      .docs  h2 {
+      .docs h2 {
         font-size: 1.3em;
         margin: 0.5em 0;
         padding: 0;
-- 
2.54.0


From 943f4eb515ec03499cf7b37d80b964e15502bfc8 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sat, 6 Aug 2022 16:07:32 +0200
Subject: [PATCH 037/290] fix: use brighter bg color for help modal in light
 mode

You can see this issue in the video.
---
 lib/docs/index.html | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index 848b130705476b1bec753106f877e56a2c84c17a..c506eac3dd954f3529b0d22c08f829a620449ad6 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -25,6 +25,7 @@
         --search-bg-color-focus: #ffffff;
         --search-sh-color: rgba(0, 0, 0, 0.18);
         --help-sh-color: rgba(0, 0, 0, 0.75);
+        --help-bg-color: #aaa;
       }
 
       html, body { margin: 0; padding: 0; height: 100%; }
@@ -314,7 +315,7 @@
         overflow: auto;
         font-size: 1rem;
         color: #fff;
-        background-color: #333;
+        background-color: var(--help-bg-color);
         border: 0.125rem solid #000;
         box-shadow: 0 0.5rem 2.5rem 0.3rem var(--help-sh-color);
       }
@@ -407,6 +408,7 @@
           --search-bg-color-focus: #000;
           --search-sh-color: rgba(255, 255, 255, 0.28);
           --help-sh-color: rgba(142, 142, 142, 0.5);
+          --help-bg-color: #333;
         }
 
         .docs pre {
-- 
2.54.0


From 9fc6990052d49f3ab965f55d2d134d3275cacf85 Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Sat, 6 Aug 2022 17:29:13 +0200
Subject: [PATCH 038/290] autodoc: re-introduce search result limits

---
 lib/docs/index.html |  1 +
 lib/docs/main.js    | 28 +++++++++++++++++++++++++---
 2 files changed, 26 insertions(+), 3 deletions(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index dbcb54288afdb472eae9738755d52724a9fb93d8..4d2fda7f1c7b2c79c0505e04394cde6bafaaaf9d 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -647,6 +647,7 @@
             <div id="sectSearchResults" class="hidden">
               <h2>Search Results</h2>
               <ul id="listSearchResults"></ul>
+              <p id="sectSearchAllResultsLink" class="hidden"><a href="">show all results</a></p>
             </div>
             <div id="sectSearchNoResults" class="hidden">
               <h2>No Results Found</h2>
diff --git a/lib/docs/main.js b/lib/docs/main.js
index 2b6417c0152bb0f0a3b7844edd670fae162bb8ff..ebbe1379796b5641a37788705473ced00bad7201 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -40,7 +40,8 @@ var zigAnalysis;
   let domDeclNoRef = document.getElementById("declNoRef");
   let domSearch = document.getElementById("search");
   let domSectSearchResults = document.getElementById("sectSearchResults");
-
+  let domSectSearchAllResultsLink = document.getElementById("sectSearchAllResultsLink");
+  
   let domListSearchResults = document.getElementById("listSearchResults");
   let domSectSearchNoResults = document.getElementById("sectSearchNoResults");
   let domSectInfo = document.getElementById("sectInfo");
@@ -51,6 +52,7 @@ var zigAnalysis;
   let domHelpModal = document.getElementById("helpDialog");
 
   let searchTimer = null;
+  let searchTrimResults = true;
 
   let escapeHtmlReplacements = {
     "&": "&amp;",
@@ -103,6 +105,14 @@ var zigAnalysis;
   // let nodesToCallsMap = indexNodesToCalls();
 
   domSearch.addEventListener("keydown", onSearchKeyDown, false);
+  domSectSearchAllResultsLink.addEventListener('click', onClickSearchShowAllResults, false);
+  function onClickSearchShowAllResults(ev) {
+      ev.preventDefault();
+      ev.stopPropagation();
+      searchTrimResults = false;
+      onHashChange();
+  }
+  
   domPrivDeclsBox.addEventListener(
     "change",
     function () {
@@ -355,6 +365,7 @@ var zigAnalysis;
     domSectFns.classList.add("hidden");
     domSectFields.classList.add("hidden");
     domSectSearchResults.classList.add("hidden");
+    domSectSearchAllResultsLink.classList.add("hidden");
     domSectSearchNoResults.classList.add("hidden");
     domSectInfo.classList.add("hidden");
     domHdrName.classList.add("hidden");
@@ -3261,6 +3272,7 @@ var zigAnalysis;
     list.sort();
     return list;
   }
+  
   function renderSearch() {
     let matchedItems = [];
     let ignoreCase = curNavSearch.toLowerCase() === curNavSearch;
@@ -3332,6 +3344,14 @@ var zigAnalysis;
         return operatorCompare(a.decl.name, b.decl.name);
       });
 
+
+      var searchTrimmed = false
+      var searchTrimResultsMaxItems = 200
+      if (searchTrimResults && matchedItems.length > searchTrimResultsMaxItems) {
+          matchedItems = matchedItems.slice(0, searchTrimResultsMaxItems)
+          searchTrimmed = true
+      }
+
       // Build up the list of search results
       let matchedItemsHTML = "";
 
@@ -3342,12 +3362,14 @@ var zigAnalysis;
         const text = lastPkgName + "." + match.path.declNames.join(".");
         const href = navLink(match.path.pkgNames, match.path.declNames);
 
-        matchedItemsHTML += `<li><a href="${href}">${text}</a></li>`;
+        matchedItemsHTML += "<li><a href=\""+ href +"\">"+ text + "</a></li>";
       }
 
       // Replace the search results using our newly constructed HTML string
       domListSearchResults.innerHTML = matchedItemsHTML;
-
+      if (searchTrimmed) {
+          domSectSearchAllResultsLink.classList.remove("hidden");
+      }
       renderSearchCursor();
 
       domSectSearchResults.classList.remove("hidden");
-- 
2.54.0


From cb7c912a1b0957c6ade28452d92d6aef95bf07ac Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Sat, 6 Aug 2022 17:29:39 +0200
Subject: [PATCH 039/290] autodoc: use location.replace to avoid history spam
 when searching

---
 lib/docs/main.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index ebbe1379796b5641a37788705473ced00bad7201..1b15183046fd335f3e0ecdda333bfe74624c9eed 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -3264,8 +3264,7 @@ var zigAnalysis;
     let oldHash = location.hash;
     let parts = oldHash.split("?");
     let newPart2 = domSearch.value === "" ? "" : "?" + domSearch.value;
-    location.hash =
-      parts.length === 1 ? oldHash + newPart2 : parts[0] + newPart2;
+    location.replace(parts.length === 1 ? oldHash + newPart2 : parts[0] + newPart2);
   }
   function getSearchTerms() {
     let list = curNavSearch.trim().split(/[ \r\n\t]+/);
-- 
2.54.0


From 94662591d617226caabcb6c7319d703f1e41a880 Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Sat, 6 Aug 2022 18:12:21 +0200
Subject: [PATCH 040/290] ci: upload langref and stdlib docs directly to s3

previously we were delegating that job to the website CI but it caused
the website repo to bloat, so now we only commit releases.json
---
 ci/srht/update_download_page | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/ci/srht/update_download_page b/ci/srht/update_download_page
index f064712d4e6c4ee790a9975ff8af86374c92d307..5c007b6986d4d94c8cfb5e892d5e7de233ef3fd3 100755
--- a/ci/srht/update_download_page
+++ b/ci/srht/update_download_page
@@ -100,6 +100,15 @@ cd "$SRCTARBALLDIR/ci/srht"
 CIDIR="$(pwd)"
 
 cd "$HOME"
+
+# Upload new stdlib autodocs 
+mkdir -p docs_to_upload/documentation/master/std/
+cp "$ZIGDIR/docs/std/index.html" docs_to_upload/documentation/master/std/index.html
+cp "$ZIGDIR/docs/std/data.js" docs_to_upload/documentation/master/std/data.js
+cp "$ZIGDIR/docs/std/main.js" docs_to_upload/documentation/master/std/main.js
+cp "$LANGREF" docs_to_upload/documentation/master/index.html
+$S3CMD put -P --no-mime-magic --recursive --add-header="Cache-Control: max-age=0, must-revalidate" "docs_to_upload/" s3://ziglang.org/
+
 git clone --depth 1 git@github.com:ziglang/www.ziglang.org.git
 cd www.ziglang.org
 WWWDIR="$(pwd)"
@@ -108,12 +117,6 @@ $S3CMD put -P --no-mime-magic --add-header="cache-control: public, max-age=31536
 
 cd "$WWWDIR"
 cp "$CIDIR/out/index.json" data/releases.json
-mkdir -p content/documentation/master/std
-cp "$LANGREF" content/documentation/master/index.html
-cp "$ZIGDIR/docs/std/index.html" content/documentation/master/std/index.html
-cp "$ZIGDIR/docs/std/data.js" content/documentation/master/std/data.js
-cp "$ZIGDIR/docs/std/main.js" content/documentation/master/std/main.js
 git add data/releases.json
-git add content/
-git commit -m "CI: update releases and docs"
+git commit -m "CI: update releases"
 git push origin master
-- 
2.54.0


From bd21f499dcd1b50a6ac39644303a9647d16adb0f Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Thu, 4 Aug 2022 11:37:09 +0300
Subject: [PATCH 041/290] Type: adjust C type sizes

---
 lib/std/target.zig |  3 ++-
 src/type.zig       | 66 +++++++++++++++++++++++++++-------------------
 2 files changed, 41 insertions(+), 28 deletions(-)

diff --git a/lib/std/target.zig b/lib/std/target.zig
index d15eae7dc5fc7e58a1d7bc394c193a956dd9f1f5..f77f73bce0bac90cb1534a7f46e9366040d5c89e 100644
--- a/lib/std/target.zig
+++ b/lib/std/target.zig
@@ -1750,10 +1750,11 @@ pub const Target = struct {
                 else => false,
             },
             f64 => switch (target.cpu.arch) {
+                .aarch64 => target.isDarwin(),
+
                 .x86_64,
                 .i386,
                 .riscv64,
-                .aarch64,
                 .aarch64_be,
                 .aarch64_32,
                 .s390x,
diff --git a/src/type.zig b/src/type.zig
index 3b1b0dd59d6c312f69e7684bdbdf425a02e6faf7..d53158735a4221a8f8c6bead4669db9e788b5980 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -6530,6 +6530,11 @@ pub const CType = enum {
                     .long, .ulong => return 32,
                     .longlong, .ulonglong, .longdouble => return 64,
                 },
+                .avr => switch (self) {
+                    .short, .ushort, .int, .uint => return 16,
+                    .long, .ulong, .longdouble => return 32,
+                    .longlong, .ulonglong => return 64,
+                },
                 else => switch (self) {
                     .short, .ushort => return 16,
                     .int, .uint => return 32,
@@ -6568,31 +6573,42 @@ pub const CType = enum {
             .emscripten,
             .plan9,
             .solaris,
-            => switch (self) {
-                .short, .ushort => return 16,
-                .int, .uint => return 32,
-                .long, .ulong => return target.cpu.arch.ptrBitWidth(),
-                .longlong, .ulonglong => return 64,
-                .longdouble => switch (target.cpu.arch) {
-                    .i386, .x86_64 => return 80,
+            .haiku,
+            .ananas,
+            .fuchsia,
+            .minix,
+            => switch (target.cpu.arch) {
+                .avr => switch (self) {
+                    .short, .ushort, .int, .uint => return 16,
+                    .long, .ulong, .longdouble => return 32,
+                    .longlong, .ulonglong => return 64,
+                },
+                else => switch (self) {
+                    .short, .ushort => return 16,
+                    .int, .uint => return 32,
+                    .long, .ulong => return target.cpu.arch.ptrBitWidth(),
+                    .longlong, .ulonglong => return 64,
+                    .longdouble => switch (target.cpu.arch) {
+                        .i386, .x86_64 => return 80,
 
-                    .riscv64,
-                    .aarch64,
-                    .aarch64_be,
-                    .aarch64_32,
-                    .s390x,
-                    .mips64,
-                    .mips64el,
-                    .sparc,
-                    .sparc64,
-                    .sparcel,
-                    .powerpc,
-                    .powerpcle,
-                    .powerpc64,
-                    .powerpc64le,
-                    => return 128,
+                        .riscv64,
+                        .aarch64,
+                        .aarch64_be,
+                        .aarch64_32,
+                        .s390x,
+                        .mips64,
+                        .mips64el,
+                        .sparc,
+                        .sparc64,
+                        .sparcel,
+                        .powerpc,
+                        .powerpcle,
+                        .powerpc64,
+                        .powerpc64le,
+                        => return 128,
 
-                    else => return 64,
+                        else => return 64,
+                    },
                 },
             },
 
@@ -6612,14 +6628,10 @@ pub const CType = enum {
                 },
             },
 
-            .ananas,
             .cloudabi,
-            .fuchsia,
             .kfreebsd,
             .lv2,
             .zos,
-            .haiku,
-            .minix,
             .rtems,
             .nacl,
             .aix,
-- 
2.54.0


From b300eecb9da8f9ea0baffe737eb595df3c12381f Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Sat, 6 Aug 2022 19:43:04 +0200
Subject: [PATCH 042/290] stage2 DWARF: fix size and offset in slices

Previously, `@sizeOf(usize)` was used, however, the pointer size of
the host may differ from the target when cross-compiling.
---
 src/link/Dwarf.zig | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index 627f946e36dbfd11cb2303561aae048a1c12a7de..2cd00f5a87430c5bbcbe5327b3a7ebb88183d5a3 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -243,11 +243,13 @@ pub const DeclState = struct {
             .Pointer => {
                 if (ty.isSlice()) {
                     // Slices are structs: struct { .ptr = *, .len = N }
+                    const ptr_bits = target.cpu.arch.ptrBitWidth();
+                    const ptr_bytes = @intCast(u8, @divExact(ptr_bits, 8));
                     // DW.AT.structure_type
                     try dbg_info_buffer.ensureUnusedCapacity(2);
                     dbg_info_buffer.appendAssumeCapacity(@enumToInt(AbbrevKind.struct_type));
                     // DW.AT.byte_size, DW.FORM.sdata
-                    dbg_info_buffer.appendAssumeCapacity(@sizeOf(usize) * 2);
+                    dbg_info_buffer.appendAssumeCapacity(ptr_bytes * 2);
                     // DW.AT.name, DW.FORM.string
                     try dbg_info_buffer.writer().print("{}\x00", .{ty.fmt(module)});
                     // DW.AT.member
@@ -276,7 +278,7 @@ pub const DeclState = struct {
                     try self.addTypeRelocGlobal(atom, Type.usize, @intCast(u32, index));
                     // DW.AT.data_member_location, DW.FORM.sdata
                     try dbg_info_buffer.ensureUnusedCapacity(2);
-                    dbg_info_buffer.appendAssumeCapacity(@sizeOf(usize));
+                    dbg_info_buffer.appendAssumeCapacity(ptr_bytes);
                     // DW.AT.structure_type delimit children
                     dbg_info_buffer.appendAssumeCapacity(0);
                 } else {
-- 
2.54.0


From 3e2defd36c0bf90a0604a7618f57beaa4077139c Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sat, 6 Aug 2022 15:56:46 +0300
Subject: [PATCH 043/290] stage2: add a helpful error for when async is used

---
 src/AstGen.zig |  7 ++++++-
 src/Sema.zig   | 40 +++++++++++++++++++++++++++-------------
 2 files changed, 33 insertions(+), 14 deletions(-)

diff --git a/src/AstGen.zig b/src/AstGen.zig
index e30913ac76e4459136e5c075a278c230bf0f7a96..9c8252da55906b12c21a629bb332d3fef2aef6e5 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -859,7 +859,12 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
         },
         .enum_literal => return simpleStrTok(gz, rl, main_tokens[node], node, .enum_literal),
         .error_value => return simpleStrTok(gz, rl, node_datas[node].rhs, node, .error_value),
-        .anyframe_literal => return rvalue(gz, rl, .anyframe_type, node),
+        // TODO restore this when implementing https://github.com/ziglang/zig/issues/6025
+        // .anyframe_literal => return rvalue(gz, rl, .anyframe_type, node),
+        .anyframe_literal => {
+            const result = try gz.addUnNode(.anyframe_type, .void_type, node);
+            return rvalue(gz, rl, result, node);
+        },
         .anyframe_type => {
             const return_type = try typeExpr(gz, scope, node_datas[node].rhs);
             const result = try gz.addUnNode(.anyframe_type, return_type, node);
diff --git a/src/Sema.zig b/src/Sema.zig
index 8c2125026dd442591b091015612a50e006c1d28c..bd75e54e873b5568ee54a98c19fe1b5955238f57 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -1828,6 +1828,17 @@ fn failWithInvalidComptimeFieldStore(sema: *Sema, block: *Block, init_src: LazyS
     return sema.failWithOwnedErrorMsg(msg);
 }
 
+fn failWithUseOfAsync(sema: *Sema, block: *Block, src: LazySrcLoc) CompileError {
+    const msg = msg: {
+        const msg = try sema.errMsg(block, src, "async has not been implemented in the self-hosted compiler yet", .{});
+        errdefer msg.destroy(sema.gpa);
+
+        try sema.errNote(block, src, msg, "to use async enable the stage1 compiler with either '-fstage1' or by setting '.use_stage1 = true` in your 'build.zig' script", .{});
+        break :msg msg;
+    };
+    return sema.failWithOwnedErrorMsg(msg);
+}
+
 /// We don't return a pointer to the new error note because the pointer
 /// becomes invalid when you add another one.
 fn errNote(
@@ -4776,7 +4787,7 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
 fn zirSuspendBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
-    return sema.fail(parent_block, src, "TODO: implement Sema.zirSuspendBlock", .{});
+    return sema.failWithUseOfAsync(parent_block, src);
 }
 
 fn zirBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -5613,7 +5624,7 @@ fn analyzeCall(
         .never_inline => Air.Inst.Tag.call_never_inline,
         .always_tail => Air.Inst.Tag.call_always_tail,
 
-        .async_kw => return sema.fail(block, call_src, "TODO implement async call", .{}),
+        .async_kw => return sema.failWithUseOfAsync(block, call_src),
     };
 
     if (modifier == .never_inline and func_ty_info.cc == .Inline) {
@@ -6657,6 +6668,9 @@ fn zirAnyframeType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     defer tracy.end();
 
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
+    if (true) {
+        return sema.failWithUseOfAsync(block, inst_data.src());
+    }
     const operand_src: LazySrcLoc = .{ .node_offset_anyframe_type = inst_data.src_node };
     const return_type = try sema.resolveType(block, operand_src, inst_data.operand);
     const anyframe_type = try Type.Tag.anyframe_T.create(sema.arena, return_type);
@@ -14141,8 +14155,8 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
             );
         },
         .BoundFn => @panic("TODO remove this type from the language and compiler"),
-        .Frame => return sema.fail(block, src, "TODO: implement zirTypeInfo for Frame", .{}),
-        .AnyFrame => return sema.fail(block, src, "TODO: implement zirTypeInfo for AnyFrame", .{}),
+        .Frame => return sema.failWithUseOfAsync(block, src),
+        .AnyFrame => return sema.failWithUseOfAsync(block, src),
     }
 }
 
@@ -15787,7 +15801,7 @@ fn zirFrame(
     extended: Zir.Inst.Extended.InstData,
 ) CompileError!Air.Inst.Ref {
     const src = LazySrcLoc.nodeOffset(@bitCast(i32, extended.operand));
-    return sema.fail(block, src, "TODO: Sema.zirFrame", .{});
+    return sema.failWithUseOfAsync(block, src);
 }
 
 fn zirAlignOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -15976,7 +15990,7 @@ fn zirReify(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
         .ComptimeInt => return Air.Inst.Ref.comptime_int_type,
         .Undefined => return Air.Inst.Ref.undefined_type,
         .Null => return Air.Inst.Ref.null_type,
-        .AnyFrame => return Air.Inst.Ref.anyframe_type,
+        .AnyFrame => return sema.failWithUseOfAsync(block, src),
         .EnumLiteral => return Air.Inst.Ref.enum_literal_type,
         .Int => {
             const struct_val = union_val.val.castTag(.aggregate).?.data;
@@ -16628,7 +16642,7 @@ fn zirReify(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
             return sema.addType(ty);
         },
         .BoundFn => @panic("TODO delete BoundFn from the language"),
-        .Frame => @panic("TODO implement https://github.com/ziglang/zig/issues/10710"),
+        .Frame => return sema.failWithUseOfAsync(block, src),
     }
 }
 
@@ -16830,13 +16844,13 @@ fn zirTypeName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 fn zirFrameType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
-    return sema.fail(block, src, "TODO: Sema.zirFrameType", .{});
+    return sema.failWithUseOfAsync(block, src);
 }
 
 fn zirFrameSize(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
-    return sema.fail(block, src, "TODO: Sema.zirFrameSize", .{});
+    return sema.failWithUseOfAsync(block, src);
 }
 
 fn zirFloatToInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
@@ -19067,13 +19081,13 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
 fn zirBuiltinAsyncCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src = inst_data.src();
-    return sema.fail(block, src, "TODO: Sema.zirBuiltinAsyncCall", .{});
+    return sema.failWithUseOfAsync(block, src);
 }
 
 fn zirResume(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
-    return sema.fail(block, src, "TODO: Sema.zirResume", .{});
+    return sema.failWithUseOfAsync(block, src);
 }
 
 fn zirAwait(
@@ -19084,7 +19098,7 @@ fn zirAwait(
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
 
-    return sema.fail(block, src, "TODO: Sema.zirAwait", .{});
+    return sema.failWithUseOfAsync(block, src);
 }
 
 fn zirAwaitNosuspend(
@@ -19095,7 +19109,7 @@ fn zirAwaitNosuspend(
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
     const src = LazySrcLoc.nodeOffset(extra.node);
 
-    return sema.fail(block, src, "TODO: Sema.zirAwaitNosuspend", .{});
+    return sema.failWithUseOfAsync(block, src);
 }
 
 fn zirVarExtended(
-- 
2.54.0


From ae16c1d0835b517cb858cb9615888cdab1e351c5 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Fri, 5 Aug 2022 23:54:05 +0200
Subject: [PATCH 044/290] std: use std.macho.LoadCommandIterator for MachO
 parsing in std.debug

---
 lib/std/debug.zig | 165 +++++++++++++++++++---------------------------
 1 file changed, 68 insertions(+), 97 deletions(-)

diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 7d0dcd35d08c68b6de1be59639e369ed31eef2a0..847298e54b5ab8459583586af79360d3df04db65 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -968,24 +968,20 @@ fn readMachODebugInfo(allocator: mem.Allocator, macho_file: File) !ModuleDebugIn
     if (hdr.magic != macho.MH_MAGIC_64)
         return error.InvalidDebugInfo;
 
-    const hdr_base = @ptrCast([*]const u8, hdr);
-    var ptr = hdr_base + @sizeOf(macho.mach_header_64);
-    var ncmd: u32 = hdr.ncmds;
-    const symtab = while (ncmd != 0) : (ncmd -= 1) {
-        const lc = @ptrCast(*const std.macho.load_command, ptr);
-        switch (lc.cmd) {
-            .SYMTAB => break @ptrCast(*const std.macho.symtab_command, ptr),
-            else => {},
-        }
-        ptr = @alignCast(@alignOf(std.macho.load_command), ptr + lc.cmdsize);
-    } else {
-        return error.MissingDebugInfo;
+    var it = macho.LoadCommandIterator{
+        .ncmds = hdr.ncmds,
+        .buffer = mapped_mem[@sizeOf(macho.mach_header_64)..][0..hdr.sizeofcmds],
     };
+    const symtab = while (it.next()) |cmd| switch (cmd.cmd()) {
+        .SYMTAB => break cmd.cast(macho.symtab_command).?,
+        else => {},
+    } else return error.MissingDebugInfo;
+
     const syms = @ptrCast(
         [*]const macho.nlist_64,
-        @alignCast(@alignOf(macho.nlist_64), hdr_base + symtab.symoff),
+        @alignCast(@alignOf(macho.nlist_64), &mapped_mem[symtab.symoff]),
     )[0..symtab.nsyms];
-    const strings = @ptrCast([*]const u8, hdr_base + symtab.stroff)[0 .. symtab.strsize - 1 :0];
+    const strings = mapped_mem[symtab.stroff..][0 .. symtab.strsize - 1 :0];
 
     const symbols_buf = try allocator.alloc(MachoSymbol, syms.len);
 
@@ -1200,48 +1196,46 @@ pub const DebugInfo = struct {
             if (address < base_address) continue;
 
             const header = std.c._dyld_get_image_header(i) orelse continue;
-            // The array of load commands is right after the header
-            var cmd_ptr = @intToPtr([*]u8, @ptrToInt(header) + @sizeOf(macho.mach_header_64));
 
-            var cmds = header.ncmds;
-            while (cmds != 0) : (cmds -= 1) {
-                const lc = @ptrCast(
-                    *macho.load_command,
-                    @alignCast(@alignOf(macho.load_command), cmd_ptr),
-                );
-                cmd_ptr += lc.cmdsize;
-                if (lc.cmd != .SEGMENT_64) continue;
+            var it = macho.LoadCommandIterator{
+                .ncmds = header.ncmds,
+                .buffer = @alignCast(@alignOf(u64), @intToPtr(
+                    [*]u8,
+                    @ptrToInt(header) + @sizeOf(macho.mach_header_64),
+                ))[0..header.sizeofcmds],
+            };
+            while (it.next()) |cmd| switch (cmd.cmd()) {
+                .SEGMENT_64 => {
+                    const segment_cmd = cmd.cast(macho.segment_command_64).?;
+                    const rebased_address = address - base_address;
+                    const seg_start = segment_cmd.vmaddr;
+                    const seg_end = seg_start + segment_cmd.vmsize;
 
-                const segment_cmd = @ptrCast(
-                    *const std.macho.segment_command_64,
-                    @alignCast(@alignOf(std.macho.segment_command_64), lc),
-                );
+                    if (rebased_address >= seg_start and rebased_address < seg_end) {
+                        if (self.address_map.get(base_address)) |obj_di| {
+                            return obj_di;
+                        }
 
-                const rebased_address = address - base_address;
-                const seg_start = segment_cmd.vmaddr;
-                const seg_end = seg_start + segment_cmd.vmsize;
+                        const obj_di = try self.allocator.create(ModuleDebugInfo);
+                        errdefer self.allocator.destroy(obj_di);
+
+                        const macho_path = mem.sliceTo(std.c._dyld_get_image_name(i), 0);
+                        const macho_file = fs.cwd().openFile(macho_path, .{
+                            .intended_io_mode = .blocking,
+                        }) catch |err| switch (err) {
+                            error.FileNotFound => return error.MissingDebugInfo,
+                            else => return err,
+                        };
+                        obj_di.* = try readMachODebugInfo(self.allocator, macho_file);
+                        obj_di.base_address = base_address;
+
+                        try self.address_map.putNoClobber(base_address, obj_di);
 
-                if (rebased_address >= seg_start and rebased_address < seg_end) {
-                    if (self.address_map.get(base_address)) |obj_di| {
                         return obj_di;
                     }
-
-                    const obj_di = try self.allocator.create(ModuleDebugInfo);
-                    errdefer self.allocator.destroy(obj_di);
-
-                    const macho_path = mem.sliceTo(std.c._dyld_get_image_name(i), 0);
-                    const macho_file = fs.cwd().openFile(macho_path, .{ .intended_io_mode = .blocking }) catch |err| switch (err) {
-                        error.FileNotFound => return error.MissingDebugInfo,
-                        else => return err,
-                    };
-                    obj_di.* = try readMachODebugInfo(self.allocator, macho_file);
-                    obj_di.base_address = base_address;
-
-                    try self.address_map.putNoClobber(base_address, obj_di);
-
-                    return obj_di;
-                }
-            }
+                },
+                else => {},
+            };
         }
 
         return error.MissingDebugInfo;
@@ -1445,44 +1439,31 @@ pub const ModuleDebugInfo = switch (native_os) {
             if (hdr.magic != std.macho.MH_MAGIC_64)
                 return error.InvalidDebugInfo;
 
-            const hdr_base = @ptrCast([*]const u8, hdr);
-            var ptr = hdr_base + @sizeOf(macho.mach_header_64);
-            var segptr = ptr;
-            var ncmd: u32 = hdr.ncmds;
-            var segcmd: ?*const macho.segment_command_64 = null;
-            var symtabcmd: ?*const macho.symtab_command = null;
-
-            while (ncmd != 0) : (ncmd -= 1) {
-                const lc = @ptrCast(*const std.macho.load_command, ptr);
-                switch (lc.cmd) {
-                    .SEGMENT_64 => {
-                        segcmd = @ptrCast(
-                            *const std.macho.segment_command_64,
-                            @alignCast(@alignOf(std.macho.segment_command_64), ptr),
-                        );
-                        segptr = ptr;
-                    },
-                    .SYMTAB => {
-                        symtabcmd = @ptrCast(
-                            *const std.macho.symtab_command,
-                            @alignCast(@alignOf(std.macho.symtab_command), ptr),
-                        );
-                    },
-                    else => {},
-                }
-                ptr = @alignCast(@alignOf(std.macho.load_command), ptr + lc.cmdsize);
-            }
+            var segcmd: ?macho.LoadCommandIterator.LoadCommand = null;
+            var symtabcmd: ?macho.symtab_command = null;
+            var it = macho.LoadCommandIterator{
+                .ncmds = hdr.ncmds,
+                .buffer = mapped_mem[@sizeOf(macho.mach_header_64)..][0..hdr.sizeofcmds],
+            };
+            while (it.next()) |cmd| switch (cmd.cmd()) {
+                .SEGMENT_64 => segcmd = cmd,
+                .SYMTAB => symtabcmd = cmd.cast(macho.symtab_command).?,
+                else => {},
+            };
 
             if (segcmd == null or symtabcmd == null) return error.MissingDebugInfo;
 
             // Parse symbols
             const strtab = @ptrCast(
                 [*]const u8,
-                hdr_base + symtabcmd.?.stroff,
+                &mapped_mem[symtabcmd.?.stroff],
             )[0 .. symtabcmd.?.strsize - 1 :0];
             const symtab = @ptrCast(
                 [*]const macho.nlist_64,
-                @alignCast(@alignOf(macho.nlist_64), hdr_base + symtabcmd.?.symoff),
+                @alignCast(
+                    @alignOf(macho.nlist_64),
+                    &mapped_mem[symtabcmd.?.symoff],
+                ),
             )[0..symtabcmd.?.nsyms];
 
             // TODO handle tentative (common) symbols
@@ -1496,25 +1477,15 @@ pub const ModuleDebugInfo = switch (native_os) {
                 addr_table.putAssumeCapacityNoClobber(sym_name, sym.n_value);
             }
 
-            var opt_debug_line: ?*const macho.section_64 = null;
-            var opt_debug_info: ?*const macho.section_64 = null;
-            var opt_debug_abbrev: ?*const macho.section_64 = null;
-            var opt_debug_str: ?*const macho.section_64 = null;
-            var opt_debug_line_str: ?*const macho.section_64 = null;
-            var opt_debug_ranges: ?*const macho.section_64 = null;
-
-            const sections = @ptrCast(
-                [*]const macho.section_64,
-                @alignCast(@alignOf(macho.section_64), segptr + @sizeOf(std.macho.segment_command_64)),
-            )[0..segcmd.?.nsects];
-            for (sections) |*sect| {
-                // The section name may not exceed 16 chars and a trailing null may
-                // not be present
-                const name = if (mem.indexOfScalar(u8, sect.sectname[0..], 0)) |last|
-                    sect.sectname[0..last]
-                else
-                    sect.sectname[0..];
+            var opt_debug_line: ?macho.section_64 = null;
+            var opt_debug_info: ?macho.section_64 = null;
+            var opt_debug_abbrev: ?macho.section_64 = null;
+            var opt_debug_str: ?macho.section_64 = null;
+            var opt_debug_line_str: ?macho.section_64 = null;
+            var opt_debug_ranges: ?macho.section_64 = null;
 
+            for (segcmd.?.getSections()) |sect| {
+                const name = sect.sectName();
                 if (mem.eql(u8, name, "__debug_line")) {
                     opt_debug_line = sect;
                 } else if (mem.eql(u8, name, "__debug_info")) {
-- 
2.54.0


From 0879cbeed262415645fe388e1991c7df866f7064 Mon Sep 17 00:00:00 2001
From: Meghan Denny <hello@nektro.net>
Date: Sun, 24 Jul 2022 19:05:20 -0700
Subject: [PATCH 045/290] remove 'builtin.stage2_arch', Sema is smart enough
 now

---
 lib/std/os/plan9.zig     | 2 +-
 lib/std/start.zig        | 4 ++--
 src/Compilation.zig      | 3 ---
 src/stage1/codegen.cpp   | 1 -
 test/behavior.zig        | 2 +-
 test/behavior/struct.zig | 2 +-
 6 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/lib/std/os/plan9.zig b/lib/std/os/plan9.zig
index 99e25709b1bcd0ed8a9d9fbc41399b3cd594e94a..6d052a35731339981ccb88ff917766857eb17c6d 100644
--- a/lib/std/os/plan9.zig
+++ b/lib/std/os/plan9.zig
@@ -1,7 +1,7 @@
 const std = @import("../std.zig");
 const builtin = @import("builtin");
 
-pub const syscall_bits = switch (builtin.stage2_arch) {
+pub const syscall_bits = switch (builtin.cpu.arch) {
     .x86_64 => @import("plan9/x86_64.zig"),
     else => @compileError("more plan9 syscall implementations (needs more inline asm in stage2"),
 };
diff --git a/lib/std/start.zig b/lib/std/start.zig
index 8ea261be2da3458fba087d3cbe165eee5e06a7ce..e6a7b7991aea95d6c66f38c1e094372c9cc8a8e6 100644
--- a/lib/std/start.zig
+++ b/lib/std/start.zig
@@ -131,7 +131,7 @@ fn wWinMainCRTStartup2() callconv(.C) noreturn {
 
 fn exit2(code: usize) noreturn {
     switch (native_os) {
-        .linux => switch (builtin.stage2_arch) {
+        .linux => switch (builtin.cpu.arch) {
             .x86_64 => {
                 asm volatile ("syscall"
                     :
@@ -175,7 +175,7 @@ fn exit2(code: usize) noreturn {
             else => @compileError("TODO"),
         },
         // exits(0)
-        .plan9 => switch (builtin.stage2_arch) {
+        .plan9 => switch (builtin.cpu.arch) {
             .x86_64 => {
                 asm volatile (
                     \\push $0
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 17ffe356a37a0a242100804a81d73e6d17982d88..d3816e542cfecf8969f9b37ed9975a214e5851e3 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -4763,8 +4763,6 @@ pub fn generateBuiltinZigSource(comp: *Compilation, allocator: Allocator) Alloca
         \\/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
         \\pub const zig_version = std.SemanticVersion.parse("{s}") catch unreachable;
         \\pub const zig_backend = std.builtin.CompilerBackend.{};
-        \\/// Temporary until self-hosted supports the `cpu.arch` value.
-        \\pub const stage2_arch: std.Target.Cpu.Arch = .{};
         \\
         \\pub const output_mode = std.builtin.OutputMode.{};
         \\pub const link_mode = std.builtin.LinkMode.{};
@@ -4779,7 +4777,6 @@ pub fn generateBuiltinZigSource(comp: *Compilation, allocator: Allocator) Alloca
     , .{
         build_options.version,
         std.zig.fmtId(@tagName(zig_backend)),
-        std.zig.fmtId(@tagName(target.cpu.arch)),
         std.zig.fmtId(@tagName(comp.bin_file.options.output_mode)),
         std.zig.fmtId(@tagName(comp.bin_file.options.link_mode)),
         comp.bin_file.options.is_test,
diff --git a/src/stage1/codegen.cpp b/src/stage1/codegen.cpp
index 8b8844629572d4de7f2f60a6039d50c6410b7d17..7010e736dc041c618023cefe12e0af458a9e3fc8 100644
--- a/src/stage1/codegen.cpp
+++ b/src/stage1/codegen.cpp
@@ -10076,7 +10076,6 @@ Buf *codegen_generate_builtin_source(CodeGen *g) {
     buf_appendf(contents, "pub const single_threaded = %s;\n", bool_to_str(g->is_single_threaded));
     buf_appendf(contents, "pub const abi = std.Target.Abi.%s;\n", cur_abi);
     buf_appendf(contents, "pub const cpu = std.Target.Cpu.baseline(.%s);\n", cur_arch);
-    buf_appendf(contents, "pub const stage2_arch: std.Target.Cpu.Arch = .%s;\n", cur_arch);
     buf_appendf(contents, "pub const os = std.Target.Os.Tag.defaultVersionRange(.%s, .%s);\n", cur_os, cur_arch);
     buf_appendf(contents,
         "pub const target = std.Target{\n"
diff --git a/test/behavior.zig b/test/behavior.zig
index 813c410f7b85840d48c84c41ee1ac02588e63f0e..fee61f5e0921ad3809aa3927a63fa8df402b3e52 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -159,7 +159,7 @@ test {
     _ = @import("behavior/while.zig");
     _ = @import("behavior/widening.zig");
 
-    if (builtin.stage2_arch == .wasm32) {
+    if (builtin.cpu.arch == .wasm32) {
         _ = @import("behavior/wasm.zig");
     }
 
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index 377cbb56f4a7ca6c2a34367fa42a55262c6827ed..eb29c9038d7a452362cc745e40c8dca7fba03d21 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -963,7 +963,7 @@ test "tuple assigned to variable" {
 
 test "comptime struct field" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.stage2_arch == .arm) return error.SkipZigTest; // TODO
+    if (builtin.cpu.arch == .arm) return error.SkipZigTest; // TODO
 
     const T = struct {
         a: i32,
-- 
2.54.0


From 11c715cd5ad392a322858627a12c288d026d2a06 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 7 Aug 2022 15:21:15 -0700
Subject: [PATCH 046/290] remove brittle test case

see #12358
---
 ...or_tagged_union_with_extra_union_field.zig | 35 -------------------
 1 file changed, 35 deletions(-)
 delete mode 100644 test/cases/compile_errors/reify_type_for_tagged_union_with_extra_union_field.zig

diff --git a/test/cases/compile_errors/reify_type_for_tagged_union_with_extra_union_field.zig b/test/cases/compile_errors/reify_type_for_tagged_union_with_extra_union_field.zig
deleted file mode 100644
index ee557cd6c2ee3e3f20ca924ba9ef4006251ab683..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/reify_type_for_tagged_union_with_extra_union_field.zig
+++ /dev/null
@@ -1,35 +0,0 @@
-const Tag = @Type(.{
-    .Enum = .{
-        .layout = .Auto,
-        .tag_type = u1,
-        .fields = &.{
-            .{ .name = "signed", .value = 0 },
-            .{ .name = "unsigned", .value = 1 },
-        },
-        .decls = &.{},
-        .is_exhaustive = true,
-    },
-});
-const Tagged = @Type(.{
-    .Union = .{
-        .layout = .Auto,
-        .tag_type = Tag,
-        .fields = &.{
-            .{ .name = "signed", .field_type = i32, .alignment = @alignOf(i32) },
-            .{ .name = "unsigned", .field_type = u32, .alignment = @alignOf(u32) },
-            .{ .name = "arst", .field_type = f32, .alignment = @alignOf(f32) },
-        },
-        .decls = &.{},
-    },
-});
-export fn entry() void {
-    var tagged = Tagged{ .signed = -1 };
-    tagged = .{ .unsigned = 1 };
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :13:16: error: no field named 'arst' in enum 'tmp.Tag__enum_266'
-// :1:13: note: enum declared here
-- 
2.54.0


From ec7f7131473a5648703c48422b449c12ed4524aa Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 7 Aug 2022 16:05:57 -0700
Subject: [PATCH 047/290] delete failing RISC-V test

this backend needs to get further along before it deserves test
coverage.
---
 .../hello_world_with_updates.0.zig            | 21 ---------------
 .../hello_world_with_updates.1.zig            | 27 -------------------
 2 files changed, 48 deletions(-)
 delete mode 100644 test/cases/riscv64-linux/hello_world_with_updates.0.zig
 delete mode 100644 test/cases/riscv64-linux/hello_world_with_updates.1.zig

diff --git a/test/cases/riscv64-linux/hello_world_with_updates.0.zig b/test/cases/riscv64-linux/hello_world_with_updates.0.zig
deleted file mode 100644
index dd119fd1f4366a089f62a796daf96cf437a43f04..0000000000000000000000000000000000000000
--- a/test/cases/riscv64-linux/hello_world_with_updates.0.zig
+++ /dev/null
@@ -1,21 +0,0 @@
-pub fn main() void {
-    print();
-}
-
-fn print() void {
-    asm volatile ("ecall"
-        :
-        : [number] "{a7}" (64),
-          [arg1] "{a0}" (1),
-          [arg2] "{a1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{a2}" ("Hello, World!\n".len),
-        : "rcx", "r11", "memory"
-    );
-    return;
-}
-
-// run
-// target=riscv64-linux
-//
-// Hello, World!
-//
diff --git a/test/cases/riscv64-linux/hello_world_with_updates.1.zig b/test/cases/riscv64-linux/hello_world_with_updates.1.zig
deleted file mode 100644
index 26718738a9ed459aeb650db31628ad2f2b7de0c6..0000000000000000000000000000000000000000
--- a/test/cases/riscv64-linux/hello_world_with_updates.1.zig
+++ /dev/null
@@ -1,27 +0,0 @@
-pub fn main() void {
-    print();
-    print();
-    print();
-    print();
-}
-
-fn print() void {
-    asm volatile ("ecall"
-        :
-        : [number] "{a7}" (64),
-          [arg1] "{a0}" (1),
-          [arg2] "{a1}" (@ptrToInt("Hello, World!\n")),
-          [arg3] "{a2}" ("Hello, World!\n".len),
-        : "rcx", "r11", "memory"
-    );
-    return;
-}
-
-// run
-// target=riscv64-linux
-//
-// Hello, World!
-// Hello, World!
-// Hello, World!
-// Hello, World!
-//
-- 
2.54.0


From 80c9d3f3b13a5e88a4103582f406a698fa8643d1 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Mon, 8 Aug 2022 14:25:45 +0200
Subject: [PATCH 048/290] update update_clang_options.zig to latest formatting
 changes

---
 tools/update_clang_options.zig | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/tools/update_clang_options.zig b/tools/update_clang_options.zig
index 2c13f1082b73ae34a3309469335cb1596cf9f269..22df0054a2830fbff1d80ee1d8fabffeb7ddb124 100644
--- a/tools/update_clang_options.zig
+++ b/tools/update_clang_options.zig
@@ -497,7 +497,7 @@ const cpu_targets = struct {
     pub const riscv = std.Target.riscv;
     pub const sparc = std.Target.sparc;
     pub const spirv = std.Target.spirv;
-    pub const systemz = std.Target.systemz;
+    pub const s390x = std.Target.s390x;
     pub const ve = std.Target.ve;
     pub const wasm = std.Target.wasm;
     pub const x86 = std.Target.x86;
@@ -647,9 +647,9 @@ pub fn main() anyerror!void {
                 \\    .name = "{s}",
                 \\    .syntax = {s},
                 \\    .zig_equivalent = .{s},
-                \\    .pd1 = {s},
-                \\    .pd2 = {s},
-                \\    .psl = {s},
+                \\    .pd1 = {},
+                \\    .pd2 = {},
+                \\    .psl = {},
                 \\}},
                 \\
             , .{ name, final_syntax, ident, pd1, pd2, pslash });
@@ -677,9 +677,9 @@ pub fn main() anyerror!void {
                 \\    .name = "{s}",
                 \\    .syntax = {s},
                 \\    .zig_equivalent = .other,
-                \\    .pd1 = {s},
-                \\    .pd2 = {s},
-                \\    .psl = {s},
+                \\    .pd1 = {},
+                \\    .pd2 = {},
+                \\    .psl = {},
                 \\}},
                 \\
             , .{ name, syntax, pd1, pd2, pslash });
-- 
2.54.0


From a0ec07fdec9efb8364394ad12b4000a9072ed59f Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Mon, 8 Aug 2022 14:26:10 +0200
Subject: [PATCH 049/290] cc: add support for -M flag

---
 src/clang_options_data.zig     | 13 ++++++++++---
 src/main.zig                   |  5 +++--
 tools/update_clang_options.zig |  8 ++++++--
 3 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/src/clang_options_data.zig b/src/clang_options_data.zig
index d4320b1619a1ed03e981e43f8d2dab2c47f5c6f9..76e687c7d6aba2a3b721e8ba97d0d6062f9c8d6b 100644
--- a/src/clang_options_data.zig
+++ b/src/clang_options_data.zig
@@ -33,7 +33,14 @@ flagpd1("H"),
     .psl = false,
 },
 flagpd1("I-"),
-flagpd1("M"),
+.{
+    .name = "M",
+    .syntax = .flag,
+    .zig_equivalent = .dep_file_to_stdout,
+    .pd1 = true,
+    .pd2 = false,
+    .psl = false,
+},
 .{
     .name = "MD",
     .syntax = .flag,
@@ -53,7 +60,7 @@ flagpd1("M"),
 .{
     .name = "MM",
     .syntax = .flag,
-    .zig_equivalent = .dep_file_mm,
+    .zig_equivalent = .dep_file_to_stdout,
     .pd1 = true,
     .pd2 = false,
     .psl = false,
@@ -1983,7 +1990,7 @@ flagpsl("MT"),
 .{
     .name = "user-dependencies",
     .syntax = .flag,
-    .zig_equivalent = .dep_file_mm,
+    .zig_equivalent = .dep_file_to_stdout,
     .pd1 = false,
     .pd2 = true,
     .psl = false,
diff --git a/src/main.zig b/src/main.zig
index f192137b3c3f26dd6482159ade66fa690c1677a0..0c6e4a63a3ab978ed59600c003b0ba7740cb3051 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -1657,7 +1657,8 @@ fn buildOutputType(
                         disable_c_depfile = true;
                         try clang_argv.appendSlice(it.other_args);
                     },
-                    .dep_file_mm => { // -MM
+                    .dep_file_to_stdout => { // -M, -MM
+                        // "Like -MD, but also implies -E and writes to stdout by default"
                         // "Like -MMD, but also implies -E and writes to stdout by default"
                         c_out_mode = .preprocessor;
                         disable_c_depfile = true;
@@ -4652,7 +4653,7 @@ pub const ClangArgIterator = struct {
         lib_dir,
         mcpu,
         dep_file,
-        dep_file_mm,
+        dep_file_to_stdout,
         framework_dir,
         framework,
         nostdlibinc,
diff --git a/tools/update_clang_options.zig b/tools/update_clang_options.zig
index 22df0054a2830fbff1d80ee1d8fabffeb7ddb124..d261b5ee33325468bd892746e3822b8a9d02974e 100644
--- a/tools/update_clang_options.zig
+++ b/tools/update_clang_options.zig
@@ -386,11 +386,15 @@ const known_options = [_]KnownOpt{
     },
     .{
         .name = "MM",
-        .ident = "dep_file_mm",
+        .ident = "dep_file_to_stdout",
+    },
+    .{
+        .name = "M",
+        .ident = "dep_file_to_stdout",
     },
     .{
         .name = "user-dependencies",
-        .ident = "dep_file_mm",
+        .ident = "dep_file_to_stdout",
     },
     .{
         .name = "MMD",
-- 
2.54.0


From ff6d2e632f8191ae7cbb048770ef2ecff00f72c7 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sat, 6 Aug 2022 19:45:50 +0200
Subject: [PATCH 050/290] fix: cleanup recent changes

---
 lib/docs/main.js | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 3b5a907536f113ebe6ce3cef6332bfabacd2ae7e..f171326b2ea0e2cd3674c26cb4b6b8a9540eb60a 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -2768,7 +2768,7 @@ var zigAnalysis;
                 });
               }
 
-              // Generic fun/ction
+              // Generic function
               if (value.kind == typeKinds.Fn && value.generic_ret != null) {
                 let resolvedVal = resolveValue({ expr: value.generic_ret });
                 if ("type" in resolvedVal.expr) {
@@ -3362,12 +3362,11 @@ var zigAnalysis;
         return operatorCompare(a.decl.name, b.decl.name);
       });
 
-
-      var searchTrimmed = false
-      var searchTrimResultsMaxItems = 200
+      let searchTrimmed = false;
+      const searchTrimResultsMaxItems = 200;
       if (searchTrimResults && matchedItems.length > searchTrimResultsMaxItems) {
-          matchedItems = matchedItems.slice(0, searchTrimResultsMaxItems)
-          searchTrimmed = true
+        matchedItems = matchedItems.slice(0, searchTrimResultsMaxItems);
+        searchTrimmed = true;
       }
 
       // Build up the list of search results
-- 
2.54.0


From a0a1178694be3ebbdad87e54a1b5db6ca954d106 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Maciej=20=27vesim=27=20Kuli=C5=84ski?= <vesim809@pm.me>
Date: Mon, 8 Aug 2022 21:42:38 +0200
Subject: [PATCH 051/290] autodoc: links to source code

---
 lib/docs/main.js |  9 +++++++--
 src/Autodoc.zig  | 12 ++++++------
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index f171326b2ea0e2cd3674c26cb4b6b8a9540eb60a..717aeb4d7fe1ffe9424f3b4df355ee93567b72a7 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -51,6 +51,7 @@ var zigAnalysis;
   const domHdrName = document.getElementById("hdrName");
   const domHelpModal = document.getElementById("helpModal");
   const domSearchPlaceholder = document.getElementById("searchPlaceholder");
+  const sourceFileUrlTemplate = "https://github.com/ziglang/zig/blob/master/lib/std/{{file}}#L{{line}}"
 
   let searchTimer = null;
   let searchTrimResults = true;
@@ -2260,6 +2261,11 @@ var zigAnalysis;
       }
     }
   }
+  function renderSourceFileLink(decl) {
+    let srcNode = zigAnalysis.astNodes[decl.src];
+
+    return  "<a style=\"float: right;\" href=\"" + sourceFileUrlTemplate.replace("{{file}}", zigAnalysis.files[srcNode.file]).replace("{{line}}", srcNode.line) + "\">[src]</a>";
+  }
 
   function renderContainer(container) {
     let typesList = [];
@@ -2378,13 +2384,12 @@ var zigAnalysis;
 
         let declType = resolveValue(decl.value);
         console.assert("type" in declType.expr);
-
         tdFnCode.innerHTML = exprName(declType.expr, {
           wantHtml: true,
           wantLink: true,
           fnDecl: decl,
           linkFnNameDecl: navLinkDecl(decl.name),
-        });
+        }) + renderSourceFileLink(decl);
 
         let docs = zigAnalysis.astNodes[decl.src].docs;
         if (docs != null) {
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index c2b0359c645259d8690c7fdf07a1cda1d2520cc3..5e0848b60fb76273403d858f72ddb99aa99133cb 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -2808,8 +2808,8 @@ fn walkDecls(
         const ast_node_index = idx: {
             const idx = self.ast_nodes.items.len;
             try self.ast_nodes.append(self.arena, .{
-                .file = 0,
-                .line = line,
+                .file = self.files.getIndex(file) orelse unreachable,
+                .line = line, // TODO: calculate absolute line
                 .col = 0,
                 .docs = doc_comment,
                 .fields = null, // walkInstruction will fill `fields` if necessary
@@ -3886,13 +3886,13 @@ fn cteTodo(self: *Autodoc, msg: []const u8) error{OutOfMemory}!DocData.WalkResul
 }
 
 fn writeFileTableToJson(map: std.AutoArrayHashMapUnmanaged(*File, usize), jsw: anytype) !void {
-    try jsw.beginObject();
+    try jsw.beginArray();
     var it = map.iterator();
     while (it.next()) |entry| {
-        try jsw.objectField(entry.key_ptr.*.sub_file_path);
-        try jsw.emitNumber(entry.value_ptr.*);
+        try jsw.arrayElem();
+        try jsw.emitString(entry.key_ptr.*.sub_file_path);
     }
-    try jsw.endObject();
+    try jsw.endArray();
 }
 
 fn writePackageTableToJson(
-- 
2.54.0


From 50b36e84fab023ec418eb794d6a5b4510ac6b984 Mon Sep 17 00:00:00 2001
From: "Ryotaro \"Justin\" Kimura" <1560508+ryoppippi@users.noreply.github.com>
Date: Mon, 8 Aug 2022 23:13:35 +0100
Subject: [PATCH 052/290] std: fix BoundedArray test checking wrong condition
 (#12372)

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

diff --git a/lib/std/bounded_array.zig b/lib/std/bounded_array.zig
index 0b0efc55e445c707960105510b0450e66c27e339..8134beb6e32c9011f052e901f71a36346f80a9f6 100644
--- a/lib/std/bounded_array.zig
+++ b/lib/std/bounded_array.zig
@@ -275,7 +275,7 @@ test "BoundedArray" {
     try testing.expectEqualSlices(u8, &x, a.constSlice());
 
     var a2 = a;
-    try testing.expectEqualSlices(u8, a.constSlice(), a.constSlice());
+    try testing.expectEqualSlices(u8, a.constSlice(), a2.constSlice());
     a2.set(0, 0);
     try testing.expect(a.get(0) != a2.get(0));
 
-- 
2.54.0


From d769fd0102dee7ea24f957c3c96e2336d1c18839 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 8 Aug 2022 22:51:08 +0300
Subject: [PATCH 053/290] stage2: pass anon name strategy to reify

---
 src/AstGen.zig                                | 26 ++++++++++++--
 src/Autodoc.zig                               |  2 +-
 src/Sema.zig                                  | 24 +++++++------
 src/Zir.zig                                   |  9 +++--
 src/print_zir.zig                             |  2 +-
 ...or_tagged_union_with_extra_union_field.zig | 35 +++++++++++++++++++
 6 files changed, 78 insertions(+), 20 deletions(-)
 create mode 100644 test/cases/compile_errors/reify_type_for_tagged_union_with_extra_union_field.zig

diff --git a/src/AstGen.zig b/src/AstGen.zig
index 9c8252da55906b12c21a629bb332d3fef2aef6e5..ffe489a216129b6f5e95e495ebe1c353341f56f5 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -2454,7 +2454,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
             .trunc,
             .round,
             .tag_name,
-            .reify,
             .type_name,
             .frame_type,
             .frame_size,
@@ -7553,7 +7552,6 @@ fn builtinCall(
         .trunc                 => return simpleUnOp(gz, scope, rl, node, .none,                               params[0], .trunc),
         .round                 => return simpleUnOp(gz, scope, rl, node, .none,                               params[0], .round),
         .tag_name              => return simpleUnOp(gz, scope, rl, node, .none,                               params[0], .tag_name),
-        .Type                  => return simpleUnOp(gz, scope, rl, node, .{ .coerced_ty = .type_info_type },  params[0], .reify),
         .type_name             => return simpleUnOp(gz, scope, rl, node, .none,                               params[0], .type_name),
         .Frame                 => return simpleUnOp(gz, scope, rl, node, .none,                               params[0], .frame_type),
         .frame_size            => return simpleUnOp(gz, scope, rl, node, .none,                               params[0], .frame_size),
@@ -7568,6 +7566,30 @@ fn builtinCall(
         .truncate     => return typeCast(gz, scope, rl, node, params[0], params[1], .truncate),
         // zig fmt: on
 
+        .Type => {
+            const operand = try expr(gz, scope, .{ .coerced_ty = .type_info_type }, params[0]);
+
+            const gpa = gz.astgen.gpa;
+
+            try gz.instructions.ensureUnusedCapacity(gpa, 1);
+            try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1);
+
+            const payload_index = try gz.astgen.addExtra(Zir.Inst.UnNode{
+                .node = gz.nodeIndexToRelative(node),
+                .operand = operand,
+            });
+            const new_index = @intCast(Zir.Inst.Index, gz.astgen.instructions.len);
+            gz.astgen.instructions.appendAssumeCapacity(.{
+                .tag = .extended,
+                .data = .{ .extended = .{
+                    .opcode = .reify,
+                    .small = @enumToInt(gz.anon_name_strategy),
+                    .operand = payload_index,
+                } },
+            });
+            gz.instructions.appendAssumeCapacity(new_index);
+            return indexToRef(new_index);
+        },
         .panic => {
             try emitDbgNode(gz, node);
             return simpleUnOp(gz, scope, rl, node, .{ .ty = .const_slice_u8_type }, params[0], if (gz.force_comptime) .panic_comptime else .panic);
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index c2b0359c645259d8690c7fdf07a1cda1d2520cc3..9e3874979d03874a61e14d09515ece43cdf135c3 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -1220,7 +1220,6 @@ fn walkInstruction(
         .trunc,
         .round,
         .tag_name,
-        .reify,
         .type_name,
         .frame_type,
         .frame_size,
@@ -2605,6 +2604,7 @@ fn walkInstruction(
                 },
                 .error_to_int,
                 .int_to_error,
+                .reify,
                 => {
                     const extra = file.zir.extraData(Zir.Inst.UnNode, extended.operand).data;
                     const bin_index = self.exprs.items.len;
diff --git a/src/Sema.zig b/src/Sema.zig
index 2f3c931e16e6483d7784549c805f2dfdf96777ea..c91f4cddb1359e4456dba2b406538fc753a423cb 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -816,7 +816,6 @@ fn analyzeBodyInner(
             .embed_file                   => try sema.zirEmbedFile(block, inst),
             .error_name                   => try sema.zirErrorName(block, inst),
             .tag_name                     => try sema.zirTagName(block, inst),
-            .reify                        => try sema.zirReify(block, inst),
             .type_name                    => try sema.zirTypeName(block, inst),
             .frame_type                   => try sema.zirFrameType(block, inst),
             .frame_size                   => try sema.zirFrameSize(block, inst),
@@ -951,6 +950,7 @@ fn analyzeBodyInner(
                     .select                => try sema.zirSelect(            block, extended),
                     .error_to_int          => try sema.zirErrorToInt(        block, extended),
                     .int_to_error          => try sema.zirIntToError(        block, extended),
+                    .reify                 => try sema.zirReify(             block, extended, inst),
                     // zig fmt: on
                     .fence => {
                         try sema.zirFence(block, extended);
@@ -16023,13 +16023,14 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     return block.addUnOp(.tag_name, casted_operand);
 }
 
-fn zirReify(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
-    const inst_data = sema.code.instructions.items(.data)[inst].un_node;
-    const src = inst_data.src();
+    const name_strategy = @intToEnum(Zir.Inst.NameStrategy, extended.small);
+    const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
+    const src = LazySrcLoc.nodeOffset(extra.node);
     const type_info_ty = try sema.resolveBuiltinTypeFields(block, src, "Type");
-    const uncasted_operand = try sema.resolveInst(inst_data.operand);
-    const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
+    const uncasted_operand = try sema.resolveInst(extra.operand);
+    const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = extra.node };
     const type_info = try sema.coerce(block, type_info_ty, uncasted_operand, operand_src);
     const val = try sema.resolveConstValue(block, operand_src, type_info, "operand to @Type must be comptime known");
     const union_val = val.cast(Value.Payload.Union).?.data;
@@ -16289,7 +16290,7 @@ fn zirReify(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
             return if (is_tuple_val.toBool())
                 try sema.reifyTuple(block, src, fields_val)
             else
-                try sema.reifyStruct(block, inst, src, layout_val, fields_val);
+                try sema.reifyStruct(block, inst, src, layout_val, fields_val, name_strategy);
         },
         .Enum => {
             const struct_val = union_val.val.castTag(.aggregate).?.data;
@@ -16338,7 +16339,7 @@ fn zirReify(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
             const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, .{
                 .ty = Type.type,
                 .val = enum_val,
-            }, .anon, "enum", null);
+            }, name_strategy, "enum", inst);
             const new_decl = mod.declPtr(new_decl_index);
             new_decl.owns_tv = true;
             errdefer mod.abortAnonDecl(new_decl_index);
@@ -16435,7 +16436,7 @@ fn zirReify(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
             const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, .{
                 .ty = Type.type,
                 .val = opaque_val,
-            }, .anon, "opaque", null);
+            }, name_strategy, "opaque", inst);
             const new_decl = mod.declPtr(new_decl_index);
             new_decl.owns_tv = true;
             errdefer mod.abortAnonDecl(new_decl_index);
@@ -16494,7 +16495,7 @@ fn zirReify(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
             const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, .{
                 .ty = Type.type,
                 .val = new_union_val,
-            }, .anon, "union", null);
+            }, name_strategy, "union", inst);
             const new_decl = mod.declPtr(new_decl_index);
             new_decl.owns_tv = true;
             errdefer mod.abortAnonDecl(new_decl_index);
@@ -16787,6 +16788,7 @@ fn reifyStruct(
     src: LazySrcLoc,
     layout_val: Value,
     fields_val: Value,
+    name_strategy: Zir.Inst.NameStrategy,
 ) CompileError!Air.Inst.Ref {
     var new_decl_arena = std.heap.ArenaAllocator.init(sema.gpa);
     errdefer new_decl_arena.deinit();
@@ -16799,7 +16801,7 @@ fn reifyStruct(
     const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, .{
         .ty = Type.type,
         .val = new_struct_val,
-    }, .anon, "struct", null);
+    }, name_strategy, "struct", inst);
     const new_decl = mod.declPtr(new_decl_index);
     new_decl.owns_tv = true;
     errdefer mod.abortAnonDecl(new_decl_index);
diff --git a/src/Zir.zig b/src/Zir.zig
index 642742084077837c2701200418e4805291eb1878..c5618a58c0b0d275bb6900b4e4e255b7b156e1a1 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -839,8 +839,6 @@ pub const Inst = struct {
         round,
         /// Implement builtin `@tagName`. Uses `un_node`.
         tag_name,
-        /// Implement builtin `@Type`. Uses `un_node`.
-        reify,
         /// Implement builtin `@typeName`. Uses `un_node`.
         type_name,
         /// Implement builtin `@Frame`. Uses `un_node`.
@@ -1197,7 +1195,6 @@ pub const Inst = struct {
                 .trunc,
                 .round,
                 .tag_name,
-                .reify,
                 .type_name,
                 .frame_type,
                 .frame_size,
@@ -1484,7 +1481,6 @@ pub const Inst = struct {
                 .trunc,
                 .round,
                 .tag_name,
-                .reify,
                 .type_name,
                 .frame_type,
                 .frame_size,
@@ -1759,7 +1755,6 @@ pub const Inst = struct {
                 .trunc = .un_node,
                 .round = .un_node,
                 .tag_name = .un_node,
-                .reify = .un_node,
                 .type_name = .un_node,
                 .frame_type = .un_node,
                 .frame_size = .un_node,
@@ -1980,6 +1975,10 @@ pub const Inst = struct {
         /// Implement builtin `@intToError`.
         /// `operand` is payload index to `UnNode`.
         int_to_error,
+        /// Implement builtin `@Type`.
+        /// `operand` is payload index to `UnNode`.
+        /// `small` contains `NameStrategy
+        reify,
 
         pub const InstData = struct {
             opcode: Extended,
diff --git a/src/print_zir.zig b/src/print_zir.zig
index 6e33154bbd8e6215051d52af043ce3ca32c9a3c6..ca2368fe100165150d656567477fb974c3b0b5a5 100644
--- a/src/print_zir.zig
+++ b/src/print_zir.zig
@@ -214,7 +214,6 @@ const Writer = struct {
             .trunc,
             .round,
             .tag_name,
-            .reify,
             .type_name,
             .frame_type,
             .frame_size,
@@ -500,6 +499,7 @@ const Writer = struct {
             .wasm_memory_size,
             .error_to_int,
             .int_to_error,
+            .reify,
             => {
                 const inst_data = self.code.extraData(Zir.Inst.UnNode, extended.operand).data;
                 const src = LazySrcLoc.nodeOffset(inst_data.node);
diff --git a/test/cases/compile_errors/reify_type_for_tagged_union_with_extra_union_field.zig b/test/cases/compile_errors/reify_type_for_tagged_union_with_extra_union_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9d6170b9d07c9be69eed5608db8f3969b88ee94e
--- /dev/null
+++ b/test/cases/compile_errors/reify_type_for_tagged_union_with_extra_union_field.zig
@@ -0,0 +1,35 @@
+const Tag = @Type(.{
+    .Enum = .{
+        .layout = .Auto,
+        .tag_type = u1,
+        .fields = &.{
+            .{ .name = "signed", .value = 0 },
+            .{ .name = "unsigned", .value = 1 },
+        },
+        .decls = &.{},
+        .is_exhaustive = true,
+    },
+});
+const Tagged = @Type(.{
+    .Union = .{
+        .layout = .Auto,
+        .tag_type = Tag,
+        .fields = &.{
+            .{ .name = "signed", .field_type = i32, .alignment = @alignOf(i32) },
+            .{ .name = "unsigned", .field_type = u32, .alignment = @alignOf(u32) },
+            .{ .name = "arst", .field_type = f32, .alignment = @alignOf(f32) },
+        },
+        .decls = &.{},
+    },
+});
+export fn entry() void {
+    var tagged = Tagged{ .signed = -1 };
+    tagged = .{ .unsigned = 1 };
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :13:16: error: no field named 'arst' in enum 'tmp.Tag'
+// :1:13: note: enum declared here
-- 
2.54.0


From 1a500b969943dc6a4c549fdcbd72659702e867a2 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 8 Aug 2022 19:16:21 -0700
Subject: [PATCH 054/290] Sema: avoid error return traces when possible

stage2 was adding bogus error return trace frames when an error was not
being returned. This commit makes several improvements:

 * Make a runtime check if necessary to only emit a frame into the error
   return trace when an actual error is returned.
 * Use the `analyzeIsNonErrComptimeOnly` machinery to avoid runtime
   checks when it is compile-time-known that the value is an error, or a
   non-error.
 * Make std.builtin.returnError take a non-optional stack trace pointer.

closes #12174
---
 lib/std/builtin.zig |  3 +-
 src/Sema.zig        | 79 ++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 69 insertions(+), 13 deletions(-)

diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index 047c65439c14c793d0b80de636c924e93e25f483..ef716c6972c4a755a0e077107d76191ff09d2850 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -867,10 +867,9 @@ pub fn panicOutOfBounds(index: usize, len: usize) noreturn {
     std.debug.panic("attempt to index out of bound: index {d}, len {d}", .{ index, len });
 }
 
-pub noinline fn returnError(maybe_st: ?*StackTrace) void {
+pub noinline fn returnError(st: *StackTrace) void {
     @setCold(true);
     @setRuntimeSafety(false);
-    const st = maybe_st orelse return;
     addErrRetTraceAddr(st, @returnAddress());
 }
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 2f3c931e16e6483d7784549c805f2dfdf96777ea..a540a75d607f6c20482494532186b99e5ec0dd5a 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -14492,6 +14492,20 @@ fn zirBoolBr(
     const rhs_result = try sema.resolveBody(rhs_block, body, inst);
     _ = try rhs_block.addBr(block_inst, rhs_result);
 
+    return finishCondBr(sema, parent_block, &child_block, &then_block, &else_block, lhs, block_inst);
+}
+
+fn finishCondBr(
+    sema: *Sema,
+    parent_block: *Block,
+    child_block: *Block,
+    then_block: *Block,
+    else_block: *Block,
+    cond: Air.Inst.Ref,
+    block_inst: Air.Inst.Index,
+) !Air.Inst.Ref {
+    const gpa = sema.gpa;
+
     try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.CondBr).Struct.fields.len +
         then_block.instructions.items.len + else_block.instructions.items.len +
         @typeInfo(Air.Block).Struct.fields.len + child_block.instructions.items.len + 1);
@@ -14504,7 +14518,7 @@ fn zirBoolBr(
     sema.air_extra.appendSliceAssumeCapacity(else_block.instructions.items);
 
     _ = try child_block.addInst(.{ .tag = .cond_br, .data = .{ .pl_op = .{
-        .operand = lhs,
+        .operand = cond,
         .payload = cond_br_payload,
     } } });
 
@@ -14901,6 +14915,8 @@ fn analyzeRet(
     uncasted_operand: Air.Inst.Ref,
     src: LazySrcLoc,
 ) CompileError!Zir.Inst.Index {
+    const gpa = sema.gpa;
+
     // Special case for returning an error to an inferred error set; we need to
     // add the error tag to the inferred error set of the in-scope function, so
     // that the coercion below works correctly.
@@ -14918,11 +14934,13 @@ fn analyzeRet(
             return error.ComptimeReturn;
         }
         // We are inlining a function call; rewrite the `ret` as a `break`.
-        try inlining.merges.results.append(sema.gpa, operand);
+        try inlining.merges.results.append(gpa, operand);
         _ = try block.addBr(inlining.merges.block_inst, operand);
         return always_noreturn;
     }
 
+    try sema.resolveTypeLayout(block, src, sema.fn_ret_ty);
+
     // TODO implement this feature in all the backends and then delete this check.
     const backend_supports_error_return_tracing =
         sema.mod.comp.bin_file.options.use_llvm;
@@ -14931,19 +14949,52 @@ fn analyzeRet(
         sema.mod.comp.bin_file.options.error_return_tracing and
         backend_supports_error_return_tracing)
     ret_err: {
-        if (try sema.resolveMaybeUndefVal(block, src, operand)) |ret_val| {
-            if (ret_val.tag() != .@"error") break :ret_err;
-        }
-        const return_err_fn = try sema.getBuiltin(block, src, "returnError");
+        // Avoid adding a frame to the error return trace in case the value is comptime-known
+        // to be not an error.
+        const is_non_err = try sema.analyzeIsNonErrComptimeOnly(block, src, operand);
+        const need_check = switch (is_non_err) {
+            .bool_true => break :ret_err,
+            .bool_false => false,
+            else => true,
+        };
+
         const unresolved_stack_trace_ty = try sema.getBuiltinType(block, src, "StackTrace");
         const stack_trace_ty = try sema.resolveTypeFields(block, src, unresolved_stack_trace_ty);
-        const ptr_stack_trace_ty = try Type.Tag.optional_single_mut_pointer.create(sema.arena, stack_trace_ty);
+        const ptr_stack_trace_ty = try Type.Tag.single_mut_pointer.create(sema.arena, stack_trace_ty);
         const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty);
+        const return_err_fn = try sema.getBuiltin(block, src, "returnError");
         const args: [1]Air.Inst.Ref = .{err_return_trace};
+
+        if (!need_check) {
+            _ = try sema.analyzeCall(block, return_err_fn, src, src, .never_inline, false, &args, null);
+            break :ret_err;
+        }
+
+        const block_inst = @intCast(Air.Inst.Index, sema.air_instructions.len);
+        try sema.air_instructions.append(gpa, .{
+            .tag = .block,
+            .data = .{ .ty_pl = .{
+                .ty = .void_type,
+                .payload = undefined,
+            } },
+        });
+
+        var child_block = block.makeSubBlock();
+        defer child_block.instructions.deinit(gpa);
+
+        var then_block = child_block.makeSubBlock();
+        defer then_block.instructions.deinit(gpa);
+        _ = try then_block.addUnOp(.ret, operand);
+
+        var else_block = child_block.makeSubBlock();
+        defer else_block.instructions.deinit(gpa);
         _ = try sema.analyzeCall(block, return_err_fn, src, src, .never_inline, false, &args, null);
+        _ = try else_block.addUnOp(.ret, operand);
+
+        _ = try finishCondBr(sema, block, &child_block, &then_block, &else_block, is_non_err, block_inst);
+        return always_noreturn;
     }
 
-    try sema.resolveTypeLayout(block, src, sema.fn_ret_ty);
     _ = try block.addUnOp(.ret, operand);
     return always_noreturn;
 }
@@ -25436,10 +25487,16 @@ fn analyzeIsNonErrComptimeOnly(
     assert(ot == .ErrorUnion);
 
     if (Air.refToIndex(operand)) |operand_inst| {
-        const air_tags = sema.air_instructions.items(.tag);
-        if (air_tags[operand_inst] == .wrap_errunion_payload) {
-            return Air.Inst.Ref.bool_true;
+        switch (sema.air_instructions.items(.tag)[operand_inst]) {
+            .wrap_errunion_payload => return Air.Inst.Ref.bool_true,
+            .wrap_errunion_err => return Air.Inst.Ref.bool_false,
+            else => {},
         }
+    } else if (operand == .undef) {
+        return sema.addConstUndef(Type.bool);
+    } else {
+        // None of the ref tags can be errors.
+        return Air.Inst.Ref.bool_true;
     }
 
     const maybe_operand_val = try sema.resolveMaybeUndefVal(block, src, operand);
-- 
2.54.0


From 3389890709b8470c59cadc21471e4a6c8dda48a6 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 8 Aug 2022 20:19:08 -0700
Subject: [PATCH 055/290] stage2: error return tracing handles ret better

Sema: insert an error return trace frame when appropriate when analyzing
ret_load. Also optimize the instructions to avoid an unnecessary block
sent to the backends.

AstGen: always emit a dbg_stmt for return expressions, in between the
defer instructions and the return instruction.

This improves the following test case:

```zig
pub fn main() !void {
    return foo();
}

fn foo() !void {
    return error.Bad;
}
```

The error return trace now points to the return token instead of
pointing to the foo() function call, matching stage1.
---
 src/AstGen.zig |  28 +++++++++
 src/Sema.zig   | 166 +++++++++++++++++++++++++++++++++----------------
 2 files changed, 141 insertions(+), 53 deletions(-)

diff --git a/src/AstGen.zig b/src/AstGen.zig
index 9c8252da55906b12c21a629bb332d3fef2aef6e5..e53c59817ad5cf5374d74ce8f1a6c71a651f3eb0 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -6573,6 +6573,16 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
 
     if (gz.in_defer) return astgen.failNode(node, "cannot return from defer expression", .{});
 
+    // Ensure debug line/column information is emitted for this return expression.
+    // Then we will save the line/column so that we can emit another one that goes
+    // "backwards" because we want to evaluate the operand, but then put the debug
+    // info back at the return keyword for error return tracing.
+    if (!gz.force_comptime) {
+        try emitDbgNode(gz, node);
+    }
+    const ret_line = astgen.source_line - gz.decl_line;
+    const ret_column = astgen.source_column;
+
     const defer_outer = &astgen.fn_block.?.base;
 
     const operand_node = node_datas[node].lhs;
@@ -6591,11 +6601,13 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
         const defer_counts = countDefers(astgen, defer_outer, scope);
         if (!defer_counts.need_err_code) {
             try genDefers(gz, defer_outer, scope, .both_sans_err);
+            try emitRetDbgStmt(gz, ret_line, ret_column);
             _ = try gz.addStrTok(.ret_err_value, err_name_str_index, ident_token);
             return Zir.Inst.Ref.unreachable_value;
         }
         const err_code = try gz.addStrTok(.ret_err_value_code, err_name_str_index, ident_token);
         try genDefers(gz, defer_outer, scope, .{ .both = err_code });
+        try emitRetDbgStmt(gz, ret_line, ret_column);
         _ = try gz.addUnNode(.ret_node, err_code, node);
         return Zir.Inst.Ref.unreachable_value;
     }
@@ -6614,6 +6626,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
         .never => {
             // Returning a value that cannot be an error; skip error defers.
             try genDefers(gz, defer_outer, scope, .normal_only);
+            try emitRetDbgStmt(gz, ret_line, ret_column);
             try gz.addRet(rl, operand, node);
             return Zir.Inst.Ref.unreachable_value;
         },
@@ -6621,6 +6634,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
             // Value is always an error. Emit both error defers and regular defers.
             const err_code = if (rl == .ptr) try gz.addUnNode(.load, rl.ptr, node) else operand;
             try genDefers(gz, defer_outer, scope, .{ .both = err_code });
+            try emitRetDbgStmt(gz, ret_line, ret_column);
             try gz.addRet(rl, operand, node);
             return Zir.Inst.Ref.unreachable_value;
         },
@@ -6629,6 +6643,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
             if (!defer_counts.have_err) {
                 // Only regular defers; no branch needed.
                 try genDefers(gz, defer_outer, scope, .normal_only);
+                try emitRetDbgStmt(gz, ret_line, ret_column);
                 try gz.addRet(rl, operand, node);
                 return Zir.Inst.Ref.unreachable_value;
             }
@@ -6642,6 +6657,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
             defer then_scope.unstack();
 
             try genDefers(&then_scope, defer_outer, scope, .normal_only);
+            try emitRetDbgStmt(gz, ret_line, ret_column);
             try then_scope.addRet(rl, operand, node);
 
             var else_scope = gz.makeSubBlock(scope);
@@ -6651,6 +6667,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
                 .both = try else_scope.addUnNode(.err_union_code, result, node),
             };
             try genDefers(&else_scope, defer_outer, scope, which_ones);
+            try emitRetDbgStmt(gz, ret_line, ret_column);
             try else_scope.addRet(rl, operand, node);
 
             try setCondBrPayload(condbr, is_non_err, &then_scope, 0, &else_scope, 0);
@@ -11667,3 +11684,14 @@ fn countBodyLenAfterFixups(astgen: *AstGen, body: []const Zir.Inst.Index) u32 {
     }
     return @intCast(u32, count);
 }
+
+fn emitRetDbgStmt(gz: *GenZir, line: u32, column: u32) !void {
+    if (gz.force_comptime) return;
+
+    _ = try gz.add(.{ .tag = .dbg_stmt, .data = .{
+        .dbg_stmt = .{
+            .line = line,
+            .column = column,
+        },
+    } });
+}
diff --git a/src/Sema.zig b/src/Sema.zig
index a540a75d607f6c20482494532186b99e5ec0dd5a..13570a509a42555fde757adc8c5d087d28a3abfc 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -14888,10 +14888,83 @@ fn zirRetLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Zir
         const operand = try sema.analyzeLoad(block, src, ret_ptr, src);
         return sema.analyzeRet(block, operand, src);
     }
+
+    if (sema.wantErrorReturnTracing()) {
+        const is_non_err = try sema.analyzePtrIsNonErr(block, src, ret_ptr);
+        return retWithErrTracing(sema, block, src, is_non_err, .ret_load, ret_ptr);
+    }
+
     _ = try block.addUnOp(.ret_load, ret_ptr);
     return always_noreturn;
 }
 
+fn retWithErrTracing(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    is_non_err: Air.Inst.Ref,
+    ret_tag: Air.Inst.Tag,
+    operand: Air.Inst.Ref,
+) CompileError!Zir.Inst.Index {
+    const need_check = switch (is_non_err) {
+        .bool_true => {
+            _ = try block.addUnOp(ret_tag, operand);
+            return always_noreturn;
+        },
+        .bool_false => false,
+        else => true,
+    };
+    const gpa = sema.gpa;
+    const unresolved_stack_trace_ty = try sema.getBuiltinType(block, src, "StackTrace");
+    const stack_trace_ty = try sema.resolveTypeFields(block, src, unresolved_stack_trace_ty);
+    const ptr_stack_trace_ty = try Type.Tag.single_mut_pointer.create(sema.arena, stack_trace_ty);
+    const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty);
+    const return_err_fn = try sema.getBuiltin(block, src, "returnError");
+    const args: [1]Air.Inst.Ref = .{err_return_trace};
+
+    if (!need_check) {
+        _ = try sema.analyzeCall(block, return_err_fn, src, src, .never_inline, false, &args, null);
+        _ = try block.addUnOp(ret_tag, operand);
+        return always_noreturn;
+    }
+
+    var then_block = block.makeSubBlock();
+    defer then_block.instructions.deinit(gpa);
+    _ = try then_block.addUnOp(ret_tag, operand);
+
+    var else_block = block.makeSubBlock();
+    defer else_block.instructions.deinit(gpa);
+    _ = try sema.analyzeCall(&else_block, return_err_fn, src, src, .never_inline, false, &args, null);
+    _ = try else_block.addUnOp(ret_tag, operand);
+
+    try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.CondBr).Struct.fields.len +
+        then_block.instructions.items.len + else_block.instructions.items.len +
+        @typeInfo(Air.Block).Struct.fields.len + 1);
+
+    const cond_br_payload = sema.addExtraAssumeCapacity(Air.CondBr{
+        .then_body_len = @intCast(u32, then_block.instructions.items.len),
+        .else_body_len = @intCast(u32, else_block.instructions.items.len),
+    });
+    sema.air_extra.appendSliceAssumeCapacity(then_block.instructions.items);
+    sema.air_extra.appendSliceAssumeCapacity(else_block.instructions.items);
+
+    _ = try block.addInst(.{ .tag = .cond_br, .data = .{ .pl_op = .{
+        .operand = is_non_err,
+        .payload = cond_br_payload,
+    } } });
+
+    return always_noreturn;
+}
+
+fn wantErrorReturnTracing(sema: *Sema) bool {
+    // TODO implement this feature in all the backends and then delete this check.
+    const backend_supports_error_return_tracing = sema.mod.comp.bin_file.options.use_llvm;
+
+    return sema.fn_ret_ty.isError() and
+        sema.mod.comp.bin_file.options.error_return_tracing and
+        backend_supports_error_return_tracing;
+}
+
 fn addToInferredErrorSet(sema: *Sema, uncasted_operand: Air.Inst.Ref) !void {
     assert(sema.fn_ret_ty.zigTypeTag() == .ErrorUnion);
 
@@ -14915,8 +14988,6 @@ fn analyzeRet(
     uncasted_operand: Air.Inst.Ref,
     src: LazySrcLoc,
 ) CompileError!Zir.Inst.Index {
-    const gpa = sema.gpa;
-
     // Special case for returning an error to an inferred error set; we need to
     // add the error tag to the inferred error set of the in-scope function, so
     // that the coercion below works correctly.
@@ -14934,65 +15005,18 @@ fn analyzeRet(
             return error.ComptimeReturn;
         }
         // We are inlining a function call; rewrite the `ret` as a `break`.
-        try inlining.merges.results.append(gpa, operand);
+        try inlining.merges.results.append(sema.gpa, operand);
         _ = try block.addBr(inlining.merges.block_inst, operand);
         return always_noreturn;
     }
 
     try sema.resolveTypeLayout(block, src, sema.fn_ret_ty);
 
-    // TODO implement this feature in all the backends and then delete this check.
-    const backend_supports_error_return_tracing =
-        sema.mod.comp.bin_file.options.use_llvm;
-
-    if (sema.fn_ret_ty.isError() and
-        sema.mod.comp.bin_file.options.error_return_tracing and
-        backend_supports_error_return_tracing)
-    ret_err: {
+    if (sema.wantErrorReturnTracing()) {
         // Avoid adding a frame to the error return trace in case the value is comptime-known
         // to be not an error.
-        const is_non_err = try sema.analyzeIsNonErrComptimeOnly(block, src, operand);
-        const need_check = switch (is_non_err) {
-            .bool_true => break :ret_err,
-            .bool_false => false,
-            else => true,
-        };
-
-        const unresolved_stack_trace_ty = try sema.getBuiltinType(block, src, "StackTrace");
-        const stack_trace_ty = try sema.resolveTypeFields(block, src, unresolved_stack_trace_ty);
-        const ptr_stack_trace_ty = try Type.Tag.single_mut_pointer.create(sema.arena, stack_trace_ty);
-        const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty);
-        const return_err_fn = try sema.getBuiltin(block, src, "returnError");
-        const args: [1]Air.Inst.Ref = .{err_return_trace};
-
-        if (!need_check) {
-            _ = try sema.analyzeCall(block, return_err_fn, src, src, .never_inline, false, &args, null);
-            break :ret_err;
-        }
-
-        const block_inst = @intCast(Air.Inst.Index, sema.air_instructions.len);
-        try sema.air_instructions.append(gpa, .{
-            .tag = .block,
-            .data = .{ .ty_pl = .{
-                .ty = .void_type,
-                .payload = undefined,
-            } },
-        });
-
-        var child_block = block.makeSubBlock();
-        defer child_block.instructions.deinit(gpa);
-
-        var then_block = child_block.makeSubBlock();
-        defer then_block.instructions.deinit(gpa);
-        _ = try then_block.addUnOp(.ret, operand);
-
-        var else_block = child_block.makeSubBlock();
-        defer else_block.instructions.deinit(gpa);
-        _ = try sema.analyzeCall(block, return_err_fn, src, src, .never_inline, false, &args, null);
-        _ = try else_block.addUnOp(.ret, operand);
-
-        _ = try finishCondBr(sema, block, &child_block, &then_block, &else_block, is_non_err, block_inst);
-        return always_noreturn;
+        const is_non_err = try sema.analyzeIsNonErr(block, src, operand);
+        return retWithErrTracing(sema, block, src, is_non_err, .ret, operand);
     }
 
     _ = try block.addUnOp(.ret, operand);
@@ -25474,6 +25498,27 @@ fn analyzeIsNull(
     return block.addUnOp(air_tag, operand);
 }
 
+fn analyzePtrIsNonErrComptimeOnly(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    operand: Air.Inst.Ref,
+) CompileError!Air.Inst.Ref {
+    const ptr_ty = sema.typeOf(operand);
+    assert(ptr_ty.zigTypeTag() == .Pointer);
+    const child_ty = ptr_ty.childType();
+
+    const child_tag = child_ty.zigTypeTag();
+    if (child_tag != .ErrorSet and child_tag != .ErrorUnion) return Air.Inst.Ref.bool_true;
+    if (child_tag == .ErrorSet) return Air.Inst.Ref.bool_false;
+    assert(child_tag == .ErrorUnion);
+
+    _ = block;
+    _ = src;
+
+    return Air.Inst.Ref.none;
+}
+
 fn analyzeIsNonErrComptimeOnly(
     sema: *Sema,
     block: *Block,
@@ -25572,6 +25617,21 @@ fn analyzeIsNonErr(
     }
 }
 
+fn analyzePtrIsNonErr(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    operand: Air.Inst.Ref,
+) CompileError!Air.Inst.Ref {
+    const result = try sema.analyzePtrIsNonErrComptimeOnly(block, src, operand);
+    if (result == .none) {
+        try sema.requireRuntimeBlock(block, src, null);
+        return block.addUnOp(.is_non_err_ptr, operand);
+    } else {
+        return result;
+    }
+}
+
 fn analyzeSlice(
     sema: *Sema,
     block: *Block,
-- 
2.54.0


From 0648177ed7a1ad5364c478b63ec28a6de15e4ad9 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 8 Aug 2022 20:29:22 -0700
Subject: [PATCH 056/290] AstGen: avoid multiple dbg_stmt instructions in a row

This is purely an optimization to emit fewer ZIR instructions.
---
 src/AstGen.zig | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/AstGen.zig b/src/AstGen.zig
index e53c59817ad5cf5374d74ce8f1a6c71a651f3eb0..5087ea629330f42c4bf471afa3437e4954f96dec 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -3071,6 +3071,19 @@ fn emitDbgNode(gz: *GenZir, node: Ast.Node.Index) !void {
     const line = astgen.source_line - gz.decl_line;
     const column = astgen.source_column;
 
+    if (gz.instructions.items.len > 0) {
+        const last = gz.instructions.items[gz.instructions.items.len - 1];
+        const zir_tags = astgen.instructions.items(.tag);
+        if (zir_tags[last] == .dbg_stmt) {
+            const zir_datas = astgen.instructions.items(.data);
+            zir_datas[last].dbg_stmt = .{
+                .line = line,
+                .column = column,
+            };
+            return;
+        }
+    }
+
     _ = try gz.add(.{ .tag = .dbg_stmt, .data = .{
         .dbg_stmt = .{
             .line = line,
-- 
2.54.0


From feb90f6ed4f64eb0faef8fbbcf8c51fad5392b39 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 8 Aug 2022 20:53:06 -0700
Subject: [PATCH 057/290] AstGen: emit debug stmt for try

This improves the following test case:

```zig
pub fn main() !void {
    try foo();
}

fn foo() !void {
    return error.Bad;
}
```

The error return trace now points to the `try` token instead of pointing
to the foo() function call, matching stage1.

Closes #12308.
---
 src/AstGen.zig        | 27 +++++++++++++++++++--------
 test/stack_traces.zig |  1 +
 2 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/src/AstGen.zig b/src/AstGen.zig
index 5087ea629330f42c4bf471afa3437e4954f96dec..4e08b397772840f9b455e940bbe59c7ff917656d 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -5051,6 +5051,16 @@ fn tryExpr(
 
     if (parent_gz.in_defer) return astgen.failNode(node, "'try' not allowed inside defer expression", .{});
 
+    // Ensure debug line/column information is emitted for this try expression.
+    // Then we will save the line/column so that we can emit another one that goes
+    // "backwards" because we want to evaluate the operand, but then put the debug
+    // info back at the try keyword for error return tracing.
+    if (!parent_gz.force_comptime) {
+        try emitDbgNode(parent_gz, node);
+    }
+    const try_line = astgen.source_line - parent_gz.decl_line;
+    const try_column = astgen.source_column;
+
     const operand_rl: ResultLoc = switch (rl) {
         .ref => .ref,
         else => .none,
@@ -5080,6 +5090,7 @@ fn tryExpr(
     };
     const err_code = try else_scope.addUnNode(err_tag, operand, node);
     try genDefers(&else_scope, &fn_block.base, scope, .{ .both = err_code });
+    try emitDbgStmt(&else_scope, try_line, try_column);
     _ = try else_scope.addUnNode(.ret_node, err_code, node);
 
     try else_scope.setTryBody(try_inst, operand);
@@ -6614,13 +6625,13 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
         const defer_counts = countDefers(astgen, defer_outer, scope);
         if (!defer_counts.need_err_code) {
             try genDefers(gz, defer_outer, scope, .both_sans_err);
-            try emitRetDbgStmt(gz, ret_line, ret_column);
+            try emitDbgStmt(gz, ret_line, ret_column);
             _ = try gz.addStrTok(.ret_err_value, err_name_str_index, ident_token);
             return Zir.Inst.Ref.unreachable_value;
         }
         const err_code = try gz.addStrTok(.ret_err_value_code, err_name_str_index, ident_token);
         try genDefers(gz, defer_outer, scope, .{ .both = err_code });
-        try emitRetDbgStmt(gz, ret_line, ret_column);
+        try emitDbgStmt(gz, ret_line, ret_column);
         _ = try gz.addUnNode(.ret_node, err_code, node);
         return Zir.Inst.Ref.unreachable_value;
     }
@@ -6639,7 +6650,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
         .never => {
             // Returning a value that cannot be an error; skip error defers.
             try genDefers(gz, defer_outer, scope, .normal_only);
-            try emitRetDbgStmt(gz, ret_line, ret_column);
+            try emitDbgStmt(gz, ret_line, ret_column);
             try gz.addRet(rl, operand, node);
             return Zir.Inst.Ref.unreachable_value;
         },
@@ -6647,7 +6658,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
             // Value is always an error. Emit both error defers and regular defers.
             const err_code = if (rl == .ptr) try gz.addUnNode(.load, rl.ptr, node) else operand;
             try genDefers(gz, defer_outer, scope, .{ .both = err_code });
-            try emitRetDbgStmt(gz, ret_line, ret_column);
+            try emitDbgStmt(gz, ret_line, ret_column);
             try gz.addRet(rl, operand, node);
             return Zir.Inst.Ref.unreachable_value;
         },
@@ -6656,7 +6667,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
             if (!defer_counts.have_err) {
                 // Only regular defers; no branch needed.
                 try genDefers(gz, defer_outer, scope, .normal_only);
-                try emitRetDbgStmt(gz, ret_line, ret_column);
+                try emitDbgStmt(gz, ret_line, ret_column);
                 try gz.addRet(rl, operand, node);
                 return Zir.Inst.Ref.unreachable_value;
             }
@@ -6670,7 +6681,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
             defer then_scope.unstack();
 
             try genDefers(&then_scope, defer_outer, scope, .normal_only);
-            try emitRetDbgStmt(gz, ret_line, ret_column);
+            try emitDbgStmt(&then_scope, ret_line, ret_column);
             try then_scope.addRet(rl, operand, node);
 
             var else_scope = gz.makeSubBlock(scope);
@@ -6680,7 +6691,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
                 .both = try else_scope.addUnNode(.err_union_code, result, node),
             };
             try genDefers(&else_scope, defer_outer, scope, which_ones);
-            try emitRetDbgStmt(gz, ret_line, ret_column);
+            try emitDbgStmt(&else_scope, ret_line, ret_column);
             try else_scope.addRet(rl, operand, node);
 
             try setCondBrPayload(condbr, is_non_err, &then_scope, 0, &else_scope, 0);
@@ -11698,7 +11709,7 @@ fn countBodyLenAfterFixups(astgen: *AstGen, body: []const Zir.Inst.Index) u32 {
     return @intCast(u32, count);
 }
 
-fn emitRetDbgStmt(gz: *GenZir, line: u32, column: u32) !void {
+fn emitDbgStmt(gz: *GenZir, line: u32, column: u32) !void {
     if (gz.force_comptime) return;
 
     _ = try gz.add(.{ .tag = .dbg_stmt, .data = .{
diff --git a/test/stack_traces.zig b/test/stack_traces.zig
index c40413f936c6f0f95012476f7425ad76ee3d6f0a..ea27b5beff7e94a170f6be4edbd065a7013e26b9 100644
--- a/test/stack_traces.zig
+++ b/test/stack_traces.zig
@@ -22,6 +22,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
         .ReleaseSafe = .{
             .exclude_os = .{
                 .windows, // segfault
+                .linux, // defeated by aggressive inlining
             },
             .expect = 
             \\error: TheSkyIsFalling
-- 
2.54.0


From c76b5c1a31ebe09726cd29e7a6da69613eabfd10 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 3 Aug 2022 19:55:27 +0300
Subject: [PATCH 058/290] stage2: correct node offset of nested declarations

---
 src/AstGen.zig                                | 21 ++++--
 src/Module.zig                                | 33 +++------
 src/Sema.zig                                  | 69 ++++++++-----------
 src/print_zir.zig                             | 16 +++++
 src/type.zig                                  | 44 ------------
 .../non_constant_expression_in_array_size.zig |  2 +-
 .../cases/compile_errors/not_an_enum_type.zig |  2 +-
 ...n_invalid_value_of_non-exhaustive_enum.zig |  2 +-
 test/cases/error_in_nested_declaration.zig    | 31 +++++++++
 9 files changed, 106 insertions(+), 114 deletions(-)
 create mode 100644 test/cases/error_in_nested_declaration.zig

diff --git a/src/AstGen.zig b/src/AstGen.zig
index ffe489a216129b6f5e95e495ebe1c353341f56f5..3a30ab7b9d3ec64eb857fc6836881c19f4822c70 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -4278,7 +4278,7 @@ fn structDeclInner(
     var known_non_opv = false;
     var known_comptime_only = false;
     for (container_decl.ast.members) |member_node| {
-        const member = switch (try containerMember(gz, &namespace.base, &wip_members, member_node)) {
+        const member = switch (try containerMember(&block_scope, &namespace.base, &wip_members, member_node)) {
             .decl => continue,
             .field => |field| field,
         };
@@ -4445,7 +4445,7 @@ fn unionDeclInner(
     defer wip_members.deinit();
 
     for (members) |member_node| {
-        const member = switch (try containerMember(gz, &namespace.base, &wip_members, member_node)) {
+        const member = switch (try containerMember(&block_scope, &namespace.base, &wip_members, member_node)) {
             .decl => continue,
             .field => |field| field,
         };
@@ -4732,7 +4732,7 @@ fn containerDecl(
             for (container_decl.ast.members) |member_node| {
                 if (member_node == counts.nonexhaustive_node)
                     continue;
-                const member = switch (try containerMember(gz, &namespace.base, &wip_members, member_node)) {
+                const member = switch (try containerMember(&block_scope, &namespace.base, &wip_members, member_node)) {
                     .decl => continue,
                     .field => |field| field,
                 };
@@ -4810,13 +4810,26 @@ fn containerDecl(
             };
             defer namespace.deinit(gpa);
 
+            astgen.advanceSourceCursorToNode(node);
+            var block_scope: GenZir = .{
+                .parent = &namespace.base,
+                .decl_node_index = node,
+                .decl_line = astgen.source_line,
+                .astgen = astgen,
+                .force_comptime = true,
+                .in_defer = false,
+                .instructions = gz.instructions,
+                .instructions_top = gz.instructions.items.len,
+            };
+            defer block_scope.unstack();
+
             const decl_count = try astgen.scanDecls(&namespace, container_decl.ast.members);
 
             var wip_members = try WipMembers.init(gpa, &astgen.scratch, decl_count, 0, 0, 0);
             defer wip_members.deinit();
 
             for (container_decl.ast.members) |member_node| {
-                const res = try containerMember(gz, &namespace.base, &wip_members, member_node);
+                const res = try containerMember(&block_scope, &namespace.base, &wip_members, member_node);
                 if (res == .field) {
                     return astgen.failNode(member_node, "opaque types cannot have fields", .{});
                 }
diff --git a/src/Module.zig b/src/Module.zig
index ab394af0ad3db8cbd30abfcd730121d3a16d64f9..8b195eff2de02674457ea2d786f0fdc9fc0da264 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -853,8 +853,6 @@ pub const EmitH = struct {
 pub const ErrorSet = struct {
     /// The Decl that corresponds to the error set itself.
     owner_decl: Decl.Index,
-    /// Offset from Decl node index, points to the error set AST node.
-    node_offset: i32,
     /// The string bytes are stored in the owner Decl arena.
     /// These must be in sorted order. See sortNames.
     names: NameMap,
@@ -866,7 +864,7 @@ pub const ErrorSet = struct {
         return .{
             .file_scope = owner_decl.getFileScope(),
             .parent_decl_node = owner_decl.src_node,
-            .lazy = LazySrcLoc.nodeOffset(self.node_offset),
+            .lazy = LazySrcLoc.nodeOffset(0),
         };
     }
 
@@ -893,8 +891,6 @@ pub const Struct = struct {
     namespace: Namespace,
     /// The Decl that corresponds to the struct itself.
     owner_decl: Decl.Index,
-    /// Offset from `owner_decl`, points to the struct AST node.
-    node_offset: i32,
     /// Index of the struct_decl ZIR instruction.
     zir_index: Zir.Inst.Index,
 
@@ -953,7 +949,7 @@ pub const Struct = struct {
         return .{
             .file_scope = owner_decl.getFileScope(),
             .parent_decl_node = owner_decl.src_node,
-            .lazy = LazySrcLoc.nodeOffset(s.node_offset),
+            .lazy = LazySrcLoc.nodeOffset(0),
         };
     }
 
@@ -968,7 +964,7 @@ pub const Struct = struct {
             });
             return s.srcLoc(mod);
         };
-        const node = owner_decl.relativeToNodeIndex(s.node_offset);
+        const node = owner_decl.relativeToNodeIndex(0);
         const node_tags = tree.nodes.items(.tag);
         switch (node_tags[node]) {
             .container_decl,
@@ -1060,8 +1056,6 @@ pub const Struct = struct {
 pub const EnumSimple = struct {
     /// The Decl that corresponds to the enum itself.
     owner_decl: Decl.Index,
-    /// Offset from `owner_decl`, points to the enum decl AST node.
-    node_offset: i32,
     /// Set of field names in declaration order.
     fields: NameMap,
 
@@ -1072,7 +1066,7 @@ pub const EnumSimple = struct {
         return .{
             .file_scope = owner_decl.getFileScope(),
             .parent_decl_node = owner_decl.src_node,
-            .lazy = LazySrcLoc.nodeOffset(self.node_offset),
+            .lazy = LazySrcLoc.nodeOffset(0),
         };
     }
 };
@@ -1083,8 +1077,6 @@ pub const EnumSimple = struct {
 pub const EnumNumbered = struct {
     /// The Decl that corresponds to the enum itself.
     owner_decl: Decl.Index,
-    /// Offset from `owner_decl`, points to the enum decl AST node.
-    node_offset: i32,
     /// An integer type which is used for the numerical value of the enum.
     /// Whether zig chooses this type or the user specifies it, it is stored here.
     tag_ty: Type,
@@ -1103,7 +1095,7 @@ pub const EnumNumbered = struct {
         return .{
             .file_scope = owner_decl.getFileScope(),
             .parent_decl_node = owner_decl.src_node,
-            .lazy = LazySrcLoc.nodeOffset(self.node_offset),
+            .lazy = LazySrcLoc.nodeOffset(0),
         };
     }
 };
@@ -1113,8 +1105,6 @@ pub const EnumNumbered = struct {
 pub const EnumFull = struct {
     /// The Decl that corresponds to the enum itself.
     owner_decl: Decl.Index,
-    /// Offset from `owner_decl`, points to the enum decl AST node.
-    node_offset: i32,
     /// An integer type which is used for the numerical value of the enum.
     /// Whether zig chooses this type or the user specifies it, it is stored here.
     tag_ty: Type,
@@ -1137,7 +1127,7 @@ pub const EnumFull = struct {
         return .{
             .file_scope = owner_decl.getFileScope(),
             .parent_decl_node = owner_decl.src_node,
-            .lazy = LazySrcLoc.nodeOffset(self.node_offset),
+            .lazy = LazySrcLoc.nodeOffset(0),
         };
     }
 };
@@ -1155,8 +1145,6 @@ pub const Union = struct {
     namespace: Namespace,
     /// The Decl that corresponds to the union itself.
     owner_decl: Decl.Index,
-    /// Offset from `owner_decl`, points to the union decl AST node.
-    node_offset: i32,
     /// Index of the union_decl ZIR instruction.
     zir_index: Zir.Inst.Index,
 
@@ -1203,7 +1191,7 @@ pub const Union = struct {
         return .{
             .file_scope = owner_decl.getFileScope(),
             .parent_decl_node = owner_decl.src_node,
-            .lazy = LazySrcLoc.nodeOffset(self.node_offset),
+            .lazy = LazySrcLoc.nodeOffset(0),
         };
     }
 
@@ -1218,7 +1206,7 @@ pub const Union = struct {
             });
             return u.srcLoc(mod);
         };
-        const node = owner_decl.relativeToNodeIndex(u.node_offset);
+        const node = owner_decl.relativeToNodeIndex(0);
         const node_tags = tree.nodes.items(.tag);
         var buf: [2]Ast.Node.Index = undefined;
         switch (node_tags[node]) {
@@ -1410,8 +1398,6 @@ pub const Union = struct {
 pub const Opaque = struct {
     /// The Decl that corresponds to the opaque itself.
     owner_decl: Decl.Index,
-    /// Offset from `owner_decl`, points to the opaque decl AST node.
-    node_offset: i32,
     /// Represents the declarations inside this opaque.
     namespace: Namespace,
 
@@ -1420,7 +1406,7 @@ pub const Opaque = struct {
         return .{
             .file_scope = owner_decl.getFileScope(),
             .parent_decl_node = owner_decl.src_node,
-            .lazy = LazySrcLoc.nodeOffset(self.node_offset),
+            .lazy = LazySrcLoc.nodeOffset(0),
         };
     }
 
@@ -4337,7 +4323,6 @@ pub fn semaFile(mod: *Module, file: *File) SemaError!void {
     struct_obj.* = .{
         .owner_decl = undefined, // set below
         .fields = .{},
-        .node_offset = 0, // it's the struct for the root file
         .zir_index = undefined, // set below
         .layout = .Auto,
         .status = .none,
diff --git a/src/Sema.zig b/src/Sema.zig
index c91f4cddb1359e4456dba2b406538fc753a423cb..34d64ff9191de810459afca51c37e86170eb2070 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -1818,10 +1818,10 @@ fn failWithInvalidComptimeFieldStore(sema: *Sema, block: *Block, init_src: LazyS
 
         const tree = try sema.getAstTree(block);
         const decl = sema.mod.declPtr(decl_index);
-        const field_src = enumFieldSrcLoc(decl, tree.*, container_ty.getNodeOffset(), field_index);
+        const field_src = enumFieldSrcLoc(decl, tree.*, 0, field_index);
         const default_value_src: LazySrcLoc = .{ .node_offset_field_default = field_src.node_offset.x };
 
-        try sema.errNote(block, default_value_src, msg, "default value set here", .{});
+        try sema.mod.errNoteNonLazy(default_value_src.toSrcLoc(decl), msg, "default value set here", .{});
         break :msg msg;
     };
     return sema.failWithOwnedErrorMsg(msg);
@@ -1866,7 +1866,7 @@ fn addFieldErrNote(
     const decl_index = container_ty.getOwnerDecl();
     const decl = mod.declPtr(decl_index);
     const tree = try sema.getAstTree(block);
-    const field_src = enumFieldSrcLoc(decl, tree.*, container_ty.getNodeOffset(), field_index);
+    const field_src = enumFieldSrcLoc(decl, tree.*, 0, field_index);
     try mod.errNoteNonLazy(field_src.toSrcLoc(decl), parent, format, args);
 }
 
@@ -2262,7 +2262,7 @@ fn zirStructDecl(
     const struct_obj = try new_decl_arena_allocator.create(Module.Struct);
     const struct_ty = try Type.Tag.@"struct".create(new_decl_arena_allocator, struct_obj);
     const struct_val = try Value.Tag.ty.create(new_decl_arena_allocator, struct_ty);
-    const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, .{
+    const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{
         .ty = Type.type,
         .val = struct_val,
     }, small.name_strategy, "struct", inst);
@@ -2272,7 +2272,6 @@ fn zirStructDecl(
     struct_obj.* = .{
         .owner_decl = new_decl_index,
         .fields = .{},
-        .node_offset = src.node_offset.x,
         .zir_index = inst,
         .layout = small.layout,
         .status = .none,
@@ -2294,6 +2293,7 @@ fn zirStructDecl(
 fn createAnonymousDeclTypeNamed(
     sema: *Sema,
     block: *Block,
+    src: LazySrcLoc,
     typed_value: TypedValue,
     name_strategy: Zir.Inst.NameStrategy,
     anon_prefix: []const u8,
@@ -2303,7 +2303,8 @@ fn createAnonymousDeclTypeNamed(
     const namespace = block.namespace;
     const src_scope = block.wip_capture_scope;
     const src_decl = mod.declPtr(block.src_decl);
-    const new_decl_index = try mod.allocateNewDecl(namespace, src_decl.src_node, src_scope);
+    const src_node = src_decl.relativeToNodeIndex(src.node_offset.x);
+    const new_decl_index = try mod.allocateNewDecl(namespace, src_node, src_scope);
     errdefer mod.destroyDecl(new_decl_index);
 
     switch (name_strategy) {
@@ -2378,7 +2379,7 @@ fn createAnonymousDeclTypeNamed(
                 },
                 else => {},
             };
-            return sema.createAnonymousDeclTypeNamed(block, typed_value, .anon, anon_prefix, null);
+            return sema.createAnonymousDeclTypeNamed(block, src, typed_value, .anon, anon_prefix, null);
         },
     }
 }
@@ -2442,7 +2443,7 @@ fn zirEnumDecl(
     };
     const enum_ty = Type.initPayload(&enum_ty_payload.base);
     const enum_val = try Value.Tag.ty.create(new_decl_arena_allocator, enum_ty);
-    const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, .{
+    const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{
         .ty = Type.type,
         .val = enum_val,
     }, small.name_strategy, "enum", inst);
@@ -2456,7 +2457,6 @@ fn zirEnumDecl(
         .tag_ty_inferred = true,
         .fields = .{},
         .values = .{},
-        .node_offset = src.node_offset.x,
         .namespace = .{
             .parent = block.namespace,
             .ty = enum_ty,
@@ -2684,7 +2684,7 @@ fn zirUnionDecl(
     const union_ty = Type.initPayload(&union_payload.base);
     const union_val = try Value.Tag.ty.create(new_decl_arena_allocator, union_ty);
     const mod = sema.mod;
-    const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, .{
+    const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{
         .ty = Type.type,
         .val = union_val,
     }, small.name_strategy, "union", inst);
@@ -2695,7 +2695,6 @@ fn zirUnionDecl(
         .owner_decl = new_decl_index,
         .tag_ty = Type.initTag(.@"null"),
         .fields = .{},
-        .node_offset = src.node_offset.x,
         .zir_index = inst,
         .layout = small.layout,
         .status = .none,
@@ -2753,7 +2752,7 @@ fn zirOpaqueDecl(
     };
     const opaque_ty = Type.initPayload(&opaque_ty_payload.base);
     const opaque_val = try Value.Tag.ty.create(new_decl_arena_allocator, opaque_ty);
-    const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, .{
+    const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{
         .ty = Type.type,
         .val = opaque_val,
     }, small.name_strategy, "opaque", inst);
@@ -2763,7 +2762,6 @@ fn zirOpaqueDecl(
 
     opaque_obj.* = .{
         .owner_decl = new_decl_index,
-        .node_offset = src.node_offset.x,
         .namespace = .{
             .parent = block.namespace,
             .ty = opaque_ty,
@@ -2802,7 +2800,7 @@ fn zirErrorSetDecl(
     const error_set_ty = try Type.Tag.error_set.create(new_decl_arena_allocator, error_set);
     const error_set_val = try Value.Tag.ty.create(new_decl_arena_allocator, error_set_ty);
     const mod = sema.mod;
-    const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, .{
+    const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{
         .ty = Type.type,
         .val = error_set_val,
     }, name_strategy, "error", inst);
@@ -2827,7 +2825,6 @@ fn zirErrorSetDecl(
 
     error_set.* = .{
         .owner_decl = new_decl_index,
-        .node_offset = inst_data.src_node,
         .names = names,
     };
     try new_decl.finalizeNewArena(&new_decl_arena);
@@ -16336,7 +16333,7 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
             };
             const enum_ty = Type.initPayload(&enum_ty_payload.base);
             const enum_val = try Value.Tag.ty.create(new_decl_arena_allocator, enum_ty);
-            const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, .{
+            const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{
                 .ty = Type.type,
                 .val = enum_val,
             }, name_strategy, "enum", inst);
@@ -16350,7 +16347,6 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
                 .tag_ty_inferred = false,
                 .fields = .{},
                 .values = .{},
-                .node_offset = src.node_offset.x,
                 .namespace = .{
                     .parent = block.namespace,
                     .ty = enum_ty,
@@ -16433,7 +16429,7 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
             };
             const opaque_ty = Type.initPayload(&opaque_ty_payload.base);
             const opaque_val = try Value.Tag.ty.create(new_decl_arena_allocator, opaque_ty);
-            const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, .{
+            const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{
                 .ty = Type.type,
                 .val = opaque_val,
             }, name_strategy, "opaque", inst);
@@ -16443,7 +16439,6 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
 
             opaque_obj.* = .{
                 .owner_decl = new_decl_index,
-                .node_offset = src.node_offset.x,
                 .namespace = .{
                     .parent = block.namespace,
                     .ty = opaque_ty,
@@ -16492,7 +16487,7 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
             };
             const union_ty = Type.initPayload(&union_payload.base);
             const new_union_val = try Value.Tag.ty.create(new_decl_arena_allocator, union_ty);
-            const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, .{
+            const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{
                 .ty = Type.type,
                 .val = new_union_val,
             }, name_strategy, "union", inst);
@@ -16503,7 +16498,6 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
                 .owner_decl = new_decl_index,
                 .tag_ty = Type.initTag(.@"null"),
                 .fields = .{},
-                .node_offset = src.node_offset.x,
                 .zir_index = inst,
                 .layout = layout,
                 .status = .have_field_types,
@@ -16798,7 +16792,7 @@ fn reifyStruct(
     const struct_ty = try Type.Tag.@"struct".create(new_decl_arena_allocator, struct_obj);
     const new_struct_val = try Value.Tag.ty.create(new_decl_arena_allocator, struct_ty);
     const mod = sema.mod;
-    const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, .{
+    const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{
         .ty = Type.type,
         .val = new_struct_val,
     }, name_strategy, "struct", inst);
@@ -16808,7 +16802,6 @@ fn reifyStruct(
     struct_obj.* = .{
         .owner_decl = new_decl_index,
         .fields = .{},
-        .node_offset = src.node_offset.x,
         .zir_index = inst,
         .layout = layout_val.toEnum(std.builtin.Type.ContainerLayout),
         .status = .have_field_types,
@@ -27241,7 +27234,7 @@ fn semaStructFields(mod: *Module, struct_obj: *Module.Struct) CompileError!void
     const small = @bitCast(Zir.Inst.StructDecl.Small, extended.small);
     var extra_index: usize = extended.operand;
 
-    const src = LazySrcLoc.nodeOffset(struct_obj.node_offset);
+    const src = LazySrcLoc.nodeOffset(0);
     extra_index += @boolToInt(small.has_src_node);
 
     const fields_len = if (small.has_fields_len) blk: {
@@ -27360,12 +27353,12 @@ fn semaStructFields(mod: *Module, struct_obj: *Module.Struct) CompileError!void
             if (gop.found_existing) {
                 const msg = msg: {
                     const tree = try sema.getAstTree(&block_scope);
-                    const field_src = enumFieldSrcLoc(decl, tree.*, struct_obj.node_offset, field_i);
+                    const field_src = enumFieldSrcLoc(decl, tree.*, 0, field_i);
                     const msg = try sema.errMsg(&block_scope, field_src, "duplicate struct field: '{s}'", .{field_name});
                     errdefer msg.destroy(gpa);
 
                     const prev_field_index = struct_obj.fields.getIndex(field_name).?;
-                    const prev_field_src = enumFieldSrcLoc(decl, tree.*, struct_obj.node_offset, prev_field_index);
+                    const prev_field_src = enumFieldSrcLoc(decl, tree.*, 0, prev_field_index);
                     try sema.mod.errNoteNonLazy(prev_field_src.toSrcLoc(decl), msg, "other field here", .{});
                     try sema.errNote(&block_scope, src, msg, "struct declared here", .{});
                     break :msg msg;
@@ -27422,7 +27415,7 @@ fn semaStructFields(mod: *Module, struct_obj: *Module.Struct) CompileError!void
         if (field_ty.zigTypeTag() == .Opaque) {
             const msg = msg: {
                 const tree = try sema.getAstTree(&block_scope);
-                const field_src = enumFieldSrcLoc(decl, tree.*, struct_obj.node_offset, i);
+                const field_src = enumFieldSrcLoc(decl, tree.*, 0, i);
                 const msg = try sema.errMsg(&block_scope, field_src, "opaque types have unknown size and therefore cannot be directly embedded in structs", .{});
                 errdefer msg.destroy(sema.gpa);
 
@@ -27434,7 +27427,7 @@ fn semaStructFields(mod: *Module, struct_obj: *Module.Struct) CompileError!void
         if (struct_obj.layout == .Extern and !sema.validateExternType(field.ty, .other)) {
             const msg = msg: {
                 const tree = try sema.getAstTree(&block_scope);
-                const fields_src = enumFieldSrcLoc(decl, tree.*, struct_obj.node_offset, i);
+                const fields_src = enumFieldSrcLoc(decl, tree.*, 0, i);
                 const msg = try sema.errMsg(&block_scope, fields_src, "extern structs cannot contain fields of type '{}'", .{field.ty.fmt(sema.mod)});
                 errdefer msg.destroy(sema.gpa);
 
@@ -27447,7 +27440,7 @@ fn semaStructFields(mod: *Module, struct_obj: *Module.Struct) CompileError!void
         } else if (struct_obj.layout == .Packed and !(validatePackedType(field.ty))) {
             const msg = msg: {
                 const tree = try sema.getAstTree(&block_scope);
-                const fields_src = enumFieldSrcLoc(decl, tree.*, struct_obj.node_offset, i);
+                const fields_src = enumFieldSrcLoc(decl, tree.*, 0, i);
                 const msg = try sema.errMsg(&block_scope, fields_src, "packed structs cannot contain fields of type '{}'", .{field.ty.fmt(sema.mod)});
                 errdefer msg.destroy(sema.gpa);
 
@@ -27504,7 +27497,7 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
     const small = @bitCast(Zir.Inst.UnionDecl.Small, extended.small);
     var extra_index: usize = extended.operand;
 
-    const src = LazySrcLoc.nodeOffset(union_obj.node_offset);
+    const src = LazySrcLoc.nodeOffset(0);
     extra_index += @boolToInt(small.has_src_node);
 
     const tag_type_ref: Zir.Inst.Ref = if (small.has_tag_type) blk: {
@@ -27728,12 +27721,12 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
         if (gop.found_existing) {
             const msg = msg: {
                 const tree = try sema.getAstTree(&block_scope);
-                const field_src = enumFieldSrcLoc(decl, tree.*, union_obj.node_offset, field_i);
+                const field_src = enumFieldSrcLoc(decl, tree.*, 0, field_i);
                 const msg = try sema.errMsg(&block_scope, field_src, "duplicate union field: '{s}'", .{field_name});
                 errdefer msg.destroy(gpa);
 
                 const prev_field_index = union_obj.fields.getIndex(field_name).?;
-                const prev_field_src = enumFieldSrcLoc(decl, tree.*, union_obj.node_offset, prev_field_index);
+                const prev_field_src = enumFieldSrcLoc(decl, tree.*, 0, prev_field_index);
                 try sema.mod.errNoteNonLazy(prev_field_src.toSrcLoc(decl), msg, "other field here", .{});
                 try sema.errNote(&block_scope, src, msg, "union declared here", .{});
                 break :msg msg;
@@ -27746,7 +27739,7 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
             if (!enum_has_field) {
                 const msg = msg: {
                     const tree = try sema.getAstTree(&block_scope);
-                    const field_src = enumFieldSrcLoc(decl, tree.*, union_obj.node_offset, field_i);
+                    const field_src = enumFieldSrcLoc(decl, tree.*, 0, field_i);
                     const msg = try sema.errMsg(&block_scope, field_src, "no field named '{s}' in enum '{}'", .{ field_name, union_obj.tag_ty.fmt(sema.mod) });
                     errdefer msg.destroy(sema.gpa);
                     try sema.addDeclaredHereNote(msg, union_obj.tag_ty);
@@ -27759,7 +27752,7 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
         if (field_ty.zigTypeTag() == .Opaque) {
             const msg = msg: {
                 const tree = try sema.getAstTree(&block_scope);
-                const field_src = enumFieldSrcLoc(decl, tree.*, union_obj.node_offset, field_i);
+                const field_src = enumFieldSrcLoc(decl, tree.*, 0, field_i);
                 const msg = try sema.errMsg(&block_scope, field_src, "opaque types have unknown size and therefore cannot be directly embedded in unions", .{});
                 errdefer msg.destroy(sema.gpa);
 
@@ -27771,7 +27764,7 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
         if (union_obj.layout == .Extern and !sema.validateExternType(field_ty, .union_field)) {
             const msg = msg: {
                 const tree = try sema.getAstTree(&block_scope);
-                const field_src = enumFieldSrcLoc(decl, tree.*, union_obj.node_offset, field_i);
+                const field_src = enumFieldSrcLoc(decl, tree.*, 0, field_i);
                 const msg = try sema.errMsg(&block_scope, field_src, "extern unions cannot contain fields of type '{}'", .{field_ty.fmt(sema.mod)});
                 errdefer msg.destroy(sema.gpa);
 
@@ -27784,7 +27777,7 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
         } else if (union_obj.layout == .Packed and !(validatePackedType(field_ty))) {
             const msg = msg: {
                 const tree = try sema.getAstTree(&block_scope);
-                const fields_src = enumFieldSrcLoc(decl, tree.*, union_obj.node_offset, field_i);
+                const fields_src = enumFieldSrcLoc(decl, tree.*, 0, field_i);
                 const msg = try sema.errMsg(&block_scope, fields_src, "packed unions cannot contain fields of type '{}'", .{field_ty.fmt(sema.mod)});
                 errdefer msg.destroy(sema.gpa);
 
@@ -27876,7 +27869,6 @@ fn generateUnionTagTypeNumbered(
         .tag_ty = int_ty,
         .fields = .{},
         .values = .{},
-        .node_offset = 0,
     };
     // Here we pre-allocate the maps using the decl arena.
     try enum_obj.fields.ensureTotalCapacity(new_decl_arena_allocator, fields_len);
@@ -27934,7 +27926,6 @@ fn generateUnionTagTypeSimple(sema: *Sema, block: *Block, fields_len: usize, may
     enum_obj.* = .{
         .owner_decl = new_decl_index,
         .fields = .{},
-        .node_offset = 0,
     };
     // Here we pre-allocate the maps using the decl arena.
     try enum_obj.fields.ensureTotalCapacity(new_decl_arena_allocator, fields_len);
@@ -28245,7 +28236,7 @@ fn enumFieldSrcLoc(
         => tree.containerDeclArg(enum_node),
 
         // Container was constructed with `@Type`.
-        else => return LazySrcLoc.nodeOffset(node_offset),
+        else => return LazySrcLoc.nodeOffset(0),
     };
     var it_index: usize = 0;
     for (container_decl.ast.members) |member_node| {
diff --git a/src/print_zir.zig b/src/print_zir.zig
index ca2368fe100165150d656567477fb974c3b0b5a5..6503e029fd134854c977b256411d24302e560b7f 100644
--- a/src/print_zir.zig
+++ b/src/print_zir.zig
@@ -1245,6 +1245,10 @@ const Writer = struct {
         if (decls_len == 0) {
             try stream.writeAll("{}, ");
         } else {
+            const prev_parent_decl_node = self.parent_decl_node;
+            if (src_node) |off| self.parent_decl_node = self.relativeToNodeIndex(off);
+            defer self.parent_decl_node = prev_parent_decl_node;
+
             try stream.writeAll("{\n");
             self.indent += 2;
             extra_index = try self.writeDecls(stream, decls_len, extra_index);
@@ -1415,6 +1419,10 @@ const Writer = struct {
         if (decls_len == 0) {
             try stream.writeAll("{}, ");
         } else {
+            const prev_parent_decl_node = self.parent_decl_node;
+            if (src_node) |off| self.parent_decl_node = self.relativeToNodeIndex(off);
+            defer self.parent_decl_node = prev_parent_decl_node;
+
             try stream.writeAll("{\n");
             self.indent += 2;
             extra_index = try self.writeDecls(stream, decls_len, extra_index);
@@ -1662,6 +1670,10 @@ const Writer = struct {
         if (decls_len == 0) {
             try stream.writeAll("{}, ");
         } else {
+            const prev_parent_decl_node = self.parent_decl_node;
+            if (src_node) |off| self.parent_decl_node = self.relativeToNodeIndex(off);
+            defer self.parent_decl_node = prev_parent_decl_node;
+
             try stream.writeAll("{\n");
             self.indent += 2;
             extra_index = try self.writeDecls(stream, decls_len, extra_index);
@@ -1755,6 +1767,10 @@ const Writer = struct {
         if (decls_len == 0) {
             try stream.writeAll("{})");
         } else {
+            const prev_parent_decl_node = self.parent_decl_node;
+            if (src_node) |off| self.parent_decl_node = self.relativeToNodeIndex(off);
+            defer self.parent_decl_node = prev_parent_decl_node;
+
             try stream.writeAll("{\n");
             self.indent += 2;
             _ = try self.writeDecls(stream, decls_len, extra_index);
diff --git a/src/type.zig b/src/type.zig
index d53158735a4221a8f8c6bead4669db9e788b5980..85d77303c9e7c9c7677b9fbf066ff409a42162a7 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -5771,50 +5771,6 @@ pub const Type = extern union {
         }
     }
 
-    pub fn getNodeOffset(ty: Type) i32 {
-        switch (ty.tag()) {
-            .enum_full, .enum_nonexhaustive => {
-                const enum_full = ty.cast(Payload.EnumFull).?.data;
-                return enum_full.node_offset;
-            },
-            .enum_numbered => return ty.castTag(.enum_numbered).?.data.node_offset,
-            .enum_simple => {
-                const enum_simple = ty.castTag(.enum_simple).?.data;
-                return enum_simple.node_offset;
-            },
-            .@"struct" => {
-                const struct_obj = ty.castTag(.@"struct").?.data;
-                return struct_obj.node_offset;
-            },
-            .error_set => {
-                const error_set = ty.castTag(.error_set).?.data;
-                return error_set.node_offset;
-            },
-            .@"union", .union_safety_tagged, .union_tagged => {
-                const union_obj = ty.cast(Payload.Union).?.data;
-                return union_obj.node_offset;
-            },
-            .@"opaque" => {
-                const opaque_obj = ty.cast(Payload.Opaque).?.data;
-                return opaque_obj.node_offset;
-            },
-            .atomic_order,
-            .atomic_rmw_op,
-            .calling_convention,
-            .address_space,
-            .float_mode,
-            .reduce_op,
-            .call_options,
-            .prefetch_options,
-            .export_options,
-            .extern_options,
-            .type_info,
-            => unreachable, // These need to be resolved earlier.
-
-            else => unreachable,
-        }
-    }
-
     /// This enum does not directly correspond to `std.builtin.TypeId` because
     /// it has extra enum tags in it, as a way of using less memory. For example,
     /// even though Zig recognizes `*align(10) i32` and `*i32` both as Pointer types
diff --git a/test/cases/compile_errors/non_constant_expression_in_array_size.zig b/test/cases/compile_errors/non_constant_expression_in_array_size.zig
index e702246001d2c613c5a6c988cfe7eab73bbd17b3..1dc8b50464620ac15cf0ad0149ebcf6de8692881 100644
--- a/test/cases/compile_errors/non_constant_expression_in_array_size.zig
+++ b/test/cases/compile_errors/non_constant_expression_in_array_size.zig
@@ -11,4 +11,4 @@ export fn entry() usize { return @offsetOf(Foo, "y"); }
 // target=native
 //
 // :5:25: error: cannot load runtime value in comptime block
-// :2:15: note: called from here
+// :2:12: note: called from here
diff --git a/test/cases/compile_errors/not_an_enum_type.zig b/test/cases/compile_errors/not_an_enum_type.zig
index 063ee8a8d858ceaece41caab08b89784d116e54a..bdd03c8db7fe54490e4342f4e3d64af7b4b79899 100644
--- a/test/cases/compile_errors/not_an_enum_type.zig
+++ b/test/cases/compile_errors/not_an_enum_type.zig
@@ -17,4 +17,4 @@ const ExpectedVarDeclOrFn = struct {};
 // target=native
 //
 // :4:9: error: expected type '@typeInfo(tmp.Error).Union.tag_type.?', found 'type'
-// :8:1: note: enum declared here
+// :8:15: note: enum declared here
diff --git a/test/cases/compile_errors/tagName_on_invalid_value_of_non-exhaustive_enum.zig b/test/cases/compile_errors/tagName_on_invalid_value_of_non-exhaustive_enum.zig
index e9e63f0d7ac1884bcc7bb0e300baa954cc9d6c26..1de0d1c1450163981eb7dde7188ba15be59e5b52 100644
--- a/test/cases/compile_errors/tagName_on_invalid_value_of_non-exhaustive_enum.zig
+++ b/test/cases/compile_errors/tagName_on_invalid_value_of_non-exhaustive_enum.zig
@@ -9,4 +9,4 @@ test "enum" {
 // is_test=1
 //
 // :3:9: error: no field with value '5' in enum 'test.enum.E'
-// :1:1: note: declared here
+// :2:15: note: declared here
diff --git a/test/cases/error_in_nested_declaration.zig b/test/cases/error_in_nested_declaration.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3fff746909a5f431fa3ca9da784c4b72ceba7fcd
--- /dev/null
+++ b/test/cases/error_in_nested_declaration.zig
@@ -0,0 +1,31 @@
+const S = struct {
+    b: u32,
+    c: i32,
+    a: struct {
+        pub fn str(_: @This(), extra: []u32) []i32 {
+            return @bitCast([]i32, extra);
+        }
+    },  
+};
+
+pub export fn entry() void {
+    var s: S = undefined;
+    _ = s.a.str(undefined);
+}
+
+const S2 = struct {
+    a: [*c]anyopaque,
+};
+
+pub export fn entry2() void {
+    var s: S2 = undefined;
+    _ = s;
+}
+
+// error
+// backend=llvm
+// target=native
+//
+// :17:12: error: C pointers cannot point to opaque types
+// :6:29: error: cannot @bitCast to '[]i32'
+// :6:29: note: use @ptrCast to cast from '[]u32'
-- 
2.54.0


From 0fd90749d10052c40d5a91881621af55e80135b3 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sun, 7 Aug 2022 19:55:31 +0300
Subject: [PATCH 059/290] stage2: generate call arguments in separate blocks

---
 src/AstGen.zig                                |  52 ++++--
 src/Sema.zig                                  | 156 ++++++++++++------
 src/Zir.zig                                   |  20 +--
 src/print_zir.zig                             |  37 +++--
 test/behavior/call.zig                        |  15 ++
 .../int_literal_passed_as_variadic_arg.zig    |  11 ++
 .../member_function_arg_mismatch.zig          |  14 ++
 7 files changed, 209 insertions(+), 96 deletions(-)
 create mode 100644 test/cases/compile_errors/int_literal_passed_as_variadic_arg.zig
 create mode 100644 test/cases/compile_errors/member_function_arg_mismatch.zig

diff --git a/src/AstGen.zig b/src/AstGen.zig
index ead9517ef04a2723ac4686dfcea9cdc58bcd1e54..efa8690b55ce96d7f2fd116972165c8e26a3432c 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -2500,7 +2500,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
             .closure_get,
             .array_base_ptr,
             .field_base_ptr,
-            .param_type,
             .ret_ptr,
             .ret_type,
             .@"try",
@@ -8228,6 +8227,33 @@ fn callExpr(
     assert(callee != .none);
     assert(node != 0);
 
+    const call_index = @intCast(Zir.Inst.Index, astgen.instructions.len);
+    const call_inst = Zir.indexToRef(call_index);
+    try gz.astgen.instructions.append(astgen.gpa, undefined);
+    try gz.instructions.append(astgen.gpa, call_index);
+
+    const scratch_top = astgen.scratch.items.len;
+    defer astgen.scratch.items.len = scratch_top;
+
+    var scratch_index = scratch_top;
+    try astgen.scratch.resize(astgen.gpa, scratch_top + call.ast.params.len);
+
+    for (call.ast.params) |param_node| {
+        var arg_block = gz.makeSubBlock(scope);
+        defer arg_block.unstack();
+
+        // `call_inst` is reused to provide the param type.
+        const arg_ref = try expr(&arg_block, &arg_block.base, .{ .coerced_ty = call_inst }, param_node);
+        _ = try arg_block.addBreak(.break_inline, call_index, arg_ref);
+
+        const body = arg_block.instructionsSlice();
+        try astgen.scratch.ensureUnusedCapacity(astgen.gpa, countBodyLenAfterFixups(astgen, body));
+        appendBodyWithFixupsArrayList(astgen, &astgen.scratch, body);
+
+        astgen.scratch.items[scratch_index] = @intCast(u32, astgen.scratch.items.len - scratch_top);
+        scratch_index += 1;
+    }
+
     const payload_index = try addExtra(astgen, Zir.Inst.Call{
         .callee = callee,
         .flags = .{
@@ -8235,22 +8261,16 @@ fn callExpr(
             .args_len = @intCast(Zir.Inst.Call.Flags.PackedArgsLen, call.ast.params.len),
         },
     });
-    var extra_index = try reserveExtra(astgen, call.ast.params.len);
-
-    for (call.ast.params) |param_node, i| {
-        const param_type = try gz.add(.{
-            .tag = .param_type,
-            .data = .{ .param_type = .{
-                .callee = callee,
-                .param_index = @intCast(u32, i),
-            } },
-        });
-        const arg_ref = try expr(gz, scope, .{ .coerced_ty = param_type }, param_node);
-        astgen.extra.items[extra_index] = @enumToInt(arg_ref);
-        extra_index += 1;
+    if (call.ast.params.len != 0) {
+        try astgen.extra.appendSlice(astgen.gpa, astgen.scratch.items[scratch_top..]);
     }
-
-    const call_inst = try gz.addPlNodePayloadIndex(.call, node, payload_index);
+    gz.astgen.instructions.set(call_index, .{
+        .tag = .call,
+        .data = .{ .pl_node = .{
+            .src_node = gz.nodeIndexToRelative(node),
+            .payload_index = payload_index,
+        } },
+    });
     return rvalue(gz, rl, call_inst, node); // TODO function call with result location
 }
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 4995d8786633d7e6fd57edcdf78ea6beb1eb792e..68409a5d05cb3a03bddf651714cc62e51ca3b1d0 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -772,7 +772,6 @@ fn analyzeBodyInner(
             .optional_payload_unsafe      => try sema.zirOptionalPayload(block, inst, false),
             .optional_payload_unsafe_ptr  => try sema.zirOptionalPayloadPtr(block, inst, false),
             .optional_type                => try sema.zirOptionalType(block, inst),
-            .param_type                   => try sema.zirParamType(block, inst),
             .ptr_type                     => try sema.zirPtrType(block, inst),
             .overflow_arithmetic_ptr      => try sema.zirOverflowArithmeticPtr(block, inst),
             .ref                          => try sema.zirRef(block, inst),
@@ -4441,43 +4440,6 @@ fn zirStoreNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!v
     return sema.storePtr2(block, src, ptr, src, operand, src, if (is_ret) .ret_ptr else .store);
 }
 
-fn zirParamType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
-    const callee_src = sema.src;
-
-    const inst_data = sema.code.instructions.items(.data)[inst].param_type;
-    const callee = try sema.resolveInst(inst_data.callee);
-    const callee_ty = sema.typeOf(callee);
-    var param_index = inst_data.param_index;
-
-    const fn_ty = if (callee_ty.tag() == .bound_fn) fn_ty: {
-        const bound_fn_val = try sema.resolveConstValue(block, .unneeded, callee, undefined);
-        const bound_fn = bound_fn_val.castTag(.bound_fn).?.data;
-        const fn_ty = sema.typeOf(bound_fn.func_inst);
-        param_index += 1;
-        break :fn_ty fn_ty;
-    } else callee_ty;
-
-    const fn_info = if (fn_ty.zigTypeTag() == .Pointer)
-        fn_ty.childType().fnInfo()
-    else
-        fn_ty.fnInfo();
-
-    if (param_index >= fn_info.param_types.len) {
-        if (fn_info.is_var_args) {
-            return sema.addType(Type.initTag(.var_args_param));
-        }
-        // TODO implement begin_call/end_call Zir instructions and check
-        // argument count before casting arguments to parameter types.
-        return sema.fail(block, callee_src, "wrong number of arguments", .{});
-    }
-
-    if (fn_info.param_types[param_index].tag() == .generic_poison) {
-        return sema.addType(Type.initTag(.var_args_param));
-    }
-
-    return sema.addType(fn_info.param_types[param_index]);
-}
-
 fn zirStr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const tracy = trace(@src());
     defer tracy.end();
@@ -5459,13 +5421,14 @@ fn zirCall(
     const func_src: LazySrcLoc = .{ .node_offset_call_func = inst_data.src_node };
     const call_src = inst_data.src();
     const extra = sema.code.extraData(Zir.Inst.Call, inst_data.payload_index);
-    const args = sema.code.refSlice(extra.end, extra.data.flags.args_len);
+    const args_len = extra.data.flags.args_len;
 
     const modifier = @intToEnum(std.builtin.CallOptions.Modifier, extra.data.flags.packed_modifier);
     const ensure_result_used = extra.data.flags.ensure_result_used;
 
     var func = try sema.resolveInst(extra.data.callee);
     var resolved_args: []Air.Inst.Ref = undefined;
+    var arg_index: u32 = 0;
 
     const func_type = sema.typeOf(func);
 
@@ -5476,16 +5439,99 @@ fn zirCall(
         const bound_func = try sema.resolveValue(block, .unneeded, func, undefined);
         const bound_data = &bound_func.cast(Value.Payload.BoundFn).?.data;
         func = bound_data.func_inst;
-        resolved_args = try sema.arena.alloc(Air.Inst.Ref, args.len + 1);
-        resolved_args[0] = bound_data.arg0_inst;
-        for (args) |zir_arg, i| {
-            resolved_args[i + 1] = try sema.resolveInst(zir_arg);
-        }
+        resolved_args = try sema.arena.alloc(Air.Inst.Ref, args_len + 1);
+        resolved_args[arg_index] = bound_data.arg0_inst;
+        arg_index += 1;
     } else {
-        resolved_args = try sema.arena.alloc(Air.Inst.Ref, args.len);
-        for (args) |zir_arg, i| {
-            resolved_args[i] = try sema.resolveInst(zir_arg);
+        resolved_args = try sema.arena.alloc(Air.Inst.Ref, args_len);
+    }
+    const total_args = args_len + @boolToInt(bound_arg_src != null);
+
+    const callee_ty = sema.typeOf(func);
+    const func_ty = func_ty: {
+        switch (callee_ty.zigTypeTag()) {
+            .Fn => break :func_ty callee_ty,
+            .Pointer => {
+                const ptr_info = callee_ty.ptrInfo().data;
+                if (ptr_info.size == .One and ptr_info.pointee_type.zigTypeTag() == .Fn) {
+                    break :func_ty ptr_info.pointee_type;
+                }
+            },
+            else => {},
         }
+        return sema.fail(block, func_src, "type '{}' not a function", .{callee_ty.fmt(sema.mod)});
+    };
+    const func_ty_info = func_ty.fnInfo();
+
+    const fn_params_len = func_ty_info.param_types.len;
+    if (func_ty_info.is_var_args) {
+        assert(func_ty_info.cc == .C);
+        if (total_args < fn_params_len) {
+            // TODO add error note: declared here
+            if (bound_arg_src != null) {
+                return sema.fail(
+                    block,
+                    call_src,
+                    "member function expected at least {d} argument(s), found {d}",
+                    .{ fn_params_len - 1, args_len },
+                );
+            }
+            return sema.fail(
+                block,
+                func_src,
+                "expected at least {d} argument(s), found {d}",
+                .{ fn_params_len, args_len },
+            );
+        }
+    } else if (fn_params_len != total_args) {
+        // TODO add error note: declared here
+        if (bound_arg_src != null) {
+            return sema.fail(
+                block,
+                call_src,
+                "member function expected {d} argument(s), found {d}",
+                .{ fn_params_len - 1, args_len },
+            );
+        }
+        return sema.fail(
+            block,
+            call_src,
+            "expected {d} argument(s), found {d}",
+            .{ fn_params_len, args_len },
+        );
+    }
+
+    const args_body = sema.code.extra[extra.end..];
+
+    const parent_comptime = block.is_comptime;
+    // `extra_index` and `arg_index` are separate since the bound function is passed as the first argument.
+    var extra_index: usize = 0;
+    var arg_start: u32 = args_len;
+    while (extra_index < args_len) : ({
+        extra_index += 1;
+        arg_index += 1;
+    }) {
+        const arg_end = sema.code.extra[extra.end + extra_index];
+        defer arg_start = arg_end;
+
+        const param_ty = if (arg_index >= fn_params_len or
+            func_ty_info.param_types[arg_index].tag() == .generic_poison)
+            Type.initTag(.var_args_param)
+        else
+            func_ty_info.param_types[arg_index];
+
+        const old_comptime = block.is_comptime;
+        defer block.is_comptime = old_comptime;
+        // Generate args to comptime params in comptime block.
+        block.is_comptime = parent_comptime;
+        if (arg_index < fn_params_len and func_ty_info.comptime_params[arg_index]) {
+            block.is_comptime = true;
+        }
+
+        const param_ty_inst = try sema.addType(param_ty);
+        try sema.inst_map.put(sema.gpa, inst, param_ty_inst);
+
+        resolved_args[arg_index] = try sema.resolveBody(block, args_body[arg_start..arg_end], inst);
     }
 
     return sema.analyzeCall(block, func, func_src, call_src, modifier, ensure_result_used, resolved_args, bound_arg_src);
@@ -5964,7 +6010,18 @@ fn analyzeCall(
                     else => |e| return e,
                 };
             } else {
-                args[i] = uncasted_arg;
+                args[i] = sema.coerceVarArgParam(block, uncasted_arg, .unneeded) catch |err| switch (err) {
+                    error.NeededSourceLocation => {
+                        const decl = sema.mod.declPtr(block.src_decl);
+                        _ = try sema.coerceVarArgParam(
+                            block,
+                            uncasted_arg,
+                            Module.argSrc(call_src.node_offset.x, sema.gpa, decl, i, bound_arg_src),
+                        );
+                        return error.AnalysisFail;
+                    },
+                    else => |e| return e,
+                };
             }
         }
 
@@ -23534,7 +23591,10 @@ fn coerceVarArgParam(
     inst_src: LazySrcLoc,
 ) !Air.Inst.Ref {
     const inst_ty = sema.typeOf(inst);
+    if (block.is_typeof) return inst;
+
     switch (inst_ty.zigTypeTag()) {
+        // TODO consider casting to c_int/f64 if they fit
         .ComptimeInt, .ComptimeFloat => return sema.fail(block, inst_src, "integer and float literals in var args function must be casted", .{}),
         else => {},
     }
diff --git a/src/Zir.zig b/src/Zir.zig
index c5618a58c0b0d275bb6900b4e4e255b7b156e1a1..c62e6d02bb550d6d3fa9fe522214c9a8366b3f35 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -490,14 +490,6 @@ pub const Inst = struct {
         /// Merge two error sets into one, `E1 || E2`.
         /// Uses the `pl_node` field with payload `Bin`.
         merge_error_sets,
-        /// Given a reference to a function and a parameter index, returns the
-        /// type of the parameter. The only usage of this instruction is for the
-        /// result location of parameters of function calls. In the case of a function's
-        /// parameter type being `anytype`, it is the type coercion's job to detect this
-        /// scenario and skip the coercion, so that semantic analysis of this instruction
-        /// is not in a position where it must create an invalid type.
-        /// Uses the `param_type` union field.
-        param_type,
         /// Turns an R-Value into a const L-Value. In other words, it takes a value,
         /// stores it in a memory location, and returns a const pointer to it. If the value
         /// is `comptime`, the memory location is global static constant data. Otherwise,
@@ -1095,7 +1087,6 @@ pub const Inst = struct {
                 .mul,
                 .mulwrap,
                 .mul_sat,
-                .param_type,
                 .ref,
                 .shl,
                 .shl_sat,
@@ -1397,7 +1388,6 @@ pub const Inst = struct {
                 .mul,
                 .mulwrap,
                 .mul_sat,
-                .param_type,
                 .ref,
                 .shl,
                 .shl_sat,
@@ -1569,7 +1559,6 @@ pub const Inst = struct {
                 .mulwrap = .pl_node,
                 .mul_sat = .pl_node,
 
-                .param_type = .param_type,
                 .param = .pl_tok,
                 .param_comptime = .pl_tok,
                 .param_anytype = .str_tok,
@@ -2540,10 +2529,6 @@ pub const Inst = struct {
             /// Points to a `Block`.
             payload_index: u32,
         },
-        param_type: struct {
-            callee: Ref,
-            param_index: u32,
-        },
         @"unreachable": struct {
             /// Offset from Decl AST node index.
             /// `Tag` determines which kind of AST node this points to.
@@ -2614,7 +2599,6 @@ pub const Inst = struct {
             ptr_type,
             int_type,
             bool_br,
-            param_type,
             @"unreachable",
             @"break",
             switch_capture,
@@ -2794,7 +2778,9 @@ pub const Inst = struct {
     };
 
     /// Stored inside extra, with trailing arguments according to `args_len`.
-    /// Each argument is a `Ref`.
+    /// Implicit 0. arg_0_start: u32, // always same as `args_len`
+    /// 1. arg_end: u32, // for each `args_len`
+    /// arg_N_start is the same as arg_N-1_end
     pub const Call = struct {
         // Note: Flags *must* come first so that unusedResultExpr
         // can find it when it goes to modify them.
diff --git a/src/print_zir.zig b/src/print_zir.zig
index 6503e029fd134854c977b256411d24302e560b7f..2b70799c367b798db5f77431ee7819863867319b 100644
--- a/src/print_zir.zig
+++ b/src/print_zir.zig
@@ -246,7 +246,6 @@ const Writer = struct {
 
             .validate_array_init_ty => try self.writeValidateArrayInitTy(stream, inst),
             .array_type_sentinel => try self.writeArrayTypeSentinel(stream, inst),
-            .param_type => try self.writeParamType(stream, inst),
             .ptr_type => try self.writePtrType(stream, inst),
             .int => try self.writeInt(stream, inst),
             .int_big => try self.writeIntBig(stream, inst),
@@ -605,16 +604,6 @@ const Writer = struct {
         try self.writeSrc(stream, inst_data.src());
     }
 
-    fn writeParamType(
-        self: *Writer,
-        stream: anytype,
-        inst: Zir.Inst.Index,
-    ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
-        const inst_data = self.code.instructions.items(.data)[inst].param_type;
-        try self.writeInstRef(stream, inst_data.callee);
-        try stream.print(", {d})", .{inst_data.param_index});
-    }
-
     fn writePtrType(
         self: *Writer,
         stream: anytype,
@@ -1158,7 +1147,8 @@ const Writer = struct {
     fn writeCall(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[inst].pl_node;
         const extra = self.code.extraData(Zir.Inst.Call, inst_data.payload_index);
-        const args = self.code.refSlice(extra.end, extra.data.flags.args_len);
+        const args_len = extra.data.flags.args_len;
+        const body = self.code.extra[extra.end..];
 
         if (extra.data.flags.ensure_result_used) {
             try stream.writeAll("nodiscard ");
@@ -1166,10 +1156,27 @@ const Writer = struct {
         try stream.print(".{s}, ", .{@tagName(@intToEnum(std.builtin.CallOptions.Modifier, extra.data.flags.packed_modifier))});
         try self.writeInstRef(stream, extra.data.callee);
         try stream.writeAll(", [");
-        for (args) |arg, i| {
-            if (i != 0) try stream.writeAll(", ");
-            try self.writeInstRef(stream, arg);
+
+        self.indent += 2;
+        if (args_len != 0) {
+            try stream.writeAll("\n");
         }
+        var i: usize = 0;
+        var arg_start: u32 = args_len;
+        while (i < args_len) : (i += 1) {
+            try stream.writeByteNTimes(' ', self.indent);
+            const arg_end = self.code.extra[extra.end + i];
+            defer arg_start = arg_end;
+            const arg_body = body[arg_start..arg_end];
+            try self.writeBracedBody(stream, arg_body);
+
+            try stream.writeAll(",\n");
+        }
+        self.indent -= 2;
+        if (args_len != 0) {
+            try stream.writeByteNTimes(' ', self.indent);
+        }
+
         try stream.writeAll("]) ");
         try self.writeSrc(stream, inst_data.src());
     }
diff --git a/test/behavior/call.zig b/test/behavior/call.zig
index 0297582234d752230d5de2bdd4e811030e43846c..eafd2ef4e9168fd379c3b430c21f8e63b5642159 100644
--- a/test/behavior/call.zig
+++ b/test/behavior/call.zig
@@ -246,3 +246,18 @@ test "function call with 40 arguments" {
     };
     try S.doTheTest(39);
 }
+
+test "arguments to comptime parameters generated in comptime blocks" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+
+    const S = struct {
+        fn fortyTwo() i32 {
+            return 42;
+        }
+
+        fn foo(comptime x: i32) void {
+            if (x != 42) @compileError("bad");
+        }
+    };
+    S.foo(S.fortyTwo());
+}
diff --git a/test/cases/compile_errors/int_literal_passed_as_variadic_arg.zig b/test/cases/compile_errors/int_literal_passed_as_variadic_arg.zig
new file mode 100644
index 0000000000000000000000000000000000000000..be9ffaa884c8741db68089a1253cd0cb562ff2f8
--- /dev/null
+++ b/test/cases/compile_errors/int_literal_passed_as_variadic_arg.zig
@@ -0,0 +1,11 @@
+extern fn printf([*:0]const u8, ...) c_int;
+
+pub export fn entry() void {
+    _ = printf("%d %d %d %d\n", 1, 2, 3, 4);
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :4:33: error: integer and float literals in var args function must be casted
diff --git a/test/cases/compile_errors/member_function_arg_mismatch.zig b/test/cases/compile_errors/member_function_arg_mismatch.zig
new file mode 100644
index 0000000000000000000000000000000000000000..aaefac58b4f0fe5b724584f963987cc2f2c42a88
--- /dev/null
+++ b/test/cases/compile_errors/member_function_arg_mismatch.zig
@@ -0,0 +1,14 @@
+const S = struct {
+    a: u32,
+    fn foo(_: *S, _: u32, _: bool) void {}
+};
+pub export fn entry() void {
+    var s: S = undefined;
+    s.foo(true);
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :7:10: error: member function expected 2 argument(s), found 1
-- 
2.54.0


From 19af4b5cadaad24fd886578da5b5840dd3499d2d Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sun, 7 Aug 2022 23:01:12 +0300
Subject: [PATCH 060/290] std: add workaround for stage2 bug

---
 lib/std/crypto/25519/ed25519.zig | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/std/crypto/25519/ed25519.zig b/lib/std/crypto/25519/ed25519.zig
index 2a7671863eb91fe083b4de6f872ecea7c3f21b19..7066b1a154198c779ac2698702bd7c2c520042ef 100644
--- a/lib/std/crypto/25519/ed25519.zig
+++ b/lib/std/crypto/25519/ed25519.zig
@@ -355,7 +355,9 @@ test "ed25519 batch verification" {
         try Ed25519.verifyBatch(2, signature_batch);
 
         signature_batch[1].sig = sig1;
-        try std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verifyBatch(signature_batch.len, signature_batch));
+        // TODO https://github.com/ziglang/zig/issues/12240
+        const sig_len = signature_batch.len;
+        try std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verifyBatch(sig_len, signature_batch));
     }
 }
 
-- 
2.54.0


From 0778490283a8129755e411877453a173759ab4f4 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 8 Aug 2022 22:28:48 +0300
Subject: [PATCH 061/290] AutoDoc: update to Zir call inst changes

---
 src/Autodoc.zig | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 9e3874979d03874a61e14d09515ece43cdf135c3..3fcc28d74274540579abd5c3dc163bf920393742 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -2078,14 +2078,19 @@ fn walkInstruction(
 
             const args_len = extra.data.flags.args_len;
             var args = try self.arena.alloc(DocData.Expr, args_len);
-            const arg_refs = file.zir.refSlice(extra.end, args_len);
-            for (arg_refs) |ref, idx| {
+            const body = file.zir.extra[extra.end..];
+
+            var i: usize = 0;
+            while (i < args_len) : (i += 1) {
+                const arg_end = file.zir.extra[extra.end + i];
+                const break_index = body[arg_end - 1];
+                const ref = data[break_index].@"break".operand;
                 // TODO: consider toggling need_type to true if we ever want
                 //       to show discrepancies between the types of provided
                 //       arguments and the types declared in the function
                 //       signature for its parameters.
                 const wr = try self.walkRef(file, parent_scope, ref, false);
-                args[idx] = wr.expr;
+                args[i] = wr.expr;
             }
 
             const cte_slot_index = self.comptime_exprs.items.len;
-- 
2.54.0


From b757a96d5c885442c38e217006d75c85a28daf09 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Tue, 9 Aug 2022 23:37:26 +0300
Subject: [PATCH 062/290] Sema: add declared here note to function call errors

---
 src/Sema.zig                                  | 92 +++++++++++--------
 ...function_with_naked_calling_convention.zig | 11 +++
 .../member_function_arg_mismatch.zig          |  3 +-
 ...function_with_naked_calling_convention.zig | 11 ---
 ...number_of_arguments_for_method_fn_call.zig | 14 ---
 .../wrong_number_of_arguments.zig             |  3 +-
 ...number_of_arguments_for_method_fn_call.zig | 15 +++
 7 files changed, 83 insertions(+), 66 deletions(-)
 create mode 100644 test/cases/compile_errors/calling_function_with_naked_calling_convention.zig
 delete mode 100644 test/cases/compile_errors/stage1/obj/calling_function_with_naked_calling_convention.zig
 delete mode 100644 test/cases/compile_errors/stage1/obj/wrong_number_of_arguments_for_method_fn_call.zig
 create mode 100644 test/cases/compile_errors/wrong_number_of_arguments_for_method_fn_call.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index 68409a5d05cb3a03bddf651714cc62e51ca3b1d0..acdce0e9b09739e52f83b7bf3eb62f6ed3406ef3 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -5409,6 +5409,19 @@ fn lookupInNamespace(
     return null;
 }
 
+fn funcDeclSrc(sema: *Sema, block: *Block, src: LazySrcLoc, func_inst: Air.Inst.Ref) !?Module.SrcLoc {
+    const func_val = (try sema.resolveMaybeUndefVal(block, src, func_inst)) orelse return null;
+    if (func_val.isUndef()) return null;
+    const owner_decl_index = switch (func_val.tag()) {
+        .extern_fn => func_val.castTag(.extern_fn).?.data.owner_decl,
+        .function => func_val.castTag(.function).?.data.owner_decl,
+        .decl_ref => sema.mod.declPtr(func_val.castTag(.decl_ref).?.data).val.castTag(.function).?.data.owner_decl,
+        else => return null,
+    };
+    const owner_decl = sema.mod.declPtr(owner_decl_index);
+    return owner_decl.srcLoc();
+}
+
 fn zirCall(
     sema: *Sema,
     block: *Block,
@@ -5464,41 +5477,35 @@ fn zirCall(
     const func_ty_info = func_ty.fnInfo();
 
     const fn_params_len = func_ty_info.param_types.len;
-    if (func_ty_info.is_var_args) {
-        assert(func_ty_info.cc == .C);
-        if (total_args < fn_params_len) {
-            // TODO add error note: declared here
-            if (bound_arg_src != null) {
-                return sema.fail(
-                    block,
-                    call_src,
-                    "member function expected at least {d} argument(s), found {d}",
-                    .{ fn_params_len - 1, args_len },
-                );
-            }
-            return sema.fail(
+    check_args: {
+        if (func_ty_info.is_var_args) {
+            assert(func_ty_info.cc == .C);
+            if (total_args >= fn_params_len) break :check_args;
+        } else if (fn_params_len == total_args) {
+            break :check_args;
+        }
+
+        const decl_src = try sema.funcDeclSrc(block, func_src, func);
+        const member_str = if (bound_arg_src != null) "member function " else "";
+        const variadic_str = if (func_ty_info.is_var_args) "at least " else "";
+        const msg = msg: {
+            const msg = try sema.errMsg(
                 block,
                 func_src,
-                "expected at least {d} argument(s), found {d}",
-                .{ fn_params_len, args_len },
+                "{s}expected {s}{d} argument(s), found {d}",
+                .{
+                    member_str,
+                    variadic_str,
+                    fn_params_len - @boolToInt(bound_arg_src != null),
+                    args_len,
+                },
             );
-        }
-    } else if (fn_params_len != total_args) {
-        // TODO add error note: declared here
-        if (bound_arg_src != null) {
-            return sema.fail(
-                block,
-                call_src,
-                "member function expected {d} argument(s), found {d}",
-                .{ fn_params_len - 1, args_len },
-            );
-        }
-        return sema.fail(
-            block,
-            call_src,
-            "expected {d} argument(s), found {d}",
-            .{ fn_params_len, args_len },
-        );
+            errdefer msg.destroy(sema.gpa);
+
+            if (decl_src) |some| try sema.mod.errNoteNonLazy(some, msg, "function declared here", .{});
+            break :msg msg;
+        };
+        return sema.failWithOwnedErrorMsg(msg);
     }
 
     const args_body = sema.code.extra[extra.end..];
@@ -5625,13 +5632,20 @@ fn analyzeCall(
     const func_ty_info = func_ty.fnInfo();
     const cc = func_ty_info.cc;
     if (cc == .Naked) {
-        // TODO add error note: declared here
-        return sema.fail(
-            block,
-            func_src,
-            "unable to call function with naked calling convention",
-            .{},
-        );
+        const decl_src = try sema.funcDeclSrc(block, func_src, func);
+        const msg = msg: {
+            const msg = try sema.errMsg(
+                block,
+                func_src,
+                "unable to call function with naked calling convention",
+                .{},
+            );
+            errdefer msg.destroy(sema.gpa);
+
+            if (decl_src) |some| try sema.mod.errNoteNonLazy(some, msg, "function declared here", .{});
+            break :msg msg;
+        };
+        return sema.failWithOwnedErrorMsg(msg);
     }
     const fn_params_len = func_ty_info.param_types.len;
     if (func_ty_info.is_var_args) {
diff --git a/test/cases/compile_errors/calling_function_with_naked_calling_convention.zig b/test/cases/compile_errors/calling_function_with_naked_calling_convention.zig
new file mode 100644
index 0000000000000000000000000000000000000000..54bf58542542ec1f43e168f53dbb32c5cf5ca738
--- /dev/null
+++ b/test/cases/compile_errors/calling_function_with_naked_calling_convention.zig
@@ -0,0 +1,11 @@
+export fn entry() void {
+    foo();
+}
+fn foo() callconv(.Naked) void { }
+
+// error
+// backend=llvm
+// target=native
+//
+// :2:5: error: unable to call function with naked calling convention
+// :4:1: note: function declared here
diff --git a/test/cases/compile_errors/member_function_arg_mismatch.zig b/test/cases/compile_errors/member_function_arg_mismatch.zig
index aaefac58b4f0fe5b724584f963987cc2f2c42a88..b739be95440be4e74235e96989b3efba52acf1a6 100644
--- a/test/cases/compile_errors/member_function_arg_mismatch.zig
+++ b/test/cases/compile_errors/member_function_arg_mismatch.zig
@@ -11,4 +11,5 @@ pub export fn entry() void {
 // backend=stage2
 // target=native
 //
-// :7:10: error: member function expected 2 argument(s), found 1
+// :7:6: error: member function expected 2 argument(s), found 1
+// :3:5: note: function declared here
diff --git a/test/cases/compile_errors/stage1/obj/calling_function_with_naked_calling_convention.zig b/test/cases/compile_errors/stage1/obj/calling_function_with_naked_calling_convention.zig
deleted file mode 100644
index 401f84e687da591d8ea817f5f1c27f4bfd02a563..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/calling_function_with_naked_calling_convention.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-export fn entry() void {
-    foo();
-}
-fn foo() callconv(.Naked) void { }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:5: error: unable to call function with naked calling convention
-// tmp.zig:4:1: note: declared here
diff --git a/test/cases/compile_errors/stage1/obj/wrong_number_of_arguments_for_method_fn_call.zig b/test/cases/compile_errors/stage1/obj/wrong_number_of_arguments_for_method_fn_call.zig
deleted file mode 100644
index 7371223863c0f43a33a8bd1ae068053cbd691e32..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/wrong_number_of_arguments_for_method_fn_call.zig
+++ /dev/null
@@ -1,14 +0,0 @@
-const Foo = struct {
-    fn method(self: *const Foo, a: i32) void {_ = self; _ = a;}
-};
-fn f(foo: *const Foo) void {
-
-    foo.method(1, 2);
-}
-export fn entry() usize { return @sizeOf(@TypeOf(f)); }
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:6:15: error: expected 2 argument(s), found 3
diff --git a/test/cases/compile_errors/wrong_number_of_arguments.zig b/test/cases/compile_errors/wrong_number_of_arguments.zig
index 64eb11650a9c0762021a1b834c4fd2e61ab53078..05d761de18ca5e4a2a42a52404c361d3fc202d51 100644
--- a/test/cases/compile_errors/wrong_number_of_arguments.zig
+++ b/test/cases/compile_errors/wrong_number_of_arguments.zig
@@ -7,4 +7,5 @@ fn c(d: i32, e: i32, f: i32) void { _ = d; _ = e; _ = f; }
 // backend=stage2
 // target=native
 //
-// :2:6: error: expected 3 argument(s), found 1
+// :2:5: error: expected 3 argument(s), found 1
+// :4:1: note: function declared here
diff --git a/test/cases/compile_errors/wrong_number_of_arguments_for_method_fn_call.zig b/test/cases/compile_errors/wrong_number_of_arguments_for_method_fn_call.zig
new file mode 100644
index 0000000000000000000000000000000000000000..da6a7be4fa453dd682f372cd510f2881b5283cf8
--- /dev/null
+++ b/test/cases/compile_errors/wrong_number_of_arguments_for_method_fn_call.zig
@@ -0,0 +1,15 @@
+const Foo = struct {
+    fn method(self: *const Foo, a: i32) void {_ = self; _ = a;}
+};
+fn f(foo: *const Foo) void {
+
+    foo.method(1, 2);
+}
+export fn entry() usize { return @sizeOf(@TypeOf(&f)); }
+
+// error
+// backend=stage2
+// target=native
+//
+// :6:8: error: member function expected 1 argument(s), found 2
+// :2:5: note: function declared here
-- 
2.54.0


From bb1c3e8b7e2be201221e14719d2d39e6298cc66c Mon Sep 17 00:00:00 2001
From: Isaac Freund <mail@isaacfreund.com>
Date: Wed, 10 Aug 2022 13:21:47 +0200
Subject: [PATCH 063/290] stage2: Handle lazy values for the % operator

---
 src/Sema.zig           | 59 ++++++++++++++++++++++++++++++++++++++++--
 src/value.zig          | 38 ---------------------------
 test/behavior/math.zig | 15 +++++++++++
 3 files changed, 72 insertions(+), 40 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index acdce0e9b09739e52f83b7bf3eb62f6ed3406ef3..6d95b46c7c6ac949fc42eb08429eae698de89881 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -78,6 +78,7 @@ post_hoc_blocks: std.AutoHashMapUnmanaged(Air.Inst.Index, *LabeledBlock) = .{},
 err: ?*Module.ErrorMsg = null,
 
 const std = @import("std");
+const math = std.math;
 const mem = std.mem;
 const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
@@ -11824,7 +11825,7 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
                     return sema.failWithDivideByZero(block, rhs_src);
                 }
                 if (maybe_lhs_val) |lhs_val| {
-                    const rem_result = try lhs_val.intRem(rhs_val, resolved_type, sema.arena, target);
+                    const rem_result = try sema.intRem(block, resolved_type, lhs_val, lhs_src, rhs_val, rhs_src);
                     // If this answer could possibly be different by doing `intMod`,
                     // we must emit a compile error. Otherwise, it's OK.
                     if ((try rhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) != (try lhs_val.compareWithZeroAdvanced(.lt, sema.kit(block, src))) and
@@ -11886,6 +11887,60 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     return block.addBinOp(air_tag, casted_lhs, casted_rhs);
 }
 
+fn intRem(
+    sema: *Sema,
+    block: *Block,
+    ty: Type,
+    lhs: Value,
+    lhs_src: LazySrcLoc,
+    rhs: Value,
+    rhs_src: LazySrcLoc,
+) CompileError!Value {
+    if (ty.zigTypeTag() == .Vector) {
+        const result_data = try sema.arena.alloc(Value, ty.vectorLen());
+        for (result_data) |*scalar, i| {
+            scalar.* = try sema.intRemScalar(block, lhs.indexVectorlike(i), lhs_src, rhs.indexVectorlike(i), rhs_src);
+        }
+        return Value.Tag.aggregate.create(sema.arena, result_data);
+    }
+    return sema.intRemScalar(block, lhs, lhs_src, rhs, rhs_src);
+}
+
+fn intRemScalar(
+    sema: *Sema,
+    block: *Block,
+    lhs: Value,
+    lhs_src: LazySrcLoc,
+    rhs: Value,
+    rhs_src: LazySrcLoc,
+) CompileError!Value {
+    const target = sema.mod.getTarget();
+    // TODO is this a performance issue? maybe we should try the operation without
+    // resorting to BigInt first.
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = try lhs.toBigIntAdvanced(&lhs_space, target, sema.kit(block, lhs_src));
+    const rhs_bigint = try rhs.toBigIntAdvanced(&rhs_space, target, sema.kit(block, rhs_src));
+    const limbs_q = try sema.arena.alloc(
+        math.big.Limb,
+        lhs_bigint.limbs.len,
+    );
+    const limbs_r = try sema.arena.alloc(
+        math.big.Limb,
+        // TODO: consider reworking Sema to re-use Values rather than
+        // always producing new Value objects.
+        rhs_bigint.limbs.len,
+    );
+    const limbs_buffer = try sema.arena.alloc(
+        math.big.Limb,
+        math.big.int.calcDivLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
+    );
+    var result_q = math.big.int.Mutable{ .limbs = limbs_q, .positive = undefined, .len = undefined };
+    var result_r = math.big.int.Mutable{ .limbs = limbs_r, .positive = undefined, .len = undefined };
+    result_q.divTrunc(&result_r, lhs_bigint, rhs_bigint, limbs_buffer);
+    return Value.fromBigInt(sema.arena, result_r.toConst());
+}
+
 fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
     const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
@@ -12050,7 +12105,7 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
                 if (maybe_lhs_val) |lhs_val| {
                     return sema.addConstant(
                         resolved_type,
-                        try lhs_val.intRem(rhs_val, resolved_type, sema.arena, target),
+                        try sema.intRem(block, resolved_type, lhs_val, lhs_src, rhs_val, rhs_src),
                     );
                 }
                 break :rs lhs_src;
diff --git a/src/value.zig b/src/value.zig
index 3994040ba656d90097f4d7c5af17580137b6660f..f156651eaac605546291e5edb6b3bdbf04bff648 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -3472,44 +3472,6 @@ pub const Value = extern union {
         return fromBigInt(allocator, result_q.toConst());
     }
 
-    pub fn intRem(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, target: Target) !Value {
-        if (ty.zigTypeTag() == .Vector) {
-            const result_data = try allocator.alloc(Value, ty.vectorLen());
-            for (result_data) |*scalar, i| {
-                scalar.* = try intRemScalar(lhs.indexVectorlike(i), rhs.indexVectorlike(i), allocator, target);
-            }
-            return Value.Tag.aggregate.create(allocator, result_data);
-        }
-        return intRemScalar(lhs, rhs, allocator, target);
-    }
-
-    pub fn intRemScalar(lhs: Value, rhs: Value, allocator: Allocator, target: Target) !Value {
-        // TODO is this a performance issue? maybe we should try the operation without
-        // resorting to BigInt first.
-        var lhs_space: Value.BigIntSpace = undefined;
-        var rhs_space: Value.BigIntSpace = undefined;
-        const lhs_bigint = lhs.toBigInt(&lhs_space, target);
-        const rhs_bigint = rhs.toBigInt(&rhs_space, target);
-        const limbs_q = try allocator.alloc(
-            std.math.big.Limb,
-            lhs_bigint.limbs.len,
-        );
-        const limbs_r = try allocator.alloc(
-            std.math.big.Limb,
-            // TODO: consider reworking Sema to re-use Values rather than
-            // always producing new Value objects.
-            rhs_bigint.limbs.len,
-        );
-        const limbs_buffer = try allocator.alloc(
-            std.math.big.Limb,
-            std.math.big.int.calcDivLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
-        );
-        var result_q = BigIntMutable{ .limbs = limbs_q, .positive = undefined, .len = undefined };
-        var result_r = BigIntMutable{ .limbs = limbs_r, .positive = undefined, .len = undefined };
-        result_q.divTrunc(&result_r, lhs_bigint, rhs_bigint, limbs_buffer);
-        return fromBigInt(allocator, result_r.toConst());
-    }
-
     pub fn intMod(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, target: Target) !Value {
         if (ty.zigTypeTag() == .Vector) {
             const result_data = try allocator.alloc(Value, ty.vectorLen());
diff --git a/test/behavior/math.zig b/test/behavior/math.zig
index c8d0becbd6552535e689b4c12e85af920fb6fbc5..ce476fea04e583379978fa6fe93ad9ea520114ed 100644
--- a/test/behavior/math.zig
+++ b/test/behavior/math.zig
@@ -1721,3 +1721,18 @@ fn testAbsFloat() !void {
 fn testAbsFloatOne(in: f32, out: f32) !void {
     try expect(@fabs(@as(f32, in)) == @as(f32, out));
 }
+
+test "mod lazy values" {
+    {
+        const X = struct { x: u32 };
+        const x = @sizeOf(X);
+        const y = 1 % x;
+        _ = y;
+    }
+    {
+        const X = struct { x: u32 };
+        const x = @sizeOf(X);
+        const y = x % 1;
+        _ = y;
+    }
+}
-- 
2.54.0


From 0d32b73078aa4579187f7d5c67343a6036eed277 Mon Sep 17 00:00:00 2001
From: Isaac Freund <mail@isaacfreund.com>
Date: Mon, 8 Aug 2022 18:39:14 +0200
Subject: [PATCH 064/290] stage2: Implement explicit backing integers for
 packed structs

Now the backing integer of a packed struct type may be explicitly
specified with e.g. `packed struct(u32) { ... }`.
---
 lib/std/builtin.zig                           |   2 +
 lib/std/zig/Ast.zig                           |   2 +-
 lib/std/zig/parse.zig                         |  10 +-
 lib/std/zig/parser_test.zig                   |   7 +
 src/AstGen.zig                                |  56 ++++-
 src/Autodoc.zig                               |  11 +
 src/Module.zig                                |  21 +-
 src/Sema.zig                                  | 207 +++++++++++++++++-
 src/Zir.zig                                   |  16 +-
 src/codegen/llvm.zig                          |  15 +-
 src/print_zir.zig                             |  25 ++-
 src/stage1/all_types.hpp                      |   1 +
 src/stage1/analyze.cpp                        |   6 +
 src/stage1/ir.cpp                             |  40 +++-
 src/stage1/parser.cpp                         |  11 +-
 src/type.zig                                  |  23 +-
 test/behavior.zig                             |   1 +
 .../packed_struct_explicit_backing_int.zig    |  53 +++++
 test/behavior/type_info.zig                   |   4 +-
 .../packed_struct_backing_int_wrong.zig       |  55 +++++
 20 files changed, 493 insertions(+), 73 deletions(-)
 create mode 100644 test/behavior/packed_struct_explicit_backing_int.zig
 create mode 100644 test/cases/compile_errors/packed_struct_backing_int_wrong.zig

diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index ef716c6972c4a755a0e077107d76191ff09d2850..2c2bc92c96022ec7b2c150d3bcdd77b89cf3740a 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -294,6 +294,8 @@ pub const Type = union(enum) {
     /// therefore must be kept in sync with the compiler implementation.
     pub const Struct = struct {
         layout: ContainerLayout,
+        /// Only valid if layout is .Packed
+        backing_integer: ?type = null,
         fields: []const StructField,
         decls: []const Declaration,
         is_tuple: bool,
diff --git a/lib/std/zig/Ast.zig b/lib/std/zig/Ast.zig
index 9bffcb3df202376c0d663aec5233c1829c4c14d5..016cefb2559256f0d0fd69c4ee4552b1e6358d98 100644
--- a/lib/std/zig/Ast.zig
+++ b/lib/std/zig/Ast.zig
@@ -2967,7 +2967,7 @@ pub const Node = struct {
         /// Same as ContainerDeclTwo except there is known to be a trailing comma
         /// or semicolon before the rbrace.
         container_decl_two_trailing,
-        /// `union(lhs)` / `enum(lhs)`. `SubRange[rhs]`.
+        /// `struct(lhs)` / `union(lhs)` / `enum(lhs)`. `SubRange[rhs]`.
         container_decl_arg,
         /// Same as container_decl_arg but there is known to be a trailing
         /// comma or semicolon before the rbrace.
diff --git a/lib/std/zig/parse.zig b/lib/std/zig/parse.zig
index 2a7d2623efb28514ab88a69693be88cda5db5c7d..a03764a91cc6b53e3879bd7a87c30c5774ea319d 100644
--- a/lib/std/zig/parse.zig
+++ b/lib/std/zig/parse.zig
@@ -3356,16 +3356,18 @@ const Parser = struct {
     }
 
     /// Caller must have already verified the first token.
+    /// ContainerDeclAuto <- ContainerDeclType LBRACE container_doc_comment? ContainerMembers RBRACE
+    ///
     /// ContainerDeclType
-    ///     <- KEYWORD_struct
+    ///     <- KEYWORD_struct (LPAREN Expr RPAREN)?
+    ///      / KEYWORD_opaque
     ///      / KEYWORD_enum (LPAREN Expr RPAREN)?
     ///      / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
-    ///      / KEYWORD_opaque
     fn parseContainerDeclAuto(p: *Parser) !Node.Index {
         const main_token = p.nextToken();
         const arg_expr = switch (p.token_tags[main_token]) {
-            .keyword_struct, .keyword_opaque => null_node,
-            .keyword_enum => blk: {
+            .keyword_opaque => null_node,
+            .keyword_struct, .keyword_enum => blk: {
                 if (p.eatToken(.l_paren)) |_| {
                     const expr = try p.expectExpr();
                     _ = try p.expectToken(.r_paren);
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index a74d53f21c0d444c862c54785dfa3879b6a366cc..bee9375b5ae188a089e03de1ebbf7368f7fe52da 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -3064,6 +3064,13 @@ test "zig fmt: struct declaration" {
         \\    c: u8,
         \\};
         \\
+        \\const Ps = packed struct(u32) {
+        \\    a: u1,
+        \\    b: u2,
+        \\
+        \\    c: u29,
+        \\};
+        \\
         \\const Es = extern struct {
         \\    a: u8,
         \\    b: u8,
diff --git a/src/AstGen.zig b/src/AstGen.zig
index efa8690b55ce96d7f2fd116972165c8e26a3432c..af77cdacc466df99613f90e561aa4fd52e2fa60d 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -152,6 +152,7 @@ pub fn generate(gpa: Allocator, tree: Ast) Allocator.Error!Zir {
         0,
         tree.containerDeclRoot(),
         .Auto,
+        0,
     )) |struct_decl_ref| {
         assert(refToIndex(struct_decl_ref).? == 0);
     } else |err| switch (err) {
@@ -4223,15 +4224,18 @@ fn structDeclInner(
     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 decl_inst = try gz.reserveInstructionIndex();
 
-    if (container_decl.ast.members.len == 0) {
+    if (container_decl.ast.members.len == 0 and backing_int_node == 0) {
         try gz.setStruct(decl_inst, .{
             .src_node = node,
             .layout = layout,
             .fields_len = 0,
             .decls_len = 0,
+            .backing_int_ref = .none,
+            .backing_int_body_len = 0,
             .known_non_opv = false,
             .known_comptime_only = false,
         });
@@ -4266,6 +4270,35 @@ fn structDeclInner(
     };
     defer block_scope.unstack();
 
+    const scratch_top = astgen.scratch.items.len;
+    defer astgen.scratch.items.len = scratch_top;
+
+    var backing_int_body_len: usize = 0;
+    const backing_int_ref: Zir.Inst.Ref = blk: {
+        if (backing_int_node != 0) {
+            if (layout != .Packed) {
+                return astgen.failNode(backing_int_node, "non-packed struct does not support backing integer type", .{});
+            } else {
+                const backing_int_ref = try typeExpr(&block_scope, &namespace.base, backing_int_node);
+                if (!block_scope.isEmpty()) {
+                    if (!block_scope.endsWithNoReturn()) {
+                        _ = try block_scope.addBreak(.break_inline, decl_inst, backing_int_ref);
+                    }
+
+                    const body = block_scope.instructionsSlice();
+                    const old_scratch_len = astgen.scratch.items.len;
+                    try astgen.scratch.ensureUnusedCapacity(gpa, countBodyLenAfterFixups(astgen, body));
+                    appendBodyWithFixupsArrayList(astgen, &astgen.scratch, body);
+                    backing_int_body_len = astgen.scratch.items.len - old_scratch_len;
+                    block_scope.instructions.items.len = block_scope.instructions_top;
+                }
+                break :blk backing_int_ref;
+            }
+        } else {
+            break :blk .none;
+        }
+    };
+
     const decl_count = try astgen.scanDecls(&namespace, container_decl.ast.members);
     const field_count = @intCast(u32, container_decl.ast.members.len - decl_count);
 
@@ -4378,6 +4411,8 @@ fn structDeclInner(
         .layout = layout,
         .fields_len = field_count,
         .decls_len = decl_count,
+        .backing_int_ref = backing_int_ref,
+        .backing_int_body_len = @intCast(u32, backing_int_body_len),
         .known_non_opv = known_non_opv,
         .known_comptime_only = known_comptime_only,
     });
@@ -4386,7 +4421,9 @@ fn structDeclInner(
     const decls_slice = wip_members.declsSlice();
     const fields_slice = wip_members.fieldsSlice();
     const bodies_slice = astgen.scratch.items[bodies_start..];
-    try astgen.extra.ensureUnusedCapacity(gpa, decls_slice.len + fields_slice.len + bodies_slice.len);
+    try astgen.extra.ensureUnusedCapacity(gpa, backing_int_body_len +
+        decls_slice.len + fields_slice.len + bodies_slice.len);
+    astgen.extra.appendSliceAssumeCapacity(astgen.scratch.items[scratch_top..][0..backing_int_body_len]);
     astgen.extra.appendSliceAssumeCapacity(decls_slice);
     astgen.extra.appendSliceAssumeCapacity(fields_slice);
     astgen.extra.appendSliceAssumeCapacity(bodies_slice);
@@ -4582,9 +4619,7 @@ fn containerDecl(
                 else => unreachable,
             } else std.builtin.Type.ContainerLayout.Auto;
 
-            assert(container_decl.ast.arg == 0);
-
-            const result = try structDeclInner(gz, scope, node, container_decl, layout);
+            const result = try structDeclInner(gz, scope, node, container_decl, layout, container_decl.ast.arg);
             return rvalue(gz, rl, result, node);
         },
         .keyword_union => {
@@ -11254,6 +11289,8 @@ const GenZir = struct {
         src_node: Ast.Node.Index,
         fields_len: u32,
         decls_len: u32,
+        backing_int_ref: Zir.Inst.Ref,
+        backing_int_body_len: u32,
         layout: std.builtin.Type.ContainerLayout,
         known_non_opv: bool,
         known_comptime_only: bool,
@@ -11261,7 +11298,7 @@ const GenZir = struct {
         const astgen = gz.astgen;
         const gpa = astgen.gpa;
 
-        try astgen.extra.ensureUnusedCapacity(gpa, 4);
+        try astgen.extra.ensureUnusedCapacity(gpa, 6);
         const payload_index = @intCast(u32, astgen.extra.items.len);
 
         if (args.src_node != 0) {
@@ -11274,6 +11311,12 @@ const GenZir = struct {
         if (args.decls_len != 0) {
             astgen.extra.appendAssumeCapacity(args.decls_len);
         }
+        if (args.backing_int_ref != .none) {
+            astgen.extra.appendAssumeCapacity(args.backing_int_body_len);
+            if (args.backing_int_body_len == 0) {
+                astgen.extra.appendAssumeCapacity(@enumToInt(args.backing_int_ref));
+            }
+        }
         astgen.instructions.set(inst, .{
             .tag = .extended,
             .data = .{ .extended = .{
@@ -11282,6 +11325,7 @@ const GenZir = struct {
                     .has_src_node = args.src_node != 0,
                     .has_fields_len = args.fields_len != 0,
                     .has_decls_len = args.decls_len != 0,
+                    .has_backing_int = args.backing_int_ref != .none,
                     .known_non_opv = args.known_non_opv,
                     .known_comptime_only = args.known_comptime_only,
                     .name_strategy = gz.anon_name_strategy,
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 3fcc28d74274540579abd5c3dc163bf920393742..ef2579a8e4182be3e1132749b662d85cec31ceec 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -2536,6 +2536,17 @@ fn walkInstruction(
                         break :blk decls_len;
                     } else 0;
 
+                    // TODO: Expose explicit backing integer types in some way.
+                    if (small.has_backing_int) {
+                        const backing_int_body_len = file.zir.extra[extra_index];
+                        extra_index += 1; // backing_int_body_len
+                        if (backing_int_body_len == 0) {
+                            extra_index += 1; // backing_int_ref
+                        } else {
+                            extra_index += backing_int_body_len; // backing_int_body_inst
+                        }
+                    }
+
                     var decl_indexes: std.ArrayListUnmanaged(usize) = .{};
                     var priv_decl_indexes: std.ArrayListUnmanaged(usize) = .{};
 
diff --git a/src/Module.zig b/src/Module.zig
index 8b195eff2de02674457ea2d786f0fdc9fc0da264..7e877a2f4ad6394442565ceffacf4824b0c7a130 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -895,6 +895,11 @@ pub const Struct = struct {
     zir_index: Zir.Inst.Index,
 
     layout: std.builtin.Type.ContainerLayout,
+    /// If the layout is not packed, this is the noreturn type.
+    /// If the layout is packed, this is the backing integer type of the packed struct.
+    /// Whether zig chooses this type or the user specifies it, it is stored here.
+    /// This will be set to the noreturn type until status is `have_layout`.
+    backing_int_ty: Type = Type.initTag(.noreturn),
     status: enum {
         none,
         field_types_wip,
@@ -1025,7 +1030,7 @@ pub const Struct = struct {
 
     pub fn packedFieldBitOffset(s: Struct, target: Target, index: usize) u16 {
         assert(s.layout == .Packed);
-        assert(s.haveFieldTypes());
+        assert(s.haveLayout());
         var bit_sum: u64 = 0;
         for (s.fields.values()) |field, i| {
             if (i == index) {
@@ -1033,19 +1038,7 @@ pub const Struct = struct {
             }
             bit_sum += field.ty.bitSize(target);
         }
-        return @intCast(u16, bit_sum);
-    }
-
-    pub fn packedIntegerBits(s: Struct, target: Target) u16 {
-        return s.packedFieldBitOffset(target, s.fields.count());
-    }
-
-    pub fn packedIntegerType(s: Struct, target: Target, buf: *Type.Payload.Bits) Type {
-        buf.* = .{
-            .base = .{ .tag = .int_unsigned },
-            .data = s.packedIntegerBits(target),
-        };
-        return Type.initPayload(&buf.base);
+        unreachable; // index out of bounds
     }
 };
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 6d95b46c7c6ac949fc42eb08429eae698de89881..faf16926539f22c29feef1957ea5638032190182 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -2239,6 +2239,16 @@ pub fn analyzeStructDecl(
         break :blk decls_len;
     } else 0;
 
+    if (small.has_backing_int) {
+        const backing_int_body_len = sema.code.extra[extra_index];
+        extra_index += 1; // backing_int_body_len
+        if (backing_int_body_len == 0) {
+            extra_index += 1; // backing_int_ref
+        } else {
+            extra_index += backing_int_body_len; // backing_int_body_inst
+        }
+    }
+
     _ = try sema.mod.scanNamespace(&struct_obj.namespace, extra_index, decls_len, new_decl);
 }
 
@@ -14285,13 +14295,27 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
             const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, struct_ty.getNamespace());
 
-            const field_values = try sema.arena.create([4]Value);
+            const backing_integer_val = blk: {
+                if (layout == .Packed) {
+                    const struct_obj = struct_ty.castTag(.@"struct").?.data;
+                    assert(struct_obj.haveLayout());
+                    assert(struct_obj.backing_int_ty.isInt());
+                    const backing_int_ty_val = try Value.Tag.ty.create(sema.arena, struct_obj.backing_int_ty);
+                    break :blk try Value.Tag.opt_payload.create(sema.arena, backing_int_ty_val);
+                } else {
+                    break :blk Value.initTag(.null_value);
+                }
+            };
+
+            const field_values = try sema.arena.create([5]Value);
             field_values.* = .{
                 // layout: ContainerLayout,
                 try Value.Tag.enum_field_index.create(
                     sema.arena,
                     @enumToInt(layout),
                 ),
+                // backing_integer: ?type,
+                backing_integer_val,
                 // fields: []const StructField,
                 fields_val,
                 // decls: []const Declaration,
@@ -16308,7 +16332,7 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
             if (!try sema.intFitsInType(block, src, alignment_val, Type.u32, null)) {
                 return sema.fail(block, src, "alignment must fit in 'u32'", .{});
             }
-            const abi_align = @intCast(u29, alignment_val.toUnsignedInt(target));
+            const abi_align = @intCast(u29, (try alignment_val.getUnsignedIntAdvanced(target, sema.kit(block, src))).?);
 
             var buffer: Value.ToTypeBuffer = undefined;
             const unresolved_elem_ty = child_val.toType(&buffer);
@@ -16473,22 +16497,31 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
             const struct_val = union_val.val.castTag(.aggregate).?.data;
             // layout: containerlayout,
             const layout_val = struct_val[0];
+            // backing_int: ?type,
+            const backing_int_val = struct_val[1];
             // fields: []const enumfield,
-            const fields_val = struct_val[1];
+            const fields_val = struct_val[2];
             // decls: []const declaration,
-            const decls_val = struct_val[2];
+            const decls_val = struct_val[3];
             // is_tuple: bool,
-            const is_tuple_val = struct_val[3];
+            const is_tuple_val = struct_val[4];
+            assert(struct_val.len == 5);
+
+            const layout = layout_val.toEnum(std.builtin.Type.ContainerLayout);
 
             // Decls
             if (decls_val.sliceLen(mod) > 0) {
                 return sema.fail(block, src, "reified structs must have no decls", .{});
             }
 
+            if (layout != .Packed and !backing_int_val.isNull()) {
+                return sema.fail(block, src, "non-packed struct does not support backing integer type", .{});
+            }
+
             return if (is_tuple_val.toBool())
                 try sema.reifyTuple(block, src, fields_val)
             else
-                try sema.reifyStruct(block, inst, src, layout_val, fields_val, name_strategy);
+                try sema.reifyStruct(block, inst, src, layout, backing_int_val, fields_val, name_strategy);
         },
         .Enum => {
             const struct_val = union_val.val.castTag(.aggregate).?.data;
@@ -16981,7 +17014,8 @@ fn reifyStruct(
     block: *Block,
     inst: Zir.Inst.Index,
     src: LazySrcLoc,
-    layout_val: Value,
+    layout: std.builtin.Type.ContainerLayout,
+    backing_int_val: Value,
     fields_val: Value,
     name_strategy: Zir.Inst.NameStrategy,
 ) CompileError!Air.Inst.Ref {
@@ -17004,7 +17038,7 @@ fn reifyStruct(
         .owner_decl = new_decl_index,
         .fields = .{},
         .zir_index = inst,
-        .layout = layout_val.toEnum(std.builtin.Type.ContainerLayout),
+        .layout = layout,
         .status = .have_field_types,
         .known_non_opv = false,
         .namespace = .{
@@ -17070,6 +17104,41 @@ fn reifyStruct(
         };
     }
 
+    if (layout == .Packed) {
+        struct_obj.status = .layout_wip;
+
+        for (struct_obj.fields.values()) |field, index| {
+            sema.resolveTypeLayout(block, src, field.ty) catch |err| switch (err) {
+                error.AnalysisFail => {
+                    const msg = sema.err orelse return err;
+                    try sema.addFieldErrNote(block, struct_ty, index, msg, "while checking this field", .{});
+                    return err;
+                },
+                else => return err,
+            };
+        }
+
+        var fields_bit_sum: u64 = 0;
+        for (struct_obj.fields.values()) |field| {
+            fields_bit_sum += field.ty.bitSize(target);
+        }
+
+        if (backing_int_val.optionalValue()) |payload| {
+            var buf: Value.ToTypeBuffer = undefined;
+            const backing_int_ty = payload.toType(&buf);
+            try sema.checkBackingIntType(block, src, backing_int_ty, fields_bit_sum);
+            struct_obj.backing_int_ty = try backing_int_ty.copy(new_decl_arena_allocator);
+        } else {
+            var buf: Type.Payload.Bits = .{
+                .base = .{ .tag = .int_unsigned },
+                .data = @intCast(u16, fields_bit_sum),
+            };
+            struct_obj.backing_int_ty = try Type.initPayload(&buf.base).copy(new_decl_arena_allocator);
+        }
+
+        struct_obj.status = .have_layout;
+    }
+
     try new_decl.finalizeNewArena(&new_decl_arena);
     return sema.analyzeDeclVal(block, src, new_decl_index);
 }
@@ -27154,6 +27223,11 @@ fn resolveStructLayout(
                 else => return err,
             };
         }
+
+        if (struct_obj.layout == .Packed) {
+            try semaBackingIntType(sema.mod, struct_obj);
+        }
+
         struct_obj.status = .have_layout;
 
         // In case of querying the ABI alignment of this struct, we will ask
@@ -27173,6 +27247,109 @@ fn resolveStructLayout(
     // otherwise it's a tuple; no need to resolve anything
 }
 
+fn semaBackingIntType(mod: *Module, struct_obj: *Module.Struct) CompileError!void {
+    const gpa = mod.gpa;
+    const target = mod.getTarget();
+
+    var fields_bit_sum: u64 = 0;
+    for (struct_obj.fields.values()) |field| {
+        fields_bit_sum += field.ty.bitSize(target);
+    }
+
+    const decl_index = struct_obj.owner_decl;
+    const decl = mod.declPtr(decl_index);
+    var decl_arena = decl.value_arena.?.promote(gpa);
+    defer decl.value_arena.?.* = decl_arena.state;
+    const decl_arena_allocator = decl_arena.allocator();
+
+    const zir = struct_obj.namespace.file_scope.zir;
+    const extended = zir.instructions.items(.data)[struct_obj.zir_index].extended;
+    assert(extended.opcode == .struct_decl);
+    const small = @bitCast(Zir.Inst.StructDecl.Small, extended.small);
+
+    if (small.has_backing_int) {
+        var extra_index: usize = extended.operand;
+        extra_index += @boolToInt(small.has_src_node);
+        extra_index += @boolToInt(small.has_fields_len);
+        extra_index += @boolToInt(small.has_decls_len);
+
+        const backing_int_body_len = zir.extra[extra_index];
+        extra_index += 1;
+
+        var analysis_arena = std.heap.ArenaAllocator.init(gpa);
+        defer analysis_arena.deinit();
+
+        var sema: Sema = .{
+            .mod = mod,
+            .gpa = gpa,
+            .arena = analysis_arena.allocator(),
+            .perm_arena = decl_arena_allocator,
+            .code = zir,
+            .owner_decl = decl,
+            .owner_decl_index = decl_index,
+            .func = null,
+            .fn_ret_ty = Type.void,
+            .owner_func = null,
+        };
+        defer sema.deinit();
+
+        var wip_captures = try WipCaptureScope.init(gpa, decl_arena_allocator, decl.src_scope);
+        defer wip_captures.deinit();
+
+        var block: Block = .{
+            .parent = null,
+            .sema = &sema,
+            .src_decl = decl_index,
+            .namespace = &struct_obj.namespace,
+            .wip_capture_scope = wip_captures.scope,
+            .instructions = .{},
+            .inlining = null,
+            .is_comptime = true,
+        };
+        defer {
+            assert(block.instructions.items.len == 0);
+            block.params.deinit(gpa);
+        }
+
+        const backing_int_src: LazySrcLoc = .{ .node_offset_container_tag = 0 };
+        const backing_int_ty = blk: {
+            if (backing_int_body_len == 0) {
+                const backing_int_ref = @intToEnum(Zir.Inst.Ref, zir.extra[extra_index]);
+                break :blk try sema.resolveType(&block, backing_int_src, backing_int_ref);
+            } else {
+                const body = zir.extra[extra_index..][0..backing_int_body_len];
+                const ty_ref = try sema.resolveBody(&block, body, struct_obj.zir_index);
+                break :blk try sema.analyzeAsType(&block, backing_int_src, ty_ref);
+            }
+        };
+
+        try sema.checkBackingIntType(&block, backing_int_src, backing_int_ty, fields_bit_sum);
+        struct_obj.backing_int_ty = try backing_int_ty.copy(decl_arena_allocator);
+    } else {
+        var buf: Type.Payload.Bits = .{
+            .base = .{ .tag = .int_unsigned },
+            .data = @intCast(u16, fields_bit_sum),
+        };
+        struct_obj.backing_int_ty = try Type.initPayload(&buf.base).copy(decl_arena_allocator);
+    }
+}
+
+fn checkBackingIntType(sema: *Sema, block: *Block, src: LazySrcLoc, backing_int_ty: Type, fields_bit_sum: u64) CompileError!void {
+    const target = sema.mod.getTarget();
+
+    if (!backing_int_ty.isInt()) {
+        return sema.fail(block, src, "expected backing integer type, found '{}'", .{backing_int_ty.fmt(sema.mod)});
+    }
+    if (backing_int_ty.bitSize(target) != fields_bit_sum) {
+        return sema.fail(
+            block,
+            src,
+            "backing integer type '{}' has bit size {} but the struct fields have a total bit size of {}",
+            .{ backing_int_ty.fmt(sema.mod), backing_int_ty.bitSize(target), fields_bit_sum },
+        );
+    }
+}
+
 fn resolveUnionLayout(
     sema: *Sema,
     block: *Block,
@@ -27495,12 +27672,26 @@ fn semaStructFields(mod: *Module, struct_obj: *Module.Struct) CompileError!void
         break :decls_len decls_len;
     } else 0;
 
+    // The backing integer cannot be handled until `resolveStructLayout()`.
+    if (small.has_backing_int) {
+        const backing_int_body_len = zir.extra[extra_index];
+        extra_index += 1; // backing_int_body_len
+        if (backing_int_body_len == 0) {
+            extra_index += 1; // backing_int_ref
+        } else {
+            extra_index += backing_int_body_len; // backing_int_body_inst
+        }
+    }
+
     // Skip over decls.
     var decls_it = zir.declIteratorInner(extra_index, decls_len);
     while (decls_it.next()) |_| {}
     extra_index = decls_it.extra_index;
 
     if (fields_len == 0) {
+        if (struct_obj.layout == .Packed) {
+            try semaBackingIntType(mod, struct_obj);
+        }
         struct_obj.status = .have_layout;
         return;
     }
diff --git a/src/Zir.zig b/src/Zir.zig
index c62e6d02bb550d6d3fa9fe522214c9a8366b3f35..538ef6aaf8c35b12a3e4586e47103283d2b29cd6 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -3085,13 +3085,16 @@ pub const Inst = struct {
     /// 0. src_node: i32, // if has_src_node
     /// 1. fields_len: u32, // if has_fields_len
     /// 2. decls_len: u32, // if has_decls_len
-    /// 3. decl_bits: u32 // for every 8 decls
+    /// 3. backing_int_body_len: u32, // if has_backing_int
+    /// 4. backing_int_ref: Ref, // if has_backing_int and backing_int_body_len is 0
+    /// 5. backing_int_body_inst: Inst, // if has_backing_int and backing_int_body_len is > 0
+    /// 6. decl_bits: u32 // for every 8 decls
     ///    - sets of 4 bits:
     ///      0b000X: whether corresponding decl is pub
     ///      0b00X0: whether corresponding decl is exported
     ///      0b0X00: whether corresponding decl has an align expression
     ///      0bX000: whether corresponding decl has a linksection or an address space expression
-    /// 4. decl: { // for every decls_len
+    /// 7. decl: { // for every decls_len
     ///        src_hash: [4]u32, // hash of source bytes
     ///        line: u32, // line number of decl, relative to parent
     ///        name: u32, // null terminated string index
@@ -3109,13 +3112,13 @@ pub const Inst = struct {
     ///            address_space: Ref,
     ///        }
     ///    }
-    /// 5. flags: u32 // for every 8 fields
+    /// 8. flags: u32 // for every 8 fields
     ///    - sets of 4 bits:
     ///      0b000X: whether corresponding field has an align expression
     ///      0b00X0: whether corresponding field has a default expression
     ///      0b0X00: whether corresponding field is comptime
     ///      0bX000: whether corresponding field has a type expression
-    /// 6. fields: { // for every fields_len
+    /// 9. fields: { // for every fields_len
     ///        field_name: u32,
     ///        doc_comment: u32, // 0 if no doc comment
     ///        field_type: Ref, // if corresponding bit is not set. none means anytype.
@@ -3123,7 +3126,7 @@ pub const Inst = struct {
     ///        align_body_len: u32, // if corresponding bit is set
     ///        init_body_len: u32, // if corresponding bit is set
     ///    }
-    /// 7. bodies: { // for every fields_len
+    /// 10. bodies: { // for every fields_len
     ///        field_type_body_inst: Inst, // for each field_type_body_len
     ///        align_body_inst: Inst, // for each align_body_len
     ///        init_body_inst: Inst, // for each init_body_len
@@ -3133,11 +3136,12 @@ pub const Inst = struct {
             has_src_node: bool,
             has_fields_len: bool,
             has_decls_len: bool,
+            has_backing_int: bool,
             known_non_opv: bool,
             known_comptime_only: bool,
             name_strategy: NameStrategy,
             layout: std.builtin.Type.ContainerLayout,
-            _: u7 = undefined,
+            _: u6 = undefined,
         };
     };
 
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 9c3efa18cd9f4ab556922af6f5c7fddb57681205..6d2922ea3fe557dd2411dba5539fd333331e07ad 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1683,8 +1683,7 @@ pub const Object = struct {
                 if (ty.castTag(.@"struct")) |payload| {
                     const struct_obj = payload.data;
                     if (struct_obj.layout == .Packed) {
-                        var buf: Type.Payload.Bits = undefined;
-                        const info = struct_obj.packedIntegerType(target, &buf).intInfo(target);
+                        const info = struct_obj.backing_int_ty.intInfo(target);
                         const dwarf_encoding: c_uint = switch (info.signedness) {
                             .signed => DW.ATE.signed,
                             .unsigned => DW.ATE.unsigned,
@@ -2679,9 +2678,7 @@ pub const DeclGen = struct {
                 const struct_obj = t.castTag(.@"struct").?.data;
 
                 if (struct_obj.layout == .Packed) {
-                    var buf: Type.Payload.Bits = undefined;
-                    const int_ty = struct_obj.packedIntegerType(target, &buf);
-                    const int_llvm_ty = try dg.lowerType(int_ty);
+                    const int_llvm_ty = try dg.lowerType(struct_obj.backing_int_ty);
                     gop.value_ptr.* = int_llvm_ty;
                     return int_llvm_ty;
                 }
@@ -3330,8 +3327,8 @@ pub const DeclGen = struct {
                 const struct_obj = tv.ty.castTag(.@"struct").?.data;
 
                 if (struct_obj.layout == .Packed) {
-                    const big_bits = struct_obj.packedIntegerBits(target);
-                    const int_llvm_ty = dg.context.intType(big_bits);
+                    const big_bits = struct_obj.backing_int_ty.bitSize(target);
+                    const int_llvm_ty = dg.context.intType(@intCast(c_uint, big_bits));
                     const fields = struct_obj.fields.values();
                     comptime assert(Type.packed_struct_layout_version == 2);
                     var running_int: *const llvm.Value = int_llvm_ty.constNull();
@@ -8243,8 +8240,8 @@ pub const FuncGen = struct {
             .Struct => {
                 if (result_ty.containerLayout() == .Packed) {
                     const struct_obj = result_ty.castTag(.@"struct").?.data;
-                    const big_bits = struct_obj.packedIntegerBits(target);
-                    const int_llvm_ty = self.dg.context.intType(big_bits);
+                    const big_bits = struct_obj.backing_int_ty.bitSize(target);
+                    const int_llvm_ty = self.dg.context.intType(@intCast(c_uint, big_bits));
                     const fields = struct_obj.fields.values();
                     comptime assert(Type.packed_struct_layout_version == 2);
                     var running_int: *const llvm.Value = int_llvm_ty.constNull();
diff --git a/src/print_zir.zig b/src/print_zir.zig
index 2b70799c367b798db5f77431ee7819863867319b..4bc96c42591cf6e01c66bde67c3305e21b76535d 100644
--- a/src/print_zir.zig
+++ b/src/print_zir.zig
@@ -1245,9 +1245,28 @@ 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 stream.print("{s}, {s}, ", .{
-            @tagName(small.name_strategy), @tagName(small.layout),
-        });
+
+        try stream.print("{s}, ", .{@tagName(small.name_strategy)});
+
+        if (small.layout == .Packed and small.has_backing_int) {
+            const backing_int_body_len = self.code.extra[extra_index];
+            extra_index += 1;
+            try stream.writeAll("Packed(");
+            if (backing_int_body_len == 0) {
+                const backing_int_ref = @intToEnum(Zir.Inst.Ref, self.code.extra[extra_index]);
+                extra_index += 1;
+                try self.writeInstRef(stream, backing_int_ref);
+            } else {
+                const body = self.code.extra[extra_index..][0..backing_int_body_len];
+                extra_index += backing_int_body_len;
+                self.indent += 2;
+                try self.writeBracedDecl(stream, body);
+                self.indent -= 2;
+            }
+            try stream.writeAll("), ");
+        } else {
+            try stream.print("{s}, ", .{@tagName(small.layout)});
+        }
 
         if (decls_len == 0) {
             try stream.writeAll("{}, ");
diff --git a/src/stage1/all_types.hpp b/src/stage1/all_types.hpp
index 4028c3872d0892058555b83749ef471ea23880d6..9f9a6151b8d57f97cd0babe142f849c4c93c9179 100644
--- a/src/stage1/all_types.hpp
+++ b/src/stage1/all_types.hpp
@@ -1116,6 +1116,7 @@ struct AstNodeContainerDecl {
     ContainerLayout layout;
 
     bool auto_enum, is_root; // union(enum)
+    bool unsupported_explicit_backing_int;
 };
 
 struct AstNodeErrorSetField {
diff --git a/src/stage1/analyze.cpp b/src/stage1/analyze.cpp
index 08aa8bbf062f31c3552f159b23cfba8bb0d3dfee..90173f384e9ec5c8adefa1959c1db10102f1f2b3 100644
--- a/src/stage1/analyze.cpp
+++ b/src/stage1/analyze.cpp
@@ -3034,6 +3034,12 @@ static Error resolve_struct_zero_bits(CodeGen *g, ZigType *struct_type) {
 
     AstNode *decl_node = struct_type->data.structure.decl_node;
 
+    if (decl_node->data.container_decl.unsupported_explicit_backing_int) {
+        add_node_error(g, decl_node, buf_create_from_str(
+            "the stage1 compiler does not support explicit backing integer types on packed structs"));
+        return ErrorSemanticAnalyzeFail;
+    }
+
     if (struct_type->data.structure.resolve_loop_flag_zero_bits) {
         if (struct_type->data.structure.resolve_status != ResolveStatusInvalid) {
             struct_type->data.structure.resolve_status = ResolveStatusInvalid;
diff --git a/src/stage1/ir.cpp b/src/stage1/ir.cpp
index e31715030cec1b3071cfc58ca5e75c4bf835c075..a5428945a99d9bd7dbcb7215aa8a99b375c6886d 100644
--- a/src/stage1/ir.cpp
+++ b/src/stage1/ir.cpp
@@ -18640,7 +18640,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, Scope *scope, AstNode *sour
                 result->special = ConstValSpecialStatic;
                 result->type = ir_type_info_get_type(ira, "Struct", nullptr);
 
-                ZigValue **fields = alloc_const_vals_ptrs(g, 4);
+                ZigValue **fields = alloc_const_vals_ptrs(g, 5);
                 result->data.x_struct.fields = fields;
 
                 // layout: ContainerLayout
@@ -18648,8 +18648,17 @@ static Error ir_make_type_info_value(IrAnalyze *ira, Scope *scope, AstNode *sour
                 fields[0]->special = ConstValSpecialStatic;
                 fields[0]->type = ir_type_info_get_type(ira, "ContainerLayout", nullptr);
                 bigint_init_unsigned(&fields[0]->data.x_enum_tag, type_entry->data.structure.layout);
+
+                // backing_integer: ?type
+                ensure_field_index(result->type, "backing_integer", 1);
+                fields[1]->special = ConstValSpecialStatic;
+                fields[1]->type = get_optional_type(g, g->builtin_types.entry_type);
+                // This is always null in stage1, as stage1 does not support explicit backing integers
+                // for packed structs.
+                fields[1]->data.x_optional = nullptr;
+
                 // fields: []Type.StructField
-                ensure_field_index(result->type, "fields", 1);
+                ensure_field_index(result->type, "fields", 2);
 
                 ZigType *type_info_struct_field_type = ir_type_info_get_type(ira, "StructField", nullptr);
                 if ((err = type_resolve(g, type_info_struct_field_type, ResolveStatusSizeKnown))) {
@@ -18663,7 +18672,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, Scope *scope, AstNode *sour
                 struct_field_array->data.x_array.special = ConstArraySpecialNone;
                 struct_field_array->data.x_array.data.s_none.elements = g->pass1_arena->allocate<ZigValue>(struct_field_count);
 
-                init_const_slice(g, fields[1], struct_field_array, 0, struct_field_count, false, nullptr);
+                init_const_slice(g, fields[2], struct_field_array, 0, struct_field_count, false, nullptr);
 
                 for (uint32_t struct_field_index = 0; struct_field_index < struct_field_count; struct_field_index++) {
                     TypeStructField *struct_field = type_entry->data.structure.fields[struct_field_index];
@@ -18710,18 +18719,18 @@ static Error ir_make_type_info_value(IrAnalyze *ira, Scope *scope, AstNode *sour
                     struct_field_val->parent.data.p_array.elem_index = struct_field_index;
                 }
                 // decls: []Type.Declaration
-                ensure_field_index(result->type, "decls", 2);
-                if ((err = ir_make_type_info_decls(ira, source_node, fields[2],
+                ensure_field_index(result->type, "decls", 3);
+                if ((err = ir_make_type_info_decls(ira, source_node, fields[3],
                                 type_entry->data.structure.decls_scope, false)))
                 {
                     return err;
                 }
 
                 // is_tuple: bool
-                ensure_field_index(result->type, "is_tuple", 3);
-                fields[3]->special = ConstValSpecialStatic;
-                fields[3]->type = g->builtin_types.entry_bool;
-                fields[3]->data.x_bool = is_tuple(type_entry);
+                ensure_field_index(result->type, "is_tuple", 4);
+                fields[4]->special = ConstValSpecialStatic;
+                fields[4]->type = g->builtin_types.entry_bool;
+                fields[4]->data.x_bool = is_tuple(type_entry);
 
                 break;
             }
@@ -19313,7 +19322,14 @@ static ZigType *type_info_to_type(IrAnalyze *ira, Scope *scope, AstNode *source_
             assert(layout_value->type == ir_type_info_get_type(ira, "ContainerLayout", nullptr));
             ContainerLayout layout = (ContainerLayout)bigint_as_u32(&layout_value->data.x_enum_tag);
 
-            ZigValue *fields_value = get_const_field(ira, source_node, payload, "fields", 1);
+            ZigType *tag_type = get_const_field_meta_type_optional(ira, source_node, payload, "backing_integer", 1);
+            if (tag_type != nullptr) {
+                ir_add_error_node(ira, source_node, buf_create_from_str(
+                    "the stage1 compiler does not support explicit backing integer types on packed structs"));
+                return ira->codegen->invalid_inst_gen->value->type;
+            }
+
+            ZigValue *fields_value = get_const_field(ira, source_node, payload, "fields", 2);
             if (fields_value == nullptr)
                 return ira->codegen->invalid_inst_gen->value->type;
             assert(fields_value->special == ConstValSpecialStatic);
@@ -19322,7 +19338,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, Scope *scope, AstNode *source_
             ZigValue *fields_len_value = fields_value->data.x_struct.fields[slice_len_index];
             size_t fields_len = bigint_as_usize(&fields_len_value->data.x_bigint);
 
-            ZigValue *decls_value = get_const_field(ira, source_node, payload, "decls", 2);
+            ZigValue *decls_value = get_const_field(ira, source_node, payload, "decls", 3);
             if (decls_value == nullptr)
                 return ira->codegen->invalid_inst_gen->value->type;
             assert(decls_value->special == ConstValSpecialStatic);
@@ -19335,7 +19351,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, Scope *scope, AstNode *source_
             }
 
             bool is_tuple;
-            if ((err = get_const_field_bool(ira, source_node, payload, "is_tuple", 3, &is_tuple)))
+            if ((err = get_const_field_bool(ira, source_node, payload, "is_tuple", 4, &is_tuple)))
                 return ira->codegen->invalid_inst_gen->value->type;
 
             ZigType *entry = new_type_table_entry(ZigTypeIdStruct);
diff --git a/src/stage1/parser.cpp b/src/stage1/parser.cpp
index fdc0777aff1c2938c575e8bf6a0f538d0cb2758b..bd778484cb9fedf017137a2a11891674b340afc7 100644
--- a/src/stage1/parser.cpp
+++ b/src/stage1/parser.cpp
@@ -2902,16 +2902,25 @@ static AstNode *ast_parse_container_decl_auto(ParseContext *pc) {
 }
 
 // ContainerDeclType
-//     <- KEYWORD_struct
+//     <- KEYWORD_struct (LPAREN Expr RPAREN)?
 //      / KEYWORD_enum (LPAREN Expr RPAREN)?
 //      / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
 //      / KEYWORD_opaque
 static AstNode *ast_parse_container_decl_type(ParseContext *pc) {
     TokenIndex first = eat_token_if(pc, TokenIdKeywordStruct);
     if (first != 0) {
+        bool explicit_backing_int = false;
+        if (eat_token_if(pc, TokenIdLParen) != 0) {
+            explicit_backing_int = true;
+            ast_expect(pc, ast_parse_expr);
+            expect_token(pc, TokenIdRParen);
+        }
         AstNode *res = ast_create_node(pc, NodeTypeContainerDecl, first);
         res->data.container_decl.init_arg_expr = nullptr;
         res->data.container_decl.kind = ContainerKindStruct;
+        // We want this to be an error in semantic analysis not parsing to make sharing
+        // the test suite between stage1 and self hosted easier.
+        res->data.container_decl.unsupported_explicit_backing_int = explicit_backing_int;
         return res;
     }
 
diff --git a/src/type.zig b/src/type.zig
index 85d77303c9e7c9c7677b9fbf066ff409a42162a7..1b71f4e9b1d90f29517c7a1bf21709714c27a2f7 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -3000,9 +3000,17 @@ pub const Type = extern union {
                     .lazy => |arena| return AbiAlignmentAdvanced{ .val = try Value.Tag.lazy_align.create(arena, ty) },
                 };
                 if (struct_obj.layout == .Packed) {
-                    var buf: Type.Payload.Bits = undefined;
-                    const int_ty = struct_obj.packedIntegerType(target, &buf);
-                    return AbiAlignmentAdvanced{ .scalar = int_ty.abiAlignment(target) };
+                    switch (strat) {
+                        .sema_kit => |sk| try sk.sema.resolveTypeLayout(sk.block, sk.src, ty),
+                        .lazy => |arena| {
+                            if (!struct_obj.haveLayout()) {
+                                return AbiAlignmentAdvanced{ .val = try Value.Tag.lazy_align.create(arena, ty) };
+                            }
+                        },
+                        .eager => {},
+                    }
+                    assert(struct_obj.haveLayout());
+                    return AbiAlignmentAdvanced{ .scalar = struct_obj.backing_int_ty.abiAlignment(target) };
                 }
 
                 const fields = ty.structFields();
@@ -3192,17 +3200,16 @@ pub const Type = extern union {
                 .Packed => {
                     const struct_obj = ty.castTag(.@"struct").?.data;
                     switch (strat) {
-                        .sema_kit => |sk| _ = try sk.sema.resolveTypeFields(sk.block, sk.src, ty),
+                        .sema_kit => |sk| try sk.sema.resolveTypeLayout(sk.block, sk.src, ty),
                         .lazy => |arena| {
-                            if (!struct_obj.haveFieldTypes()) {
+                            if (!struct_obj.haveLayout()) {
                                 return AbiSizeAdvanced{ .val = try Value.Tag.lazy_size.create(arena, ty) };
                             }
                         },
                         .eager => {},
                     }
-                    var buf: Type.Payload.Bits = undefined;
-                    const int_ty = struct_obj.packedIntegerType(target, &buf);
-                    return AbiSizeAdvanced{ .scalar = int_ty.abiSize(target) };
+                    assert(struct_obj.haveLayout());
+                    return AbiSizeAdvanced{ .scalar = struct_obj.backing_int_ty.abiSize(target) };
                 },
                 else => {
                     switch (strat) {
diff --git a/test/behavior.zig b/test/behavior.zig
index fee61f5e0921ad3809aa3927a63fa8df402b3e52..e9c4ec779bb5e6bc4dca8ea89eccddb61be1ab5a 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -165,6 +165,7 @@ test {
 
     if (builtin.zig_backend != .stage1) {
         _ = @import("behavior/decltest.zig");
+        _ = @import("behavior/packed_struct_explicit_backing_int.zig");
     }
 
     if (builtin.os.tag != .wasi) {
diff --git a/test/behavior/packed_struct_explicit_backing_int.zig b/test/behavior/packed_struct_explicit_backing_int.zig
new file mode 100644
index 0000000000000000000000000000000000000000..165e94fd4e731c476264d22b01cfbccd415640f2
--- /dev/null
+++ b/test/behavior/packed_struct_explicit_backing_int.zig
@@ -0,0 +1,53 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const assert = std.debug.assert;
+const expectEqual = std.testing.expectEqual;
+const native_endian = builtin.cpu.arch.endian();
+
+test "packed struct explicit backing integer" {
+    assert(builtin.zig_backend != .stage1);
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
+    const S1 = packed struct { a: u8, b: u8, c: u8 };
+
+    const S2 = packed struct(i24) { d: u8, e: u8, f: u8 };
+
+    const S3 = packed struct { x: S1, y: S2 };
+    const S3Padded = packed struct(u64) { s3: S3, pad: u16 };
+
+    try expectEqual(48, @bitSizeOf(S3));
+    try expectEqual(@sizeOf(u48), @sizeOf(S3));
+
+    try expectEqual(3, @offsetOf(S3, "y"));
+    try expectEqual(24, @bitOffsetOf(S3, "y"));
+
+    if (native_endian == .Little) {
+        const s3 = @bitCast(S3Padded, @as(u64, 0xe952d5c71ff4)).s3;
+        try expectEqual(@as(u8, 0xf4), s3.x.a);
+        try expectEqual(@as(u8, 0x1f), s3.x.b);
+        try expectEqual(@as(u8, 0xc7), s3.x.c);
+        try expectEqual(@as(u8, 0xd5), s3.y.d);
+        try expectEqual(@as(u8, 0x52), s3.y.e);
+        try expectEqual(@as(u8, 0xe9), s3.y.f);
+    }
+
+    const S4 = packed struct { a: i32, b: i8 };
+    const S5 = packed struct(u80) { a: i32, b: i8, c: S4 };
+    const S6 = packed struct(i80) { a: i32, b: S4, c: i8 };
+
+    const expectedBitSize = 80;
+    const expectedByteSize = @sizeOf(u80);
+    try expectEqual(expectedBitSize, @bitSizeOf(S5));
+    try expectEqual(expectedByteSize, @sizeOf(S5));
+    try expectEqual(expectedBitSize, @bitSizeOf(S6));
+    try expectEqual(expectedByteSize, @sizeOf(S6));
+
+    try expectEqual(5, @offsetOf(S5, "c"));
+    try expectEqual(40, @bitOffsetOf(S5, "c"));
+    try expectEqual(9, @offsetOf(S6, "c"));
+    try expectEqual(72, @bitOffsetOf(S6, "c"));
+}
diff --git a/test/behavior/type_info.zig b/test/behavior/type_info.zig
index b1012e69c8b714a1831be4e0a8beedbf8e96bb58..968c3e7490b70b1700607f5fb2c6199d539694a3 100644
--- a/test/behavior/type_info.zig
+++ b/test/behavior/type_info.zig
@@ -293,6 +293,7 @@ test "type info: struct info" {
 fn testStruct() !void {
     const unpacked_struct_info = @typeInfo(TestStruct);
     try expect(unpacked_struct_info.Struct.is_tuple == false);
+    try expect(unpacked_struct_info.Struct.backing_integer == null);
     try expect(unpacked_struct_info.Struct.fields[0].alignment == @alignOf(u32));
     try expect(@ptrCast(*const u32, unpacked_struct_info.Struct.fields[0].default_value.?).* == 4);
     try expect(mem.eql(u8, "foobar", @ptrCast(*const *const [6:0]u8, unpacked_struct_info.Struct.fields[1].default_value.?).*));
@@ -315,6 +316,7 @@ fn testPackedStruct() !void {
     try expect(struct_info == .Struct);
     try expect(struct_info.Struct.is_tuple == false);
     try expect(struct_info.Struct.layout == .Packed);
+    try expect(struct_info.Struct.backing_integer == u128);
     try expect(struct_info.Struct.fields.len == 4);
     try expect(struct_info.Struct.fields[0].alignment == 0);
     try expect(struct_info.Struct.fields[2].field_type == f32);
@@ -326,7 +328,7 @@ fn testPackedStruct() !void {
 }
 
 const TestPackedStruct = packed struct {
-    fieldA: usize,
+    fieldA: u64,
     fieldB: void,
     fieldC: f32,
     fieldD: u32 = 4,
diff --git a/test/cases/compile_errors/packed_struct_backing_int_wrong.zig b/test/cases/compile_errors/packed_struct_backing_int_wrong.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cd1b4ec11cb73b99b3625e3fcc09aea377d29175
--- /dev/null
+++ b/test/cases/compile_errors/packed_struct_backing_int_wrong.zig
@@ -0,0 +1,55 @@
+export fn entry1() void {
+    _ = @sizeOf(packed struct(u32) {
+        x: u1,
+        y: u24,
+        z: u4,
+    });
+}
+export fn entry2() void {
+    _ = @sizeOf(packed struct(i31) {
+        x: u4,
+        y: u24,
+        z: u4,
+    });
+}
+
+export fn entry3() void {
+    _ = @sizeOf(packed struct(void) {
+        x: void,
+    });
+}
+
+export fn entry4() void {
+    _ = @sizeOf(packed struct(void) {});
+}
+
+export fn entry5() void {
+    _ = @sizeOf(packed struct(noreturn) {});
+}
+
+export fn entry6() void {
+    _ = @sizeOf(packed struct(f64) {
+        x: u32,
+        y: f32,
+    });
+}
+
+export fn entry7() void {
+    _ = @sizeOf(packed struct(*u32) {
+        x: u4,
+        y: u24,
+        z: u4,
+    });
+}
+
+// error
+// backend=llvm
+// target=native
+//
+// :2:31: error: backing integer type 'u32' has bit size 32 but the struct fields have a total bit size of 29
+// :9:31: error: backing integer type 'i31' has bit size 31 but the struct fields have a total bit size of 32
+// :17:31: error: expected backing integer type, found 'void'
+// :23:31: error: expected backing integer type, found 'void'
+// :27:31: error: expected backing integer type, found 'noreturn'
+// :31:31: error: expected backing integer type, found 'f64'
+// :38:31: error: expected backing integer type, found '*u32'
-- 
2.54.0


From 40447b25e87ece9eee2d83d1c78c365ad7ab40f1 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 10 Aug 2022 10:59:26 +0300
Subject: [PATCH 065/290] Sema: fix expansion of repeated value

Closes #12386
---
 src/Sema.zig           |  5 ++++-
 test/behavior/eval.zig | 17 +++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index acdce0e9b09739e52f83b7bf3eb62f6ed3406ef3..fc8a182508acde178b711e8eb338be64b41bd21d 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -23990,7 +23990,10 @@ fn beginComptimePtrMutation(
                                 const array_len_including_sentinel =
                                     try sema.usizeCast(block, src, parent.ty.arrayLenIncludingSentinel());
                                 const elems = try arena.alloc(Value, array_len_including_sentinel);
-                                mem.set(Value, elems, repeated_val);
+                                if (elems.len > 0) elems[0] = repeated_val;
+                                for (elems[1..]) |*elem| {
+                                    elem.* = try repeated_val.copy(arena);
+                                }
 
                                 val_ptr.* = try Value.Tag.aggregate.create(arena, elems);
 
diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
index d2a75e18dfe158c4880f832d754c6d1b307f51a9..8a872f63781374b4edd56224b6ab1586369ca1e7 100644
--- a/test/behavior/eval.zig
+++ b/test/behavior/eval.zig
@@ -1293,3 +1293,20 @@ test "mutate through pointer-like optional at comptime" {
         try expect(payload_ptr.*.* == 16);
     }
 }
+
+test "repeated value is correctly expanded" {
+    const S = struct { x: [4]i8 = std.mem.zeroes([4]i8) };
+    const M = struct { x: [4]S = std.mem.zeroes([4]S) };
+
+    comptime {
+        var res = M{};
+        for (.{ 1, 2, 3 }) |i| res.x[i].x[i] = i;
+
+        try expectEqual(M{ .x = .{
+            .{ .x = .{ 0, 0, 0, 0 } },
+            .{ .x = .{ 0, 1, 0, 0 } },
+            .{ .x = .{ 0, 0, 2, 0 } },
+            .{ .x = .{ 0, 0, 0, 3 } },
+        } }, res);
+    }
+}
-- 
2.54.0


From 8fd20a5eb015fda4b27cef14c9e3149575861994 Mon Sep 17 00:00:00 2001
From: zooster <r00ster91@proton.me>
Date: Wed, 10 Aug 2022 18:40:18 +0200
Subject: [PATCH 066/290] fix: disallow newline in char literal

---
 lib/std/zig/tokenizer.zig | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/lib/std/zig/tokenizer.zig b/lib/std/zig/tokenizer.zig
index 8a0885ab7b712cfd32e708a53cd243f3f1cefe42..5c6d7324193148a39fa6e8e62f0a7c11c89f1680 100644
--- a/lib/std/zig/tokenizer.zig
+++ b/lib/std/zig/tokenizer.zig
@@ -797,6 +797,10 @@ pub const Tokenizer = struct {
                         remaining_code_units = 3;
                         state = .char_literal_unicode;
                     },
+                    '\n' => {
+                        result.tag = .invalid;
+                        break;
+                    },
                     else => {
                         state = .char_literal_end;
                     },
@@ -1507,6 +1511,20 @@ test "tokenizer - code point literal with hex escape" {
     , &.{ .invalid, .invalid });
 }
 
+test "tokenizer - newline in char literal" {
+    try testTokenize(
+        \\'
+        \\'
+    , &.{ .invalid, .invalid });
+}
+
+test "tokenizer - newline in string literal" {
+    try testTokenize(
+        \\"
+        \\"
+    , &.{ .invalid, .string_literal });
+}
+
 test "tokenizer - code point literal with unicode escapes" {
     // Valid unicode escapes
     try testTokenize(
-- 
2.54.0


From 0e118ed0aca3d852d2499fa37d04adef62b03ead Mon Sep 17 00:00:00 2001
From: LeRoyce Pearson <contact@leroycepearson.dev>
Date: Tue, 9 Aug 2022 16:08:59 -0600
Subject: [PATCH 067/290] stage2: add compile error for shlExact overflow

- moves a stage1 test case and makes it target `llvm` backend instead
  of `stage1` backend
---
 src/Sema.zig                                         | 12 +++++-------
 .../{stage1/obj => }/shlExact_shifts_out_1_bits.zig  |  4 ++--
 2 files changed, 7 insertions(+), 9 deletions(-)
 rename test/cases/compile_errors/{stage1/obj => }/shlExact_shifts_out_1_bits.zig (60%)

diff --git a/src/Sema.zig b/src/Sema.zig
index fc8a182508acde178b711e8eb338be64b41bd21d..4fefff7c26a17f2ad234d99a8f285ac5576b91ea 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -10269,16 +10269,14 @@ fn zirShl(
 
         const val = switch (air_tag) {
             .shl_exact => val: {
-                const shifted = try lhs_val.shl(rhs_val, lhs_ty, sema.arena, target);
+                const shifted = try lhs_val.shlWithOverflow(rhs_val, lhs_ty, sema.arena, target);
                 if (scalar_ty.zigTypeTag() == .ComptimeInt) {
-                    break :val shifted;
+                    break :val shifted.wrapped_result;
                 }
-                const int_info = scalar_ty.intInfo(target);
-                const truncated = try shifted.intTrunc(lhs_ty, sema.arena, int_info.signedness, int_info.bits, target);
-                if (try sema.compare(block, src, truncated, .eq, shifted, lhs_ty)) {
-                    break :val shifted;
+                if (shifted.overflowed.compareWithZero(.eq)) {
+                    break :val shifted.wrapped_result;
                 }
-                return sema.addConstUndef(lhs_ty);
+                return sema.fail(block, src, "operation caused overflow", .{});
             },
 
             .shl_sat => if (scalar_ty.zigTypeTag() == .ComptimeInt)
diff --git a/test/cases/compile_errors/stage1/obj/shlExact_shifts_out_1_bits.zig b/test/cases/compile_errors/shlExact_shifts_out_1_bits.zig
similarity index 60%
rename from test/cases/compile_errors/stage1/obj/shlExact_shifts_out_1_bits.zig
rename to test/cases/compile_errors/shlExact_shifts_out_1_bits.zig
index 953c5fec50199c59dd2669b4e8601d026f4d70f8..b2ab45a8e9233958df13e7a60867ca77d0af1914 100644
--- a/test/cases/compile_errors/stage1/obj/shlExact_shifts_out_1_bits.zig
+++ b/test/cases/compile_errors/shlExact_shifts_out_1_bits.zig
@@ -4,7 +4,7 @@ comptime {
 }
 
 // error
-// backend=stage1
+// backend=llvm
 // target=native
 //
-// tmp.zig:2:15: error: operation caused overflow
+// :2:15: error: operation caused overflow
-- 
2.54.0


From e218b7ea0c2a907c5728006b38e7ca492e19ccb6 Mon Sep 17 00:00:00 2001
From: InKryption <inkryption07@gmail.com>
Date: Wed, 10 Aug 2022 17:09:27 +0200
Subject: [PATCH 068/290] stage2: add compile error for invalid null/undefined
 pointer cast

---
 src/Sema.zig                                          |  9 +++++++++
 .../compile_errors/compile_time_null_ptr_cast.zig     | 11 +++++++++++
 .../compile_errors/compile_time_undef_ptr_cast.zig    | 11 +++++++++++
 3 files changed, 31 insertions(+)
 create mode 100644 test/cases/compile_errors/compile_time_null_ptr_cast.zig
 create mode 100644 test/cases/compile_errors/compile_time_undef_ptr_cast.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index 4fefff7c26a17f2ad234d99a8f285ac5576b91ea..fe19de39ddd9b5e8a97ce3bf56aa3417d6da26b0 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -17272,6 +17272,15 @@ fn zirPtrCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
     else
         operand;
 
+    if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |operand_val| {
+        if (!dest_ty.ptrAllowsZero() and operand_val.isUndef()) {
+            return sema.failWithUseOfUndef(block, operand_src);
+        }
+        if (!dest_ty.ptrAllowsZero() and operand_val.isNull()) {
+            return sema.fail(block, operand_src, "null pointer casted to type {}", .{dest_ty.fmt(sema.mod)});
+        }
+    }
+
     const dest_elem_ty = dest_ty.elemType2();
     try sema.resolveTypeLayout(block, dest_ty_src, dest_elem_ty);
     const dest_align = dest_ty.ptrAlignment(target);
diff --git a/test/cases/compile_errors/compile_time_null_ptr_cast.zig b/test/cases/compile_errors/compile_time_null_ptr_cast.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d3750c865407633c2b40c7fb04d8ee1b9113b836
--- /dev/null
+++ b/test/cases/compile_errors/compile_time_null_ptr_cast.zig
@@ -0,0 +1,11 @@
+comptime {
+    var opt_ptr: ?*i32 = null;
+    const ptr = @ptrCast(*i32, opt_ptr);
+    _ = ptr;
+}
+
+// error
+// backend=llvm
+// target=native
+//
+// :3:32: error: null pointer casted to type *i32
diff --git a/test/cases/compile_errors/compile_time_undef_ptr_cast.zig b/test/cases/compile_errors/compile_time_undef_ptr_cast.zig
new file mode 100644
index 0000000000000000000000000000000000000000..14edd293de286852b7e5a0bf61d77ccb763e3c5a
--- /dev/null
+++ b/test/cases/compile_errors/compile_time_undef_ptr_cast.zig
@@ -0,0 +1,11 @@
+comptime {
+    var undef_ptr: *i32 = undefined;
+    const ptr = @ptrCast(*i32, undef_ptr);
+    _ = ptr;
+}
+
+// error
+// backend=llvm
+// target=native
+//
+// :3:32: error: use of undefined value here causes undefined behavior
-- 
2.54.0


From 45c444ff18b43d30a7277e346174ba6eca4a6193 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Thu, 11 Aug 2022 00:06:31 +0200
Subject: [PATCH 069/290] macho: allow unaligned offsets in object files

---
 src/link/MachO/Object.zig | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index 996a85ed4b75a732c5f5a995f327e62d0a0e4374..098917e81f60002c473f56d6e371294b626218ab 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -99,10 +99,11 @@ pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch)
             },
             .SYMTAB => {
                 const symtab = cmd.cast(macho.symtab_command).?;
-                self.in_symtab = @ptrCast(
-                    [*]const macho.nlist_64,
-                    @alignCast(@alignOf(macho.nlist_64), &self.contents[symtab.symoff]),
-                )[0..symtab.nsyms];
+                // Sadly, SYMTAB may be at an unaligned offset within the object file.
+                self.in_symtab = @alignCast(@alignOf(macho.nlist_64), @ptrCast(
+                    [*]align(1) const macho.nlist_64,
+                    self.contents.ptr + symtab.symoff,
+                ))[0..symtab.nsyms];
                 self.in_strtab = self.contents[symtab.stroff..][0..symtab.strsize];
                 try self.symtab.appendSlice(allocator, self.in_symtab);
             },
@@ -302,10 +303,10 @@ pub fn splitIntoAtomsOneShot(self: *Object, macho_file: *MachO, object_id: u32)
         const code: ?[]const u8 = if (!sect.isZerofill()) try self.getSectionContents(sect) else null;
 
         // Read section's list of relocations
-        const relocs = @ptrCast(
-            [*]const macho.relocation_info,
-            @alignCast(@alignOf(macho.relocation_info), &self.contents[sect.reloff]),
-        )[0..sect.nreloc];
+        const relocs = @alignCast(@alignOf(macho.relocation_info), @ptrCast(
+            [*]align(1) const macho.relocation_info,
+            self.contents.ptr + sect.reloff,
+        ))[0..sect.nreloc];
 
         // Symbols within this section only.
         const filtered_syms = filterSymbolsByAddress(
@@ -548,10 +549,10 @@ pub fn parseDataInCode(self: Object) ?[]const macho.data_in_code_entry {
             .DATA_IN_CODE => {
                 const dice = cmd.cast(macho.linkedit_data_command).?;
                 const ndice = @divExact(dice.datasize, @sizeOf(macho.data_in_code_entry));
-                return @ptrCast(
-                    [*]const macho.data_in_code_entry,
-                    @alignCast(@alignOf(macho.data_in_code_entry), &self.contents[dice.dataoff]),
-                )[0..ndice];
+                return @alignCast(@alignOf(macho.data_in_code_entry), @ptrCast(
+                    [*]align(1) const macho.data_in_code_entry,
+                    self.contents.ptr + dice.dataoff,
+                ))[0..ndice];
             },
             else => {},
         }
-- 
2.54.0


From 173952f4b82713712fde873ffa31decb53ad4450 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 14:37:49 -0700
Subject: [PATCH 070/290] disable failing behavior test

see tracking issue #12396
---
 test/behavior/cast.zig | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index e899def4aa9db1751d8bdaaa18d1f12aae4bb7b8..ac3a4daeab443157dd0f7e640739af680dd68f82 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -1431,6 +1431,11 @@ test "coerce between pointers of compatible differently-named floats" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
 
+    if (builtin.os.tag == .windows) {
+        // https://github.com/ziglang/zig/issues/12396
+        return error.SkipZigTest;
+    }
+
     const F = switch (@typeInfo(c_longdouble).Float.bits) {
         16 => f16,
         32 => f32,
-- 
2.54.0


From 9656ec271c3ca1009c48c26a9a5c407d98bbcacd Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 16:24:04 -0700
Subject: [PATCH 071/290] better default for use_stage1 when -ofmt=c is
 provided

---
 src/Compilation.zig | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index d3816e542cfecf8969f9b37ed9975a214e5851e3..af39154a3f233e43fbe7c80c19599f43312f4f08 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -1041,6 +1041,10 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
                 }
             }
 
+            // If LLVM does not support the target, then we can't use it.
+            if (!target_util.hasLlvmSupport(options.target, ofmt))
+                break :blk false;
+
             break :blk build_options.is_stage1;
         };
 
-- 
2.54.0


From e8d02c5b90c0833401a70cc797a28da57a356927 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 14:49:06 -0700
Subject: [PATCH 072/290] add ZIG_GLOBAL_CACHE_DIR env var

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

diff --git a/src/main.zig b/src/main.zig
index 0c6e4a63a3ab978ed59600c003b0ba7740cb3051..c103cddcd45c6504b4354cfcaaf0fad21bdd1184 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -718,7 +718,7 @@ fn buildOutputType(
     var test_filter: ?[]const u8 = null;
     var test_name_prefix: ?[]const u8 = null;
     var override_local_cache_dir: ?[]const u8 = try optionalStringEnvVar(arena, "ZIG_LOCAL_CACHE_DIR");
-    var override_global_cache_dir: ?[]const u8 = null;
+    var override_global_cache_dir: ?[]const u8 = try optionalStringEnvVar(arena, "ZIG_GLOBAL_CACHE_DIR");
     var override_lib_dir: ?[]const u8 = try optionalStringEnvVar(arena, "ZIG_LIB_DIR");
     var main_pkg_path: ?[]const u8 = null;
     var clang_preprocessor_mode: Compilation.ClangPreprocessorMode = .no;
-- 
2.54.0


From d267f0f968c97d77d8434ef9918c71fb4c11f45d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 14:08:09 -0700
Subject: [PATCH 073/290] LLVM: respect linksection for exported variables

---
 src/Sema.zig                  |  1 +
 src/codegen/llvm.zig          | 11 +++++++++++
 src/codegen/llvm/bindings.zig |  3 +++
 3 files changed, 15 insertions(+)

diff --git a/src/Sema.zig b/src/Sema.zig
index 9aaa761a035053235c71fb0079094a5fd1850f7f..f9b37f5b495eb26d578978a14e95cf9e14d1253d 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -6351,6 +6351,7 @@ fn instantiateGenericCall(
         new_decl.is_exported = fn_owner_decl.is_exported;
         new_decl.has_align = fn_owner_decl.has_align;
         new_decl.has_linksection_or_addrspace = fn_owner_decl.has_linksection_or_addrspace;
+        new_decl.@"linksection" = fn_owner_decl.@"linksection";
         new_decl.@"addrspace" = fn_owner_decl.@"addrspace";
         new_decl.zir_decl_index = fn_owner_decl.zir_decl_index;
         new_decl.alive = true; // This Decl is called at runtime.
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 6d2922ea3fe557dd2411dba5539fd333331e07ad..aa846f4247e2b1c406b0edece45243b252ffdf0d 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -722,6 +722,10 @@ pub const Object = struct {
             dg.addFnAttrString(llvm_func, "no-stack-arg-probe", "");
         }
 
+        if (decl.@"linksection") |section| {
+            llvm_func.setSection(section);
+        }
+
         // Remove all the basic blocks of a function in order to start over, generating
         // LLVM IR from an empty function body.
         while (llvm_func.getFirstBasicBlock()) |bb| {
@@ -1107,6 +1111,11 @@ pub const Object = struct {
                 .hidden => llvm_global.setVisibility(.Hidden),
                 .protected => llvm_global.setVisibility(.Protected),
             }
+            if (exports[0].options.section) |section| {
+                const section_z = try module.gpa.dupeZ(u8, section);
+                defer module.gpa.free(section_z);
+                llvm_global.setSection(section_z);
+            }
             if (decl.val.castTag(.variable)) |variable| {
                 if (variable.data.is_threadlocal) {
                     llvm_global.setThreadLocalMode(.GeneralDynamicTLSModel);
@@ -2183,6 +2192,7 @@ pub const DeclGen = struct {
             const target = dg.module.getTarget();
             var global = try dg.resolveGlobalDecl(decl_index);
             global.setAlignment(decl.getAlignment(target));
+            if (decl.@"linksection") |section| global.setSection(section);
             assert(decl.has_tv);
             const init_val = if (decl.val.castTag(.variable)) |payload| init_val: {
                 const variable = payload.data;
@@ -2216,6 +2226,7 @@ pub const DeclGen = struct {
                     new_global.setLinkage(global.getLinkage());
                     new_global.setUnnamedAddr(global.getUnnamedAddress());
                     new_global.setAlignment(global.getAlignment());
+                    if (decl.@"linksection") |section| new_global.setSection(section);
                     new_global.setInitializer(llvm_init);
                     // replaceAllUsesWith requires the type to be unchanged. So we bitcast
                     // the new global to the old type and use that as the thing to replace
diff --git a/src/codegen/llvm/bindings.zig b/src/codegen/llvm/bindings.zig
index e4357b80609bf5c1b4b483b2a9a4b11ec25e8fb8..baf67b15aa42b7563cacaf5d1a1a69f07b790efd 100644
--- a/src/codegen/llvm/bindings.zig
+++ b/src/codegen/llvm/bindings.zig
@@ -126,6 +126,9 @@ pub const Value = opaque {
     pub const setThreadLocalMode = LLVMSetThreadLocalMode;
     extern fn LLVMSetThreadLocalMode(Global: *const Value, Mode: ThreadLocalMode) void;
 
+    pub const setSection = LLVMSetSection;
+    extern fn LLVMSetSection(Global: *const Value, Section: [*:0]const u8) void;
+
     pub const deleteGlobal = LLVMDeleteGlobal;
     extern fn LLVMDeleteGlobal(GlobalVar: *const Value) void;
 
-- 
2.54.0


From 3c4e9b5983e49fa3179adec8e41e3198f3fd66ae Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 8 Aug 2022 15:54:07 -0700
Subject: [PATCH 074/290] disable failing behavior test

See #12360
---
 test/behavior/type.zig | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/behavior/type.zig b/test/behavior/type.zig
index 4aec553527fa5ffc5b73dc7e7e4a43ef6e9cc7d5..8cef86b5dd36c88ae30afa8ddcc0cf951314b16a 100644
--- a/test/behavior/type.zig
+++ b/test/behavior/type.zig
@@ -513,6 +513,11 @@ test "Type.Fn" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
 
+    if (true) {
+        // https://github.com/ziglang/zig/issues/12360
+        return error.SkipZigTest;
+    }
+
     const some_opaque = opaque {};
     const some_ptr = *some_opaque;
     const T = fn (c_int, some_ptr) callconv(.C) void;
-- 
2.54.0


From 4d7f5a1917f569506682bbb6ee5af672ab1fd8e8 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 7 Aug 2022 22:48:34 -0700
Subject: [PATCH 075/290] stage2: fix crash with comptime vector reduce

---
 src/value.zig            | 10 ++++++++++
 test/behavior/vector.zig | 17 +++++++++++++++++
 2 files changed, 27 insertions(+)

diff --git a/src/value.zig b/src/value.zig
index f156651eaac605546291e5edb6b3bdbf04bff648..677a459afe77a4af576060241d89dae2069a4e55 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -1194,6 +1194,16 @@ pub const Value = extern union {
         return switch (self.tag()) {
             .bool_true, .one => true,
             .bool_false, .zero => false,
+            .int_u64 => switch (self.castTag(.int_u64).?.data) {
+                0 => false,
+                1 => true,
+                else => unreachable,
+            },
+            .int_i64 => switch (self.castTag(.int_i64).?.data) {
+                0 => false,
+                1 => true,
+                else => unreachable,
+            },
             else => unreachable,
         };
     }
diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig
index c13db2e262712525c2826819d33ed2e5e96f3774..863a8030c02671921db812e7074b84b96178798f 100644
--- a/test/behavior/vector.zig
+++ b/test/behavior/vector.zig
@@ -807,6 +807,23 @@ test "vector reduce operation" {
     comptime try S.doTheTest();
 }
 
+test "vector @reduce comptime" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
+    const value = @Vector(4, i32){ 1, -1, 1, -1 };
+    const result = value > @splat(4, @as(i32, 0));
+    // result is { true, false, true, false };
+    comptime try expect(@TypeOf(result) == @Vector(4, bool));
+    const is_all_true = @reduce(.And, result);
+    comptime try expect(@TypeOf(is_all_true) == bool);
+    try expect(is_all_true == false);
+}
+
 test "mask parameter of @shuffle is comptime scope" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-- 
2.54.0


From 74673b7f69b27dc39a653f92eb58bba71e289f39 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 10 Aug 2022 22:45:46 +0300
Subject: [PATCH 076/290] stage2 llvm: implement more C ABI

---
 src/codegen/llvm.zig          | 124 +++++++++++++++++++++++++++++++---
 src/codegen/llvm/bindings.zig |   3 +
 test/standalone.zig           |   2 +-
 3 files changed, 119 insertions(+), 10 deletions(-)

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index aa846f4247e2b1c406b0edece45243b252ffdf0d..38f7d285aed18678a4340e7a47cd5fe395639bcb 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -921,6 +921,40 @@ pub const Object = struct {
                     };
                     try args.append(loaded);
                 },
+                .multiple_llvm_float => {
+                    const llvm_floats = it.llvm_types_buffer[0..it.llvm_types_len];
+                    const param_ty = fn_info.param_types[it.zig_index - 1];
+                    const param_llvm_ty = try dg.lowerType(param_ty);
+                    const param_alignment = param_ty.abiAlignment(target);
+                    const arg_ptr = buildAllocaInner(builder, llvm_func, false, param_llvm_ty);
+                    arg_ptr.setAlignment(param_alignment);
+                    var field_types_buf: [8]*const llvm.Type = undefined;
+                    const field_types = field_types_buf[0..llvm_floats.len];
+                    for (llvm_floats) |float_bits, i| {
+                        switch (float_bits) {
+                            64 => field_types[i] = dg.context.doubleType(),
+                            80 => field_types[i] = dg.context.x86FP80Type(),
+                            else => {},
+                        }
+                    }
+                    const ints_llvm_ty = dg.context.structType(field_types.ptr, @intCast(c_uint, field_types.len), .False);
+                    const casted_ptr = builder.buildBitCast(arg_ptr, ints_llvm_ty.pointerType(0), "");
+                    for (llvm_floats) |_, i_usize| {
+                        const i = @intCast(c_uint, i_usize);
+                        const param = llvm_func.getParam(i);
+                        const field_ptr = builder.buildStructGEP(casted_ptr, i, "");
+                        const store_inst = builder.buildStore(param, field_ptr);
+                        store_inst.setAlignment(target.cpu.arch.ptrBitWidth() / 8);
+                    }
+
+                    const is_by_ref = isByRef(param_ty);
+                    const loaded = if (is_by_ref) arg_ptr else l: {
+                        const load_inst = builder.buildLoad(arg_ptr, "");
+                        load_inst.setAlignment(param_alignment);
+                        break :l load_inst;
+                    };
+                    try args.append(loaded);
+                },
                 .as_u16 => {
                     const param = llvm_func.getParam(llvm_arg_i);
                     llvm_arg_i += 1;
@@ -2341,6 +2375,14 @@ pub const DeclGen = struct {
             dg.addFnAttr(llvm_fn, "noreturn");
         }
 
+        var llvm_arg_i = @as(c_uint, @boolToInt(sret)) + @boolToInt(err_return_tracing);
+        var it = iterateParamTypes(dg, fn_info);
+        while (it.next()) |_| : (llvm_arg_i += 1) {
+            if (!it.byval_attr) continue;
+            const param = llvm_fn.getParam(llvm_arg_i);
+            llvm_fn.addByValAttr(llvm_arg_i, param.typeOf().getElementType());
+        }
+
         return llvm_fn;
     }
 
@@ -2894,6 +2936,18 @@ pub const DeclGen = struct {
                     llvm_params.appendAssumeCapacity(big_int_ty);
                 }
             },
+            .multiple_llvm_float => {
+                const llvm_ints = it.llvm_types_buffer[0..it.llvm_types_len];
+                try llvm_params.ensureUnusedCapacity(it.llvm_types_len);
+                for (llvm_ints) |float_bits| {
+                    const float_ty = switch (float_bits) {
+                        64 => dg.context.doubleType(),
+                        80 => dg.context.x86FP80Type(),
+                        else => unreachable,
+                    };
+                    llvm_params.appendAssumeCapacity(float_ty);
+                }
+            },
             .as_u16 => {
                 try llvm_params.append(dg.context.intType(16));
             },
@@ -4402,6 +4456,39 @@ pub const FuncGen = struct {
                     llvm_args.appendAssumeCapacity(load_inst);
                 }
             },
+            .multiple_llvm_float => {
+                const arg = args[it.zig_index - 1];
+                const param_ty = self.air.typeOf(arg);
+                const llvm_floats = it.llvm_types_buffer[0..it.llvm_types_len];
+                const llvm_arg = try self.resolveInst(arg);
+                const is_by_ref = isByRef(param_ty);
+                const arg_ptr = if (is_by_ref) llvm_arg else p: {
+                    const p = self.buildAlloca(llvm_arg.typeOf());
+                    const store_inst = self.builder.buildStore(llvm_arg, p);
+                    store_inst.setAlignment(param_ty.abiAlignment(target));
+                    break :p p;
+                };
+
+                var field_types_buf: [8]*const llvm.Type = undefined;
+                const field_types = field_types_buf[0..llvm_floats.len];
+                for (llvm_floats) |float_bits, i| {
+                    switch (float_bits) {
+                        64 => field_types[i] = self.dg.context.doubleType(),
+                        80 => field_types[i] = self.dg.context.x86FP80Type(),
+                        else => {},
+                    }
+                }
+                const ints_llvm_ty = self.dg.context.structType(field_types.ptr, @intCast(c_uint, field_types.len), .False);
+                const casted_ptr = self.builder.buildBitCast(arg_ptr, ints_llvm_ty.pointerType(0), "");
+                try llvm_args.ensureUnusedCapacity(it.llvm_types_len);
+                for (llvm_floats) |_, i_usize| {
+                    const i = @intCast(c_uint, i_usize);
+                    const field_ptr = self.builder.buildStructGEP(casted_ptr, i, "");
+                    const load_inst = self.builder.buildLoad(field_ptr, "");
+                    load_inst.setAlignment(target.cpu.arch.ptrBitWidth() / 8);
+                    llvm_args.appendAssumeCapacity(load_inst);
+                }
+            },
             .as_u16 => {
                 const arg = args[it.zig_index - 1];
                 const llvm_arg = try self.resolveInst(arg);
@@ -9367,16 +9454,20 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*const llvm.
                                     llvm_types_index += 1;
                                 },
                                 .sse => {
-                                    @panic("TODO");
+                                    llvm_types_buffer[llvm_types_index] = dg.context.doubleType();
+                                    llvm_types_index += 1;
                                 },
                                 .sseup => {
-                                    @panic("TODO");
+                                    llvm_types_buffer[llvm_types_index] = dg.context.doubleType();
+                                    llvm_types_index += 1;
                                 },
                                 .x87 => {
-                                    @panic("TODO");
+                                    llvm_types_buffer[llvm_types_index] = dg.context.x86FP80Type();
+                                    llvm_types_index += 1;
                                 },
                                 .x87up => {
-                                    @panic("TODO");
+                                    llvm_types_buffer[llvm_types_index] = dg.context.x86FP80Type();
+                                    llvm_types_index += 1;
                                 },
                                 .complex_x87 => {
                                     @panic("TODO");
@@ -9422,6 +9513,7 @@ const ParamTypeIterator = struct {
     target: std.Target,
     llvm_types_len: u32,
     llvm_types_buffer: [8]u16,
+    byval_attr: bool,
 
     const Lowering = enum {
         no_bits,
@@ -9429,6 +9521,7 @@ const ParamTypeIterator = struct {
         byref,
         abi_sized_int,
         multiple_llvm_ints,
+        multiple_llvm_float,
         slice,
         as_u16,
     };
@@ -9436,6 +9529,7 @@ const ParamTypeIterator = struct {
     pub fn next(it: *ParamTypeIterator) ?Lowering {
         if (it.zig_index >= it.fn_info.param_types.len) return null;
         const ty = it.fn_info.param_types[it.zig_index];
+        it.byval_attr = false;
         return nextInner(it, ty);
     }
 
@@ -9521,6 +9615,7 @@ const ParamTypeIterator = struct {
                             .memory => {
                                 it.zig_index += 1;
                                 it.llvm_index += 1;
+                                it.byval_attr = true;
                                 return .byref;
                             },
                             .sse => {
@@ -9540,6 +9635,7 @@ const ParamTypeIterator = struct {
                             if (classes[0] == .memory) {
                                 it.zig_index += 1;
                                 it.llvm_index += 1;
+                                it.byval_attr = true;
                                 return .byref;
                             }
                             var llvm_types_buffer: [8]u16 = undefined;
@@ -9551,16 +9647,20 @@ const ParamTypeIterator = struct {
                                         llvm_types_index += 1;
                                     },
                                     .sse => {
-                                        @panic("TODO");
+                                        llvm_types_buffer[llvm_types_index] = 64;
+                                        llvm_types_index += 1;
                                     },
                                     .sseup => {
-                                        @panic("TODO");
+                                        llvm_types_buffer[llvm_types_index] = 64;
+                                        llvm_types_index += 1;
                                     },
                                     .x87 => {
-                                        @panic("TODO");
+                                        llvm_types_buffer[llvm_types_index] = 80;
+                                        llvm_types_index += 1;
                                     },
                                     .x87up => {
-                                        @panic("TODO");
+                                        llvm_types_buffer[llvm_types_index] = 80;
+                                        llvm_types_index += 1;
                                     },
                                     .complex_x87 => {
                                         @panic("TODO");
@@ -9574,11 +9674,16 @@ const ParamTypeIterator = struct {
                                 it.llvm_index += 1;
                                 return .abi_sized_int;
                             }
+                            if (classes[0] == .sse and classes[1] == .none) {
+                                it.zig_index += 1;
+                                it.llvm_index += 1;
+                                return .byval;
+                            }
                             it.llvm_types_buffer = llvm_types_buffer;
                             it.llvm_types_len = llvm_types_index;
                             it.llvm_index += llvm_types_index;
                             it.zig_index += 1;
-                            return .multiple_llvm_ints;
+                            return if (classes[0] == .integer) .multiple_llvm_ints else .multiple_llvm_float;
                         },
                     },
                     .wasm32 => {
@@ -9619,6 +9724,7 @@ fn iterateParamTypes(dg: *DeclGen, fn_info: Type.Payload.Function.Data) ParamTyp
         .target = dg.module.getTarget(),
         .llvm_types_buffer = undefined,
         .llvm_types_len = 0,
+        .byval_attr = false,
     };
 }
 
diff --git a/src/codegen/llvm/bindings.zig b/src/codegen/llvm/bindings.zig
index baf67b15aa42b7563cacaf5d1a1a69f07b790efd..9daa96eb8ff0397c4e04e801ca60e8d13b71eaec 100644
--- a/src/codegen/llvm/bindings.zig
+++ b/src/codegen/llvm/bindings.zig
@@ -248,6 +248,9 @@ pub const Value = opaque {
 
     pub const addFunctionAttr = ZigLLVMAddFunctionAttr;
     extern fn ZigLLVMAddFunctionAttr(Fn: *const Value, attr_name: [*:0]const u8, attr_value: [*:0]const u8) void;
+
+    pub const addByValAttr = ZigLLVMAddByValAttr;
+    extern fn ZigLLVMAddByValAttr(Fn: *const Value, ArgNo: c_uint, type: *const Type) void;
 };
 
 pub const Type = opaque {
diff --git a/test/standalone.zig b/test/standalone.zig
index 76e46a1b62f37f6b3644015f3a8cd8fe05bb840a..2b0667e89c988f3bd88d7fe757132e5c209491fc 100644
--- a/test/standalone.zig
+++ b/test/standalone.zig
@@ -40,7 +40,7 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
     }
     // C ABI compatibility issue: https://github.com/ziglang/zig/issues/1481
     if (builtin.cpu.arch == .x86_64) {
-        if (builtin.zig_backend == .stage1) { // https://github.com/ziglang/zig/issues/12222
+        if (builtin.zig_backend == .stage1 or builtin.zig_backend == .stage2_llvm) { // https://github.com/ziglang/zig/issues/12222
             cases.addBuildFile("test/c_abi/build.zig", .{});
         }
     }
-- 
2.54.0


From cc56400e62ae7d59cccf78d0cfe2e4b990d53abc Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 18:56:08 -0700
Subject: [PATCH 077/290] Revert "macho: allow unaligned offsets in object
 files"

This reverts commit 45c444ff18b43d30a7277e346174ba6eca4a6193.
---
 src/link/MachO/Object.zig | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index 098917e81f60002c473f56d6e371294b626218ab..996a85ed4b75a732c5f5a995f327e62d0a0e4374 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -99,11 +99,10 @@ pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch)
             },
             .SYMTAB => {
                 const symtab = cmd.cast(macho.symtab_command).?;
-                // Sadly, SYMTAB may be at an unaligned offset within the object file.
-                self.in_symtab = @alignCast(@alignOf(macho.nlist_64), @ptrCast(
-                    [*]align(1) const macho.nlist_64,
-                    self.contents.ptr + symtab.symoff,
-                ))[0..symtab.nsyms];
+                self.in_symtab = @ptrCast(
+                    [*]const macho.nlist_64,
+                    @alignCast(@alignOf(macho.nlist_64), &self.contents[symtab.symoff]),
+                )[0..symtab.nsyms];
                 self.in_strtab = self.contents[symtab.stroff..][0..symtab.strsize];
                 try self.symtab.appendSlice(allocator, self.in_symtab);
             },
@@ -303,10 +302,10 @@ pub fn splitIntoAtomsOneShot(self: *Object, macho_file: *MachO, object_id: u32)
         const code: ?[]const u8 = if (!sect.isZerofill()) try self.getSectionContents(sect) else null;
 
         // Read section's list of relocations
-        const relocs = @alignCast(@alignOf(macho.relocation_info), @ptrCast(
-            [*]align(1) const macho.relocation_info,
-            self.contents.ptr + sect.reloff,
-        ))[0..sect.nreloc];
+        const relocs = @ptrCast(
+            [*]const macho.relocation_info,
+            @alignCast(@alignOf(macho.relocation_info), &self.contents[sect.reloff]),
+        )[0..sect.nreloc];
 
         // Symbols within this section only.
         const filtered_syms = filterSymbolsByAddress(
@@ -549,10 +548,10 @@ pub fn parseDataInCode(self: Object) ?[]const macho.data_in_code_entry {
             .DATA_IN_CODE => {
                 const dice = cmd.cast(macho.linkedit_data_command).?;
                 const ndice = @divExact(dice.datasize, @sizeOf(macho.data_in_code_entry));
-                return @alignCast(@alignOf(macho.data_in_code_entry), @ptrCast(
-                    [*]align(1) const macho.data_in_code_entry,
-                    self.contents.ptr + dice.dataoff,
-                ))[0..ndice];
+                return @ptrCast(
+                    [*]const macho.data_in_code_entry,
+                    @alignCast(@alignOf(macho.data_in_code_entry), &self.contents[dice.dataoff]),
+                )[0..ndice];
             },
             else => {},
         }
-- 
2.54.0


From fa620ef710bbbf7f642fd1d6d24a188d02902988 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 22:26:29 -0700
Subject: [PATCH 078/290] link.MachO: use accurate alignment attribute on
 pointers

Also adds a new method to ArrayList: appendUnalignedSlice
---
 lib/std/array_list.zig    | 63 +++++++++++++++++++++++++++++++++++++++
 src/link/MachO.zig        |  6 ++--
 src/link/MachO/Atom.zig   |  2 +-
 src/link/MachO/Object.zig | 25 ++++++++--------
 4 files changed, 80 insertions(+), 16 deletions(-)

diff --git a/lib/std/array_list.zig b/lib/std/array_list.zig
index 655bdeaa42c2803023a2c07eb452799060734b52..a8c53c314244ad7e810aaf8133eee2fae4b4d3d6 100644
--- a/lib/std/array_list.zig
+++ b/lib/std/array_list.zig
@@ -221,6 +221,30 @@ pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
             mem.copy(T, self.items[old_len..], items);
         }
 
+        /// Append an unaligned slice of items to the list. Allocates more
+        /// memory as necessary. Only call this function if calling
+        /// `appendSlice` instead would be a compile error.
+        pub fn appendUnalignedSlice(self: *Self, items: []align(1) const T) Allocator.Error!void {
+            try self.ensureUnusedCapacity(items.len);
+            self.appendUnalignedSliceAssumeCapacity(items);
+        }
+
+        /// Append the slice of items to the list, asserting the capacity is already
+        /// enough to store the new items. **Does not** invalidate pointers.
+        /// Only call this function if calling `appendSliceAssumeCapacity` instead
+        /// would be a compile error.
+        pub fn appendUnalignedSliceAssumeCapacity(self: *Self, items: []align(1) const T) void {
+            const old_len = self.items.len;
+            const new_len = old_len + items.len;
+            assert(new_len <= self.capacity);
+            self.items.len = new_len;
+            @memcpy(
+                @ptrCast([*]align(@alignOf(T)) u8, self.items.ptr + old_len),
+                @ptrCast([*]const u8, items.ptr),
+                items.len * @sizeOf(T),
+            );
+        }
+
         pub const Writer = if (T != u8)
             @compileError("The Writer interface is only defined for ArrayList(u8) " ++
                 "but the given type is ArrayList(" ++ @typeName(T) ++ ")")
@@ -592,6 +616,29 @@ pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) typ
             mem.copy(T, self.items[old_len..], items);
         }
 
+        /// Append the slice of items to the list. Allocates more
+        /// memory as necessary. Only call this function if a call to `appendSlice` instead would
+        /// be a compile error.
+        pub fn appendUnalignedSlice(self: *Self, allocator: Allocator, items: []align(1) const T) Allocator.Error!void {
+            try self.ensureUnusedCapacity(allocator, items.len);
+            self.appendUnalignedSliceAssumeCapacity(items);
+        }
+
+        /// Append an unaligned slice of items to the list, asserting the capacity is enough
+        /// to store the new items. Only call this function if a call to `appendSliceAssumeCapacity`
+        /// instead would be a compile error.
+        pub fn appendUnalignedSliceAssumeCapacity(self: *Self, items: []align(1) const T) void {
+            const old_len = self.items.len;
+            const new_len = old_len + items.len;
+            assert(new_len <= self.capacity);
+            self.items.len = new_len;
+            @memcpy(
+                @ptrCast([*]align(@alignOf(T)) u8, self.items.ptr + old_len),
+                @ptrCast([*]const u8, items.ptr),
+                items.len * @sizeOf(T),
+            );
+        }
+
         pub const WriterContext = struct {
             self: *Self,
             allocator: Allocator,
@@ -899,6 +946,14 @@ test "std.ArrayList/ArrayListUnmanaged.basic" {
         try testing.expect(list.pop() == 1);
         try testing.expect(list.items.len == 9);
 
+        var unaligned: [3]i32 align(1) = [_]i32{ 4, 5, 6 };
+        list.appendUnalignedSlice(&unaligned) catch unreachable;
+        try testing.expect(list.items.len == 12);
+        try testing.expect(list.pop() == 6);
+        try testing.expect(list.pop() == 5);
+        try testing.expect(list.pop() == 4);
+        try testing.expect(list.items.len == 9);
+
         list.appendSlice(&[_]i32{}) catch unreachable;
         try testing.expect(list.items.len == 9);
 
@@ -941,6 +996,14 @@ test "std.ArrayList/ArrayListUnmanaged.basic" {
         try testing.expect(list.pop() == 1);
         try testing.expect(list.items.len == 9);
 
+        var unaligned: [3]i32 align(1) = [_]i32{ 4, 5, 6 };
+        list.appendUnalignedSlice(a, &unaligned) catch unreachable;
+        try testing.expect(list.items.len == 12);
+        try testing.expect(list.pop() == 6);
+        try testing.expect(list.pop() == 5);
+        try testing.expect(list.pop() == 4);
+        try testing.expect(list.items.len == 9);
+
         list.appendSlice(a, &[_]i32{}) catch unreachable;
         try testing.expect(list.items.len == 9);
 
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index db207af5f54c990e5e0f5a34c45921e14fd437a6..3da086a382fc38179011e8c6587f18806f4d2e3b 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -5315,10 +5315,10 @@ fn writeFunctionStarts(self: *MachO, ncmds: *u32, lc_writer: anytype) !void {
 }
 
 fn filterDataInCode(
-    dices: []const macho.data_in_code_entry,
+    dices: []align(1) const macho.data_in_code_entry,
     start_addr: u64,
     end_addr: u64,
-) []const macho.data_in_code_entry {
+) []align(1) const macho.data_in_code_entry {
     const Predicate = struct {
         addr: u64,
 
@@ -5825,7 +5825,7 @@ pub fn getEntryPoint(self: MachO) error{MissingMainEntrypoint}!SymbolWithLoc {
     return global;
 }
 
-pub fn findFirst(comptime T: type, haystack: []const T, start: usize, predicate: anytype) usize {
+pub fn findFirst(comptime T: type, haystack: []align(1) const T, start: usize, predicate: anytype) usize {
     if (!@hasDecl(@TypeOf(predicate), "predicate"))
         @compileError("Predicate is required to define fn predicate(@This(), T) bool");
 
diff --git a/src/link/MachO/Atom.zig b/src/link/MachO/Atom.zig
index 4871276f3c2729f1ad1fba42b636a17f0bcedd3f..dd818ea936f4cf0396145d349dcbc3e4b6df4fe7 100644
--- a/src/link/MachO/Atom.zig
+++ b/src/link/MachO/Atom.zig
@@ -218,7 +218,7 @@ const RelocContext = struct {
     base_offset: i32 = 0,
 };
 
-pub fn parseRelocs(self: *Atom, relocs: []const macho.relocation_info, context: RelocContext) !void {
+pub fn parseRelocs(self: *Atom, relocs: []align(1) const macho.relocation_info, context: RelocContext) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index 996a85ed4b75a732c5f5a995f327e62d0a0e4374..935183bbc6f1b1da3cc58be997b77bc574145140 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -24,7 +24,7 @@ mtime: u64,
 contents: []align(@alignOf(u64)) const u8,
 
 header: macho.mach_header_64 = undefined,
-in_symtab: []const macho.nlist_64 = undefined,
+in_symtab: []align(1) const macho.nlist_64 = undefined,
 in_strtab: []const u8 = undefined,
 
 symtab: std.ArrayListUnmanaged(macho.nlist_64) = .{},
@@ -99,12 +99,13 @@ pub fn parse(self: *Object, allocator: Allocator, cpu_arch: std.Target.Cpu.Arch)
             },
             .SYMTAB => {
                 const symtab = cmd.cast(macho.symtab_command).?;
+                // Sadly, SYMTAB may be at an unaligned offset within the object file.
                 self.in_symtab = @ptrCast(
-                    [*]const macho.nlist_64,
-                    @alignCast(@alignOf(macho.nlist_64), &self.contents[symtab.symoff]),
+                    [*]align(1) const macho.nlist_64,
+                    self.contents.ptr + symtab.symoff,
                 )[0..symtab.nsyms];
                 self.in_strtab = self.contents[symtab.stroff..][0..symtab.strsize];
-                try self.symtab.appendSlice(allocator, self.in_symtab);
+                try self.symtab.appendUnalignedSlice(allocator, self.in_symtab);
             },
             else => {},
         }
@@ -196,10 +197,10 @@ fn filterSymbolsByAddress(
 }
 
 fn filterRelocs(
-    relocs: []const macho.relocation_info,
+    relocs: []align(1) const macho.relocation_info,
     start_addr: u64,
     end_addr: u64,
-) []const macho.relocation_info {
+) []align(1) const macho.relocation_info {
     const Predicate = struct {
         addr: u64,
 
@@ -303,8 +304,8 @@ pub fn splitIntoAtomsOneShot(self: *Object, macho_file: *MachO, object_id: u32)
 
         // Read section's list of relocations
         const relocs = @ptrCast(
-            [*]const macho.relocation_info,
-            @alignCast(@alignOf(macho.relocation_info), &self.contents[sect.reloff]),
+            [*]align(1) const macho.relocation_info,
+            self.contents.ptr + sect.reloff,
         )[0..sect.nreloc];
 
         // Symbols within this section only.
@@ -472,7 +473,7 @@ fn createAtomFromSubsection(
     size: u64,
     alignment: u32,
     code: ?[]const u8,
-    relocs: []const macho.relocation_info,
+    relocs: []align(1) const macho.relocation_info,
     indexes: []const SymbolAtIndex,
     match: u8,
     sect: macho.section_64,
@@ -538,7 +539,7 @@ pub fn getSourceSection(self: Object, index: u16) macho.section_64 {
     return self.sections.items[index];
 }
 
-pub fn parseDataInCode(self: Object) ?[]const macho.data_in_code_entry {
+pub fn parseDataInCode(self: Object) ?[]align(1) const macho.data_in_code_entry {
     var it = LoadCommandIterator{
         .ncmds = self.header.ncmds,
         .buffer = self.contents[@sizeOf(macho.mach_header_64)..][0..self.header.sizeofcmds],
@@ -549,8 +550,8 @@ pub fn parseDataInCode(self: Object) ?[]const macho.data_in_code_entry {
                 const dice = cmd.cast(macho.linkedit_data_command).?;
                 const ndice = @divExact(dice.datasize, @sizeOf(macho.data_in_code_entry));
                 return @ptrCast(
-                    [*]const macho.data_in_code_entry,
-                    @alignCast(@alignOf(macho.data_in_code_entry), &self.contents[dice.dataoff]),
+                    [*]align(1) const macho.data_in_code_entry,
+                    self.contents.ptr + dice.dataoff,
                 )[0..ndice];
             },
             else => {},
-- 
2.54.0


From 933436dc52b9be0a3e5d81b014fba6df2124fe20 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 20:39:57 -0700
Subject: [PATCH 079/290] stage2: remove destroyed functions from maps

This is likely the cause of the flaky test failures in master branch.
Since we have some test coverage for incremental compilation, it's not
OK to leave proper memory management of Fn objects as "TODO".
---
 src/Module.zig | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/Module.zig b/src/Module.zig
index 7e877a2f4ad6394442565ceffacf4824b0c7a130..995fdda7ea24d16437f29442e004681580883af5 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -84,7 +84,6 @@ string_literal_bytes: std.ArrayListUnmanaged(u8) = .{},
 /// The set of all the generic function instantiations. This is used so that when a generic
 /// function is called twice with the same comptime parameter arguments, both calls dispatch
 /// to the same function.
-/// TODO: remove functions from this set when they are destroyed.
 monomorphed_funcs: MonomorphedFuncsSet = .{},
 /// The set of all comptime function calls that have been cached so that future calls
 /// with the same parameters will get the same return value.
@@ -92,7 +91,6 @@ memoized_calls: MemoizedCallSet = .{},
 /// Contains the values from `@setAlignStack`. A sparse table is used here
 /// instead of a field of `Fn` because usage of `@setAlignStack` is rare, while
 /// functions are many.
-/// TODO: remove functions from this set when they are destroyed.
 align_stack_fns: std.AutoHashMapUnmanaged(*const Fn, SetAlignStack) = .{},
 
 /// We optimize memory usage for a compilation with no compile errors by storing the
@@ -560,6 +558,8 @@ pub const Decl = struct {
             gpa.destroy(extern_fn);
         }
         if (decl.getFunction()) |func| {
+            _ = mod.align_stack_fns.remove(func);
+            _ = mod.monomorphed_funcs.remove(func);
             func.deinit(gpa);
             gpa.destroy(func);
         }
@@ -4094,6 +4094,12 @@ pub fn ensureDeclAnalyzed(mod: *Module, decl_index: Decl.Index) SemaError!void {
             // The exports this Decl performs will be re-discovered, so we remove them here
             // prior to re-analysis.
             mod.deleteDeclExports(decl_index);
+
+            // Similarly, `@setAlignStack` invocations will be re-discovered.
+            if (decl.getFunction()) |func| {
+                _ = mod.align_stack_fns.remove(func);
+            }
+
             // Dependencies will be re-discovered, so we remove them here prior to re-analysis.
             for (decl.dependencies.keys()) |dep_index| {
                 const dep = mod.declPtr(dep_index);
-- 
2.54.0


From 9f1f60fd4311b37493a5297ccaac167d0270f521 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 11 Aug 2022 00:46:44 -0700
Subject: [PATCH 080/290] test-cases: remove multi-threading

This effectively reverts 22690efcc2378222503cb8aaad26a6f4a539f5aa,
re-opening #11818.

This had the following problems:
 * Buggy on some targets (macOS, Windows)
 * Messy output to the terminal

These problems need to be solved before moving forward with this.
---
 src/test.zig | 48 ++++++++----------------------------------------
 1 file changed, 8 insertions(+), 40 deletions(-)

diff --git a/src/test.zig b/src/test.zig
index 5f4107a402d41954e188b40e885d32e800778382..266b4181e0113d9f84e4e6bf946703b578adf8f6 100644
--- a/src/test.zig
+++ b/src/test.zig
@@ -1224,10 +1224,6 @@ pub const TestContext = struct {
         try aux_thread_pool.init(self.gpa);
         defer aux_thread_pool.deinit();
 
-        var case_thread_pool: ThreadPool = undefined;
-        try case_thread_pool.init(self.gpa);
-        defer case_thread_pool.deinit();
-
         // Use the same global cache dir for all the tests, such that we for example don't have to
         // rebuild musl libc for every case (when LLVM backend is enabled).
         var global_tmp = std.testing.tmpDir(.{});
@@ -1245,9 +1241,6 @@ pub const TestContext = struct {
         defer self.gpa.free(global_cache_directory.path.?);
 
         {
-            var wait_group: WaitGroup = .{};
-            defer wait_group.wait();
-
             for (self.cases.items) |*case| {
                 if (build_options.skip_non_native) {
                     if (case.target.getCpuArch() != builtin.cpu.arch)
@@ -1267,17 +1260,19 @@ pub const TestContext = struct {
                     if (std.mem.indexOf(u8, case.name, test_filter) == null) continue;
                 }
 
-                wait_group.start();
-                try case_thread_pool.spawn(workerRunOneCase, .{
+                var prg_node = root_node.start(case.name, case.updates.items.len);
+                prg_node.activate();
+                defer prg_node.end();
+
+                case.result = runOneCase(
                     self.gpa,
-                    root_node,
-                    case,
+                    &prg_node,
+                    case.*,
                     zig_lib_directory,
                     &aux_thread_pool,
                     global_cache_directory,
                     host,
-                    &wait_group,
-                });
+                );
             }
         }
 
@@ -1295,33 +1290,6 @@ pub const TestContext = struct {
         }
     }
 
-    fn workerRunOneCase(
-        gpa: Allocator,
-        root_node: *std.Progress.Node,
-        case: *Case,
-        zig_lib_directory: Compilation.Directory,
-        thread_pool: *ThreadPool,
-        global_cache_directory: Compilation.Directory,
-        host: std.zig.system.NativeTargetInfo,
-        wait_group: *WaitGroup,
-    ) void {
-        defer wait_group.finish();
-
-        var prg_node = root_node.start(case.name, case.updates.items.len);
-        prg_node.activate();
-        defer prg_node.end();
-
-        case.result = runOneCase(
-            gpa,
-            &prg_node,
-            case.*,
-            zig_lib_directory,
-            thread_pool,
-            global_cache_directory,
-            host,
-        );
-    }
-
     fn runOneCase(
         allocator: Allocator,
         root_node: *std.Progress.Node,
-- 
2.54.0


From 7d6a7f513b0053be4e1629de492cbde9215c442c Mon Sep 17 00:00:00 2001
From: Isaac Freund <mail@isaacfreund.com>
Date: Thu, 11 Aug 2022 11:04:26 +0200
Subject: [PATCH 081/290] std: Don't pass undefined memory to the kernel in
 os.abort()

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

diff --git a/lib/std/os.zig b/lib/std/os.zig
index 1192c726298e8919ab6dce959a1c26409ccb8494..b068a11229b54c93de90afed384f2321b0dbc041 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -476,9 +476,8 @@ pub fn abort() noreturn {
         // Install default handler so that the tkill below will terminate.
         const sigact = Sigaction{
             .handler = .{ .sigaction = SIG.DFL },
-            .mask = undefined,
-            .flags = undefined,
-            .restorer = undefined,
+            .mask = empty_sigset,
+            .flags = 0,
         };
         sigaction(SIG.ABRT, &sigact, null) catch |err| switch (err) {
             error.OperationNotSupported => unreachable,
-- 
2.54.0


From 7e6dbd63989ed4f62b9d12fb03119b0bec1bda84 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Sat, 23 Jul 2022 19:49:26 +0200
Subject: [PATCH 082/290] wasm: Use free-lists for unused locals

When a local is no longer needed (for instance, it was used as
a temporary during arithmetic), it can be appended to one of
the typed freelists. This allows us to re-use locals and therefore
require less locals, reducing the binary size, as well as runtime
initialization.
---
 src/arch/wasm/CodeGen.zig | 49 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 47 insertions(+), 2 deletions(-)

diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index ef92361de2c03e2844524904525a1b6a729c9161..2048a456d74f96f7725c133fbee529de4a7f9a7c 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -601,6 +601,21 @@ stack_size: u32 = 0,
 /// However, local variables or the usage of `@setAlignStack` can overwrite this default.
 stack_alignment: u32 = 16,
 
+// For each individual Wasm valtype we store a seperate free list which
+// allows us to re-use locals that are no longer used. e.g. a temporary local.
+/// A list of indexes which represents a local of valtype `i32`.
+/// It is illegal to store a non-i32 valtype in this list.
+free_locals_i32: std.ArrayListUnmanaged(u32) = .{},
+/// A list of indexes which represents a local of valtype `i64`.
+/// It is illegal to store a non-i32 valtype in this list.
+free_locals_i64: std.ArrayListUnmanaged(u32) = .{},
+/// A list of indexes which represents a local of valtype `f32`.
+/// It is illegal to store a non-i32 valtype in this list.
+free_locals_f32: std.ArrayListUnmanaged(u32) = .{},
+/// A list of indexes which represents a local of valtype `f64`.
+/// It is illegal to store a non-i32 valtype in this list.
+free_locals_f64: std.ArrayListUnmanaged(u32) = .{},
+
 const InnerError = error{
     OutOfMemory,
     /// An error occurred when trying to lower AIR to MIR.
@@ -781,13 +796,43 @@ fn emitWValue(self: *Self, value: WValue) InnerError!void {
 /// Creates one locals for a given `Type`.
 /// Returns a corresponding `Wvalue` with `local` as active tag
 fn allocLocal(self: *Self, ty: Type) InnerError!WValue {
+    const valtype = typeToValtype(ty, self.target);
+    switch (valtype) {
+        .i32 => if (self.free_locals_i32.popOrNull()) |index| {
+            return WValue{ .local = index };
+        },
+        .i64 => if (self.free_locals_i64.popOrNull()) |index| {
+            return WValue{ .local = index };
+        },
+        .f32 => if (self.free_locals_f32.popOrNull()) |index| {
+            return WValue{ .local = index };
+        },
+        .f64 => if (self.free_locals_f64.popOrNull()) |index| {
+            return WValue{ .local = index };
+        },
+    }
+    // no local was free to be re-used, so allocate a new local instead
+    try self.locals.append(self.gpa, wasm.valtype(valtype));
     const initial_index = self.local_index;
-    const valtype = genValtype(ty, self.target);
-    try self.locals.append(self.gpa, valtype);
     self.local_index += 1;
     return WValue{ .local = initial_index };
 }
 
+/// Marks a local as no longer being referenced and essentially allows
+/// us to re-use it somewhere else within the function.
+/// The valtype of the local is deducted by using the index of the given.
+/// Asserts given `WValue` is a `local`.
+fn freeLocal(self: *Self, value: WValue) InnerError!WValue {
+    const index = value.local;
+    const valtype = wasm.valtype(self.locals.items[index]);
+    switch (valtype) {
+        .i32 => self.free_locals_i32.append(index) catch {}, // It's ok to fail any of those, a new local can be allocated instead
+        .i64 => self.free_locals_i64.append(index) catch {},
+        .f32 => self.free_locals_f32.append(index) catch {},
+        .f64 => self.free_locals_f64.append(index) catch {},
+    }
+}
+
 /// Generates a `wasm.Type` from a given function type.
 /// Memory is owned by the caller.
 fn genFunctype(gpa: Allocator, cc: std.builtin.CallingConvention, params: []const Type, return_type: Type, target: std.Target) !wasm.Type {
-- 
2.54.0


From cc6f2b67c68ece7577e27e23846670d6566ad5f2 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Sun, 24 Jul 2022 15:48:12 +0200
Subject: [PATCH 083/290] wasm: `binOp` leave value on stack

Rather than always creating a new local and storing the result of
a binary operation into said local, we now leave it on top of the stack.
This allows for better codegen as we need less instructions, as well
as less total amount of locals.
---
 src/arch/wasm/CodeGen.zig | 147 ++++++++++++++++++++++----------------
 1 file changed, 84 insertions(+), 63 deletions(-)

diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index 2048a456d74f96f7725c133fbee529de4a7f9a7c..cbe4b558610b603b3368614310a98a679456951b 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -29,6 +29,8 @@ const errUnionErrorOffset = codegen.errUnionErrorOffset;
 const WValue = union(enum) {
     /// May be referenced but is unused
     none: void,
+    /// The value lives on top of the stack
+    stack: void,
     /// Index of the local variable
     local: u32,
     /// An immediate 32bit value
@@ -55,7 +57,7 @@ const WValue = union(enum) {
     /// In wasm function pointers are indexes into a function table,
     /// rather than an address in the data section.
     function_index: u32,
-    /// Offset from the bottom of the stack, with the offset
+    /// Offset from the bottom of the virtual stack, with the offset
     /// pointing to where the value lives.
     stack_offset: u32,
 
@@ -71,6 +73,21 @@ const WValue = union(enum) {
             else => return 0,
         }
     }
+
+    /// Promotes a `WValue` to a local when given value is on top of the stack.
+    /// When encountering a `local` or `stack_offset` this is essentially a no-op.
+    /// All other tags are illegal.
+    fn toLocal(self: WValue, gen: *Self, ty: Type) InnerError!WValue {
+        switch (self) {
+            .stack => {
+                const local = try gen.allocLocal(ty);
+                try gen.addLabel(.local_set, local.local);
+                return local;
+            },
+            .local, .stack_offset => return self,
+            else => unreachable,
+        }
+    }
 };
 
 /// Wasm ops, but without input/output/signedness information
@@ -774,7 +791,7 @@ fn genBlockType(ty: Type, target: std.Target) u8 {
 /// Writes the bytecode depending on the given `WValue` in `val`
 fn emitWValue(self: *Self, value: WValue) InnerError!void {
     switch (value) {
-        .none => {}, // no-op
+        .none, .stack => {}, // no-op
         .local => |idx| try self.addLabel(.local_get, idx),
         .imm32 => |val| try self.addImm32(@bitCast(i32, val)),
         .imm64 => |val| try self.addImm64(val),
@@ -1892,6 +1909,7 @@ fn airStore(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
 }
 
 fn store(self: *Self, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerError!void {
+    assert(!(lhs != .stack and rhs == .stack));
     switch (ty.zigTypeTag()) {
         .ErrorUnion => {
             const pl_ty = ty.errorUnionPayload();
@@ -2070,10 +2088,14 @@ fn airBinOp(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!WValue {
     const rhs = try self.resolveInst(bin_op.rhs);
     const ty = self.air.typeOf(bin_op.lhs);
 
-    return self.binOp(lhs, rhs, ty, op);
+    const stack_value = try self.binOp(lhs, rhs, ty, op);
+    return stack_value.toLocal(self, ty);
 }
 
+/// Performs a binary operation on the given `WValue`'s
+/// NOTE: THis leaves the value on top of the stack.
 fn binOp(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WValue {
+    assert(!(lhs != .stack and rhs == .stack));
     if (isByRef(ty, self.target)) {
         if (ty.zigTypeTag() == .Int) {
             return self.binOpBigInt(lhs, rhs, ty, op);
@@ -2099,10 +2121,7 @@ fn binOp(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WVa
 
     try self.addTag(Mir.Inst.Tag.fromOpcode(opcode));
 
-    // save the result in a temporary
-    const bin_local = try self.allocLocal(ty);
-    try self.addLabel(.local_set, bin_local.local);
-    return bin_local;
+    return WValue{ .stack = {} };
 }
 
 fn binOpFloat16(self: *Self, lhs: WValue, rhs: WValue, op: Op) InnerError!WValue {
@@ -2134,8 +2153,8 @@ fn binOpBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerErr
     const rhs_high_bit = try self.load(rhs, Type.u64, 0);
     const rhs_low_bit = try self.load(rhs, Type.u64, 8);
 
-    const low_op_res = try self.binOp(lhs_low_bit, rhs_low_bit, Type.u64, op);
-    const high_op_res = try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, op);
+    const low_op_res = try (try self.binOp(lhs_low_bit, rhs_low_bit, Type.u64, op)).toLocal(self, Type.u64);
+    const high_op_res = try (try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, op)).toLocal(self, Type.u64);
 
     const lt = if (op == .add) blk: {
         break :blk try self.cmp(high_op_res, rhs_high_bit, Type.u64, .lt);
@@ -2143,7 +2162,7 @@ fn binOpBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerErr
         break :blk try self.cmp(lhs_high_bit, rhs_high_bit, Type.u64, .lt);
     } else unreachable;
     const tmp = try self.intcast(lt, Type.u32, Type.u64);
-    const tmp_op = try self.binOp(low_op_res, tmp, Type.u64, op);
+    const tmp_op = try (try self.binOp(low_op_res, tmp, Type.u64, op)).toLocal(self, Type.u64);
 
     try self.store(result, high_op_res, Type.u64, 0);
     try self.store(result, tmp_op, Type.u64, 8);
@@ -2202,6 +2221,7 @@ fn wrapOperand(self: *Self, operand: WValue, ty: Type) InnerError!WValue {
     if (wasm_bits == bitsize) return operand;
 
     if (wasm_bits == 128) {
+        assert(operand != .stack);
         const msb = try self.load(operand, Type.u64, 0);
         const lsb = try self.load(operand, Type.u64, 8);
 
@@ -2772,19 +2792,19 @@ fn airNot(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         switch (wasm_bits) {
             32 => {
                 const bin_op = try self.binOp(operand, .{ .imm32 = ~@as(u32, 0) }, operand_ty, .xor);
-                return self.wrapOperand(bin_op, operand_ty);
+                return (try self.wrapOperand(bin_op, operand_ty)).toLocal(self, operand_ty);
             },
             64 => {
                 const bin_op = try self.binOp(operand, .{ .imm64 = ~@as(u64, 0) }, operand_ty, .xor);
-                return self.wrapOperand(bin_op, operand_ty);
+                return (try self.wrapOperand(bin_op, operand_ty)).toLocal(self, operand_ty);
             },
             128 => {
                 const result_ptr = try self.allocStack(operand_ty);
                 const msb = try self.load(operand, Type.u64, 0);
                 const lsb = try self.load(operand, Type.u64, 8);
 
-                const msb_xor = try self.binOp(msb, .{ .imm64 = ~@as(u64, 0) }, Type.u64, .xor);
-                const lsb_xor = try self.binOp(lsb, .{ .imm64 = ~@as(u64, 0) }, Type.u64, .xor);
+                const msb_xor = try (try self.binOp(msb, .{ .imm64 = ~@as(u64, 0) }, Type.u64, .xor)).toLocal(self, operand_ty);
+                const lsb_xor = try (try self.binOp(lsb, .{ .imm64 = ~@as(u64, 0) }, Type.u64, .xor)).toLocal(self, operand_ty);
                 try self.store(result_ptr, msb_xor, Type.u64, 0);
                 try self.store(result_ptr, lsb_xor, Type.u64, 8);
                 return result_ptr;
@@ -3215,7 +3235,7 @@ fn intcast(self: *Self, operand: WValue, given: Type, wanted: Type) InnerError!W
 
         // For signed integers we shift msb by 63 (64bit integer - 1 sign bit) and store remaining value
         if (wanted.isSignedInt()) {
-            const shr = try self.binOp(lhs, .{ .imm64 = 63 }, Type.i64, .shr);
+            const shr = try (try self.binOp(lhs, .{ .imm64 = 63 }, Type.i64, .shr)).toLocal(self, Type.i64);
             try self.store(stack_ptr, shr, Type.u64, 8);
         } else {
             // Ensure memory of lsb is zero'd
@@ -4320,7 +4340,7 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!W
         break :blk try self.signAbsValue(rhs_op, lhs_ty);
     } else rhs_op;
 
-    const bin_op = try self.binOp(lhs, rhs, lhs_ty, op);
+    const bin_op = try (try self.binOp(lhs, rhs, lhs_ty, op)).toLocal(self, lhs_ty);
     const result = if (wasm_bits != int_info.bits) blk: {
         break :blk try self.wrapOperand(bin_op, lhs_ty);
     } else bin_op;
@@ -4330,7 +4350,7 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!W
         if (wasm_bits == int_info.bits) {
             const cmp_zero = try self.cmp(rhs, zero, lhs_ty, cmp_op);
             const lt = try self.cmp(bin_op, lhs, lhs_ty, .lt);
-            break :blk try self.binOp(cmp_zero, lt, Type.u32, .xor); // result of cmp_zero and lt is always 32bit
+            break :blk try (try self.binOp(cmp_zero, lt, Type.u32, .xor)).toLocal(self, Type.u32); // result of cmp_zero and lt is always 32bit
         }
         const abs = try self.signAbsValue(bin_op, lhs_ty);
         break :blk try self.cmp(abs, bin_op, lhs_ty, .neq);
@@ -4360,8 +4380,8 @@ fn airAddSubWithOverflowBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type,
     const rhs_high_bit = try self.load(rhs, Type.u64, 0);
     const rhs_low_bit = try self.load(rhs, Type.u64, 8);
 
-    const low_op_res = try self.binOp(lhs_low_bit, rhs_low_bit, Type.u64, op);
-    const high_op_res = try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, op);
+    const low_op_res = try (try self.binOp(lhs_low_bit, rhs_low_bit, Type.u64, op)).toLocal(self, Type.u64);
+    const high_op_res = try (try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, op)).toLocal(self, Type.u64);
 
     const lt = if (op == .add) blk: {
         break :blk try self.cmp(high_op_res, lhs_high_bit, Type.u64, .lt);
@@ -4369,14 +4389,14 @@ fn airAddSubWithOverflowBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type,
         break :blk try self.cmp(lhs_high_bit, rhs_high_bit, Type.u64, .lt);
     } else unreachable;
     const tmp = try self.intcast(lt, Type.u32, Type.u64);
-    const tmp_op = try self.binOp(low_op_res, tmp, Type.u64, op);
+    const tmp_op = try (try self.binOp(low_op_res, tmp, Type.u64, op)).toLocal(self, Type.u64);
 
     const overflow_bit = if (is_signed) blk: {
-        const xor_op = try self.binOp(lhs_low_bit, tmp_op, Type.u64, .xor);
         const xor_low = try self.binOp(lhs_low_bit, rhs_low_bit, Type.u64, .xor);
         const to_wrap = if (op == .add) wrap: {
             break :wrap try self.binOp(xor_low, .{ .imm64 = ~@as(u64, 0) }, Type.u64, .xor);
         } else xor_low;
+        const xor_op = try self.binOp(lhs_low_bit, tmp_op, Type.u64, .xor);
         const wrap = try self.binOp(to_wrap, xor_op, Type.u64, .@"and");
         break :blk try self.cmp(wrap, .{ .imm64 = 0 }, Type.i64, .lt); // i64 because signed
     } else blk: {
@@ -4422,7 +4442,7 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         return self.fail("TODO: Implement shl_with_overflow for integer bitsize: {d}", .{int_info.bits});
     };
 
-    const shl = try self.binOp(lhs, rhs, lhs_ty, .shl);
+    const shl = try (try self.binOp(lhs, rhs, lhs_ty, .shl)).toLocal(self, lhs_ty);
     const result = if (wasm_bits != int_info.bits) blk: {
         break :blk try self.wrapOperand(shl, lhs_ty);
     } else shl;
@@ -4432,7 +4452,7 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         const wrapped = try self.wrapBinOp(abs, rhs, lhs_ty, .shr);
         break :blk try self.cmp(lhs, wrapped, lhs_ty, .neq);
     } else blk: {
-        const shr = try self.binOp(result, rhs, lhs_ty, .shr);
+        const shr = try (try self.binOp(result, rhs, lhs_ty, .shr)).toLocal(self, lhs_ty);
         break :blk try self.cmp(lhs, shr, lhs_ty, .neq);
     };
 
@@ -4478,7 +4498,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         const new_ty = if (int_info.signedness == .signed) Type.i64 else Type.u64;
         const lhs_upcast = try self.intcast(lhs, lhs_ty, new_ty);
         const rhs_upcast = try self.intcast(rhs, lhs_ty, new_ty);
-        const bin_op = try self.binOp(lhs_upcast, rhs_upcast, new_ty, .mul);
+        const bin_op = try (try self.binOp(lhs_upcast, rhs_upcast, new_ty, .mul)).toLocal(self, new_ty);
         if (int_info.signedness == .unsigned) {
             const shr = try self.binOp(bin_op, .{ .imm64 = int_info.bits }, new_ty, .shr);
             const wrap = try self.intcast(shr, new_ty, lhs_ty);
@@ -4488,7 +4508,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             break :blk try self.intcast(bin_op, new_ty, lhs_ty);
         } else {
             const down_cast = try self.intcast(bin_op, new_ty, lhs_ty);
-            const shr = try self.binOp(down_cast, .{ .imm32 = int_info.bits - 1 }, lhs_ty, .shr);
+            const shr = try (try self.binOp(down_cast, .{ .imm32 = int_info.bits - 1 }, lhs_ty, .shr)).toLocal(self, lhs_ty);
 
             const shr_res = try self.binOp(bin_op, .{ .imm64 = int_info.bits }, new_ty, .shr);
             const down_shr_res = try self.intcast(shr_res, new_ty, lhs_ty);
@@ -4500,14 +4520,14 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     } else if (int_info.signedness == .signed) blk: {
         const lhs_abs = try self.signAbsValue(lhs, lhs_ty);
         const rhs_abs = try self.signAbsValue(rhs, lhs_ty);
-        const bin_op = try self.binOp(lhs_abs, rhs_abs, lhs_ty, .mul);
+        const bin_op = try (try self.binOp(lhs_abs, rhs_abs, lhs_ty, .mul)).toLocal(self, lhs_ty);
         const mul_abs = try self.signAbsValue(bin_op, lhs_ty);
         const cmp_op = try self.cmp(mul_abs, bin_op, lhs_ty, .neq);
         try self.emitWValue(cmp_op);
         try self.addLabel(.local_set, overflow_bit.local);
         break :blk try self.wrapOperand(bin_op, lhs_ty);
     } else blk: {
-        const bin_op = try self.binOp(lhs, rhs, lhs_ty, .mul);
+        const bin_op = try (try self.binOp(lhs, rhs, lhs_ty, .mul)).toLocal(self, lhs_ty);
         const shift_imm = if (wasm_bits == 32)
             WValue{ .imm32 = int_info.bits }
         else
@@ -4587,7 +4607,7 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     }
 
     const mul_result = try self.binOp(lhs, rhs, ty, .mul);
-    return self.binOp(mul_result, addend, ty, .add);
+    return (try self.binOp(mul_result, addend, ty, .add)).toLocal(self, ty);
 }
 
 fn airClz(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -4663,16 +4683,16 @@ fn airCtz(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         32 => {
             if (wasm_bits != int_info.bits) {
                 const val: u32 = @as(u32, 1) << @intCast(u5, int_info.bits);
-                const bin_op = try self.binOp(operand, .{ .imm32 = val }, ty, .@"or");
-                try self.emitWValue(bin_op);
+                // leave value on the stack
+                _ = try self.binOp(operand, .{ .imm32 = val }, ty, .@"or");
             } else try self.emitWValue(operand);
             try self.addTag(.i32_ctz);
         },
         64 => {
             if (wasm_bits != int_info.bits) {
                 const val: u64 = @as(u64, 1) << @intCast(u6, int_info.bits);
-                const bin_op = try self.binOp(operand, .{ .imm64 = val }, ty, .@"or");
-                try self.emitWValue(bin_op);
+                // leave value on the stack
+                _ = try self.binOp(operand, .{ .imm64 = val }, ty, .@"or");
             } else try self.emitWValue(operand);
             try self.addTag(.i64_ctz);
             try self.addTag(.i32_wrap_i64);
@@ -4847,45 +4867,45 @@ fn airByteSwap(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     switch (int_info.bits) {
         16 => {
             const shl_res = try self.binOp(operand, .{ .imm32 = 8 }, ty, .shl);
-            const lhs = try self.binOp(shl_res, .{ .imm32 = 0xFF00 }, ty, .@"and");
-            const shr_res = try self.binOp(operand, .{ .imm32 = 8 }, ty, .shr);
+            const lhs = try (try self.binOp(shl_res, .{ .imm32 = 0xFF00 }, ty, .@"and")).toLocal(self, ty);
+            const shr_res = try (try self.binOp(operand, .{ .imm32 = 8 }, ty, .shr)).toLocal(self, ty);
             const res = if (int_info.signedness == .signed) blk: {
                 break :blk try self.wrapOperand(shr_res, Type.u8);
             } else shr_res;
-            return self.binOp(lhs, res, ty, .@"or");
+            return (try self.binOp(lhs, res, ty, .@"or")).toLocal(self, ty);
         },
         24 => {
             const msb = try self.wrapOperand(operand, Type.u16);
             const lsb = try self.wrapBinOp(operand, .{ .imm32 = 16 }, Type.u8, .shr);
 
             const shl_res = try self.binOp(msb, .{ .imm32 = 8 }, Type.u16, .shl);
-            const lhs = try self.binOp(shl_res, .{ .imm32 = 0xFF0000 }, Type.u16, .@"and");
-            const shr_res = try self.binOp(msb, .{ .imm32 = 8 }, ty, .shr);
+            const lhs = try (try self.binOp(shl_res, .{ .imm32 = 0xFF0000 }, Type.u16, .@"and")).toLocal(self, Type.u16);
+            const shr_res = try (try self.binOp(msb, .{ .imm32 = 8 }, ty, .shr)).toLocal(self, ty);
 
             const res = if (int_info.signedness == .signed) blk: {
                 break :blk try self.wrapOperand(shr_res, Type.u8);
             } else shr_res;
             const lhs_tmp = try self.binOp(lhs, res, ty, .@"or");
-            const lhs_result = try self.binOp(lhs_tmp, .{ .imm32 = 8 }, ty, .shr);
+            const lhs_result = try (try self.binOp(lhs_tmp, .{ .imm32 = 8 }, ty, .shr)).toLocal(self, ty);
             const rhs_wrap = try self.wrapOperand(msb, Type.u8);
-            const rhs_result = try self.binOp(rhs_wrap, .{ .imm32 = 16 }, ty, .shl);
+            const rhs_result = try (try self.binOp(rhs_wrap, .{ .imm32 = 16 }, ty, .shl)).toLocal(self, ty);
 
             const tmp = try self.binOp(lhs_result, rhs_result, ty, .@"or");
-            return self.binOp(tmp, lsb, ty, .@"or");
+            return (try self.binOp(tmp, lsb, ty, .@"or")).toLocal(self, ty);
         },
         32 => {
             const shl_tmp = try self.binOp(operand, .{ .imm32 = 8 }, ty, .shl);
-            const lhs = try self.binOp(shl_tmp, .{ .imm32 = 0xFF00FF00 }, ty, .@"and");
+            const lhs = try (try self.binOp(shl_tmp, .{ .imm32 = 0xFF00FF00 }, ty, .@"and")).toLocal(self, ty);
             const shr_tmp = try self.binOp(operand, .{ .imm32 = 8 }, ty, .shr);
-            const rhs = try self.binOp(shr_tmp, .{ .imm32 = 0xFF00FF }, ty, .@"and");
-            const tmp_or = try self.binOp(lhs, rhs, ty, .@"or");
+            const rhs = try (try self.binOp(shr_tmp, .{ .imm32 = 0xFF00FF }, ty, .@"and")).toLocal(self, ty);
+            const tmp_or = try (try self.binOp(lhs, rhs, ty, .@"or")).toLocal(self, ty);
 
-            const shl = try self.binOp(tmp_or, .{ .imm32 = 16 }, ty, .shl);
-            const shr = try self.binOp(tmp_or, .{ .imm32 = 16 }, ty, .shr);
+            const shr = try (try self.binOp(tmp_or, .{ .imm32 = 16 }, ty, .shr)).toLocal(self, ty);
             const res = if (int_info.signedness == .signed) blk: {
                 break :blk try self.wrapOperand(shr, Type.u16);
             } else shr;
-            return self.binOp(shl, res, ty, .@"or");
+            const shl = try self.binOp(tmp_or, .{ .imm32 = 16 }, ty, .shl);
+            return (try self.binOp(shl, res, ty, .@"or")).toLocal(self, ty);
         },
         else => return self.fail("TODO: @byteSwap for integers with bitsize {d}", .{int_info.bits}),
     }
@@ -4902,7 +4922,7 @@ fn airDiv(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     if (ty.isSignedInt()) {
         return self.divSigned(lhs, rhs, ty);
     }
-    return self.binOp(lhs, rhs, ty, .div);
+    return (try self.binOp(lhs, rhs, ty, .div)).toLocal(self, ty);
 }
 
 fn airDivFloor(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -4914,7 +4934,7 @@ fn airDivFloor(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     const rhs = try self.resolveInst(bin_op.rhs);
 
     if (ty.isUnsignedInt()) {
-        return self.binOp(lhs, rhs, ty, .div);
+        return (try self.binOp(lhs, rhs, ty, .div)).toLocal(self, ty);
     } else if (ty.isSignedInt()) {
         const int_bits = ty.intInfo(self.target).bits;
         const wasm_bits = toWasmBits(int_bits) orelse {
@@ -4927,9 +4947,6 @@ fn airDivFloor(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             break :blk try self.signAbsValue(rhs, ty);
         } else rhs;
 
-        const div_result = try self.binOp(lhs_res, rhs_res, ty, .div);
-        const rem_result = try self.binOp(lhs_res, rhs_res, ty, .rem);
-
         const zero = switch (wasm_bits) {
             32 => WValue{ .imm32 = 0 },
             64 => WValue{ .imm64 = 0 },
@@ -4938,7 +4955,10 @@ fn airDivFloor(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         const lhs_less_than_zero = try self.cmp(lhs_res, zero, ty, .lt);
         const rhs_less_than_zero = try self.cmp(rhs_res, zero, ty, .lt);
 
-        try self.emitWValue(div_result);
+        const div_result = try self.allocLocal(ty);
+        // leave on stack
+        _ = try self.binOp(lhs_res, rhs_res, ty, .div);
+        try self.addLabel(.local_tee, div_result.local);
         try self.emitWValue(lhs_less_than_zero);
         try self.emitWValue(rhs_less_than_zero);
         switch (wasm_bits) {
@@ -4953,7 +4973,8 @@ fn airDivFloor(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             else => unreachable,
         }
         try self.emitWValue(div_result);
-        try self.emitWValue(rem_result);
+        // leave value on the stack
+        _ = try self.binOp(lhs_res, rhs_res, ty, .rem);
         try self.addTag(.select);
     } else {
         const float_bits = ty.floatBits(self.target);
@@ -5110,7 +5131,7 @@ fn airSatBinOp(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!WValue {
     }
 
     const wasm_bits = toWasmBits(int_info.bits).?;
-    const bin_result = try self.binOp(lhs, rhs, ty, op);
+    const bin_result = try (try self.binOp(lhs, rhs, ty, op)).toLocal(self, ty);
     if (wasm_bits != int_info.bits and op == .add) {
         const val: u64 = @intCast(u64, (@as(u65, 1) << @intCast(u7, int_info.bits)) - 1);
         const imm_val = switch (wasm_bits) {
@@ -5161,7 +5182,7 @@ fn signedSat(self: *Self, lhs_operand: WValue, rhs_operand: WValue, ty: Type, op
         else => unreachable,
     };
 
-    const bin_result = try self.binOp(lhs, rhs, ty, op);
+    const bin_result = try (try self.binOp(lhs, rhs, ty, op)).toLocal(self, ty);
     if (!is_wasm_bits) {
         const cmp_result_lt = try self.cmp(bin_result, max_wvalue, ty, .lt);
         try self.emitWValue(bin_result);
@@ -5185,14 +5206,14 @@ fn signedSat(self: *Self, lhs_operand: WValue, rhs_operand: WValue, ty: Type, op
         };
         const cmp_bin_result = try self.cmp(bin_result, lhs, ty, .lt);
         const cmp_zero_result = try self.cmp(rhs, zero, ty, if (op == .add) .lt else .gt);
-        const xor = try self.binOp(cmp_zero_result, cmp_bin_result, Type.u32, .xor); // comparisons always return i32, so provide u32 as type to xor.
         const cmp_bin_zero_result = try self.cmp(bin_result, zero, ty, .lt);
         try self.emitWValue(max_wvalue);
         try self.emitWValue(min_wvalue);
         try self.emitWValue(cmp_bin_zero_result);
         try self.addTag(.select);
         try self.emitWValue(bin_result);
-        try self.emitWValue(xor);
+        // leave on stack
+        _ = try self.binOp(cmp_zero_result, cmp_bin_result, Type.u32, .xor); // comparisons always return i32, so provide u32 as type to xor.
         try self.addTag(.select);
         try self.addLabel(.local_set, bin_result.local); // re-use local
         return bin_result;
@@ -5216,8 +5237,8 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     const result = try self.allocLocal(ty);
 
     if (wasm_bits == int_info.bits) {
-        const shl = try self.binOp(lhs, rhs, ty, .shl);
-        const shr = try self.binOp(shl, rhs, ty, .shr);
+        const shl = try (try self.binOp(lhs, rhs, ty, .shl)).toLocal(self, ty);
+        const shr = try (try self.binOp(shl, rhs, ty, .shr)).toLocal(self, ty);
         const cmp_result = try self.cmp(lhs, shr, ty, .neq);
 
         switch (wasm_bits) {
@@ -5258,9 +5279,9 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             else => unreachable,
         };
 
-        const shl_res = try self.binOp(lhs, shift_value, ty, .shl);
-        const shl = try self.binOp(shl_res, rhs, ty, .shl);
-        const shr = try self.binOp(shl, rhs, ty, .shr);
+        const shl_res = try (try self.binOp(lhs, shift_value, ty, .shl)).toLocal(self, ty);
+        const shl = try (try self.binOp(shl_res, rhs, ty, .shl)).toLocal(self, ty);
+        const shr = try (try self.binOp(shl, rhs, ty, .shr)).toLocal(self, ty);
         const cmp_result = try self.cmp(shl_res, shr, ty, .neq);
 
         switch (wasm_bits) {
@@ -5294,7 +5315,7 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         try self.emitWValue(cmp_result);
         try self.addTag(.select);
         try self.addLabel(.local_set, result.local);
-        const shift_result = try self.binOp(result, shift_value, ty, .shr);
+        const shift_result = try (try self.binOp(result, shift_value, ty, .shr)).toLocal(self, ty);
         if (is_signed) {
             return self.wrapOperand(shift_result, ty);
         }
-- 
2.54.0


From 305b113a53cd5905d837ea620e2bcae8912c5938 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Mon, 25 Jul 2022 07:10:56 +0200
Subject: [PATCH 084/290] wasm: keep result of `cmp` on the stack

By keeping the result on the stack, we prevent codegen
from generating unneccesary locals when we have subsequent instructions
that do not have to be re-used.
---
 src/arch/wasm/CodeGen.zig | 133 ++++++++++++++++----------------------
 1 file changed, 54 insertions(+), 79 deletions(-)

diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index cbe4b558610b603b3368614310a98a679456951b..4e88e044900e96eb20680457e159d4587b51632c 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -2659,10 +2659,14 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: std.math.CompareOperator) Inner
     const lhs = try self.resolveInst(bin_op.lhs);
     const rhs = try self.resolveInst(bin_op.rhs);
     const operand_ty = self.air.typeOf(bin_op.lhs);
-    return self.cmp(lhs, rhs, operand_ty, op);
+    return (try self.cmp(lhs, rhs, operand_ty, op)).toLocal(self, Type.u32); // comparison result is always 32 bits
 }
 
+/// Compares two operands.
+/// Asserts rhs is not a stack value when the lhs isn't a stack value either
+/// NOTE: This leaves the result on top of the stack, rather than a new local.
 fn cmp(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareOperator) InnerError!WValue {
+    assert(!(lhs != .stack and rhs == .stack));
     if (ty.zigTypeTag() == .Optional and !ty.optionalReprIsPayload()) {
         var buf: Type.Payload.ElemType = undefined;
         const payload_ty = ty.optionalChild(&buf);
@@ -2704,9 +2708,7 @@ fn cmp(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareOper
     });
     try self.addTag(Mir.Inst.Tag.fromOpcode(opcode));
 
-    const cmp_tmp = try self.allocLocal(Type.initTag(.i32)); // bool is always i32
-    try self.addLabel(.local_set, cmp_tmp.local);
-    return cmp_tmp;
+    return WValue{ .stack = {} };
 }
 
 fn cmpFloat16(self: *Self, lhs: WValue, rhs: WValue, op: std.math.CompareOperator) InnerError!WValue {
@@ -2729,9 +2731,7 @@ fn cmpFloat16(self: *Self, lhs: WValue, rhs: WValue, op: std.math.CompareOperato
     try self.emitWValue(ext_rhs);
     try self.addTag(Mir.Inst.Tag.fromOpcode(opcode));
 
-    const result = try self.allocLocal(Type.initTag(.i32)); // bool is always i32
-    try self.addLabel(.local_set, result.local);
-    return result;
+    return WValue{ .stack = {} };
 }
 
 fn airCmpVector(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -3982,13 +3982,16 @@ fn cmpOptionals(self: *Self, lhs: WValue, rhs: WValue, operand_ty: Type, op: std
     try self.addImm32(0);
     try self.addTag(if (op == .eq) .i32_ne else .i32_eq);
     try self.addLabel(.local_set, result.local);
-    return result;
+    try self.emitWValue(result);
+    return WValue{ .stack = {} };
 }
 
 /// Compares big integers by checking both its high bits and low bits.
+/// NOTE: Leaves the result of the comparison on top of the stack.
 /// TODO: Lower this to compiler_rt call when bitsize > 128
 fn cmpBigInt(self: *Self, lhs: WValue, rhs: WValue, operand_ty: Type, op: std.math.CompareOperator) InnerError!WValue {
     assert(operand_ty.abiSize(self.target) >= 16);
+    assert(!(lhs != .stack and rhs == .stack));
     if (operand_ty.intInfo(self.target).bits > 128) {
         return self.fail("TODO: Support cmpBigInt for integer bitsize: '{d}'", .{operand_ty.intInfo(self.target).bits});
     }
@@ -4012,20 +4015,15 @@ fn cmpBigInt(self: *Self, lhs: WValue, rhs: WValue, operand_ty: Type, op: std.ma
         },
         else => {
             const ty = if (operand_ty.isSignedInt()) Type.i64 else Type.u64;
-            const high_bit_eql = try self.cmp(lhs_high_bit, rhs_high_bit, ty, .eq);
-            const high_bit_cmp = try self.cmp(lhs_high_bit, rhs_high_bit, ty, op);
-            const low_bit_cmp = try self.cmp(lhs_low_bit, rhs_low_bit, ty, op);
-
-            try self.emitWValue(low_bit_cmp);
-            try self.emitWValue(high_bit_cmp);
-            try self.emitWValue(high_bit_eql);
+            // leave those value on top of the stack for '.select'
+            _ = try self.cmp(lhs_low_bit, rhs_low_bit, ty, op);
+            _ = try self.cmp(lhs_high_bit, rhs_high_bit, ty, op);
+            _ = try self.cmp(lhs_high_bit, rhs_high_bit, ty, .eq);
             try self.addTag(.select);
         },
     }
 
-    const result = try self.allocLocal(Type.initTag(.i32));
-    try self.addLabel(.local_set, result.local);
-    return result;
+    return WValue{ .stack = {} };
 }
 
 fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -4350,7 +4348,7 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!W
         if (wasm_bits == int_info.bits) {
             const cmp_zero = try self.cmp(rhs, zero, lhs_ty, cmp_op);
             const lt = try self.cmp(bin_op, lhs, lhs_ty, .lt);
-            break :blk try (try self.binOp(cmp_zero, lt, Type.u32, .xor)).toLocal(self, Type.u32); // result of cmp_zero and lt is always 32bit
+            break :blk try self.binOp(cmp_zero, lt, Type.u32, .xor);
         }
         const abs = try self.signAbsValue(bin_op, lhs_ty);
         break :blk try self.cmp(abs, bin_op, lhs_ty, .neq);
@@ -4358,11 +4356,12 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!W
         try self.cmp(bin_op, lhs, lhs_ty, cmp_op)
     else
         try self.cmp(bin_op, result, lhs_ty, .neq);
+    const overflow_local = try overflow_bit.toLocal(self, Type.u32);
 
     const result_ptr = try self.allocStack(self.air.typeOfIndex(inst));
     try self.store(result_ptr, result, lhs_ty, 0);
     const offset = @intCast(u32, lhs_ty.abiSize(self.target));
-    try self.store(result_ptr, overflow_bit, Type.initTag(.u1), offset);
+    try self.store(result_ptr, overflow_local, Type.initTag(.u1), offset);
 
     return result_ptr;
 }
@@ -4384,9 +4383,9 @@ fn airAddSubWithOverflowBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type,
     const high_op_res = try (try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, op)).toLocal(self, Type.u64);
 
     const lt = if (op == .add) blk: {
-        break :blk try self.cmp(high_op_res, lhs_high_bit, Type.u64, .lt);
+        break :blk try (try self.cmp(high_op_res, lhs_high_bit, Type.u64, .lt)).toLocal(self, Type.u32);
     } else if (op == .sub) blk: {
-        break :blk try self.cmp(lhs_high_bit, rhs_high_bit, Type.u64, .lt);
+        break :blk try (try self.cmp(lhs_high_bit, rhs_high_bit, Type.u64, .lt)).toLocal(self, Type.u32);
     } else unreachable;
     const tmp = try self.intcast(lt, Type.u32, Type.u64);
     const tmp_op = try (try self.binOp(low_op_res, tmp, Type.u64, op)).toLocal(self, Type.u64);
@@ -4400,27 +4399,23 @@ fn airAddSubWithOverflowBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type,
         const wrap = try self.binOp(to_wrap, xor_op, Type.u64, .@"and");
         break :blk try self.cmp(wrap, .{ .imm64 = 0 }, Type.i64, .lt); // i64 because signed
     } else blk: {
-        const eq = try self.cmp(tmp_op, lhs_low_bit, Type.u64, .eq);
-        const op_eq = try self.cmp(tmp_op, lhs_low_bit, Type.u64, if (op == .add) .lt else .gt);
-
         const first_arg = if (op == .sub) arg: {
             break :arg try self.cmp(high_op_res, lhs_high_bit, Type.u64, .gt);
         } else lt;
 
         try self.emitWValue(first_arg);
-        try self.emitWValue(op_eq);
-        try self.emitWValue(eq);
+        _ = try self.cmp(tmp_op, lhs_low_bit, Type.u64, if (op == .add) .lt else .gt);
+        _ = try self.cmp(tmp_op, lhs_low_bit, Type.u64, .eq);
         try self.addTag(.select);
 
-        const overflow_bit = try self.allocLocal(Type.initTag(.u1));
-        try self.addLabel(.local_set, overflow_bit.local);
-        break :blk overflow_bit;
+        break :blk WValue{ .stack = {} };
     };
+    const overflow_local = try overflow_bit.toLocal(self, Type.initTag(.u1));
 
     const result_ptr = try self.allocStack(result_ty);
     try self.store(result_ptr, high_op_res, Type.u64, 0);
     try self.store(result_ptr, tmp_op, Type.u64, 8);
-    try self.store(result_ptr, overflow_bit, Type.initTag(.u1), 16);
+    try self.store(result_ptr, overflow_local, Type.initTag(.u1), 16);
 
     return result_ptr;
 }
@@ -4455,11 +4450,12 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         const shr = try (try self.binOp(result, rhs, lhs_ty, .shr)).toLocal(self, lhs_ty);
         break :blk try self.cmp(lhs, shr, lhs_ty, .neq);
     };
+    const overflow_local = try overflow_bit.toLocal(self, Type.initTag(.u1));
 
     const result_ptr = try self.allocStack(self.air.typeOfIndex(inst));
     try self.store(result_ptr, result, lhs_ty, 0);
     const offset = @intCast(u32, lhs_ty.abiSize(self.target));
-    try self.store(result_ptr, overflow_bit, Type.initTag(.u1), offset);
+    try self.store(result_ptr, overflow_local, Type.initTag(.u1), offset);
 
     return result_ptr;
 }
@@ -4502,8 +4498,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         if (int_info.signedness == .unsigned) {
             const shr = try self.binOp(bin_op, .{ .imm64 = int_info.bits }, new_ty, .shr);
             const wrap = try self.intcast(shr, new_ty, lhs_ty);
-            const cmp_res = try self.cmp(wrap, zero, lhs_ty, .neq);
-            try self.emitWValue(cmp_res);
+            _ = try self.cmp(wrap, zero, lhs_ty, .neq);
             try self.addLabel(.local_set, overflow_bit.local);
             break :blk try self.intcast(bin_op, new_ty, lhs_ty);
         } else {
@@ -4512,8 +4507,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
 
             const shr_res = try self.binOp(bin_op, .{ .imm64 = int_info.bits }, new_ty, .shr);
             const down_shr_res = try self.intcast(shr_res, new_ty, lhs_ty);
-            const cmp_res = try self.cmp(down_shr_res, shr, lhs_ty, .neq);
-            try self.emitWValue(cmp_res);
+            _ = try self.cmp(down_shr_res, shr, lhs_ty, .neq);
             try self.addLabel(.local_set, overflow_bit.local);
             break :blk down_cast;
         }
@@ -4522,8 +4516,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         const rhs_abs = try self.signAbsValue(rhs, lhs_ty);
         const bin_op = try (try self.binOp(lhs_abs, rhs_abs, lhs_ty, .mul)).toLocal(self, lhs_ty);
         const mul_abs = try self.signAbsValue(bin_op, lhs_ty);
-        const cmp_op = try self.cmp(mul_abs, bin_op, lhs_ty, .neq);
-        try self.emitWValue(cmp_op);
+        _ = try self.cmp(mul_abs, bin_op, lhs_ty, .neq);
         try self.addLabel(.local_set, overflow_bit.local);
         break :blk try self.wrapOperand(bin_op, lhs_ty);
     } else blk: {
@@ -4533,8 +4526,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         else
             WValue{ .imm64 = int_info.bits };
         const shr = try self.binOp(bin_op, shift_imm, lhs_ty, .shr);
-        const cmp_op = try self.cmp(shr, zero, lhs_ty, .neq);
-        try self.emitWValue(cmp_op);
+        _ = try self.cmp(shr, zero, lhs_ty, .neq);
         try self.addLabel(.local_set, overflow_bit.local);
         break :blk try self.wrapOperand(bin_op, lhs_ty);
     };
@@ -4562,12 +4554,10 @@ fn airMaxMin(self: *Self, inst: Air.Inst.Index, op: enum { max, min }) InnerErro
     const lhs = try self.resolveInst(bin_op.lhs);
     const rhs = try self.resolveInst(bin_op.rhs);
 
-    const cmp_result = try self.cmp(lhs, rhs, ty, if (op == .max) .gt else .lt);
-
     // operands to select from
     try self.lowerToStack(lhs);
     try self.lowerToStack(rhs);
-    try self.emitWValue(cmp_result);
+    _ = try self.cmp(lhs, rhs, ty, if (op == .max) .gt else .lt);
 
     // based on the result from comparison, return operand 0 or 1.
     try self.addTag(.select);
@@ -4638,7 +4628,6 @@ fn airClz(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         128 => {
             const msb = try self.load(operand, Type.u64, 0);
             const lsb = try self.load(operand, Type.u64, 8);
-            const neq = try self.cmp(lsb, .{ .imm64 = 0 }, Type.u64, .neq);
 
             try self.emitWValue(lsb);
             try self.addTag(.i64_clz);
@@ -4646,7 +4635,7 @@ fn airClz(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             try self.addTag(.i64_clz);
             try self.emitWValue(.{ .imm64 = 64 });
             try self.addTag(.i64_add);
-            try self.emitWValue(neq);
+            _ = try self.cmp(lsb, .{ .imm64 = 0 }, Type.u64, .neq);
             try self.addTag(.select);
             try self.addTag(.i32_wrap_i64);
         },
@@ -4700,7 +4689,6 @@ fn airCtz(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         128 => {
             const msb = try self.load(operand, Type.u64, 0);
             const lsb = try self.load(operand, Type.u64, 8);
-            const neq = try self.cmp(msb, .{ .imm64 = 0 }, Type.u64, .neq);
 
             try self.emitWValue(msb);
             try self.addTag(.i64_ctz);
@@ -4716,7 +4704,7 @@ fn airCtz(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             } else {
                 try self.addTag(.i64_add);
             }
-            try self.emitWValue(neq);
+            _ = try self.cmp(msb, .{ .imm64 = 0 }, Type.u64, .neq);
             try self.addTag(.select);
             try self.addTag(.i32_wrap_i64);
         },
@@ -4952,15 +4940,13 @@ fn airDivFloor(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             64 => WValue{ .imm64 = 0 },
             else => unreachable,
         };
-        const lhs_less_than_zero = try self.cmp(lhs_res, zero, ty, .lt);
-        const rhs_less_than_zero = try self.cmp(rhs_res, zero, ty, .lt);
 
         const div_result = try self.allocLocal(ty);
         // leave on stack
         _ = try self.binOp(lhs_res, rhs_res, ty, .div);
         try self.addLabel(.local_tee, div_result.local);
-        try self.emitWValue(lhs_less_than_zero);
-        try self.emitWValue(rhs_less_than_zero);
+        _ = try self.cmp(lhs_res, zero, ty, .lt);
+        _ = try self.cmp(rhs_res, zero, ty, .lt);
         switch (wasm_bits) {
             32 => {
                 try self.addTag(.i32_xor);
@@ -5140,19 +5126,17 @@ fn airSatBinOp(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!WValue {
             else => unreachable,
         };
 
-        const cmp_result = try self.cmp(bin_result, imm_val, ty, .lt);
         try self.emitWValue(bin_result);
         try self.emitWValue(imm_val);
-        try self.emitWValue(cmp_result);
+        _ = try self.cmp(bin_result, imm_val, ty, .lt);
     } else {
-        const cmp_result = try self.cmp(bin_result, lhs, ty, if (op == .add) .lt else .gt);
         switch (wasm_bits) {
             32 => try self.addImm32(if (op == .add) @as(i32, -1) else 0),
             64 => try self.addImm64(if (op == .add) @bitCast(u64, @as(i64, -1)) else 0),
             else => unreachable,
         }
         try self.emitWValue(bin_result);
-        try self.emitWValue(cmp_result);
+        _ = try self.cmp(bin_result, lhs, ty, if (op == .add) .lt else .gt);
     }
 
     try self.addTag(.select);
@@ -5184,17 +5168,15 @@ fn signedSat(self: *Self, lhs_operand: WValue, rhs_operand: WValue, ty: Type, op
 
     const bin_result = try (try self.binOp(lhs, rhs, ty, op)).toLocal(self, ty);
     if (!is_wasm_bits) {
-        const cmp_result_lt = try self.cmp(bin_result, max_wvalue, ty, .lt);
         try self.emitWValue(bin_result);
         try self.emitWValue(max_wvalue);
-        try self.emitWValue(cmp_result_lt);
+        _ = try self.cmp(bin_result, max_wvalue, ty, .lt);
         try self.addTag(.select);
         try self.addLabel(.local_set, bin_result.local); // re-use local
 
-        const cmp_result_gt = try self.cmp(bin_result, min_wvalue, ty, .gt);
         try self.emitWValue(bin_result);
         try self.emitWValue(min_wvalue);
-        try self.emitWValue(cmp_result_gt);
+        _ = try self.cmp(bin_result, min_wvalue, ty, .gt);
         try self.addTag(.select);
         try self.addLabel(.local_set, bin_result.local); // re-use local
         return self.wrapOperand(bin_result, ty);
@@ -5204,15 +5186,14 @@ fn signedSat(self: *Self, lhs_operand: WValue, rhs_operand: WValue, ty: Type, op
             64 => WValue{ .imm64 = 0 },
             else => unreachable,
         };
-        const cmp_bin_result = try self.cmp(bin_result, lhs, ty, .lt);
+        try self.emitWValue(max_wvalue);
+        try self.emitWValue(min_wvalue);
+        _ = try self.cmp(bin_result, zero, ty, .lt);
+        try self.addTag(.select);
+        try self.emitWValue(bin_result);
+        // leave on stack
         const cmp_zero_result = try self.cmp(rhs, zero, ty, if (op == .add) .lt else .gt);
-        const cmp_bin_zero_result = try self.cmp(bin_result, zero, ty, .lt);
-        try self.emitWValue(max_wvalue);
-        try self.emitWValue(min_wvalue);
-        try self.emitWValue(cmp_bin_zero_result);
-        try self.addTag(.select);
-        try self.emitWValue(bin_result);
-        // leave on stack
+        const cmp_bin_result = try self.cmp(bin_result, lhs, ty, .lt);
         _ = try self.binOp(cmp_zero_result, cmp_bin_result, Type.u32, .xor); // comparisons always return i32, so provide u32 as type to xor.
         try self.addTag(.select);
         try self.addLabel(.local_set, bin_result.local); // re-use local
@@ -5239,7 +5220,6 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     if (wasm_bits == int_info.bits) {
         const shl = try (try self.binOp(lhs, rhs, ty, .shl)).toLocal(self, ty);
         const shr = try (try self.binOp(shl, rhs, ty, .shr)).toLocal(self, ty);
-        const cmp_result = try self.cmp(lhs, shr, ty, .neq);
 
         switch (wasm_bits) {
             32 => blk: {
@@ -5247,10 +5227,9 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
                     try self.addImm32(-1);
                     break :blk;
                 }
-                const less_than_zero = try self.cmp(lhs, .{ .imm32 = 0 }, ty, .lt);
                 try self.addImm32(std.math.minInt(i32));
                 try self.addImm32(std.math.maxInt(i32));
-                try self.emitWValue(less_than_zero);
+                _ = try self.cmp(lhs, .{ .imm32 = 0 }, ty, .lt);
                 try self.addTag(.select);
             },
             64 => blk: {
@@ -5258,16 +5237,15 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
                     try self.addImm64(@bitCast(u64, @as(i64, -1)));
                     break :blk;
                 }
-                const less_than_zero = try self.cmp(lhs, .{ .imm64 = 0 }, ty, .lt);
                 try self.addImm64(@bitCast(u64, @as(i64, std.math.minInt(i64))));
                 try self.addImm64(@bitCast(u64, @as(i64, std.math.maxInt(i64))));
-                try self.emitWValue(less_than_zero);
+                _ = try self.cmp(lhs, .{ .imm64 = 0 }, ty, .lt);
                 try self.addTag(.select);
             },
             else => unreachable,
         }
         try self.emitWValue(shl);
-        try self.emitWValue(cmp_result);
+        _ = try self.cmp(lhs, shr, ty, .neq);
         try self.addTag(.select);
         try self.addLabel(.local_set, result.local);
         return result;
@@ -5282,7 +5260,6 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         const shl_res = try (try self.binOp(lhs, shift_value, ty, .shl)).toLocal(self, ty);
         const shl = try (try self.binOp(shl_res, rhs, ty, .shl)).toLocal(self, ty);
         const shr = try (try self.binOp(shl, rhs, ty, .shr)).toLocal(self, ty);
-        const cmp_result = try self.cmp(shl_res, shr, ty, .neq);
 
         switch (wasm_bits) {
             32 => blk: {
@@ -5291,10 +5268,9 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
                     break :blk;
                 }
 
-                const less_than_zero = try self.cmp(shl_res, .{ .imm32 = 0 }, ty, .lt);
                 try self.addImm32(std.math.minInt(i32));
                 try self.addImm32(std.math.maxInt(i32));
-                try self.emitWValue(less_than_zero);
+                _ = try self.cmp(shl_res, .{ .imm32 = 0 }, ty, .lt);
                 try self.addTag(.select);
             },
             64 => blk: {
@@ -5303,16 +5279,15 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
                     break :blk;
                 }
 
-                const less_than_zero = try self.cmp(shl_res, .{ .imm64 = 0 }, ty, .lt);
                 try self.addImm64(@bitCast(u64, @as(i64, std.math.minInt(i64))));
                 try self.addImm64(@bitCast(u64, @as(i64, std.math.maxInt(i64))));
-                try self.emitWValue(less_than_zero);
+                _ = try self.cmp(shl_res, .{ .imm64 = 0 }, ty, .lt);
                 try self.addTag(.select);
             },
             else => unreachable,
         }
         try self.emitWValue(shl);
-        try self.emitWValue(cmp_result);
+        _ = try self.cmp(shl_res, shr, ty, .neq);
         try self.addTag(.select);
         try self.addLabel(.local_set, result.local);
         const shift_result = try (try self.binOp(result, shift_value, ty, .shr)).toLocal(self, ty);
-- 
2.54.0


From 699bc6171dcc18d681de754ca2eeb63645aea889 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Mon, 25 Jul 2022 16:27:26 +0200
Subject: [PATCH 085/290] wasm: Keep `intcast` values on stack

---
 src/arch/wasm/CodeGen.zig | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index 4e88e044900e96eb20680457e159d4587b51632c..c91edca37d9122d1b7cbece626f520acb358d1b8 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -2153,8 +2153,8 @@ fn binOpBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerErr
     const rhs_high_bit = try self.load(rhs, Type.u64, 0);
     const rhs_low_bit = try self.load(rhs, Type.u64, 8);
 
-    const low_op_res = try (try self.binOp(lhs_low_bit, rhs_low_bit, Type.u64, op)).toLocal(self, Type.u64);
     const high_op_res = try (try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, op)).toLocal(self, Type.u64);
+    const low_op_res = try self.binOp(lhs_low_bit, rhs_low_bit, Type.u64, op);
 
     const lt = if (op == .add) blk: {
         break :blk try self.cmp(high_op_res, rhs_high_bit, Type.u64, .lt);
@@ -3190,12 +3190,13 @@ fn airIntcast(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         return self.fail("todo Wasm intcast for bitsize > 128", .{});
     }
 
-    return self.intcast(operand, operand_ty, ty);
+    return (try self.intcast(operand, operand_ty, ty)).toLocal(self, ty);
 }
 
 /// Upcasts or downcasts an integer based on the given and wanted types,
 /// and stores the result in a new operand.
 /// Asserts type's bitsize <= 128
+/// NOTE: May leave the result on the top of the stack.
 fn intcast(self: *Self, operand: WValue, given: Type, wanted: Type) InnerError!WValue {
     const given_info = given.intInfo(self.target);
     const wanted_info = wanted.intInfo(self.target);
@@ -3227,7 +3228,7 @@ fn intcast(self: *Self, operand: WValue, given: Type, wanted: Type) InnerError!W
                 given,
                 if (wanted.isSignedInt()) Type.i64 else Type.u64,
             );
-            break :blk tmp;
+            break :blk try tmp.toLocal(self, Type.u64);
         } else operand;
 
         // store msb first
@@ -3244,9 +3245,7 @@ fn intcast(self: *Self, operand: WValue, given: Type, wanted: Type) InnerError!W
         return stack_ptr;
     } else return self.load(operand, wanted, 0);
 
-    const result = try self.allocLocal(wanted);
-    try self.addLabel(.local_set, result.local);
-    return result;
+    return WValue{ .stack = {} };
 }
 
 fn airIsNull(self: *Self, inst: Air.Inst.Index, opcode: wasm.Opcode, op_kind: enum { value, ptr }) InnerError!WValue {
@@ -3478,7 +3477,7 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     if (wasm_bits != wanted_bits) {
         return self.wrapOperand(result, wanted_ty);
     }
-    return result;
+    return result.toLocal(self, wanted_ty);
 }
 
 fn airBoolToInt(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -4387,7 +4386,7 @@ fn airAddSubWithOverflowBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type,
     } else if (op == .sub) blk: {
         break :blk try (try self.cmp(lhs_high_bit, rhs_high_bit, Type.u64, .lt)).toLocal(self, Type.u32);
     } else unreachable;
-    const tmp = try self.intcast(lt, Type.u32, Type.u64);
+    const tmp = try (try self.intcast(lt, Type.u32, Type.u64)).toLocal(self, Type.u64);
     const tmp_op = try (try self.binOp(low_op_res, tmp, Type.u64, op)).toLocal(self, Type.u64);
 
     const overflow_bit = if (is_signed) blk: {
@@ -4500,9 +4499,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             const wrap = try self.intcast(shr, new_ty, lhs_ty);
             _ = try self.cmp(wrap, zero, lhs_ty, .neq);
             try self.addLabel(.local_set, overflow_bit.local);
-            break :blk try self.intcast(bin_op, new_ty, lhs_ty);
+            break :blk try (try self.intcast(bin_op, new_ty, lhs_ty)).toLocal(self, lhs_ty);
         } else {
-            const down_cast = try self.intcast(bin_op, new_ty, lhs_ty);
+            const down_cast = try (try self.intcast(bin_op, new_ty, lhs_ty)).toLocal(self, lhs_ty);
             const shr = try (try self.binOp(down_cast, .{ .imm32 = int_info.bits - 1 }, lhs_ty, .shr)).toLocal(self, lhs_ty);
 
             const shr_res = try self.binOp(bin_op, .{ .imm64 = int_info.bits }, new_ty, .shr);
-- 
2.54.0


From cde16f61eb41f2beda85e838331a30869e420c68 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Tue, 26 Jul 2022 16:46:58 +0200
Subject: [PATCH 086/290] wasm: `wrapOperand` - leave value on the stack

This also does it for `wrapBinOp` which internally uses the already
refactored `binOp` and `wrapOperand` heavily simplifying this
function and not duplicate the logic from `binOp`
---
 src/arch/wasm/CodeGen.zig | 85 +++++++++++++++------------------------
 1 file changed, 33 insertions(+), 52 deletions(-)

diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index c91edca37d9122d1b7cbece626f520acb358d1b8..75e989764ff065f924966aac348616fa9a731b1a 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -2179,40 +2179,22 @@ fn airWrapBinOp(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!WValue {
         return self.fail("TODO: Implement wrapping arithmetic for vectors", .{});
     }
 
-    return self.wrapBinOp(lhs, rhs, ty, op);
+    return (try self.wrapBinOp(lhs, rhs, ty, op)).toLocal(self, ty);
 }
 
+/// Performs a wrapping binary operation.
+/// Asserts rhs is not a stack value when lhs also isn't.
+/// NOTE: Leaves the result on the stack when its Type is <= 64 bits
 fn wrapBinOp(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WValue {
-    const bit_size = ty.intInfo(self.target).bits;
-    var wasm_bits = toWasmBits(bit_size) orelse {
-        return self.fail("TODO: Implement wrapping arithmetic for integers with bitsize: {d}\n", .{bit_size});
-    };
-
-    if (wasm_bits == 128) {
-        const bin_op = try self.binOpBigInt(lhs, rhs, ty, op);
-        return self.wrapOperand(bin_op, ty);
-    }
-
-    const opcode: wasm.Opcode = buildOpcode(.{
-        .op = op,
-        .valtype1 = typeToValtype(ty, self.target),
-        .signedness = if (ty.isSignedInt()) .signed else .unsigned,
-    });
-
-    try self.emitWValue(lhs);
-    try self.emitWValue(rhs);
-    try self.addTag(Mir.Inst.Tag.fromOpcode(opcode));
-    const bin_local = try self.allocLocal(ty);
-    try self.addLabel(.local_set, bin_local.local);
-
+    const bin_local = try self.binOp(lhs, rhs, ty, op);
     return self.wrapOperand(bin_local, ty);
 }
 
 /// Wraps an operand based on a given type's bitsize.
 /// Asserts `Type` is <= 128 bits.
+/// NOTE: When the Type is <= 64 bits, leaves the value on top of the stack.
 fn wrapOperand(self: *Self, operand: WValue, ty: Type) InnerError!WValue {
     assert(ty.abiSize(self.target) <= 16);
-    const result_local = try self.allocLocal(ty);
     const bitsize = ty.intInfo(self.target).bits;
     const wasm_bits = toWasmBits(bitsize) orelse {
         return self.fail("TODO: Implement wrapOperand for bitsize '{d}'", .{bitsize});
@@ -2246,8 +2228,7 @@ fn wrapOperand(self: *Self, operand: WValue, ty: Type) InnerError!WValue {
         try self.addTag(.i64_and);
     } else unreachable;
 
-    try self.addLabel(.local_set, result_local.local);
-    return result_local;
+    return WValue{ .stack = {} };
 }
 
 fn lowerParentPtr(self: *Self, ptr_val: Value, ptr_child_ty: Type) InnerError!WValue {
@@ -3471,11 +3452,11 @@ fn airTrunc(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         return self.fail("TODO: Implement wasm integer truncation for integer bitsize: {d}", .{int_info.bits});
     }
 
-    const result = try self.intcast(operand, op_ty, wanted_ty);
+    var result = try self.intcast(operand, op_ty, wanted_ty);
     const wanted_bits = wanted_ty.intInfo(self.target).bits;
     const wasm_bits = toWasmBits(wanted_bits).?;
     if (wasm_bits != wanted_bits) {
-        return self.wrapOperand(result, wanted_ty);
+        result = try self.wrapOperand(result, wanted_ty);
     }
     return result.toLocal(self, wanted_ty);
 }
@@ -3749,11 +3730,8 @@ fn airFloatToInt(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         .signedness = if (dest_ty.isSignedInt()) .signed else .unsigned,
     });
     try self.addTag(Mir.Inst.Tag.fromOpcode(op));
-
-    const result = try self.allocLocal(dest_ty);
-    try self.addLabel(.local_set, result.local);
-
-    return self.wrapOperand(result, dest_ty);
+    const wrapped = try self.wrapOperand(.{ .stack = {} }, dest_ty);
+    return wrapped.toLocal(self, dest_ty);
 }
 
 fn airIntToFloat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -4339,7 +4317,7 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!W
 
     const bin_op = try (try self.binOp(lhs, rhs, lhs_ty, op)).toLocal(self, lhs_ty);
     const result = if (wasm_bits != int_info.bits) blk: {
-        break :blk try self.wrapOperand(bin_op, lhs_ty);
+        break :blk try (try self.wrapOperand(bin_op, lhs_ty)).toLocal(self, lhs_ty);
     } else bin_op;
 
     const cmp_op: std.math.CompareOperator = if (op == .sub) .gt else .lt;
@@ -4438,13 +4416,15 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
 
     const shl = try (try self.binOp(lhs, rhs, lhs_ty, .shl)).toLocal(self, lhs_ty);
     const result = if (wasm_bits != int_info.bits) blk: {
-        break :blk try self.wrapOperand(shl, lhs_ty);
+        break :blk try (try self.wrapOperand(shl, lhs_ty)).toLocal(self, lhs_ty);
     } else shl;
 
     const overflow_bit = if (wasm_bits != int_info.bits and is_signed) blk: {
         const abs = try self.signAbsValue(shl, lhs_ty);
+        // emit lhs to stack to we can keep 'wrapped' on the stack also
+        try self.emitWValue(lhs);
         const wrapped = try self.wrapBinOp(abs, rhs, lhs_ty, .shr);
-        break :blk try self.cmp(lhs, wrapped, lhs_ty, .neq);
+        break :blk try self.cmp(.{ .stack = {} }, wrapped, lhs_ty, .neq);
     } else blk: {
         const shr = try (try self.binOp(result, rhs, lhs_ty, .shr)).toLocal(self, lhs_ty);
         break :blk try self.cmp(lhs, shr, lhs_ty, .neq);
@@ -4499,7 +4479,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             const wrap = try self.intcast(shr, new_ty, lhs_ty);
             _ = try self.cmp(wrap, zero, lhs_ty, .neq);
             try self.addLabel(.local_set, overflow_bit.local);
-            break :blk try (try self.intcast(bin_op, new_ty, lhs_ty)).toLocal(self, lhs_ty);
+            break :blk try self.intcast(bin_op, new_ty, lhs_ty);
         } else {
             const down_cast = try (try self.intcast(bin_op, new_ty, lhs_ty)).toLocal(self, lhs_ty);
             const shr = try (try self.binOp(down_cast, .{ .imm32 = int_info.bits - 1 }, lhs_ty, .shr)).toLocal(self, lhs_ty);
@@ -4529,9 +4509,10 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         try self.addLabel(.local_set, overflow_bit.local);
         break :blk try self.wrapOperand(bin_op, lhs_ty);
     };
+    const bin_op_local = try bin_op.toLocal(self, lhs_ty);
 
     const result_ptr = try self.allocStack(self.air.typeOfIndex(inst));
-    try self.store(result_ptr, bin_op, lhs_ty, 0);
+    try self.store(result_ptr, bin_op_local, lhs_ty, 0);
     const offset = @intCast(u32, lhs_ty.abiSize(self.target));
     try self.store(result_ptr, overflow_bit, Type.initTag(.u1), offset);
 
@@ -4854,29 +4835,29 @@ fn airByteSwap(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     switch (int_info.bits) {
         16 => {
             const shl_res = try self.binOp(operand, .{ .imm32 = 8 }, ty, .shl);
-            const lhs = try (try self.binOp(shl_res, .{ .imm32 = 0xFF00 }, ty, .@"and")).toLocal(self, ty);
-            const shr_res = try (try self.binOp(operand, .{ .imm32 = 8 }, ty, .shr)).toLocal(self, ty);
+            const lhs = try self.binOp(shl_res, .{ .imm32 = 0xFF00 }, ty, .@"and");
+            const shr_res = try self.binOp(operand, .{ .imm32 = 8 }, ty, .shr);
             const res = if (int_info.signedness == .signed) blk: {
                 break :blk try self.wrapOperand(shr_res, Type.u8);
             } else shr_res;
             return (try self.binOp(lhs, res, ty, .@"or")).toLocal(self, ty);
         },
         24 => {
-            const msb = try self.wrapOperand(operand, Type.u16);
-            const lsb = try self.wrapBinOp(operand, .{ .imm32 = 16 }, Type.u8, .shr);
+            const msb = try (try self.wrapOperand(operand, Type.u16)).toLocal(self, Type.u16);
 
             const shl_res = try self.binOp(msb, .{ .imm32 = 8 }, Type.u16, .shl);
-            const lhs = try (try self.binOp(shl_res, .{ .imm32 = 0xFF0000 }, Type.u16, .@"and")).toLocal(self, Type.u16);
-            const shr_res = try (try self.binOp(msb, .{ .imm32 = 8 }, ty, .shr)).toLocal(self, ty);
+            const lhs = try self.binOp(shl_res, .{ .imm32 = 0xFF0000 }, Type.u16, .@"and");
+            const shr_res = try self.binOp(msb, .{ .imm32 = 8 }, ty, .shr);
 
             const res = if (int_info.signedness == .signed) blk: {
                 break :blk try self.wrapOperand(shr_res, Type.u8);
             } else shr_res;
             const lhs_tmp = try self.binOp(lhs, res, ty, .@"or");
-            const lhs_result = try (try self.binOp(lhs_tmp, .{ .imm32 = 8 }, ty, .shr)).toLocal(self, ty);
+            const lhs_result = try self.binOp(lhs_tmp, .{ .imm32 = 8 }, ty, .shr);
             const rhs_wrap = try self.wrapOperand(msb, Type.u8);
-            const rhs_result = try (try self.binOp(rhs_wrap, .{ .imm32 = 16 }, ty, .shl)).toLocal(self, ty);
+            const rhs_result = try self.binOp(rhs_wrap, .{ .imm32 = 16 }, ty, .shl);
 
+            const lsb = try self.wrapBinOp(operand, .{ .imm32 = 16 }, Type.u8, .shr);
             const tmp = try self.binOp(lhs_result, rhs_result, ty, .@"or");
             return (try self.binOp(tmp, lsb, ty, .@"or")).toLocal(self, ty);
         },
@@ -4887,11 +4868,11 @@ fn airByteSwap(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             const rhs = try (try self.binOp(shr_tmp, .{ .imm32 = 0xFF00FF }, ty, .@"and")).toLocal(self, ty);
             const tmp_or = try (try self.binOp(lhs, rhs, ty, .@"or")).toLocal(self, ty);
 
-            const shr = try (try self.binOp(tmp_or, .{ .imm32 = 16 }, ty, .shr)).toLocal(self, ty);
+            const shl = try self.binOp(tmp_or, .{ .imm32 = 16 }, ty, .shl);
+            const shr = try self.binOp(tmp_or, .{ .imm32 = 16 }, ty, .shr);
             const res = if (int_info.signedness == .signed) blk: {
                 break :blk try self.wrapOperand(shr, Type.u16);
             } else shr;
-            const shl = try self.binOp(tmp_or, .{ .imm32 = 16 }, ty, .shl);
             return (try self.binOp(shl, res, ty, .@"or")).toLocal(self, ty);
         },
         else => return self.fail("TODO: @byteSwap for integers with bitsize {d}", .{int_info.bits}),
@@ -5178,7 +5159,7 @@ fn signedSat(self: *Self, lhs_operand: WValue, rhs_operand: WValue, ty: Type, op
         _ = try self.cmp(bin_result, min_wvalue, ty, .gt);
         try self.addTag(.select);
         try self.addLabel(.local_set, bin_result.local); // re-use local
-        return self.wrapOperand(bin_result, ty);
+        return (try self.wrapOperand(bin_result, ty)).toLocal(self, ty);
     } else {
         const zero = switch (wasm_bits) {
             32 => WValue{ .imm32 = 0 },
@@ -5289,11 +5270,11 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         _ = try self.cmp(shl_res, shr, ty, .neq);
         try self.addTag(.select);
         try self.addLabel(.local_set, result.local);
-        const shift_result = try (try self.binOp(result, shift_value, ty, .shr)).toLocal(self, ty);
+        var shift_result = try self.binOp(result, shift_value, ty, .shr);
         if (is_signed) {
-            return self.wrapOperand(shift_result, ty);
+            shift_result = try self.wrapOperand(shift_result, ty);
         }
-        return shift_result;
+        return try shift_result.toLocal(self, ty);
     }
 }
 
-- 
2.54.0


From 3cd0cd12a08435fca5f5b2b6788ff519abfc6184 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Tue, 26 Jul 2022 17:24:18 +0200
Subject: [PATCH 087/290] wasm: leave `signedAbsValue` values on the stack

---
 src/arch/wasm/CodeGen.zig | 32 ++++++++++++++++++--------------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index 75e989764ff065f924966aac348616fa9a731b1a..2ee6a76401a3d5f4222c6c0169bdfbd715c09062 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -4309,10 +4309,10 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!W
     // for signed integers, we first apply signed shifts by the difference in bits
     // to get the signed value, as we store it internally as 2's complement.
     const lhs = if (wasm_bits != int_info.bits and is_signed) blk: {
-        break :blk try self.signAbsValue(lhs_op, lhs_ty);
+        break :blk try (try self.signAbsValue(lhs_op, lhs_ty)).toLocal(self, lhs_ty);
     } else lhs_op;
     const rhs = if (wasm_bits != int_info.bits and is_signed) blk: {
-        break :blk try self.signAbsValue(rhs_op, lhs_ty);
+        break :blk try (try self.signAbsValue(rhs_op, lhs_ty)).toLocal(self, lhs_ty);
     } else rhs_op;
 
     const bin_op = try (try self.binOp(lhs, rhs, lhs_ty, op)).toLocal(self, lhs_ty);
@@ -4420,9 +4420,9 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     } else shl;
 
     const overflow_bit = if (wasm_bits != int_info.bits and is_signed) blk: {
-        const abs = try self.signAbsValue(shl, lhs_ty);
         // emit lhs to stack to we can keep 'wrapped' on the stack also
         try self.emitWValue(lhs);
+        const abs = try self.signAbsValue(shl, lhs_ty);
         const wrapped = try self.wrapBinOp(abs, rhs, lhs_ty, .shr);
         break :blk try self.cmp(.{ .stack = {} }, wrapped, lhs_ty, .neq);
     } else blk: {
@@ -4909,10 +4909,10 @@ fn airDivFloor(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             return self.fail("TODO: `@divFloor` for signed integers larger than '{d}' bits", .{int_bits});
         };
         const lhs_res = if (wasm_bits != int_bits) blk: {
-            break :blk try self.signAbsValue(lhs, ty);
+            break :blk try (try self.signAbsValue(lhs, ty)).toLocal(self, ty);
         } else lhs;
         const rhs_res = if (wasm_bits != int_bits) blk: {
-            break :blk try self.signAbsValue(rhs, ty);
+            break :blk try (try self.signAbsValue(rhs, ty)).toLocal(self, ty);
         } else rhs;
 
         const zero = switch (wasm_bits) {
@@ -4994,10 +4994,9 @@ fn divSigned(self: *Self, lhs: WValue, rhs: WValue, ty: Type) InnerError!WValue
     }
 
     if (wasm_bits != int_bits) {
-        const lhs_abs = try self.signAbsValue(lhs, ty);
-        const rhs_abs = try self.signAbsValue(rhs, ty);
-        try self.emitWValue(lhs_abs);
-        try self.emitWValue(rhs_abs);
+        // Leave both values on the stack
+        _ = try self.signAbsValue(lhs, ty);
+        _ = try self.signAbsValue(rhs, ty);
     } else {
         try self.emitWValue(lhs);
         try self.emitWValue(rhs);
@@ -5009,6 +5008,8 @@ fn divSigned(self: *Self, lhs: WValue, rhs: WValue, ty: Type) InnerError!WValue
     return result;
 }
 
+/// Retrieves the absolute value of a signed integer
+/// NOTE: Leaves the result value on the stack.
 fn signAbsValue(self: *Self, operand: WValue, ty: Type) InnerError!WValue {
     const int_bits = ty.intInfo(self.target).bits;
     const wasm_bits = toWasmBits(int_bits) orelse {
@@ -5037,9 +5038,8 @@ fn signAbsValue(self: *Self, operand: WValue, ty: Type) InnerError!WValue {
         },
         else => unreachable,
     }
-    const result = try self.allocLocal(ty);
-    try self.addLabel(.local_set, result.local);
-    return result;
+
+    return WValue{ .stack = {} };
 }
 
 fn airCeilFloorTrunc(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!WValue {
@@ -5130,8 +5130,12 @@ fn signedSat(self: *Self, lhs_operand: WValue, rhs_operand: WValue, ty: Type, op
     const wasm_bits = toWasmBits(int_info.bits).?;
     const is_wasm_bits = wasm_bits == int_info.bits;
 
-    const lhs = if (!is_wasm_bits) try self.signAbsValue(lhs_operand, ty) else lhs_operand;
-    const rhs = if (!is_wasm_bits) try self.signAbsValue(rhs_operand, ty) else rhs_operand;
+    const lhs = if (!is_wasm_bits) lhs: {
+        break :lhs try (try self.signAbsValue(lhs_operand, ty)).toLocal(self, ty);
+    } else lhs_operand;
+    const rhs = if (!is_wasm_bits) rhs: {
+        break :rhs try (try self.signAbsValue(rhs_operand, ty)).toLocal(self, ty);
+    } else rhs_operand;
 
     const max_val: u64 = @intCast(u64, (@as(u65, 1) << @intCast(u7, int_info.bits - 1)) - 1);
     const min_val: i64 = (-@intCast(i64, @intCast(u63, max_val))) - 1;
-- 
2.54.0


From a5e4fd7ef66bbd16ddad1a12d378eefcb740da1d Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Wed, 27 Jul 2022 19:14:42 +0200
Subject: [PATCH 088/290] wasm: keep `load` values on the stack

We internally use a lot of `load`'s that used to put
the result in a newly created local. For instance, when is considered
byRef or when we need a specific field/element/bytes from a larger type.
However, sometimes we want to directly use this value and then forget about
it, which means storing it in a local first is wasted instructions as well
as wasted locals that shouldn't be generated in the first place.
With this change it's explicit and requires the usage of `toLocal`.
---
 src/arch/wasm/CodeGen.zig | 229 +++++++++++++++++++-------------------
 1 file changed, 116 insertions(+), 113 deletions(-)

diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index 2ee6a76401a3d5f4222c6c0169bdfbd715c09062..728b4af651dae876cc797fb269c195d6bde3275b 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -1789,8 +1789,8 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
 
     const fn_info = self.decl.ty.fnInfo();
     if (!firstParamSRet(fn_info.cc, fn_info.return_type, self.target)) {
-        const result = try self.load(operand, ret_ty, 0);
-        try self.emitWValue(result);
+        // leave on the stack
+        _ = try self.load(operand, ret_ty, 0);
     }
 
     try self.restoreStackPointer();
@@ -1943,20 +1943,26 @@ fn store(self: *Self, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErro
         .Pointer => {
             if (ty.isSlice()) {
                 // store pointer first
+                // lower it to the stack so we do not have to store rhs into a local first
+                try self.emitWValue(lhs);
                 const ptr_local = try self.load(rhs, Type.usize, 0);
-                try self.store(lhs, ptr_local, Type.usize, 0);
+                try self.store(.{ .stack = {} }, ptr_local, Type.usize, 0 + lhs.offset());
 
                 // retrieve length from rhs, and store that alongside lhs as well
+                try self.emitWValue(lhs);
                 const len_local = try self.load(rhs, Type.usize, self.ptrSize());
-                try self.store(lhs, len_local, Type.usize, self.ptrSize());
+                try self.store(.{ .stack = {} }, len_local, Type.usize, self.ptrSize() + lhs.offset());
                 return;
             }
         },
         .Int => if (ty.intInfo(self.target).bits > 64) {
+            try self.emitWValue(lhs);
             const lsb = try self.load(rhs, Type.u64, 0);
+            try self.store(.{ .stack = {} }, lsb, Type.u64, 0 + lhs.offset());
+
+            try self.emitWValue(lhs);
             const msb = try self.load(rhs, Type.u64, 8);
-            try self.store(lhs, lsb, Type.u64, 0);
-            try self.store(lhs, msb, Type.u64, 8);
+            try self.store(.{ .stack = {} }, msb, Type.u64, 8 + lhs.offset());
             return;
         },
         else => {},
@@ -1995,9 +2001,12 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         return new_local;
     }
 
-    return self.load(operand, ty, 0);
+    const stack_loaded = try self.load(operand, ty, 0);
+    return stack_loaded.toLocal(self, ty);
 }
 
+/// Loads an operand from the linear memory section.
+/// NOTE: Leaves the value on the stack.
 fn load(self: *Self, operand: WValue, ty: Type, offset: u32) InnerError!WValue {
     // load local's value from memory by its stack position
     try self.emitWValue(operand);
@@ -2015,10 +2024,7 @@ fn load(self: *Self, operand: WValue, ty: Type, offset: u32) InnerError!WValue {
         .{ .offset = offset + operand.offset(), .alignment = ty.abiAlignment(self.target) },
     );
 
-    // store the result in a local
-    const result = try self.allocLocal(ty);
-    try self.addLabel(.local_set, result.local);
-    return result;
+    return WValue{ .stack = {} };
 }
 
 fn airArg(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -2124,18 +2130,15 @@ fn binOp(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WVa
     return WValue{ .stack = {} };
 }
 
+/// Performs a binary operation for 16-bit floats.
+/// NOTE: Leaves the result value on the stack
 fn binOpFloat16(self: *Self, lhs: WValue, rhs: WValue, op: Op) InnerError!WValue {
-    const ext_lhs = try self.fpext(lhs, Type.f16, Type.f32);
-    const ext_rhs = try self.fpext(rhs, Type.f16, Type.f32);
-
     const opcode: wasm.Opcode = buildOpcode(.{ .op = op, .valtype1 = .f32, .signedness = .unsigned });
-    try self.emitWValue(ext_lhs);
-    try self.emitWValue(ext_rhs);
+    _ = try self.fpext(lhs, Type.f16, Type.f32);
+    _ = try self.fpext(rhs, Type.f16, Type.f32);
     try self.addTag(Mir.Inst.Tag.fromOpcode(opcode));
 
-    // re-use temporary local
-    try self.addLabel(.local_set, ext_lhs.local);
-    return self.fptrunc(ext_lhs, Type.f32, Type.f16);
+    return self.fptrunc(.{ .stack = {} }, Type.f32, Type.f16);
 }
 
 fn binOpBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerError!WValue {
@@ -2148,12 +2151,12 @@ fn binOpBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerErr
     }
 
     const result = try self.allocStack(ty);
-    const lhs_high_bit = try self.load(lhs, Type.u64, 0);
+    const lhs_high_bit = try (try self.load(lhs, Type.u64, 0)).toLocal(self, Type.u64);
+    const rhs_high_bit = try (try self.load(rhs, Type.u64, 0)).toLocal(self, Type.u64);
+    const high_op_res = try (try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, op)).toLocal(self, Type.u64);
+
     const lhs_low_bit = try self.load(lhs, Type.u64, 8);
-    const rhs_high_bit = try self.load(rhs, Type.u64, 0);
     const rhs_low_bit = try self.load(rhs, Type.u64, 8);
-
-    const high_op_res = try (try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, op)).toLocal(self, Type.u64);
     const low_op_res = try self.binOp(lhs_low_bit, rhs_low_bit, Type.u64, op);
 
     const lt = if (op == .add) blk: {
@@ -2204,14 +2207,14 @@ fn wrapOperand(self: *Self, operand: WValue, ty: Type) InnerError!WValue {
 
     if (wasm_bits == 128) {
         assert(operand != .stack);
-        const msb = try self.load(operand, Type.u64, 0);
         const lsb = try self.load(operand, Type.u64, 8);
 
         const result_ptr = try self.allocStack(ty);
-        try self.store(result_ptr, lsb, Type.u64, 8);
+        try self.emitWValue(result_ptr);
+        try self.store(.{ .stack = {} }, lsb, Type.u64, 8 + result_ptr.offset());
         const result = (@as(u64, 1) << @intCast(u6, 64 - (wasm_bits - bitsize))) - 1;
         try self.emitWValue(result_ptr);
-        try self.emitWValue(msb);
+        _ = try self.load(operand, Type.u64, 0);
         try self.addImm64(result);
         try self.addTag(.i64_and);
         try self.addMemArg(.i64_store, .{ .offset = result_ptr.offset(), .alignment = 8 });
@@ -2692,10 +2695,9 @@ fn cmp(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareOper
     return WValue{ .stack = {} };
 }
 
+/// Compares 16-bit floats
+/// NOTE: The result value remains on top of the stack.
 fn cmpFloat16(self: *Self, lhs: WValue, rhs: WValue, op: std.math.CompareOperator) InnerError!WValue {
-    const ext_lhs = try self.fpext(lhs, Type.f16, Type.f32);
-    const ext_rhs = try self.fpext(rhs, Type.f16, Type.f32);
-
     const opcode: wasm.Opcode = buildOpcode(.{
         .op = switch (op) {
             .lt => .lt,
@@ -2708,8 +2710,8 @@ fn cmpFloat16(self: *Self, lhs: WValue, rhs: WValue, op: std.math.CompareOperato
         .valtype1 = .f32,
         .signedness = .unsigned,
     });
-    try self.emitWValue(ext_lhs);
-    try self.emitWValue(ext_rhs);
+    _ = try self.fpext(lhs, Type.f16, Type.f32);
+    _ = try self.fpext(rhs, Type.f16, Type.f32);
     try self.addTag(Mir.Inst.Tag.fromOpcode(opcode));
 
     return WValue{ .stack = {} };
@@ -2781,13 +2783,15 @@ fn airNot(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             },
             128 => {
                 const result_ptr = try self.allocStack(operand_ty);
+                try self.emitWValue(result_ptr);
                 const msb = try self.load(operand, Type.u64, 0);
+                const msb_xor = try self.binOp(msb, .{ .imm64 = ~@as(u64, 0) }, Type.u64, .xor);
+                try self.store(.{ .stack = {} }, msb_xor, Type.u64, 0 + result_ptr.offset());
+
+                try self.emitWValue(result_ptr);
                 const lsb = try self.load(operand, Type.u64, 8);
-
-                const msb_xor = try (try self.binOp(msb, .{ .imm64 = ~@as(u64, 0) }, Type.u64, .xor)).toLocal(self, operand_ty);
-                const lsb_xor = try (try self.binOp(lsb, .{ .imm64 = ~@as(u64, 0) }, Type.u64, .xor)).toLocal(self, operand_ty);
-                try self.store(result_ptr, msb_xor, Type.u64, 0);
-                try self.store(result_ptr, lsb_xor, Type.u64, 8);
+                const lsb_xor = try self.binOp(lsb, .{ .imm64 = ~@as(u64, 0) }, Type.u64, .xor);
+                try self.store(result_ptr, lsb_xor, Type.u64, 8 + result_ptr.offset());
                 return result_ptr;
             },
             else => unreachable,
@@ -2875,7 +2879,8 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         }
     }
 
-    return self.load(operand, field_ty, offset);
+    const field = try self.load(operand, field_ty, offset);
+    return field.toLocal(self, field_ty);
 }
 
 fn airSwitchBr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -3085,7 +3090,9 @@ fn airUnwrapErrUnionPayload(self: *Self, inst: Air.Inst.Index, op_is_ptr: bool)
     if (op_is_ptr or isByRef(payload_ty, self.target)) {
         return self.buildPointerOffset(operand, pl_offset, .new);
     }
-    return self.load(operand, payload_ty, pl_offset);
+
+    const payload = try self.load(operand, payload_ty, pl_offset);
+    return payload.toLocal(self, payload_ty);
 }
 
 fn airUnwrapErrUnionError(self: *Self, inst: Air.Inst.Index, op_is_ptr: bool) InnerError!WValue {
@@ -3105,7 +3112,8 @@ fn airUnwrapErrUnionError(self: *Self, inst: Air.Inst.Index, op_is_ptr: bool) In
         return operand;
     }
 
-    return self.load(operand, Type.anyerror, @intCast(u32, errUnionErrorOffset(payload_ty, self.target)));
+    const error_val = try self.load(operand, Type.anyerror, @intCast(u32, errUnionErrorOffset(payload_ty, self.target)));
+    return error_val.toLocal(self, Type.anyerror);
 }
 
 fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -3235,9 +3243,12 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index, opcode: wasm.Opcode, op_kind: en
 
     const op_ty = self.air.typeOf(un_op);
     const optional_ty = if (op_kind == .ptr) op_ty.childType() else op_ty;
-    return self.isNull(operand, optional_ty, opcode);
+    const is_null = try self.isNull(operand, optional_ty, opcode);
+    return is_null.toLocal(self, optional_ty);
 }
 
+/// For a given type and operand, checks if it's considered `null`.
+/// NOTE: Leaves the result on the stack
 fn isNull(self: *Self, operand: WValue, optional_ty: Type, opcode: wasm.Opcode) InnerError!WValue {
     try self.emitWValue(operand);
     if (!optional_ty.optionalReprIsPayload()) {
@@ -3254,9 +3265,7 @@ fn isNull(self: *Self, operand: WValue, optional_ty: Type, opcode: wasm.Opcode)
     try self.addImm32(0);
     try self.addTag(Mir.Inst.Tag.fromOpcode(opcode));
 
-    const is_null_tmp = try self.allocLocal(Type.initTag(.i32));
-    try self.addLabel(.local_set, is_null_tmp.local);
-    return is_null_tmp;
+    return WValue{ .stack = {} };
 }
 
 fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -3274,7 +3283,8 @@ fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         return self.buildPointerOffset(operand, offset, .new);
     }
 
-    return self.load(operand, payload_ty, @intCast(u32, offset));
+    const payload = try self.load(operand, payload_ty, @intCast(u32, offset));
+    return payload.toLocal(self, payload_ty);
 }
 
 fn airOptionalPayloadPtr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -3377,7 +3387,8 @@ fn airSliceLen(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     const ty_op = self.air.instructions.items(.data)[inst].ty_op;
     const operand = try self.resolveInst(ty_op.operand);
 
-    return self.load(operand, Type.usize, self.ptrSize());
+    const len = try self.load(operand, Type.usize, self.ptrSize());
+    return len.toLocal(self, Type.usize);
 }
 
 fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -3391,8 +3402,7 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     const elem_size = elem_ty.abiSize(self.target);
 
     // load pointer onto stack
-    const slice_ptr = try self.load(slice, Type.usize, 0);
-    try self.addLabel(.local_get, slice_ptr.local);
+    _ = try self.load(slice, Type.usize, 0);
 
     // calculate index into slice
     try self.emitWValue(index);
@@ -3406,7 +3416,9 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     if (isByRef(elem_ty, self.target)) {
         return result;
     }
-    return self.load(result, elem_ty, 0);
+
+    const elem_val = try self.load(result, elem_ty, 0);
+    return elem_val.toLocal(self, elem_ty);
 }
 
 fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -3419,8 +3431,7 @@ fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     const slice = try self.resolveInst(bin_op.lhs);
     const index = try self.resolveInst(bin_op.rhs);
 
-    const slice_ptr = try self.load(slice, Type.usize, 0);
-    try self.addLabel(.local_get, slice_ptr.local);
+    _ = try self.load(slice, Type.usize, 0);
 
     // calculate index into slice
     try self.emitWValue(index);
@@ -3428,7 +3439,7 @@ fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     try self.addTag(.i32_mul);
     try self.addTag(.i32_add);
 
-    const result = try self.allocLocal(Type.initTag(.i32));
+    const result = try self.allocLocal(Type.i32);
     try self.addLabel(.local_set, result.local);
     return result;
 }
@@ -3437,7 +3448,8 @@ fn airSlicePtr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     if (self.liveness.isUnused(inst)) return WValue{ .none = {} };
     const ty_op = self.air.instructions.items(.data)[inst].ty_op;
     const operand = try self.resolveInst(ty_op.operand);
-    return self.load(operand, Type.usize, 0);
+    const ptr = try self.load(operand, Type.usize, 0);
+    return ptr.toLocal(self, Type.usize);
 }
 
 fn airTrunc(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -3511,8 +3523,7 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
 
     // load pointer onto the stack
     if (ptr_ty.isSlice()) {
-        const ptr_local = try self.load(ptr, Type.usize, 0);
-        try self.addLabel(.local_get, ptr_local.local);
+        _ = try self.load(ptr, Type.usize, 0);
     } else {
         try self.lowerToStack(ptr);
     }
@@ -3528,7 +3539,9 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     if (isByRef(elem_ty, self.target)) {
         return result;
     }
-    return self.load(result, elem_ty, 0);
+
+    const elem_val = try self.load(result, elem_ty, 0);
+    return elem_val.toLocal(self, elem_ty);
 }
 
 fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -3544,8 +3557,7 @@ fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
 
     // load pointer onto the stack
     if (ptr_ty.isSlice()) {
-        const ptr_local = try self.load(ptr, Type.usize, 0);
-        try self.addLabel(.local_get, ptr_local.local);
+        _ = try self.load(ptr, Type.usize, 0);
     } else {
         try self.lowerToStack(ptr);
     }
@@ -3556,7 +3568,7 @@ fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     try self.addTag(.i32_mul);
     try self.addTag(.i32_add);
 
-    const result = try self.allocLocal(Type.initTag(.i32));
+    const result = try self.allocLocal(Type.i32);
     try self.addLabel(.local_set, result.local);
     return result;
 }
@@ -3707,7 +3719,8 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     if (isByRef(elem_ty, self.target)) {
         return result;
     }
-    return self.load(result, elem_ty, 0);
+    const elem_val = try self.load(result, elem_ty, 0);
+    return elem_val.toLocal(self, elem_ty);
 }
 
 fn airFloatToInt(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -3929,24 +3942,18 @@ fn cmpOptionals(self: *Self, lhs: WValue, rhs: WValue, operand_ty: Type, op: std
     const payload_ty = operand_ty.optionalChild(&buf);
     const offset = @intCast(u32, operand_ty.abiSize(self.target) - payload_ty.abiSize(self.target));
 
-    const lhs_is_null = try self.isNull(lhs, operand_ty, .i32_eq);
-    const rhs_is_null = try self.isNull(rhs, operand_ty, .i32_eq);
-
     // We store the final result in here that will be validated
     // if the optional is truly equal.
     const result = try self.allocLocal(Type.initTag(.i32));
 
     try self.startBlock(.block, wasm.block_empty);
-    try self.emitWValue(lhs_is_null);
-    try self.emitWValue(rhs_is_null);
+    _ = try self.isNull(lhs, operand_ty, .i32_eq);
+    _ = try self.isNull(rhs, operand_ty, .i32_eq);
     try self.addTag(.i32_ne); // inverse so we can exit early
     try self.addLabel(.br_if, 0);
 
-    const lhs_pl = try self.load(lhs, payload_ty, offset);
-    const rhs_pl = try self.load(rhs, payload_ty, offset);
-
-    try self.emitWValue(lhs_pl);
-    try self.emitWValue(rhs_pl);
+    _ = try self.load(lhs, payload_ty, offset);
+    _ = try self.load(rhs, payload_ty, offset);
     const opcode = buildOpcode(.{ .op = .ne, .valtype1 = typeToValtype(payload_ty, self.target) });
     try self.addTag(Mir.Inst.Tag.fromOpcode(opcode));
     try self.addLabel(.br_if, 0);
@@ -3973,14 +3980,14 @@ fn cmpBigInt(self: *Self, lhs: WValue, rhs: WValue, operand_ty: Type, op: std.ma
         return self.fail("TODO: Support cmpBigInt for integer bitsize: '{d}'", .{operand_ty.intInfo(self.target).bits});
     }
 
-    const lhs_high_bit = try self.load(lhs, Type.u64, 0);
-    const lhs_low_bit = try self.load(lhs, Type.u64, 8);
-    const rhs_high_bit = try self.load(rhs, Type.u64, 0);
-    const rhs_low_bit = try self.load(rhs, Type.u64, 8);
+    const lhs_high_bit = try (try self.load(lhs, Type.u64, 0)).toLocal(self, Type.u64);
+    const rhs_high_bit = try (try self.load(rhs, Type.u64, 0)).toLocal(self, Type.u64);
 
     switch (op) {
         .eq, .neq => {
             const xor_high = try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, .xor);
+            const lhs_low_bit = try self.load(lhs, Type.u64, 8);
+            const rhs_low_bit = try self.load(rhs, Type.u64, 8);
             const xor_low = try self.binOp(lhs_low_bit, rhs_low_bit, Type.u64, .xor);
             const or_result = try self.binOp(xor_high, xor_low, Type.u64, .@"or");
 
@@ -3993,6 +4000,8 @@ fn cmpBigInt(self: *Self, lhs: WValue, rhs: WValue, operand_ty: Type, op: std.ma
         else => {
             const ty = if (operand_ty.isSignedInt()) Type.i64 else Type.u64;
             // leave those value on top of the stack for '.select'
+            const lhs_low_bit = try self.load(lhs, Type.u64, 8);
+            const rhs_low_bit = try self.load(rhs, Type.u64, 8);
             _ = try self.cmp(lhs_low_bit, rhs_low_bit, ty, op);
             _ = try self.cmp(lhs_high_bit, rhs_high_bit, ty, op);
             _ = try self.cmp(lhs_high_bit, rhs_high_bit, ty, .eq);
@@ -4040,7 +4049,8 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     const offset = if (layout.tag_align < layout.payload_align) blk: {
         break :blk @intCast(u32, layout.payload_size);
     } else @as(u32, 0);
-    return self.load(operand, tag_ty, offset);
+    const tag = try self.load(operand, tag_ty, offset);
+    return tag.toLocal(self, tag_ty);
 }
 
 fn airFpext(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -4050,19 +4060,20 @@ fn airFpext(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     const dest_ty = self.air.typeOfIndex(inst);
     const operand = try self.resolveInst(ty_op.operand);
 
-    return self.fpext(operand, self.air.typeOf(ty_op.operand), dest_ty);
+    const extended = try self.fpext(operand, self.air.typeOf(ty_op.operand), dest_ty);
+    return extended.toLocal(self, dest_ty);
 }
 
+/// Extends a float from a given `Type` to a larger wanted `Type`
+/// NOTE: Leaves the result on the stack
 fn fpext(self: *Self, operand: WValue, given: Type, wanted: Type) InnerError!WValue {
     const given_bits = given.floatBits(self.target);
     const wanted_bits = wanted.floatBits(self.target);
 
     if (wanted_bits == 64 and given_bits == 32) {
-        const result = try self.allocLocal(wanted);
         try self.emitWValue(operand);
         try self.addTag(.f64_promote_f32);
-        try self.addLabel(.local_set, result.local);
-        return result;
+        return WValue{ .stack = {} };
     } else if (given_bits == 16) {
         // call __extendhfsf2(f16) f32
         const f32_result = try self.callIntrinsic(
@@ -4076,11 +4087,9 @@ fn fpext(self: *Self, operand: WValue, given: Type, wanted: Type) InnerError!WVa
             return f32_result;
         }
         if (wanted_bits == 64) {
-            const result = try self.allocLocal(wanted);
             try self.emitWValue(f32_result);
             try self.addTag(.f64_promote_f32);
-            try self.addLabel(.local_set, result.local);
-            return result;
+            return WValue{ .stack = {} };
         }
         return self.fail("TODO: Implement 'fpext' for floats with bitsize: {d}", .{wanted_bits});
     } else {
@@ -4095,26 +4104,25 @@ fn airFptrunc(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     const ty_op = self.air.instructions.items(.data)[inst].ty_op;
     const dest_ty = self.air.typeOfIndex(inst);
     const operand = try self.resolveInst(ty_op.operand);
-    return self.fptrunc(operand, self.air.typeOf(ty_op.operand), dest_ty);
+    const trunc = try self.fptrunc(operand, self.air.typeOf(ty_op.operand), dest_ty);
+    return trunc.toLocal(self, dest_ty);
 }
 
+/// Truncates a float from a given `Type` to its wanted `Type`
+/// NOTE: The result value remains on the stack
 fn fptrunc(self: *Self, operand: WValue, given: Type, wanted: Type) InnerError!WValue {
     const given_bits = given.floatBits(self.target);
     const wanted_bits = wanted.floatBits(self.target);
 
     if (wanted_bits == 32 and given_bits == 64) {
-        const result = try self.allocLocal(wanted);
         try self.emitWValue(operand);
         try self.addTag(.f32_demote_f64);
-        try self.addLabel(.local_set, result.local);
-        return result;
+        return WValue{ .stack = {} };
     } else if (wanted_bits == 16) {
         const op: WValue = if (given_bits == 64) blk: {
-            const tmp = try self.allocLocal(Type.f32);
             try self.emitWValue(operand);
             try self.addTag(.f32_demote_f64);
-            try self.addLabel(.local_set, tmp.local);
-            break :blk tmp;
+            break :blk WValue{ .stack = {} };
         } else operand;
 
         // call __truncsfhf2(f32) f16
@@ -4199,12 +4207,9 @@ fn airPopcount(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
 
     switch (wasm_bits) {
         128 => {
-            const msb = try self.load(operand, Type.u64, 0);
-            const lsb = try self.load(operand, Type.u64, 8);
-
-            try self.emitWValue(msb);
+            _ = try self.load(operand, Type.u64, 0);
             try self.addTag(.i64_popcnt);
-            try self.emitWValue(lsb);
+            _ = try self.load(operand, Type.u64, 8);
             try self.addTag(.i64_popcnt);
             try self.addTag(.i64_add);
             try self.addTag(.i32_wrap_i64);
@@ -4351,10 +4356,10 @@ fn airAddSubWithOverflowBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type,
         return self.fail("TODO: Implement @{{add/sub}}WithOverflow for integer bitsize '{d}'", .{int_info.bits});
     }
 
-    const lhs_high_bit = try self.load(lhs, Type.u64, 0);
-    const lhs_low_bit = try self.load(lhs, Type.u64, 8);
-    const rhs_high_bit = try self.load(rhs, Type.u64, 0);
-    const rhs_low_bit = try self.load(rhs, Type.u64, 8);
+    const lhs_high_bit = try (try self.load(lhs, Type.u64, 0)).toLocal(self, Type.u64);
+    const lhs_low_bit = try (try self.load(lhs, Type.u64, 8)).toLocal(self, Type.u64);
+    const rhs_high_bit = try (try self.load(rhs, Type.u64, 0)).toLocal(self, Type.u64);
+    const rhs_low_bit = try (try self.load(rhs, Type.u64, 8)).toLocal(self, Type.u64);
 
     const low_op_res = try (try self.binOp(lhs_low_bit, rhs_low_bit, Type.u64, op)).toLocal(self, Type.u64);
     const high_op_res = try (try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, op)).toLocal(self, Type.u64);
@@ -4563,9 +4568,9 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     const rhs = try self.resolveInst(bin_op.rhs);
 
     if (ty.floatBits(self.target) == 16) {
-        const addend_ext = try self.fpext(addend, ty, Type.f32);
-        const lhs_ext = try self.fpext(lhs, ty, Type.f32);
         const rhs_ext = try self.fpext(rhs, ty, Type.f32);
+        const lhs_ext = try self.fpext(lhs, ty, Type.f32);
+        const addend_ext = try self.fpext(addend, ty, Type.f32);
         // call to compiler-rt `fn fmaf(f32, f32, f32) f32`
         const result = try self.callIntrinsic(
             "fmaf",
@@ -4573,7 +4578,7 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             Type.f32,
             &.{ rhs_ext, lhs_ext, addend_ext },
         );
-        return try self.fptrunc(result, Type.f32, ty);
+        return try (try self.fptrunc(result, Type.f32, ty)).toLocal(self, ty);
     }
 
     const mul_result = try self.binOp(lhs, rhs, ty, .mul);
@@ -4606,12 +4611,11 @@ fn airClz(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             try self.addTag(.i32_wrap_i64);
         },
         128 => {
-            const msb = try self.load(operand, Type.u64, 0);
-            const lsb = try self.load(operand, Type.u64, 8);
+            const lsb = try (try self.load(operand, Type.u64, 8)).toLocal(self, Type.u64);
 
             try self.emitWValue(lsb);
             try self.addTag(.i64_clz);
-            try self.emitWValue(msb);
+            _ = try self.load(operand, Type.u64, 0);
             try self.addTag(.i64_clz);
             try self.emitWValue(.{ .imm64 = 64 });
             try self.addTag(.i64_add);
@@ -4667,12 +4671,11 @@ fn airCtz(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             try self.addTag(.i32_wrap_i64);
         },
         128 => {
-            const msb = try self.load(operand, Type.u64, 0);
-            const lsb = try self.load(operand, Type.u64, 8);
+            const msb = try (try self.load(operand, Type.u64, 0)).toLocal(self, Type.u64);
 
             try self.emitWValue(msb);
             try self.addTag(.i64_ctz);
-            try self.emitWValue(lsb);
+            _ = try self.load(operand, Type.u64, 8);
             if (wasm_bits != int_info.bits) {
                 try self.addImm64(@as(u64, 1) << @intCast(u6, int_info.bits - 64));
                 try self.addTag(.i64_or);
@@ -4810,7 +4813,8 @@ fn lowerTry(
     if (isByRef(pl_ty, self.target)) {
         return buildPointerOffset(self, err_union, pl_offset, .new);
     }
-    return self.load(err_union, pl_ty, pl_offset);
+    const payload = try self.load(err_union, pl_ty, pl_offset);
+    return payload.toLocal(self, pl_ty);
 }
 
 fn airByteSwap(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
@@ -4972,9 +4976,7 @@ fn airDivFloor(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         }
 
         if (is_f16) {
-            // we can re-use temporary local
-            try self.addLabel(.local_set, lhs_operand.local);
-            return self.fptrunc(lhs_operand, Type.f32, Type.f16);
+            _ = try self.fptrunc(.{ .stack = {} }, Type.f32, Type.f16);
         }
     }
 
@@ -5066,9 +5068,7 @@ fn airCeilFloorTrunc(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!WValu
     try self.addTag(Mir.Inst.Tag.fromOpcode(opcode));
 
     if (is_f16) {
-        // re-use temporary to save locals
-        try self.addLabel(.local_set, op_to_lower.local);
-        return self.fptrunc(op_to_lower, Type.f32, Type.f16);
+        _ = try self.fptrunc(.{ .stack = {} }, Type.f32, Type.f16);
     }
 
     const result = try self.allocLocal(ty);
@@ -5285,6 +5285,8 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
 /// Calls a compiler-rt intrinsic by creating an undefined symbol,
 /// then lowering the arguments and calling the symbol as a function call.
 /// This function call assumes the C-ABI.
+/// Asserts arguments are not stack values when the return value is
+/// passed as the first parameter.
 fn callIntrinsic(
     self: *Self,
     name: []const u8,
@@ -5314,6 +5316,7 @@ fn callIntrinsic(
 
     // Lower all arguments to the stack before we call our function
     for (args) |arg, arg_i| {
+        assert(!(want_sret_param and arg == .stack));
         assert(param_types[arg_i].hasRuntimeBitsIgnoreComptime());
         try self.lowerArg(.C, param_types[arg_i], arg);
     }
-- 
2.54.0


From b42ba7c3d411cde31ede290b3915150c3e8acfbb Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Wed, 27 Jul 2022 21:04:58 +0200
Subject: [PATCH 089/290] wasm: free unused locals

When a local is no longer referenced or used, free it
so the local can be re-used by another instruction.
This means we generate less locals. Freeing this local
is a manual action and must only be used on temporaries
or where we are sure the local is not referenced by a
different AIR instruction, as that creates UB.

We now also no longer store a `WValue` when its tag is set to `none`
as those may never be referenced by any AIR instruction.
An assertion is done to make sure we never store a reference to a
`stack` value in our resolved instructions.
---
 src/arch/wasm/CodeGen.zig | 237 ++++++++++++++++++++++++--------------
 1 file changed, 151 insertions(+), 86 deletions(-)

diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index 728b4af651dae876cc797fb269c195d6bde3275b..53b7b7fb6bae6441f46534606cc4810e0342cfeb 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -77,17 +77,34 @@ const WValue = union(enum) {
     /// Promotes a `WValue` to a local when given value is on top of the stack.
     /// When encountering a `local` or `stack_offset` this is essentially a no-op.
     /// All other tags are illegal.
-    fn toLocal(self: WValue, gen: *Self, ty: Type) InnerError!WValue {
-        switch (self) {
+    fn toLocal(value: WValue, gen: *Self, ty: Type) InnerError!WValue {
+        switch (value) {
             .stack => {
                 const local = try gen.allocLocal(ty);
                 try gen.addLabel(.local_set, local.local);
                 return local;
             },
-            .local, .stack_offset => return self,
+            .local, .stack_offset => return value,
             else => unreachable,
         }
     }
+
+    /// Marks a local as no longer being referenced and essentially allows
+    /// us to re-use it somewhere else within the function.
+    /// The valtype of the local is deducted by using the index of the given.
+    fn free(value: *WValue, gen: *Self) void {
+        if (value.* != .local) return;
+        const local_value = value.local;
+        const index = local_value - gen.args.len - @boolToInt(gen.return_value != .none);
+        const valtype = @intToEnum(wasm.Valtype, gen.locals.items[index]);
+        switch (valtype) {
+            .i32 => gen.free_locals_i32.append(gen.gpa, local_value) catch return, // It's ok to fail any of those, a new local can be allocated instead
+            .i64 => gen.free_locals_i64.append(gen.gpa, local_value) catch return,
+            .f32 => gen.free_locals_f32.append(gen.gpa, local_value) catch return,
+            .f64 => gen.free_locals_f64.append(gen.gpa, local_value) catch return,
+        }
+        value.* = WValue{ .none = {} };
+    }
 };
 
 /// Wasm ops, but without input/output/signedness information
@@ -829,27 +846,18 @@ fn allocLocal(self: *Self, ty: Type) InnerError!WValue {
         },
     }
     // no local was free to be re-used, so allocate a new local instead
-    try self.locals.append(self.gpa, wasm.valtype(valtype));
+    return self.ensureAllocLocal(ty);
+}
+
+/// Ensures a new local will be created. This is useful when it's useful
+/// to use a zero-initialized local.
+fn ensureAllocLocal(self: *Self, ty: Type) InnerError!WValue {
+    try self.locals.append(self.gpa, genValtype(ty, self.target));
     const initial_index = self.local_index;
     self.local_index += 1;
     return WValue{ .local = initial_index };
 }
 
-/// Marks a local as no longer being referenced and essentially allows
-/// us to re-use it somewhere else within the function.
-/// The valtype of the local is deducted by using the index of the given.
-/// Asserts given `WValue` is a `local`.
-fn freeLocal(self: *Self, value: WValue) InnerError!WValue {
-    const index = value.local;
-    const valtype = wasm.valtype(self.locals.items[index]);
-    switch (valtype) {
-        .i32 => self.free_locals_i32.append(index) catch {}, // It's ok to fail any of those, a new local can be allocated instead
-        .i64 => self.free_locals_i64.append(index) catch {},
-        .f32 => self.free_locals_f32.append(index) catch {},
-        .f64 => self.free_locals_f64.append(index) catch {},
-    }
-}
-
 /// Generates a `wasm.Type` from a given function type.
 /// Memory is owned by the caller.
 fn genFunctype(gpa: Allocator, cc: std.builtin.CallingConvention, params: []const Type, return_type: Type, target: std.Target) !wasm.Type {
@@ -1197,9 +1205,9 @@ fn initializeStack(self: *Self) !void {
     // Reserve a local to store the current stack pointer
     // We can later use this local to set the stack pointer back to the value
     // we have stored here.
-    self.initial_stack_value = try self.allocLocal(Type.usize);
+    self.initial_stack_value = try self.ensureAllocLocal(Type.usize);
     // Also reserve a local to store the bottom stack value
-    self.bottom_stack_value = try self.allocLocal(Type.usize);
+    self.bottom_stack_value = try self.ensureAllocLocal(Type.usize);
 }
 
 /// Reads the stack pointer from `Context.initial_stack_value` and writes it
@@ -1330,7 +1338,9 @@ fn memcpy(self: *Self, dst: WValue, src: WValue, len: WValue) !void {
         else => {
             // TODO: We should probably lower this to a call to compiler_rt
             // But for now, we implement it manually
-            const offset = try self.allocLocal(Type.usize); // local for counter
+            var offset = try self.ensureAllocLocal(Type.usize); // local for counter
+            defer offset.free(self);
+
             // outer block to jump to when loop is done
             try self.startBlock(.block, wasm.block_empty);
             try self.startBlock(.loop, wasm.block_empty);
@@ -1467,7 +1477,7 @@ fn buildPointerOffset(self: *Self, ptr_value: WValue, offset: u64, action: enum
     // do not perform arithmetic when offset is 0.
     if (offset == 0 and ptr_value.offset() == 0 and action == .modify) return ptr_value;
     const result_ptr: WValue = switch (action) {
-        .new => try self.allocLocal(Type.usize),
+        .new => try self.ensureAllocLocal(Type.usize),
         .modify => ptr_value,
     };
     try self.emitWValue(ptr_value);
@@ -1715,7 +1725,10 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
 fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
     for (body) |inst| {
         const result = try self.genInst(inst);
-        try self.values.putNoClobber(self.gpa, Air.indexToRef(inst), result);
+        if (result != .none) {
+            assert(result != .stack); // not allowed to store stack values as we cannot keep track of where they are on the stack
+            try self.values.putNoClobber(self.gpa, Air.indexToRef(inst), result);
+        }
     }
 }
 
@@ -2151,9 +2164,12 @@ fn binOpBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerErr
     }
 
     const result = try self.allocStack(ty);
-    const lhs_high_bit = try (try self.load(lhs, Type.u64, 0)).toLocal(self, Type.u64);
-    const rhs_high_bit = try (try self.load(rhs, Type.u64, 0)).toLocal(self, Type.u64);
-    const high_op_res = try (try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, op)).toLocal(self, Type.u64);
+    var lhs_high_bit = try (try self.load(lhs, Type.u64, 0)).toLocal(self, Type.u64);
+    defer lhs_high_bit.free(self);
+    var rhs_high_bit = try (try self.load(rhs, Type.u64, 0)).toLocal(self, Type.u64);
+    defer rhs_high_bit.free(self);
+    var high_op_res = try (try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, op)).toLocal(self, Type.u64);
+    defer high_op_res.free(self);
 
     const lhs_low_bit = try self.load(lhs, Type.u64, 8);
     const rhs_low_bit = try self.load(rhs, Type.u64, 8);
@@ -2165,7 +2181,8 @@ fn binOpBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type, op: Op) InnerErr
         break :blk try self.cmp(lhs_high_bit, rhs_high_bit, Type.u64, .lt);
     } else unreachable;
     const tmp = try self.intcast(lt, Type.u32, Type.u64);
-    const tmp_op = try (try self.binOp(low_op_res, tmp, Type.u64, op)).toLocal(self, Type.u64);
+    var tmp_op = try (try self.binOp(low_op_res, tmp, Type.u64, op)).toLocal(self, Type.u64);
+    defer tmp_op.free(self);
 
     try self.store(result, high_op_res, Type.u64, 0);
     try self.store(result, tmp_op, Type.u64, 8);
@@ -3208,25 +3225,22 @@ fn intcast(self: *Self, operand: WValue, given: Type, wanted: Type) InnerError!W
     } else if (wanted_bits == 128) {
         // for 128bit integers we store the integer in the virtual stack, rather than a local
         const stack_ptr = try self.allocStack(wanted);
+        try self.emitWValue(stack_ptr);
 
         // for 32 bit integers, we first coerce the value into a 64 bit integer before storing it
         // meaning less store operations are required.
         const lhs = if (op_bits == 32) blk: {
-            const tmp = try self.intcast(
-                operand,
-                given,
-                if (wanted.isSignedInt()) Type.i64 else Type.u64,
-            );
-            break :blk try tmp.toLocal(self, Type.u64);
+            break :blk try self.intcast(operand, given, if (wanted.isSignedInt()) Type.i64 else Type.u64);
         } else operand;
 
         // store msb first
-        try self.store(stack_ptr, lhs, Type.u64, 0);
+        try self.store(.{ .stack = {} }, lhs, Type.u64, 0 + stack_ptr.offset());
 
         // For signed integers we shift msb by 63 (64bit integer - 1 sign bit) and store remaining value
         if (wanted.isSignedInt()) {
-            const shr = try (try self.binOp(lhs, .{ .imm64 = 63 }, Type.i64, .shr)).toLocal(self, Type.i64);
-            try self.store(stack_ptr, shr, Type.u64, 8);
+            try self.emitWValue(stack_ptr);
+            const shr = try self.binOp(lhs, .{ .imm64 = 63 }, Type.i64, .shr);
+            try self.store(.{ .stack = {} }, shr, Type.u64, 8 + stack_ptr.offset());
         } else {
             // Ensure memory of lsb is zero'd
             try self.store(stack_ptr, .{ .imm64 = 0 }, Type.u64, 8);
@@ -3534,11 +3548,12 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     try self.addTag(.i32_mul);
     try self.addTag(.i32_add);
 
-    const result = try self.allocLocal(elem_ty);
+    var result = try self.allocLocal(elem_ty);
     try self.addLabel(.local_set, result.local);
     if (isByRef(elem_ty, self.target)) {
         return result;
     }
+    defer result.free(self); // only free if it's not returned like above
 
     const elem_val = try self.load(result, elem_ty, 0);
     return elem_val.toLocal(self, elem_ty);
@@ -3656,7 +3671,7 @@ fn memset(self: *Self, ptr: WValue, len: WValue, value: WValue) InnerError!void
         else => {
             // TODO: We should probably lower this to a call to compiler_rt
             // But for now, we implement it manually
-            const offset = try self.allocLocal(Type.usize); // local for counter
+            const offset = try self.ensureAllocLocal(Type.usize); // local for counter
             // outer block to jump to when loop is done
             try self.startBlock(.block, wasm.block_empty);
             try self.startBlock(.loop, wasm.block_empty);
@@ -3713,12 +3728,14 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     try self.addTag(.i32_mul);
     try self.addTag(.i32_add);
 
-    const result = try self.allocLocal(Type.usize);
+    var result = try self.allocLocal(Type.usize);
     try self.addLabel(.local_set, result.local);
 
     if (isByRef(elem_ty, self.target)) {
         return result;
     }
+    defer result.free(self); // only free if no longer needed and not returned like above
+
     const elem_val = try self.load(result, elem_ty, 0);
     return elem_val.toLocal(self, elem_ty);
 }
@@ -3944,7 +3961,8 @@ fn cmpOptionals(self: *Self, lhs: WValue, rhs: WValue, operand_ty: Type, op: std
 
     // We store the final result in here that will be validated
     // if the optional is truly equal.
-    const result = try self.allocLocal(Type.initTag(.i32));
+    var result = try self.ensureAllocLocal(Type.initTag(.i32));
+    defer result.free(self);
 
     try self.startBlock(.block, wasm.block_empty);
     _ = try self.isNull(lhs, operand_ty, .i32_eq);
@@ -3965,8 +3983,6 @@ fn cmpOptionals(self: *Self, lhs: WValue, rhs: WValue, operand_ty: Type, op: std
     try self.emitWValue(result);
     try self.addImm32(0);
     try self.addTag(if (op == .eq) .i32_ne else .i32_eq);
-    try self.addLabel(.local_set, result.local);
-    try self.emitWValue(result);
     return WValue{ .stack = {} };
 }
 
@@ -3980,8 +3996,10 @@ fn cmpBigInt(self: *Self, lhs: WValue, rhs: WValue, operand_ty: Type, op: std.ma
         return self.fail("TODO: Support cmpBigInt for integer bitsize: '{d}'", .{operand_ty.intInfo(self.target).bits});
     }
 
-    const lhs_high_bit = try (try self.load(lhs, Type.u64, 0)).toLocal(self, Type.u64);
-    const rhs_high_bit = try (try self.load(rhs, Type.u64, 0)).toLocal(self, Type.u64);
+    var lhs_high_bit = try (try self.load(lhs, Type.u64, 0)).toLocal(self, Type.u64);
+    defer lhs_high_bit.free(self);
+    var rhs_high_bit = try (try self.load(rhs, Type.u64, 0)).toLocal(self, Type.u64);
+    defer rhs_high_bit.free(self);
 
     switch (op) {
         .eq, .neq => {
@@ -4313,17 +4331,19 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!W
 
     // for signed integers, we first apply signed shifts by the difference in bits
     // to get the signed value, as we store it internally as 2's complement.
-    const lhs = if (wasm_bits != int_info.bits and is_signed) blk: {
+    var lhs = if (wasm_bits != int_info.bits and is_signed) blk: {
         break :blk try (try self.signAbsValue(lhs_op, lhs_ty)).toLocal(self, lhs_ty);
     } else lhs_op;
-    const rhs = if (wasm_bits != int_info.bits and is_signed) blk: {
+    var rhs = if (wasm_bits != int_info.bits and is_signed) blk: {
         break :blk try (try self.signAbsValue(rhs_op, lhs_ty)).toLocal(self, lhs_ty);
     } else rhs_op;
 
-    const bin_op = try (try self.binOp(lhs, rhs, lhs_ty, op)).toLocal(self, lhs_ty);
-    const result = if (wasm_bits != int_info.bits) blk: {
+    var bin_op = try (try self.binOp(lhs, rhs, lhs_ty, op)).toLocal(self, lhs_ty);
+    defer bin_op.free(self);
+    var result = if (wasm_bits != int_info.bits) blk: {
         break :blk try (try self.wrapOperand(bin_op, lhs_ty)).toLocal(self, lhs_ty);
     } else bin_op;
+    defer result.free(self); // no-op when wasm_bits == int_info.bits
 
     const cmp_op: std.math.CompareOperator = if (op == .sub) .gt else .lt;
     const overflow_bit: WValue = if (is_signed) blk: {
@@ -4338,13 +4358,23 @@ fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!W
         try self.cmp(bin_op, lhs, lhs_ty, cmp_op)
     else
         try self.cmp(bin_op, result, lhs_ty, .neq);
-    const overflow_local = try overflow_bit.toLocal(self, Type.u32);
+    var overflow_local = try overflow_bit.toLocal(self, Type.u32);
+    defer overflow_local.free(self);
 
     const result_ptr = try self.allocStack(self.air.typeOfIndex(inst));
     try self.store(result_ptr, result, lhs_ty, 0);
     const offset = @intCast(u32, lhs_ty.abiSize(self.target));
     try self.store(result_ptr, overflow_local, Type.initTag(.u1), offset);
 
+    // in this case, we performed a signAbsValue which created a temporary local
+    // so let's free this so it can be re-used instead.
+    // In the other case we do not want to free it, because that would free the
+    // resolved instructions which may be referenced by other instructions.
+    if (wasm_bits != int_info.bits and is_signed) {
+        lhs.free(self);
+        rhs.free(self);
+    }
+
     return result_ptr;
 }
 
@@ -4356,21 +4386,30 @@ fn airAddSubWithOverflowBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type,
         return self.fail("TODO: Implement @{{add/sub}}WithOverflow for integer bitsize '{d}'", .{int_info.bits});
     }
 
-    const lhs_high_bit = try (try self.load(lhs, Type.u64, 0)).toLocal(self, Type.u64);
-    const lhs_low_bit = try (try self.load(lhs, Type.u64, 8)).toLocal(self, Type.u64);
-    const rhs_high_bit = try (try self.load(rhs, Type.u64, 0)).toLocal(self, Type.u64);
-    const rhs_low_bit = try (try self.load(rhs, Type.u64, 8)).toLocal(self, Type.u64);
+    var lhs_high_bit = try (try self.load(lhs, Type.u64, 0)).toLocal(self, Type.u64);
+    defer lhs_high_bit.free(self);
+    var lhs_low_bit = try (try self.load(lhs, Type.u64, 8)).toLocal(self, Type.u64);
+    defer lhs_low_bit.free(self);
+    var rhs_high_bit = try (try self.load(rhs, Type.u64, 0)).toLocal(self, Type.u64);
+    defer rhs_high_bit.free(self);
+    var rhs_low_bit = try (try self.load(rhs, Type.u64, 8)).toLocal(self, Type.u64);
+    defer rhs_low_bit.free(self);
 
-    const low_op_res = try (try self.binOp(lhs_low_bit, rhs_low_bit, Type.u64, op)).toLocal(self, Type.u64);
-    const high_op_res = try (try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, op)).toLocal(self, Type.u64);
+    var low_op_res = try (try self.binOp(lhs_low_bit, rhs_low_bit, Type.u64, op)).toLocal(self, Type.u64);
+    defer low_op_res.free(self);
+    var high_op_res = try (try self.binOp(lhs_high_bit, rhs_high_bit, Type.u64, op)).toLocal(self, Type.u64);
+    defer high_op_res.free(self);
 
-    const lt = if (op == .add) blk: {
+    var lt = if (op == .add) blk: {
         break :blk try (try self.cmp(high_op_res, lhs_high_bit, Type.u64, .lt)).toLocal(self, Type.u32);
     } else if (op == .sub) blk: {
         break :blk try (try self.cmp(lhs_high_bit, rhs_high_bit, Type.u64, .lt)).toLocal(self, Type.u32);
     } else unreachable;
-    const tmp = try (try self.intcast(lt, Type.u32, Type.u64)).toLocal(self, Type.u64);
-    const tmp_op = try (try self.binOp(low_op_res, tmp, Type.u64, op)).toLocal(self, Type.u64);
+    defer lt.free(self);
+    var tmp = try (try self.intcast(lt, Type.u32, Type.u64)).toLocal(self, Type.u64);
+    defer tmp.free(self);
+    var tmp_op = try (try self.binOp(low_op_res, tmp, Type.u64, op)).toLocal(self, Type.u64);
+    defer tmp_op.free(self);
 
     const overflow_bit = if (is_signed) blk: {
         const xor_low = try self.binOp(lhs_low_bit, rhs_low_bit, Type.u64, .xor);
@@ -4392,7 +4431,8 @@ fn airAddSubWithOverflowBigInt(self: *Self, lhs: WValue, rhs: WValue, ty: Type,
 
         break :blk WValue{ .stack = {} };
     };
-    const overflow_local = try overflow_bit.toLocal(self, Type.initTag(.u1));
+    var overflow_local = try overflow_bit.toLocal(self, Type.initTag(.u1));
+    defer overflow_local.free(self);
 
     const result_ptr = try self.allocStack(result_ty);
     try self.store(result_ptr, high_op_res, Type.u64, 0);
@@ -4419,10 +4459,12 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         return self.fail("TODO: Implement shl_with_overflow for integer bitsize: {d}", .{int_info.bits});
     };
 
-    const shl = try (try self.binOp(lhs, rhs, lhs_ty, .shl)).toLocal(self, lhs_ty);
-    const result = if (wasm_bits != int_info.bits) blk: {
+    var shl = try (try self.binOp(lhs, rhs, lhs_ty, .shl)).toLocal(self, lhs_ty);
+    defer shl.free(self);
+    var result = if (wasm_bits != int_info.bits) blk: {
         break :blk try (try self.wrapOperand(shl, lhs_ty)).toLocal(self, lhs_ty);
     } else shl;
+    defer result.free(self); // it's a no-op to free the same local twice (when wasm_bits == int_info.bits)
 
     const overflow_bit = if (wasm_bits != int_info.bits and is_signed) blk: {
         // emit lhs to stack to we can keep 'wrapped' on the stack also
@@ -4431,10 +4473,12 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         const wrapped = try self.wrapBinOp(abs, rhs, lhs_ty, .shr);
         break :blk try self.cmp(.{ .stack = {} }, wrapped, lhs_ty, .neq);
     } else blk: {
-        const shr = try (try self.binOp(result, rhs, lhs_ty, .shr)).toLocal(self, lhs_ty);
-        break :blk try self.cmp(lhs, shr, lhs_ty, .neq);
+        try self.emitWValue(lhs);
+        const shr = try self.binOp(result, rhs, lhs_ty, .shr);
+        break :blk try self.cmp(.{ .stack = {} }, shr, lhs_ty, .neq);
     };
-    const overflow_local = try overflow_bit.toLocal(self, Type.initTag(.u1));
+    var overflow_local = try overflow_bit.toLocal(self, Type.initTag(.u1));
+    defer overflow_local.free(self);
 
     const result_ptr = try self.allocStack(self.air.typeOfIndex(inst));
     try self.store(result_ptr, result, lhs_ty, 0);
@@ -4457,7 +4501,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
 
     // We store the bit if it's overflowed or not in this. As it's zero-initialized
     // we only need to update it if an overflow (or underflow) occurred.
-    const overflow_bit = try self.allocLocal(Type.initTag(.u1));
+    var overflow_bit = try self.ensureAllocLocal(Type.initTag(.u1));
+    defer overflow_bit.free(self);
+
     const int_info = lhs_ty.intInfo(self.target);
     const wasm_bits = toWasmBits(int_info.bits) orelse {
         return self.fail("TODO: Implement overflow arithmetic for integer bitsize: {d}", .{int_info.bits});
@@ -4487,7 +4533,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             break :blk try self.intcast(bin_op, new_ty, lhs_ty);
         } else {
             const down_cast = try (try self.intcast(bin_op, new_ty, lhs_ty)).toLocal(self, lhs_ty);
-            const shr = try (try self.binOp(down_cast, .{ .imm32 = int_info.bits - 1 }, lhs_ty, .shr)).toLocal(self, lhs_ty);
+            var shr = try (try self.binOp(down_cast, .{ .imm32 = int_info.bits - 1 }, lhs_ty, .shr)).toLocal(self, lhs_ty);
+            defer shr.free(self);
 
             const shr_res = try self.binOp(bin_op, .{ .imm64 = int_info.bits }, new_ty, .shr);
             const down_shr_res = try self.intcast(shr_res, new_ty, lhs_ty);
@@ -4504,7 +4551,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         try self.addLabel(.local_set, overflow_bit.local);
         break :blk try self.wrapOperand(bin_op, lhs_ty);
     } else blk: {
-        const bin_op = try (try self.binOp(lhs, rhs, lhs_ty, .mul)).toLocal(self, lhs_ty);
+        var bin_op = try (try self.binOp(lhs, rhs, lhs_ty, .mul)).toLocal(self, lhs_ty);
+        defer bin_op.free(self);
         const shift_imm = if (wasm_bits == 32)
             WValue{ .imm32 = int_info.bits }
         else
@@ -4514,7 +4562,8 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         try self.addLabel(.local_set, overflow_bit.local);
         break :blk try self.wrapOperand(bin_op, lhs_ty);
     };
-    const bin_op_local = try bin_op.toLocal(self, lhs_ty);
+    var bin_op_local = try bin_op.toLocal(self, lhs_ty);
+    defer bin_op_local.free(self);
 
     const result_ptr = try self.allocStack(self.air.typeOfIndex(inst));
     try self.store(result_ptr, bin_op_local, lhs_ty, 0);
@@ -4572,12 +4621,13 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         const lhs_ext = try self.fpext(lhs, ty, Type.f32);
         const addend_ext = try self.fpext(addend, ty, Type.f32);
         // call to compiler-rt `fn fmaf(f32, f32, f32) f32`
-        const result = try self.callIntrinsic(
+        var result = try self.callIntrinsic(
             "fmaf",
             &.{ Type.f32, Type.f32, Type.f32 },
             Type.f32,
             &.{ rhs_ext, lhs_ext, addend_ext },
         );
+        defer result.free(self);
         return try (try self.fptrunc(result, Type.f32, ty)).toLocal(self, ty);
     }
 
@@ -4611,7 +4661,8 @@ fn airClz(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             try self.addTag(.i32_wrap_i64);
         },
         128 => {
-            const lsb = try (try self.load(operand, Type.u64, 8)).toLocal(self, Type.u64);
+            var lsb = try (try self.load(operand, Type.u64, 8)).toLocal(self, Type.u64);
+            defer lsb.free(self);
 
             try self.emitWValue(lsb);
             try self.addTag(.i64_clz);
@@ -4671,7 +4722,8 @@ fn airCtz(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             try self.addTag(.i32_wrap_i64);
         },
         128 => {
-            const msb = try (try self.load(operand, Type.u64, 0)).toLocal(self, Type.u64);
+            var msb = try (try self.load(operand, Type.u64, 0)).toLocal(self, Type.u64);
+            defer msb.free(self);
 
             try self.emitWValue(msb);
             try self.addTag(.i64_ctz);
@@ -4847,7 +4899,8 @@ fn airByteSwap(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             return (try self.binOp(lhs, res, ty, .@"or")).toLocal(self, ty);
         },
         24 => {
-            const msb = try (try self.wrapOperand(operand, Type.u16)).toLocal(self, Type.u16);
+            var msb = try (try self.wrapOperand(operand, Type.u16)).toLocal(self, Type.u16);
+            defer msb.free(self);
 
             const shl_res = try self.binOp(msb, .{ .imm32 = 8 }, Type.u16, .shl);
             const lhs = try self.binOp(shl_res, .{ .imm32 = 0xFF0000 }, Type.u16, .@"and");
@@ -4867,10 +4920,13 @@ fn airByteSwap(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         },
         32 => {
             const shl_tmp = try self.binOp(operand, .{ .imm32 = 8 }, ty, .shl);
-            const lhs = try (try self.binOp(shl_tmp, .{ .imm32 = 0xFF00FF00 }, ty, .@"and")).toLocal(self, ty);
+            var lhs = try (try self.binOp(shl_tmp, .{ .imm32 = 0xFF00FF00 }, ty, .@"and")).toLocal(self, ty);
+            defer lhs.free(self);
             const shr_tmp = try self.binOp(operand, .{ .imm32 = 8 }, ty, .shr);
-            const rhs = try (try self.binOp(shr_tmp, .{ .imm32 = 0xFF00FF }, ty, .@"and")).toLocal(self, ty);
-            const tmp_or = try (try self.binOp(lhs, rhs, ty, .@"or")).toLocal(self, ty);
+            var rhs = try (try self.binOp(shr_tmp, .{ .imm32 = 0xFF00FF }, ty, .@"and")).toLocal(self, ty);
+            defer rhs.free(self);
+            var tmp_or = try (try self.binOp(lhs, rhs, ty, .@"or")).toLocal(self, ty);
+            defer tmp_or.free(self);
 
             const shl = try self.binOp(tmp_or, .{ .imm32 = 16 }, ty, .shl);
             const shr = try self.binOp(tmp_or, .{ .imm32 = 16 }, ty, .shr);
@@ -5097,7 +5153,8 @@ fn airSatBinOp(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!WValue {
     }
 
     const wasm_bits = toWasmBits(int_info.bits).?;
-    const bin_result = try (try self.binOp(lhs, rhs, ty, op)).toLocal(self, ty);
+    var bin_result = try (try self.binOp(lhs, rhs, ty, op)).toLocal(self, ty);
+    defer bin_result.free(self);
     if (wasm_bits != int_info.bits and op == .add) {
         const val: u64 = @intCast(u64, (@as(u65, 1) << @intCast(u7, int_info.bits)) - 1);
         const imm_val = switch (wasm_bits) {
@@ -5130,10 +5187,10 @@ fn signedSat(self: *Self, lhs_operand: WValue, rhs_operand: WValue, ty: Type, op
     const wasm_bits = toWasmBits(int_info.bits).?;
     const is_wasm_bits = wasm_bits == int_info.bits;
 
-    const lhs = if (!is_wasm_bits) lhs: {
+    var lhs = if (!is_wasm_bits) lhs: {
         break :lhs try (try self.signAbsValue(lhs_operand, ty)).toLocal(self, ty);
     } else lhs_operand;
-    const rhs = if (!is_wasm_bits) rhs: {
+    var rhs = if (!is_wasm_bits) rhs: {
         break :rhs try (try self.signAbsValue(rhs_operand, ty)).toLocal(self, ty);
     } else rhs_operand;
 
@@ -5150,8 +5207,11 @@ fn signedSat(self: *Self, lhs_operand: WValue, rhs_operand: WValue, ty: Type, op
         else => unreachable,
     };
 
-    const bin_result = try (try self.binOp(lhs, rhs, ty, op)).toLocal(self, ty);
+    var bin_result = try (try self.binOp(lhs, rhs, ty, op)).toLocal(self, ty);
     if (!is_wasm_bits) {
+        defer bin_result.free(self); // not returned in this branch
+        defer lhs.free(self); // uses temporary local for absvalue
+        defer rhs.free(self); // uses temporary local for absvalue
         try self.emitWValue(bin_result);
         try self.emitWValue(max_wvalue);
         _ = try self.cmp(bin_result, max_wvalue, ty, .lt);
@@ -5202,8 +5262,10 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
     const result = try self.allocLocal(ty);
 
     if (wasm_bits == int_info.bits) {
-        const shl = try (try self.binOp(lhs, rhs, ty, .shl)).toLocal(self, ty);
-        const shr = try (try self.binOp(shl, rhs, ty, .shr)).toLocal(self, ty);
+        var shl = try (try self.binOp(lhs, rhs, ty, .shl)).toLocal(self, ty);
+        defer shl.free(self);
+        var shr = try (try self.binOp(shl, rhs, ty, .shr)).toLocal(self, ty);
+        defer shr.free(self);
 
         switch (wasm_bits) {
             32 => blk: {
@@ -5241,9 +5303,12 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             else => unreachable,
         };
 
-        const shl_res = try (try self.binOp(lhs, shift_value, ty, .shl)).toLocal(self, ty);
-        const shl = try (try self.binOp(shl_res, rhs, ty, .shl)).toLocal(self, ty);
-        const shr = try (try self.binOp(shl, rhs, ty, .shr)).toLocal(self, ty);
+        var shl_res = try (try self.binOp(lhs, shift_value, ty, .shl)).toLocal(self, ty);
+        defer shl_res.free(self);
+        var shl = try (try self.binOp(shl_res, rhs, ty, .shl)).toLocal(self, ty);
+        defer shl.free(self);
+        var shr = try (try self.binOp(shl, rhs, ty, .shr)).toLocal(self, ty);
+        defer shr.free(self);
 
         switch (wasm_bits) {
             32 => blk: {
@@ -5278,7 +5343,7 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
         if (is_signed) {
             shift_result = try self.wrapOperand(shift_result, ty);
         }
-        return try shift_result.toLocal(self, ty);
+        return shift_result.toLocal(self, ty);
     }
 }
 
-- 
2.54.0


From b78f3bf1f17c7d67ae30d95047e40efc164bf8af Mon Sep 17 00:00:00 2001
From: Isaac Freund <mail@isaacfreund.com>
Date: Thu, 11 Aug 2022 10:56:21 +0200
Subject: [PATCH 090/290] std: fix definition of SIG_IGN, SIG_DFL, etc.

POSIX specifies that the sa_handler field of the sigaction struct may
be set to SIG_IGN or SIG_DFL. However, the current constants in the
standard library use the function pointer signature corresponding to
the sa_sigaction field instead.

This may not cause issues in practice because the fields usually occupy
the same memory in a union, but this isn't required by POSIX and there
may be systems we do not yet support that do this differently.

Fixing this also makes the Zig interface less confusing to use after
reading the man page.
---
 lib/std/c/darwin.zig    |  8 ++++----
 lib/std/c/dragonfly.zig |  6 +++---
 lib/std/c/freebsd.zig   |  6 +++---
 lib/std/c/netbsd.zig    |  6 +++---
 lib/std/c/openbsd.zig   | 10 +++++-----
 lib/std/c/solaris.zig   |  8 ++++----
 lib/std/debug.zig       |  2 +-
 lib/std/os.zig          |  2 +-
 lib/std/os/linux.zig    | 18 +++++++++---------
 lib/std/os/test.zig     |  2 +-
 10 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/lib/std/c/darwin.zig b/lib/std/c/darwin.zig
index e7fd3cde44e82d80518f0c66bbf37e0ba5ff520e..0a65fa52429ea9a6f23fef3e08e2d56b0cf4c9b7 100644
--- a/lib/std/c/darwin.zig
+++ b/lib/std/c/darwin.zig
@@ -814,10 +814,10 @@ pub const sigset_t = u32;
 pub const empty_sigset: sigset_t = 0;
 
 pub const SIG = struct {
-    pub const ERR = @intToPtr(?Sigaction.sigaction_fn, maxInt(usize));
-    pub const DFL = @intToPtr(?Sigaction.sigaction_fn, 0);
-    pub const IGN = @intToPtr(?Sigaction.sigaction_fn, 1);
-    pub const HOLD = @intToPtr(?Sigaction.sigaction_fn, 5);
+    pub const ERR = @intToPtr(?Sigaction.handler_fn, maxInt(usize));
+    pub const DFL = @intToPtr(?Sigaction.handler_fn, 0);
+    pub const IGN = @intToPtr(?Sigaction.handler_fn, 1);
+    pub const HOLD = @intToPtr(?Sigaction.handler_fn, 5);
 
     /// block specified signal set
     pub const _BLOCK = 1;
diff --git a/lib/std/c/dragonfly.zig b/lib/std/c/dragonfly.zig
index 1a60f94a1ec2a402343e3bb2fb3b0527573a221a..5d7822e8e9b925e12524ee7cbca4a786bf144a5c 100644
--- a/lib/std/c/dragonfly.zig
+++ b/lib/std/c/dragonfly.zig
@@ -609,9 +609,9 @@ pub const S = struct {
 pub const BADSIG = SIG.ERR;
 
 pub const SIG = struct {
-    pub const DFL = @intToPtr(?Sigaction.sigaction_fn, 0);
-    pub const IGN = @intToPtr(?Sigaction.sigaction_fn, 1);
-    pub const ERR = @intToPtr(?Sigaction.sigaction_fn, maxInt(usize));
+    pub const DFL = @intToPtr(?Sigaction.handler_fn, 0);
+    pub const IGN = @intToPtr(?Sigaction.handler_fn, 1);
+    pub const ERR = @intToPtr(?Sigaction.handler_fn, maxInt(usize));
 
     pub const BLOCK = 1;
     pub const UNBLOCK = 2;
diff --git a/lib/std/c/freebsd.zig b/lib/std/c/freebsd.zig
index dac239094e4a1a640f4a72a39d205be561df3c23..6f0188698662308f2f91093c48096495c252bc7d 100644
--- a/lib/std/c/freebsd.zig
+++ b/lib/std/c/freebsd.zig
@@ -670,9 +670,9 @@ pub const SIG = struct {
     pub const UNBLOCK = 2;
     pub const SETMASK = 3;
 
-    pub const DFL = @intToPtr(?Sigaction.sigaction_fn, 0);
-    pub const IGN = @intToPtr(?Sigaction.sigaction_fn, 1);
-    pub const ERR = @intToPtr(?Sigaction.sigaction_fn, maxInt(usize));
+    pub const DFL = @intToPtr(?Sigaction.handler_fn, 0);
+    pub const IGN = @intToPtr(?Sigaction.handler_fn, 1);
+    pub const ERR = @intToPtr(?Sigaction.handler_fn, maxInt(usize));
 
     pub const WORDS = 4;
     pub const MAXSIG = 128;
diff --git a/lib/std/c/netbsd.zig b/lib/std/c/netbsd.zig
index 3de14da7a26af0184e14aa898ca718f2307df8ac..a8287033d75e9fa4adce7231e6917632ff80cb48 100644
--- a/lib/std/c/netbsd.zig
+++ b/lib/std/c/netbsd.zig
@@ -910,9 +910,9 @@ pub const winsize = extern struct {
 const NSIG = 32;
 
 pub const SIG = struct {
-    pub const DFL = @intToPtr(?Sigaction.sigaction_fn, 0);
-    pub const IGN = @intToPtr(?Sigaction.sigaction_fn, 1);
-    pub const ERR = @intToPtr(?Sigaction.sigaction_fn, maxInt(usize));
+    pub const DFL = @intToPtr(?Sigaction.handler_fn, 0);
+    pub const IGN = @intToPtr(?Sigaction.handler_fn, 1);
+    pub const ERR = @intToPtr(?Sigaction.handler_fn, maxInt(usize));
 
     pub const WORDS = 4;
     pub const MAXSIG = 128;
diff --git a/lib/std/c/openbsd.zig b/lib/std/c/openbsd.zig
index 0863cc5a5e794819c09cf0aa7ec25c8339566a1a..5c259bc41ae3c929cda4d4f56c9591dca48f218c 100644
--- a/lib/std/c/openbsd.zig
+++ b/lib/std/c/openbsd.zig
@@ -982,11 +982,11 @@ pub const winsize = extern struct {
 const NSIG = 33;
 
 pub const SIG = struct {
-    pub const DFL = @intToPtr(?Sigaction.sigaction_fn, 0);
-    pub const IGN = @intToPtr(?Sigaction.sigaction_fn, 1);
-    pub const ERR = @intToPtr(?Sigaction.sigaction_fn, maxInt(usize));
-    pub const CATCH = @intToPtr(?Sigaction.sigaction_fn, 2);
-    pub const HOLD = @intToPtr(?Sigaction.sigaction_fn, 3);
+    pub const DFL = @intToPtr(?Sigaction.handler_fn, 0);
+    pub const IGN = @intToPtr(?Sigaction.handler_fn, 1);
+    pub const ERR = @intToPtr(?Sigaction.handler_fn, maxInt(usize));
+    pub const CATCH = @intToPtr(?Sigaction.handler_fn, 2);
+    pub const HOLD = @intToPtr(?Sigaction.handler_fn, 3);
 
     pub const HUP = 1;
     pub const INT = 2;
diff --git a/lib/std/c/solaris.zig b/lib/std/c/solaris.zig
index 61e52cfe301d24ed9064f808f05ca5eb78556310..1e726beb75c9f4a71333de44efa35b6e24883f29 100644
--- a/lib/std/c/solaris.zig
+++ b/lib/std/c/solaris.zig
@@ -879,10 +879,10 @@ pub const winsize = extern struct {
 const NSIG = 75;
 
 pub const SIG = struct {
-    pub const DFL = @intToPtr(?Sigaction.sigaction_fn, 0);
-    pub const ERR = @intToPtr(?Sigaction.sigaction_fn, maxInt(usize));
-    pub const IGN = @intToPtr(?Sigaction.sigaction_fn, 1);
-    pub const HOLD = @intToPtr(?Sigaction.sigaction_fn, 2);
+    pub const DFL = @intToPtr(?Sigaction.handler_fn, 0);
+    pub const ERR = @intToPtr(?Sigaction.handler_fn, maxInt(usize));
+    pub const IGN = @intToPtr(?Sigaction.handler_fn, 1);
+    pub const HOLD = @intToPtr(?Sigaction.handler_fn, 2);
 
     pub const WORDS = 4;
     pub const MAXSIG = 75;
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 847298e54b5ab8459583586af79360d3df04db65..0738b5af0b63754bd20bc1efe653fa66cd49beb3 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -1787,7 +1787,7 @@ fn resetSegfaultHandler() void {
         return;
     }
     var act = os.Sigaction{
-        .handler = .{ .sigaction = os.SIG.DFL },
+        .handler = .{ .handler = os.SIG.DFL },
         .mask = os.empty_sigset,
         .flags = 0,
     };
diff --git a/lib/std/os.zig b/lib/std/os.zig
index b068a11229b54c93de90afed384f2321b0dbc041..46b1bed7bdc941cdb93f6a8f3582c9512236a9aa 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -475,7 +475,7 @@ pub fn abort() noreturn {
 
         // Install default handler so that the tkill below will terminate.
         const sigact = Sigaction{
-            .handler = .{ .sigaction = SIG.DFL },
+            .handler = .{ .handler = SIG.DFL },
             .mask = empty_sigset,
             .flags = 0,
         };
diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index ae9b441b60ef78abb72aaae579291e9d1c2b98b4..539f3612f91878967433f182d2339d32978f9e23 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -1945,9 +1945,9 @@ pub const SIG = if (is_mips) struct {
     pub const SYS = 31;
     pub const UNUSED = SIG.SYS;
 
-    pub const ERR = @intToPtr(?Sigaction.sigaction_fn, maxInt(usize));
-    pub const DFL = @intToPtr(?Sigaction.sigaction_fn, 0);
-    pub const IGN = @intToPtr(?Sigaction.sigaction_fn, 1);
+    pub const ERR = @intToPtr(?Sigaction.handler_fn, maxInt(usize));
+    pub const DFL = @intToPtr(?Sigaction.handler_fn, 0);
+    pub const IGN = @intToPtr(?Sigaction.handler_fn, 1);
 } else if (is_sparc) struct {
     pub const BLOCK = 1;
     pub const UNBLOCK = 2;
@@ -1989,9 +1989,9 @@ pub const SIG = if (is_mips) struct {
     pub const PWR = LOST;
     pub const IO = SIG.POLL;
 
-    pub const ERR = @intToPtr(?Sigaction.sigaction_fn, maxInt(usize));
-    pub const DFL = @intToPtr(?Sigaction.sigaction_fn, 0);
-    pub const IGN = @intToPtr(?Sigaction.sigaction_fn, 1);
+    pub const ERR = @intToPtr(?Sigaction.handler_fn, maxInt(usize));
+    pub const DFL = @intToPtr(?Sigaction.handler_fn, 0);
+    pub const IGN = @intToPtr(?Sigaction.handler_fn, 1);
 } else struct {
     pub const BLOCK = 0;
     pub const UNBLOCK = 1;
@@ -2032,9 +2032,9 @@ pub const SIG = if (is_mips) struct {
     pub const SYS = 31;
     pub const UNUSED = SIG.SYS;
 
-    pub const ERR = @intToPtr(?Sigaction.sigaction_fn, maxInt(usize));
-    pub const DFL = @intToPtr(?Sigaction.sigaction_fn, 0);
-    pub const IGN = @intToPtr(?Sigaction.sigaction_fn, 1);
+    pub const ERR = @intToPtr(?Sigaction.handler_fn, maxInt(usize));
+    pub const DFL = @intToPtr(?Sigaction.handler_fn, 0);
+    pub const IGN = @intToPtr(?Sigaction.handler_fn, 1);
 };
 
 pub const kernel_rwf = u32;
diff --git a/lib/std/os/test.zig b/lib/std/os/test.zig
index 44f8b16b9e0c97bcd8aa5f2e97bdb946dbf91ab0..a8497586f96999ec061dfbbf60cc88d394cb0fff 100644
--- a/lib/std/os/test.zig
+++ b/lib/std/os/test.zig
@@ -785,7 +785,7 @@ test "sigaction" {
     try testing.expect(signal_test_failed == false);
     // Check if the handler has been correctly reset to SIG_DFL
     try os.sigaction(os.SIG.USR1, null, &old_sa);
-    try testing.expectEqual(os.SIG.DFL, old_sa.handler.sigaction);
+    try testing.expectEqual(os.SIG.DFL, old_sa.handler.handler);
 }
 
 test "dup & dup2" {
-- 
2.54.0


From a82d7c20631b90de2f2298d351353041ac41650d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 23:02:04 -0700
Subject: [PATCH 091/290] std: add missing error to windows.WriteFile

I encountered this error today when testing the self-hosted compiler on
Windows.
---
 lib/std/os.zig         | 4 ++++
 lib/std/os/windows.zig | 4 ++++
 src/link.zig           | 1 +
 src/main.zig           | 1 +
 4 files changed, 10 insertions(+)

diff --git a/lib/std/os.zig b/lib/std/os.zig
index 1192c726298e8919ab6dce959a1c26409ccb8494..2836ddf9c9111fe2f81ef614e5b71a9c93fcefa6 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -953,6 +953,10 @@ pub const WriteError = error{
     OperationAborted,
     NotOpenForWriting,
 
+    /// The process cannot access the file because another process has locked
+    /// a portion of the file. Windows-only.
+    LockViolation,
+
     /// This error occurs when no global event loop is configured,
     /// and reading from the file descriptor would block.
     WouldBlock,
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index 3e42ee5f2d08cc28acea971949ed5dca62604189..c79ccb511375d5127a21062d497f897d1ba5754d 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -517,6 +517,9 @@ pub const WriteFileError = error{
     OperationAborted,
     BrokenPipe,
     NotOpenForWriting,
+    /// The process cannot access the file because another process has locked
+    /// a portion of the file.
+    LockViolation,
     Unexpected,
 };
 
@@ -597,6 +600,7 @@ pub fn WriteFile(
                 .IO_PENDING => unreachable,
                 .BROKEN_PIPE => return error.BrokenPipe,
                 .INVALID_HANDLE => return error.NotOpenForWriting,
+                .LOCK_VIOLATION => return error.LockViolation,
                 else => |err| return unexpectedError(err),
             }
         }
diff --git a/src/link.zig b/src/link.zig
index a69dcc4c6eae8f3677519c55bb8871a33d20d4db..14ae142a3fbe4a8eba828f82de53fc9a6ff92c79 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -435,6 +435,7 @@ pub const File = struct {
         EmitFail,
         NameTooLong,
         CurrentWorkingDirectoryUnlinked,
+        LockViolation,
     };
 
     /// Called from within the CodeGen to lower a local variable instantion as an unnamed
diff --git a/src/main.zig b/src/main.zig
index c103cddcd45c6504b4354cfcaaf0fad21bdd1184..971fe19e36c6c3f384d4dc0ce55c590e5b18ecac 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -4227,6 +4227,7 @@ const FmtError = error{
     NotOpenForWriting,
     UnsupportedEncoding,
     ConnectionResetByPeer,
+    LockViolation,
 } || fs.File.OpenError;
 
 fn fmtPath(fmt: *Fmt, file_path: []const u8, check_mode: bool, dir: fs.Dir, sub_path: []const u8) FmtError!void {
-- 
2.54.0


From bbcc26a9b6d8de5971f26cda01350022a1049e08 Mon Sep 17 00:00:00 2001
From: LordMZTE <lord@mzte.de>
Date: Thu, 11 Aug 2022 12:16:36 +0200
Subject: [PATCH 092/290] fix error message when providing slice to
 `std.hash.autoHash`

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

diff --git a/lib/std/hash/auto_hash.zig b/lib/std/hash/auto_hash.zig
index c4060e9182b5f6b0c119e7779614312b0bb23f07..951c0148d9d03f1f3a1835de2583ec9c5555488b 100644
--- a/lib/std/hash/auto_hash.zig
+++ b/lib/std/hash/auto_hash.zig
@@ -193,8 +193,8 @@ fn typeContainsSlice(comptime K: type) bool {
 pub fn autoHash(hasher: anytype, key: anytype) void {
     const Key = @TypeOf(key);
     if (comptime typeContainsSlice(Key)) {
-        @compileError("std.auto_hash.autoHash does not allow slices as well as unions and structs containing slices here (" ++ @typeName(Key) ++
-            ") because the intent is unclear. Consider using std.auto_hash.hash or providing your own hash function instead.");
+        @compileError("std.hash.autoHash does not allow slices as well as unions and structs containing slices here (" ++ @typeName(Key) ++
+            ") because the intent is unclear. Consider using std.hash.autoHashStrat or providing your own hash function instead.");
     }
 
     hash(hasher, key, .Shallow);
-- 
2.54.0


From bcc6cdc4fb7784895bd3f508a8a642f3dae5d81e Mon Sep 17 00:00:00 2001
From: Hadrien Dorio <hadrien.dorio@gmail.com>
Date: Tue, 9 Aug 2022 04:16:54 +0200
Subject: [PATCH 093/290] ci: azure: stop when exe exits with an error

---
 ci/azure/pipelines.yml | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index 75e9e7ef8eee9f7f61d8c8772f892362a05038c8..27e95c6842361e65c8d5c7c674001933742dbd4c 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -41,6 +41,13 @@ jobs:
       Set-Variable -Name ZIGINSTALLDIR -Value "${ZIGBUILDDIR}\dist"
       Set-Variable -Name ZIGPREFIXPATH -Value "$(Get-Location)\$(ZIG_LLVM_CLANG_LLD_NAME)"
 
+      function CheckLastExitCode {
+        if (!$?) {
+          exit 1
+        }
+        return 0
+      }
+
       # Make the `zig version` number consistent.
       # This will affect the `zig build` command below which uses `git describe`.
       git config core.abbrev 9
@@ -69,6 +76,7 @@ jobs:
         -Dstrip `
         -Duse-zig-libcxx `
         -Dtarget=$(TARGET)
+      CheckLastExitCode
 
       cd -
 
@@ -83,19 +91,37 @@ jobs:
   - pwsh: |
       Set-Variable -Name ZIGINSTALLDIR -Value "$(Get-Location)\build\dist"
 
+      function CheckLastExitCode {
+        if (!$?) {
+          exit 1
+        }
+        return 0
+      }
+
       # Sadly, stage2 is omitted from this build to save memory on the CI server. Once self-hosted is
       # built with itself and does not gobble as much memory, we can enable these tests.
       #& "$ZIGINSTALLDIR\bin\zig.exe" test "..\test\behavior.zig" -fno-stage1 -fLLVM -I "..\test" 2>&1
+      #CheckLastExitCode
 
       & "$ZIGINSTALLDIR\bin\zig.exe" build test-toolchain -Dskip-non-native -Dskip-stage2-tests 2>&1
+      CheckLastExitCode
       & "$ZIGINSTALLDIR\bin\zig.exe" build test-std -Dskip-non-native  2>&1
+      CheckLastExitCode
     name: test
     displayName: 'Test'
 
   - pwsh: |
       Set-Variable -Name ZIGINSTALLDIR -Value "$(Get-Location)\build\dist"
 
+      function CheckLastExitCode {
+        if (!$?) {
+          exit 1
+        }
+        return 0
+      }
+
       & "$ZIGINSTALLDIR\bin\zig.exe" build docs
+      CheckLastExitCode
     timeoutInMinutes: 60
     name: doc
     displayName: 'Documentation'
-- 
2.54.0


From 64307c28211a7d402bd7f4363dff5b65ab79bd34 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 23:55:10 -0700
Subject: [PATCH 094/290] CI: update windows tarball

---
 ci/azure/pipelines.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index 27e95c6842361e65c8d5c7c674001933742dbd4c..5ff0a5d61b1506c1605ebe347988d430c5c52c8c 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -27,7 +27,7 @@ jobs:
     vmImage: 'windows-2019'
   variables:
     TARGET: 'x86_64-windows-gnu'
-    ZIG_LLVM_CLANG_LLD_NAME: 'zig+llvm+lld+clang-${{ variables.TARGET }}-0.10.0-dev.2931+bdf3fa12f'
+    ZIG_LLVM_CLANG_LLD_NAME: 'zig+llvm+lld+clang-${{ variables.TARGET }}-0.10.0-dev.3524+74673b7f6'
     ZIG_LLVM_CLANG_LLD_URL: 'https://ziglang.org/deps/${{ variables.ZIG_LLVM_CLANG_LLD_NAME }}.zip'
   steps:
   - pwsh: |
-- 
2.54.0


From dba758da18a706efbdbeb1e1bbbabdfe49e1931d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 11 Aug 2022 12:56:46 -0700
Subject: [PATCH 095/290] disable failing C backend behavior test on Windows

See tracking issue #12415
---
 test/tests.zig | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/test/tests.zig b/test/tests.zig
index dcc891f8786bd90c50a384160e228ede9011bcc6..0bca9a9d16030ceae1322a01008281722f9f536e 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -641,6 +641,13 @@ pub fn addPkgTests(
         } else false;
         if (!want_this_mode) continue;
 
+        if (test_target.backend) |backend| {
+            if (backend == .stage2_c and builtin.os.tag == .windows) {
+                // https://github.com/ziglang/zig/issues/12415
+                continue;
+            }
+        }
+
         const libc_prefix = if (test_target.target.getOs().requiresLibC())
             ""
         else if (test_target.link_libc)
-- 
2.54.0


From 23a227a0736d2ef749c41b43857a7aabc8919597 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 11 Aug 2022 16:55:24 -0700
Subject: [PATCH 096/290] disable failing standalone test: issue_11595

See tracking issue #12419
---
 test/standalone.zig | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/test/standalone.zig b/test/standalone.zig
index 2b0667e89c988f3bd88d7fe757132e5c209491fc..2a7902dfb25835c9e3f81d7df9df628830dfacae 100644
--- a/test/standalone.zig
+++ b/test/standalone.zig
@@ -34,7 +34,10 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
     if (builtin.zig_backend == .stage1) { // https://github.com/ziglang/zig/issues/12194
         cases.addBuildFile("test/standalone/issue_9812/build.zig", .{});
     }
-    cases.addBuildFile("test/standalone/issue_11595/build.zig", .{});
+    if (builtin.os.tag != .windows) {
+        // https://github.com/ziglang/zig/issues/12419
+        cases.addBuildFile("test/standalone/issue_11595/build.zig", .{});
+    }
     if (builtin.os.tag != .wasi) {
         cases.addBuildFile("test/standalone/load_dynamic_library/build.zig", .{});
     }
-- 
2.54.0


From 486626beb73936a10c3a566607b1c6633292fb8f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 11 Aug 2022 17:51:57 -0700
Subject: [PATCH 097/290] disable failing link tests on windows

See tracking issue #12421
---
 test/link.zig | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/link.zig b/test/link.zig
index 1e75620919ca2976f45316f29121c97d582ae692..01edd07261d05ba943e449528ba410625951e68e 100644
--- a/test/link.zig
+++ b/test/link.zig
@@ -3,6 +3,11 @@ const builtin = @import("builtin");
 const tests = @import("tests.zig");
 
 pub fn addCases(cases: *tests.StandaloneContext) void {
+    if (builtin.os.tag == .windows) {
+        // https://github.com/ziglang/zig/issues/12421
+        return;
+    }
+
     cases.addBuildFile("test/link/bss/build.zig", .{
         .build_modes = false, // we only guarantee zerofill for undefined in Debug
     });
-- 
2.54.0


From 5e42b0821a5aa6af2327b4380fd796be274cb024 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 11 Aug 2022 19:19:23 -0700
Subject: [PATCH 098/290] disable failing stack traces tests on windows

See tracking issue #12422
---
 test/stack_traces.zig | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/stack_traces.zig b/test/stack_traces.zig
index ea27b5beff7e94a170f6be4edbd065a7013e26b9..e514e0fd881a419893cb9dacf56928c891fa171f 100644
--- a/test/stack_traces.zig
+++ b/test/stack_traces.zig
@@ -3,6 +3,11 @@ const os = std.os;
 const tests = @import("tests.zig");
 
 pub fn addCases(cases: *tests.StackTracesContext) void {
+    if (@import("builtin").os.tag == .windows) {
+        // https://github.com/ziglang/zig/issues/12422
+        return;
+    }
+
     cases.addCase(.{
         .name = "return",
         .source = 
-- 
2.54.0


From 7c9979a02e830a4383995e66ff623a7d07cac091 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Thu, 11 Aug 2022 22:45:15 +0300
Subject: [PATCH 099/290] stage2: generate a switch for `@errSetCast` safety

---
 src/Air.zig                  |  5 ++++
 src/Liveness.zig             |  2 ++
 src/Sema.zig                 | 13 +++-------
 src/arch/aarch64/CodeGen.zig |  1 +
 src/arch/arm/CodeGen.zig     |  1 +
 src/arch/riscv64/CodeGen.zig |  1 +
 src/arch/sparc64/CodeGen.zig |  1 +
 src/arch/wasm/CodeGen.zig    |  1 +
 src/arch/x86_64/CodeGen.zig  |  1 +
 src/codegen/c.zig            |  1 +
 src/codegen/llvm.zig         | 48 ++++++++++++++++++++++++++++++++++++
 src/print_air.zig            |  1 +
 12 files changed, 66 insertions(+), 10 deletions(-)

diff --git a/src/Air.zig b/src/Air.zig
index c5734278d338458e549749bccf5462b301d28e97..e08993bbed5ab8b2b07efafd1d719e97e5b69460 100644
--- a/src/Air.zig
+++ b/src/Air.zig
@@ -673,6 +673,10 @@ pub const Inst = struct {
         /// Uses the `un_op` field.
         error_name,
 
+        /// Returns true if error set has error with value.
+        /// Uses the `ty_op` field.
+        error_set_has_value,
+
         /// Constructs a vector, tuple, struct, or array value out of runtime-known elements.
         /// Some of the elements may be comptime-known.
         /// Uses the `ty_pl` field, payload is index of an array of elements, each of which
@@ -1062,6 +1066,7 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
         .is_err_ptr,
         .is_non_err_ptr,
         .is_named_enum_value,
+        .error_set_has_value,
         => return Type.bool,
 
         .const_ty => return Type.type,
diff --git a/src/Liveness.zig b/src/Liveness.zig
index 748016d5845d689cd69d0d43a39ee05991c08327..5a4bd2265e18e0854da76183e3f69e111995264c 100644
--- a/src/Liveness.zig
+++ b/src/Liveness.zig
@@ -267,6 +267,7 @@ pub fn categorizeOperand(
         .byte_swap,
         .bit_reverse,
         .splat,
+        .error_set_has_value,
         => {
             const o = air_datas[inst].ty_op;
             if (o.operand == operand_ref) return matchOperandSmallIndex(l, inst, 0, .none);
@@ -842,6 +843,7 @@ fn analyzeInst(
         .byte_swap,
         .bit_reverse,
         .splat,
+        .error_set_has_value,
         => {
             const o = inst_datas[inst].ty_op;
             return trackOperands(a, new_set, inst, main_tomb, .{ o.operand, .none, .none });
diff --git a/src/Sema.zig b/src/Sema.zig
index f9b37f5b495eb26d578978a14e95cf9e14d1253d..3e62344a0436948a708a944201de9a7aa1baf568 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -17359,17 +17359,10 @@ fn zirErrSetCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
     }
 
     try sema.requireRuntimeBlock(block, src, operand_src);
-    if (block.wantSafety() and !dest_ty.isAnyError()) {
+    if (block.wantSafety() and !dest_ty.isAnyError() and sema.mod.comp.bin_file.options.use_llvm) {
         const err_int_inst = try block.addBitCast(Type.u16, operand);
-        // TODO: Output a switch instead of chained OR's.
-        var found_match: Air.Inst.Ref = undefined;
-        for (dest_ty.errorSetNames()) |dest_err_name, i| {
-            const dest_err_int = (try sema.mod.getErrorValue(dest_err_name)).value;
-            const dest_err_int_inst = try sema.addIntUnsigned(Type.u16, dest_err_int);
-            const next_match = try block.addBinOp(.cmp_eq, dest_err_int_inst, err_int_inst);
-            found_match = if (i == 0) next_match else try block.addBinOp(.bool_or, found_match, next_match);
-        }
-        try sema.addSafetyCheck(block, found_match, .invalid_error_code);
+        const ok = try block.addTyOp(.error_set_has_value, dest_ty, err_int_inst);
+        try sema.addSafetyCheck(block, ok, .invalid_error_code);
     }
     return block.addBitCast(dest_ty, operand);
 }
diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig
index 988317284bd64cc9646fd0eaebbabf8759eb3a16..d256f9a55856b24f42d3426121446ffa86f9d26d 100644
--- a/src/arch/aarch64/CodeGen.zig
+++ b/src/arch/aarch64/CodeGen.zig
@@ -778,6 +778,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             => return self.fail("TODO implement optimized float mode", .{}),
 
             .is_named_enum_value => return self.fail("TODO implement is_named_enum_value", .{}),
+            .error_set_has_value => return self.fail("TODO implement error_set_has_value", .{}),
 
             .wasm_memory_size => unreachable,
             .wasm_memory_grow => unreachable,
diff --git a/src/arch/arm/CodeGen.zig b/src/arch/arm/CodeGen.zig
index be2891ef6fc0116e15af4099387ebd2d1eafddb6..60008ec1d1927aa864028ccd35bfc225e00dd16f 100644
--- a/src/arch/arm/CodeGen.zig
+++ b/src/arch/arm/CodeGen.zig
@@ -769,6 +769,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             => return self.fail("TODO implement optimized float mode", .{}),
 
             .is_named_enum_value => return self.fail("TODO implement is_named_enum_value", .{}),
+            .error_set_has_value => return self.fail("TODO implement error_set_has_value", .{}),
 
             .wasm_memory_size => unreachable,
             .wasm_memory_grow => unreachable,
diff --git a/src/arch/riscv64/CodeGen.zig b/src/arch/riscv64/CodeGen.zig
index a5007928b639e9a785cafc922b6a4d1819ab215e..06adcff6d45f1bed059a932a5066bcbe3baf62aa 100644
--- a/src/arch/riscv64/CodeGen.zig
+++ b/src/arch/riscv64/CodeGen.zig
@@ -694,6 +694,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             => return self.fail("TODO implement optimized float mode", .{}),
 
             .is_named_enum_value => return self.fail("TODO implement is_named_enum_value", .{}),
+            .error_set_has_value => return self.fail("TODO implement error_set_has_value", .{}),
 
             .wasm_memory_size => unreachable,
             .wasm_memory_grow => unreachable,
diff --git a/src/arch/sparc64/CodeGen.zig b/src/arch/sparc64/CodeGen.zig
index bf834a36d97a2db27df9e7b993800630a5f034e6..cd891f0fa3a0e8e9c23cb5a32a7357fca85a5a09 100644
--- a/src/arch/sparc64/CodeGen.zig
+++ b/src/arch/sparc64/CodeGen.zig
@@ -706,6 +706,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             => @panic("TODO implement optimized float mode"),
 
             .is_named_enum_value => @panic("TODO implement is_named_enum_value"),
+            .error_set_has_value => @panic("TODO implement error_set_has_value"),
 
             .wasm_memory_size => unreachable,
             .wasm_memory_grow => unreachable,
diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index 53b7b7fb6bae6441f46534606cc4810e0342cfeb..8eb3e2175b9a292f54bdc9cee85d8d70d5133c3c 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -1694,6 +1694,7 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
         .err_return_trace,
         .set_err_return_trace,
         .is_named_enum_value,
+        .error_set_has_value,
         => |tag| return self.fail("TODO: Implement wasm inst: {s}", .{@tagName(tag)}),
 
         .add_optimized,
diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig
index 7f7473bc666484c8b6e3f7fce6995a17df75a1ee..8d19768bbb278aa560091048727ba5f2c894b0b9 100644
--- a/src/arch/x86_64/CodeGen.zig
+++ b/src/arch/x86_64/CodeGen.zig
@@ -776,6 +776,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
             => return self.fail("TODO implement optimized float mode", .{}),
 
             .is_named_enum_value => return self.fail("TODO implement is_named_enum_value", .{}),
+            .error_set_has_value => return self.fail("TODO implement error_set_has_value", .{}),
 
             .wasm_memory_size => unreachable,
             .wasm_memory_grow => unreachable,
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 74e4404bce2bc3fd86ab1daef83f8dc9ff33885a..81a892183f1dca201878af7fc1ddff0b83b89a62 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -1954,6 +1954,7 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO
             => return f.fail("TODO implement optimized float mode", .{}),
 
             .is_named_enum_value => return f.fail("TODO: C backend: implement is_named_enum_value", .{}),
+            .error_set_has_value => return f.fail("TODO: C backend: implement error_set_has_value", .{}),
             // zig fmt: on
         };
         switch (result_value) {
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 38f7d285aed18678a4340e7a47cd5fe395639bcb..5da3e7e32790fb323edf9e9d9c2d8722bd03c1fd 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -4247,6 +4247,7 @@ pub const FuncGen = struct {
                 .prefetch       => try self.airPrefetch(inst),
 
                 .is_named_enum_value => try self.airIsNamedEnumValue(inst),
+                .error_set_has_value => try self.airErrorSetHasValue(inst),
 
                 .reduce           => try self.airReduce(inst, false),
                 .reduce_optimized => try self.airReduce(inst, true),
@@ -7983,6 +7984,53 @@ pub const FuncGen = struct {
         }
     }
 
+    fn airErrorSetHasValue(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+        if (self.liveness.isUnused(inst)) return null;
+
+        const ty_op = self.air.instructions.items(.data)[inst].ty_op;
+        const operand = try self.resolveInst(ty_op.operand);
+        const error_set_ty = self.air.getRefType(ty_op.ty);
+
+        const names = error_set_ty.errorSetNames();
+        const valid_block = self.dg.context.appendBasicBlock(self.llvm_func, "Valid");
+        const invalid_block = self.dg.context.appendBasicBlock(self.llvm_func, "Invalid");
+        const end_block = self.context.appendBasicBlock(self.llvm_func, "End");
+        const switch_instr = self.builder.buildSwitch(operand, invalid_block, @intCast(c_uint, names.len));
+
+        for (names) |name| {
+            const err_int = self.dg.module.global_error_set.get(name).?;
+            const this_tag_int_value = int: {
+                var tag_val_payload: Value.Payload.U64 = .{
+                    .base = .{ .tag = .int_u64 },
+                    .data = err_int,
+                };
+                break :int try self.dg.lowerValue(.{
+                    .ty = Type.u16,
+                    .val = Value.initPayload(&tag_val_payload.base),
+                });
+            };
+            switch_instr.addCase(this_tag_int_value, valid_block);
+        }
+        self.builder.positionBuilderAtEnd(valid_block);
+        _ = self.builder.buildBr(end_block);
+
+        self.builder.positionBuilderAtEnd(invalid_block);
+        _ = self.builder.buildBr(end_block);
+
+        self.builder.positionBuilderAtEnd(end_block);
+
+        const llvm_type = self.dg.context.intType(1);
+        const incoming_values: [2]*const llvm.Value = .{
+            llvm_type.constInt(1, .False), llvm_type.constInt(0, .False),
+        };
+        const incoming_blocks: [2]*const llvm.BasicBlock = .{
+            valid_block, invalid_block,
+        };
+        const phi_node = self.builder.buildPhi(llvm_type, "");
+        phi_node.addIncoming(&incoming_values, &incoming_blocks, 2);
+        return phi_node;
+    }
+
     fn airIsNamedEnumValue(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
         if (self.liveness.isUnused(inst)) return null;
 
diff --git a/src/print_air.zig b/src/print_air.zig
index 23107946f6fee77767631ced2b2032988b1a77ec..04dec25f5f51e431a0c69158c29d0b1c7c100d19 100644
--- a/src/print_air.zig
+++ b/src/print_air.zig
@@ -243,6 +243,7 @@ const Writer = struct {
             .popcount,
             .byte_swap,
             .bit_reverse,
+            .error_set_has_value,
             => try w.writeTyOp(s, inst),
 
             .block,
-- 
2.54.0


From 09f273136c74639d18695f63ba9c0fdc68ad678c Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Thu, 11 Aug 2022 23:06:50 +0300
Subject: [PATCH 100/290] stage2: check for zero in `@intToError` safety

---
 src/Sema.zig                               | 22 ++++++++++++----------
 src/codegen/llvm.zig                       |  2 +-
 src/type.zig                               |  2 ++
 test/cases/safety/zero casted to error.zig | 19 +++++++++++++++++++
 4 files changed, 34 insertions(+), 11 deletions(-)
 create mode 100644 test/cases/safety/zero casted to error.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index 3e62344a0436948a708a944201de9a7aa1baf568..55b519d9003fdcce6669a5115325cb72f4e36820 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -6804,11 +6804,10 @@ fn zirErrorToInt(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
     const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = extra.node };
     const uncasted_operand = try sema.resolveInst(extra.operand);
     const operand = try sema.coerce(block, Type.anyerror, uncasted_operand, operand_src);
-    const result_ty = Type.u16;
 
     if (try sema.resolveMaybeUndefVal(block, src, operand)) |val| {
         if (val.isUndef()) {
-            return sema.addConstUndef(result_ty);
+            return sema.addConstUndef(Type.err_int);
         }
         switch (val.tag()) {
             .@"error" => {
@@ -6817,14 +6816,14 @@ fn zirErrorToInt(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
                     .base = .{ .tag = .int_u64 },
                     .data = (try sema.mod.getErrorValue(val.castTag(.@"error").?.data.name)).value,
                 };
-                return sema.addConstant(result_ty, Value.initPayload(&payload.base));
+                return sema.addConstant(Type.err_int, Value.initPayload(&payload.base));
             },
 
             // This is not a valid combination with the type `anyerror`.
             .the_only_possible_value => unreachable,
 
             // Assume it's already encoded as an integer.
-            else => return sema.addConstant(result_ty, val),
+            else => return sema.addConstant(Type.err_int, val),
         }
     }
 
@@ -6833,14 +6832,14 @@ fn zirErrorToInt(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
     if (!op_ty.isAnyError()) {
         const names = op_ty.errorSetNames();
         switch (names.len) {
-            0 => return sema.addConstant(result_ty, Value.zero),
-            1 => return sema.addIntUnsigned(result_ty, sema.mod.global_error_set.get(names[0]).?),
+            0 => return sema.addConstant(Type.err_int, Value.zero),
+            1 => return sema.addIntUnsigned(Type.err_int, sema.mod.global_error_set.get(names[0]).?),
             else => {},
         }
     }
 
     try sema.requireRuntimeBlock(block, src, operand_src);
-    return block.addBitCast(result_ty, operand);
+    return block.addBitCast(Type.err_int, operand);
 }
 
 fn zirIntToError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
@@ -6851,7 +6850,7 @@ fn zirIntToError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
     const src = LazySrcLoc.nodeOffset(extra.node);
     const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = extra.node };
     const uncasted_operand = try sema.resolveInst(extra.operand);
-    const operand = try sema.coerce(block, Type.u16, uncasted_operand, operand_src);
+    const operand = try sema.coerce(block, Type.err_int, uncasted_operand, operand_src);
     const target = sema.mod.getTarget();
 
     if (try sema.resolveDefinedValue(block, operand_src, operand)) |value| {
@@ -6868,7 +6867,10 @@ fn zirIntToError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
     try sema.requireRuntimeBlock(block, src, operand_src);
     if (block.wantSafety()) {
         const is_lt_len = try block.addUnOp(.cmp_lt_errors_len, operand);
-        try sema.addSafetyCheck(block, is_lt_len, .invalid_error_code);
+        const zero_val = try sema.addConstant(Type.err_int, Value.zero);
+        const is_non_zero = try block.addBinOp(.cmp_neq, operand, zero_val);
+        const ok = try block.addBinOp(.bit_and, is_lt_len, is_non_zero);
+        try sema.addSafetyCheck(block, ok, .invalid_error_code);
     }
     return block.addInst(.{
         .tag = .bitcast,
@@ -17360,7 +17362,7 @@ fn zirErrSetCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
 
     try sema.requireRuntimeBlock(block, src, operand_src);
     if (block.wantSafety() and !dest_ty.isAnyError() and sema.mod.comp.bin_file.options.use_llvm) {
-        const err_int_inst = try block.addBitCast(Type.u16, operand);
+        const err_int_inst = try block.addBitCast(Type.err_int, operand);
         const ok = try block.addTyOp(.error_set_has_value, dest_ty, err_int_inst);
         try sema.addSafetyCheck(block, ok, .invalid_error_code);
     }
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 5da3e7e32790fb323edf9e9d9c2d8722bd03c1fd..0586c994320b91708d92d8962cccf7c487b6b5d2 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -8005,7 +8005,7 @@ pub const FuncGen = struct {
                     .data = err_int,
                 };
                 break :int try self.dg.lowerValue(.{
-                    .ty = Type.u16,
+                    .ty = Type.err_int,
                     .val = Value.initPayload(&tag_val_payload.base),
                 });
             };
diff --git a/src/type.zig b/src/type.zig
index 1b71f4e9b1d90f29517c7a1bf21709714c27a2f7..582ea230ef99fb64f2cd040ada393840bdda58a9 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -6303,6 +6303,8 @@ pub const Type = extern union {
     pub const @"anyopaque" = initTag(.anyopaque);
     pub const @"null" = initTag(.@"null");
 
+    pub const err_int = Type.u16;
+
     pub fn ptr(arena: Allocator, mod: *Module, data: Payload.Pointer.Data) !Type {
         const target = mod.getTarget();
 
diff --git a/test/cases/safety/zero casted to error.zig b/test/cases/safety/zero casted to error.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3a2edf834a1c7b2c7371c541d5c383cbbbf20a48
--- /dev/null
+++ b/test/cases/safety/zero casted to error.zig	
@@ -0,0 +1,19 @@
+const std = @import("std");
+
+pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
+    _ = stack_trace;
+    if (std.mem.eql(u8, message, "invalid error code")) {
+        std.process.exit(0);
+    }
+    std.process.exit(1);
+}
+pub fn main() !void {
+    bar(0) catch {};
+    return error.TestFailed;
+}
+fn bar(x: u16) anyerror {
+    return @intToError(x);
+}
+// run
+// backend=llvm
+// target=native
-- 
2.54.0


From 92568a0097a6aeb0cd59f1f3dae43d0ecd7a18d0 Mon Sep 17 00:00:00 2001
From: martinhath <martinhath@users.noreply.github.com>
Date: Fri, 12 Aug 2022 10:45:11 +0200
Subject: [PATCH 101/290] Sema: add error for signed integer division

stage1 error reads

error: division with 'i32' and 'comptime_int': signed integers must use @divTrunc, @divFloor, or @divExact

Fixes: #12339
---
 src/Sema.zig                                             | 7 ++++++-
 test/cases/compile_errors/signed_integer_division.zig    | 9 +++++++++
 .../stage1/obj/signed_integer_division.zig               | 9 ---------
 3 files changed, 15 insertions(+), 10 deletions(-)
 create mode 100644 test/cases/compile_errors/signed_integer_division.zig
 delete mode 100644 test/cases/compile_errors/stage1/obj/signed_integer_division.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index f9b37f5b495eb26d578978a14e95cf9e14d1253d..d697ab0a9958fea7647be7e20d9e1385ce063be8 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -11261,7 +11261,12 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
         try sema.addDivByZeroSafety(block, resolved_type, maybe_rhs_val, casted_rhs, is_int);
     }
 
-    const air_tag = if (is_int) Air.Inst.Tag.div_trunc else switch (block.float_mode) {
+    const air_tag = if (is_int) blk: {
+        if (lhs_ty.isSignedInt() or rhs_ty.isSignedInt()) {
+            return sema.fail(block, src, "division with '{s}' and '{s}': signed integers must use @divTrunc, @divFloor, or @divExact", .{ @tagName(lhs_ty.tag()), @tagName(rhs_ty.tag()) });
+        }
+        break :blk Air.Inst.Tag.div_trunc;
+    } else switch (block.float_mode) {
         .Optimized => Air.Inst.Tag.div_float_optimized,
         .Strict => Air.Inst.Tag.div_float,
     };
diff --git a/test/cases/compile_errors/signed_integer_division.zig b/test/cases/compile_errors/signed_integer_division.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7e968ac77eb1984c65ed4aa938366a24accacb3c
--- /dev/null
+++ b/test/cases/compile_errors/signed_integer_division.zig
@@ -0,0 +1,9 @@
+export fn foo(a: i32, b: i32) i32 {
+    return a / b;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:14: error: division with 'i32' and 'i32': signed integers must use @divTrunc, @divFloor, or @divExact
diff --git a/test/cases/compile_errors/stage1/obj/signed_integer_division.zig b/test/cases/compile_errors/stage1/obj/signed_integer_division.zig
deleted file mode 100644
index 3eebbf2248dbb2acd204d755c00346e2abbbdf6a..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/stage1/obj/signed_integer_division.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-export fn foo(a: i32, b: i32) i32 {
-    return a / b;
-}
-
-// error
-// backend=stage1
-// target=native
-//
-// tmp.zig:2:14: error: division with 'i32' and 'i32': signed integers must use @divTrunc, @divFloor, or @divExact
-- 
2.54.0


From f2f1bb7cb675fc14dc7754f06329b5780091baaf Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Thu, 11 Aug 2022 10:13:16 +0200
Subject: [PATCH 102/290] macho: update __DWARF sections before and after
 writing out __LINKEDIT

---
 src/link/Dwarf.zig              |  2 +-
 src/link/MachO/DebugSymbols.zig | 16 ++++++++--------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index 2cd00f5a87430c5bbcbe5327b3a7ebb88183d5a3..73891a81f5642bcc367050cbf2d72688b00d9eae 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -1259,7 +1259,7 @@ fn writeDeclDebugInfo(self: *Dwarf, file: *File, atom: *Atom, dbg_info_buf: []co
                     debug_info_sect.addr = dwarf_segment.vmaddr + new_offset - dwarf_segment.fileoff;
                 }
                 debug_info_sect.size = needed_size;
-                d_sym.debug_line_header_dirty = true;
+                d_sym.debug_info_header_dirty = true;
             }
             const file_pos = debug_info_sect.offset + atom.off;
             try pwriteDbgInfoNops(
diff --git a/src/link/MachO/DebugSymbols.zig b/src/link/MachO/DebugSymbols.zig
index 3bfe334302a1a7f929d4baa5f72472a315dd717b..c2aa562db5fdcf446e920099a63df8b1a689a595 100644
--- a/src/link/MachO/DebugSymbols.zig
+++ b/src/link/MachO/DebugSymbols.zig
@@ -63,17 +63,16 @@ pub const Reloc = struct {
 pub fn populateMissingMetadata(self: *DebugSymbols, allocator: Allocator) !void {
     if (self.linkedit_segment_cmd_index == null) {
         self.linkedit_segment_cmd_index = @intCast(u8, self.segments.items.len);
-        log.debug("found __LINKEDIT segment free space 0x{x} to 0x{x}", .{
-            self.base.page_size,
-            self.base.page_size * 2,
-        });
+        const fileoff = @intCast(u64, self.base.page_size);
+        const needed_size = @intCast(u64, self.base.page_size) * 2;
+        log.debug("found __LINKEDIT segment free space 0x{x} to 0x{x}", .{ fileoff, needed_size });
         // TODO this needs reworking
         try self.segments.append(allocator, .{
             .segname = makeStaticString("__LINKEDIT"),
-            .vmaddr = self.base.page_size,
-            .vmsize = self.base.page_size,
-            .fileoff = self.base.page_size,
-            .filesize = self.base.page_size,
+            .vmaddr = fileoff,
+            .vmsize = needed_size,
+            .fileoff = fileoff,
+            .filesize = needed_size,
             .maxprot = macho.PROT.READ,
             .initprot = macho.PROT.READ,
             .cmdsize = @sizeOf(macho.segment_command_64),
@@ -284,6 +283,7 @@ pub fn flushModule(self: *DebugSymbols, allocator: Allocator, options: link.Opti
     const lc_writer = lc_buffer.writer();
     var ncmds: u32 = 0;
 
+    self.updateDwarfSegment();
     try self.writeLinkeditSegmentData(&ncmds, lc_writer);
     self.updateDwarfSegment();
 
-- 
2.54.0


From aeaffd42f6d1c8fc92fa7669a579a8e6c46eb641 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Fri, 12 Aug 2022 11:55:38 +0200
Subject: [PATCH 103/290] x86: fix generating debug info for variables

Add handling for these additional `MCValue`s:
* `.immediate` - lower to `DW.OP.consts` or `DW.OP.constu` depending
  on signedness followed by popping off the DWARF stack with
  `DW.OP.stack_value`
* `.undef` - lower to `DW.OP.implicit_value`
* `.none` - lower to `DW.OP.lit0` followed by popping off the DWARF
  stack with `DW.OP.stack_value`

For any remaining unhandled case, we generate `DW.OP.nop` in order
not to mess up remaining DWARF info.
---
 src/arch/x86_64/CodeGen.zig | 48 ++++++++++++++++++++++++++++++++++++-
 src/link/Dwarf.zig          | 11 +++++----
 2 files changed, 54 insertions(+), 5 deletions(-)

diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig
index 7f7473bc666484c8b6e3f7fce6995a17df75a1ee..e58163875c065172314773163c2b7425be1357f9 100644
--- a/src/arch/x86_64/CodeGen.zig
+++ b/src/arch/x86_64/CodeGen.zig
@@ -4370,6 +4370,7 @@ fn genVarDbgInfo(
         .dwarf => |dw| {
             const dbg_info = &dw.dbg_info;
             try dbg_info.append(@enumToInt(link.File.Dwarf.AbbrevKind.variable));
+            const endian = self.target.cpu.arch.endian();
 
             switch (mcv) {
                 .register => |reg| {
@@ -4390,7 +4391,6 @@ fn genVarDbgInfo(
                     dbg_info.items[fixup] += @intCast(u8, dbg_info.items.len - fixup - 2);
                 },
                 .memory, .got_load, .direct_load => {
-                    const endian = self.target.cpu.arch.endian();
                     const ptr_width = @intCast(u8, @divExact(self.target.cpu.arch.ptrBitWidth(), 8));
                     const is_ptr = switch (tag) {
                         .dbg_var_ptr => true,
@@ -4425,7 +4425,53 @@ fn genVarDbgInfo(
                         else => {},
                     }
                 },
+                .immediate => |x| {
+                    const signedness: std.builtin.Signedness = blk: {
+                        if (ty.zigTypeTag() != .Int) break :blk .unsigned;
+                        break :blk ty.intInfo(self.target.*).signedness;
+                    };
+                    try dbg_info.ensureUnusedCapacity(2);
+                    const fixup = dbg_info.items.len;
+                    dbg_info.appendSliceAssumeCapacity(&[2]u8{ // DW.AT.location, DW.FORM.exprloc
+                        1,
+                        switch (signedness) {
+                            .signed => DW.OP.consts,
+                            .unsigned => DW.OP.constu,
+                        },
+                    });
+                    switch (signedness) {
+                        .signed => try leb128.writeILEB128(dbg_info.writer(), @bitCast(i64, x)),
+                        .unsigned => try leb128.writeULEB128(dbg_info.writer(), x),
+                    }
+                    try dbg_info.append(DW.OP.stack_value);
+                    dbg_info.items[fixup] += @intCast(u8, dbg_info.items.len - fixup - 2);
+                },
+                .undef => {
+                    // DW.AT.location, DW.FORM.exprloc
+                    // uleb128(exprloc_len)
+                    // DW.OP.implicit_value uleb128(len_of_bytes) bytes
+                    const abi_size = @intCast(u32, ty.abiSize(self.target.*));
+                    var implicit_value_len = std.ArrayList(u8).init(self.gpa);
+                    defer implicit_value_len.deinit();
+                    try leb128.writeULEB128(implicit_value_len.writer(), abi_size);
+                    const total_exprloc_len = 1 + implicit_value_len.items.len + abi_size;
+                    try leb128.writeULEB128(dbg_info.writer(), total_exprloc_len);
+                    try dbg_info.ensureUnusedCapacity(total_exprloc_len);
+                    dbg_info.appendAssumeCapacity(DW.OP.implicit_value);
+                    dbg_info.appendSliceAssumeCapacity(implicit_value_len.items);
+                    dbg_info.appendNTimesAssumeCapacity(0xaa, abi_size);
+                },
+                .none => {
+                    try dbg_info.ensureUnusedCapacity(3);
+                    dbg_info.appendSliceAssumeCapacity(&[3]u8{ // DW.AT.location, DW.FORM.exprloc
+                        2, DW.OP.lit0, DW.OP.stack_value,
+                    });
+                },
                 else => {
+                    try dbg_info.ensureUnusedCapacity(2);
+                    dbg_info.appendSliceAssumeCapacity(&[2]u8{ // DW.AT.location, DW.FORM.exprloc
+                        1, DW.OP.nop,
+                    });
                     log.debug("TODO generate debug info for {}", .{mcv});
                 },
             }
diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig
index 73891a81f5642bcc367050cbf2d72688b00d9eae..3ae151491f82716e5e3a1d1164aec6ff380a0efa 100644
--- a/src/link/Dwarf.zig
+++ b/src/link/Dwarf.zig
@@ -102,7 +102,7 @@ pub const DeclState = struct {
     }
 
     pub fn addExprlocReloc(self: *DeclState, target: u32, offset: u32, is_ptr: bool) !void {
-        log.debug("{x}: target sym @{d}, via GOT {}", .{ offset, target, is_ptr });
+        log.debug("{x}: target sym %{d}, via GOT {}", .{ offset, target, is_ptr });
         try self.exprloc_relocs.append(self.gpa, .{
             .@"type" = if (is_ptr) .got_load else .direct_load,
             .target = target,
@@ -135,7 +135,7 @@ pub const DeclState = struct {
                 .@"type" = ty,
                 .offset = undefined,
             });
-            log.debug("@{d}: {}", .{ sym_index, ty.fmtDebug() });
+            log.debug("%{d}: {}", .{ sym_index, ty.fmtDebug() });
             try self.abbrev_resolver.putNoClobberContext(self.gpa, ty, sym_index, .{
                 .mod = self.mod,
             });
@@ -143,7 +143,7 @@ pub const DeclState = struct {
                 .mod = self.mod,
             }).?;
         };
-        log.debug("{x}: @{d} + 0", .{ offset, resolv });
+        log.debug("{x}: %{d} + 0", .{ offset, resolv });
         try self.abbrev_relocs.append(self.gpa, .{
             .target = resolv,
             .atom = atom,
@@ -1056,6 +1056,7 @@ pub fn commitDeclState(
                 break :blk false;
             };
             if (deferred) {
+                log.debug("resolving %{d} deferred until flush", .{target});
                 try self.global_abbrev_relocs.append(gpa, .{
                     .target = null,
                     .offset = reloc.offset,
@@ -1063,10 +1064,12 @@ pub fn commitDeclState(
                     .addend = reloc.addend,
                 });
             } else {
+                const value = symbol.atom.off + symbol.offset + reloc.addend;
+                log.debug("{x}: [() => {x}] (%{d}, '{}')", .{ reloc.offset, value, target, ty.fmtDebug() });
                 mem.writeInt(
                     u32,
                     dbg_info_buffer.items[reloc.offset..][0..@sizeOf(u32)],
-                    symbol.atom.off + symbol.offset + reloc.addend,
+                    value,
                     target_endian,
                 );
             }
-- 
2.54.0


From 7e07f3d4f95f9e7a0d95ee7b9335798eccb470c7 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Fri, 12 Aug 2022 14:47:54 -0700
Subject: [PATCH 104/290] stage2 astgen: Use `rl` semantics for `@Type`

Resolves #12430.
---
 src/AstGen.zig               |  3 ++-
 test/behavior.zig            |  1 +
 test/behavior/bugs/12430.zig | 11 +++++++++++
 3 files changed, 14 insertions(+), 1 deletion(-)
 create mode 100644 test/behavior/bugs/12430.zig

diff --git a/src/AstGen.zig b/src/AstGen.zig
index af77cdacc466df99613f90e561aa4fd52e2fa60d..1151ed60daafecd81da92c24d26ab016a164bf7a 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -7676,7 +7676,8 @@ fn builtinCall(
                 } },
             });
             gz.instructions.appendAssumeCapacity(new_index);
-            return indexToRef(new_index);
+            const result = indexToRef(new_index);
+            return rvalue(gz, rl, result, node);
         },
         .panic => {
             try emitDbgNode(gz, node);
diff --git a/test/behavior.zig b/test/behavior.zig
index e9c4ec779bb5e6bc4dca8ea89eccddb61be1ab5a..40f8ca0fb3800fafe4d21156fc8c1c3c470c01c7 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -84,6 +84,7 @@ test {
     _ = @import("behavior/bugs/11213.zig");
     _ = @import("behavior/bugs/12003.zig");
     _ = @import("behavior/bugs/12033.zig");
+    _ = @import("behavior/bugs/12430.zig");
     _ = @import("behavior/byteswap.zig");
     _ = @import("behavior/byval_arg_var.zig");
     _ = @import("behavior/call.zig");
diff --git a/test/behavior/bugs/12430.zig b/test/behavior/bugs/12430.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cbf1658b1ccf195e54af47ac29342234247a4e16
--- /dev/null
+++ b/test/behavior/bugs/12430.zig
@@ -0,0 +1,11 @@
+const std = @import("std");
+
+test {
+    const T = comptime b: {
+        break :b @Type(.{ .Int = .{
+            .signedness = .unsigned,
+            .bits = 8,
+        } });
+    };
+    try std.testing.expect(T == u8);
+}
-- 
2.54.0


From 4c5156544b1b96a4860f98ecac5c7abe47de5465 Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Sat, 6 Aug 2022 21:23:21 +0200
Subject: [PATCH 105/290] stage2 ARM: pass stack arguments in opposite order

Earlier arguments have a smaller address (i.e. towards the bottom of
the stack)
---
 src/arch/arm/CodeGen.zig | 28 +++++++++++---------
 src/arch/arm/Emit.zig    | 57 ++++++++++++++--------------------------
 2 files changed, 34 insertions(+), 51 deletions(-)

diff --git a/src/arch/arm/CodeGen.zig b/src/arch/arm/CodeGen.zig
index be2891ef6fc0116e15af4099387ebd2d1eafddb6..0ac1344221ee0712192a29147f5580b8f88fd2ed 100644
--- a/src/arch/arm/CodeGen.zig
+++ b/src/arch/arm/CodeGen.zig
@@ -332,7 +332,7 @@ pub fn generate(
     };
 
     for (function.dbg_arg_relocs.items) |reloc| {
-        try function.genArgDbgInfo(reloc.inst, reloc.index, call_info.stack_byte_count);
+        try function.genArgDbgInfo(reloc.inst, reloc.index);
     }
 
     var mir = Mir{
@@ -351,7 +351,8 @@ pub fn generate(
         .prev_di_pc = 0,
         .prev_di_line = module_fn.lbrace_line,
         .prev_di_column = module_fn.lbrace_column,
-        .prologue_stack_space = call_info.stack_byte_count + function.saved_regs_stack_space,
+        .stack_size = function.max_end_stack,
+        .saved_regs_stack_space = function.saved_regs_stack_space,
     };
     defer emit.deinit();
 
@@ -464,6 +465,7 @@ fn gen(self: *Self) !void {
         const total_stack_size = self.max_end_stack + self.saved_regs_stack_space;
         const aligned_total_stack_end = mem.alignForwardGeneric(u32, total_stack_size, self.stack_align);
         const stack_size = aligned_total_stack_end - self.saved_regs_stack_space;
+        self.max_end_stack = stack_size;
         if (Instruction.Operand.fromU32(stack_size)) |op| {
             self.mir_instructions.set(sub_reloc, .{
                 .tag = .sub,
@@ -1812,7 +1814,7 @@ fn errUnionErr(self: *Self, error_union_mcv: MCValue, error_union_ty: Type) !MCV
     switch (error_union_mcv) {
         .register => return self.fail("TODO errUnionErr for registers", .{}),
         .stack_argument_offset => |off| {
-            return MCValue{ .stack_argument_offset = off - err_offset };
+            return MCValue{ .stack_argument_offset = off + err_offset };
         },
         .stack_offset => |off| {
             return MCValue{ .stack_offset = off - err_offset };
@@ -1849,7 +1851,7 @@ fn errUnionPayload(self: *Self, error_union_mcv: MCValue, error_union_ty: Type)
     switch (error_union_mcv) {
         .register => return self.fail("TODO errUnionPayload for registers", .{}),
         .stack_argument_offset => |off| {
-            return MCValue{ .stack_argument_offset = off - payload_offset };
+            return MCValue{ .stack_argument_offset = off + payload_offset };
         },
         .stack_offset => |off| {
             return MCValue{ .stack_offset = off - payload_offset };
@@ -1983,7 +1985,7 @@ fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void {
             .dead, .unreach => unreachable,
             .register => unreachable, // a slice doesn't fit in one register
             .stack_argument_offset => |off| {
-                break :result MCValue{ .stack_argument_offset = off - 4 };
+                break :result MCValue{ .stack_argument_offset = off + 4 };
             },
             .stack_offset => |off| {
                 break :result MCValue{ .stack_offset = off - 4 };
@@ -2507,7 +2509,7 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
         switch (mcv) {
             .dead, .unreach => unreachable,
             .stack_argument_offset => |off| {
-                break :result MCValue{ .stack_argument_offset = off - struct_field_offset };
+                break :result MCValue{ .stack_argument_offset = off + struct_field_offset };
             },
             .stack_offset => |off| {
                 break :result MCValue{ .stack_offset = off - struct_field_offset };
@@ -3369,9 +3371,7 @@ fn addDbgInfoTypeReloc(self: *Self, ty: Type) error{OutOfMemory}!void {
     }
 }
 
-fn genArgDbgInfo(self: *Self, inst: Air.Inst.Index, arg_index: u32, stack_byte_count: u32) error{OutOfMemory}!void {
-    const prologue_stack_space = stack_byte_count + self.saved_regs_stack_space;
-
+fn genArgDbgInfo(self: *Self, inst: Air.Inst.Index, arg_index: u32) error{OutOfMemory}!void {
     const mcv = self.args[arg_index];
     const ty = self.air.instructions.items(.data)[inst].ty;
     const name = self.mod_fn.getParamName(self.bin_file.options.module.?, arg_index);
@@ -3404,7 +3404,7 @@ fn genArgDbgInfo(self: *Self, inst: Air.Inst.Index, arg_index: u32, stack_byte_c
                     // const abi_size = @intCast(u32, ty.abiSize(self.target.*));
                     const adjusted_stack_offset = switch (mcv) {
                         .stack_offset => |offset| -@intCast(i32, offset),
-                        .stack_argument_offset => |offset| @intCast(i32, prologue_stack_space - offset),
+                        .stack_argument_offset => |offset| @intCast(i32, self.saved_regs_stack_space + offset),
                         else => unreachable,
                     };
 
@@ -3559,7 +3559,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallOptions.
             .stack_offset => unreachable,
             .stack_argument_offset => |offset| try self.genSetStackArgument(
                 arg_ty,
-                info.stack_byte_count - offset,
+                offset,
                 arg_mcv,
             ),
             else => unreachable,
@@ -5653,8 +5653,8 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
                     if (ty.abiAlignment(self.target.*) == 8)
                         nsaa = std.mem.alignForwardGeneric(u32, nsaa, 8);
 
-                    nsaa += param_size;
                     result.args[i] = .{ .stack_argument_offset = nsaa };
+                    nsaa += param_size;
                 }
             }
 
@@ -5687,9 +5687,11 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
             for (param_types) |ty, i| {
                 if (ty.abiSize(self.target.*) > 0) {
                     const param_size = @intCast(u32, ty.abiSize(self.target.*));
+                    const param_alignment = ty.abiAlignment(self.target.*);
 
-                    stack_offset = std.mem.alignForwardGeneric(u32, stack_offset, ty.abiAlignment(self.target.*)) + param_size;
+                    stack_offset = std.mem.alignForwardGeneric(u32, stack_offset, param_alignment);
                     result.args[i] = .{ .stack_argument_offset = stack_offset };
+                    stack_offset += param_size;
                 } else {
                     result.args[i] = .{ .none = {} };
                 }
diff --git a/src/arch/arm/Emit.zig b/src/arch/arm/Emit.zig
index 47d508b34aa5c315da3417e790c8a17dbcd4fd33..cf749792f0e81fa06a7cb5e3371c81da9d5afa49 100644
--- a/src/arch/arm/Emit.zig
+++ b/src/arch/arm/Emit.zig
@@ -33,9 +33,13 @@ prev_di_column: u32,
 /// Relative to the beginning of `code`.
 prev_di_pc: usize,
 
-/// The amount of stack space consumed by all stack arguments as well
-/// as the saved callee-saved registers
-prologue_stack_space: u32,
+/// The amount of stack space consumed by the saved callee-saved
+/// registers in bytes
+saved_regs_stack_space: u32,
+
+/// The final stack frame size of the function (already aligned to the
+/// respective stack alignment). Does not include prologue stack space.
+stack_size: u32,
 
 /// The branch type of every branch
 branch_types: std.AutoHashMapUnmanaged(Mir.Inst.Index, BranchType) = .{},
@@ -500,14 +504,15 @@ fn mirLoadStackArgument(emit: *Emit, inst: Mir.Inst.Index) !void {
     const tag = emit.mir.instructions.items(.tag)[inst];
     const cond = emit.mir.instructions.items(.cond)[inst];
     const r_stack_offset = emit.mir.instructions.items(.data)[inst].r_stack_offset;
+    const rt = r_stack_offset.rt;
 
-    const raw_offset = emit.prologue_stack_space - r_stack_offset.stack_offset;
+    const raw_offset = emit.stack_size + emit.saved_regs_stack_space + r_stack_offset.stack_offset;
     switch (tag) {
         .ldr_ptr_stack_argument => {
             const operand = Instruction.Operand.fromU32(raw_offset) orelse
                 return emit.fail("TODO mirLoadStack larger offsets", .{});
 
-            try emit.writeInstruction(Instruction.add(cond, r_stack_offset.rt, .fp, operand));
+            try emit.writeInstruction(Instruction.add(cond, rt, .sp, operand));
         },
         .ldr_stack_argument,
         .ldrb_stack_argument,
@@ -516,23 +521,11 @@ fn mirLoadStackArgument(emit: *Emit, inst: Mir.Inst.Index) !void {
                 break :blk Instruction.Offset.imm(@intCast(u12, raw_offset));
             } else return emit.fail("TODO mirLoadStack larger offsets", .{});
 
-            const ldr = switch (tag) {
-                .ldr_stack_argument => &Instruction.ldr,
-                .ldrb_stack_argument => &Instruction.ldrb,
+            switch (tag) {
+                .ldr_stack_argument => try emit.writeInstruction(Instruction.ldr(cond, rt, .sp, .{ .offset = offset })),
+                .ldrb_stack_argument => try emit.writeInstruction(Instruction.ldrb(cond, rt, .sp, .{ .offset = offset })),
                 else => unreachable,
-            };
-
-            const ldr_workaround = switch (builtin.zig_backend) {
-                .stage1 => ldr.*,
-                else => ldr,
-            };
-
-            try emit.writeInstruction(ldr_workaround(
-                cond,
-                r_stack_offset.rt,
-                .fp,
-                .{ .offset = offset },
-            ));
+            }
         },
         .ldrh_stack_argument,
         .ldrsb_stack_argument,
@@ -542,24 +535,12 @@ fn mirLoadStackArgument(emit: *Emit, inst: Mir.Inst.Index) !void {
                 break :blk Instruction.ExtraLoadStoreOffset.imm(@intCast(u8, raw_offset));
             } else return emit.fail("TODO mirLoadStack larger offsets", .{});
 
-            const ldr = switch (tag) {
-                .ldrh_stack_argument => &Instruction.ldrh,
-                .ldrsb_stack_argument => &Instruction.ldrsb,
-                .ldrsh_stack_argument => &Instruction.ldrsh,
+            switch (tag) {
+                .ldrh_stack_argument => try emit.writeInstruction(Instruction.ldrh(cond, rt, .sp, .{ .offset = offset })),
+                .ldrsb_stack_argument => try emit.writeInstruction(Instruction.ldrsb(cond, rt, .sp, .{ .offset = offset })),
+                .ldrsh_stack_argument => try emit.writeInstruction(Instruction.ldrsh(cond, rt, .sp, .{ .offset = offset })),
                 else => unreachable,
-            };
-
-            const ldr_workaround = switch (builtin.zig_backend) {
-                .stage1 => ldr.*,
-                else => ldr,
-            };
-
-            try emit.writeInstruction(ldr_workaround(
-                cond,
-                r_stack_offset.rt,
-                .fp,
-                .{ .offset = offset },
-            ));
+            }
         },
         else => unreachable,
     }
-- 
2.54.0


From 91969ad908ebb0362eac994ba10cb23bce0a7a4c Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Fri, 12 Aug 2022 20:29:48 +0200
Subject: [PATCH 106/290] stage2 ARM: Fix tracking of function return values

---
 src/arch/arm/CodeGen.zig | 35 +++++++++++++++++++++++++++++++++--
 1 file changed, 33 insertions(+), 2 deletions(-)

diff --git a/src/arch/arm/CodeGen.zig b/src/arch/arm/CodeGen.zig
index 0ac1344221ee0712192a29147f5580b8f88fd2ed..d78197d2a7159ae4c4af928ef9fc45d041583360 100644
--- a/src/arch/arm/CodeGen.zig
+++ b/src/arch/arm/CodeGen.zig
@@ -247,6 +247,31 @@ const BigTomb = struct {
             log.debug("%{d} => {}", .{ bt.inst, result });
             const branch = &bt.function.branch_stack.items[bt.function.branch_stack.items.len - 1];
             branch.inst_table.putAssumeCapacityNoClobber(bt.inst, result);
+
+            switch (result) {
+                .register => |reg| {
+                    // In some cases (such as bitcast), an operand
+                    // may be the same MCValue as the result. If
+                    // that operand died and was a register, it
+                    // was freed by processDeath. We have to
+                    // "re-allocate" the register.
+                    if (bt.function.register_manager.isRegFree(reg)) {
+                        bt.function.register_manager.getRegAssumeFree(reg, bt.inst);
+                    }
+                },
+                .register_c_flag,
+                .register_v_flag,
+                => |reg| {
+                    if (bt.function.register_manager.isRegFree(reg)) {
+                        bt.function.register_manager.getRegAssumeFree(reg, bt.inst);
+                    }
+                    bt.function.cpsr_flags_inst = bt.inst;
+                },
+                .cpsr_flags => {
+                    bt.function.cpsr_flags_inst = bt.inst;
+                },
+                else => {},
+            }
         }
         bt.function.finishAirBookkeeping();
     }
@@ -3524,7 +3549,10 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallOptions.
         try self.register_manager.getReg(reg, null);
     }
 
-    if (info.return_value == .stack_offset) {
+    // If returning by reference, r0 will contain the address of where
+    // to put the result into. In that case, make sure that r0 remains
+    // untouched by the parameter passing code
+    const r0_lock: ?RegisterLock = if (info.return_value == .stack_offset) blk: {
         log.debug("airCall: return by reference", .{});
         const ret_ty = fn_ty.fnReturnType();
         const ret_abi_size = @intCast(u32, ret_ty.abiSize(self.target.*));
@@ -3540,7 +3568,10 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallOptions.
         try self.genSetReg(ptr_ty, .r0, .{ .ptr_stack_offset = stack_offset });
 
         info.return_value = .{ .stack_offset = stack_offset };
-    }
+
+        break :blk self.register_manager.lockRegAssumeUnused(.r0);
+    } else null;
+    defer if (r0_lock) |reg| self.register_manager.unlockReg(reg);
 
     // Make space for the arguments passed via the stack
     self.max_end_stack += info.stack_byte_count;
-- 
2.54.0


From c9d9fd53a61cbc656f543a3fa778ac4c72a58701 Mon Sep 17 00:00:00 2001
From: joachimschmidt557 <joachim.schmidt557@outlook.com>
Date: Sat, 13 Aug 2022 15:51:49 +0200
Subject: [PATCH 107/290] stage2 ARM: add inline memcpy to genSetStack

---
 src/arch/arm/CodeGen.zig | 131 ++++++++++++++++++++++++++++++++++-----
 1 file changed, 116 insertions(+), 15 deletions(-)

diff --git a/src/arch/arm/CodeGen.zig b/src/arch/arm/CodeGen.zig
index d78197d2a7159ae4c4af928ef9fc45d041583360..5b772cc4d0675b59dcf59cdcb727770034ab631b 100644
--- a/src/arch/arm/CodeGen.zig
+++ b/src/arch/arm/CodeGen.zig
@@ -2286,16 +2286,17 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
         .register_c_flag,
         .register_v_flag,
         => unreachable, // cannot hold an address
-        .immediate => |imm| try self.setRegOrMem(elem_ty, dst_mcv, .{ .memory = imm }),
-        .ptr_stack_offset => |off| try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off }),
+        .immediate => |imm| {
+            try self.setRegOrMem(elem_ty, dst_mcv, .{ .memory = imm });
+        },
+        .ptr_stack_offset => |off| {
+            try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off });
+        },
         .register => |reg| {
             const reg_lock = self.register_manager.lockReg(reg);
             defer if (reg_lock) |reg_locked| self.register_manager.unlockReg(reg_locked);
 
             switch (dst_mcv) {
-                .dead => unreachable,
-                .undef => unreachable,
-                .cpsr_flags => unreachable,
                 .register => |dst_reg| {
                     try self.genLdrRegister(dst_reg, reg, elem_ty);
                 },
@@ -2331,7 +2332,7 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
                         try self.genInlineMemcpy(src_reg, dst_reg, len_reg, count_reg, tmp_reg);
                     }
                 },
-                else => return self.fail("TODO load from register into {}", .{dst_mcv}),
+                else => unreachable, // attempting to load into non-register or non-stack MCValue
             }
         },
         .memory,
@@ -2428,7 +2429,7 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
                                 // sub src_reg, fp, #off
                                 try self.genSetReg(ptr_ty, src_reg, .{ .ptr_stack_offset = off });
                             },
-                            .memory => |addr| try self.genSetReg(Type.usize, src_reg, .{ .immediate = @intCast(u32, addr) }),
+                            .memory => |addr| try self.genSetReg(ptr_ty, src_reg, .{ .immediate = @intCast(u32, addr) }),
                             .stack_argument_offset => |off| {
                                 _ = try self.addInst(.{
                                     .tag = .ldr_ptr_stack_argument,
@@ -3374,6 +3375,102 @@ fn genInlineMemcpy(
     // end:
 }
 
+fn genInlineMemset(
+    self: *Self,
+    dst: MCValue,
+    val: MCValue,
+    len: MCValue,
+) !void {
+    const dst_reg = switch (dst) {
+        .register => |r| r,
+        else => try self.copyToTmpRegister(Type.initTag(.manyptr_u8), dst),
+    };
+    const dst_reg_lock = self.register_manager.lockReg(dst_reg);
+    defer if (dst_reg_lock) |lock| self.register_manager.unlockReg(lock);
+
+    const val_reg = switch (val) {
+        .register => |r| r,
+        else => try self.copyToTmpRegister(Type.initTag(.u8), val),
+    };
+    const val_reg_lock = self.register_manager.lockReg(val_reg);
+    defer if (val_reg_lock) |lock| self.register_manager.unlockReg(lock);
+
+    const len_reg = switch (len) {
+        .register => |r| r,
+        else => try self.copyToTmpRegister(Type.usize, len),
+    };
+    const len_reg_lock = self.register_manager.lockReg(len_reg);
+    defer if (len_reg_lock) |lock| self.register_manager.unlockReg(lock);
+
+    const count_reg = try self.register_manager.allocReg(null, gp);
+
+    try self.genInlineMemsetCode(dst_reg, val_reg, len_reg, count_reg);
+}
+
+fn genInlineMemsetCode(
+    self: *Self,
+    dst: Register,
+    val: Register,
+    len: Register,
+    count: Register,
+) !void {
+    // mov count, #0
+    _ = try self.addInst(.{
+        .tag = .mov,
+        .data = .{ .rr_op = .{
+            .rd = count,
+            .rn = .r0,
+            .op = Instruction.Operand.imm(0, 0),
+        } },
+    });
+
+    // loop:
+    // cmp count, len
+    _ = try self.addInst(.{
+        .tag = .cmp,
+        .data = .{ .rr_op = .{
+            .rd = .r0,
+            .rn = count,
+            .op = Instruction.Operand.reg(len, Instruction.Operand.Shift.none),
+        } },
+    });
+
+    // bge end
+    _ = try self.addInst(.{
+        .tag = .b,
+        .cond = .ge,
+        .data = .{ .inst = @intCast(u32, self.mir_instructions.len + 4) },
+    });
+
+    // strb val, [src, count]
+    _ = try self.addInst(.{
+        .tag = .strb,
+        .data = .{ .rr_offset = .{
+            .rt = val,
+            .rn = dst,
+            .offset = .{ .offset = Instruction.Offset.reg(count, .none) },
+        } },
+    });
+
+    // add count, count, #1
+    _ = try self.addInst(.{
+        .tag = .add,
+        .data = .{ .rr_op = .{
+            .rd = count,
+            .rn = count,
+            .op = Instruction.Operand.imm(1, 0),
+        } },
+    });
+
+    // b loop
+    _ = try self.addInst(.{
+        .tag = .b,
+        .data = .{ .inst = @intCast(u32, self.mir_instructions.len - 4) },
+    });
+
+    // end:
+}
+
 /// Adds a Type to the .debug_info at the current position. The bytes will be populated later,
 /// after codegen for this symbol is done.
 fn addDbgInfoTypeReloc(self: *Self, ty: Type) error{OutOfMemory}!void {
@@ -4652,11 +4749,15 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
             if (!self.wantSafety())
                 return; // The already existing value will do just fine.
             // TODO Upgrade this to a memset call when we have that available.
-            switch (ty.abiSize(self.target.*)) {
-                1 => return self.genSetStack(ty, stack_offset, .{ .immediate = 0xaa }),
-                2 => return self.genSetStack(ty, stack_offset, .{ .immediate = 0xaaaa }),
-                4 => return self.genSetStack(ty, stack_offset, .{ .immediate = 0xaaaaaaaa }),
-                else => return self.fail("TODO implement memset", .{}),
+            switch (abi_size) {
+                1 => try self.genSetStack(ty, stack_offset, .{ .immediate = 0xaa }),
+                2 => try self.genSetStack(ty, stack_offset, .{ .immediate = 0xaaaa }),
+                4 => try self.genSetStack(ty, stack_offset, .{ .immediate = 0xaaaaaaaa }),
+                else => try self.genInlineMemset(
+                    .{ .ptr_stack_offset = stack_offset },
+                    .{ .immediate = 0xaa },
+                    .{ .immediate = abi_size },
+                ),
             }
         },
         .cpsr_flags,
@@ -5068,9 +5169,9 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
                 return; // The already existing value will do just fine.
             // TODO Upgrade this to a memset call when we have that available.
             switch (abi_size) {
-                1 => return self.genSetStackArgument(ty, stack_offset, .{ .immediate = 0xaa }),
-                2 => return self.genSetStackArgument(ty, stack_offset, .{ .immediate = 0xaaaa }),
-                4 => return self.genSetStackArgument(ty, stack_offset, .{ .immediate = 0xaaaaaaaa }),
+                1 => try self.genSetStackArgument(ty, stack_offset, .{ .immediate = 0xaa }),
+                2 => try self.genSetStackArgument(ty, stack_offset, .{ .immediate = 0xaaaa }),
+                4 => try self.genSetStackArgument(ty, stack_offset, .{ .immediate = 0xaaaaaaaa }),
                 else => return self.fail("TODO implement memset", .{}),
             }
         },
-- 
2.54.0


From dc5174440ca547d787b85d407b6836a77688610b Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sun, 14 Aug 2022 11:28:12 +0200
Subject: [PATCH 108/290] feat: better No Results Found page

This adds some helpful links to the page and makes it look nicer by using <kbd> etc.
---
 lib/docs/index.html | 8 +++++++-
 lib/docs/main.js    | 8 ++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index f9c2954a3a658526e8cb58fc52e90d06da570313..3d4e663dbcfd54dab07ba425e7a001e4e03ed5e2 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -654,7 +654,13 @@
             </div>
             <div id="sectSearchNoResults" class="hidden">
               <h2>No Results Found</h2>
-              <p>Press escape to exit search and then '?' to see more options.</p>
+              <p>Here are some things you can try:</p>
+              <ul>
+                <li>Check out the <a id="langRefLink">Language Reference</a> for the language itself.</li>
+                <li>Check out the <a href="https://ziglang.org/learn/">Learn page</a> for other helpful resources for learning Zig.</li>
+                <li>Use your search engine.</li>
+              </ul>
+              <p>Press <kbd>?</kbd> to see keyboard shortcuts and <kbd>Esc</kbd> to return.</p>
             </div>
             <div id="sectFields" class="hidden">
               <h2>Fields</h2>
diff --git a/lib/docs/main.js b/lib/docs/main.js
index f171326b2ea0e2cd3674c26cb4b6b8a9540eb60a..3072918b32bcd9ff6741f5bef466e0e3ccb8a1f4 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -51,6 +51,7 @@ var zigAnalysis;
   const domHdrName = document.getElementById("hdrName");
   const domHelpModal = document.getElementById("helpModal");
   const domSearchPlaceholder = document.getElementById("searchPlaceholder");
+  const domLangRefLink = document.getElementById("langRefLink");
 
   let searchTimer = null;
   let searchTrimResults = true;
@@ -161,6 +162,13 @@ var zigAnalysis;
   window.addEventListener("keydown", onWindowKeyDown, false);
   onHashChange();
 
+  let langRefVersion = zigAnalysis.params.zigVersion;
+  if (!/^\d+\.\d+\.\d+$/.test(langRefVersion)) {
+    // the version is probably not released yet
+    langRefVersion = "master";
+  }
+  domLangRefLink.href = `https://ziglang.org/documentation/${langRefVersion}/`;
+
   function renderTitle() {
     let list = curNav.pkgNames.concat(curNav.declNames);
     let suffix = " - Zig";
-- 
2.54.0


From e1eaa1f7d6a71cb33f76995cb945f1cb67cccc63 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sun, 14 Aug 2022 11:34:41 +0200
Subject: [PATCH 109/290] fix: var(--mono) used for font-size

---
 lib/docs/index.html | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index 3d4e663dbcfd54dab07ba425e7a001e4e03ed5e2..5fe80be91c7b54cd0e5984e0168ba90d6832b658 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -169,8 +169,8 @@
         width: 100%;
         margin-bottom: 0.8rem;
         padding: 0.5rem;
-        font-size: 1rem;
         font-family: var(--ui);
+        font-size: 1rem;
         color: var(--tx-color);
         background-color: var(--search-bg-color);
         border-top: 0;
@@ -339,8 +339,8 @@
       kbd {
         display: inline-block;
         padding: 0.3em 0.2em;
-        font-size: 1.2em;
-        font-size: var(--mono);
+        font-family: var(--mono);
+        font-size: 1em;
         line-height: 0.8em;
         vertical-align: middle;
         color: #000;
-- 
2.54.0


From 9900413eb12a3eea74fff74025ae8c33d9425439 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sun, 14 Aug 2022 11:35:11 +0200
Subject: [PATCH 110/290] feat: indent keyboard shortcuts

This indents the keyboard shortcuts related to the S key because you can only
use these keyboard shortcuts after you pressed S (when the search field is focused).
This is a visual hint.
---
 lib/docs/index.html | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index 5fe80be91c7b54cd0e5984e0168ba90d6832b658..37025c4e72a93bbe67939bbedaccc1a8178fea90 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -722,11 +722,13 @@
         <div class="modal">
           <h1>Keyboard Shortcuts</h1>
           <dl><dt><kbd>?</kbd></dt><dd>Show this help modal</dd></dl>
-          <dl><dt><kbd>Esc</kbd></dt><dd>Clear focus; close this modal</dd></dl>
           <dl><dt><kbd>s</kbd></dt><dd>Focus the search field</dd></dl>
-          <dl><dt><kbd>↑</kbd></dt><dd>Move up in search results</dd></dl>
-          <dl><dt><kbd>↓</kbd></dt><dd>Move down in search results</dd></dl>
-          <dl><dt><kbd>⏎</kbd></dt><dd>Go to active search result</dd></dl>
+          <div style="margin-left: 1em">
+            <dl><dt><kbd>↑</kbd></dt><dd>Move up in search results</dd></dl>
+            <dl><dt><kbd>↓</kbd></dt><dd>Move down in search results</dd></dl>
+            <dl><dt><kbd>⏎</kbd></dt><dd>Go to active search result</dd></dl>
+          </div>
+          <dl><dt><kbd>Esc</kbd></dt><dd>Clear focus; close this modal</dd></dl>
         </div>
       </div>
     </div>
-- 
2.54.0


From 8f6f4bc7caf09a4399a5f2b1fdf5c966b89bab15 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sun, 14 Aug 2022 11:49:44 +0200
Subject: [PATCH 111/290] feat: make modal more restrictive and more Esc
 freedom

This makes it so that you can no longer interact with the search bar
or the results or anything while the modal is open. That's why it's a "modal" and not a "dialog".

It also makes it so that you can now always press Esc to return to the results or the main page.
Previously this was only possible when the search field was active.
---
 lib/docs/main.js | 43 +++++++++++++++++++++++++++----------------
 1 file changed, 27 insertions(+), 16 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 3072918b32bcd9ff6741f5bef466e0e3ccb8a1f4..57cdd3c5130167660ec784a3a60a3119e2ef1ce1 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -3148,6 +3148,22 @@ var zigAnalysis;
     domSearch.blur();
   }
 
+  function onEscape(ev) {
+    if (!domHelpModal.classList.contains("hidden")) {
+      domHelpModal.classList.add("hidden");
+      ev.preventDefault();
+      ev.stopPropagation();
+    } else {
+      domSearch.value = "";
+      domSearch.blur();
+      domSearchPlaceholder.classList.remove("hidden");
+      curSearchIndex = -1;
+      ev.preventDefault();
+      ev.stopPropagation();
+      startSearch();
+    }
+  }
+
   function onSearchKeyDown(ev) {
     switch (getKeyString(ev)) {
       case "Enter":
@@ -3164,13 +3180,8 @@ var zigAnalysis;
         ev.stopPropagation();
         return;
       case "Esc":
-        domSearch.value = "";
-        domSearch.blur();
-        curSearchIndex = -1;
-        ev.preventDefault();
-        ev.stopPropagation();
-        startSearch();
-        return;
+        onEscape(ev);
+        return
       case "Up":
         moveSearchCursor(-1);
         ev.preventDefault();
@@ -3245,19 +3256,18 @@ var zigAnalysis;
   function onWindowKeyDown(ev) {
     switch (getKeyString(ev)) {
       case "Esc":
-        if (!domHelpModal.classList.contains("hidden")) {
-          domHelpModal.classList.add("hidden");
+        onEscape(ev);
+        break;
+      case "s":
+        if (domHelpModal.classList.contains("hidden")) {
+          // TODO: scroll the page to the very top
+          domSearch.focus();
+          domSearch.select();
           ev.preventDefault();
           ev.stopPropagation();
+          startAsyncSearch();
         }
         break;
-      case "s":
-        domSearch.focus();
-        domSearch.select();
-        ev.preventDefault();
-        ev.stopPropagation();
-        startAsyncSearch();
-        break;
       case "?":
         ev.preventDefault();
         ev.stopPropagation();
@@ -3273,6 +3283,7 @@ var zigAnalysis;
     domHelpModal.style.top =
       window.innerHeight / 2 - domHelpModal.clientHeight / 2 + "px";
     domHelpModal.focus();
+    domSearch.blur();
   }
 
   function clearAsyncSearch() {
-- 
2.54.0


From 2723d8e6e2fea6229a8f9082bc991cb7bef39054 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sun, 14 Aug 2022 11:51:43 +0200
Subject: [PATCH 112/290] style: format

Some formatting, apparently.
---
 lib/docs/main.js | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 57cdd3c5130167660ec784a3a60a3119e2ef1ce1..b6a6e8332b488cc298ad96a1eec435aff46ac291 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -117,10 +117,10 @@ var zigAnalysis;
   });
   domSectSearchAllResultsLink.addEventListener('click', onClickSearchShowAllResults, false);
   function onClickSearchShowAllResults(ev) {
-      ev.preventDefault();
-      ev.stopPropagation();
-      searchTrimResults = false;
-      onHashChange();
+    ev.preventDefault();
+    ev.stopPropagation();
+    searchTrimResults = false;
+    onHashChange();
   }
 
   domPrivDeclsBox.addEventListener(
@@ -3309,7 +3309,7 @@ var zigAnalysis;
     list.sort();
     return list;
   }
-  
+
   function renderSearch() {
     let matchedItems = [];
     let ignoreCase = curNavSearch.toLowerCase() === curNavSearch;
@@ -3398,13 +3398,13 @@ var zigAnalysis;
         const text = lastPkgName + "." + match.path.declNames.join(".");
         const href = navLink(match.path.pkgNames, match.path.declNames);
 
-        matchedItemsHTML += "<li><a href=\""+ href +"\">"+ text + "</a></li>";
+        matchedItemsHTML += "<li><a href=\"" + href + "\">" + text + "</a></li>";
       }
 
       // Replace the search results using our newly constructed HTML string
       domListSearchResults.innerHTML = matchedItemsHTML;
       if (searchTrimmed) {
-          domSectSearchAllResultsLink.classList.remove("hidden");
+        domSectSearchAllResultsLink.classList.remove("hidden");
       }
       renderSearchCursor();
 
-- 
2.54.0


From e5379e5027d33f5954fc7daa00b835a374f57272 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sun, 14 Aug 2022 12:09:17 +0200
Subject: [PATCH 113/290] docs: add comment

---
 lib/docs/main.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index b6a6e8332b488cc298ad96a1eec435aff46ac291..44a7c88572a6097565c776b0fe83594566f39ebf 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -3148,6 +3148,7 @@ var zigAnalysis;
     domSearch.blur();
   }
 
+  // hide the modal if it's visible or return to the previous result page and unfocus the search
   function onEscape(ev) {
     if (!domHelpModal.classList.contains("hidden")) {
       domHelpModal.classList.add("hidden");
-- 
2.54.0


From af20dfae60bb5c1c1ae0db25339e1f4ad5f8a2e7 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sun, 14 Aug 2022 12:20:26 +0200
Subject: [PATCH 114/290] bug: add TODO

---
 lib/docs/main.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 44a7c88572a6097565c776b0fe83594566f39ebf..680fc1d962afbbb89a1db7f267a6fd6a11bcde8e 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -3189,6 +3189,7 @@ var zigAnalysis;
         ev.stopPropagation();
         return;
       case "Down":
+        // TODO: make the page scroll down if the search cursor is out of the screen
         moveSearchCursor(1);
         ev.preventDefault();
         ev.stopPropagation();
-- 
2.54.0


From 78bb29d1dc45acedf7ec8990e1ca2c47978b5087 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sun, 14 Aug 2022 19:17:20 +0200
Subject: [PATCH 115/290] fix: scroll page to very top when S is pressed

Credits go to @rudedogg
---
 lib/docs/index.html | 2 +-
 lib/docs/main.js    | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index 37025c4e72a93bbe67939bbedaccc1a8178fea90..236923c1d89952bd3d34dd0391c3f7047b05be58 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -612,7 +612,7 @@
           </div>
         </nav>
       </div>
-      <div class="flex-right">
+      <div id="docs" class="flex-right">
         <div class="wrap">
           <section class="docs">
             <div style="position: relative">
diff --git a/lib/docs/main.js b/lib/docs/main.js
index 680fc1d962afbbb89a1db7f267a6fd6a11bcde8e..e2b5162beb326b7148d610750994ab118a3e5f5a 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -41,7 +41,7 @@ var zigAnalysis;
   const domSearch = document.getElementById("search");
   const domSectSearchResults = document.getElementById("sectSearchResults");
   const domSectSearchAllResultsLink = document.getElementById("sectSearchAllResultsLink");
-
+  const domDocs = document.getElementById("docs");
   const domListSearchResults = document.getElementById("listSearchResults");
   const domSectSearchNoResults = document.getElementById("sectSearchNoResults");
   const domSectInfo = document.getElementById("sectInfo");
@@ -3262,9 +3262,9 @@ var zigAnalysis;
         break;
       case "s":
         if (domHelpModal.classList.contains("hidden")) {
-          // TODO: scroll the page to the very top
           domSearch.focus();
           domSearch.select();
+          domDocs.scrollTo(0, 0);
           ev.preventDefault();
           ev.stopPropagation();
           startAsyncSearch();
-- 
2.54.0


From 2279f27e0f97e66aedc87ec5c85f05b185a3631d Mon Sep 17 00:00:00 2001
From: Yujiri <yujiri@disroot.org>
Date: Fri, 12 Aug 2022 11:56:00 +0000
Subject: [PATCH 116/290] Fix #12423: auto_hash not hashing arrays of slices
 uniquely

---
 lib/std/hash/auto_hash.zig | 35 +++++++++++++++++------------------
 1 file changed, 17 insertions(+), 18 deletions(-)

diff --git a/lib/std/hash/auto_hash.zig b/lib/std/hash/auto_hash.zig
index 951c0148d9d03f1f3a1835de2583ec9c5555488b..32f4f4378f68b590b5b277721a546feeff0b51a3 100644
--- a/lib/std/hash/auto_hash.zig
+++ b/lib/std/hash/auto_hash.zig
@@ -30,13 +30,15 @@ pub fn hashPointer(hasher: anytype, key: anytype, comptime strat: HashStrategy)
             .DeepRecursive => hash(hasher, key.*, .DeepRecursive),
         },
 
-        .Slice => switch (strat) {
-            .Shallow => {
-                hashPointer(hasher, key.ptr, .Shallow);
-                hash(hasher, key.len, .Shallow);
-            },
-            .Deep => hashArray(hasher, key, .Shallow),
-            .DeepRecursive => hashArray(hasher, key, .DeepRecursive),
+        .Slice => {
+            switch (strat) {
+                .Shallow => {
+                    hashPointer(hasher, key.ptr, .Shallow);
+                },
+                .Deep => hashArray(hasher, key, .Shallow),
+                .DeepRecursive => hashArray(hasher, key, .DeepRecursive),
+            }
+            hash(hasher, key.len, .Shallow);
         },
 
         .Many,
@@ -53,17 +55,8 @@ pub fn hashPointer(hasher: anytype, key: anytype, comptime strat: HashStrategy)
 
 /// Helper function to hash a set of contiguous objects, from an array or slice.
 pub fn hashArray(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
-    switch (strat) {
-        .Shallow => {
-            for (key) |element| {
-                hash(hasher, element, .Shallow);
-            }
-        },
-        else => {
-            for (key) |element| {
-                hash(hasher, element, strat);
-            }
-        },
+    for (key) |element| {
+        hash(hasher, element, strat);
     }
 }
 
@@ -359,6 +352,12 @@ test "testHash array" {
     try testing.expectEqual(h, hasher.final());
 }
 
+test "testHash multi-dimensional array" {
+    const a = [_][]const u32{ &.{ 1, 2, 3 }, &.{ 4, 5 } };
+    const b = [_][]const u32{ &.{ 1, 2 }, &.{ 3, 4, 5 } };
+    try testing.expect(testHash(a) != testHash(b));
+}
+
 test "testHash struct" {
     const Foo = struct {
         a: u32 = 1,
-- 
2.54.0


From 764cf4e53ffc29bbd39c636020019ae419135d82 Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Sat, 13 Aug 2022 22:08:40 -0700
Subject: [PATCH 117/290] std.fs: Fix `WalkerEntry.dir` not always being the
 containing dir

Before this commit, the modified test would fail with `FileNotFound` because the `entry.dir` would be for the entry itself rather than the containing dir of the entry. That is, if you were walking a tree of `a/b`, then (previously) the entry for `b` would incorrectly have an `entry.dir` for `b` rather than `a`.
---
 lib/std/fs.zig      | 6 ++++--
 lib/std/fs/test.zig | 3 +++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/lib/std/fs.zig b/lib/std/fs.zig
index 0968e168124f0784b4084373e973a006451e886b..b1e88d2e0109c96dc98fcda9213f88c1ee50ab6b 100644
--- a/lib/std/fs.zig
+++ b/lib/std/fs.zig
@@ -877,8 +877,9 @@ pub const IterableDir = struct {
         /// a reference to the path.
         pub fn next(self: *Walker) !?WalkerEntry {
             while (self.stack.items.len != 0) {
-                // `top` becomes invalid after appending to `self.stack`
+                // `top` and `containing` become invalid after appending to `self.stack`
                 var top = &self.stack.items[self.stack.items.len - 1];
+                var containing = top;
                 var dirname_len = top.dirname_len;
                 if (try top.iter.next()) |base| {
                     self.name_buffer.shrinkRetainingCapacity(dirname_len);
@@ -899,10 +900,11 @@ pub const IterableDir = struct {
                                 .dirname_len = self.name_buffer.items.len,
                             });
                             top = &self.stack.items[self.stack.items.len - 1];
+                            containing = &self.stack.items[self.stack.items.len - 2];
                         }
                     }
                     return WalkerEntry{
-                        .dir = top.iter.dir,
+                        .dir = containing.iter.dir,
                         .basename = self.name_buffer.items[dirname_len..],
                         .path = self.name_buffer.items,
                         .kind = base.kind,
diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index 538ce1bf5ed18f3df908cb1bad4a3d839c20c0ac..a7686080c1500c09bfe6ce6d148d481860c25f68 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -1058,6 +1058,9 @@ test "walker" {
             std.debug.print("found unexpected path: {s}\n", .{std.fmt.fmtSliceEscapeLower(entry.path)});
             return err;
         };
+        // make sure that the entry.dir is the containing dir
+        var entry_dir = try entry.dir.openDir(entry.basename, .{});
+        defer entry_dir.close();
         num_walked += 1;
     }
     try testing.expectEqual(expected_paths.kvs.len, num_walked);
-- 
2.54.0


From cb901e578cbc321003d5e4327d51d349d91f6dd6 Mon Sep 17 00:00:00 2001
From: LeRoyce Pearson <contact@leroycepearson.dev>
Date: Mon, 15 Aug 2022 02:28:42 -0600
Subject: [PATCH 118/290] stage2: add compile errors for comptime `@shrExact`
 and `@divExact` failures

---
 src/Sema.zig                                         | 12 +++++++++---
 test/cases/compile_errors/exact division failure.zig | 10 ++++++++++
 .../compile_errors/float exact division failure.zig  | 10 ++++++++++
 .../{stage1/obj => }/shrExact_shifts_out_1_bits.zig  |  4 ++--
 4 files changed, 31 insertions(+), 5 deletions(-)
 create mode 100644 test/cases/compile_errors/exact division failure.zig
 create mode 100644 test/cases/compile_errors/float exact division failure.zig
 rename test/cases/compile_errors/{stage1/obj => }/shrExact_shifts_out_1_bits.zig (58%)

diff --git a/src/Sema.zig b/src/Sema.zig
index d697ab0a9958fea7647be7e20d9e1385ce063be8..12851cc9add831e94fc3fea67618a266c251bac6 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -10441,7 +10441,7 @@ fn zirShr(
                 // Detect if any ones would be shifted out.
                 const truncated = try lhs_val.intTruncBitsAsValue(lhs_ty, sema.arena, .unsigned, rhs_val, target);
                 if (!(try truncated.compareWithZeroAdvanced(.eq, sema.kit(block, src)))) {
-                    return sema.addConstUndef(lhs_ty);
+                    return sema.fail(block, src, "exact shift shifted out 1 bits", .{});
                 }
             }
             const val = try lhs_val.shr(rhs_val, lhs_ty, sema.arena, target);
@@ -11346,13 +11346,19 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         if (maybe_lhs_val) |lhs_val| {
             if (maybe_rhs_val) |rhs_val| {
                 if (is_int) {
-                    // TODO: emit compile error if there is a remainder
+                    const modulus_val = try lhs_val.intMod(rhs_val, resolved_type, sema.arena, target);
+                    if (modulus_val.compareWithZero(.neq)) {
+                        return sema.fail(block, src, "exact division produced remainder", .{});
+                    }
                     return sema.addConstant(
                         resolved_type,
                         try lhs_val.intDiv(rhs_val, resolved_type, sema.arena, target),
                     );
                 } else {
-                    // TODO: emit compile error if there is a remainder
+                    const modulus_val = try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, target);
+                    if (modulus_val.compareWithZero(.neq)) {
+                        return sema.fail(block, src, "exact division produced remainder", .{});
+                    }
                     return sema.addConstant(
                         resolved_type,
                         try lhs_val.floatDiv(rhs_val, resolved_type, sema.arena, target),
diff --git a/test/cases/compile_errors/exact division failure.zig b/test/cases/compile_errors/exact division failure.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d134e0e2fbabd3fe38886a1e97c5a8835903fd1e
--- /dev/null
+++ b/test/cases/compile_errors/exact division failure.zig	
@@ -0,0 +1,10 @@
+comptime {
+    const x = @divExact(10, 3);
+    _ = x;
+}
+
+// error
+// backend=llvm
+// target=native
+//
+// :2:15: error: exact division produced remainder
diff --git a/test/cases/compile_errors/float exact division failure.zig b/test/cases/compile_errors/float exact division failure.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c09defc56ebf72c04ed24248fcc45a5143534087
--- /dev/null
+++ b/test/cases/compile_errors/float exact division failure.zig	
@@ -0,0 +1,10 @@
+comptime {
+    const x = @divExact(10.0, 3.0);
+    _ = x;
+}
+
+// error
+// backend=llvm
+// target=native
+//
+// :2:15: error: exact division produced remainder
diff --git a/test/cases/compile_errors/stage1/obj/shrExact_shifts_out_1_bits.zig b/test/cases/compile_errors/shrExact_shifts_out_1_bits.zig
similarity index 58%
rename from test/cases/compile_errors/stage1/obj/shrExact_shifts_out_1_bits.zig
rename to test/cases/compile_errors/shrExact_shifts_out_1_bits.zig
index 223db7663042f98a32ff416c5e513d806e6e155a..dd23c4bcb3f68258fc52fe6ad53924900cfe1a1e 100644
--- a/test/cases/compile_errors/stage1/obj/shrExact_shifts_out_1_bits.zig
+++ b/test/cases/compile_errors/shrExact_shifts_out_1_bits.zig
@@ -4,7 +4,7 @@ comptime {
 }
 
 // error
-// backend=stage1
+// backend=llvm
 // target=native
 //
-// tmp.zig:2:15: error: exact shift shifted out 1 bits
+// :2:15: error: exact shift shifted out 1 bits
-- 
2.54.0


From a9c4dc84f487c4764c5787439ea87962f698d511 Mon Sep 17 00:00:00 2001
From: sin-ack <sin-ack@users.noreply.github.com>
Date: Fri, 12 Aug 2022 21:51:07 +0000
Subject: [PATCH 119/290] Sema: Revert sema.err to null if the Decl already has
 an error

Previously we would assign the error message to Sema and then never
clear it even when destroying the error message, which caused memory
corruption.

Closes #12437
---
 src/Sema.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index ed8204b3467c0003cb6a33e4b7097a8196fe5bad..879ecb4e2f4161f838f78fe18bf68e45af0fee20 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -1906,8 +1906,6 @@ fn failWithOwnedErrorMsg(sema: *Sema, err_msg: *Module.ErrorMsg) CompileError {
     }
 
     const mod = sema.mod;
-    sema.err = err_msg;
-
     {
         errdefer err_msg.destroy(mod.gpa);
         if (err_msg.src_loc.lazy == .unneeded) {
@@ -1925,8 +1923,10 @@ fn failWithOwnedErrorMsg(sema: *Sema, err_msg: *Module.ErrorMsg) CompileError {
     const gop = mod.failed_decls.getOrPutAssumeCapacity(sema.owner_decl_index);
     if (gop.found_existing) {
         // If there are multiple errors for the same Decl, prefer the first one added.
+        sema.err = null;
         err_msg.destroy(mod.gpa);
     } else {
+        sema.err = err_msg;
         gop.value_ptr.* = err_msg;
     }
     return error.AnalysisFail;
-- 
2.54.0


From 95573dbeebf7a9d3617c1944ab0a74691b7e9d51 Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Mon, 15 Aug 2022 20:44:30 +0200
Subject: [PATCH 120/290] ci: add gzip compression to stdlib docs & langref

---
 ci/srht/update_download_page | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/ci/srht/update_download_page b/ci/srht/update_download_page
index 5c007b6986d4d94c8cfb5e892d5e7de233ef3fd3..5277da7d2bb361c2fa3dd3406940ffd6d078d291 100755
--- a/ci/srht/update_download_page
+++ b/ci/srht/update_download_page
@@ -103,11 +103,19 @@ cd "$HOME"
 
 # Upload new stdlib autodocs 
 mkdir -p docs_to_upload/documentation/master/std/
-cp "$ZIGDIR/docs/std/index.html" docs_to_upload/documentation/master/std/index.html
-cp "$ZIGDIR/docs/std/data.js" docs_to_upload/documentation/master/std/data.js
-cp "$ZIGDIR/docs/std/main.js" docs_to_upload/documentation/master/std/main.js
-cp "$LANGREF" docs_to_upload/documentation/master/index.html
-$S3CMD put -P --no-mime-magic --recursive --add-header="Cache-Control: max-age=0, must-revalidate" "docs_to_upload/" s3://ziglang.org/
+
+gzip -c -9 "$ZIGDIR/docs/std/index.html" >  docs_to_upload/documentation/master/std/index.html
+gzip -c -9 "$ZIGDIR/docs/std/data.js" > docs_to_upload/documentation/master/std/data.js
+gzip -c -9 "$ZIGDIR/docs/std/main.js" > docs_to_upload/documentation/master/std/main.js
+gzip -c -9 "$LANGREF" > docs_to_upload/documentation/master/index.html
+$S3CMD put -P --no-mime-magic --recursive --add-header="Content-Encoding:gzip" --add-header="Cache-Control: max-age=0, must-revalidate" "docs_to_upload/" s3://ziglang.org/
+
+## Copy without compression:
+# cp "$ZIGDIR/docs/std/index.html" docs_to_upload/documentation/master/std/index.html
+# cp "$ZIGDIR/docs/std/data.js" docs_to_upload/documentation/master/std/data.js
+# cp "$ZIGDIR/docs/std/main.js" docs_to_upload/documentation/master/std/main.js
+# cp "$LANGREF" docs_to_upload/documentation/master/index.html
+# $S3CMD put -P --no-mime-magic --recursive --add-header="Cache-Control: max-age=0, must-revalidate" "docs_to_upload/" s3://ziglang.org/
 
 git clone --depth 1 git@github.com:ziglang/www.ziglang.org.git
 cd www.ziglang.org
-- 
2.54.0


From b3922289be1ffaf194b55face332892280981356 Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Mon, 15 Aug 2022 21:56:59 +0200
Subject: [PATCH 121/290] Zir: add missing support for packed ints in
 declIterator

---
 src/Zir.zig | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/Zir.zig b/src/Zir.zig
index 538ef6aaf8c35b12a3e4586e47103283d2b29cd6..7a1db54ea28c0c7b4e8416699cd2ff33d7173a2b 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -3608,6 +3608,16 @@ pub fn declIterator(zir: Zir, decl_inst: u32) DeclIterator {
                         break :decls_len decls_len;
                     } else 0;
 
+                    if (small.has_backing_int) {
+                        const backing_int_body_len = zir.extra[extra_index];
+                        extra_index += 1; // backing_int_body_len
+                        if (backing_int_body_len == 0) {
+                            extra_index += 1; // backing_int_ref
+                        } else {
+                            extra_index += backing_int_body_len; // backing_int_body_inst
+                        }
+                    }
+
                     return declIteratorInner(zir, extra_index, decls_len);
                 },
                 .enum_decl => {
-- 
2.54.0


From f07cba10a3b8bfe5fa75da9f67284c9b2869b261 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Fri, 12 Aug 2022 14:23:57 +0200
Subject: [PATCH 122/290] test(names): remove unnecessary "tokenizer - " prefix

---
 lib/std/zig/tokenizer.zig | 60 +++++++++++++++++++--------------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/lib/std/zig/tokenizer.zig b/lib/std/zig/tokenizer.zig
index 5c6d7324193148a39fa6e8e62f0a7c11c89f1680..178249091e72861b91c802823e4c228bd25a297b 100644
--- a/lib/std/zig/tokenizer.zig
+++ b/lib/std/zig/tokenizer.zig
@@ -1485,7 +1485,7 @@ test "line comment followed by top-level comptime" {
     });
 }
 
-test "tokenizer - unknown length pointer and then c pointer" {
+test "unknown length pointer and then c pointer" {
     try testTokenize(
         \\[*]u8
         \\[*c]u8
@@ -1502,7 +1502,7 @@ test "tokenizer - unknown length pointer and then c pointer" {
     });
 }
 
-test "tokenizer - code point literal with hex escape" {
+test "code point literal with hex escape" {
     try testTokenize(
         \\'\x1b'
     , &.{.char_literal});
@@ -1511,21 +1511,21 @@ test "tokenizer - code point literal with hex escape" {
     , &.{ .invalid, .invalid });
 }
 
-test "tokenizer - newline in char literal" {
+test "newline in char literal" {
     try testTokenize(
         \\'
         \\'
     , &.{ .invalid, .invalid });
 }
 
-test "tokenizer - newline in string literal" {
+test "newline in string literal" {
     try testTokenize(
         \\"
         \\"
     , &.{ .invalid, .string_literal });
 }
 
-test "tokenizer - code point literal with unicode escapes" {
+test "code point literal with unicode escapes" {
     // Valid unicode escapes
     try testTokenize(
         \\'\u{3}'
@@ -1575,13 +1575,13 @@ test "tokenizer - code point literal with unicode escapes" {
     , &.{ .invalid, .integer_literal, .invalid });
 }
 
-test "tokenizer - code point literal with unicode code point" {
+test "code point literal with unicode code point" {
     try testTokenize(
         \\'💩'
     , &.{.char_literal});
 }
 
-test "tokenizer - float literal e exponent" {
+test "float literal e exponent" {
     try testTokenize("a = 4.94065645841246544177e-324;\n", &.{
         .identifier,
         .equal,
@@ -1590,7 +1590,7 @@ test "tokenizer - float literal e exponent" {
     });
 }
 
-test "tokenizer - float literal p exponent" {
+test "float literal p exponent" {
     try testTokenize("a = 0x1.a827999fcef32p+1022;\n", &.{
         .identifier,
         .equal,
@@ -1599,11 +1599,11 @@ test "tokenizer - float literal p exponent" {
     });
 }
 
-test "tokenizer - chars" {
+test "chars" {
     try testTokenize("'c'", &.{.char_literal});
 }
 
-test "tokenizer - invalid token characters" {
+test "invalid token characters" {
     try testTokenize("#", &.{.invalid});
     try testTokenize("`", &.{.invalid});
     try testTokenize("'c", &.{.invalid});
@@ -1611,7 +1611,7 @@ test "tokenizer - invalid token characters" {
     try testTokenize("''", &.{ .invalid, .invalid });
 }
 
-test "tokenizer - invalid literal/comment characters" {
+test "invalid literal/comment characters" {
     try testTokenize("\"\x00\"", &.{
         .string_literal,
         .invalid,
@@ -1627,12 +1627,12 @@ test "tokenizer - invalid literal/comment characters" {
     });
 }
 
-test "tokenizer - utf8" {
+test "utf8" {
     try testTokenize("//\xc2\x80", &.{});
     try testTokenize("//\xf4\x8f\xbf\xbf", &.{});
 }
 
-test "tokenizer - invalid utf8" {
+test "invalid utf8" {
     try testTokenize("//\x80", &.{
         .invalid,
     });
@@ -1659,7 +1659,7 @@ test "tokenizer - invalid utf8" {
     });
 }
 
-test "tokenizer - illegal unicode codepoints" {
+test "illegal unicode codepoints" {
     // unicode newline characters.U+0085, U+2028, U+2029
     try testTokenize("//\xc2\x84", &.{});
     try testTokenize("//\xc2\x85", &.{
@@ -1676,7 +1676,7 @@ test "tokenizer - illegal unicode codepoints" {
     try testTokenize("//\xe2\x80\xaa", &.{});
 }
 
-test "tokenizer - string identifier and builtin fns" {
+test "string identifier and builtin fns" {
     try testTokenize(
         \\const @"if" = @import("std");
     , &.{
@@ -1691,7 +1691,7 @@ test "tokenizer - string identifier and builtin fns" {
     });
 }
 
-test "tokenizer - multiline string literal with literal tab" {
+test "multiline string literal with literal tab" {
     try testTokenize(
         \\\\foo	bar
     , &.{
@@ -1699,7 +1699,7 @@ test "tokenizer - multiline string literal with literal tab" {
     });
 }
 
-test "tokenizer - comments with literal tab" {
+test "comments with literal tab" {
     try testTokenize(
         \\//foo	bar
         \\//!foo	bar
@@ -1715,14 +1715,14 @@ test "tokenizer - comments with literal tab" {
     });
 }
 
-test "tokenizer - pipe and then invalid" {
+test "pipe and then invalid" {
     try testTokenize("||=", &.{
         .pipe_pipe,
         .equal,
     });
 }
 
-test "tokenizer - line comment and doc comment" {
+test "line comment and doc comment" {
     try testTokenize("//", &.{});
     try testTokenize("// a / b", &.{});
     try testTokenize("// /", &.{});
@@ -1733,7 +1733,7 @@ test "tokenizer - line comment and doc comment" {
     try testTokenize("//!!", &.{.container_doc_comment});
 }
 
-test "tokenizer - line comment followed by identifier" {
+test "line comment followed by identifier" {
     try testTokenize(
         \\    Unexpected,
         \\    // another
@@ -1746,7 +1746,7 @@ test "tokenizer - line comment followed by identifier" {
     });
 }
 
-test "tokenizer - UTF-8 BOM is recognized and skipped" {
+test "UTF-8 BOM is recognized and skipped" {
     try testTokenize("\xEF\xBB\xBFa;\n", &.{
         .identifier,
         .semicolon,
@@ -1788,7 +1788,7 @@ test "correctly parse pointer dereference followed by asterisk" {
     });
 }
 
-test "tokenizer - range literals" {
+test "range literals" {
     try testTokenize("0...9", &.{ .integer_literal, .ellipsis3, .integer_literal });
     try testTokenize("'0'...'9'", &.{ .char_literal, .ellipsis3, .char_literal });
     try testTokenize("0x00...0x09", &.{ .integer_literal, .ellipsis3, .integer_literal });
@@ -1796,7 +1796,7 @@ test "tokenizer - range literals" {
     try testTokenize("0o00...0o11", &.{ .integer_literal, .ellipsis3, .integer_literal });
 }
 
-test "tokenizer - number literals decimal" {
+test "number literals decimal" {
     try testTokenize("0", &.{.integer_literal});
     try testTokenize("1", &.{.integer_literal});
     try testTokenize("2", &.{.integer_literal});
@@ -1863,7 +1863,7 @@ test "tokenizer - number literals decimal" {
     try testTokenize("1.0e0_+", &.{ .invalid, .plus });
 }
 
-test "tokenizer - number literals binary" {
+test "number literals binary" {
     try testTokenize("0b0", &.{.integer_literal});
     try testTokenize("0b1", &.{.integer_literal});
     try testTokenize("0b2", &.{ .invalid, .integer_literal });
@@ -1902,7 +1902,7 @@ test "tokenizer - number literals binary" {
     try testTokenize("0b1_,", &.{ .invalid, .comma });
 }
 
-test "tokenizer - number literals octal" {
+test "number literals octal" {
     try testTokenize("0o0", &.{.integer_literal});
     try testTokenize("0o1", &.{.integer_literal});
     try testTokenize("0o2", &.{.integer_literal});
@@ -1941,7 +1941,7 @@ test "tokenizer - number literals octal" {
     try testTokenize("0o_,", &.{ .invalid, .identifier, .comma });
 }
 
-test "tokenizer - number literals hexadecimal" {
+test "number literals hexadecimal" {
     try testTokenize("0x0", &.{.integer_literal});
     try testTokenize("0x1", &.{.integer_literal});
     try testTokenize("0x2", &.{.integer_literal});
@@ -2029,22 +2029,22 @@ test "tokenizer - number literals hexadecimal" {
     try testTokenize("0x0.0p0_", &.{ .invalid, .eof });
 }
 
-test "tokenizer - multi line string literal with only 1 backslash" {
+test "multi line string literal with only 1 backslash" {
     try testTokenize("x \\\n;", &.{ .identifier, .invalid, .semicolon });
 }
 
-test "tokenizer - invalid builtin identifiers" {
+test "invalid builtin identifiers" {
     try testTokenize("@()", &.{ .invalid, .l_paren, .r_paren });
     try testTokenize("@0()", &.{ .invalid, .integer_literal, .l_paren, .r_paren });
 }
 
-test "tokenizer - invalid token with unfinished escape right before eof" {
+test "invalid token with unfinished escape right before eof" {
     try testTokenize("\"\\", &.{.invalid});
     try testTokenize("'\\", &.{.invalid});
     try testTokenize("'\\u", &.{.invalid});
 }
 
-test "tokenizer - saturating" {
+test "saturating" {
     try testTokenize("<<", &.{.angle_bracket_angle_bracket_left});
     try testTokenize("<<|", &.{.angle_bracket_angle_bracket_left_pipe});
     try testTokenize("<<|=", &.{.angle_bracket_angle_bracket_left_pipe_equal});
-- 
2.54.0


From e3b3eab840d6fc055cdf12cde6d9077cb59b4022 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Fri, 12 Aug 2022 14:25:47 +0200
Subject: [PATCH 123/290] test(names): some renamings

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

diff --git a/lib/std/zig/tokenizer.zig b/lib/std/zig/tokenizer.zig
index 178249091e72861b91c802823e4c228bd25a297b..8cc221a8dca47db076bdec5d8ecad6aeefabcd69 100644
--- a/lib/std/zig/tokenizer.zig
+++ b/lib/std/zig/tokenizer.zig
@@ -1469,8 +1469,8 @@ pub const Tokenizer = struct {
     }
 };
 
-test "tokenizer" {
-    try testTokenize("test", &.{.keyword_test});
+test "keywords" {
+    try testTokenize("test const else", &.{ .keyword_test, .keyword_const, .keyword_else });
 }
 
 test "line comment followed by top-level comptime" {
@@ -2044,7 +2044,7 @@ test "invalid token with unfinished escape right before eof" {
     try testTokenize("'\\u", &.{.invalid});
 }
 
-test "saturating" {
+test "saturating operators" {
     try testTokenize("<<", &.{.angle_bracket_angle_bracket_left});
     try testTokenize("<<|", &.{.angle_bracket_angle_bracket_left_pipe});
     try testTokenize("<<|=", &.{.angle_bracket_angle_bracket_left_pipe_equal});
-- 
2.54.0


From 5490688d658973982d111ad5ad52bc497ef15d84 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Fri, 12 Aug 2022 14:28:22 +0200
Subject: [PATCH 124/290] refactor: use std.ascii functions

---
 lib/std/zig/tokenizer.zig | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/lib/std/zig/tokenizer.zig b/lib/std/zig/tokenizer.zig
index 8cc221a8dca47db076bdec5d8ecad6aeefabcd69..89d4ee59d944b725556bc2c23e4f47b154559d0d 100644
--- a/lib/std/zig/tokenizer.zig
+++ b/lib/std/zig/tokenizer.zig
@@ -1,5 +1,4 @@
 const std = @import("../std.zig");
-const mem = std.mem;
 
 pub const Token = struct {
     tag: Tag,
@@ -350,7 +349,7 @@ pub const Tokenizer = struct {
 
     pub fn init(buffer: [:0]const u8) Tokenizer {
         // Skip the UTF-8 BOM if present
-        const src_start = if (mem.startsWith(u8, buffer, "\xEF\xBB\xBF")) 3 else @as(usize, 0);
+        const src_start: usize = if (std.mem.startsWith(u8, buffer, "\xEF\xBB\xBF")) 3 else 0;
         return Tokenizer{
             .buffer = buffer,
             .index = src_start,
@@ -1433,8 +1432,8 @@ pub const Tokenizer = struct {
 
     fn getInvalidCharacterLength(self: *Tokenizer) u3 {
         const c0 = self.buffer[self.index];
-        if (c0 < 0x80) {
-            if (c0 < 0x20 or c0 == 0x7f) {
+        if (std.ascii.isASCII(c0)) {
+            if (std.ascii.isCntrl(c0)) {
                 // ascii control codes are never allowed
                 // (note that \n was checked before we got here)
                 return 1;
-- 
2.54.0


From 83909651ea99eb45c67ead40b5fcb5773d1998d5 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Sat, 13 Aug 2022 11:44:19 +0200
Subject: [PATCH 125/290] test: simplify testTokenize

What this does is already done by `expectEqual`.
Now the trace seems to be shorter and more concise so the errors should be easier to read now.
---
 lib/std/zig/tokenizer.zig | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/lib/std/zig/tokenizer.zig b/lib/std/zig/tokenizer.zig
index 89d4ee59d944b725556bc2c23e4f47b154559d0d..eaa0ddd716da7a4ed5a0e1eca4954f01c47bb616 100644
--- a/lib/std/zig/tokenizer.zig
+++ b/lib/std/zig/tokenizer.zig
@@ -2061,17 +2061,14 @@ test "saturating operators" {
     try testTokenize("-|=", &.{.minus_pipe_equal});
 }
 
-fn testTokenize(source: [:0]const u8, expected_tokens: []const Token.Tag) !void {
+fn testTokenize(source: [:0]const u8, expected_token_tags: []const Token.Tag) !void {
     var tokenizer = Tokenizer.init(source);
-    for (expected_tokens) |expected_token_id| {
+    for (expected_token_tags) |expected_token_tag| {
         const token = tokenizer.next();
-        if (token.tag != expected_token_id) {
-            std.debug.panic("expected {s}, found {s}\n", .{
-                @tagName(expected_token_id), @tagName(token.tag),
-            });
-        }
+        try std.testing.expectEqual(expected_token_tag, token.tag);
     }
     const last_token = tokenizer.next();
     try std.testing.expectEqual(Token.Tag.eof, last_token.tag);
     try std.testing.expectEqual(source.len, last_token.loc.start);
+    try std.testing.expectEqual(source.len, last_token.loc.end);
 }
-- 
2.54.0


From c17793b4875cc9e1ccb605431142ffecb0b6f3f2 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Tue, 16 Aug 2022 16:37:27 +0300
Subject: [PATCH 126/290] Sema: ignore current declaration in ambiguous
 reference error

Closes #12429
---
 src/Sema.zig            | 11 +++++++++++
 test/behavior/basic.zig | 21 +++++++++++++++++++++
 2 files changed, 32 insertions(+)

diff --git a/src/Sema.zig b/src/Sema.zig
index 879ecb4e2f4161f838f78fe18bf68e45af0fee20..d7d6994bcdef41c391f3bc2f10366490ab8b202a 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -5384,6 +5384,17 @@ fn lookupInNamespace(
             }
         }
 
+        {
+            var i: usize = 0;
+            while (i < candidates.items.len) {
+                if (candidates.items[i] == sema.owner_decl_index) {
+                    _ = candidates.orderedRemove(i);
+                } else {
+                    i += 1;
+                }
+            }
+        }
+
         switch (candidates.items.len) {
             0 => {},
             1 => {
diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index 1a1412420a84f90abf2ac55a698620cb54d8b57e..4d8b176fbfd85543812892ef21acc4c7217daa27 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -1104,3 +1104,24 @@ test "namespace lookup ignores decl causing the lookup" {
     };
     _ = S.foo();
 }
+
+test "ambiguous reference error ignores current declaration" {
+    const S = struct {
+        const foo = 666;
+
+        const a = @This();
+        const b = struct {
+            const foo = a.foo;
+            const bar = struct {
+                bar: u32 = b.foo,
+            };
+
+            comptime {
+                _ = b.foo;
+            }
+        };
+
+        usingnamespace b;
+    };
+    try expect(S.b.foo == 666);
+}
-- 
2.54.0


From 0a0b3dda03fc26dd2b3fdef1c66401cc182f5409 Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Tue, 16 Aug 2022 16:19:54 +0200
Subject: [PATCH 127/290] autodoc: remove reference to github, replace with
 placeholder link

---
 lib/docs/main.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 717aeb4d7fe1ffe9424f3b4df355ee93567b72a7..c08378f5f39dac54c0746c71a57426911d18e510 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -51,7 +51,7 @@ var zigAnalysis;
   const domHdrName = document.getElementById("hdrName");
   const domHelpModal = document.getElementById("helpModal");
   const domSearchPlaceholder = document.getElementById("searchPlaceholder");
-  const sourceFileUrlTemplate = "https://github.com/ziglang/zig/blob/master/lib/std/{{file}}#L{{line}}"
+  const sourceFileUrlTemplate = "/src-viewer/{{file}}#L{{line}}"
 
   let searchTimer = null;
   let searchTrimResults = true;
@@ -974,7 +974,7 @@ var zigAnalysis;
           "switch(" +
           cond +
           ") {" +
-          '<a href="https://github.com/ziglang/zig/tree/master/lib/std/' +
+          '<a href="/src-viewer/' +
           file_name +
           "#L" +
           line +
-- 
2.54.0


From 5929da37a117dfe67983155b39d4ee39e11f7ebc Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Tue, 16 Aug 2022 16:51:32 +0200
Subject: [PATCH 128/290] autodoc: absolute line numbers in decl [src] links

---
 lib/docs/main.js | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index c08378f5f39dac54c0746c71a57426911d18e510..a5ddb3b6fb0641a9d18c4fca96e6e13c7cf8c62e 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -53,6 +53,7 @@ var zigAnalysis;
   const domSearchPlaceholder = document.getElementById("searchPlaceholder");
   const sourceFileUrlTemplate = "/src-viewer/{{file}}#L{{line}}"
 
+  let lineCounter = 1;
   let searchTimer = null;
   let searchTrimResults = true;
 
@@ -404,6 +405,8 @@ var zigAnalysis;
     if (curNavSearch !== "") {
       return renderSearch();
     }
+    
+    lineCounter = 1;
 
     let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
     let pkg = rootPkg;
@@ -434,6 +437,10 @@ var zigAnalysis;
       }
 
       currentType = childDecl;
+      if ("src" in currentType) {
+        const ast_node = zigAnalysis.astNodes[currentType.src];
+        lineCounter += ast_node.line; 
+      }
       curNav.declObjs.push(currentType);
     }
 
@@ -2264,7 +2271,9 @@ var zigAnalysis;
   function renderSourceFileLink(decl) {
     let srcNode = zigAnalysis.astNodes[decl.src];
 
-    return  "<a style=\"float: right;\" href=\"" + sourceFileUrlTemplate.replace("{{file}}", zigAnalysis.files[srcNode.file]).replace("{{line}}", srcNode.line) + "\">[src]</a>";
+    return  "<a style=\"float: right;\" href=\"" + 
+      sourceFileUrlTemplate.replace("{{file}}", 
+        zigAnalysis.files[srcNode.file]).replace("{{line}}", lineCounter + srcNode.line) + "\">[src]</a>";
   }
 
   function renderContainer(container) {
-- 
2.54.0


From 9d4561ef0082728bbba085e8a4689ccc93a37b27 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Tue, 16 Aug 2022 16:55:49 +0300
Subject: [PATCH 129/290] AstGen: detect declarations shadowing locals

Closes #9355
---
 lib/std/bounded_array.zig                     | 14 +++----
 lib/std/debug.zig                             |  4 +-
 src/AstGen.zig                                | 40 +++++++++++++++++++
 .../compile_errors/decl_shadows_local.zig     | 22 ++++++++++
 4 files changed, 71 insertions(+), 9 deletions(-)
 create mode 100644 test/cases/compile_errors/decl_shadows_local.zig

diff --git a/lib/std/bounded_array.zig b/lib/std/bounded_array.zig
index 8134beb6e32c9011f052e901f71a36346f80a9f6..3d74e5e47fe589ec39b0495a2a0dc2f9e9a11d7c 100644
--- a/lib/std/bounded_array.zig
+++ b/lib/std/bounded_array.zig
@@ -15,16 +15,16 @@ const testing = std.testing;
 /// var slice = a.slice(); // a slice of the 64-byte array
 /// var a_clone = a; // creates a copy - the structure doesn't use any internal pointers
 /// ```
-pub fn BoundedArray(comptime T: type, comptime capacity: usize) type {
+pub fn BoundedArray(comptime T: type, comptime buffer_capacity: usize) type {
     return struct {
         const Self = @This();
-        buffer: [capacity]T = undefined,
+        buffer: [buffer_capacity]T = undefined,
         len: usize = 0,
 
         /// Set the actual length of the slice.
         /// Returns error.Overflow if it exceeds the length of the backing array.
         pub fn init(len: usize) error{Overflow}!Self {
-            if (len > capacity) return error.Overflow;
+            if (len > buffer_capacity) return error.Overflow;
             return Self{ .len = len };
         }
 
@@ -41,7 +41,7 @@ pub fn BoundedArray(comptime T: type, comptime capacity: usize) type {
         /// Adjust the slice's length to `len`.
         /// Does not initialize added items if any.
         pub fn resize(self: *Self, len: usize) error{Overflow}!void {
-            if (len > capacity) return error.Overflow;
+            if (len > buffer_capacity) return error.Overflow;
             self.len = len;
         }
 
@@ -69,7 +69,7 @@ pub fn BoundedArray(comptime T: type, comptime capacity: usize) type {
 
         /// Check that the slice can hold at least `additional_count` items.
         pub fn ensureUnusedCapacity(self: Self, additional_count: usize) error{Overflow}!void {
-            if (self.len + additional_count > capacity) {
+            if (self.len + additional_count > buffer_capacity) {
                 return error.Overflow;
             }
         }
@@ -83,7 +83,7 @@ pub fn BoundedArray(comptime T: type, comptime capacity: usize) type {
         /// Increase length by 1, returning pointer to the new item.
         /// Asserts that there is space for the new item.
         pub fn addOneAssumeCapacity(self: *Self) *T {
-            assert(self.len < capacity);
+            assert(self.len < buffer_capacity);
             self.len += 1;
             return &self.slice()[self.len - 1];
         }
@@ -236,7 +236,7 @@ pub fn BoundedArray(comptime T: type, comptime capacity: usize) type {
         pub fn appendNTimesAssumeCapacity(self: *Self, value: T, n: usize) void {
             const old_len = self.len;
             self.len += n;
-            assert(self.len <= capacity);
+            assert(self.len <= buffer_capacity);
             mem.set(T, self.slice()[old_len..self.len], value);
         }
 
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 0738b5af0b63754bd20bc1efe653fa66cd49beb3..33b8a98d7fbc715694490241305d3853b6732dbc 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -1947,7 +1947,7 @@ noinline fn showMyTrace() usize {
 /// For more advanced usage, see `ConfigurableTrace`.
 pub const Trace = ConfigurableTrace(2, 4, builtin.mode == .Debug);
 
-pub fn ConfigurableTrace(comptime size: usize, comptime stack_frame_count: usize, comptime enabled: bool) type {
+pub fn ConfigurableTrace(comptime size: usize, comptime stack_frame_count: usize, comptime is_enabled: bool) type {
     return struct {
         addrs: [actual_size][stack_frame_count]usize = undefined,
         notes: [actual_size][]const u8 = undefined,
@@ -1956,7 +1956,7 @@ pub fn ConfigurableTrace(comptime size: usize, comptime stack_frame_count: usize
         const actual_size = if (enabled) size else 0;
         const Index = if (enabled) usize else u0;
 
-        pub const enabled = enabled;
+        pub const enabled = is_enabled;
 
         pub const add = if (enabled) addNoInline else addNoOp;
 
diff --git a/src/AstGen.zig b/src/AstGen.zig
index 1151ed60daafecd81da92c24d26ab016a164bf7a..2fcd8cd9947e332a66c3beb68131b6cabf098afd 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -11751,6 +11751,46 @@ fn scanDecls(astgen: *AstGen, namespace: *Scope.Namespace, members: []const Ast.
                 error.OutOfMemory => return error.OutOfMemory,
             }
         }
+
+        // const index_name = try astgen.identAsString(index_token);
+        var s = namespace.parent;
+        while (true) switch (s.tag) {
+            .local_val => {
+                const local_val = s.cast(Scope.LocalVal).?;
+                if (local_val.name == name_str_index) {
+                    return astgen.failTokNotes(name_token, "redeclaration of {s} '{s}'", .{
+                        @tagName(local_val.id_cat), token_bytes,
+                    }, &[_]u32{
+                        try astgen.errNoteTok(
+                            local_val.token_src,
+                            "previous declaration here",
+                            .{},
+                        ),
+                    });
+                }
+                s = local_val.parent;
+            },
+            .local_ptr => {
+                const local_ptr = s.cast(Scope.LocalPtr).?;
+                if (local_ptr.name == name_str_index) {
+                    return astgen.failTokNotes(name_token, "redeclaration of {s} '{s}'", .{
+                        @tagName(local_ptr.id_cat), token_bytes,
+                    }, &[_]u32{
+                        try astgen.errNoteTok(
+                            local_ptr.token_src,
+                            "previous declaration here",
+                            .{},
+                        ),
+                    });
+                }
+                s = local_ptr.parent;
+            },
+            .namespace => s = s.cast(Scope.Namespace).?.parent,
+            .gen_zir => s = s.cast(GenZir).?.parent,
+            .defer_normal, .defer_error => s = s.cast(Scope.Defer).?.parent,
+            .defer_gen => s = s.cast(Scope.DeferGen).?.parent,
+            .top => break,
+        };
         gop.value_ptr.* = member_node;
     }
     return decl_count;
diff --git a/test/cases/compile_errors/decl_shadows_local.zig b/test/cases/compile_errors/decl_shadows_local.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cb48cafa4574e28f0c6f84ff4c3fa44cc49ec409
--- /dev/null
+++ b/test/cases/compile_errors/decl_shadows_local.zig
@@ -0,0 +1,22 @@
+fn foo(a: usize) void {
+    struct {
+        const a = 1;
+    };
+}
+fn bar(a: usize) void {
+    struct {
+        const b = struct {
+            const a = 1;
+        };
+    };
+    _ = a;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:15: error: redeclaration of function parameter 'a'
+// :1:8: note: previous declaration here
+// :9:19: error: redeclaration of function parameter 'a'
+// :6:8: note: previous declaration here
-- 
2.54.0


From d84282174c449325b4bc43fed4d65289445399d4 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Wed, 17 Aug 2022 09:00:23 +0200
Subject: [PATCH 130/290] link-test: move tls test to macho/tls

This test was always really testing correct behavior of our in-house
MachO linker to begin with.
---
 test/link.zig                       | 13 ++++---------
 test/link/{ => macho}/tls/a.c       |  0
 test/link/{ => macho}/tls/build.zig |  1 +
 test/link/{ => macho}/tls/main.zig  |  0
 4 files changed, 5 insertions(+), 9 deletions(-)
 rename test/link/{ => macho}/tls/a.c (100%)
 rename test/link/{ => macho}/tls/build.zig (88%)
 rename test/link/{ => macho}/tls/main.zig (100%)

diff --git a/test/link.zig b/test/link.zig
index 01edd07261d05ba943e449528ba410625951e68e..a8a39a7018c3912d624b349988cdcf34dcb56b5d 100644
--- a/test/link.zig
+++ b/test/link.zig
@@ -3,11 +3,6 @@ const builtin = @import("builtin");
 const tests = @import("tests.zig");
 
 pub fn addCases(cases: *tests.StandaloneContext) void {
-    if (builtin.os.tag == .windows) {
-        // https://github.com/ziglang/zig/issues/12421
-        return;
-    }
-
     cases.addBuildFile("test/link/bss/build.zig", .{
         .build_modes = false, // we only guarantee zerofill for undefined in Debug
     });
@@ -28,10 +23,6 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
         .build_modes = true,
     });
 
-    cases.addBuildFile("test/link/tls/build.zig", .{
-        .build_modes = true,
-    });
-
     cases.addBuildFile("test/link/wasm/type/build.zig", .{
         .build_modes = true,
         .requires_stage2 = true,
@@ -115,4 +106,8 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
         .build_modes = true,
         .requires_macos_sdk = true,
     });
+
+    cases.addBuildFile("test/link/macho/tls/build.zig", .{
+        .build_modes = true,
+    });
 }
diff --git a/test/link/tls/a.c b/test/link/macho/tls/a.c
similarity index 100%
rename from test/link/tls/a.c
rename to test/link/macho/tls/a.c
diff --git a/test/link/tls/build.zig b/test/link/macho/tls/build.zig
similarity index 88%
rename from test/link/tls/build.zig
rename to test/link/macho/tls/build.zig
index ebf15ca4399a349e29c8c9c5722b70dc25774cc6..7bf3ea1c9e14b41a626eb5d9f192353bede2ee16 100644
--- a/test/link/tls/build.zig
+++ b/test/link/macho/tls/build.zig
@@ -2,6 +2,7 @@ const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
     const mode = b.standardReleaseOptions();
+    const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const lib = b.addSharedLibrary("a", null, b.version(1, 0, 0));
     lib.setBuildMode(mode);
diff --git a/test/link/tls/main.zig b/test/link/macho/tls/main.zig
similarity index 100%
rename from test/link/tls/main.zig
rename to test/link/macho/tls/main.zig
-- 
2.54.0


From db0f372da8b25f4a911cd8e0b7f8e5cdfc64f940 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 17 Aug 2022 13:10:58 +0300
Subject: [PATCH 131/290] Sema: make optional noreturn behave correctly

---
 src/Sema.zig                                  | 15 ++++++--
 test/behavior/optional.zig                    | 36 +++++++++++++++++++
 .../invalid_optional_payload_type.zig         | 13 +++++++
 3 files changed, 62 insertions(+), 2 deletions(-)
 create mode 100644 test/cases/compile_errors/invalid_optional_payload_type.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index d7d6994bcdef41c391f3bc2f10366490ab8b202a..ceeb8af23c72712a734142ffefec4448fb5365c2 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -6684,8 +6684,13 @@ fn zirOptionalType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
     defer tracy.end();
 
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
-    const src = inst_data.src();
-    const child_type = try sema.resolveType(block, src, inst_data.operand);
+    const operand_src: LazySrcLoc = .{ .node_offset_un_op = inst_data.src_node };
+    const child_type = try sema.resolveType(block, operand_src, inst_data.operand);
+    if (child_type.zigTypeTag() == .Opaque) {
+        return sema.fail(block, operand_src, "opaque type '{}' cannot be optional", .{child_type.fmt(sema.mod)});
+    } else if (child_type.zigTypeTag() == .Null) {
+        return sema.fail(block, operand_src, "type '{}' cannot be optional", .{child_type.fmt(sema.mod)});
+    }
     const opt_type = try Type.optional(sema.arena, child_type);
 
     return sema.addType(opt_type);
@@ -25714,6 +25719,12 @@ fn analyzeIsNull(
             return Air.Inst.Ref.bool_false;
         }
     }
+
+    const operand_ty = sema.typeOf(operand);
+    var buf: Type.Payload.ElemType = undefined;
+    if (operand_ty.zigTypeTag() == .Optional and operand_ty.optionalChild(&buf).zigTypeTag() == .NoReturn) {
+        return Air.Inst.Ref.bool_true;
+    }
     try sema.requireRuntimeBlock(block, src, null);
     const air_tag: Air.Inst.Tag = if (invert_logic) .is_non_null else .is_null;
     return block.addUnOp(air_tag, operand);
diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig
index 4e5eb5061cd74f98eed9d39aae9fec50c8927783..c13a3b7e4fd2c82de872d373bf10d9fbb7c7e78a 100644
--- a/test/behavior/optional.zig
+++ b/test/behavior/optional.zig
@@ -369,3 +369,39 @@ test "optional pointer to zero bit error union payload" {
         some.foo();
     } else |_| {}
 }
+
+const NoReturn = struct {
+    var a: u32 = undefined;
+    fn someData() bool {
+        a -= 1;
+        return a == 0;
+    }
+    fn loop() ?noreturn {
+        while (true) {
+            if (someData()) return null;
+        }
+    }
+    fn testOrelse() u32 {
+        loop() orelse return 123;
+        @compileError("bad");
+    }
+};
+
+test "optional of noreturn used with if" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+
+    NoReturn.a = 64;
+    if (NoReturn.loop()) |_| {
+        @compileError("bad");
+    } else {
+        try expect(true);
+    }
+}
+
+test "optional of noreturn used with orelse" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+
+    NoReturn.a = 64;
+    const val = NoReturn.testOrelse();
+    try expect(val == 123);
+}
diff --git a/test/cases/compile_errors/invalid_optional_payload_type.zig b/test/cases/compile_errors/invalid_optional_payload_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0058cd5e3663c3d55aa46d950ab03084b85bbf6e
--- /dev/null
+++ b/test/cases/compile_errors/invalid_optional_payload_type.zig
@@ -0,0 +1,13 @@
+comptime {
+    _ = ?anyopaque;
+}
+comptime {
+    _ = ?@TypeOf(null);
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:10: error: opaque type 'anyopaque' cannot be optional
+// :5:10: error: type '@TypeOf(null)' cannot be optional
-- 
2.54.0


From b0a55e1b3be3a274546f9c18016e9609d546bdb0 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 17 Aug 2022 13:21:07 +0300
Subject: [PATCH 132/290] Sema: make noreturn error union behave correctly

---
 src/Sema.zig                                  | 14 +++++
 test/behavior/error.zig                       | 62 ++++++++++++++++++-
 .../invalid_error_union_payload_type.zig      | 13 ++++
 3 files changed, 88 insertions(+), 1 deletion(-)
 create mode 100644 test/cases/compile_errors/invalid_error_union_payload_type.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index ceeb8af23c72712a734142ffefec4448fb5365c2..772abf5a84d6e58f4808c7af5041b07fecb2d09c 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -6789,6 +6789,15 @@ fn zirErrorUnionType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
             error_set.fmt(sema.mod),
         });
     }
+    if (payload.zigTypeTag() == .Opaque) {
+        return sema.fail(block, rhs_src, "error union with payload of opaque type '{}' not allowed", .{
+            payload.fmt(sema.mod),
+        });
+    } else if (payload.zigTypeTag() == .ErrorSet) {
+        return sema.fail(block, rhs_src, "error union with payload of error set type '{}' not allowed", .{
+            payload.fmt(sema.mod),
+        });
+    }
     const err_union_ty = try Type.errorUnion(sema.arena, error_set, payload, sema.mod);
     return sema.addType(err_union_ty);
 }
@@ -25763,6 +25772,11 @@ fn analyzeIsNonErrComptimeOnly(
     if (ot == .ErrorSet) return Air.Inst.Ref.bool_false;
     assert(ot == .ErrorUnion);
 
+    const payload_ty = operand_ty.errorUnionPayload();
+    if (payload_ty.zigTypeTag() == .NoReturn) {
+        return Air.Inst.Ref.bool_false;
+    }
+
     if (Air.refToIndex(operand)) |operand_inst| {
         switch (sema.air_instructions.items(.tag)[operand_inst]) {
             .wrap_errunion_payload => return Air.Inst.Ref.bool_true,
diff --git a/test/behavior/error.zig b/test/behavior/error.zig
index 306dad5d9edc7e6f5a579fc35d860f2d6a9d4ec5..84b18a27383ebd053b33614245a0031b003c20a7 100644
--- a/test/behavior/error.zig
+++ b/test/behavior/error.zig
@@ -725,7 +725,7 @@ test "simple else prong allowed even when all errors handled" {
     try expect(value == 255);
 }
 
-test {
+test "pointer to error union payload" {
     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_wasm) return error.SkipZigTest; // TODO
@@ -736,3 +736,63 @@ test {
     const payload_ptr = &(err_union catch unreachable);
     try expect(payload_ptr.* == 15);
 }
+
+const NoReturn = struct {
+    var a: u32 = undefined;
+    fn someData() bool {
+        a -= 1;
+        return a == 0;
+    }
+    fn loop() !noreturn {
+        while (true) {
+            if (someData())
+                return error.GenericFailure;
+        }
+    }
+    fn testTry() anyerror {
+        try loop();
+    }
+    fn testCatch() anyerror {
+        loop() catch return error.OtherFailure;
+        @compileError("bad");
+    }
+};
+
+test "error union of noreturn used with if" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+    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_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+
+    NoReturn.a = 64;
+    if (NoReturn.loop()) {
+        @compileError("bad");
+    } else |err| {
+        try expect(err == error.GenericFailure);
+    }
+}
+
+test "error union of noreturn used with try" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+    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_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+
+    NoReturn.a = 64;
+    const err = NoReturn.testTry();
+    try expect(err == error.GenericFailure);
+}
+
+test "error union of noreturn used with catch" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+    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_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+
+    NoReturn.a = 64;
+    const err = NoReturn.testCatch();
+    try expect(err == error.OtherFailure);
+}
diff --git a/test/cases/compile_errors/invalid_error_union_payload_type.zig b/test/cases/compile_errors/invalid_error_union_payload_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f8646d9450c663f808eb2d4275f66180d50c24b8
--- /dev/null
+++ b/test/cases/compile_errors/invalid_error_union_payload_type.zig
@@ -0,0 +1,13 @@
+comptime {
+    _ = anyerror!anyopaque;
+}
+comptime {
+    _ = anyerror!anyerror;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:18: error: error union with payload of opaque type 'anyopaque' not allowed
+// :5:18: error: error union with payload of error set type 'anyerror' not allowed
-- 
2.54.0


From c3d5428cba4d02afbe1ec34bdc7bcb68f56d1b45 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 17 Aug 2022 15:07:20 +0300
Subject: [PATCH 133/290] Sema: properly handle noreturn fields in unions

---
 src/Sema.zig                                  | 202 +++++++++++++++---
 test/behavior/union.zig                       |  45 ++++
 .../compile_errors/noreturn_struct_field.zig  |  12 ++
 ...ast_to_union_which_has_non-void_fields.zig |   2 -
 .../union_noreturn_field_initialized.zig      |  43 ++++
 5 files changed, 270 insertions(+), 34 deletions(-)
 create mode 100644 test/cases/compile_errors/noreturn_struct_field.zig
 create mode 100644 test/cases/compile_errors/union_noreturn_field_initialized.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index 772abf5a84d6e58f4808c7af5041b07fecb2d09c..1aebe8e98eb0bdfa1c2e9e6a58774a75ae62435a 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -3772,6 +3772,7 @@ fn validateStructInit(
     }
 
     var root_msg: ?*Module.ErrorMsg = null;
+    errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
 
     const struct_ptr = try sema.resolveInst(struct_ptr_zir_ref);
     if ((is_comptime or block.is_comptime) and
@@ -3947,6 +3948,7 @@ fn validateStructInit(
     }
 
     if (root_msg) |msg| {
+        root_msg = null;
         if (struct_ty.castTag(.@"struct")) |struct_obj| {
             const fqn = try struct_obj.data.getFullyQualifiedName(sema.mod);
             defer gpa.free(fqn);
@@ -4005,6 +4007,8 @@ fn zirValidateArrayInit(
     if (instrs.len != array_len and array_ty.isTuple()) {
         const struct_obj = array_ty.castTag(.tuple).?.data;
         var root_msg: ?*Module.ErrorMsg = null;
+        errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
+
         for (struct_obj.values) |default_val, i| {
             if (i < instrs.len) continue;
 
@@ -4019,6 +4023,7 @@ fn zirValidateArrayInit(
         }
 
         if (root_msg) |msg| {
+            root_msg = null;
             return sema.failWithOwnedErrorMsg(msg);
         }
     }
@@ -8964,12 +8969,15 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         },
     };
 
-    const union_originally = blk: {
+    const maybe_union_ty = blk: {
         const zir_data = sema.code.instructions.items(.data);
         const cond_index = Zir.refToIndex(extra.data.operand).?;
         const raw_operand = sema.resolveInst(zir_data[cond_index].un_node.operand) catch unreachable;
-        break :blk sema.typeOf(raw_operand).zigTypeTag() == .Union;
+        break :blk sema.typeOf(raw_operand);
     };
+    const union_originally = maybe_union_ty.zigTypeTag() == .Union;
+    var seen_union_fields: []?Module.SwitchProngSrc = &.{};
+    defer gpa.free(seen_union_fields);
 
     const operand_ty = sema.typeOf(operand);
 
@@ -9004,7 +9012,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         .Union => unreachable, // handled in zirSwitchCond
         .Enum => {
             var seen_fields = try gpa.alloc(?Module.SwitchProngSrc, operand_ty.enumFieldCount());
-            defer gpa.free(seen_fields);
+            defer if (!union_originally) gpa.free(seen_fields);
+            if (union_originally) seen_union_fields = seen_fields;
             mem.set(?Module.SwitchProngSrc, seen_fields, null);
 
             // This is used for non-exhaustive enum values that do not correspond to any tags.
@@ -9637,18 +9646,28 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         const item = try sema.resolveInst(item_ref);
         // `item` is already guaranteed to be constant known.
 
-        _ = sema.analyzeBodyInner(&case_block, body) catch |err| switch (err) {
-            error.ComptimeBreak => {
-                const zir_datas = sema.code.instructions.items(.data);
-                const break_data = zir_datas[sema.comptime_break_inst].@"break";
-                try sema.addRuntimeBreak(&case_block, .{
-                    .block_inst = break_data.block_inst,
-                    .operand = break_data.operand,
-                    .inst = sema.comptime_break_inst,
-                });
-            },
-            else => |e| return e,
-        };
+        const analyze_body = if (union_originally) blk: {
+            const item_val = sema.resolveConstValue(block, .unneeded, item, undefined) catch unreachable;
+            const field_ty = maybe_union_ty.unionFieldType(item_val, sema.mod);
+            break :blk field_ty.zigTypeTag() != .NoReturn;
+        } else true;
+
+        if (analyze_body) {
+            _ = sema.analyzeBodyInner(&case_block, body) catch |err| switch (err) {
+                error.ComptimeBreak => {
+                    const zir_datas = sema.code.instructions.items(.data);
+                    const break_data = zir_datas[sema.comptime_break_inst].@"break";
+                    try sema.addRuntimeBreak(&case_block, .{
+                        .block_inst = break_data.block_inst,
+                        .operand = break_data.operand,
+                        .inst = sema.comptime_break_inst,
+                    });
+                },
+                else => |e| return e,
+            };
+        } else {
+            _ = try case_block.addNoOp(.unreach);
+        }
 
         try wip_captures.finalize();
 
@@ -9689,20 +9708,34 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         if (ranges_len == 0) {
             cases_len += 1;
 
+            const analyze_body = if (union_originally)
+                for (items) |item_ref| {
+                    const item = try sema.resolveInst(item_ref);
+                    const item_val = sema.resolveConstValue(block, .unneeded, item, undefined) catch unreachable;
+                    const field_ty = maybe_union_ty.unionFieldType(item_val, sema.mod);
+                    if (field_ty.zigTypeTag() != .NoReturn) break true;
+                } else false
+            else
+                true;
+
             const body = sema.code.extra[extra_index..][0..body_len];
             extra_index += body_len;
-            _ = sema.analyzeBodyInner(&case_block, body) catch |err| switch (err) {
-                error.ComptimeBreak => {
-                    const zir_datas = sema.code.instructions.items(.data);
-                    const break_data = zir_datas[sema.comptime_break_inst].@"break";
-                    try sema.addRuntimeBreak(&case_block, .{
-                        .block_inst = break_data.block_inst,
-                        .operand = break_data.operand,
-                        .inst = sema.comptime_break_inst,
-                    });
-                },
-                else => |e| return e,
-            };
+            if (analyze_body) {
+                _ = sema.analyzeBodyInner(&case_block, body) catch |err| switch (err) {
+                    error.ComptimeBreak => {
+                        const zir_datas = sema.code.instructions.items(.data);
+                        const break_data = zir_datas[sema.comptime_break_inst].@"break";
+                        try sema.addRuntimeBreak(&case_block, .{
+                            .block_inst = break_data.block_inst,
+                            .operand = break_data.operand,
+                            .inst = sema.comptime_break_inst,
+                        });
+                    },
+                    else => |e| return e,
+                };
+            } else {
+                _ = try case_block.addNoOp(.unreach);
+            }
 
             try cases_extra.ensureUnusedCapacity(gpa, 2 + items.len +
                 case_block.instructions.items.len);
@@ -9824,7 +9857,17 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         case_block.instructions.shrinkRetainingCapacity(0);
         case_block.wip_capture_scope = wip_captures.scope;
 
-        if (special.body.len != 0) {
+        const analyze_body = if (union_originally)
+            for (seen_union_fields) |seen_field, index| {
+                if (seen_field != null) continue;
+                const union_obj = maybe_union_ty.cast(Type.Payload.Union).?.data;
+                const field_ty = union_obj.fields.values()[index].ty;
+                if (field_ty.zigTypeTag() != .NoReturn) break true;
+            } else false
+        else
+            true;
+
+        if (special.body.len != 0 and analyze_body) {
             _ = sema.analyzeBodyInner(&case_block, special.body) catch |err| switch (err) {
                 error.ComptimeBreak => {
                     const zir_datas = sema.code.instructions.items(.data);
@@ -13225,6 +13268,14 @@ fn analyzeCmpUnionTag(
     const coerced_tag = try sema.coerce(block, union_tag_ty, tag, tag_src);
     const coerced_union = try sema.coerce(block, union_tag_ty, un, un_src);
 
+    if (try sema.resolveMaybeUndefVal(block, tag_src, coerced_tag)) |enum_val| {
+        if (enum_val.isUndef()) return sema.addConstUndef(Type.bool);
+        const field_ty = union_ty.unionFieldType(enum_val, sema.mod);
+        if (field_ty.zigTypeTag() == .NoReturn) {
+            return Air.Inst.Ref.bool_false;
+        }
+    }
+
     return sema.cmpSelf(block, src, coerced_union, coerced_tag, op, un_src, tag_src);
 }
 
@@ -15579,6 +15630,8 @@ fn finishStructInit(
     const gpa = sema.gpa;
 
     var root_msg: ?*Module.ErrorMsg = null;
+    errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
+
     if (struct_ty.isAnonStruct()) {
         const struct_obj = struct_ty.castTag(.anon_struct).?.data;
         for (struct_obj.values) |default_val, i| {
@@ -15634,6 +15687,7 @@ fn finishStructInit(
     }
 
     if (root_msg) |msg| {
+        root_msg = null;
         if (struct_ty.castTag(.@"struct")) |struct_obj| {
             const fqn = try struct_obj.data.getFullyQualifiedName(sema.mod);
             defer gpa.free(fqn);
@@ -21682,6 +21736,18 @@ fn unionFieldPtr(
         .@"addrspace" = union_ptr_ty.ptrAddressSpace(),
     });
 
+    if (initializing and field.ty.zigTypeTag() == .NoReturn) {
+        const msg = msg: {
+            const msg = try sema.errMsg(block, src, "cannot initialize 'noreturn' field of union", .{});
+            errdefer msg.destroy(sema.gpa);
+
+            try sema.addFieldErrNote(block, union_ty, field_index, msg, "field '{s}' declared here", .{field_name});
+            try sema.addDeclaredHereNote(msg, union_ty);
+            break :msg msg;
+        };
+        return sema.failWithOwnedErrorMsg(msg);
+    }
+
     if (try sema.resolveDefinedValue(block, src, union_ptr)) |union_ptr_val| ct: {
         switch (union_obj.layout) {
             .Auto => if (!initializing) {
@@ -21734,6 +21800,10 @@ fn unionFieldPtr(
         const ok = try block.addBinOp(.cmp_eq, active_tag, wanted_tag);
         try sema.addSafetyCheck(block, ok, .inactive_union_field);
     }
+    if (field.ty.zigTypeTag() == .NoReturn) {
+        _ = try block.addNoOp(.unreach);
+        return Air.Inst.Ref.unreachable_value;
+    }
     return block.addStructFieldPtr(union_ptr, field_index, ptr_field_ty);
 }
 
@@ -21802,6 +21872,10 @@ fn unionFieldVal(
         const ok = try block.addBinOp(.cmp_eq, active_tag, wanted_tag);
         try sema.addSafetyCheck(block, ok, .inactive_union_field);
     }
+    if (field.ty.zigTypeTag() == .NoReturn) {
+        _ = try block.addNoOp(.unreach);
+        return Air.Inst.Ref.unreachable_value;
+    }
     return block.addStructFieldVal(union_byval, field_index, field.ty);
 }
 
@@ -25002,6 +25076,18 @@ fn coerceEnumToUnion(
         };
         const field = union_obj.fields.values()[field_index];
         const field_ty = try sema.resolveTypeFields(block, inst_src, field.ty);
+        if (field_ty.zigTypeTag() == .NoReturn) {
+            const msg = msg: {
+                const msg = try sema.errMsg(block, inst_src, "cannot initialize 'noreturn' field of union", .{});
+                errdefer msg.destroy(sema.gpa);
+
+                const field_name = union_obj.fields.keys()[field_index];
+                try sema.addFieldErrNote(block, union_ty, field_index, msg, "field '{s}' declared here", .{field_name});
+                try sema.addDeclaredHereNote(msg, union_ty);
+                break :msg msg;
+            };
+            return sema.failWithOwnedErrorMsg(msg);
+        }
         const opv = (try sema.typeHasOnePossibleValue(block, inst_src, field_ty)) orelse {
             const msg = msg: {
                 const field_name = union_obj.fields.keys()[field_index];
@@ -25037,13 +25123,37 @@ fn coerceEnumToUnion(
         return sema.failWithOwnedErrorMsg(msg);
     }
 
+    const union_obj = union_ty.cast(Type.Payload.Union).?.data;
+    {
+        var msg: ?*Module.ErrorMsg = null;
+        errdefer if (msg) |some| some.destroy(sema.gpa);
+
+        for (union_obj.fields.values()) |field, i| {
+            if (field.ty.zigTypeTag() == .NoReturn) {
+                const err_msg = msg orelse try sema.errMsg(
+                    block,
+                    inst_src,
+                    "runtime coercion from enum '{}' to union '{}' which has a 'noreturn' field",
+                    .{ tag_ty.fmt(sema.mod), union_ty.fmt(sema.mod) },
+                );
+                msg = err_msg;
+
+                try sema.addFieldErrNote(block, union_ty, i, err_msg, "'noreturn' field here", .{});
+            }
+        }
+        if (msg) |some| {
+            msg = null;
+            try sema.addDeclaredHereNote(some, union_ty);
+            return sema.failWithOwnedErrorMsg(some);
+        }
+    }
+
     // If the union has all fields 0 bits, the union value is just the enum value.
     if (union_ty.unionHasAllZeroBitFieldTypes()) {
         return block.addBitCast(union_ty, enum_tag);
     }
 
     const msg = msg: {
-        const union_obj = union_ty.cast(Type.Payload.Union).?.data;
         const msg = try sema.errMsg(
             block,
             inst_src,
@@ -25054,11 +25164,11 @@ fn coerceEnumToUnion(
 
         var it = union_obj.fields.iterator();
         var field_index: usize = 0;
-        while (it.next()) |field| {
+        while (it.next()) |field| : (field_index += 1) {
             const field_name = field.key_ptr.*;
             const field_ty = field.value_ptr.ty;
+            if (!field_ty.hasRuntimeBits()) continue;
             try sema.addFieldErrNote(block, union_ty, field_index, msg, "field '{s}' has type '{}'", .{ field_name, field_ty.fmt(sema.mod) });
-            field_index += 1;
         }
         try sema.addDeclaredHereNote(msg, union_ty);
         break :msg msg;
@@ -25361,6 +25471,7 @@ fn coerceTupleToStruct(
 
     // Populate default field values and report errors for missing fields.
     var root_msg: ?*Module.ErrorMsg = null;
+    errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
 
     for (field_refs) |*field_ref, i| {
         if (field_ref.* != .none) continue;
@@ -25386,6 +25497,7 @@ fn coerceTupleToStruct(
     }
 
     if (root_msg) |msg| {
+        root_msg = null;
         try sema.addDeclaredHereNote(msg, struct_ty);
         return sema.failWithOwnedErrorMsg(msg);
     }
@@ -25455,6 +25567,7 @@ fn coerceTupleToTuple(
 
     // Populate default field values and report errors for missing fields.
     var root_msg: ?*Module.ErrorMsg = null;
+    errdefer if (root_msg) |msg| msg.destroy(sema.gpa);
 
     for (field_refs) |*field_ref, i| {
         if (field_ref.* != .none) continue;
@@ -25490,6 +25603,7 @@ fn coerceTupleToTuple(
     }
 
     if (root_msg) |msg| {
+        root_msg = null;
         try sema.addDeclaredHereNote(msg, tuple_ty);
         return sema.failWithOwnedErrorMsg(msg);
     }
@@ -27914,6 +28028,18 @@ fn semaStructFields(mod: *Module, struct_obj: *Module.Struct) CompileError!void
             };
             return sema.failWithOwnedErrorMsg(msg);
         }
+        if (field_ty.zigTypeTag() == .NoReturn) {
+            const msg = msg: {
+                const tree = try sema.getAstTree(&block_scope);
+                const field_src = enumFieldSrcLoc(decl, tree.*, 0, i);
+                const msg = try sema.errMsg(&block_scope, field_src, "struct fields cannot be 'noreturn'", .{});
+                errdefer msg.destroy(sema.gpa);
+
+                try sema.addDeclaredHereNote(msg, field_ty);
+                break :msg msg;
+            };
+            return sema.failWithOwnedErrorMsg(msg);
+        }
         if (struct_obj.layout == .Extern and !sema.validateExternType(field.ty, .other)) {
             const msg = msg: {
                 const tree = try sema.getAstTree(&block_scope);
@@ -28725,6 +28851,16 @@ fn enumFieldSrcLoc(
         .container_decl_arg_trailing,
         => tree.containerDeclArg(enum_node),
 
+        .tagged_union,
+        .tagged_union_trailing,
+        => tree.taggedUnion(enum_node),
+        .tagged_union_two,
+        .tagged_union_two_trailing,
+        => tree.taggedUnionTwo(&buffer, enum_node),
+        .tagged_union_enum_tag,
+        .tagged_union_enum_tag_trailing,
+        => tree.taggedUnionEnumTag(enum_node),
+
         // Container was constructed with `@Type`.
         else => return LazySrcLoc.nodeOffset(0),
     };
@@ -29375,7 +29511,9 @@ fn unionFieldAlignment(
     src: LazySrcLoc,
     field: Module.Union.Field,
 ) !u32 {
-    if (field.abi_align == 0) {
+    if (field.ty.zigTypeTag() == .NoReturn) {
+        return @as(u32, 0);
+    } else if (field.abi_align == 0) {
         return sema.typeAbiAlignment(block, src, field.ty);
     } else {
         return field.abi_align;
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index 2f6fa78f0ce0db757880696819024e70d46794e4..efca75af30ed3b9d4251f13b5c69327be5383999 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1256,3 +1256,48 @@ test "return an extern union from C calling convention" {
     });
     try expect(u.d == 4.0);
 }
+
+test "noreturn field in union" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+    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_x86_64) return error.SkipZigTest; // TODO
+
+    const U = union(enum) {
+        a: u32,
+        b: noreturn,
+        c: noreturn,
+    };
+    var a = U{ .a = 1 };
+    var count: u32 = 0;
+    if (a == .b) @compileError("bad");
+    switch (a) {
+        .a => count += 1,
+        .b => |val| {
+            _ = val;
+            @compileError("bad");
+        },
+        .c => @compileError("bad"),
+    }
+    switch (a) {
+        .a => count += 1,
+        .b, .c => @compileError("bad"),
+    }
+    switch (a) {
+        .a, .b, .c => {
+            count += 1;
+            try expect(a == .a);
+        },
+    }
+    switch (a) {
+        .a => count += 1,
+        else => @compileError("bad"),
+    }
+    switch (a) {
+        else => {
+            count += 1;
+            try expect(a == .a);
+        },
+    }
+    try expect(count == 5);
+}
diff --git a/test/cases/compile_errors/noreturn_struct_field.zig b/test/cases/compile_errors/noreturn_struct_field.zig
new file mode 100644
index 0000000000000000000000000000000000000000..90b243c31df4aa517fb5be0a6b126351617bb054
--- /dev/null
+++ b/test/cases/compile_errors/noreturn_struct_field.zig
@@ -0,0 +1,12 @@
+const S = struct {
+    s: noreturn,
+};
+comptime {
+    _ = @typeInfo(S);
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:5: error: struct fields cannot be 'noreturn'
diff --git a/test/cases/compile_errors/runtime_cast_to_union_which_has_non-void_fields.zig b/test/cases/compile_errors/runtime_cast_to_union_which_has_non-void_fields.zig
index c312d6db40680475b44655eab9bf62091f547de4..0142f422f475acc15df4048e77e714dbe230dd46 100644
--- a/test/cases/compile_errors/runtime_cast_to_union_which_has_non-void_fields.zig
+++ b/test/cases/compile_errors/runtime_cast_to_union_which_has_non-void_fields.zig
@@ -18,6 +18,4 @@ fn foo(l: Letter) void {
 //
 // :11:20: error: runtime coercion from enum 'tmp.Letter' to union 'tmp.Value' which has non-void fields
 // :3:5: note: field 'A' has type 'i32'
-// :4:5: note: field 'B' has type 'void'
-// :5:5: note: field 'C' has type 'void'
 // :2:15: note: union declared here
diff --git a/test/cases/compile_errors/union_noreturn_field_initialized.zig b/test/cases/compile_errors/union_noreturn_field_initialized.zig
new file mode 100644
index 0000000000000000000000000000000000000000..66304d6a74ef2e5786bce749ce3e36b3caa738fd
--- /dev/null
+++ b/test/cases/compile_errors/union_noreturn_field_initialized.zig
@@ -0,0 +1,43 @@
+pub export fn entry1() void {
+    const U = union(enum) {
+        a: u32,
+        b: noreturn,
+        fn foo(_: @This()) void {}
+        fn bar() noreturn {
+            unreachable;
+        }
+    };
+
+    var a = U{ .b = undefined };
+    _ = a;
+}
+pub export fn entry2() void {
+    const U = union(enum) {
+        a: noreturn,
+    };
+    var u: U = undefined;
+    u = .a;
+}
+pub export fn entry3() void {
+    const U = union(enum) {
+        a: noreturn,
+        b: void,
+    };
+    var e = @typeInfo(U).Union.tag_type.?.a;
+    var u: U = undefined;
+    u = e;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :11:21: error: cannot initialize 'noreturn' field of union
+// :4:9: note: field 'b' declared here
+// :2:15: note: union declared here
+// :19:10: error: cannot initialize 'noreturn' field of union
+// :16:9: note: field 'a' declared here
+// :15:15: note: union declared here
+// :28:9: error: runtime coercion from enum '@typeInfo(tmp.entry3.U).Union.tag_type.?' to union 'tmp.entry3.U' which has a 'noreturn' field
+// :23:9: note: 'noreturn' field here
+// :22:15: note: union declared here
-- 
2.54.0


From c764640e92c9e4d32b89650ac774bebf1498be92 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 17 Aug 2022 12:55:08 -0700
Subject: [PATCH 134/290] Sema: fix generics with struct literal coerced to
 tagged union

The `Value.eql` function has to test for value equality *as-if* the lhs
value parameter is coerced into the type of the rhs. For tagged unions,
there was a problematic case when the lhs was an anonymous struct,
because in such case the value is empty_struct_value and the type
contains all the value information. But the only type available in the
function was the rhs type.

So the fix involved making `Value.eqlAdvanced` also accept the lhs type,
and then enhancing the logic to handle the case of the `.anon_struct` tag.

closes #12418

Tests run locally:
 * test-behavior
 * test-cases
---
 src/Sema.zig               | 56 +++++++++++++++++----------
 src/value.zig              | 77 ++++++++++++++++++++++++++------------
 test/behavior/generics.zig | 19 ++++++++++
 3 files changed, 110 insertions(+), 42 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index d7d6994bcdef41c391f3bc2f10366490ab8b202a..f1d140520cc1588676f11f4079b05c62003ed1ea 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -1495,7 +1495,8 @@ pub fn resolveInst(sema: *Sema, zir_ref: Zir.Inst.Ref) !Air.Inst.Ref {
 
     // Finally, the last section of indexes refers to the map of ZIR=>AIR.
     const inst = sema.inst_map.get(@intCast(u32, i)).?;
-    if (sema.typeOf(inst).tag() == .generic_poison) return error.GenericPoison;
+    const ty = sema.typeOf(inst);
+    if (ty.tag() == .generic_poison) return error.GenericPoison;
     return inst;
 }
 
@@ -5570,11 +5571,15 @@ const GenericCallAdapter = struct {
     generic_fn: *Module.Fn,
     precomputed_hash: u64,
     func_ty_info: Type.Payload.Function.Data,
-    /// Unlike comptime_args, the Type here is not always present.
-    /// .generic_poison is used to communicate non-anytype parameters.
-    comptime_tvs: []const TypedValue,
+    args: []const Arg,
     module: *Module,
 
+    const Arg = struct {
+        ty: Type,
+        val: Value,
+        is_anytype: bool,
+    };
+
     pub fn eql(ctx: @This(), adapted_key: void, other_key: *Module.Fn) bool {
         _ = adapted_key;
         // The generic function Decl is guaranteed to be the first dependency
@@ -5585,10 +5590,10 @@ const GenericCallAdapter = struct {
 
         const other_comptime_args = other_key.comptime_args.?;
         for (other_comptime_args[0..ctx.func_ty_info.param_types.len]) |other_arg, i| {
-            const this_arg = ctx.comptime_tvs[i];
+            const this_arg = ctx.args[i];
             const this_is_comptime = this_arg.val.tag() != .generic_poison;
             const other_is_comptime = other_arg.val.tag() != .generic_poison;
-            const this_is_anytype = this_arg.ty.tag() != .generic_poison;
+            const this_is_anytype = this_arg.is_anytype;
             const other_is_anytype = other_key.isAnytypeParam(ctx.module, @intCast(u32, i));
 
             if (other_is_anytype != this_is_anytype) return false;
@@ -5607,7 +5612,17 @@ const GenericCallAdapter = struct {
                 }
             } else if (this_is_comptime) {
                 // Both are comptime parameters but not anytype parameters.
-                if (!this_arg.val.eql(other_arg.val, other_arg.ty, ctx.module)) {
+                // We assert no error is possible here because any lazy values must be resolved
+                // before inserting into the generic function hash map.
+                const is_eql = Value.eqlAdvanced(
+                    this_arg.val,
+                    this_arg.ty,
+                    other_arg.val,
+                    other_arg.ty,
+                    ctx.module,
+                    null,
+                ) catch unreachable;
+                if (!is_eql) {
                     return false;
                 }
             }
@@ -6258,8 +6273,7 @@ fn instantiateGenericCall(
     var hasher = std.hash.Wyhash.init(0);
     std.hash.autoHash(&hasher, @ptrToInt(module_fn));
 
-    const comptime_tvs = try sema.arena.alloc(TypedValue, func_ty_info.param_types.len);
-
+    const generic_args = try sema.arena.alloc(GenericCallAdapter.Arg, func_ty_info.param_types.len);
     {
         var i: usize = 0;
         for (fn_info.param_body) |inst| {
@@ -6283,8 +6297,9 @@ fn instantiateGenericCall(
                 else => continue,
             }
 
+            const arg_ty = sema.typeOf(uncasted_args[i]);
+
             if (is_comptime) {
-                const arg_ty = sema.typeOf(uncasted_args[i]);
                 const arg_val = sema.analyzeGenericCallArgVal(block, .unneeded, uncasted_args[i]) catch |err| switch (err) {
                     error.NeededSourceLocation => {
                         const decl = sema.mod.declPtr(block.src_decl);
@@ -6297,27 +6312,30 @@ fn instantiateGenericCall(
                 arg_val.hash(arg_ty, &hasher, mod);
                 if (is_anytype) {
                     arg_ty.hashWithHasher(&hasher, mod);
-                    comptime_tvs[i] = .{
+                    generic_args[i] = .{
                         .ty = arg_ty,
                         .val = arg_val,
+                        .is_anytype = true,
                     };
                 } else {
-                    comptime_tvs[i] = .{
-                        .ty = Type.initTag(.generic_poison),
+                    generic_args[i] = .{
+                        .ty = arg_ty,
                         .val = arg_val,
+                        .is_anytype = false,
                     };
                 }
             } else if (is_anytype) {
-                const arg_ty = sema.typeOf(uncasted_args[i]);
                 arg_ty.hashWithHasher(&hasher, mod);
-                comptime_tvs[i] = .{
+                generic_args[i] = .{
                     .ty = arg_ty,
                     .val = Value.initTag(.generic_poison),
+                    .is_anytype = true,
                 };
             } else {
-                comptime_tvs[i] = .{
-                    .ty = Type.initTag(.generic_poison),
+                generic_args[i] = .{
+                    .ty = arg_ty,
                     .val = Value.initTag(.generic_poison),
+                    .is_anytype = false,
                 };
             }
 
@@ -6331,7 +6349,7 @@ fn instantiateGenericCall(
         .generic_fn = module_fn,
         .precomputed_hash = precomputed_hash,
         .func_ty_info = func_ty_info,
-        .comptime_tvs = comptime_tvs,
+        .args = generic_args,
         .module = mod,
     };
     const gop = try mod.monomorphed_funcs.getOrPutAdapted(gpa, {}, adapter);
@@ -30124,7 +30142,7 @@ fn valuesEqual(
     rhs: Value,
     ty: Type,
 ) CompileError!bool {
-    return Value.eqlAdvanced(lhs, rhs, ty, sema.mod, sema.kit(block, src));
+    return Value.eqlAdvanced(lhs, ty, rhs, ty, sema.mod, sema.kit(block, src));
 }
 
 /// Asserts the values are comparable vectors of type `ty`.
diff --git a/src/value.zig b/src/value.zig
index 677a459afe77a4af576060241d89dae2069a4e55..9909cab5ce535dcbcf73078e3a5fbb2932e2d9a5 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -2004,6 +2004,10 @@ pub const Value = extern union {
         return (try orderAgainstZeroAdvanced(lhs, sema_kit)).compare(op);
     }
 
+    pub fn eql(a: Value, b: Value, ty: Type, mod: *Module) bool {
+        return eqlAdvanced(a, ty, b, ty, mod, null) catch unreachable;
+    }
+
     /// This function is used by hash maps and so treats floating-point NaNs as equal
     /// to each other, and not equal to other floating-point values.
     /// Similarly, it treats `undef` as a distinct value from all other values.
@@ -2012,13 +2016,10 @@ pub const Value = extern union {
     /// for `a`. This function must act *as if* `a` has been coerced to `ty`. This complication
     /// is required in order to make generic function instantiation efficient - specifically
     /// the insertion into the monomorphized function table.
-    pub fn eql(a: Value, b: Value, ty: Type, mod: *Module) bool {
-        return eqlAdvanced(a, b, ty, mod, null) catch unreachable;
-    }
-
     /// If `null` is provided for `sema_kit` then it is guaranteed no error will be returned.
     pub fn eqlAdvanced(
         a: Value,
+        a_ty: Type,
         b: Value,
         ty: Type,
         mod: *Module,
@@ -2044,33 +2045,34 @@ pub const Value = extern union {
                 const a_payload = a.castTag(.opt_payload).?.data;
                 const b_payload = b.castTag(.opt_payload).?.data;
                 var buffer: Type.Payload.ElemType = undefined;
-                return eqlAdvanced(a_payload, b_payload, ty.optionalChild(&buffer), mod, sema_kit);
+                const payload_ty = ty.optionalChild(&buffer);
+                return eqlAdvanced(a_payload, payload_ty, b_payload, payload_ty, mod, sema_kit);
             },
             .slice => {
                 const a_payload = a.castTag(.slice).?.data;
                 const b_payload = b.castTag(.slice).?.data;
-                if (!(try eqlAdvanced(a_payload.len, b_payload.len, Type.usize, mod, sema_kit))) {
+                if (!(try eqlAdvanced(a_payload.len, Type.usize, b_payload.len, Type.usize, mod, sema_kit))) {
                     return false;
                 }
 
                 var ptr_buf: Type.SlicePtrFieldTypeBuffer = undefined;
                 const ptr_ty = ty.slicePtrFieldType(&ptr_buf);
 
-                return eqlAdvanced(a_payload.ptr, b_payload.ptr, ptr_ty, mod, sema_kit);
+                return eqlAdvanced(a_payload.ptr, ptr_ty, b_payload.ptr, ptr_ty, mod, sema_kit);
             },
             .elem_ptr => {
                 const a_payload = a.castTag(.elem_ptr).?.data;
                 const b_payload = b.castTag(.elem_ptr).?.data;
                 if (a_payload.index != b_payload.index) return false;
 
-                return eqlAdvanced(a_payload.array_ptr, b_payload.array_ptr, ty, mod, sema_kit);
+                return eqlAdvanced(a_payload.array_ptr, ty, b_payload.array_ptr, ty, mod, sema_kit);
             },
             .field_ptr => {
                 const a_payload = a.castTag(.field_ptr).?.data;
                 const b_payload = b.castTag(.field_ptr).?.data;
                 if (a_payload.field_index != b_payload.field_index) return false;
 
-                return eqlAdvanced(a_payload.container_ptr, b_payload.container_ptr, ty, mod, sema_kit);
+                return eqlAdvanced(a_payload.container_ptr, ty, b_payload.container_ptr, ty, mod, sema_kit);
             },
             .@"error" => {
                 const a_name = a.castTag(.@"error").?.data.name;
@@ -2080,7 +2082,8 @@ pub const Value = extern union {
             .eu_payload => {
                 const a_payload = a.castTag(.eu_payload).?.data;
                 const b_payload = b.castTag(.eu_payload).?.data;
-                return eqlAdvanced(a_payload, b_payload, ty.errorUnionPayload(), mod, sema_kit);
+                const payload_ty = ty.errorUnionPayload();
+                return eqlAdvanced(a_payload, payload_ty, b_payload, payload_ty, mod, sema_kit);
             },
             .eu_payload_ptr => @panic("TODO: Implement more pointer eql cases"),
             .opt_payload_ptr => @panic("TODO: Implement more pointer eql cases"),
@@ -2098,7 +2101,7 @@ pub const Value = extern union {
                     const types = ty.tupleFields().types;
                     assert(types.len == a_field_vals.len);
                     for (types) |field_ty, i| {
-                        if (!(try eqlAdvanced(a_field_vals[i], b_field_vals[i], field_ty, mod, sema_kit))) {
+                        if (!(try eqlAdvanced(a_field_vals[i], field_ty, b_field_vals[i], field_ty, mod, sema_kit))) {
                             return false;
                         }
                     }
@@ -2109,7 +2112,7 @@ pub const Value = extern union {
                     const fields = ty.structFields().values();
                     assert(fields.len == a_field_vals.len);
                     for (fields) |field, i| {
-                        if (!(try eqlAdvanced(a_field_vals[i], b_field_vals[i], field.ty, mod, sema_kit))) {
+                        if (!(try eqlAdvanced(a_field_vals[i], field.ty, b_field_vals[i], field.ty, mod, sema_kit))) {
                             return false;
                         }
                     }
@@ -2120,7 +2123,7 @@ pub const Value = extern union {
                 for (a_field_vals) |a_elem, i| {
                     const b_elem = b_field_vals[i];
 
-                    if (!(try eqlAdvanced(a_elem, b_elem, elem_ty, mod, sema_kit))) {
+                    if (!(try eqlAdvanced(a_elem, elem_ty, b_elem, elem_ty, mod, sema_kit))) {
                         return false;
                     }
                 }
@@ -2132,7 +2135,7 @@ pub const Value = extern union {
                 switch (ty.containerLayout()) {
                     .Packed, .Extern => {
                         const tag_ty = ty.unionTagTypeHypothetical();
-                        if (!(try a_union.tag.eqlAdvanced(b_union.tag, tag_ty, mod, sema_kit))) {
+                        if (!(try eqlAdvanced(a_union.tag, tag_ty, b_union.tag, tag_ty, mod, sema_kit))) {
                             // In this case, we must disregard mismatching tags and compare
                             // based on the in-memory bytes of the payloads.
                             @panic("TODO comptime comparison of extern union values with mismatching tags");
@@ -2140,13 +2143,13 @@ pub const Value = extern union {
                     },
                     .Auto => {
                         const tag_ty = ty.unionTagTypeHypothetical();
-                        if (!(try a_union.tag.eqlAdvanced(b_union.tag, tag_ty, mod, sema_kit))) {
+                        if (!(try eqlAdvanced(a_union.tag, tag_ty, b_union.tag, tag_ty, mod, sema_kit))) {
                             return false;
                         }
                     },
                 }
                 const active_field_ty = ty.unionFieldType(a_union.tag, mod);
-                return a_union.val.eqlAdvanced(b_union.val, active_field_ty, mod, sema_kit);
+                return eqlAdvanced(a_union.val, active_field_ty, b_union.val, active_field_ty, mod, sema_kit);
             },
             else => {},
         } else if (a_tag == .null_value or b_tag == .null_value) {
@@ -2180,7 +2183,7 @@ pub const Value = extern union {
                 const b_val = b.enumToInt(ty, &buf_b);
                 var buf_ty: Type.Payload.Bits = undefined;
                 const int_ty = ty.intTagType(&buf_ty);
-                return eqlAdvanced(a_val, b_val, int_ty, mod, sema_kit);
+                return eqlAdvanced(a_val, int_ty, b_val, int_ty, mod, sema_kit);
             },
             .Array, .Vector => {
                 const len = ty.arrayLen();
@@ -2191,17 +2194,44 @@ pub const Value = extern union {
                 while (i < len) : (i += 1) {
                     const a_elem = elemValueBuffer(a, mod, i, &a_buf);
                     const b_elem = elemValueBuffer(b, mod, i, &b_buf);
-                    if (!(try eqlAdvanced(a_elem, b_elem, elem_ty, mod, sema_kit))) {
+                    if (!(try eqlAdvanced(a_elem, elem_ty, b_elem, elem_ty, mod, sema_kit))) {
                         return false;
                     }
                 }
                 return true;
             },
             .Struct => {
-                // A tuple can be represented with .empty_struct_value,
-                // the_one_possible_value, .aggregate in which case we could
-                // end up here and the values are equal if the type has zero fields.
-                return ty.isTupleOrAnonStruct() and ty.structFieldCount() != 0;
+                // A struct can be represented with one of:
+                //   .empty_struct_value,
+                //   .the_one_possible_value,
+                //   .aggregate,
+                // Note that we already checked above for matching tags, e.g. both .aggregate.
+                return ty.onePossibleValue() != null;
+            },
+            .Union => {
+                // Here we have to check for value equality, as-if `a` has been coerced to `ty`.
+                if (ty.onePossibleValue() != null) {
+                    return true;
+                }
+                if (a_ty.castTag(.anon_struct)) |payload| {
+                    const tuple = payload.data;
+                    if (tuple.values.len != 1) {
+                        return false;
+                    }
+                    const field_name = tuple.names[0];
+                    const union_obj = ty.cast(Type.Payload.Union).?.data;
+                    const field_index = union_obj.fields.getIndex(field_name) orelse return false;
+                    const tag_and_val = b.castTag(.@"union").?.data;
+                    var field_tag_buf: Value.Payload.U32 = .{
+                        .base = .{ .tag = .enum_field_index },
+                        .data = @intCast(u32, field_index),
+                    };
+                    const field_tag = Value.initPayload(&field_tag_buf.base);
+                    const tag_matches = tag_and_val.tag.eql(field_tag, union_obj.tag_ty, mod);
+                    if (!tag_matches) return false;
+                    return eqlAdvanced(tag_and_val.val, union_obj.tag_ty, tuple.values[0], tuple.types[0], mod, sema_kit);
+                }
+                return false;
             },
             .Float => {
                 switch (ty.floatBits(target)) {
@@ -2230,7 +2260,8 @@ pub const Value = extern union {
                         .base = .{ .tag = .opt_payload },
                         .data = a,
                     };
-                    return eqlAdvanced(Value.initPayload(&buffer.base), b, ty, mod, sema_kit);
+                    const opt_val = Value.initPayload(&buffer.base);
+                    return eqlAdvanced(opt_val, ty, b, ty, mod, sema_kit);
                 }
             },
             else => {},
diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig
index cd4e018be3a4751698ba7be10f0ab0ff12dffab8..d930fb7d27d1369544d166f22948705d19c2da64 100644
--- a/test/behavior/generics.zig
+++ b/test/behavior/generics.zig
@@ -323,3 +323,22 @@ test "generic function instantiation non-duplicates" {
     S.copy(u8, &buffer, "hello");
     S.copy(u8, &buffer, "hello2");
 }
+
+test "generic instantiation of tagged union with only one field" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.os.tag == .wasi) return error.SkipZigTest;
+
+    const S = struct {
+        const U = union(enum) {
+            s: []const u8,
+        };
+
+        fn foo(comptime u: U) usize {
+            return u.s.len;
+        }
+    };
+
+    try expect(S.foo(.{ .s = "a" }) == 1);
+    try expect(S.foo(.{ .s = "ab" }) == 2);
+}
-- 
2.54.0


From 233049503a41ac4c6895f7126cda63349606b8f8 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 17 Aug 2022 16:10:46 +0300
Subject: [PATCH 135/290] Sema: allow empty enums and unions

---
 src/AstGen.zig                                |   9 -
 src/Sema.zig                                  | 168 +++++++++---------
 src/print_zir.zig                             |  15 +-
 src/type.zig                                  |   5 +-
 test/behavior.zig                             |   1 +
 test/behavior/empty_union.zig                 |  54 ++++++
 .../compile_errors/enum_with_0_fields.zig     |   7 -
 ...e_for_exhaustive_enum_with_zero_fields.zig |  18 --
 .../reify_type_for_union_with_zero_fields.zig |  17 --
 .../union_fields_with_value_assignments.zig   |   7 -
 .../compile_errors/union_with_0_fields.zig    |   7 -
 ...types_in_function_call_raises_an_error.zig |  11 --
 test/stage2/cbe.zig                           |   9 -
 13 files changed, 153 insertions(+), 175 deletions(-)
 create mode 100644 test/behavior/empty_union.zig
 delete mode 100644 test/cases/compile_errors/enum_with_0_fields.zig
 delete mode 100644 test/cases/compile_errors/reify_type_for_exhaustive_enum_with_zero_fields.zig
 delete mode 100644 test/cases/compile_errors/reify_type_for_union_with_zero_fields.zig
 delete mode 100644 test/cases/compile_errors/union_fields_with_value_assignments.zig
 delete mode 100644 test/cases/compile_errors/union_with_0_fields.zig
 delete mode 100644 test/cases/compile_errors/using_invalid_types_in_function_call_raises_an_error.zig

diff --git a/src/AstGen.zig b/src/AstGen.zig
index 2fcd8cd9947e332a66c3beb68131b6cabf098afd..ee1dbeffa44d48eb44fc0ce761b663c22646d12d 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -4557,9 +4557,6 @@ fn unionDeclInner(
             wip_members.appendToField(@enumToInt(tag_value));
         }
     }
-    if (field_count == 0) {
-        return astgen.failNode(node, "union declarations must have at least one tag", .{});
-    }
 
     if (!block_scope.isEmpty()) {
         _ = try block_scope.addBreak(.break_inline, decl_inst, .void_value);
@@ -4715,12 +4712,6 @@ fn containerDecl(
                     .nonexhaustive_node = nonexhaustive_node,
                 };
             };
-            if (counts.total_fields == 0 and counts.nonexhaustive_node == 0) {
-                // One can construct an enum with no tags, and it functions the same as `noreturn`. But
-                // this is only useful for generic code; when explicitly using `enum {}` syntax, there
-                // must be at least one tag.
-                try astgen.appendErrorNode(node, "enum declarations must have at least one tag", .{});
-            }
             if (counts.nonexhaustive_node != 0 and container_decl.ast.arg == 0) {
                 try astgen.appendErrorNodeNotes(
                     node,
diff --git a/src/Sema.zig b/src/Sema.zig
index 1aebe8e98eb0bdfa1c2e9e6a58774a75ae62435a..1a0ded4a0015c40d33b639f0f2899d43466b3c62 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -8979,6 +8979,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     var seen_union_fields: []?Module.SwitchProngSrc = &.{};
     defer gpa.free(seen_union_fields);
 
+    var empty_enum = false;
+
     const operand_ty = sema.typeOf(operand);
 
     var else_error_ty: ?Type = null;
@@ -9012,6 +9014,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         .Union => unreachable, // handled in zirSwitchCond
         .Enum => {
             var seen_fields = try gpa.alloc(?Module.SwitchProngSrc, operand_ty.enumFieldCount());
+            empty_enum = seen_fields.len == 0 and !operand_ty.isNonexhaustiveEnum();
             defer if (!union_originally) gpa.free(seen_fields);
             if (union_originally) seen_union_fields = seen_fields;
             mem.set(?Module.SwitchProngSrc, seen_fields, null);
@@ -9607,6 +9610,9 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     }
 
     if (scalar_cases_len + multi_cases_len == 0) {
+        if (empty_enum) {
+            return Air.Inst.Ref.void_value;
+        }
         if (special_prong == .none) {
             return sema.fail(block, src, "switch must handle all possibilities", .{});
         }
@@ -16690,43 +16696,39 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
 
             // Fields
             const fields_len = try sema.usizeCast(block, src, fields_val.sliceLen(mod));
-            if (fields_len > 0) {
-                try enum_obj.fields.ensureTotalCapacity(new_decl_arena_allocator, fields_len);
-                try enum_obj.values.ensureTotalCapacityContext(new_decl_arena_allocator, fields_len, .{
+            try enum_obj.fields.ensureTotalCapacity(new_decl_arena_allocator, fields_len);
+            try enum_obj.values.ensureTotalCapacityContext(new_decl_arena_allocator, fields_len, .{
+                .ty = enum_obj.tag_ty,
+                .mod = mod,
+            });
+
+            var i: usize = 0;
+            while (i < fields_len) : (i += 1) {
+                const elem_val = try fields_val.elemValue(sema.mod, sema.arena, i);
+                const field_struct_val = elem_val.castTag(.aggregate).?.data;
+                // TODO use reflection instead of magic numbers here
+                // name: []const u8
+                const name_val = field_struct_val[0];
+                // value: comptime_int
+                const value_val = field_struct_val[1];
+
+                const field_name = try name_val.toAllocatedBytes(
+                    Type.initTag(.const_slice_u8),
+                    new_decl_arena_allocator,
+                    sema.mod,
+                );
+
+                const gop = enum_obj.fields.getOrPutAssumeCapacity(field_name);
+                if (gop.found_existing) {
+                    // TODO: better source location
+                    return sema.fail(block, src, "duplicate enum tag {s}", .{field_name});
+                }
+
+                const copied_tag_val = try value_val.copy(new_decl_arena_allocator);
+                enum_obj.values.putAssumeCapacityNoClobberContext(copied_tag_val, {}, .{
                     .ty = enum_obj.tag_ty,
                     .mod = mod,
                 });
-
-                var i: usize = 0;
-                while (i < fields_len) : (i += 1) {
-                    const elem_val = try fields_val.elemValue(sema.mod, sema.arena, i);
-                    const field_struct_val = elem_val.castTag(.aggregate).?.data;
-                    // TODO use reflection instead of magic numbers here
-                    // name: []const u8
-                    const name_val = field_struct_val[0];
-                    // value: comptime_int
-                    const value_val = field_struct_val[1];
-
-                    const field_name = try name_val.toAllocatedBytes(
-                        Type.initTag(.const_slice_u8),
-                        new_decl_arena_allocator,
-                        sema.mod,
-                    );
-
-                    const gop = enum_obj.fields.getOrPutAssumeCapacity(field_name);
-                    if (gop.found_existing) {
-                        // TODO: better source location
-                        return sema.fail(block, src, "duplicate enum tag {s}", .{field_name});
-                    }
-
-                    const copied_tag_val = try value_val.copy(new_decl_arena_allocator);
-                    enum_obj.values.putAssumeCapacityNoClobberContext(copied_tag_val, {}, .{
-                        .ty = enum_obj.tag_ty,
-                        .mod = mod,
-                    });
-                }
-            } else {
-                return sema.fail(block, src, "enums must have at least one field", .{});
             }
 
             try new_decl.finalizeNewArena(&new_decl_arena);
@@ -16851,58 +16853,54 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
             }
 
             // Fields
-            if (fields_len > 0) {
-                try union_obj.fields.ensureTotalCapacity(new_decl_arena_allocator, fields_len);
+            try union_obj.fields.ensureTotalCapacity(new_decl_arena_allocator, fields_len);
 
-                var i: usize = 0;
-                while (i < fields_len) : (i += 1) {
-                    const elem_val = try fields_val.elemValue(sema.mod, sema.arena, i);
-                    const field_struct_val = elem_val.castTag(.aggregate).?.data;
-                    // TODO use reflection instead of magic numbers here
-                    // name: []const u8
-                    const name_val = field_struct_val[0];
-                    // field_type: type,
-                    const field_type_val = field_struct_val[1];
-                    // alignment: comptime_int,
-                    const alignment_val = field_struct_val[2];
+            var i: usize = 0;
+            while (i < fields_len) : (i += 1) {
+                const elem_val = try fields_val.elemValue(sema.mod, sema.arena, i);
+                const field_struct_val = elem_val.castTag(.aggregate).?.data;
+                // TODO use reflection instead of magic numbers here
+                // name: []const u8
+                const name_val = field_struct_val[0];
+                // field_type: type,
+                const field_type_val = field_struct_val[1];
+                // alignment: comptime_int,
+                const alignment_val = field_struct_val[2];
 
-                    const field_name = try name_val.toAllocatedBytes(
-                        Type.initTag(.const_slice_u8),
-                        new_decl_arena_allocator,
-                        sema.mod,
-                    );
+                const field_name = try name_val.toAllocatedBytes(
+                    Type.initTag(.const_slice_u8),
+                    new_decl_arena_allocator,
+                    sema.mod,
+                );
 
-                    if (enum_field_names) |set| {
-                        set.putAssumeCapacity(field_name, {});
-                    }
-
-                    if (tag_ty_field_names) |*names| {
-                        const enum_has_field = names.orderedRemove(field_name);
-                        if (!enum_has_field) {
-                            const msg = msg: {
-                                const msg = try sema.errMsg(block, src, "no field named '{s}' in enum '{}'", .{ field_name, union_obj.tag_ty.fmt(sema.mod) });
-                                errdefer msg.destroy(sema.gpa);
-                                try sema.addDeclaredHereNote(msg, union_obj.tag_ty);
-                                break :msg msg;
-                            };
-                            return sema.failWithOwnedErrorMsg(msg);
-                        }
-                    }
+                if (enum_field_names) |set| {
+                    set.putAssumeCapacity(field_name, {});
+                }
 
-                    const gop = union_obj.fields.getOrPutAssumeCapacity(field_name);
-                    if (gop.found_existing) {
-                        // TODO: better source location
-                        return sema.fail(block, src, "duplicate union field {s}", .{field_name});
+                if (tag_ty_field_names) |*names| {
+                    const enum_has_field = names.orderedRemove(field_name);
+                    if (!enum_has_field) {
+                        const msg = msg: {
+                            const msg = try sema.errMsg(block, src, "no field named '{s}' in enum '{}'", .{ field_name, union_obj.tag_ty.fmt(sema.mod) });
+                            errdefer msg.destroy(sema.gpa);
+                            try sema.addDeclaredHereNote(msg, union_obj.tag_ty);
+                            break :msg msg;
+                        };
+                        return sema.failWithOwnedErrorMsg(msg);
                     }
+                }
 
-                    var buffer: Value.ToTypeBuffer = undefined;
-                    gop.value_ptr.* = .{
-                        .ty = try field_type_val.toType(&buffer).copy(new_decl_arena_allocator),
-                        .abi_align = @intCast(u32, alignment_val.toUnsignedInt(target)),
-                    };
+                const gop = union_obj.fields.getOrPutAssumeCapacity(field_name);
+                if (gop.found_existing) {
+                    // TODO: better source location
+                    return sema.fail(block, src, "duplicate union field {s}", .{field_name});
                 }
-            } else {
-                return sema.fail(block, src, "unions must have at least one field", .{});
+
+                var buffer: Value.ToTypeBuffer = undefined;
+                gop.value_ptr.* = .{
+                    .ty = try field_type_val.toType(&buffer).copy(new_decl_arena_allocator),
+                    .abi_align = @intCast(u32, alignment_val.toUnsignedInt(target)),
+                };
             }
 
             if (tag_ty_field_names) |names| {
@@ -28146,10 +28144,6 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
     extra_index = decls_it.extra_index;
 
     const body = zir.extra[extra_index..][0..body_len];
-    if (fields_len == 0) {
-        assert(body.len == 0);
-        return;
-    }
     extra_index += body.len;
 
     const decl = mod.declPtr(decl_index);
@@ -28237,6 +28231,10 @@ fn semaUnionFields(mod: *Module, union_obj: *Module.Union) CompileError!void {
         enum_field_names = &union_obj.tag_ty.castTag(.enum_simple).?.data.fields;
     }
 
+    if (fields_len == 0) {
+        return;
+    }
+
     const bits_per_field = 4;
     const fields_per_u32 = 32 / bits_per_field;
     const bit_bags_count = std.math.divCeil(usize, fields_len, fields_per_u32) catch unreachable;
@@ -28772,7 +28770,9 @@ pub fn typeHasOnePossibleValue(
             const union_obj = resolved_ty.cast(Type.Payload.Union).?.data;
             const tag_val = (try sema.typeHasOnePossibleValue(block, src, union_obj.tag_ty)) orelse
                 return null;
-            const only_field = union_obj.fields.values()[0];
+            const fields = union_obj.fields.values();
+            if (fields.len == 0) return Value.initTag(.empty_struct_value);
+            const only_field = fields[0];
             if (only_field.ty.eql(resolved_ty, sema.mod)) {
                 const msg = try Module.ErrorMsg.create(
                     sema.gpa,
diff --git a/src/print_zir.zig b/src/print_zir.zig
index 4bc96c42591cf6e01c66bde67c3305e21b76535d..579a7970b7de5a0a716f6941204f6bce66d6d609 100644
--- a/src/print_zir.zig
+++ b/src/print_zir.zig
@@ -1443,7 +1443,7 @@ const Writer = struct {
         try self.writeFlag(stream, "autoenum, ", small.auto_enum_tag);
 
         if (decls_len == 0) {
-            try stream.writeAll("{}, ");
+            try stream.writeAll("{}");
         } else {
             const prev_parent_decl_node = self.parent_decl_node;
             if (src_node) |off| self.parent_decl_node = self.relativeToNodeIndex(off);
@@ -1454,16 +1454,21 @@ const Writer = struct {
             extra_index = try self.writeDecls(stream, decls_len, extra_index);
             self.indent -= 2;
             try stream.writeByteNTimes(' ', self.indent);
-            try stream.writeAll("}, ");
+            try stream.writeAll("}");
         }
 
-        assert(fields_len != 0);
-
         if (tag_type_ref != .none) {
-            try self.writeInstRef(stream, tag_type_ref);
             try stream.writeAll(", ");
+            try self.writeInstRef(stream, tag_type_ref);
         }
 
+        if (fields_len == 0) {
+            try stream.writeAll("})");
+            try self.writeSrcNode(stream, src_node);
+            return;
+        }
+        try stream.writeAll(", ");
+
         const body = self.code.extra[extra_index..][0..body_len];
         extra_index += body.len;
 
diff --git a/src/type.zig b/src/type.zig
index 582ea230ef99fb64f2cd040ada393840bdda58a9..55847b8adda6a68efbda6ce9f020ecdcd6679ef7 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -2488,7 +2488,7 @@ pub const Type = extern union {
             },
             .union_safety_tagged, .union_tagged => {
                 const union_obj = ty.cast(Payload.Union).?.data;
-                if (try union_obj.tag_ty.hasRuntimeBitsAdvanced(ignore_comptime_only, sema_kit)) {
+                if (union_obj.fields.count() > 0 and try union_obj.tag_ty.hasRuntimeBitsAdvanced(ignore_comptime_only, sema_kit)) {
                     return true;
                 }
                 if (sema_kit) |sk| {
@@ -3113,6 +3113,9 @@ pub const Type = extern union {
             .sema_kit => unreachable, // handled above
             .lazy => |arena| return AbiAlignmentAdvanced{ .val = try Value.Tag.lazy_align.create(arena, ty) },
         };
+        if (union_obj.fields.count() == 0) {
+            return AbiAlignmentAdvanced{ .scalar = @boolToInt(union_obj.layout == .Extern) };
+        }
 
         var max_align: u32 = 0;
         if (have_tag) max_align = union_obj.tag_ty.abiAlignment(target);
diff --git a/test/behavior.zig b/test/behavior.zig
index 40f8ca0fb3800fafe4d21156fc8c1c3c470c01c7..ba8379cd723b85ae2af0a51580ec5893d2d35db0 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -167,6 +167,7 @@ test {
     if (builtin.zig_backend != .stage1) {
         _ = @import("behavior/decltest.zig");
         _ = @import("behavior/packed_struct_explicit_backing_int.zig");
+        _ = @import("behavior/empty_union.zig");
     }
 
     if (builtin.os.tag != .wasi) {
diff --git a/test/behavior/empty_union.zig b/test/behavior/empty_union.zig
new file mode 100644
index 0000000000000000000000000000000000000000..051e464b72a1f1b09135108b718680b374b5d621
--- /dev/null
+++ b/test/behavior/empty_union.zig
@@ -0,0 +1,54 @@
+const builtin = @import("builtin");
+const std = @import("std");
+const expect = std.testing.expect;
+
+test "switch on empty enum" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+
+    const E = enum {};
+    var e: E = undefined;
+    switch (e) {}
+}
+
+test "switch on empty enum with a specified tag type" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+
+    const E = enum(u8) {};
+    var e: E = undefined;
+    switch (e) {}
+}
+
+test "switch on empty auto numbered tagged union" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+
+    const U = union(enum(u8)) {};
+    var u: U = undefined;
+    switch (u) {}
+}
+
+test "switch on empty tagged union" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+
+    const E = enum {};
+    const U = union(E) {};
+    var u: U = undefined;
+    switch (u) {}
+}
+
+test "empty union" {
+    const U = union {};
+    try expect(@sizeOf(U) == 0);
+    try expect(@alignOf(U) == 0);
+}
+
+test "empty extern union" {
+    const U = extern union {};
+    try expect(@sizeOf(U) == 0);
+    try expect(@alignOf(U) == 1);
+}
diff --git a/test/cases/compile_errors/enum_with_0_fields.zig b/test/cases/compile_errors/enum_with_0_fields.zig
deleted file mode 100644
index f34065b69d6b6426c3b5312c4517d58b730444a0..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/enum_with_0_fields.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-const Foo = enum {};
-
-// error
-// backend=stage2
-// target=native
-//
-// :1:13: error: enum declarations must have at least one tag
diff --git a/test/cases/compile_errors/reify_type_for_exhaustive_enum_with_zero_fields.zig b/test/cases/compile_errors/reify_type_for_exhaustive_enum_with_zero_fields.zig
deleted file mode 100644
index 44876e938af0eff4aef0836ba910bb5d3082a3c3..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/reify_type_for_exhaustive_enum_with_zero_fields.zig
+++ /dev/null
@@ -1,18 +0,0 @@
-const Tag = @Type(.{
-    .Enum = .{
-        .layout = .Auto,
-        .tag_type = u1,
-        .fields = &.{},
-        .decls = &.{},
-        .is_exhaustive = true,
-    },
-});
-export fn entry() void {
-    _ = @intToEnum(Tag, 0);
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :1:13: error: enums must have at least one field
diff --git a/test/cases/compile_errors/reify_type_for_union_with_zero_fields.zig b/test/cases/compile_errors/reify_type_for_union_with_zero_fields.zig
deleted file mode 100644
index 0b4f395c8182c9977643adb2f7d3761e72ad39bf..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/reify_type_for_union_with_zero_fields.zig
+++ /dev/null
@@ -1,17 +0,0 @@
-const Untagged = @Type(.{
-    .Union = .{
-        .layout = .Auto,
-        .tag_type = null,
-        .fields = &.{},
-        .decls = &.{},
-    },
-});
-export fn entry() void {
-    _ = Untagged{};
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :1:18: error: unions must have at least one field
diff --git a/test/cases/compile_errors/union_fields_with_value_assignments.zig b/test/cases/compile_errors/union_fields_with_value_assignments.zig
deleted file mode 100644
index 2121568dd20f610e6159106c029745c4946bb5e5..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/union_fields_with_value_assignments.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-const Foo = union {};
-
-// error
-// backend=stage2
-// target=native
-//
-// :1:13: error: union declarations must have at least one tag
diff --git a/test/cases/compile_errors/union_with_0_fields.zig b/test/cases/compile_errors/union_with_0_fields.zig
deleted file mode 100644
index 2121568dd20f610e6159106c029745c4946bb5e5..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/union_with_0_fields.zig
+++ /dev/null
@@ -1,7 +0,0 @@
-const Foo = union {};
-
-// error
-// backend=stage2
-// target=native
-//
-// :1:13: error: union declarations must have at least one tag
diff --git a/test/cases/compile_errors/using_invalid_types_in_function_call_raises_an_error.zig b/test/cases/compile_errors/using_invalid_types_in_function_call_raises_an_error.zig
deleted file mode 100644
index ee6d1b8b7c90762621d0c8c082116543f8e60332..0000000000000000000000000000000000000000
--- a/test/cases/compile_errors/using_invalid_types_in_function_call_raises_an_error.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const MenuEffect = enum {};
-fn func(effect: MenuEffect) void { _ = effect; }
-export fn entry() void {
-    func(MenuEffect.ThisDoesNotExist);
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :1:20: error: enum declarations must have at least one tag
diff --git a/test/stage2/cbe.zig b/test/stage2/cbe.zig
index 644cba74c1303b58c95546ed1ea5f29f733bdd9f..321de1e3f67a83867c2608ef0193843b691b8113 100644
--- a/test/stage2/cbe.zig
+++ b/test/stage2/cbe.zig
@@ -704,15 +704,6 @@ pub fn addCases(ctx: *TestContext) !void {
             ":5:9: error: '_' is used to mark an enum as non-exhaustive and cannot be assigned a value",
         });
 
-        case.addError(
-            \\const E1 = enum {};
-            \\export fn foo() void {
-            \\    _ = E1.a;
-            \\}
-        , &.{
-            ":1:12: error: enum declarations must have at least one tag",
-        });
-
         case.addError(
             \\const E1 = enum { a, b, _ };
             \\export fn foo() void {
-- 
2.54.0


From 070282a96ec23fb41041843d5753608ec5090f8b Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Wed, 17 Aug 2022 16:58:16 +0200
Subject: [PATCH 136/290] libstd: fix off-by-one error in def of ProcSym in pdb

Make sure `ProcSym` includes a single element byte-array which delimits
the start of the symbol's name as part of its definition. This makes
the code more elegant in that accessing the name is equivalent to taking
the address of this one element array.
---
 lib/std/pdb.zig       | 9 ++++++---
 test/stack_traces.zig | 7 +------
 2 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/lib/std/pdb.zig b/lib/std/pdb.zig
index a44296c9209e81fe2d91159609cf37000846460f..00ce2cc5baab19b3704d4713bfa9d8d1793bb13b 100644
--- a/lib/std/pdb.zig
+++ b/lib/std/pdb.zig
@@ -310,6 +310,10 @@ pub const SymbolKind = enum(u16) {
 
 pub const TypeIndex = u32;
 
+// TODO According to this header:
+// https://github.com/microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/include/cvinfo.h#L3722
+// we should define RecordPrefix as part of the ProcSym structure.
+// This might be important when we start generating PDB in self-hosted with our own PE linker.
 pub const ProcSym = extern struct {
     Parent: u32,
     End: u32,
@@ -321,8 +325,7 @@ pub const ProcSym = extern struct {
     CodeOffset: u32,
     Segment: u16,
     Flags: ProcSymFlags,
-    // following is a null terminated string
-    // Name: [*]u8,
+    Name: [1]u8, // null-terminated
 };
 
 pub const ProcSymFlags = packed struct {
@@ -693,7 +696,7 @@ pub const Pdb = struct {
                 .S_LPROC32, .S_GPROC32 => {
                     const proc_sym = @ptrCast(*align(1) ProcSym, &module.symbols[symbol_i + @sizeOf(RecordPrefix)]);
                     if (address >= proc_sym.CodeOffset and address < proc_sym.CodeOffset + proc_sym.CodeSize) {
-                        return mem.sliceTo(@ptrCast([*:0]u8, proc_sym) + @sizeOf(ProcSym), 0);
+                        return mem.sliceTo(@ptrCast([*:0]u8, &proc_sym.Name[0]), 0);
                     }
                 },
                 else => {},
diff --git a/test/stack_traces.zig b/test/stack_traces.zig
index e514e0fd881a419893cb9dacf56928c891fa171f..06534a2f7e45c489a0ca08a85396cfe00395865f 100644
--- a/test/stack_traces.zig
+++ b/test/stack_traces.zig
@@ -3,11 +3,6 @@ const os = std.os;
 const tests = @import("tests.zig");
 
 pub fn addCases(cases: *tests.StackTracesContext) void {
-    if (@import("builtin").os.tag == .windows) {
-        // https://github.com/ziglang/zig/issues/12422
-        return;
-    }
-
     cases.addCase(.{
         .name = "return",
         .source = 
@@ -178,7 +173,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
     cases.addCase(.{
         .exclude_os = .{
             .openbsd, // integer overflow
-            .windows,
+            .windows, // TODO intermittent failures
         },
         .name = "dumpCurrentStackTrace",
         .source = 
-- 
2.54.0


From 07f64a2e13ab80acffba7f7bdd5d7c58df7893c0 Mon Sep 17 00:00:00 2001
From: Martin Hafskjold Thoresen <git@mht.wtf>
Date: Wed, 10 Aug 2022 23:32:02 +0200
Subject: [PATCH 137/290] Sema: error on ambiguous coercion of comptime float
 and ints

The following, from the documentation as of the time of writing, illustrates
the problem:

```zig
// Compile time coercion of float to int
test "implicit cast to comptime_int" {
    var f: f32 = 54.0 / 5;
    _ = f;
}
```

It is not clear how to unify the types of 54.0 and 5 to perform the
division. We can either

 - cast 54.0 to comptime_int resulting in @as(comptime_int, 10), which is
   casted to @as(f32, 10), or
 - cast 5 to comptime_float resulting in @as(comptime_float, 10.8), which
   is casted to @as(f32, 10.8)

Since the two resulting values are different, a compiler error is appropriate.

If we know that casting to either type will result in the same value we
don't need to error.  For instance, 10.0 / 2 is okay, as is 10 / 2.0.

Fixes: #12364
---
 src/Sema.zig              | 16 ++++++++++++++++
 test/behavior/floatop.zig |  8 ++++----
 2 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index f1d140520cc1588676f11f4079b05c62003ed1ea..e5700a6fe4c20b55e4506150acc466e6fb83eb95 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -11202,6 +11202,22 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(block, lhs_src, casted_lhs);
     const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(block, rhs_src, casted_rhs);
 
+    if ((lhs_ty.tag() == .comptime_float and rhs_ty.tag() == .comptime_int) or
+        (lhs_ty.tag() == .comptime_int and rhs_ty.tag() == .comptime_float))
+    {
+        // If it makes a difference whether we coerce to ints or floats before doing the division, error.
+        // If lhs % rhs is 0, it doesn't matter.
+        var lhs_val = maybe_lhs_val orelse unreachable;
+        var rhs_val = maybe_rhs_val orelse unreachable;
+        var rem = lhs_val.floatRem(rhs_val, resolved_type, sema.arena, target) catch unreachable;
+        var float_rem = rem.toFloat(f32);
+        if (float_rem != 0.0) {
+            return sema.fail(block, src, "ambiguous coercion of division operands: '{s}' and '{s}': division has non-zero reminder: {d}", .{
+                @tagName(lhs_ty.tag()), @tagName(rhs_ty.tag()), float_rem,
+            });
+        }
+    }
+
     // TODO: emit compile error when .div is used on integers and there would be an
     // ambiguous result between div_floor and div_trunc.
 
diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig
index c057f7a8426bd1049b34a05e2b0a52b614ef79cd..a5eb25d4f5b96bd201208d60fcc1b2ff5d642284 100644
--- a/test/behavior/floatop.zig
+++ b/test/behavior/floatop.zig
@@ -194,8 +194,8 @@ fn testSin() !void {
         const eps = epsForType(ty);
         try expect(@sin(@as(ty, 0)) == 0);
         try expect(math.approxEqAbs(ty, @sin(@as(ty, std.math.pi)), 0, eps));
-        try expect(math.approxEqAbs(ty, @sin(@as(ty, std.math.pi / 2)), 1, eps));
-        try expect(math.approxEqAbs(ty, @sin(@as(ty, std.math.pi / 4)), 0.7071067811865475, eps));
+        try expect(math.approxEqAbs(ty, @sin(@as(ty, std.math.pi / 2.0)), 1, eps));
+        try expect(math.approxEqAbs(ty, @sin(@as(ty, std.math.pi / 4.0)), 0.7071067811865475, eps));
     }
 
     {
@@ -228,8 +228,8 @@ fn testCos() !void {
         const eps = epsForType(ty);
         try expect(@cos(@as(ty, 0)) == 1);
         try expect(math.approxEqAbs(ty, @cos(@as(ty, std.math.pi)), -1, eps));
-        try expect(math.approxEqAbs(ty, @cos(@as(ty, std.math.pi / 2)), 0, eps));
-        try expect(math.approxEqAbs(ty, @cos(@as(ty, std.math.pi / 4)), 0.7071067811865475, eps));
+        try expect(math.approxEqAbs(ty, @cos(@as(ty, std.math.pi / 2.0)), 0, eps));
+        try expect(math.approxEqAbs(ty, @cos(@as(ty, std.math.pi / 4.0)), 0.7071067811865475, eps));
     }
 
     {
-- 
2.54.0


From 59b6483d63ca68f63c0b3758e80da918629ada2c Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Tue, 16 Aug 2022 16:17:56 +0300
Subject: [PATCH 138/290] add test

---
 src/Sema.zig                                  | 17 +++++++------
 ...mbiguous_coercion_of_division_operands.zig | 24 +++++++++++++++++++
 2 files changed, 32 insertions(+), 9 deletions(-)
 create mode 100644 test/cases/compile_errors/ambiguous_coercion_of_division_operands.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index e5700a6fe4c20b55e4506150acc466e6fb83eb95..29a53ebb2a7283206b659f6e8700cece0f6d9850 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -11202,18 +11202,17 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(block, lhs_src, casted_lhs);
     const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(block, rhs_src, casted_rhs);
 
-    if ((lhs_ty.tag() == .comptime_float and rhs_ty.tag() == .comptime_int) or
-        (lhs_ty.tag() == .comptime_int and rhs_ty.tag() == .comptime_float))
+    if ((lhs_ty.zigTypeTag() == .ComptimeFloat and rhs_ty.zigTypeTag() == .ComptimeInt) or
+        (lhs_ty.zigTypeTag() == .ComptimeInt and rhs_ty.zigTypeTag() == .ComptimeFloat))
     {
         // If it makes a difference whether we coerce to ints or floats before doing the division, error.
         // If lhs % rhs is 0, it doesn't matter.
-        var lhs_val = maybe_lhs_val orelse unreachable;
-        var rhs_val = maybe_rhs_val orelse unreachable;
-        var rem = lhs_val.floatRem(rhs_val, resolved_type, sema.arena, target) catch unreachable;
-        var float_rem = rem.toFloat(f32);
-        if (float_rem != 0.0) {
-            return sema.fail(block, src, "ambiguous coercion of division operands: '{s}' and '{s}': division has non-zero reminder: {d}", .{
-                @tagName(lhs_ty.tag()), @tagName(rhs_ty.tag()), float_rem,
+        const lhs_val = maybe_lhs_val orelse unreachable;
+        const rhs_val = maybe_rhs_val orelse unreachable;
+        const rem = lhs_val.floatRem(rhs_val, resolved_type, sema.arena, target) catch unreachable;
+        if (rem.compareWithZero(.neq)) {
+            return sema.fail(block, src, "ambiguous coercion of division operands '{s}' and '{s}'; division has non-zero reminder '{}'", .{
+                @tagName(lhs_ty.tag()), @tagName(rhs_ty.tag()), rem.fmtValue(resolved_type, sema.mod),
             });
         }
     }
diff --git a/test/cases/compile_errors/ambiguous_coercion_of_division_operands.zig b/test/cases/compile_errors/ambiguous_coercion_of_division_operands.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d8fa4e5726aa60311b0bf248f90201930cc947e7
--- /dev/null
+++ b/test/cases/compile_errors/ambiguous_coercion_of_division_operands.zig
@@ -0,0 +1,24 @@
+export fn entry1() void {
+    var f: f32 = 54.0 / 5;
+    _ = f;
+}
+export fn entry2() void {
+    var f: f32 = 54 / 5.0;
+    _ = f;
+}
+export fn entry3() void {
+    var f: f32 = 55.0 / 5;
+    _ = f;
+}
+export fn entry4() void {
+    var f: f32 = 55 / 5.0;
+    _ = f;
+}
+
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:23: error: ambiguous coercion of division operands 'comptime_float' and 'comptime_int'; division has non-zero reminder '4'
+// :6:21: error: ambiguous coercion of division operands 'comptime_int' and 'comptime_float'; division has non-zero reminder '4'
-- 
2.54.0


From 2cccd144914d8715894458f317fa4c3c572cdcad Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 17 Aug 2022 14:06:47 -0700
Subject: [PATCH 139/290] fix typo in compile error message

---
 src/Sema.zig                                                 | 2 +-
 .../ambiguous_coercion_of_division_operands.zig              | 5 ++---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 29a53ebb2a7283206b659f6e8700cece0f6d9850..5fd1c1ce4cbb6c5b04a8a9305ea9b5ad7437625f 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -11211,7 +11211,7 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
         const rhs_val = maybe_rhs_val orelse unreachable;
         const rem = lhs_val.floatRem(rhs_val, resolved_type, sema.arena, target) catch unreachable;
         if (rem.compareWithZero(.neq)) {
-            return sema.fail(block, src, "ambiguous coercion of division operands '{s}' and '{s}'; division has non-zero reminder '{}'", .{
+            return sema.fail(block, src, "ambiguous coercion of division operands '{s}' and '{s}'; non-zero remainder '{}'", .{
                 @tagName(lhs_ty.tag()), @tagName(rhs_ty.tag()), rem.fmtValue(resolved_type, sema.mod),
             });
         }
diff --git a/test/cases/compile_errors/ambiguous_coercion_of_division_operands.zig b/test/cases/compile_errors/ambiguous_coercion_of_division_operands.zig
index d8fa4e5726aa60311b0bf248f90201930cc947e7..f3e51a1bed2459b067e42f966e0b6ba4b4afe328 100644
--- a/test/cases/compile_errors/ambiguous_coercion_of_division_operands.zig
+++ b/test/cases/compile_errors/ambiguous_coercion_of_division_operands.zig
@@ -15,10 +15,9 @@ export fn entry4() void {
     _ = f;
 }
 
-
 // error
 // backend=stage2
 // target=native
 //
-// :2:23: error: ambiguous coercion of division operands 'comptime_float' and 'comptime_int'; division has non-zero reminder '4'
-// :6:21: error: ambiguous coercion of division operands 'comptime_int' and 'comptime_float'; division has non-zero reminder '4'
+// :2:23: error: ambiguous coercion of division operands 'comptime_float' and 'comptime_int'; non-zero remainder '4'
+// :6:21: error: ambiguous coercion of division operands 'comptime_int' and 'comptime_float'; non-zero remainder '4'
-- 
2.54.0


From 9b595dd55f1ae336e2fb4e2a64334efe137dc19a Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Wed, 17 Aug 2022 10:46:42 +0200
Subject: [PATCH 140/290] link-test: refactor and reorg

Move common tests by target file format (Wasm, MachO) into helper
functions in `link.zig`, and sort alphabetically within for easier
tracking versus file organization on disk.
---
 test/link.zig                             | 53 +++++++++++++----------
 test/link/macho/dead_strip/build.zig      |  8 ++--
 test/link/macho/pagezero/build.zig        |  5 ++-
 test/link/macho/search_strategy/build.zig |  8 ++--
 test/link/macho/stack_size/build.zig      |  3 +-
 test/link/macho/tls/build.zig             |  5 ++-
 6 files changed, 47 insertions(+), 35 deletions(-)

diff --git a/test/link.zig b/test/link.zig
index a8a39a7018c3912d624b349988cdcf34dcb56b5d..88b370f343503207a93dde2e0ce0576134bd4d0e 100644
--- a/test/link.zig
+++ b/test/link.zig
@@ -23,7 +23,12 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
         .build_modes = true,
     });
 
-    cases.addBuildFile("test/link/wasm/type/build.zig", .{
+    addWasmCases(cases);
+    addMachOCases(cases);
+}
+
+fn addWasmCases(cases: *tests.StandaloneContext) void {
+    cases.addBuildFile("test/link/wasm/bss/build.zig", .{
         .build_modes = true,
         .requires_stage2 = true,
     });
@@ -38,23 +43,13 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
         .requires_stage2 = true,
     });
 
-    cases.addBuildFile("test/link/wasm/bss/build.zig", .{
+    cases.addBuildFile("test/link/wasm/type/build.zig", .{
         .build_modes = true,
         .requires_stage2 = true,
     });
+}
 
-    cases.addBuildFile("test/link/macho/entry/build.zig", .{
-        .build_modes = true,
-    });
-
-    cases.addBuildFile("test/link/macho/pagezero/build.zig", .{
-        .build_modes = false,
-    });
-
-    cases.addBuildFile("test/link/macho/dylib/build.zig", .{
-        .build_modes = true,
-    });
-
+fn addMachOCases(cases: *tests.StandaloneContext) void {
     cases.addBuildFile("test/link/macho/dead_strip/build.zig", .{
         .build_modes = false,
     });
@@ -64,50 +59,60 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
         .requires_macos_sdk = true,
     });
 
-    cases.addBuildFile("test/link/macho/needed_library/build.zig", .{
+    cases.addBuildFile("test/link/macho/dylib/build.zig", .{
         .build_modes = true,
     });
 
-    cases.addBuildFile("test/link/macho/weak_library/build.zig", .{
+    cases.addBuildFile("test/link/macho/entry/build.zig", .{
         .build_modes = true,
     });
 
+    cases.addBuildFile("test/link/macho/headerpad/build.zig", .{
+        .build_modes = true,
+        .requires_macos_sdk = true,
+    });
+
     cases.addBuildFile("test/link/macho/needed_framework/build.zig", .{
         .build_modes = true,
         .requires_macos_sdk = true,
     });
 
-    cases.addBuildFile("test/link/macho/weak_framework/build.zig", .{
+    cases.addBuildFile("test/link/macho/needed_library/build.zig", .{
         .build_modes = true,
-        .requires_macos_sdk = true,
     });
 
-    // Try to build and run an Objective-C executable.
     cases.addBuildFile("test/link/macho/objc/build.zig", .{
         .build_modes = true,
         .requires_macos_sdk = true,
     });
 
-    // Try to build and run an Objective-C++ executable.
     cases.addBuildFile("test/link/macho/objcpp/build.zig", .{
         .build_modes = true,
         .requires_macos_sdk = true,
     });
 
-    cases.addBuildFile("test/link/macho/stack_size/build.zig", .{
-        .build_modes = true,
+    cases.addBuildFile("test/link/macho/pagezero/build.zig", .{
+        .build_modes = false,
     });
 
     cases.addBuildFile("test/link/macho/search_strategy/build.zig", .{
         .build_modes = true,
     });
 
-    cases.addBuildFile("test/link/macho/headerpad/build.zig", .{
+    cases.addBuildFile("test/link/macho/stack_size/build.zig", .{
         .build_modes = true,
-        .requires_macos_sdk = true,
     });
 
     cases.addBuildFile("test/link/macho/tls/build.zig", .{
         .build_modes = true,
     });
+
+    cases.addBuildFile("test/link/macho/weak_library/build.zig", .{
+        .build_modes = true,
+    });
+
+    cases.addBuildFile("test/link/macho/weak_framework/build.zig", .{
+        .build_modes = true,
+        .requires_macos_sdk = true,
+    });
 }
diff --git a/test/link/macho/dead_strip/build.zig b/test/link/macho/dead_strip/build.zig
index dea225dd6fd72715d7364210a31cfcd03e12504c..25759f56192a874d08166af689e0f8b9af22d3c7 100644
--- a/test/link/macho/dead_strip/build.zig
+++ b/test/link/macho/dead_strip/build.zig
@@ -4,13 +4,14 @@ const LibExeObjectStep = std.build.LibExeObjStep;
 
 pub fn build(b: *Builder) void {
     const mode = b.standardReleaseOptions();
+    const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test the program");
     test_step.dependOn(b.getInstallStep());
 
     {
         // Without -dead_strip, we expect `iAmUnused` symbol present
-        const exe = createScenario(b, mode);
+        const exe = createScenario(b, mode, target);
 
         const check = exe.checkObject(.macho);
         check.checkInSymtab();
@@ -23,7 +24,7 @@ pub fn build(b: *Builder) void {
 
     {
         // With -dead_strip, no `iAmUnused` symbol should be present
-        const exe = createScenario(b, mode);
+        const exe = createScenario(b, mode, target);
         exe.link_gc_sections = true;
 
         const check = exe.checkObject(.macho);
@@ -36,10 +37,11 @@ pub fn build(b: *Builder) void {
     }
 }
 
-fn createScenario(b: *Builder, mode: std.builtin.Mode) *LibExeObjectStep {
+fn createScenario(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarget) *LibExeObjectStep {
     const exe = b.addExecutable("test", null);
     exe.addCSourceFile("main.c", &[0][]const u8{});
     exe.setBuildMode(mode);
+    exe.setTarget(target);
     exe.linkLibC();
     return exe;
 }
diff --git a/test/link/macho/pagezero/build.zig b/test/link/macho/pagezero/build.zig
index 9dbc0e64733fc272a1be4103406936da301bc4de..5a7044d960c29becc56acaf16e44e6110dfa8f75 100644
--- a/test/link/macho/pagezero/build.zig
+++ b/test/link/macho/pagezero/build.zig
@@ -3,13 +3,14 @@ const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
     const mode = b.standardReleaseOptions();
+    const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
     {
         const exe = b.addExecutable("pagezero", null);
-        exe.setTarget(.{ .os_tag = .macos });
+        exe.setTarget(target);
         exe.setBuildMode(mode);
         exe.addCSourceFile("main.c", &.{});
         exe.linkLibC();
@@ -29,7 +30,7 @@ pub fn build(b: *Builder) void {
 
     {
         const exe = b.addExecutable("no_pagezero", null);
-        exe.setTarget(.{ .os_tag = .macos });
+        exe.setTarget(target);
         exe.setBuildMode(mode);
         exe.addCSourceFile("main.c", &.{});
         exe.linkLibC();
diff --git a/test/link/macho/search_strategy/build.zig b/test/link/macho/search_strategy/build.zig
index 39a82bc6a74d7742598e8577adf860698d9b715a..e556b5bb23538c22c5be38252bf42248a3897f33 100644
--- a/test/link/macho/search_strategy/build.zig
+++ b/test/link/macho/search_strategy/build.zig
@@ -1,17 +1,17 @@
 const std = @import("std");
 const Builder = std.build.Builder;
 const LibExeObjectStep = std.build.LibExeObjStep;
-const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
 pub fn build(b: *Builder) void {
     const mode = b.standardReleaseOptions();
+    const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
     {
         // -search_dylibs_first
-        const exe = createScenario(b, mode);
+        const exe = createScenario(b, mode, target);
         exe.search_strategy = .dylibs_first;
 
         const check = exe.checkObject(.macho);
@@ -26,7 +26,7 @@ pub fn build(b: *Builder) void {
 
     {
         // -search_paths_first
-        const exe = createScenario(b, mode);
+        const exe = createScenario(b, mode, target);
         exe.search_strategy = .paths_first;
 
         const run = std.build.EmulatableRunStep.create(b, "run", exe);
@@ -36,7 +36,7 @@ pub fn build(b: *Builder) void {
     }
 }
 
-fn createScenario(b: *Builder, mode: std.builtin.Mode) *LibExeObjectStep {
+fn createScenario(b: *Builder, mode: std.builtin.Mode, target: std.zig.CrossTarget) *LibExeObjectStep {
     const static = b.addStaticLibrary("a", null);
     static.setTarget(target);
     static.setBuildMode(mode);
diff --git a/test/link/macho/stack_size/build.zig b/test/link/macho/stack_size/build.zig
index 3abf48df7af1863b3f0498a8be2659c6d42ca012..91c44baf5212de27b1934971602df431653df730 100644
--- a/test/link/macho/stack_size/build.zig
+++ b/test/link/macho/stack_size/build.zig
@@ -3,12 +3,13 @@ const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
     const mode = b.standardReleaseOptions();
+    const target: std.zig.CrossTarget = .{ .os_tag = .macos };
 
     const test_step = b.step("test", "Test");
     test_step.dependOn(b.getInstallStep());
 
     const exe = b.addExecutable("main", null);
-    exe.setTarget(.{ .os_tag = .macos });
+    exe.setTarget(target);
     exe.setBuildMode(mode);
     exe.addCSourceFile("main.c", &.{});
     exe.linkLibC();
diff --git a/test/link/macho/tls/build.zig b/test/link/macho/tls/build.zig
index 7bf3ea1c9e14b41a626eb5d9f192353bede2ee16..031a05cedf9907407592cce3c2e9b1e7ad8b536e 100644
--- a/test/link/macho/tls/build.zig
+++ b/test/link/macho/tls/build.zig
@@ -1,4 +1,5 @@
-const Builder = @import("std").build.Builder;
+const std = @import("std");
+const Builder = std.build.Builder;
 
 pub fn build(b: *Builder) void {
     const mode = b.standardReleaseOptions();
@@ -6,11 +7,13 @@ pub fn build(b: *Builder) void {
 
     const lib = b.addSharedLibrary("a", null, b.version(1, 0, 0));
     lib.setBuildMode(mode);
+    lib.setTarget(target);
     lib.addCSourceFile("a.c", &.{});
     lib.linkLibC();
 
     const test_exe = b.addTest("main.zig");
     test_exe.setBuildMode(mode);
+    test_exe.setTarget(target);
     test_exe.linkLibrary(lib);
     test_exe.linkLibC();
 
-- 
2.54.0


From 515ee5b2fa0161e3df4cfe47c71847f8b3476bf2 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Wed, 17 Aug 2022 13:30:23 +0200
Subject: [PATCH 141/290] libstd: do not follow symlinks in renameatW

This correctly mimicks POSIX behavior.
---
 lib/std/os.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/std/os.zig b/lib/std/os.zig
index 984758565cf9475e954ff41c292028ca45e09323..c757561b0717b53251238980ba40c5d28c0a68cb 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -2651,6 +2651,7 @@ pub fn renameatW(
         .creation = windows.FILE_OPEN,
         .io_mode = .blocking,
         .filter = .any, // This function is supposed to rename both files and directories.
+        .follow_symlinks = false,
     }) catch |err| switch (err) {
         error.WouldBlock => unreachable, // Not possible without `.share_access_nonblocking = true`.
         else => |e| return e,
-- 
2.54.0


From b6ce0cce69e4bf37509f99040abda4ca92bec6cb Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Wed, 17 Aug 2022 14:53:20 +0200
Subject: [PATCH 142/290] windows-ci: pass -Domit-stage2 to test-toolchain

---
 ci/azure/pipelines.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index 5ff0a5d61b1506c1605ebe347988d430c5c52c8c..5d208b31a2f732703c288644faf12f25bb89d0e9 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -103,7 +103,7 @@ jobs:
       #& "$ZIGINSTALLDIR\bin\zig.exe" test "..\test\behavior.zig" -fno-stage1 -fLLVM -I "..\test" 2>&1
       #CheckLastExitCode
 
-      & "$ZIGINSTALLDIR\bin\zig.exe" build test-toolchain -Dskip-non-native -Dskip-stage2-tests 2>&1
+      & "$ZIGINSTALLDIR\bin\zig.exe" build test-toolchain -Dskip-non-native -Dskip-stage2-tests -Domit-stage2 2>&1
       CheckLastExitCode
       & "$ZIGINSTALLDIR\bin\zig.exe" build test-std -Dskip-non-native  2>&1
       CheckLastExitCode
-- 
2.54.0


From 79757f233d9bfc646caa13d20243266a19bbdf91 Mon Sep 17 00:00:00 2001
From: Techatrix <19954306+Techatrix@users.noreply.github.com>
Date: Wed, 17 Aug 2022 21:28:11 +0200
Subject: [PATCH 143/290] fix memory leak in NativePaths.zig

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

diff --git a/lib/std/zig/system/NativePaths.zig b/lib/std/zig/system/NativePaths.zig
index e9e7460314654d3974c9d804034e9e951516b062..5f52b04ce4237e0ec43827ad8a1fe9e7ccfad5fd 100644
--- a/lib/std/zig/system/NativePaths.zig
+++ b/lib/std/zig/system/NativePaths.zig
@@ -109,6 +109,8 @@ pub fn detect(allocator: Allocator, native_info: NativeTargetInfo) !NativePaths
 
     if (native_target.os.tag != .windows) {
         const triple = try native_target.linuxTriple(allocator);
+        defer allocator.free(triple);
+
         const qual = native_target.cpu.arch.ptrBitWidth();
 
         // TODO: $ ld --verbose | grep SEARCH_DIR
-- 
2.54.0


From 656b9429d05c4aad2d514e6d4df15326d903e3f4 Mon Sep 17 00:00:00 2001
From: Der Teufel <der.teufel.mail@gmail.com>
Date: Thu, 18 Aug 2022 14:03:42 +0200
Subject: [PATCH 144/290] autodoc: An attempt at generating HTML files from all
 imported source files. Files generated from the standard library could be
 considered for placing with main.js and index.html in lib/docs. Paths should
 reflect packages in the future.

---
 lib/docs/main.js |   2 +-
 src/Autodoc.zig  |  42 +++++
 src/Docgen.zig   | 424 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 467 insertions(+), 1 deletion(-)
 create mode 100644 src/Docgen.zig

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 0a99432c67cb75bb0521d27f4d8e7fde4ed82ac2..a0b8001a9ea859048230a585488f294f9105cae8 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -51,7 +51,7 @@ var zigAnalysis;
   const domHdrName = document.getElementById("hdrName");
   const domHelpModal = document.getElementById("helpModal");
   const domSearchPlaceholder = document.getElementById("searchPlaceholder");
-  const sourceFileUrlTemplate = "/src-viewer/{{file}}#L{{line}}"
+  const sourceFileUrlTemplate = "src-viewer/{{file}}#L{{line}}"
   const domLangRefLink = document.getElementById("langRefLink");
 
   let lineCounter = 1;
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index d90ebc3de875034edb2027327df8ebdfdabe4571..2364a40f9f20b90c9448c393d3b7d8d584e9deb6 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -9,6 +9,7 @@ const Package = @import("Package.zig");
 const Zir = @import("Zir.zig");
 const Ref = Zir.Inst.Ref;
 const log = std.log.scoped(.autodoc);
+const Docgen = @import("Docgen.zig");
 
 module: *Module,
 doc_location: Compilation.EmitLoc,
@@ -266,6 +267,27 @@ pub fn generateZirData(self: *Autodoc) !void {
         try buffer.flush();
     }
 
+    output_dir.makeDir("src-viewer") catch |e| switch (e) {
+        error.PathAlreadyExists => {},
+        else => |err| return err,
+    };
+    const html_dir = try output_dir.openDir("src-viewer", .{});
+
+    var files_iterator = self.files.iterator();
+
+    while (files_iterator.next()) |entry| {
+        const new_html_path = entry.key_ptr.*.sub_file_path;
+
+        const html_file = try createFromPath(html_dir, new_html_path);
+        defer html_file.close();
+        var buffer = std.io.bufferedWriter(html_file.writer());
+
+        const out = buffer.writer();
+
+        try Docgen.genHtml(self.module.gpa, entry.key_ptr.*, out);
+        try buffer.flush();
+    }
+
     // copy main.js, index.html
     var docs_dir = try self.module.comp.zig_lib_directory.handle.openDir("docs", .{});
     defer docs_dir.close();
@@ -273,6 +295,26 @@ pub fn generateZirData(self: *Autodoc) !void {
     try docs_dir.copyFile("index.html", output_dir, "index.html", .{});
 }
 
+fn createFromPath(base_dir: std.fs.Dir, path: []const u8) !std.fs.File {
+    var path_tokens = std.mem.tokenize(u8, path, std.fs.path.sep_str);
+    var dir = base_dir;
+    while (path_tokens.next()) |toc| {
+        if (path_tokens.peek() != null) {
+            dir.makeDir(toc) catch |e| switch (e) {
+                error.PathAlreadyExists => {},
+                else => |err| return err,
+            };
+            dir = try dir.openDir(toc, .{});
+        } else {
+            return dir.createFile(toc, .{}) catch |e| switch (e) {
+                error.PathAlreadyExists => try dir.openFile(toc, .{}),
+                else => |e| return e,
+            };
+        }
+    }
+    return error.EmptyPath;
+}
+
 /// Represents a chain of scopes, used to resolve decl references to the
 /// corresponding entry in `self.decls`.
 const Scope = struct {
diff --git a/src/Docgen.zig b/src/Docgen.zig
new file mode 100644
index 0000000000000000000000000000000000000000..294ff359f0360a4b66acc74169cb38cb03484cc1
--- /dev/null
+++ b/src/Docgen.zig
@@ -0,0 +1,424 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const io = std.io;
+const fs = std.fs;
+const process = std.process;
+const ChildProcess = std.ChildProcess;
+const Progress = std.Progress;
+const print = std.debug.print;
+const mem = std.mem;
+const testing = std.testing;
+const Allocator = std.mem.Allocator;
+const Module = @import("Module.zig");
+
+pub fn genHtml(
+    allocator: Allocator,
+    src: *Module.File,
+    out: anytype,
+) !void {
+    try out.writeAll(
+        \\<!doctype html>
+        \\<html lang="en">
+        \\<head>
+        \\    <meta charset="utf-8">
+        \\    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    );
+    try out.print("    <title>{s} - source view</title>\n", .{src.sub_file_path});
+    try out.writeAll(\\    <link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAgklEQVR4AWMYWuD7EllJIM4G4g4g5oIJ/odhOJ8wToOxSTXgNxDHoeiBMfA4+wGShjyYOCkG/IGqWQziEzYAoUAeiF9D5U+DxEg14DRU7jWIT5IBIOdCxf+A+CQZAAoopEB7QJwBCBwHiip8UYmRdrAlDpIMgApwQZNnNii5Dq0MBgCxxycBnwEd+wAAAABJRU5ErkJggg=="/>
+        \\    <style>
+        \\      body{
+        \\        font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
+        \\        margin: 0;
+        \\        line-height: 1.5;
+        \\      }
+        \\
+        \\      @media screen and (min-width: 1025px) {
+        \\      pre > code {
+        \\        display: block;
+        \\        overflow: auto;
+        \\        line-height: normal;
+        \\        margin: 0em;
+        \\      }
+        \\      .tok-kw {
+        \\          color: #333;
+        \\          font-weight: bold;
+        \\      }
+        \\      .tok-str {
+        \\          color: #d14;
+        \\      }
+        \\      .tok-builtin {
+        \\          color: #005C7A;
+        \\      }
+        \\      .tok-comment {
+        \\          color: #545454;
+        \\          font-style: italic;
+        \\      }
+        \\      .tok-fn {
+        \\          color: #900;
+        \\          font-weight: bold;
+        \\      }
+        \\      .tok-null {
+        \\          color: #005C5C;
+        \\      }
+        \\      .tok-number {
+        \\          color: #005C5C;
+        \\      }
+        \\      .tok-type {
+        \\          color: #458;
+        \\          font-weight: bold;
+        \\      }
+        \\      pre {
+        \\        counter-reset: line;
+        \\      }
+        \\      pre .line:before {
+        \\        counter-increment: line;
+        \\        content: counter(line);
+        \\        display: inline-block;
+        \\        padding-right: 1em;
+        \\        width: 2em;
+        \\        text-align: right;
+        \\        color: #999;
+        \\      }
+        \\
+        \\      @media (prefers-color-scheme: dark) {
+        \\        body{
+        \\            background:#222;
+        \\            color: #ccc;
+        \\        }
+        \\        pre > code {
+        \\            color: #ccc;
+        \\            background: #222;
+        \\            border: unset;
+        \\        }
+        \\        .tok-kw {
+        \\            color: #eee;
+        \\        }
+        \\        .tok-str {
+        \\            color: #2e5;
+        \\        }
+        \\        .tok-builtin {
+        \\            color: #ff894c;
+        \\        }
+        \\        .tok-comment {
+        \\            color: #aa7;
+        \\        }
+        \\        .tok-fn {
+        \\            color: #B1A0F8;
+        \\        }
+        \\        .tok-null {
+        \\            color: #ff8080;
+        \\        }
+        \\        .tok-number {
+        \\            color: #ff8080;
+        \\        }
+        \\        .tok-type {
+        \\            color: #68f;
+        \\        }
+        \\      }
+        \\    </style>
+        \\</head>
+        \\<body>
+        \\
+    );
+
+    const source = try src.getSource(allocator);
+    try tokenizeAndPrintRaw(allocator, out, source.bytes);
+    try out.writeAll(\\</body>
+    \\</html>
+    );
+}
+
+const start_line = "<span class=\"line\" id=\"L{d}\">";
+const end_line = "</span>\n";
+
+
+    var line_counter: usize = 1;
+
+pub fn tokenizeAndPrintRaw(
+    allocator: Allocator,
+    out: anytype,
+    raw_src: [:0]const u8,
+) !void {
+    const src = try allocator.dupeZ(u8, raw_src);
+    defer allocator.free(src);
+
+    line_counter = 1;
+
+    try out.print("<pre><code>" ++ start_line, .{line_counter});
+    var tokenizer = std.zig.Tokenizer.init(src);
+    var index: usize = 0;
+    var next_tok_is_fn = false;
+    while (true) {
+        const prev_tok_was_fn = next_tok_is_fn;
+        next_tok_is_fn = false;
+
+        const token = tokenizer.next();
+        if (mem.indexOf(u8, src[index..token.loc.start], "//")) |comment_start_off| {
+            // render one comment
+            const comment_start = index + comment_start_off;
+            const comment_end_off = mem.indexOf(u8, src[comment_start..token.loc.start], "\n");
+            const comment_end = if (comment_end_off) |o| comment_start + o else token.loc.start;
+
+            try writeEscapedLines(out, src[index..comment_start]);
+            try out.writeAll("<span class=\"tok-comment\">");
+            try writeEscaped(out, src[comment_start..comment_end]);
+            try out.writeAll("</span>\n");
+            index = comment_end;
+            tokenizer.index = index;
+            continue;
+        }
+
+        try writeEscapedLines(out, src[index..token.loc.start]);
+        switch (token.tag) {
+            .eof => break,
+
+            .keyword_addrspace,
+            .keyword_align,
+            .keyword_and,
+            .keyword_asm,
+            .keyword_async,
+            .keyword_await,
+            .keyword_break,
+            .keyword_catch,
+            .keyword_comptime,
+            .keyword_const,
+            .keyword_continue,
+            .keyword_defer,
+            .keyword_else,
+            .keyword_enum,
+            .keyword_errdefer,
+            .keyword_error,
+            .keyword_export,
+            .keyword_extern,
+            .keyword_for,
+            .keyword_if,
+            .keyword_inline,
+            .keyword_noalias,
+            .keyword_noinline,
+            .keyword_nosuspend,
+            .keyword_opaque,
+            .keyword_or,
+            .keyword_orelse,
+            .keyword_packed,
+            .keyword_anyframe,
+            .keyword_pub,
+            .keyword_resume,
+            .keyword_return,
+            .keyword_linksection,
+            .keyword_callconv,
+            .keyword_struct,
+            .keyword_suspend,
+            .keyword_switch,
+            .keyword_test,
+            .keyword_threadlocal,
+            .keyword_try,
+            .keyword_union,
+            .keyword_unreachable,
+            .keyword_usingnamespace,
+            .keyword_var,
+            .keyword_volatile,
+            .keyword_allowzero,
+            .keyword_while,
+            .keyword_anytype,
+            => {
+                try out.writeAll("<span class=\"tok-kw\">");
+                try writeEscaped(out, src[token.loc.start..token.loc.end]);
+                try out.writeAll("</span>");
+            },
+
+            .keyword_fn => {
+                try out.writeAll("<span class=\"tok-kw\">");
+                try writeEscaped(out, src[token.loc.start..token.loc.end]);
+                try out.writeAll("</span>");
+                next_tok_is_fn = true;
+            },
+
+            .string_literal,
+            .char_literal,
+            => {
+                try out.writeAll("<span class=\"tok-str\">");
+                try writeEscaped(out, src[token.loc.start..token.loc.end]);
+                try out.writeAll("</span>");
+            },
+
+            .multiline_string_literal_line => {
+                if (src[token.loc.end - 1] == '\n') {
+                    try out.writeAll("<span class=\"tok-str\">");
+                    try writeEscaped(out, src[token.loc.start .. token.loc.end - 1]);
+                    line_counter += 1;
+                    try out.print("</span>" ++ end_line ++ "\n" ++ start_line, .{line_counter});
+                } else {
+                    try out.writeAll("<span class=\"tok-str\">");
+                    try writeEscaped(out, src[token.loc.start..token.loc.end]);
+                    try out.writeAll("</span>");
+                }
+            },
+
+            .builtin => {
+                try out.writeAll("<span class=\"tok-builtin\">");
+                try writeEscaped(out, src[token.loc.start..token.loc.end]);
+                try out.writeAll("</span>");
+            },
+
+            .doc_comment,
+            .container_doc_comment,
+            => {
+                try out.writeAll("<span class=\"tok-comment\">");
+                try writeEscaped(out, src[token.loc.start..token.loc.end]);
+                try out.writeAll("</span>");
+            },
+
+            .identifier => {
+                const tok_bytes = src[token.loc.start..token.loc.end];
+                if (mem.eql(u8, tok_bytes, "undefined") or
+                    mem.eql(u8, tok_bytes, "null") or
+                    mem.eql(u8, tok_bytes, "true") or
+                    mem.eql(u8, tok_bytes, "false"))
+                {
+                    try out.writeAll("<span class=\"tok-null\">");
+                    try writeEscaped(out, tok_bytes);
+                    try out.writeAll("</span>");
+                } else if (prev_tok_was_fn) {
+                    try out.writeAll("<span class=\"tok-fn\">");
+                    try writeEscaped(out, tok_bytes);
+                    try out.writeAll("</span>");
+                } else {
+                    const is_int = blk: {
+                        if (src[token.loc.start] != 'i' and src[token.loc.start] != 'u')
+                            break :blk false;
+                        var i = token.loc.start + 1;
+                        if (i == token.loc.end)
+                            break :blk false;
+                        while (i != token.loc.end) : (i += 1) {
+                            if (src[i] < '0' or src[i] > '9')
+                                break :blk false;
+                        }
+                        break :blk true;
+                    };
+                    if (is_int or isType(tok_bytes)) {
+                        try out.writeAll("<span class=\"tok-type\">");
+                        try writeEscaped(out, tok_bytes);
+                        try out.writeAll("</span>");
+                    } else {
+                        try writeEscaped(out, tok_bytes);
+                    }
+                }
+            },
+
+            .integer_literal,
+            .float_literal,
+            => {
+                try out.writeAll("<span class=\"tok-number\">");
+                try writeEscaped(out, src[token.loc.start..token.loc.end]);
+                try out.writeAll("</span>");
+            },
+
+            .bang,
+            .pipe,
+            .pipe_pipe,
+            .pipe_equal,
+            .equal,
+            .equal_equal,
+            .equal_angle_bracket_right,
+            .bang_equal,
+            .l_paren,
+            .r_paren,
+            .semicolon,
+            .percent,
+            .percent_equal,
+            .l_brace,
+            .r_brace,
+            .l_bracket,
+            .r_bracket,
+            .period,
+            .period_asterisk,
+            .ellipsis2,
+            .ellipsis3,
+            .caret,
+            .caret_equal,
+            .plus,
+            .plus_plus,
+            .plus_equal,
+            .plus_percent,
+            .plus_percent_equal,
+            .plus_pipe,
+            .plus_pipe_equal,
+            .minus,
+            .minus_equal,
+            .minus_percent,
+            .minus_percent_equal,
+            .minus_pipe,
+            .minus_pipe_equal,
+            .asterisk,
+            .asterisk_equal,
+            .asterisk_asterisk,
+            .asterisk_percent,
+            .asterisk_percent_equal,
+            .asterisk_pipe,
+            .asterisk_pipe_equal,
+            .arrow,
+            .colon,
+            .slash,
+            .slash_equal,
+            .comma,
+            .ampersand,
+            .ampersand_equal,
+            .question_mark,
+            .angle_bracket_left,
+            .angle_bracket_left_equal,
+            .angle_bracket_angle_bracket_left,
+            .angle_bracket_angle_bracket_left_equal,
+            .angle_bracket_angle_bracket_left_pipe,
+            .angle_bracket_angle_bracket_left_pipe_equal,
+            .angle_bracket_right,
+            .angle_bracket_right_equal,
+            .angle_bracket_angle_bracket_right,
+            .angle_bracket_angle_bracket_right_equal,
+            .tilde,
+            => try writeEscaped(out, src[token.loc.start..token.loc.end]),
+
+            .invalid, .invalid_periodasterisks => return error.ParseError,
+        }
+        index = token.loc.end;
+    }
+    try out.writeAll(end_line ++ "</code></pre>");
+}
+
+fn writeEscapedLines(out: anytype, text: []const u8) !void {
+    for (text) |char| {
+        if (char == '\n') {
+            try out.writeAll(end_line);
+            line_counter += 1;
+            try out.print(start_line, .{line_counter});
+        } else {
+            try writeEscaped(out, &[_]u8{char});
+        }
+    }
+}
+
+fn writeEscaped(out: anytype, input: []const u8) !void {
+    for (input) |c| {
+        try switch (c) {
+            '&' => out.writeAll("&amp;"),
+            '<' => out.writeAll("&lt;"),
+            '>' => out.writeAll("&gt;"),
+            '"' => out.writeAll("&quot;"),
+            else => out.writeByte(c),
+        };
+    }
+}
+
+const builtin_types = [_][]const u8{
+    "f16",         "f32",      "f64",       "f128",     "c_longdouble", "c_short",
+    "c_ushort",    "c_int",    "c_uint",    "c_long",   "c_ulong",      "c_longlong",
+    "c_ulonglong", "c_char",   "anyopaque", "void",     "bool",         "isize",
+    "usize",       "noreturn", "type",      "anyerror", "comptime_int", "comptime_float",
+};
+
+fn isType(name: []const u8) bool {
+    for (builtin_types) |t| {
+        if (mem.eql(u8, t, name))
+            return true;
+    }
+    return false;
+}
-- 
2.54.0


From 63c25cc1cc4aef1ae5c7425496d99b30db2f44d7 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Tue, 16 Aug 2022 20:41:48 +0200
Subject: [PATCH 145/290] wasm: fix callInstrinsic return value

Rather than storing it in a local and returning that,
we now keep this on the stack as all internal functions
expect it to be on the stack already and therefore were
generating extra `local.set` instructions.
---
 src/arch/wasm/CodeGen.zig | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index 8eb3e2175b9a292f54bdc9cee85d8d70d5133c3c..95a0a8e4aa83b0adf377de3922392158782ed8d6 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -4106,7 +4106,6 @@ fn fpext(self: *Self, operand: WValue, given: Type, wanted: Type) InnerError!WVa
             return f32_result;
         }
         if (wanted_bits == 64) {
-            try self.emitWValue(f32_result);
             try self.addTag(.f64_promote_f32);
             return WValue{ .stack = {} };
         }
@@ -4628,7 +4627,6 @@ fn airMulAdd(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
             Type.f32,
             &.{ rhs_ext, lhs_ext, addend_ext },
         );
-        defer result.free(self);
         return try (try self.fptrunc(result, Type.f32, ty)).toLocal(self, ty);
     }
 
@@ -5353,6 +5351,7 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
 /// This function call assumes the C-ABI.
 /// Asserts arguments are not stack values when the return value is
 /// passed as the first parameter.
+/// May leave the return value on the stack.
 fn callIntrinsic(
     self: *Self,
     name: []const u8,
@@ -5398,8 +5397,6 @@ fn callIntrinsic(
     } else if (want_sret_param) {
         return sret;
     } else {
-        const result_local = try self.allocLocal(return_type);
-        try self.addLabel(.local_set, result_local.local);
-        return result_local;
+        return WValue{ .stack = {} };
     }
 }
-- 
2.54.0


From 4f2143beccb822f42c77d1d6c5ad31388123803e Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Tue, 16 Aug 2022 20:50:50 +0200
Subject: [PATCH 146/290] link/Wasm: improve symbol resolution

This adds additional checks during symbol resolution:
- Ensures function signatures match when a symbol will be replaced.
- Ensures global types match when the symbol is being replaced.
- When both symbols are undefined, ensures they have a matching module name.

Those changes ensure the result will pass the validator when
the runtime compiles the Wasm module.

Additionally, this also slightly changes the behavior when both
the existing symbol and new symbol are both defined. Rather than
always resulting in a collision, it only results in a collision
when both are also weak. Else, the non-weak symbol will be picked.
---
 src/link/Wasm.zig | 100 ++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 96 insertions(+), 4 deletions(-)

diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 30e219226895d522eae60431a93982d293d45d89..1bdd9426a58b464b17d5d7bb598b094462c8a598 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -463,8 +463,6 @@ fn resolveSymbolsInObject(self: *Wasm, object_index: u16) !void {
             continue;
         }
 
-        // TODO: Store undefined symbols so we can verify at the end if they've all been found
-        // if not, emit an error (unless --allow-undefined is enabled).
         const maybe_existing = try self.globals.getOrPut(self.base.allocator, sym_name_index);
         if (!maybe_existing.found_existing) {
             maybe_existing.value_ptr.* = location;
@@ -483,8 +481,15 @@ fn resolveSymbolsInObject(self: *Wasm, object_index: u16) !void {
             break :blk self.objects.items[file].name;
         } else self.name;
 
-        if (!existing_sym.isUndefined()) {
-            if (!symbol.isUndefined()) {
+        if (!existing_sym.isUndefined()) outer: {
+            if (!symbol.isUndefined()) inner: {
+                if (symbol.isWeak()) {
+                    break :inner; // ignore the new symbol (discard it)
+                }
+                if (existing_sym.isWeak()) {
+                    break :outer; // existing is weak, while new one isn't. Replace it.
+                }
+                // both are defined and weak, we have a symbol collision.
                 log.err("symbol '{s}' defined multiple times", .{sym_name});
                 log.err("  first definition in '{s}'", .{existing_file_path});
                 log.err("  next definition in '{s}'", .{object.name});
@@ -502,6 +507,53 @@ fn resolveSymbolsInObject(self: *Wasm, object_index: u16) !void {
             return error.SymbolMismatchingType;
         }
 
+        if (existing_sym.isUndefined() and symbol.isUndefined()) {
+            const existing_name = if (existing_loc.file) |file_index| blk: {
+                const obj = self.objects.items[file_index];
+                const name_index = obj.findImport(symbol.tag.externalType(), existing_sym.index).module_name;
+                break :blk obj.string_table.get(name_index);
+            } else blk: {
+                const name_index = self.imports.get(existing_loc).?.module_name;
+                break :blk self.string_table.get(name_index);
+            };
+
+            const module_index = object.findImport(symbol.tag.externalType(), symbol.index).module_name;
+            const module_name = object.string_table.get(module_index);
+            if (!mem.eql(u8, existing_name, module_name)) {
+                log.err("symbol '{s}' module name mismatch. Expected '{s}', but found '{s}'", .{
+                    sym_name,
+                    existing_name,
+                    module_name,
+                });
+                log.err("  first definition in '{s}'", .{existing_file_path});
+                log.err("  next definition in '{s}'", .{object.name});
+                return error.ModuleNameMismatch;
+            }
+        }
+
+        if (existing_sym.tag == .global) {
+            const existing_ty = self.getGlobalType(existing_loc);
+            const new_ty = self.getGlobalType(location);
+            if (existing_ty.mutable != new_ty.mutable or existing_ty.valtype != new_ty.valtype) {
+                log.err("symbol '{s}' mismatching global types", .{sym_name});
+                log.err("  first definition in '{s}'", .{existing_file_path});
+                log.err("  next definition in '{s}'", .{object.name});
+                return error.GlobalTypeMismatch;
+            }
+        }
+
+        if (existing_sym.tag == .function) {
+            const existing_ty = self.getFunctionSignature(existing_loc);
+            const new_ty = self.getFunctionSignature(location);
+            if (!existing_ty.eql(new_ty)) {
+                log.err("symbol '{s}' mismatching function signatures.", .{sym_name});
+                log.err("  expected signature {}, but found signature {}", .{ existing_ty, new_ty });
+                log.err("  first definition in '{s}'", .{existing_file_path});
+                log.err("  next definition in '{s}'", .{object.name});
+                return error.FunctionSignatureMismatch;
+            }
+        }
+
         // when both symbols are weak, we skip overwriting
         if (existing_sym.isWeak() and symbol.isWeak()) {
             try self.discarded.put(self.base.allocator, location, existing_loc);
@@ -797,6 +849,46 @@ fn finishUpdateDecl(self: *Wasm, decl: *Module.Decl, code: []const u8) !void {
     try self.resolved_symbols.put(self.base.allocator, atom.symbolLoc(), {});
 }
 
+/// From a given symbol location, returns its `wasm.GlobalType`.
+/// Asserts the Symbol represents a global.
+fn getGlobalType(self: *const Wasm, loc: SymbolLoc) wasm.GlobalType {
+    const symbol = loc.getSymbol(self);
+    assert(symbol.tag == .global);
+    const is_undefined = symbol.isUndefined();
+    if (loc.file) |file_index| {
+        const obj: Object = self.objects.items[file_index];
+        if (is_undefined) {
+            return obj.findImport(.global, symbol.index).kind.global;
+        }
+        return obj.globals[symbol.index].global_type;
+    }
+    if (is_undefined) {
+        return self.imports.get(loc).?.kind.global;
+    }
+    return self.wasm_globals.items[symbol.index].global_type;
+}
+
+/// From a given symbol location, returns its `wasm.Type`.
+/// Asserts the Symbol represents a function.
+fn getFunctionSignature(self: *const Wasm, loc: SymbolLoc) wasm.Type {
+    const symbol = loc.getSymbol(self);
+    assert(symbol.tag == .function);
+    const is_undefined = symbol.isUndefined();
+    if (loc.file) |file_index| {
+        const obj: Object = self.objects.items[file_index];
+        if (is_undefined) {
+            const ty_index = obj.findImport(.function, symbol.index).kind.function;
+            return obj.func_types[ty_index];
+        }
+        return obj.func_types[obj.functions[symbol.index].type_index];
+    }
+    if (is_undefined) {
+        const ty_index = self.imports.get(loc).?.kind.function;
+        return self.func_types.items[ty_index];
+    }
+    return self.func_types.items[self.functions.get(.{ .file = loc.file, .index = loc.index }).?.type_index];
+}
+
 /// Lowers a constant typed value to a local symbol and atom.
 /// Returns the symbol index of the local
 /// The given `decl` is the parent decl whom owns the constant.
-- 
2.54.0


From f0bfdf9766716572d114b4bddefc6d26bb0ec298 Mon Sep 17 00:00:00 2001
From: Der Teufel <der.teufel.mail@gmail.com>
Date: Thu, 18 Aug 2022 15:31:56 +0200
Subject: [PATCH 147/290] Fixed stage1 compilation error

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

diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 2364a40f9f20b90c9448c393d3b7d8d584e9deb6..de8a83202983417ab3c5b2fa705efdb7f329a9db 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -308,7 +308,7 @@ fn createFromPath(base_dir: std.fs.Dir, path: []const u8) !std.fs.File {
         } else {
             return dir.createFile(toc, .{}) catch |e| switch (e) {
                 error.PathAlreadyExists => try dir.openFile(toc, .{}),
-                else => |e| return e,
+                else => |err| return err,
             };
         }
     }
-- 
2.54.0


From 51a4861a081eea5d9bfd590c63f4a4506305f941 Mon Sep 17 00:00:00 2001
From: Der Teufel <der.teufel.mail@gmail.com>
Date: Thu, 18 Aug 2022 15:44:42 +0200
Subject: [PATCH 148/290] Fixed Docgen.zig formatting

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

diff --git a/src/Docgen.zig b/src/Docgen.zig
index 294ff359f0360a4b66acc74169cb38cb03484cc1..1edb551ed9756c6ebc3066aa7fdf5435c4e42eb8 100644
--- a/src/Docgen.zig
+++ b/src/Docgen.zig
@@ -24,7 +24,8 @@ pub fn genHtml(
         \\    <meta name="viewport" content="width=device-width, initial-scale=1.0">
     );
     try out.print("    <title>{s} - source view</title>\n", .{src.sub_file_path});
-    try out.writeAll(\\    <link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAgklEQVR4AWMYWuD7EllJIM4G4g4g5oIJ/odhOJ8wToOxSTXgNxDHoeiBMfA4+wGShjyYOCkG/IGqWQziEzYAoUAeiF9D5U+DxEg14DRU7jWIT5IBIOdCxf+A+CQZAAoopEB7QJwBCBwHiip8UYmRdrAlDpIMgApwQZNnNii5Dq0MBgCxxycBnwEd+wAAAABJRU5ErkJggg=="/>
+    try out.writeAll(
+        \\    <link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAgklEQVR4AWMYWuD7EllJIM4G4g4g5oIJ/odhOJ8wToOxSTXgNxDHoeiBMfA4+wGShjyYOCkG/IGqWQziEzYAoUAeiF9D5U+DxEg14DRU7jWIT5IBIOdCxf+A+CQZAAoopEB7QJwBCBwHiip8UYmRdrAlDpIMgApwQZNnNii5Dq0MBgCxxycBnwEd+wAAAABJRU5ErkJggg=="/>
         \\    <style>
         \\      body{
         \\        font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
@@ -123,16 +124,16 @@ pub fn genHtml(
 
     const source = try src.getSource(allocator);
     try tokenizeAndPrintRaw(allocator, out, source.bytes);
-    try out.writeAll(\\</body>
-    \\</html>
+    try out.writeAll(
+        \\</body>
+        \\</html>
     );
 }
 
 const start_line = "<span class=\"line\" id=\"L{d}\">";
 const end_line = "</span>\n";
 
-
-    var line_counter: usize = 1;
+var line_counter: usize = 1;
 
 pub fn tokenizeAndPrintRaw(
     allocator: Allocator,
-- 
2.54.0


From 53e971226dcc2fd0cb53e3442399b8724700b3e5 Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Thu, 18 Aug 2022 18:02:19 +0200
Subject: [PATCH 149/290] autodoc: minor pr cleanup

---
 lib/docs/main.js                              |  4 +--
 src/Autodoc.zig                               | 33 ++++++++++---------
 src/{Docgen.zig => autodoc/render_source.zig} |  3 +-
 3 files changed, 21 insertions(+), 19 deletions(-)
 rename src/{Docgen.zig => autodoc/render_source.zig} (99%)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index a0b8001a9ea859048230a585488f294f9105cae8..28f8fb1a703194eec24a35ba54d345cf4f0c8b67 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -51,7 +51,7 @@ var zigAnalysis;
   const domHdrName = document.getElementById("hdrName");
   const domHelpModal = document.getElementById("helpModal");
   const domSearchPlaceholder = document.getElementById("searchPlaceholder");
-  const sourceFileUrlTemplate = "src-viewer/{{file}}#L{{line}}"
+  const sourceFileUrlTemplate = "src/{{file}}#L{{line}}"
   const domLangRefLink = document.getElementById("langRefLink");
 
   let lineCounter = 1;
@@ -989,7 +989,7 @@ var zigAnalysis;
           "switch(" +
           cond +
           ") {" +
-          '<a href="/src-viewer/' +
+          '<a href="/src/' +
           file_name +
           "#L" +
           line +
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index de8a83202983417ab3c5b2fa705efdb7f329a9db..bc1b1beebb0d9f4a7a4bd96f1f2a4ff4818ce790 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -9,7 +9,7 @@ const Package = @import("Package.zig");
 const Zir = @import("Zir.zig");
 const Ref = Zir.Inst.Ref;
 const log = std.log.scoped(.autodoc);
-const Docgen = @import("Docgen.zig");
+const Docgen = @import("autodoc/render_source.zig");
 
 module: *Module,
 doc_location: Compilation.EmitLoc,
@@ -243,6 +243,7 @@ pub fn generateZirData(self: *Autodoc) !void {
         try d.handle.openDir(self.doc_location.basename, .{})
     else
         try self.module.zig_cache_artifact_directory.handle.openDir(self.doc_location.basename, .{});
+
     {
         const data_js_f = try output_dir.createFile("data.js", .{});
         defer data_js_f.close();
@@ -267,25 +268,27 @@ pub fn generateZirData(self: *Autodoc) !void {
         try buffer.flush();
     }
 
-    output_dir.makeDir("src-viewer") catch |e| switch (e) {
-        error.PathAlreadyExists => {},
-        else => |err| return err,
-    };
-    const html_dir = try output_dir.openDir("src-viewer", .{});
+    {
+        output_dir.makeDir("src") catch |e| switch (e) {
+            error.PathAlreadyExists => {},
+            else => |err| return err,
+        };
+        const html_dir = try output_dir.openDir("src", .{});
 
-    var files_iterator = self.files.iterator();
+        var files_iterator = self.files.iterator();
 
-    while (files_iterator.next()) |entry| {
-        const new_html_path = entry.key_ptr.*.sub_file_path;
+        while (files_iterator.next()) |entry| {
+            const new_html_path = entry.key_ptr.*.sub_file_path;
 
-        const html_file = try createFromPath(html_dir, new_html_path);
-        defer html_file.close();
-        var buffer = std.io.bufferedWriter(html_file.writer());
+            const html_file = try createFromPath(html_dir, new_html_path);
+            defer html_file.close();
+            var buffer = std.io.bufferedWriter(html_file.writer());
 
-        const out = buffer.writer();
+            const out = buffer.writer();
 
-        try Docgen.genHtml(self.module.gpa, entry.key_ptr.*, out);
-        try buffer.flush();
+            try Docgen.genHtml(self.module.gpa, entry.key_ptr.*, out);
+            try buffer.flush();
+        }
     }
 
     // copy main.js, index.html
diff --git a/src/Docgen.zig b/src/autodoc/render_source.zig
similarity index 99%
rename from src/Docgen.zig
rename to src/autodoc/render_source.zig
index 1edb551ed9756c6ebc3066aa7fdf5435c4e42eb8..cafed8d5265c509a3056d54bfa9556cf7efce0ce 100644
--- a/src/Docgen.zig
+++ b/src/autodoc/render_source.zig
@@ -9,7 +9,7 @@ const print = std.debug.print;
 const mem = std.mem;
 const testing = std.testing;
 const Allocator = std.mem.Allocator;
-const Module = @import("Module.zig");
+const Module = @import("../Module.zig");
 
 pub fn genHtml(
     allocator: Allocator,
@@ -33,7 +33,6 @@ pub fn genHtml(
         \\        line-height: 1.5;
         \\      }
         \\
-        \\      @media screen and (min-width: 1025px) {
         \\      pre > code {
         \\        display: block;
         \\        overflow: auto;
-- 
2.54.0


From 4055e6055b5c0727f5e85a30760c9bccf525f4de Mon Sep 17 00:00:00 2001
From: zooster <r00ster91@proton.me>
Date: Thu, 18 Aug 2022 18:54:51 +0200
Subject: [PATCH 150/290] AstGen: disallow leading zeroes in int literals and
 int types

This makes `0123` and `u0123` etc. illegal.

I'm now confident that this is a good change because
I actually caught two C header translation mistakes in `haiku.zig` with this.
Clearly, `0123` being octal in C (TIL) can cause confusion, and we make this easier to read by
requiring `0o` as the prefix and now also disallowing leading zeroes in integers.

For consistency and because it looks weird, we disallow it for integer types too (e.g. `u0123`).

Fixes #11963
Fixes #12417
---
 lib/std/c/haiku.zig                           |  4 +-
 lib/std/zig/parser_test.zig                   | 16 +++----
 src/AstGen.zig                                | 43 ++++++++++++++-----
 test/behavior/math.zig                        |  7 ++-
 ..._underscore_placement_in_int_literal-1.zig |  4 +-
 .../leading_zero_in_integer.zig               | 27 ++++++++++++
 6 files changed, 74 insertions(+), 27 deletions(-)
 create mode 100644 test/cases/compile_errors/leading_zero_in_integer.zig

diff --git a/lib/std/c/haiku.zig b/lib/std/c/haiku.zig
index 672f4fa4baa8440724350039dcdecb6887406d65..28935ffa34740f07430a63630851f847956f3794 100644
--- a/lib/std/c/haiku.zig
+++ b/lib/std/c/haiku.zig
@@ -702,7 +702,7 @@ pub const T = struct {
     pub const CSETAF = 0x8002;
     pub const CSETAW = 0x8003;
     pub const CWAITEVENT = 0x8004;
-    pub const CSBRK = 08005;
+    pub const CSBRK = 0x8005;
     pub const CFLSH = 0x8006;
     pub const CXONC = 0x8007;
     pub const CQUERYCONNECTED = 0x8008;
@@ -874,7 +874,7 @@ pub const S = struct {
     pub const IFDIR = 0o040000;
     pub const IFCHR = 0o020000;
     pub const IFIFO = 0o010000;
-    pub const INDEX_DIR = 04000000000;
+    pub const INDEX_DIR = 0o4000000000;
 
     pub const IUMSK = 0o7777;
     pub const ISUID = 0o4000;
diff --git a/lib/std/zig/parser_test.zig b/lib/std/zig/parser_test.zig
index bee9375b5ae188a089e03de1ebbf7368f7fe52da..2bb8c848bc201ac05ad21f9f7f6e0bdad9b1f74e 100644
--- a/lib/std/zig/parser_test.zig
+++ b/lib/std/zig/parser_test.zig
@@ -4254,10 +4254,10 @@ test "zig fmt: integer literals with underscore separators" {
         \\const
         \\ x     =
         \\ 1_234_567
-        \\ + (0b0_1-0o7_0+0xff_FF ) +  0_0;
+        \\ + (0b0_1-0o7_0+0xff_FF ) +  1_0;
     ,
         \\const x =
-        \\    1_234_567 + (0b0_1 - 0o7_0 + 0xff_FF) + 0_0;
+        \\    1_234_567 + (0b0_1 - 0o7_0 + 0xff_FF) + 1_0;
         \\
     );
 }
@@ -4266,7 +4266,7 @@ test "zig fmt: hex literals with underscore separators" {
     try testTransform(
         \\pub fn orMask(a: [ 1_000 ]u64, b: [  1_000]  u64) [1_000]u64 {
         \\    var c: [1_000]u64 =  [1]u64{ 0xFFFF_FFFF_FFFF_FFFF}**1_000;
-        \\    for (c [ 0_0 .. ]) |_, i| {
+        \\    for (c [ 1_0 .. ]) |_, i| {
         \\        c[i] = (a[i] | b[i]) & 0xCCAA_CCAA_CCAA_CCAA;
         \\    }
         \\    return c;
@@ -4276,7 +4276,7 @@ test "zig fmt: hex literals with underscore separators" {
     ,
         \\pub fn orMask(a: [1_000]u64, b: [1_000]u64) [1_000]u64 {
         \\    var c: [1_000]u64 = [1]u64{0xFFFF_FFFF_FFFF_FFFF} ** 1_000;
-        \\    for (c[0_0..]) |_, i| {
+        \\    for (c[1_0..]) |_, i| {
         \\        c[i] = (a[i] | b[i]) & 0xCCAA_CCAA_CCAA_CCAA;
         \\    }
         \\    return c;
@@ -4288,14 +4288,14 @@ test "zig fmt: hex literals with underscore separators" {
 test "zig fmt: decimal float literals with underscore separators" {
     try testTransform(
         \\pub fn main() void {
-        \\    const a:f64=(10.0e-0+(10.0e+0))+10_00.00_00e-2+00_00.00_10e+4;
-        \\    const b:f64=010.0--0_10.0+0_1_0.0_0+1e2;
+        \\    const a:f64=(10.0e-0+(10.0e+0))+10_00.00_00e-2+20_00.00_10e+4;
+        \\    const b:f64=1_0.0--10_10.0+1_0_0.0_0+1e2;
         \\    std.debug.warn("a: {}, b: {} -> a+b: {}\n", .{ a, b, a + b });
         \\}
     ,
         \\pub fn main() void {
-        \\    const a: f64 = (10.0e-0 + (10.0e+0)) + 10_00.00_00e-2 + 00_00.00_10e+4;
-        \\    const b: f64 = 010.0 - -0_10.0 + 0_1_0.0_0 + 1e2;
+        \\    const a: f64 = (10.0e-0 + (10.0e+0)) + 10_00.00_00e-2 + 20_00.00_10e+4;
+        \\    const b: f64 = 1_0.0 - -10_10.0 + 1_0_0.0_0 + 1e2;
         \\    std.debug.warn("a: {}, b: {} -> a+b: {}\n", .{ a, b, a + b });
         \\}
         \\
diff --git a/src/AstGen.zig b/src/AstGen.zig
index ee1dbeffa44d48eb44fc0ce761b663c22646d12d..2001e6950a44ac183411a16192401d465c072032 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -4088,6 +4088,13 @@ fn testDecl(
                             true => .signed,
                             false => .unsigned,
                         };
+                        if (ident_name_raw.len >= 3 and ident_name_raw[1] == '0') {
+                            return astgen.failTok(
+                                test_name_token,
+                                "primitive integer type '{s}' has leading zero",
+                                .{ident_name_raw},
+                            );
+                        }
                         _ = parseBitCount(ident_name_raw[1..]) catch |err| switch (err) {
                             error.Overflow => return astgen.failTok(
                                 test_name_token,
@@ -6791,6 +6798,13 @@ fn identifier(
                     true => .signed,
                     false => .unsigned,
                 };
+                if (ident_name_raw.len >= 3 and ident_name_raw[1] == '0') {
+                    return astgen.failNode(
+                        ident,
+                        "primitive integer type '{s}' has leading zero",
+                        .{ident_name_raw},
+                    );
+                }
                 const bit_count = parseBitCount(ident_name_raw[1..]) catch |err| switch (err) {
                     error.Overflow => return astgen.failNode(
                         ident,
@@ -7021,17 +7035,6 @@ fn integerLiteral(gz: *GenZir, rl: ResultLoc, node: Ast.Node.Index) InnerError!Z
     const main_tokens = tree.nodes.items(.main_token);
     const int_token = main_tokens[node];
     const prefixed_bytes = tree.tokenSlice(int_token);
-    if (std.fmt.parseInt(u64, prefixed_bytes, 0)) |small_int| {
-        const result: Zir.Inst.Ref = switch (small_int) {
-            0 => .zero,
-            1 => .one,
-            else => try gz.addInt(small_int),
-        };
-        return rvalue(gz, rl, result, node);
-    } else |err| switch (err) {
-        error.InvalidCharacter => unreachable, // Caught by the parser.
-        error.Overflow => {},
-    }
 
     var base: u8 = 10;
     var non_prefixed: []const u8 = prefixed_bytes;
@@ -7046,6 +7049,24 @@ fn integerLiteral(gz: *GenZir, rl: ResultLoc, node: Ast.Node.Index) InnerError!Z
         non_prefixed = prefixed_bytes[2..];
     }
 
+    if (base == 10 and prefixed_bytes.len >= 2 and prefixed_bytes[0] == '0') {
+        return astgen.failNodeNotes(node, "integer literal '{s}' has leading zero", .{prefixed_bytes}, &.{
+            try astgen.errNoteNode(node, "use '0o' prefix for octal literals", .{}),
+        });
+    }
+
+    if (std.fmt.parseUnsigned(u64, non_prefixed, base)) |small_int| {
+        const result: Zir.Inst.Ref = switch (small_int) {
+            0 => .zero,
+            1 => .one,
+            else => try gz.addInt(small_int),
+        };
+        return rvalue(gz, rl, result, node);
+    } else |err| switch (err) {
+        error.InvalidCharacter => unreachable, // Caught by the parser.
+        error.Overflow => {},
+    }
+
     const gpa = astgen.gpa;
     var big_int = try std.math.big.int.Managed.init(gpa);
     defer big_int.deinit();
diff --git a/test/behavior/math.zig b/test/behavior/math.zig
index ce476fea04e583379978fa6fe93ad9ea520114ed..d3f9676f11523c2a407d73cea935f47f242157a6 100644
--- a/test/behavior/math.zig
+++ b/test/behavior/math.zig
@@ -239,10 +239,9 @@ test "quad hex float literal parsing in range" {
 }
 
 test "underscore separator parsing" {
-    try expect(0_0_0_0 == 0);
     try expect(1_234_567 == 1234567);
-    try expect(001_234_567 == 1234567);
-    try expect(0_0_1_2_3_4_5_6_7 == 1234567);
+    try expect(1_234_567 == 1234567);
+    try expect(1_2_3_4_5_6_7 == 1234567);
 
     try expect(0b0_0_0_0 == 0);
     try expect(0b1010_1010 == 0b10101010);
@@ -260,7 +259,7 @@ test "underscore separator parsing" {
     try expect(0x1_0_1_0_1_0_1_0 == 0x10101010);
 
     try expect(123_456.789_000e1_0 == 123456.789000e10);
-    try expect(0_1_2_3_4_5_6.7_8_9_0_0_0e0_0_1_0 == 123456.789000e10);
+    try expect(1_2_3_4_5_6.7_8_9_0_0_0e0_0_1_0 == 123456.789000e10);
 
     try expect(0x1234_5678.9ABC_DEF0p-1_0 == 0x12345678.9ABCDEF0p-10);
     try expect(0x1_2_3_4_5_6_7_8.9_A_B_C_D_E_F_0p-0_0_0_1_0 == 0x12345678.9ABCDEF0p-10);
diff --git a/test/cases/compile_errors/invalid_underscore_placement_in_int_literal-1.zig b/test/cases/compile_errors/invalid_underscore_placement_in_int_literal-1.zig
index 868ea8d42af42d5ec30135dbfce799563c729698..b90c733dea19e09abbbeab76a70aa98dca2787de 100644
--- a/test/cases/compile_errors/invalid_underscore_placement_in_int_literal-1.zig
+++ b/test/cases/compile_errors/invalid_underscore_placement_in_int_literal-1.zig
@@ -1,5 +1,5 @@
 fn main() void {
-    var bad: u128 = 0010_;
+    var bad: u128 = 10_;
     _ = bad;
 }
 
@@ -8,4 +8,4 @@ fn main() void {
 // target=native
 //
 // :2:21: error: expected expression, found 'invalid bytes'
-// :2:26: note: invalid byte: ';'
+// :2:24: note: invalid byte: ';'
diff --git a/test/cases/compile_errors/leading_zero_in_integer.zig b/test/cases/compile_errors/leading_zero_in_integer.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a818a3d75dbfe13463792bc01b03f949d95b52fa
--- /dev/null
+++ b/test/cases/compile_errors/leading_zero_in_integer.zig
@@ -0,0 +1,27 @@
+export fn entry1() void {
+    const T = u000123;
+    _ = T;
+}
+export fn entry2() void {
+    _ = i0;
+    _ = u0;
+    var x: i01 = 1;
+    _ = x;
+}
+export fn entry3() void {
+    _ = 000123;
+}
+export fn entry4() void {
+    _ = 01;
+}
+
+// error
+// backend=llvm
+// target=native
+//
+// :2:15: error: primitive integer type 'u000123' has leading zero
+// :8:12: error: primitive integer type 'i01' has leading zero
+// :12:9: error: integer literal '000123' has leading zero
+// :12:9: note: use '0o' prefix for octal literals
+// :15:9: error: integer literal '01' has leading zero
+// :15:9: note: use '0o' prefix for octal literals
-- 
2.54.0


From b97ae88898b181ccc99188544411ff06e88e47ec Mon Sep 17 00:00:00 2001
From: Eric Joldasov <bratishkaerik@getgoogleoff.me>
Date: Fri, 12 Aug 2022 02:34:53 +0600
Subject: [PATCH 151/290] std.zig.system.NativeTargetInfo: look for a shebang
 line in /usr/bin/env, if any

---
 lib/std/zig/system/NativeTargetInfo.zig | 99 ++++++++++++++++++-------
 1 file changed, 71 insertions(+), 28 deletions(-)

diff --git a/lib/std/zig/system/NativeTargetInfo.zig b/lib/std/zig/system/NativeTargetInfo.zig
index 002ad49d643d2414ed6d2c4f0717a1c8409d269d..6dcedd93b8c8c30fe34a456b636c5ec7d0991c16 100644
--- a/lib/std/zig/system/NativeTargetInfo.zig
+++ b/lib/std/zig/system/NativeTargetInfo.zig
@@ -237,7 +237,7 @@ pub fn detect(allocator: Allocator, cross_target: CrossTarget) DetectError!Nativ
 
 /// First we attempt to use the executable's own binary. If it is dynamically
 /// linked, then it should answer both the C ABI question and the dynamic linker question.
-/// If it is statically linked, then we try /usr/bin/env. If that does not provide the answer, then
+/// If it is statically linked, then we try /usr/bin/env (or the file it references in shebang). If that does not provide the answer, then
 /// we fall back to the defaults.
 /// TODO Remove the Allocator requirement from this function.
 fn detectAbiAndDynamicLinker(
@@ -355,37 +355,77 @@ fn detectAbiAndDynamicLinker(
         return result;
     }
 
-    const env_file = std.fs.openFileAbsoluteZ("/usr/bin/env", .{}) catch |err| switch (err) {
-        error.NoSpaceLeft => unreachable,
-        error.NameTooLong => unreachable,
-        error.PathAlreadyExists => unreachable,
-        error.SharingViolation => unreachable,
-        error.InvalidUtf8 => unreachable,
-        error.BadPathName => unreachable,
-        error.PipeBusy => unreachable,
-        error.FileLocksNotSupported => unreachable,
-        error.WouldBlock => unreachable,
-        error.FileBusy => unreachable, // opened without write permissions
+    const elf_file = blk: {
+        // This block looks for a shebang line in /usr/bin/env,
+        // if it finds one, then instead of using /usr/bin/env as the ELF file to examine, it uses the file it references instead,
+        // doing the same logic recursively in case it finds another shebang line.
 
-        error.IsDir,
-        error.NotDir,
-        error.InvalidHandle,
-        error.AccessDenied,
-        error.NoDevice,
-        error.FileNotFound,
-        error.FileTooBig,
-        error.Unexpected,
-        => return defaultAbiAndDynamicLinker(cpu, os, cross_target),
+        // Since /usr/bin/env is hard-coded into the shebang line of many portable scripts, it's a
+        // reasonably reliable path to start with.
+        var file_name: []const u8 = "/usr/bin/env";
+        // #! (2) + 255 (max length of shebang line since Linux 5.1) + \n (1)
+        var buffer: [258]u8 = undefined;
+        while (true) {
+            const file = std.fs.openFileAbsolute(file_name, .{}) catch |err| switch (err) {
+                error.NoSpaceLeft => unreachable,
+                error.NameTooLong => unreachable,
+                error.PathAlreadyExists => unreachable,
+                error.SharingViolation => unreachable,
+                error.InvalidUtf8 => unreachable,
+                error.BadPathName => unreachable,
+                error.PipeBusy => unreachable,
+                error.FileLocksNotSupported => unreachable,
+                error.WouldBlock => unreachable,
+                error.FileBusy => unreachable, // opened without write permissions
 
-        else => |e| return e,
+                error.IsDir,
+                error.NotDir,
+                error.InvalidHandle,
+                error.AccessDenied,
+                error.NoDevice,
+                error.FileNotFound,
+                error.FileTooBig,
+                error.Unexpected,
+                => |e| {
+                    std.log.warn("Encoutered error: {s}, falling back to default ABI and dynamic linker.\n", .{@errorName(e)});
+                    return defaultAbiAndDynamicLinker(cpu, os, cross_target);
+                },
+
+                else => |e| return e,
+            };
+
+            const line = file.reader().readUntilDelimiter(&buffer, '\n') catch |err| switch (err) {
+                error.IsDir => unreachable, // Handled before
+                error.AccessDenied => unreachable,
+                error.WouldBlock => unreachable, // Did not request blocking mode
+                error.OperationAborted => unreachable, // Windows-only
+                error.BrokenPipe => unreachable,
+                error.ConnectionResetByPeer => unreachable,
+                error.ConnectionTimedOut => unreachable,
+                error.InputOutput => unreachable,
+                error.Unexpected => unreachable,
+
+                error.StreamTooLong,
+                error.EndOfStream,
+                error.NotOpenForReading,
+                => break :blk file,
+
+                else => |e| {
+                    file.close();
+                    return e;
+                },
+            };
+            if (!mem.startsWith(u8, line, "#!")) break :blk file;
+            var it = std.mem.tokenize(u8, line[2..], " ");
+            file.close();
+            file_name = it.next() orelse return defaultAbiAndDynamicLinker(cpu, os, cross_target);
+        }
     };
-    defer env_file.close();
+    defer elf_file.close();
 
     // If Zig is statically linked, such as via distributed binary static builds, the above
-    // trick won't work. The next thing we fall back to is the same thing, but for /usr/bin/env.
-    // Since that path is hard-coded into the shebang line of many portable scripts, it's a
-    // reasonably reliable path to check for.
-    return abiAndDynamicLinkerFromFile(env_file, cpu, os, ld_info_list, cross_target) catch |err| switch (err) {
+    // trick (block self_exe) won't work. The next thing we fall back to is the same thing, but for elf_file.
+    return abiAndDynamicLinkerFromFile(elf_file, cpu, os, ld_info_list, cross_target) catch |err| switch (err) {
         error.FileSystem,
         error.SystemResources,
         error.SymLinkLoop,
@@ -403,7 +443,10 @@ fn detectAbiAndDynamicLinker(
         error.UnexpectedEndOfFile,
         error.NameTooLong,
         // Finally, we fall back on the standard path.
-        => defaultAbiAndDynamicLinker(cpu, os, cross_target),
+        => |e| {
+            std.log.warn("Encoutered error: {s}, falling back to default ABI and dynamic linker.\n", .{@errorName(e)});
+            return defaultAbiAndDynamicLinker(cpu, os, cross_target);
+        },
     };
 }
 
-- 
2.54.0


From f6459721e549e91858edc2e93de398e3e3cae45e Mon Sep 17 00:00:00 2001
From: Sage Hane <sage@sagehane.com>
Date: Sun, 7 Aug 2022 01:17:49 +0900
Subject: [PATCH 152/290] std.build: Fix typo in
 `LibExeObjStep.runEmulatable`'s assertion

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

diff --git a/lib/std/build.zig b/lib/std/build.zig
index b5defc2e9c0254838bbb88ca9ed0758ba03585f8..57f0d126d8c0e9ea4db115e1fccc8986517a8da9 100644
--- a/lib/std/build.zig
+++ b/lib/std/build.zig
@@ -1896,7 +1896,7 @@ pub const LibExeObjStep = struct {
     /// When a binary cannot be ran through emulation or the option is disabled, a warning
     /// will be printed and the binary will *NOT* be ran.
     pub fn runEmulatable(exe: *LibExeObjStep) *EmulatableRunStep {
-        assert(exe.kind == .exe or exe.kind == .text_exe);
+        assert(exe.kind == .exe or exe.kind == .test_exe);
 
         const run_step = EmulatableRunStep.create(exe.builder.fmt("run {s}", .{exe.step.name}), exe);
         if (exe.vcpkg_bin_path) |path| {
-- 
2.54.0


From 51b2aa16438bccda8b05a07ea3b1c32021731c12 Mon Sep 17 00:00:00 2001
From: Ali Chraghi <63465728+alichraghi@users.noreply.github.com>
Date: Thu, 18 Aug 2022 22:02:02 +0430
Subject: [PATCH 153/290] docs: add padding between functions list

---
 lib/docs/index.html | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index 236923c1d89952bd3d34dd0391c3f7047b05be58..b2a443b253612e6d9571604f0cc0e8cbdbb445a6 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -352,6 +352,10 @@
         box-shadow: inset 0 -0.2em 0 #c6cbd1;
         cursor: default;
       }
+      
+      #listFns > div {
+        padding-bottom: 10px;
+      }
 
       #listFns dt {
         font-family: var(--mono);
-- 
2.54.0


From b12992cb0172bc2de1f1aae3da57b952dbaf70cd Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Thu, 18 Aug 2022 15:32:15 +0200
Subject: [PATCH 154/290] macho: do not open file handle when building static
 archive

Firstly, opening a file handle is not really needed since we won't even
use it, and secondly, this can cause AccessDenied errors on Windows
when trying to move a directory from zig-cache/tmp/ to zig-cache/o/
since, without POSIX semantics, it is illegal to move directories
with open handles to any of its resources.
---
 src/link.zig       |  7 +++++--
 src/link/MachO.zig | 18 +++++++++---------
 2 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/src/link.zig b/src/link.zig
index 14ae142a3fbe4a8eba828f82de53fc9a6ff92c79..a6dafce20e5bb9948240b0b20bc491564b7ae0a5 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -772,12 +772,15 @@ pub const File = struct {
                     error.FileNotFound => {},
                     else => |e| return e,
                 }
-                try std.fs.rename(
+                std.fs.rename(
                     cache_directory.handle,
                     tmp_dir_sub_path,
                     cache_directory.handle,
                     o_sub_path,
-                );
+                ) catch |err| switch (err) {
+                    error.AccessDenied => unreachable, // We are most likely trying to move a dir with open handles to its resources
+                    else => |e| return e,
+                };
                 break;
             } else {
                 std.fs.rename(
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 3da086a382fc38179011e8c6587f18806f4d2e3b..e4370c703e3932f610df1fbceb8c7941a293a062 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -276,22 +276,14 @@ pub fn openPath(allocator: Allocator, options: link.Options) !*MachO {
     if (use_stage1 or options.emit == null) {
         return createEmpty(allocator, options);
     }
+
     const emit = options.emit.?;
-    const file = try emit.directory.handle.createFile(emit.sub_path, .{
-        .truncate = false,
-        .read = true,
-        .mode = link.determineMode(options),
-    });
-    errdefer file.close();
-
     const self = try createEmpty(allocator, options);
     errdefer {
         self.base.file = null;
         self.base.destroy();
     }
 
-    self.base.file = file;
-
     if (build_options.have_llvm and options.use_llvm and options.module != null) {
         // TODO this intermediary_basename isn't enough; in the case of `zig build-exe`,
         // we also want to put the intermediary object file in the cache while the
@@ -307,6 +299,14 @@ pub fn openPath(allocator: Allocator, options: link.Options) !*MachO {
         return self;
     }
 
+    const file = try emit.directory.handle.createFile(emit.sub_path, .{
+        .truncate = false,
+        .read = true,
+        .mode = link.determineMode(options),
+    });
+    errdefer file.close();
+    self.base.file = file;
+
     if (!options.strip and options.module != null) blk: {
         // TODO once I add support for converting (and relocating) DWARF info from relocatable
         // object files, this check becomes unnecessary.
-- 
2.54.0


From 7d674d5fb664b6e2d4d3d5b85751ed464dc4c4b9 Mon Sep 17 00:00:00 2001
From: Ben Fiedler <git@bfiedler.ch>
Date: Tue, 16 Aug 2022 18:10:23 +0200
Subject: [PATCH 155/290] build: Allow comptime_int in OptionsStep.addOption

---
 lib/std/build/OptionsStep.zig | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/lib/std/build/OptionsStep.zig b/lib/std/build/OptionsStep.zig
index 7b219a210ef426a7ee8a2a78405211264d3bf5a8..89a0b3ab3efa0145d6c1f64b74649fe27bd698e7 100644
--- a/lib/std/build/OptionsStep.zig
+++ b/lib/std/build/OptionsStep.zig
@@ -171,6 +171,7 @@ fn printLiteral(out: anytype, val: anytype, indent: u8) !void {
         .Void,
         .Bool,
         .Int,
+        .ComptimeInt,
         .Float,
         .Null,
         => try out.print("{any}", .{val}),
@@ -302,6 +303,7 @@ test "OptionsStep" {
     options.addOption(usize, "option1", 1);
     options.addOption(?usize, "option2", null);
     options.addOption(?usize, "option3", 3);
+    options.addOption(comptime_int, "option4", 4);
     options.addOption([]const u8, "string", "zigisthebest");
     options.addOption(?[]const u8, "optional_string", null);
     options.addOption([2][2]u16, "nested_array", nested_array);
@@ -314,6 +316,7 @@ test "OptionsStep" {
         \\pub const option1: usize = 1;
         \\pub const option2: ?usize = null;
         \\pub const option3: ?usize = 3;
+        \\pub const option4: comptime_int = 4;
         \\pub const string: []const u8 = "zigisthebest";
         \\pub const optional_string: ?[]const u8 = null;
         \\pub const nested_array: [2][2]u16 = [2][2]u16 {
-- 
2.54.0


From c5ba941b77fbdb06841f28142420c6786f2a4d0c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sat, 16 Jul 2022 15:18:36 -0700
Subject: [PATCH 156/290] stage2: all pointers have runtime bits

---
 src/type.zig | 36 ++++++++++++------------------------
 1 file changed, 12 insertions(+), 24 deletions(-)

diff --git a/src/type.zig b/src/type.zig
index 55847b8adda6a68efbda6ce9f020ecdcd6679ef7..700f5245562b0d2fd14eaddf3762f3eea8a12863 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -2374,6 +2374,18 @@ pub const Type = extern union {
             .error_union,
             .error_set,
             .error_set_merged,
+            .anyframe_T,
+            .optional_single_mut_pointer,
+            .optional_single_const_pointer,
+            .single_const_pointer,
+            .single_mut_pointer,
+            .many_const_pointer,
+            .many_mut_pointer,
+            .c_const_pointer,
+            .c_mut_pointer,
+            .const_slice,
+            .mut_slice,
+            .pointer,
             => return true,
 
             // These are false because they are comptime-only types.
@@ -2399,30 +2411,6 @@ pub const Type = extern union {
             .fn_ccc_void_no_args,
             => return false,
 
-            // These types have more than one possible value, so the result is the same as
-            // asking whether they are comptime-only types.
-            .anyframe_T,
-            .optional_single_mut_pointer,
-            .optional_single_const_pointer,
-            .single_const_pointer,
-            .single_mut_pointer,
-            .many_const_pointer,
-            .many_mut_pointer,
-            .c_const_pointer,
-            .c_mut_pointer,
-            .const_slice,
-            .mut_slice,
-            .pointer,
-            => {
-                if (ignore_comptime_only) {
-                    return true;
-                } else if (sema_kit) |sk| {
-                    return !(try sk.sema.typeRequiresComptime(sk.block, sk.src, ty));
-                } else {
-                    return !comptimeOnly(ty);
-                }
-            },
-
             .optional => {
                 var buf: Payload.ElemType = undefined;
                 const child_ty = ty.optionalChild(&buf);
-- 
2.54.0


From 6e313eb1107d4f5d7b0ada0a67c810ce90e79bf5 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sat, 16 Jul 2022 16:27:37 -0700
Subject: [PATCH 157/290] stage2: agree with LLVM that `@alignOf(u128)` is 8

on x86_64 and similar targets.
---
 lib/std/target.zig      |  7 ++++---
 src/Module.zig          | 30 +++++++++++++++++++++++++-----
 src/Sema.zig            |  5 +----
 src/codegen/llvm.zig    | 14 ++++++++------
 src/type.zig            | 13 +++++++++++--
 test/behavior/align.zig | 29 +++++++++++++++++++++--------
 6 files changed, 70 insertions(+), 28 deletions(-)

diff --git a/lib/std/target.zig b/lib/std/target.zig
index f77f73bce0bac90cb1534a7f46e9366040d5c89e..155c59bdfcfded88a43d62c6fe62fc2882613675 100644
--- a/lib/std/target.zig
+++ b/lib/std/target.zig
@@ -1806,9 +1806,9 @@ pub const Target = struct {
                 else => 4,
             },
 
-            // For x86_64, LLVMABIAlignmentOfType(i128) reports 8. However I think 16
-            // is a better number for two reasons:
-            // 1. Better machine code when loading into SIMD register.
+            // For these, LLVMABIAlignmentOfType(i128) reports 8. Note that 16
+            // is a relevant number in three cases:
+            // 1. Different machine code instruction when loading into SIMD register.
             // 2. The C ABI wants 16 for extern structs.
             // 3. 16-byte cmpxchg needs 16-byte alignment.
             // Same logic for riscv64, powerpc64, mips64, sparc64.
@@ -1819,6 +1819,7 @@ pub const Target = struct {
             .mips64,
             .mips64el,
             .sparc64,
+            => 8,
 
             // Even LLVMABIAlignmentOfType(i128) agrees on these targets.
             .aarch64,
diff --git a/src/Module.zig b/src/Module.zig
index 995fdda7ea24d16437f29442e004681580883af5..6d2180e8e7476c9dc4b330da0be559ab99755f86 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -935,13 +935,33 @@ pub const Struct = struct {
         /// If true then `default_val` is the comptime field value.
         is_comptime: bool,
 
-        /// Returns the field alignment, assuming the struct is not packed.
-        pub fn normalAlignment(field: Field, target: Target) u32 {
-            if (field.abi_align == 0) {
-                return field.ty.abiAlignment(target);
-            } else {
+        /// Returns the field alignment. If the struct is packed, returns 0.
+        pub fn alignment(
+            field: Field,
+            target: Target,
+            layout: std.builtin.Type.ContainerLayout,
+        ) u32 {
+            if (field.abi_align != 0) {
+                assert(layout != .Packed);
                 return field.abi_align;
             }
+
+            switch (layout) {
+                .Packed => return 0,
+                .Auto => return field.ty.abiAlignment(target),
+                .Extern => {
+                    // This logic is duplicated in Type.abiAlignmentAdvanced.
+                    const ty_abi_align = field.ty.abiAlignment(target);
+
+                    if (field.ty.isAbiInt() and field.ty.intInfo(target).bits >= 128) {
+                        // The C ABI requires 128 bit integer fields of structs
+                        // to be 16-bytes aligned.
+                        return @maximum(ty_abi_align, 16);
+                    }
+
+                    return ty_abi_align;
+                },
+            }
         }
     };
 
diff --git a/src/Sema.zig b/src/Sema.zig
index d6ac3d02766ae2287b7ade5d2bcbaf61a4297acc..32b95a4c21be3bfd8f89285774f929c7279489b3 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -14380,10 +14380,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
                     else
                         field.default_val;
                     const default_val_ptr = try sema.optRefValue(block, src, field.ty, opt_default_val);
-                    const alignment = switch (layout) {
-                        .Auto, .Extern => field.normalAlignment(target),
-                        .Packed => 0,
-                    };
+                    const alignment = field.alignment(target, layout);
 
                     struct_field_fields.* = .{
                         // name: []const u8,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 0586c994320b91708d92d8962cccf7c487b6b5d2..a9a343439df3908d7f0a3ef4c876f5f18d93befb 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1841,6 +1841,7 @@ pub const Object = struct {
                 }
 
                 const fields = ty.structFields();
+                const layout = ty.containerLayout();
 
                 var di_fields: std.ArrayListUnmanaged(*llvm.DIType) = .{};
                 defer di_fields.deinit(gpa);
@@ -1854,7 +1855,7 @@ pub const Object = struct {
                     if (field.is_comptime or !field.ty.hasRuntimeBitsIgnoreComptime()) continue;
 
                     const field_size = field.ty.abiSize(target);
-                    const field_align = field.normalAlignment(target);
+                    const field_align = field.alignment(target, layout);
                     const field_offset = std.mem.alignForwardGeneric(u64, offset, field_align);
                     offset = field_offset + field_size;
 
@@ -2499,7 +2500,7 @@ pub const DeclGen = struct {
 
     fn lowerType(dg: *DeclGen, t: Type) Allocator.Error!*const llvm.Type {
         const llvm_ty = try lowerTypeInner(dg, t);
-        if (std.debug.runtime_safety and false) check: {
+        if (std.debug.runtime_safety) check: {
             if (t.zigTypeTag() == .Opaque) break :check;
             if (!t.hasRuntimeBits()) break :check;
             if (!llvm_ty.isSized().toBool()) break :check;
@@ -2757,7 +2758,7 @@ pub const DeclGen = struct {
                 for (struct_obj.fields.values()) |field| {
                     if (field.is_comptime or !field.ty.hasRuntimeBitsIgnoreComptime()) continue;
 
-                    const field_align = field.normalAlignment(target);
+                    const field_align = field.alignment(target, struct_obj.layout);
                     const field_ty_align = field.ty.abiAlignment(target);
                     any_underaligned_fields = any_underaligned_fields or
                         field_align < field_ty_align;
@@ -3433,7 +3434,7 @@ pub const DeclGen = struct {
                 for (struct_obj.fields.values()) |field, i| {
                     if (field.is_comptime or !field.ty.hasRuntimeBitsIgnoreComptime()) continue;
 
-                    const field_align = field.normalAlignment(target);
+                    const field_align = field.alignment(target, struct_obj.layout);
                     big_align = @maximum(big_align, field_align);
                     const prev_offset = offset;
                     offset = std.mem.alignForwardGeneric(u64, offset, field_align);
@@ -9376,13 +9377,14 @@ fn llvmFieldIndex(
         }
         return null;
     }
-    assert(ty.containerLayout() != .Packed);
+    const layout = ty.containerLayout();
+    assert(layout != .Packed);
 
     var llvm_field_index: c_uint = 0;
     for (ty.structFields().values()) |field, i| {
         if (field.is_comptime or !field.ty.hasRuntimeBitsIgnoreComptime()) continue;
 
-        const field_align = field.normalAlignment(target);
+        const field_align = field.alignment(target, layout);
         big_align = @maximum(big_align, field_align);
         const prev_offset = offset;
         offset = std.mem.alignForwardGeneric(u64, offset, field_align);
diff --git a/src/type.zig b/src/type.zig
index 700f5245562b0d2fd14eaddf3762f3eea8a12863..4432ae9cf3d25d33708ff8723c6a205f74182e39 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -3017,6 +3017,15 @@ pub const Type = extern union {
                         },
                     };
                     big_align = @maximum(big_align, field_align);
+
+                    // This logic is duplicated in Module.Struct.Field.alignment.
+                    if (struct_obj.layout == .Extern) {
+                        if (field.ty.isAbiInt() and field.ty.intInfo(target).bits >= 128) {
+                            // The C ABI requires 128 bit integer fields of structs
+                            // to be 16-bytes aligned.
+                            big_align = @maximum(big_align, 16);
+                        }
+                    }
                 }
                 return AbiAlignmentAdvanced{ .scalar = big_align };
             },
@@ -5490,7 +5499,7 @@ pub const Type = extern union {
             .@"struct" => {
                 const struct_obj = ty.castTag(.@"struct").?.data;
                 assert(struct_obj.layout != .Packed);
-                return struct_obj.fields.values()[index].normalAlignment(target);
+                return struct_obj.fields.values()[index].alignment(target, struct_obj.layout);
             },
             .@"union", .union_safety_tagged, .union_tagged => {
                 const union_obj = ty.cast(Payload.Union).?.data;
@@ -5597,7 +5606,7 @@ pub const Type = extern union {
             if (!field.ty.hasRuntimeBits() or field.is_comptime)
                 return FieldOffset{ .field = it.field, .offset = it.offset };
 
-            const field_align = field.normalAlignment(it.target);
+            const field_align = field.alignment(it.target, it.struct_obj.layout);
             it.big_align = @maximum(it.big_align, field_align);
             it.offset = std.mem.alignForwardGeneric(u64, it.offset, field_align);
             defer it.offset += field.ty.abiSize(it.target);
diff --git a/test/behavior/align.zig b/test/behavior/align.zig
index 26e3d9137335c61c65663429b0b70f443774a5ea..4a824bc9cf48276281cc77a17e01934deb64e6ed 100644
--- a/test/behavior/align.zig
+++ b/test/behavior/align.zig
@@ -143,6 +143,19 @@ test "alignment and size of structs with 128-bit fields" {
         .riscv64,
         .sparc64,
         .x86_64,
+        => .{
+            .a_align = 8,
+            .a_size = 16,
+
+            .b_align = 16,
+            .b_size = 32,
+
+            .u128_align = 8,
+            .u128_size = 16,
+            .u129_align = 8,
+            .u129_size = 24,
+        },
+
         .aarch64,
         .aarch64_be,
         .aarch64_32,
@@ -166,17 +179,17 @@ test "alignment and size of structs with 128-bit fields" {
         else => return error.SkipZigTest,
     };
     comptime {
-        std.debug.assert(@alignOf(A) == expected.a_align);
-        std.debug.assert(@sizeOf(A) == expected.a_size);
+        assert(@alignOf(A) == expected.a_align);
+        assert(@sizeOf(A) == expected.a_size);
 
-        std.debug.assert(@alignOf(B) == expected.b_align);
-        std.debug.assert(@sizeOf(B) == expected.b_size);
+        assert(@alignOf(B) == expected.b_align);
+        assert(@sizeOf(B) == expected.b_size);
 
-        std.debug.assert(@alignOf(u128) == expected.u128_align);
-        std.debug.assert(@sizeOf(u128) == expected.u128_size);
+        assert(@alignOf(u128) == expected.u128_align);
+        assert(@sizeOf(u128) == expected.u128_size);
 
-        std.debug.assert(@alignOf(u129) == expected.u129_align);
-        std.debug.assert(@sizeOf(u129) == expected.u129_size);
+        assert(@alignOf(u129) == expected.u129_align);
+        assert(@sizeOf(u129) == expected.u129_size);
     }
 }
 
-- 
2.54.0


From 4552ccb6856a84bb88badb265c43114ff57bd90c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sat, 16 Jul 2022 16:48:47 -0700
Subject: [PATCH 158/290] stage2: make `@Vector` ABI size agree with LLVM

---
 src/type.zig | 26 ++++++++++++++++++++++++--
 1 file changed, 24 insertions(+), 2 deletions(-)

diff --git a/src/type.zig b/src/type.zig
index 4432ae9cf3d25d33708ff8723c6a205f74182e39..fb2ca1e3fcb812a5bf2d237af75455f92e4a2d26 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -3260,8 +3260,8 @@ pub const Type = extern union {
 
             .array_u8 => return AbiSizeAdvanced{ .scalar = ty.castTag(.array_u8).?.data },
             .array_u8_sentinel_0 => return AbiSizeAdvanced{ .scalar = ty.castTag(.array_u8_sentinel_0).?.data + 1 },
-            .array, .vector => {
-                const payload = ty.cast(Payload.Array).?.data;
+            .array => {
+                const payload = ty.castTag(.array).?.data;
                 switch (try payload.elem_type.abiSizeAdvanced(target, strat)) {
                     .scalar => |elem_size| return AbiSizeAdvanced{ .scalar = payload.len * elem_size },
                     .val => switch (strat) {
@@ -3283,6 +3283,28 @@ pub const Type = extern union {
                 }
             },
 
+            .vector => {
+                const payload = ty.castTag(.vector).?.data;
+                const sema_kit = switch (strat) {
+                    .sema_kit => |sk| sk,
+                    .eager => null,
+                    .lazy => |arena| return AbiSizeAdvanced{
+                        .val = try Value.Tag.lazy_size.create(arena, ty),
+                    },
+                };
+                const elem_bits = try payload.elem_type.bitSizeAdvanced(target, sema_kit);
+                const total_bits = elem_bits * payload.len;
+                const total_bytes = (total_bits + 7) / 8;
+                const alignment = switch (try ty.abiAlignmentAdvanced(target, strat)) {
+                    .scalar => |x| x,
+                    .val => return AbiSizeAdvanced{
+                        .val = try Value.Tag.lazy_size.create(strat.lazy, ty),
+                    },
+                };
+                const result = std.mem.alignForwardGeneric(u64, total_bytes, alignment);
+                return AbiSizeAdvanced{ .scalar = result };
+            },
+
             .isize,
             .usize,
             .@"anyframe",
-- 
2.54.0


From 517eb73b23ee77672abe6b20b79b6648cd3ff879 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sat, 16 Jul 2022 17:03:05 -0700
Subject: [PATCH 159/290] LLVM: disable the ABI size safety check

There still more instances of this check being tripped during behavior
tests that we need to fix before we can enable this.
---
 src/codegen/llvm.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index a9a343439df3908d7f0a3ef4c876f5f18d93befb..983813d780c17f36d6c07101744a2a924ba9f662 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -2500,7 +2500,7 @@ pub const DeclGen = struct {
 
     fn lowerType(dg: *DeclGen, t: Type) Allocator.Error!*const llvm.Type {
         const llvm_ty = try lowerTypeInner(dg, t);
-        if (std.debug.runtime_safety) check: {
+        if (std.debug.runtime_safety and false) check: {
             if (t.zigTypeTag() == .Opaque) break :check;
             if (!t.hasRuntimeBits()) break :check;
             if (!llvm_ty.isSized().toBool()) break :check;
-- 
2.54.0


From b975f7a56fec9e0e7aca9832282bc772c743d731 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 18 Aug 2022 18:58:28 -0700
Subject: [PATCH 160/290] std.Target gains ObjectFormat field

---
 lib/std/target.zig                      | 33 ++++++++--------
 lib/std/zig.zig                         | 12 +++---
 lib/std/zig/CrossTarget.zig             | 13 ++++++-
 lib/std/zig/system/NativeTargetInfo.zig |  5 +++
 src/Compilation.zig                     | 30 +++++++--------
 src/Sema.zig                            |  2 +-
 src/codegen/llvm.zig                    |  2 +-
 src/link.zig                            | 11 +++---
 src/link/C.zig                          |  2 +-
 src/link/Coff.zig                       |  2 +-
 src/link/Elf.zig                        |  2 +-
 src/link/MachO.zig                      |  4 +-
 src/link/NvPtx.zig                      |  2 +-
 src/link/Plan9.zig                      |  2 +-
 src/link/SpirV.zig                      |  2 +-
 src/link/Wasm.zig                       |  2 +-
 src/main.zig                            | 51 +++++++++++--------------
 src/stage1/codegen.cpp                  |  1 +
 18 files changed, 93 insertions(+), 85 deletions(-)

diff --git a/lib/std/target.zig b/lib/std/target.zig
index 155c59bdfcfded88a43d62c6fe62fc2882613675..00553bb520797e40c8555b297a1a07ade95326cd 100644
--- a/lib/std/target.zig
+++ b/lib/std/target.zig
@@ -9,6 +9,7 @@ pub const Target = struct {
     cpu: Cpu,
     os: Os,
     abi: Abi,
+    ofmt: ObjectFormat,
 
     pub const Os = struct {
         tag: Tag,
@@ -594,6 +595,20 @@ pub const Target = struct {
                 .nvptx => ".ptx",
             };
         }
+
+        pub fn default(os_tag: Os.Tag, cpu_arch: Cpu.Arch) ObjectFormat {
+            return switch (os_tag) {
+                .windows, .uefi => .coff,
+                .ios, .macos, .watchos, .tvos => .macho,
+                .plan9 => .plan9,
+                else => return switch (cpu_arch) {
+                    .wasm32, .wasm64 => .wasm,
+                    .spirv32, .spirv64 => .spirv,
+                    .nvptx, .nvptx64 => .nvptx,
+                    else => .elf,
+                },
+            };
+        }
     };
 
     pub const SubSystem = enum {
@@ -1381,24 +1396,6 @@ pub const Target = struct {
         return libPrefix_os_abi(self.os.tag, self.abi);
     }
 
-    pub fn getObjectFormatSimple(os_tag: Os.Tag, cpu_arch: Cpu.Arch) ObjectFormat {
-        return switch (os_tag) {
-            .windows, .uefi => .coff,
-            .ios, .macos, .watchos, .tvos => .macho,
-            .plan9 => .plan9,
-            else => return switch (cpu_arch) {
-                .wasm32, .wasm64 => .wasm,
-                .spirv32, .spirv64 => .spirv,
-                .nvptx, .nvptx64 => .nvptx,
-                else => .elf,
-            },
-        };
-    }
-
-    pub fn getObjectFormat(self: Target) ObjectFormat {
-        return getObjectFormatSimple(self.os.tag, self.cpu.arch);
-    }
-
     pub fn isMinGW(self: Target) bool {
         return self.os.tag == .windows and self.isGnu();
     }
diff --git a/lib/std/zig.zig b/lib/std/zig.zig
index b8f75f649eef313319ea2d8f18e117a6dc67771e..85835ebf1880b1c4af37b46f239f8530572b5b55 100644
--- a/lib/std/zig.zig
+++ b/lib/std/zig.zig
@@ -103,7 +103,6 @@ pub const BinNameOptions = struct {
     target: std.Target,
     output_mode: std.builtin.OutputMode,
     link_mode: ?std.builtin.LinkMode = null,
-    object_format: ?std.Target.ObjectFormat = null,
     version: ?std.builtin.Version = null,
 };
 
@@ -111,8 +110,7 @@ pub const BinNameOptions = struct {
 pub fn binNameAlloc(allocator: std.mem.Allocator, options: BinNameOptions) error{OutOfMemory}![]u8 {
     const root_name = options.root_name;
     const target = options.target;
-    const ofmt = options.object_format orelse target.getObjectFormat();
-    switch (ofmt) {
+    switch (target.ofmt) {
         .coff => switch (options.output_mode) {
             .Exe => return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, target.exeFileExt() }),
             .Lib => {
@@ -186,8 +184,12 @@ pub fn binNameAlloc(allocator: std.mem.Allocator, options: BinNameOptions) error
         .raw => return std.fmt.allocPrint(allocator, "{s}.bin", .{root_name}),
         .plan9 => switch (options.output_mode) {
             .Exe => return allocator.dupe(u8, root_name),
-            .Obj => return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, ofmt.fileExt(target.cpu.arch) }),
-            .Lib => return std.fmt.allocPrint(allocator, "{s}{s}.a", .{ target.libPrefix(), root_name }),
+            .Obj => return std.fmt.allocPrint(allocator, "{s}{s}", .{
+                root_name, target.ofmt.fileExt(target.cpu.arch),
+            }),
+            .Lib => return std.fmt.allocPrint(allocator, "{s}{s}.a", .{
+                target.libPrefix(), root_name,
+            }),
         },
         .nvptx => return std.fmt.allocPrint(allocator, "{s}", .{root_name}),
     }
diff --git a/lib/std/zig/CrossTarget.zig b/lib/std/zig/CrossTarget.zig
index 196afbc83560c828a8d67838ed3859dda569d896..a4e9b2576d4167963da7ea400bf093826b1cb50f 100644
--- a/lib/std/zig/CrossTarget.zig
+++ b/lib/std/zig/CrossTarget.zig
@@ -42,6 +42,9 @@ abi: ?Target.Abi = null,
 /// based on the `os_tag`.
 dynamic_linker: DynamicLinker = DynamicLinker{},
 
+/// `null` means default for the cpu/arch/os combo.
+ofmt: ?Target.ObjectFormat = null,
+
 pub const CpuModel = union(enum) {
     /// Always native
     native,
@@ -168,6 +171,7 @@ pub fn toTarget(self: CrossTarget) Target {
         .cpu = self.getCpu(),
         .os = self.getOs(),
         .abi = self.getAbi(),
+        .ofmt = self.getObjectFormat(),
     };
 }
 
@@ -197,6 +201,8 @@ pub const ParseOptions = struct {
     /// detected path, or a standard path.
     dynamic_linker: ?[]const u8 = null,
 
+    object_format: ?[]const u8 = null,
+
     /// If this is provided, the function will populate some information about parsing failures,
     /// so that user-friendly error messages can be delivered.
     diagnostics: ?*Diagnostics = null,
@@ -321,6 +327,11 @@ pub fn parse(args: ParseOptions) !CrossTarget {
         }
     }
 
+    if (args.object_format) |ofmt_name| {
+        result.ofmt = std.meta.stringToEnum(Target.ObjectFormat, ofmt_name) orelse
+            return error.UnknownObjectFormat;
+    }
+
     return result;
 }
 
@@ -620,7 +631,7 @@ pub fn setGnuLibCVersion(self: *CrossTarget, major: u32, minor: u32, patch: u32)
 }
 
 pub fn getObjectFormat(self: CrossTarget) Target.ObjectFormat {
-    return Target.getObjectFormatSimple(self.getOsTag(), self.getCpuArch());
+    return self.ofmt orelse Target.ObjectFormat.default(self.getOsTag(), self.getCpuArch());
 }
 
 pub fn updateCpuFeatures(self: CrossTarget, set: *Target.Cpu.Feature.Set) void {
diff --git a/lib/std/zig/system/NativeTargetInfo.zig b/lib/std/zig/system/NativeTargetInfo.zig
index 6dcedd93b8c8c30fe34a456b636c5ec7d0991c16..4f8c0025c5dda3ce0b1b7bc8868bd1536501cc2f 100644
--- a/lib/std/zig/system/NativeTargetInfo.zig
+++ b/lib/std/zig/system/NativeTargetInfo.zig
@@ -276,6 +276,7 @@ fn detectAbiAndDynamicLinker(
     };
     var ld_info_list_buffer: [all_abis.len]LdInfo = undefined;
     var ld_info_list_len: usize = 0;
+    const ofmt = cross_target.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
@@ -284,6 +285,7 @@ fn detectAbiAndDynamicLinker(
             .cpu = cpu,
             .os = os,
             .abi = abi,
+            .ofmt = ofmt,
         };
         const ld = target.standardDynamicLinkerPath();
         if (ld.get() == null) continue;
@@ -346,6 +348,7 @@ fn detectAbiAndDynamicLinker(
                 .cpu = cpu,
                 .os = os_adjusted,
                 .abi = cross_target.abi orelse found_ld_info.abi,
+                .ofmt = cross_target.ofmt orelse Target.ObjectFormat.default(os_adjusted.tag, cpu.arch),
             },
             .dynamic_linker = if (cross_target.dynamic_linker.get() == null)
                 DynamicLinker.init(found_ld_path)
@@ -539,6 +542,7 @@ pub fn abiAndDynamicLinkerFromFile(
             .cpu = cpu,
             .os = os,
             .abi = cross_target.abi orelse Target.Abi.default(cpu.arch, os),
+            .ofmt = cross_target.ofmt orelse Target.ObjectFormat.default(os.tag, cpu.arch),
         },
         .dynamic_linker = cross_target.dynamic_linker,
     };
@@ -829,6 +833,7 @@ fn defaultAbiAndDynamicLinker(cpu: Target.Cpu, os: Target.Os, cross_target: Cros
         .cpu = cpu,
         .os = os,
         .abi = cross_target.abi orelse Target.Abi.default(cpu.arch, os),
+        .ofmt = cross_target.ofmt orelse Target.ObjectFormat.default(os.tag, cpu.arch),
     };
     return NativeTargetInfo{
         .target = target,
diff --git a/src/Compilation.zig b/src/Compilation.zig
index af39154a3f233e43fbe7c80c19599f43312f4f08..5e0d815c9620d7a8ef77134f27446bc4a3e15a98 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -810,7 +810,6 @@ pub const InitOptions = struct {
     /// this flag would be set to disable this machinery to avoid false positives.
     disable_lld_caching: bool = false,
     cache_mode: CacheMode = .incremental,
-    object_format: ?std.Target.ObjectFormat = null,
     optimize_mode: std.builtin.Mode = .Debug,
     keep_source_files_loaded: bool = false,
     clang_argv: []const []const u8 = &[0][]const u8{},
@@ -1027,8 +1026,6 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
         const comp = try arena.create(Compilation);
         const root_name = try arena.dupeZ(u8, options.root_name);
 
-        const ofmt = options.object_format orelse options.target.getObjectFormat();
-
         const use_stage1 = options.use_stage1 orelse blk: {
             // Even though we may have no Zig code to compile (depending on `options.main_pkg`),
             // we may need to use stage1 for building compiler-rt and other dependencies.
@@ -1042,7 +1039,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             }
 
             // If LLVM does not support the target, then we can't use it.
-            if (!target_util.hasLlvmSupport(options.target, ofmt))
+            if (!target_util.hasLlvmSupport(options.target, options.target.ofmt))
                 break :blk false;
 
             break :blk build_options.is_stage1;
@@ -1072,7 +1069,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
                 break :blk true;
 
             // If LLVM does not support the target, then we can't use it.
-            if (!target_util.hasLlvmSupport(options.target, ofmt))
+            if (!target_util.hasLlvmSupport(options.target, options.target.ofmt))
                 break :blk false;
 
             // Prefer LLVM for release builds.
@@ -1115,7 +1112,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             if (!build_options.have_llvm)
                 break :blk false;
 
-            if (ofmt == .c)
+            if (options.target.ofmt == .c)
                 break :blk false;
 
             if (options.want_lto) |lto| {
@@ -1374,7 +1371,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
         cache.hash.add(options.target.os.getVersionRange());
         cache.hash.add(options.is_native_os);
         cache.hash.add(options.target.abi);
-        cache.hash.add(ofmt);
+        cache.hash.add(options.target.ofmt);
         cache.hash.add(pic);
         cache.hash.add(pie);
         cache.hash.add(lto);
@@ -1682,7 +1679,6 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             .sysroot = sysroot,
             .output_mode = options.output_mode,
             .link_mode = link_mode,
-            .object_format = ofmt,
             .optimize_mode = options.optimize_mode,
             .use_lld = use_lld,
             .use_llvm = use_llvm,
@@ -1841,7 +1837,9 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
 
     const have_bin_emit = comp.bin_file.options.emit != null or comp.whole_bin_sub_path != null;
 
-    if (have_bin_emit and !comp.bin_file.options.skip_linker_dependencies) {
+    if (have_bin_emit and !comp.bin_file.options.skip_linker_dependencies and
+        options.target.ofmt != .c)
+    {
         if (comp.getTarget().isDarwin()) {
             switch (comp.getTarget().abi) {
                 .none,
@@ -3739,7 +3737,8 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.P
     else
         c_source_basename[0 .. c_source_basename.len - std.fs.path.extension(c_source_basename).len];
 
-    const o_ext = comp.bin_file.options.object_format.fileExt(comp.bin_file.options.target.cpu.arch);
+    const target = comp.getTarget();
+    const o_ext = target.ofmt.fileExt(target.cpu.arch);
     const digest = if (!comp.disable_c_depfile and try man.hit()) man.final() else blk: {
         var argv = std.ArrayList([]const u8).init(comp.gpa);
         defer argv.deinit();
@@ -4092,7 +4091,7 @@ pub fn addCCArgs(
 
             if (!comp.bin_file.options.strip) {
                 try argv.append("-g");
-                switch (comp.bin_file.options.object_format) {
+                switch (target.ofmt) {
                     .coff => try argv.append("-gcodeview"),
                     else => {},
                 }
@@ -4660,7 +4659,7 @@ fn wantBuildLibCFromSource(comp: Compilation) bool {
     };
     return comp.bin_file.options.link_libc and is_exe_or_dyn_lib and
         comp.bin_file.options.libc_installation == null and
-        comp.bin_file.options.object_format != .c;
+        comp.bin_file.options.target.ofmt != .c;
 }
 
 fn wantBuildGLibCFromSource(comp: Compilation) bool {
@@ -4688,7 +4687,7 @@ fn wantBuildLibUnwindFromSource(comp: *Compilation) bool {
         .Exe => true,
     };
     return is_exe_or_dyn_lib and comp.bin_file.options.link_libunwind and
-        comp.bin_file.options.object_format != .c;
+        comp.bin_file.options.target.ofmt != .c;
 }
 
 fn setAllocFailure(comp: *Compilation) void {
@@ -4747,7 +4746,7 @@ pub fn generateBuiltinZigSource(comp: *Compilation, allocator: Allocator) Alloca
     const zig_backend: std.builtin.CompilerBackend = blk: {
         if (use_stage1) break :blk .stage1;
         if (build_options.have_llvm and comp.bin_file.options.use_llvm) break :blk .stage2_llvm;
-        if (comp.bin_file.options.object_format == .c) break :blk .stage2_c;
+        if (target.ofmt == .c) break :blk .stage2_c;
         break :blk switch (target.cpu.arch) {
             .wasm32, .wasm64 => std.builtin.CompilerBackend.stage2_wasm,
             .arm, .armeb, .thumb, .thumbeb => .stage2_arm,
@@ -4895,6 +4894,7 @@ pub fn generateBuiltinZigSource(comp: *Compilation, allocator: Allocator) Alloca
         \\    .cpu = cpu,
         \\    .os = os,
         \\    .abi = abi,
+        \\    .ofmt = object_format,
         \\}};
         \\pub const object_format = std.Target.ObjectFormat.{};
         \\pub const mode = std.builtin.Mode.{};
@@ -4909,7 +4909,7 @@ pub fn generateBuiltinZigSource(comp: *Compilation, allocator: Allocator) Alloca
         \\pub const code_model = std.builtin.CodeModel.{};
         \\
     , .{
-        std.zig.fmtId(@tagName(comp.bin_file.options.object_format)),
+        std.zig.fmtId(@tagName(target.ofmt)),
         std.zig.fmtId(@tagName(comp.bin_file.options.optimize_mode)),
         link_libc,
         comp.bin_file.options.link_libcpp,
diff --git a/src/Sema.zig b/src/Sema.zig
index 32b95a4c21be3bfd8f89285774f929c7279489b3..d059ee09a39d211d2746a6ea8db2d2f664f83170 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -20654,7 +20654,7 @@ fn panicWithMsg(
     const arena = sema.arena;
 
     const this_feature_is_implemented_in_the_backend =
-        mod.comp.bin_file.options.object_format == .c or
+        mod.comp.bin_file.options.target.ofmt == .c or
         mod.comp.bin_file.options.use_llvm;
     if (!this_feature_is_implemented_in_the_backend) {
         // TODO implement this feature in all the backends and then delete this branch
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 983813d780c17f36d6c07101744a2a924ba9f662..8c84f61a81e72a25f26edb5e6f6a2b4c4eb7b4de 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -273,7 +273,7 @@ pub const Object = struct {
         var di_compile_unit: ?*llvm.DICompileUnit = null;
 
         if (!options.strip) {
-            switch (options.object_format) {
+            switch (options.target.ofmt) {
                 .coff => llvm_module.addModuleCodeViewFlag(),
                 else => llvm_module.addModuleDebugInfoFlag(),
             }
diff --git a/src/link.zig b/src/link.zig
index a6dafce20e5bb9948240b0b20bc491564b7ae0a5..31b54f705a1c2b4ea742cf1d76ce9e5878aab98a 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -72,7 +72,6 @@ pub const Options = struct {
     target: std.Target,
     output_mode: std.builtin.OutputMode,
     link_mode: std.builtin.LinkMode,
-    object_format: std.Target.ObjectFormat,
     optimize_mode: std.builtin.Mode,
     machine_code_model: std.builtin.CodeModel,
     root_name: [:0]const u8,
@@ -273,13 +272,13 @@ pub const File = struct {
     /// rewriting it. A malicious file is detected as incremental link failure
     /// and does not cause Illegal Behavior. This operation is not atomic.
     pub fn openPath(allocator: Allocator, options: Options) !*File {
-        if (options.object_format == .macho) {
+        if (options.target.ofmt == .macho) {
             return &(try MachO.openPath(allocator, options)).base;
         }
 
         const use_stage1 = build_options.is_stage1 and options.use_stage1;
         if (use_stage1 or options.emit == null) {
-            return switch (options.object_format) {
+            return switch (options.target.ofmt) {
                 .coff => &(try Coff.createEmpty(allocator, options)).base,
                 .elf => &(try Elf.createEmpty(allocator, options)).base,
                 .macho => unreachable,
@@ -298,7 +297,7 @@ pub const File = struct {
             if (options.module == null) {
                 // No point in opening a file, we would not write anything to it.
                 // Initialize with empty.
-                return switch (options.object_format) {
+                return switch (options.target.ofmt) {
                     .coff => &(try Coff.createEmpty(allocator, options)).base,
                     .elf => &(try Elf.createEmpty(allocator, options)).base,
                     .macho => unreachable,
@@ -314,12 +313,12 @@ pub const File = struct {
             // Open a temporary object file, not the final output file because we
             // want to link with LLD.
             break :blk try std.fmt.allocPrint(allocator, "{s}{s}", .{
-                emit.sub_path, options.object_format.fileExt(options.target.cpu.arch),
+                emit.sub_path, options.target.ofmt.fileExt(options.target.cpu.arch),
             });
         } else emit.sub_path;
         errdefer if (use_lld) allocator.free(sub_path);
 
-        const file: *File = switch (options.object_format) {
+        const file: *File = switch (options.target.ofmt) {
             .coff => &(try Coff.openPath(allocator, sub_path, options)).base,
             .elf => &(try Elf.openPath(allocator, sub_path, options)).base,
             .macho => unreachable,
diff --git a/src/link/C.zig b/src/link/C.zig
index 6449be9c56fb1a073ce41ca4b50cca9126267768..955044f90d4616175a92b2014a132f5e1ecc27c1 100644
--- a/src/link/C.zig
+++ b/src/link/C.zig
@@ -48,7 +48,7 @@ const DeclBlock = struct {
 };
 
 pub fn openPath(gpa: Allocator, sub_path: []const u8, options: link.Options) !*C {
-    assert(options.object_format == .c);
+    assert(options.target.ofmt == .c);
 
     if (options.use_llvm) return error.LLVMHasNoCBackend;
     if (options.use_lld) return error.LLDHasNoCBackend;
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index 1b5ddbbf8b528e22fa3d2b64132d19c586e94b35..92e9dce3ad28ec9cc2cb13551d9762ff27add3bb 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -128,7 +128,7 @@ pub const TextBlock = struct {
 pub const SrcFn = void;
 
 pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Options) !*Coff {
-    assert(options.object_format == .coff);
+    assert(options.target.ofmt == .coff);
 
     if (build_options.have_llvm and options.use_llvm) {
         return createEmpty(allocator, options);
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index 917e4c18d1171b6840e5c6793e239c2228f34c58..2f67c352054f9ada374c18e65e1e3303d0e3848e 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -249,7 +249,7 @@ pub const Export = struct {
 };
 
 pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Options) !*Elf {
-    assert(options.object_format == .elf);
+    assert(options.target.ofmt == .elf);
 
     if (build_options.have_llvm and options.use_llvm) {
         return createEmpty(allocator, options);
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index e4370c703e3932f610df1fbceb8c7941a293a062..7a508430236320fb79c1e16fe17f16802b4c3449 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -270,7 +270,7 @@ pub const Export = struct {
 };
 
 pub fn openPath(allocator: Allocator, options: link.Options) !*MachO {
-    assert(options.object_format == .macho);
+    assert(options.target.ofmt == .macho);
 
     const use_stage1 = build_options.is_stage1 and options.use_stage1;
     if (use_stage1 or options.emit == null) {
@@ -289,7 +289,7 @@ pub fn openPath(allocator: Allocator, options: link.Options) !*MachO {
         // we also want to put the intermediary object file in the cache while the
         // main emit directory is the cwd.
         self.base.intermediary_basename = try std.fmt.allocPrint(allocator, "{s}{s}", .{
-            emit.sub_path, options.object_format.fileExt(options.target.cpu.arch),
+            emit.sub_path, options.target.ofmt.fileExt(options.target.cpu.arch),
         });
     }
 
diff --git a/src/link/NvPtx.zig b/src/link/NvPtx.zig
index bd86d8720105360119bb7e155a878453f46c0781..7bf51c7ad3fced5cde6f2ede114eb476d302c91b 100644
--- a/src/link/NvPtx.zig
+++ b/src/link/NvPtx.zig
@@ -57,7 +57,7 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*NvPtx {
 pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Options) !*NvPtx {
     if (!build_options.have_llvm) @panic("nvptx target requires a zig compiler with llvm enabled.");
     if (!options.use_llvm) return error.PtxArchNotSupported;
-    assert(options.object_format == .nvptx);
+    assert(options.target.ofmt == .nvptx);
 
     const nvptx = try createEmpty(allocator, options);
     log.info("Opening .ptx target file {s}", .{sub_path});
diff --git a/src/link/Plan9.zig b/src/link/Plan9.zig
index 16f7841c2d7d232711fb6afe50890b0c1678d937..9a8927dcb4dd163c0a63d2323c8c279fbb9d8cc8 100644
--- a/src/link/Plan9.zig
+++ b/src/link/Plan9.zig
@@ -657,7 +657,7 @@ pub const base_tag = .plan9;
 pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Options) !*Plan9 {
     if (options.use_llvm)
         return error.LLVMBackendDoesNotSupportPlan9;
-    assert(options.object_format == .plan9);
+    assert(options.target.ofmt == .plan9);
 
     const self = try createEmpty(allocator, options);
     errdefer self.base.destroy();
diff --git a/src/link/SpirV.zig b/src/link/SpirV.zig
index e295dceb559e18d63c327b16090cc1811489d6c5..b2f6edddfb4ed78fb4c78519c6f77c316bfd93bc 100644
--- a/src/link/SpirV.zig
+++ b/src/link/SpirV.zig
@@ -99,7 +99,7 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*SpirV {
 }
 
 pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Options) !*SpirV {
-    assert(options.object_format == .spirv);
+    assert(options.target.ofmt == .spirv);
 
     if (options.use_llvm) return error.LLVM_BackendIsTODO_ForSpirV; // TODO: LLVM Doesn't support SpirV at all.
     if (options.use_lld) return error.LLD_LinkingIsTODO_ForSpirV; // TODO: LLD Doesn't support SpirV at all.
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 1bdd9426a58b464b17d5d7bb598b094462c8a598..6267865888734f49474456c4d0fdf5abdb7c6353 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -282,7 +282,7 @@ pub const StringTable = struct {
 };
 
 pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Options) !*Wasm {
-    assert(options.object_format == .wasm);
+    assert(options.target.ofmt == .wasm);
 
     if (build_options.have_llvm and options.use_llvm) {
         return createEmpty(allocator, options);
diff --git a/src/main.zig b/src/main.zig
index 971fe19e36c6c3f384d4dc0ce55c590e5b18ecac..dfce4d83b88e21c266e816c6810108343d6e8b4d 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -2192,6 +2192,7 @@ fn buildOutputType(
         .arch_os_abi = target_arch_os_abi,
         .cpu_features = target_mcpu,
         .dynamic_linker = target_dynamic_linker,
+        .object_format = target_ofmt,
     };
 
     // Before passing the mcpu string in for parsing, we convert any -m flags that were
@@ -2494,28 +2495,7 @@ fn buildOutputType(
         }
     }
 
-    const object_format: std.Target.ObjectFormat = blk: {
-        const ofmt = target_ofmt orelse break :blk target_info.target.getObjectFormat();
-        if (mem.eql(u8, ofmt, "elf")) {
-            break :blk .elf;
-        } else if (mem.eql(u8, ofmt, "c")) {
-            break :blk .c;
-        } else if (mem.eql(u8, ofmt, "coff")) {
-            break :blk .coff;
-        } else if (mem.eql(u8, ofmt, "macho")) {
-            break :blk .macho;
-        } else if (mem.eql(u8, ofmt, "wasm")) {
-            break :blk .wasm;
-        } else if (mem.eql(u8, ofmt, "hex")) {
-            break :blk .hex;
-        } else if (mem.eql(u8, ofmt, "raw")) {
-            break :blk .raw;
-        } else if (mem.eql(u8, ofmt, "spirv")) {
-            break :blk .spirv;
-        } else {
-            fatal("unsupported object format: {s}", .{ofmt});
-        }
-    };
+    const object_format = target_info.target.ofmt;
 
     if (output_mode == .Obj and (object_format == .coff or object_format == .macho)) {
         const total_obj_count = c_source_files.items.len +
@@ -2569,7 +2549,6 @@ fn buildOutputType(
                 .target = target_info.target,
                 .output_mode = output_mode,
                 .link_mode = link_mode,
-                .object_format = object_format,
                 .version = optional_version,
             }),
         },
@@ -2859,7 +2838,6 @@ fn buildOutputType(
         .emit_implib = emit_implib_resolved.data,
         .link_mode = link_mode,
         .dll_export_fns = dll_export_fns,
-        .object_format = object_format,
         .optimize_mode = optimize_mode,
         .keep_source_files_loaded = false,
         .clang_argv = clang_argv.items,
@@ -3173,11 +3151,11 @@ fn parseCrossTargetOrReportFatalError(
                 for (diags.arch.?.allCpuModels()) |cpu| {
                     help_text.writer().print(" {s}\n", .{cpu.name}) catch break :help;
                 }
-                std.log.info("Available CPUs for architecture '{s}':\n{s}", .{
+                std.log.info("available CPUs for architecture '{s}':\n{s}", .{
                     @tagName(diags.arch.?), help_text.items,
                 });
             }
-            fatal("Unknown CPU: '{s}'", .{diags.cpu_name.?});
+            fatal("unknown CPU: '{s}'", .{diags.cpu_name.?});
         },
         error.UnknownCpuFeature => {
             help: {
@@ -3186,11 +3164,26 @@ fn parseCrossTargetOrReportFatalError(
                 for (diags.arch.?.allFeaturesList()) |feature| {
                     help_text.writer().print(" {s}: {s}\n", .{ feature.name, feature.description }) catch break :help;
                 }
-                std.log.info("Available CPU features for architecture '{s}':\n{s}", .{
+                std.log.info("available CPU features for architecture '{s}':\n{s}", .{
                     @tagName(diags.arch.?), help_text.items,
                 });
             }
-            fatal("Unknown CPU feature: '{s}'", .{diags.unknown_feature_name.?});
+            fatal("unknown CPU feature: '{s}'", .{diags.unknown_feature_name.?});
+        },
+        error.UnknownObjectFormat => {
+            {
+                var help_text = std.ArrayList(u8).init(allocator);
+                defer help_text.deinit();
+                inline for (@typeInfo(std.Target.ObjectFormat).Enum.fields) |field| {
+                    help_text.writer().print(" {s}\n", .{field.name}) catch
+                    // TODO change this back to `break :help`
+                    // this working around a stage1 bug.
+                    //break :help;
+                        @panic("out of memory");
+                }
+                std.log.info("available object formats:\n{s}", .{help_text.items});
+            }
+            fatal("unknown object format: '{s}'", .{opts.object_format.?});
         },
         else => |e| return e,
     };
@@ -3360,7 +3353,7 @@ fn updateModule(gpa: Allocator, comp: *Compilation, hook: AfterUpdateHook) !void
 
             // If a .pdb file is part of the expected output, we must also copy
             // it into place here.
-            const is_coff = comp.bin_file.options.object_format == .coff;
+            const is_coff = comp.bin_file.options.target.ofmt == .coff;
             const have_pdb = is_coff and !comp.bin_file.options.strip;
             if (have_pdb) {
                 // Replace `.out` or `.exe` with `.pdb` on both the source and destination
diff --git a/src/stage1/codegen.cpp b/src/stage1/codegen.cpp
index 7010e736dc041c618023cefe12e0af458a9e3fc8..d4a09f79687ca6ef70e37ea3184faea48b44682d 100644
--- a/src/stage1/codegen.cpp
+++ b/src/stage1/codegen.cpp
@@ -10082,6 +10082,7 @@ Buf *codegen_generate_builtin_source(CodeGen *g) {
         "    .cpu = cpu,\n"
         "    .os = os,\n"
         "    .abi = abi,\n"
+        "    .ofmt = object_format,\n"
         "};\n"
     );
 
-- 
2.54.0


From cee82c7ce4fb8beb39042f9dba16a1a391803fa4 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 18 Aug 2022 20:34:36 -0700
Subject: [PATCH 161/290] improved ABI alignment/size for >= 128-bit integers

 * riscv64: adjust alignment and size of 128-bit integers.
 * take ofmt=c into account for ABI alignment of 128-bit integers and
   structs.
 * Type: make packed struct support intInfo
 * fix f80 alignment for i386-windows-msvc
---
 lib/std/target.zig      |  9 +++++---
 src/Module.zig          | 30 +++++++++++++++++----------
 src/type.zig            | 16 ++++++++++++--
 test/behavior/align.zig | 46 +++++++++++++++++++++++++++--------------
 4 files changed, 69 insertions(+), 32 deletions(-)

diff --git a/lib/std/target.zig b/lib/std/target.zig
index 00553bb520797e40c8555b297a1a07ade95326cd..64f9f9780961ea7ab7e964d29b2b3fd308d46fe3 100644
--- a/lib/std/target.zig
+++ b/lib/std/target.zig
@@ -1808,20 +1808,23 @@ pub const Target = struct {
             // 1. Different machine code instruction when loading into SIMD register.
             // 2. The C ABI wants 16 for extern structs.
             // 3. 16-byte cmpxchg needs 16-byte alignment.
-            // Same logic for riscv64, powerpc64, mips64, sparc64.
+            // Same logic for powerpc64, mips64, sparc64.
             .x86_64,
-            .riscv64,
             .powerpc64,
             .powerpc64le,
             .mips64,
             .mips64el,
             .sparc64,
-            => 8,
+            => return switch (target.ofmt) {
+                .c => 16,
+                else => 8,
+            },
 
             // Even LLVMABIAlignmentOfType(i128) agrees on these targets.
             .aarch64,
             .aarch64_be,
             .aarch64_32,
+            .riscv64,
             .bpfel,
             .bpfeb,
             .nvptx,
diff --git a/src/Module.zig b/src/Module.zig
index 6d2180e8e7476c9dc4b330da0be559ab99755f86..3ae61c264feafa4203595114b77fd5cc14cc3c73 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -948,21 +948,29 @@ pub const Struct = struct {
 
             switch (layout) {
                 .Packed => return 0,
-                .Auto => return field.ty.abiAlignment(target),
-                .Extern => {
-                    // This logic is duplicated in Type.abiAlignmentAdvanced.
-                    const ty_abi_align = field.ty.abiAlignment(target);
-
-                    if (field.ty.isAbiInt() and field.ty.intInfo(target).bits >= 128) {
-                        // The C ABI requires 128 bit integer fields of structs
-                        // to be 16-bytes aligned.
-                        return @maximum(ty_abi_align, 16);
+                .Auto => {
+                    if (target.ofmt == .c) {
+                        return alignmentExtern(field, target);
+                    } else {
+                        return field.ty.abiAlignment(target);
                     }
-
-                    return ty_abi_align;
                 },
+                .Extern => return alignmentExtern(field, target),
             }
         }
+
+        pub fn alignmentExtern(field: Field, target: Target) u32 {
+            // This logic is duplicated in Type.abiAlignmentAdvanced.
+            const ty_abi_align = field.ty.abiAlignment(target);
+
+            if (field.ty.isAbiInt() and field.ty.intInfo(target).bits >= 128) {
+                // The C ABI requires 128 bit integer fields of structs
+                // to be 16-bytes aligned.
+                return @maximum(ty_abi_align, 16);
+            }
+
+            return ty_abi_align;
+        }
     };
 
     pub fn getFullyQualifiedName(s: *Struct, mod: *Module) ![:0]u8 {
diff --git a/src/type.zig b/src/type.zig
index fb2ca1e3fcb812a5bf2d237af75455f92e4a2d26..6a66fb9d700c9ea7cfe4c401e03f817d59136fcc 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -3019,7 +3019,7 @@ pub const Type = extern union {
                     big_align = @maximum(big_align, field_align);
 
                     // This logic is duplicated in Module.Struct.Field.alignment.
-                    if (struct_obj.layout == .Extern) {
+                    if (struct_obj.layout == .Extern or target.ofmt == .c) {
                         if (field.ty.isAbiInt() and field.ty.intInfo(target).bits >= 128) {
                             // The C ABI requires 128 bit integer fields of structs
                             // to be 16-bytes aligned.
@@ -3348,7 +3348,13 @@ pub const Type = extern union {
             .f128 => return AbiSizeAdvanced{ .scalar = 16 },
 
             .f80 => switch (target.cpu.arch) {
-                .i386 => return AbiSizeAdvanced{ .scalar = 12 },
+                .i386 => switch (target.os.tag) {
+                    .windows => switch (target.abi) {
+                        .msvc => return AbiSizeAdvanced{ .scalar = 16 },
+                        else => return AbiSizeAdvanced{ .scalar = 12 },
+                    },
+                    else => return AbiSizeAdvanced{ .scalar = 12 },
+                },
                 .x86_64 => return AbiSizeAdvanced{ .scalar = 16 },
                 else => {
                     var payload: Payload.Bits = .{
@@ -4559,6 +4565,12 @@ pub const Type = extern union {
 
             .vector => ty = ty.castTag(.vector).?.data.elem_type,
 
+            .@"struct" => {
+                const struct_obj = ty.castTag(.@"struct").?.data;
+                assert(struct_obj.layout == .Packed);
+                ty = struct_obj.backing_int_ty;
+            },
+
             else => unreachable,
         };
     }
diff --git a/test/behavior/align.zig b/test/behavior/align.zig
index 4a824bc9cf48276281cc77a17e01934deb64e6ed..ad857fb9c2e7bd8c7753ee9a0f428769de273908 100644
--- a/test/behavior/align.zig
+++ b/test/behavior/align.zig
@@ -100,8 +100,8 @@ test "alignment and size of structs with 128-bit fields" {
             .a_align = 8,
             .a_size = 16,
 
-            .b_align = 8,
-            .b_size = 24,
+            .b_align = 16,
+            .b_size = 32,
 
             .u128_align = 8,
             .u128_size = 16,
@@ -114,8 +114,8 @@ test "alignment and size of structs with 128-bit fields" {
                 .a_align = 8,
                 .a_size = 16,
 
-                .b_align = 8,
-                .b_size = 24,
+                .b_align = 16,
+                .b_size = 32,
 
                 .u128_align = 8,
                 .u128_size = 16,
@@ -126,8 +126,8 @@ test "alignment and size of structs with 128-bit fields" {
                 .a_align = 4,
                 .a_size = 16,
 
-                .b_align = 4,
-                .b_size = 20,
+                .b_align = 16,
+                .b_size = 32,
 
                 .u128_align = 4,
                 .u128_size = 16,
@@ -140,25 +140,39 @@ test "alignment and size of structs with 128-bit fields" {
         .mips64el,
         .powerpc64,
         .powerpc64le,
-        .riscv64,
         .sparc64,
         .x86_64,
-        => .{
-            .a_align = 8,
-            .a_size = 16,
+        => switch (builtin.object_format) {
+            .c => .{
+                .a_align = 16,
+                .a_size = 16,
 
-            .b_align = 16,
-            .b_size = 32,
+                .b_align = 16,
+                .b_size = 32,
 
-            .u128_align = 8,
-            .u128_size = 16,
-            .u129_align = 8,
-            .u129_size = 24,
+                .u128_align = 16,
+                .u128_size = 16,
+                .u129_align = 16,
+                .u129_size = 32,
+            },
+            else => .{
+                .a_align = 8,
+                .a_size = 16,
+
+                .b_align = 16,
+                .b_size = 32,
+
+                .u128_align = 8,
+                .u128_size = 16,
+                .u129_align = 8,
+                .u129_size = 24,
+            },
         },
 
         .aarch64,
         .aarch64_be,
         .aarch64_32,
+        .riscv64,
         .bpfel,
         .bpfeb,
         .nvptx,
-- 
2.54.0


From 5e989fcb679215a6357dd35b5b8903293f963846 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 18 Aug 2022 22:02:10 -0700
Subject: [PATCH 162/290] stage2: pointers to comptime-only types are
 comptime-only

This is a partial revert of c5ba941b77fbdb06841f28142420c6786f2a4d0c.
---
 src/type.zig | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/type.zig b/src/type.zig
index 6a66fb9d700c9ea7cfe4c401e03f817d59136fcc..f6afa33df16ddb2ad1da69fea43f9a9395c089a3 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -2374,6 +2374,10 @@ pub const Type = extern union {
             .error_union,
             .error_set,
             .error_set_merged,
+            => return true,
+
+            // Pointers to zero-bit types still have a runtime address; however, pointers
+            // to comptime-only types do not, with the exception of function pointers.
             .anyframe_T,
             .optional_single_mut_pointer,
             .optional_single_const_pointer,
@@ -2386,7 +2390,17 @@ pub const Type = extern union {
             .const_slice,
             .mut_slice,
             .pointer,
-            => return true,
+            => {
+                if (ignore_comptime_only) {
+                    return true;
+                } else if (ty.childType().zigTypeTag() == .Fn) {
+                    return true;
+                } else if (sema_kit) |sk| {
+                    return !(try sk.sema.typeRequiresComptime(sk.block, sk.src, ty));
+                } else {
+                    return !comptimeOnly(ty);
+                }
+            },
 
             // These are false because they are comptime-only types.
             .single_const_pointer_to_comptime_int,
-- 
2.54.0


From 150786e83c705a34e16f031b7848a440946b2ef9 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 18 Aug 2022 22:02:55 -0700
Subject: [PATCH 163/290] test harness: fix handling of object format

Follow-up to b975f7a56fec9e0e7aca9832282bc772c743d731.
---
 src/test.zig | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/test.zig b/src/test.zig
index 266b4181e0113d9f84e4e6bf946703b578adf8f6..a8567f24928b2d35b87177a451c131f47d2a8b79 100644
--- a/src/test.zig
+++ b/src/test.zig
@@ -606,7 +606,6 @@ pub const TestContext = struct {
         output_mode: std.builtin.OutputMode,
         optimize_mode: std.builtin.Mode = .Debug,
         updates: std.ArrayList(Update),
-        object_format: ?std.Target.ObjectFormat = null,
         emit_h: bool = false,
         is_test: bool = false,
         expect_exact: bool = false,
@@ -782,12 +781,13 @@ pub const TestContext = struct {
     pub fn exeFromCompiledC(ctx: *TestContext, name: []const u8, target: CrossTarget) *Case {
         const prefixed_name = std.fmt.allocPrint(ctx.arena, "CBE: {s}", .{name}) catch
             @panic("out of memory");
+        var target_adjusted = target;
+        target_adjusted.ofmt = std.Target.ObjectFormat.c;
         ctx.cases.append(Case{
             .name = prefixed_name,
-            .target = target,
+            .target = target_adjusted,
             .updates = std.ArrayList(Update).init(ctx.cases.allocator),
             .output_mode = .Exe,
-            .object_format = .c,
             .files = std.ArrayList(File).init(ctx.arena),
         }) catch @panic("out of memory");
         return &ctx.cases.items[ctx.cases.items.len - 1];
@@ -851,12 +851,13 @@ pub const TestContext = struct {
 
     /// Adds a test case for Zig or ZIR input, producing C code.
     pub fn addC(ctx: *TestContext, name: []const u8, target: CrossTarget) *Case {
+        var target_adjusted = target;
+        target_adjusted.ofmt = std.Target.ObjectFormat.c;
         ctx.cases.append(Case{
             .name = name,
-            .target = target,
+            .target = target_adjusted,
             .updates = std.ArrayList(Update).init(ctx.cases.allocator),
             .output_mode = .Obj,
-            .object_format = .c,
             .files = std.ArrayList(File).init(ctx.arena),
         }) catch @panic("out of memory");
         return &ctx.cases.items[ctx.cases.items.len - 1];
@@ -1501,7 +1502,6 @@ pub const TestContext = struct {
             .root_name = "test_case",
             .target = target,
             .output_mode = case.output_mode,
-            .object_format = case.object_format,
         });
 
         const emit_directory: Compilation.Directory = .{
@@ -1537,7 +1537,6 @@ pub const TestContext = struct {
             .emit_h = emit_h,
             .main_pkg = &main_pkg,
             .keep_source_files_loaded = true,
-            .object_format = case.object_format,
             .is_native_os = case.target.isNativeOs(),
             .is_native_abi = case.target.isNativeAbi(),
             .dynamic_linker = target_info.dynamic_linker.get(),
@@ -1782,7 +1781,7 @@ pub const TestContext = struct {
                             ".." ++ ss ++ "{s}" ++ ss ++ "{s}",
                             .{ &tmp.sub_path, bin_name },
                         );
-                        if (case.object_format != null and case.object_format.? == .c) {
+                        if (case.target.ofmt != null and case.target.ofmt.? == .c) {
                             if (host.getExternalExecutor(target_info, .{ .link_libc = true }) != .native) {
                                 // We wouldn't be able to run the compiled C code.
                                 continue :update; // Pass test.
-- 
2.54.0


From c0b7f20893ea5ca42e0d02b59db6f459c2f80ca1 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 17 Aug 2022 18:42:39 -0700
Subject: [PATCH 164/290] stage2: implement stack protectors

This is one of the final remaining TODOs for the LLVM backend.
---
 src/Compilation.zig            | 121 +++++++++++++++++++++------------
 src/clang_options_data.zig     |  45 ++++++++++--
 src/codegen/llvm.zig           |  11 ++-
 src/glibc.zig                  |   1 +
 src/libcxx.zig                 |   2 +
 src/libtsan.zig                |   1 +
 src/libunwind.zig              |   1 +
 src/link.zig                   |   3 +
 src/link/Elf.zig               |   6 ++
 src/main.zig                   |  16 +++++
 src/musl.zig                   |   1 +
 src/target.zig                 |   9 +++
 tools/update_clang_options.zig |  20 ++++++
 13 files changed, 184 insertions(+), 53 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 5e0d815c9620d7a8ef77134f27446bc4a3e15a98..060afba6948b01d749d2ade35e213932e708e60b 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -173,6 +173,7 @@ astgen_wait_group: WaitGroup = .{},
 /// TODO: Remove this when Stage2 becomes the default compiler as it will already have this information.
 export_symbol_names: std.ArrayListUnmanaged([]const u8) = .{},
 
+pub const default_stack_protector_buffer_size = 4;
 pub const SemaError = Module.SemaError;
 
 pub const CRTFile = struct {
@@ -837,6 +838,10 @@ pub const InitOptions = struct {
     want_pie: ?bool = null,
     want_sanitize_c: ?bool = null,
     want_stack_check: ?bool = null,
+    /// null means default.
+    /// 0 means no stack protector.
+    /// other number means stack protection with that buffer size.
+    want_stack_protector: ?u32 = null,
     want_red_zone: ?bool = null,
     omit_frame_pointer: ?bool = null,
     want_valgrind: ?bool = null,
@@ -1014,6 +1019,15 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
         return error.ExportTableAndImportTableConflict;
     }
 
+    // The `have_llvm` condition is here only because native backends cannot yet build compiler-rt.
+    // Once they are capable this condition could be removed. When removing this condition,
+    // also test the use case of `build-obj -fcompiler-rt` with the native backends
+    // and make sure the compiler-rt symbols are emitted.
+    const capable_of_building_compiler_rt = build_options.have_llvm;
+
+    const capable_of_building_zig_libc = build_options.have_llvm;
+    const capable_of_building_ssp = build_options.have_llvm;
+
     const comp: *Compilation = comp: {
         // For allocations that have the same lifetime as Compilation. This arena is used only during this
         // initialization and then is freed in deinit().
@@ -1289,11 +1303,36 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
 
         const sanitize_c = options.want_sanitize_c orelse is_safe_mode;
 
-        const stack_check: bool = b: {
-            if (!target_util.supportsStackProbing(options.target))
-                break :b false;
-            break :b options.want_stack_check orelse is_safe_mode;
+        const stack_check: bool = options.want_stack_check orelse b: {
+            if (!target_util.supportsStackProbing(options.target)) break :b false;
+            break :b is_safe_mode;
         };
+        if (stack_check and !target_util.supportsStackProbing(options.target))
+            return error.StackCheckUnsupportedByTarget;
+
+        const stack_protector: u32 = options.want_stack_protector orelse b: {
+            if (!target_util.supportsStackProtector(options.target)) break :b @as(u32, 0);
+
+            // This logic is checking for linking libc because otherwise our start code
+            // which is trying to set up TLS (i.e. the fs/gs registers) but the stack
+            // protection code depends on fs/gs registers being already set up.
+            // If we were able to annotate start code, or perhaps the entire std lib,
+            // as being exempt from stack protection checks, we could change this logic
+            // to supporting stack protection even when not linking libc.
+            // TODO file issue about this
+            if (!link_libc) break :b 0;
+            if (!capable_of_building_ssp) break :b 0;
+            if (is_safe_mode) break :b default_stack_protector_buffer_size;
+            break :b 0;
+        };
+        if (stack_protector != 0) {
+            if (!target_util.supportsStackProtector(options.target))
+                return error.StackProtectorUnsupportedByTarget;
+            if (!capable_of_building_ssp)
+                return error.StackProtectorUnsupportedByBackend;
+            if (!link_libc)
+                return error.StackProtectorUnavailableWithoutLibC;
+        }
 
         const valgrind: bool = b: {
             if (!target_util.hasValgrindSupport(options.target))
@@ -1378,6 +1417,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
         cache.hash.add(unwind_tables);
         cache.hash.add(tsan);
         cache.hash.add(stack_check);
+        cache.hash.add(stack_protector);
         cache.hash.add(red_zone);
         cache.hash.add(omit_frame_pointer);
         cache.hash.add(link_mode);
@@ -1741,6 +1781,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             .valgrind = valgrind,
             .tsan = tsan,
             .stack_check = stack_check,
+            .stack_protector = stack_protector,
             .red_zone = red_zone,
             .omit_frame_pointer = omit_frame_pointer,
             .single_threaded = single_threaded,
@@ -1822,6 +1863,8 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
     };
     errdefer comp.destroy();
 
+    const target = comp.getTarget();
+
     // Add a `CObject` for each `c_source_files`.
     try comp.c_object_table.ensureTotalCapacity(gpa, options.c_source_files.len);
     for (options.c_source_files) |c_source_file| {
@@ -1837,11 +1880,9 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
 
     const have_bin_emit = comp.bin_file.options.emit != null or comp.whole_bin_sub_path != null;
 
-    if (have_bin_emit and !comp.bin_file.options.skip_linker_dependencies and
-        options.target.ofmt != .c)
-    {
-        if (comp.getTarget().isDarwin()) {
-            switch (comp.getTarget().abi) {
+    if (have_bin_emit and !comp.bin_file.options.skip_linker_dependencies and target.ofmt != .c) {
+        if (target.isDarwin()) {
+            switch (target.abi) {
                 .none,
                 .simulator,
                 .macabi,
@@ -1852,9 +1893,9 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
         // 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 (!target_util.canBuildLibC(comp.getTarget())) return error.LibCUnavailable;
+            if (!target_util.canBuildLibC(target)) return error.LibCUnavailable;
 
-            if (glibc.needsCrtiCrtn(comp.getTarget())) {
+            if (glibc.needsCrtiCrtn(target)) {
                 try comp.work_queue.write(&[_]Job{
                     .{ .glibc_crt_file = .crti_o },
                     .{ .glibc_crt_file = .crtn_o },
@@ -1867,10 +1908,10 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             });
         }
         if (comp.wantBuildMuslFromSource()) {
-            if (!target_util.canBuildLibC(comp.getTarget())) return error.LibCUnavailable;
+            if (!target_util.canBuildLibC(target)) return error.LibCUnavailable;
 
             try comp.work_queue.ensureUnusedCapacity(6);
-            if (musl.needsCrtiCrtn(comp.getTarget())) {
+            if (musl.needsCrtiCrtn(target)) {
                 comp.work_queue.writeAssumeCapacity(&[_]Job{
                     .{ .musl_crt_file = .crti_o },
                     .{ .musl_crt_file = .crtn_o },
@@ -1887,7 +1928,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             });
         }
         if (comp.wantBuildWasiLibcFromSource()) {
-            if (!target_util.canBuildLibC(comp.getTarget())) return error.LibCUnavailable;
+            if (!target_util.canBuildLibC(target)) return error.LibCUnavailable;
 
             const wasi_emulated_libs = comp.bin_file.options.wasi_emulated_libs;
             try comp.work_queue.ensureUnusedCapacity(wasi_emulated_libs.len + 2); // worst-case we need all components
@@ -1902,7 +1943,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             });
         }
         if (comp.wantBuildMinGWFromSource()) {
-            if (!target_util.canBuildLibC(comp.getTarget())) return error.LibCUnavailable;
+            if (!target_util.canBuildLibC(target)) return error.LibCUnavailable;
 
             const static_lib_jobs = [_]Job{
                 .{ .mingw_crt_file = .mingw32_lib },
@@ -1921,7 +1962,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             }
         }
         // Generate Windows import libs.
-        if (comp.getTarget().os.tag == .windows) {
+        if (target.os.tag == .windows) {
             const count = comp.bin_file.options.system_libs.count();
             try comp.work_queue.ensureUnusedCapacity(count);
             var i: usize = 0;
@@ -1940,15 +1981,6 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             try comp.work_queue.writeItem(.libtsan);
         }
 
-        // The `have_llvm` condition is here only because native backends cannot yet build compiler-rt.
-        // Once they are capable this condition could be removed. When removing this condition,
-        // also test the use case of `build-obj -fcompiler-rt` with the native backends
-        // and make sure the compiler-rt symbols are emitted.
-        const capable_of_building_compiler_rt = build_options.have_llvm;
-
-        const capable_of_building_zig_libc = build_options.have_llvm;
-        const capable_of_building_ssp = comp.bin_file.options.use_stage1;
-
         if (comp.bin_file.options.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", .{});
@@ -1962,8 +1994,11 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             }
         }
         if (needs_c_symbols) {
-            // MinGW provides no libssp, use our own implementation.
-            if (comp.getTarget().isMinGW() and capable_of_building_ssp) {
+            // Related: https://github.com/ziglang/zig/issues/7265.
+            if (comp.bin_file.options.stack_protector != 0 and
+                (!comp.bin_file.options.link_libc or
+                !target_util.libcProvidesStackProtector(target)))
+            {
                 try comp.work_queue.writeItem(.{ .libssp = {} });
             }
 
@@ -4123,6 +4158,17 @@ pub fn addCCArgs(
                 try argv.append("-fno-omit-frame-pointer");
             }
 
+            const ssp_buf_size = comp.bin_file.options.stack_protector;
+            if (ssp_buf_size != 0) {
+                try argv.appendSlice(&[_][]const u8{
+                    "-fstack-protector-strong",
+                    "--param",
+                    try std.fmt.allocPrint(arena, "ssp-buffer-size={d}", .{ssp_buf_size}),
+                });
+            } else {
+                try argv.append("-fno-stack-protector");
+            }
+
             switch (comp.bin_file.options.optimize_mode) {
                 .Debug => {
                     // windows c runtime requires -D_DEBUG if using debug libraries
@@ -4131,27 +4177,12 @@ pub fn addCCArgs(
                     // to -O1. Besides potentially impairing debugging, -O1/-Og significantly
                     // increases compile times.
                     try argv.append("-O0");
-
-                    if (comp.bin_file.options.link_libc and target.os.tag != .wasi) {
-                        try argv.append("-fstack-protector-strong");
-                        try argv.append("--param");
-                        try argv.append("ssp-buffer-size=4");
-                    } else {
-                        try argv.append("-fno-stack-protector");
-                    }
                 },
                 .ReleaseSafe => {
                     // See the comment in the BuildModeFastRelease case for why we pass -O2 rather
                     // than -O3 here.
                     try argv.append("-O2");
-                    if (comp.bin_file.options.link_libc and target.os.tag != .wasi) {
-                        try argv.append("-D_FORTIFY_SOURCE=2");
-                        try argv.append("-fstack-protector-strong");
-                        try argv.append("--param");
-                        try argv.append("ssp-buffer-size=4");
-                    } else {
-                        try argv.append("-fno-stack-protector");
-                    }
+                    try argv.append("-D_FORTIFY_SOURCE=2");
                 },
                 .ReleaseFast => {
                     try argv.append("-DNDEBUG");
@@ -4161,12 +4192,10 @@ pub fn addCCArgs(
                     // Zig code than it is for C code. Also, C programmers are used to their code
                     // running in -O2 and thus the -O3 path has been tested less.
                     try argv.append("-O2");
-                    try argv.append("-fno-stack-protector");
                 },
                 .ReleaseSmall => {
                     try argv.append("-DNDEBUG");
                     try argv.append("-Os");
-                    try argv.append("-fno-stack-protector");
                 },
             }
 
@@ -5031,6 +5060,7 @@ fn buildOutputFromZig(
         .use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1,
         .want_sanitize_c = false,
         .want_stack_check = false,
+        .want_stack_protector = 0,
         .want_red_zone = comp.bin_file.options.red_zone,
         .omit_frame_pointer = comp.bin_file.options.omit_frame_pointer,
         .want_valgrind = false,
@@ -5311,6 +5341,7 @@ pub fn build_crt_file(
         .optimize_mode = comp.compilerRtOptMode(),
         .want_sanitize_c = false,
         .want_stack_check = false,
+        .want_stack_protector = 0,
         .want_red_zone = comp.bin_file.options.red_zone,
         .omit_frame_pointer = comp.bin_file.options.omit_frame_pointer,
         .want_valgrind = false,
diff --git a/src/clang_options_data.zig b/src/clang_options_data.zig
index 76e687c7d6aba2a3b721e8ba97d0d6062f9c8d6b..90ba377847bb6e756232b1e32d2ff3335b64f157 100644
--- a/src/clang_options_data.zig
+++ b/src/clang_options_data.zig
@@ -3290,7 +3290,14 @@ flagpd1("fno-stack-arrays"),
     .psl = false,
 },
 flagpd1("fno-stack-clash-protection"),
-flagpd1("fno-stack-protector"),
+.{
+    .name = "fno-stack-protector",
+    .syntax = .flag,
+    .zig_equivalent = .no_stack_protector,
+    .pd1 = true,
+    .pd2 = false,
+    .psl = false,
+},
 flagpd1("fno-stack-size-section"),
 flagpd1("fno-standalone-debug"),
 flagpd1("fno-strength-reduce"),
@@ -3588,9 +3595,30 @@ flagpd1("fstack-arrays"),
     .psl = false,
 },
 flagpd1("fstack-clash-protection"),
-flagpd1("fstack-protector"),
-flagpd1("fstack-protector-all"),
-flagpd1("fstack-protector-strong"),
+.{
+    .name = "fstack-protector",
+    .syntax = .flag,
+    .zig_equivalent = .stack_protector,
+    .pd1 = true,
+    .pd2 = false,
+    .psl = false,
+},
+.{
+    .name = "fstack-protector-all",
+    .syntax = .flag,
+    .zig_equivalent = .stack_protector,
+    .pd1 = true,
+    .pd2 = false,
+    .psl = false,
+},
+.{
+    .name = "fstack-protector-strong",
+    .syntax = .flag,
+    .zig_equivalent = .stack_protector,
+    .pd1 = true,
+    .pd2 = false,
+    .psl = false,
+},
 flagpd1("fstack-size-section"),
 flagpd1("fstack-usage"),
 flagpd1("fstandalone-debug"),
@@ -4809,7 +4837,14 @@ flagpd1("single_module"),
 },
 sepd1("split-dwarf-file"),
 sepd1("split-dwarf-output"),
-sepd1("stack-protector"),
+.{
+    .name = "stack-protector",
+    .syntax = .separate,
+    .zig_equivalent = .stack_protector,
+    .pd1 = true,
+    .pd2 = false,
+    .psl = false,
+},
 sepd1("stack-protector-buffer-size"),
 sepd1("stack-usage-file"),
 .{
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 8c84f61a81e72a25f26edb5e6f6a2b4c4eb7b4de..0898c8fe87c6a79df5e4567276f15ea952dc1245 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -711,9 +711,14 @@ pub const Object = struct {
             DeclGen.removeFnAttr(llvm_func, "noinline");
         }
 
-        // TODO: port these over from stage1
-        // addLLVMFnAttr(llvm_fn, "sspstrong");
-        // addLLVMFnAttrStr(llvm_fn, "stack-protector-buffer-size", "4");
+        // TODO: disable this if safety is off for the function scope
+        const ssp_buf_size = module.comp.bin_file.options.stack_protector;
+        if (ssp_buf_size != 0) {
+            var buf: [12]u8 = undefined;
+            const arg = std.fmt.bufPrintZ(&buf, "{d}", .{ssp_buf_size}) catch unreachable;
+            dg.addFnAttr(llvm_func, "sspstrong");
+            dg.addFnAttrString(llvm_func, "stack-protector-buffer-size", arg);
+        }
 
         // TODO: disable this if safety is off for the function scope
         if (module.comp.bin_file.options.stack_check) {
diff --git a/src/glibc.zig b/src/glibc.zig
index 4deac5275fba5db8502d5adf04ea403864d37a42..ceb60ff096596f7fd456dcae99a42308547e5096 100644
--- a/src/glibc.zig
+++ b/src/glibc.zig
@@ -1111,6 +1111,7 @@ fn buildSharedLib(
         .optimize_mode = comp.compilerRtOptMode(),
         .want_sanitize_c = false,
         .want_stack_check = false,
+        .want_stack_protector = 0,
         .want_red_zone = comp.bin_file.options.red_zone,
         .omit_frame_pointer = comp.bin_file.options.omit_frame_pointer,
         .want_valgrind = false,
diff --git a/src/libcxx.zig b/src/libcxx.zig
index 17d88fa03d4d0de56afeb820439ba4177c820a42..b19834f8c3386267b0f04ca5c2c8072918426406 100644
--- a/src/libcxx.zig
+++ b/src/libcxx.zig
@@ -206,6 +206,7 @@ pub fn buildLibCXX(comp: *Compilation) !void {
         .link_mode = link_mode,
         .want_sanitize_c = false,
         .want_stack_check = false,
+        .want_stack_protector = 0,
         .want_red_zone = comp.bin_file.options.red_zone,
         .omit_frame_pointer = comp.bin_file.options.omit_frame_pointer,
         .want_valgrind = false,
@@ -349,6 +350,7 @@ pub fn buildLibCXXABI(comp: *Compilation) !void {
         .link_mode = link_mode,
         .want_sanitize_c = false,
         .want_stack_check = false,
+        .want_stack_protector = 0,
         .want_red_zone = comp.bin_file.options.red_zone,
         .omit_frame_pointer = comp.bin_file.options.omit_frame_pointer,
         .want_valgrind = false,
diff --git a/src/libtsan.zig b/src/libtsan.zig
index cbbcd11a8a085cf507238c686b146ca897a7b7d7..16e40c16f82c12bae4d498d8a7b39f029deedf75 100644
--- a/src/libtsan.zig
+++ b/src/libtsan.zig
@@ -211,6 +211,7 @@ pub fn buildTsan(comp: *Compilation) !void {
         .link_mode = link_mode,
         .want_sanitize_c = false,
         .want_stack_check = false,
+        .want_stack_protector = 0,
         .want_valgrind = false,
         .want_tsan = false,
         .want_pic = true,
diff --git a/src/libunwind.zig b/src/libunwind.zig
index 0d030be329457f290c82eabe38557f95cebc7a30..fb4f93af02236361b958eda8e47a66d00bbd528a 100644
--- a/src/libunwind.zig
+++ b/src/libunwind.zig
@@ -113,6 +113,7 @@ pub fn buildStaticLib(comp: *Compilation) !void {
         .link_mode = link_mode,
         .want_sanitize_c = false,
         .want_stack_check = false,
+        .want_stack_protector = 0,
         .want_red_zone = comp.bin_file.options.red_zone,
         .omit_frame_pointer = comp.bin_file.options.omit_frame_pointer,
         .want_valgrind = false,
diff --git a/src/link.zig b/src/link.zig
index 31b54f705a1c2b4ea742cf1d76ce9e5878aab98a..a0c0c5c369ee4d09cc7a4cd5d129946333cb4716 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -90,6 +90,9 @@ pub const Options = struct {
     entry: ?[]const u8,
     stack_size_override: ?u64,
     image_base_override: ?u64,
+    /// 0 means no stack protector
+    /// other value means stack protector with that buffer size.
+    stack_protector: u32,
     cache_mode: CacheMode,
     include_compiler_rt: bool,
     /// Set to `true` to omit debug info.
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index 2f67c352054f9ada374c18e65e1e3303d0e3848e..9902886baca5b25c4fc26f8b7b0ce0608c086d3a 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -1673,6 +1673,12 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             }
         }
 
+        // stack-protector.
+        // Related: https://github.com/ziglang/zig/issues/7265
+        if (comp.libssp_static_lib) |ssp| {
+            try argv.append(ssp.full_object_path);
+        }
+
         // compiler-rt
         if (compiler_rt_path) |p| {
             try argv.append(p);
diff --git a/src/main.zig b/src/main.zig
index dfce4d83b88e21c266e816c6810108343d6e8b4d..91d171d23764c13873a89ef63116441153c49e2f 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -378,6 +378,8 @@ const usage_build_generic =
     \\  -fno-lto                  Force-disable Link Time Optimization
     \\  -fstack-check             Enable stack probing in unsafe builds
     \\  -fno-stack-check          Disable stack probing in safe builds
+    \\  -fstack-protector         Enable stack protection in unsafe builds
+    \\  -fno-stack-protector      Disable stack protection in safe builds
     \\  -fsanitize-c              Enable C undefined behavior detection in unsafe builds
     \\  -fno-sanitize-c           Disable C undefined behavior detection in safe builds
     \\  -fvalgrind                Include valgrind client requests in release builds
@@ -668,6 +670,7 @@ fn buildOutputType(
     var want_unwind_tables: ?bool = null;
     var want_sanitize_c: ?bool = null;
     var want_stack_check: ?bool = null;
+    var want_stack_protector: ?u32 = null;
     var want_red_zone: ?bool = null;
     var omit_frame_pointer: ?bool = null;
     var want_valgrind: ?bool = null;
@@ -1168,6 +1171,10 @@ fn buildOutputType(
                         want_stack_check = true;
                     } else if (mem.eql(u8, arg, "-fno-stack-check")) {
                         want_stack_check = false;
+                    } else if (mem.eql(u8, arg, "-fstack-protector")) {
+                        want_stack_protector = Compilation.default_stack_protector_buffer_size;
+                    } else if (mem.eql(u8, arg, "-fno-stack-protector")) {
+                        want_stack_protector = 0;
                     } else if (mem.eql(u8, arg, "-mred-zone")) {
                         want_red_zone = true;
                     } else if (mem.eql(u8, arg, "-mno-red-zone")) {
@@ -1521,6 +1528,12 @@ fn buildOutputType(
                     .no_color_diagnostics => color = .off,
                     .stack_check => want_stack_check = true,
                     .no_stack_check => want_stack_check = false,
+                    .stack_protector => {
+                        if (want_stack_protector == null) {
+                            want_stack_protector = Compilation.default_stack_protector_buffer_size;
+                        }
+                    },
+                    .no_stack_protector => want_stack_protector = 0,
                     .unwind_tables => want_unwind_tables = true,
                     .no_unwind_tables => want_unwind_tables = false,
                     .nostdlib => ensure_libc_on_non_freestanding = false,
@@ -2859,6 +2872,7 @@ fn buildOutputType(
         .want_unwind_tables = want_unwind_tables,
         .want_sanitize_c = want_sanitize_c,
         .want_stack_check = want_stack_check,
+        .want_stack_protector = want_stack_protector,
         .want_red_zone = want_red_zone,
         .omit_frame_pointer = omit_frame_pointer,
         .want_valgrind = want_valgrind,
@@ -4663,6 +4677,8 @@ pub const ClangArgIterator = struct {
         no_color_diagnostics,
         stack_check,
         no_stack_check,
+        stack_protector,
+        no_stack_protector,
         strip,
         exec_model,
         emit_llvm,
diff --git a/src/musl.zig b/src/musl.zig
index 68b524b4152a19a1cd96b81e5f6aee4ad1a53f5c..12ff530f8e8e3db43cc86c708850947a1ee2a4db 100644
--- a/src/musl.zig
+++ b/src/musl.zig
@@ -215,6 +215,7 @@ pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile) !void {
                 .optimize_mode = comp.compilerRtOptMode(),
                 .want_sanitize_c = false,
                 .want_stack_check = false,
+                .want_stack_protector = 0,
                 .want_red_zone = comp.bin_file.options.red_zone,
                 .omit_frame_pointer = comp.bin_file.options.omit_frame_pointer,
                 .want_valgrind = false,
diff --git a/src/target.zig b/src/target.zig
index 5202fb15fc1007a3b5633b5cf194cd47b1602be7..3c8eabe01d503f75556beebed5393c85a27fbcf1 100644
--- a/src/target.zig
+++ b/src/target.zig
@@ -300,6 +300,15 @@ pub fn supportsStackProbing(target: std.Target) bool {
         (target.cpu.arch == .i386 or target.cpu.arch == .x86_64);
 }
 
+pub fn supportsStackProtector(target: std.Target) bool {
+    _ = target;
+    return true;
+}
+
+pub fn libcProvidesStackProtector(target: std.Target) bool {
+    return !target.isMinGW() and target.os.tag != .wasi;
+}
+
 pub fn supportsReturnAddress(target: std.Target) bool {
     return switch (target.cpu.arch) {
         .wasm32, .wasm64 => target.os.tag == .emscripten,
diff --git a/tools/update_clang_options.zig b/tools/update_clang_options.zig
index d261b5ee33325468bd892746e3822b8a9d02974e..f1656546f0a2c9b72ac84c82bdc94e7c89b8a8bb 100644
--- a/tools/update_clang_options.zig
+++ b/tools/update_clang_options.zig
@@ -352,6 +352,26 @@ const known_options = [_]KnownOpt{
         .name = "fno-stack-check",
         .ident = "no_stack_check",
     },
+    .{
+        .name = "stack-protector",
+        .ident = "stack_protector",
+    },
+    .{
+        .name = "fstack-protector",
+        .ident = "stack_protector",
+    },
+    .{
+        .name = "fno-stack-protector",
+        .ident = "no_stack_protector",
+    },
+    .{
+        .name = "fstack-protector-strong",
+        .ident = "stack_protector",
+    },
+    .{
+        .name = "fstack-protector-all",
+        .ident = "stack_protector",
+    },
     .{
         .name = "MD",
         .ident = "dep_file",
-- 
2.54.0


From d6ba66e50d5f0dbabaf7b56e7eed4b668cd53244 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 17 Aug 2022 23:18:45 -0700
Subject: [PATCH 165/290] Sema: avoid false positive error for linking libc

when extern c functions are called.
---
 src/Sema.zig   | 15 ++++++++-------
 src/stage1.zig |  2 +-
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index d059ee09a39d211d2746a6ea8db2d2f664f83170..091b88e7190fd0383dd649af24ff73f0750c33ce 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -7567,10 +7567,11 @@ fn handleExternLibName(
 ) CompileError![:0]u8 {
     blk: {
         const mod = sema.mod;
+        const comp = mod.comp;
         const target = mod.getTarget();
         log.debug("extern fn symbol expected in lib '{s}'", .{lib_name});
         if (target_util.is_libc_lib_name(target, lib_name)) {
-            if (!mod.comp.bin_file.options.link_libc) {
+            if (!comp.bin_file.options.link_libc and !comp.bin_file.options.parent_compilation_link_libc) {
                 return sema.fail(
                     block,
                     src_loc,
@@ -7578,11 +7579,11 @@ fn handleExternLibName(
                     .{},
                 );
             }
-            mod.comp.bin_file.options.link_libc = true;
+            comp.bin_file.options.link_libc = true;
             break :blk;
         }
         if (target_util.is_libcpp_lib_name(target, lib_name)) {
-            if (!mod.comp.bin_file.options.link_libcpp) {
+            if (!comp.bin_file.options.link_libcpp) {
                 return sema.fail(
                     block,
                     src_loc,
@@ -7590,14 +7591,14 @@ fn handleExternLibName(
                     .{},
                 );
             }
-            mod.comp.bin_file.options.link_libcpp = true;
+            comp.bin_file.options.link_libcpp = true;
             break :blk;
         }
         if (mem.eql(u8, lib_name, "unwind")) {
-            mod.comp.bin_file.options.link_libunwind = true;
+            comp.bin_file.options.link_libunwind = true;
             break :blk;
         }
-        if (!target.isWasm() and !mod.comp.bin_file.options.pic) {
+        if (!target.isWasm() and !comp.bin_file.options.pic) {
             return sema.fail(
                 block,
                 src_loc,
@@ -7605,7 +7606,7 @@ fn handleExternLibName(
                 .{ lib_name, lib_name },
             );
         }
-        mod.comp.stage1AddLinkLib(lib_name) catch |err| {
+        comp.stage1AddLinkLib(lib_name) catch |err| {
             return sema.fail(block, src_loc, "unable to add link lib '{s}': {s}", .{
                 lib_name, @errorName(err),
             });
diff --git a/src/stage1.zig b/src/stage1.zig
index f400053b0fb302417f3fc4c6b830f4167611ac1b..826fdd0f6bb9466883ecd66050b918f865406f56 100644
--- a/src/stage1.zig
+++ b/src/stage1.zig
@@ -416,7 +416,7 @@ export fn stage2_add_link_lib(
     const target = comp.getTarget();
     const is_libc = target_util.is_libc_lib_name(target, lib_name);
     if (is_libc) {
-        if (!comp.bin_file.options.link_libc) {
+        if (!comp.bin_file.options.link_libc and !comp.bin_file.options.parent_compilation_link_libc) {
             return "dependency on libc must be explicitly specified in the build command";
         }
         return null;
-- 
2.54.0


From fdb934a157230ae6d3f11dee8d0d62013d5b919e Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 18 Aug 2022 01:03:25 -0700
Subject: [PATCH 166/290] stage2: disable stack-protector on wasm, matching
 stage1

The CI gave me: unknown import: `env::__stack_chk_fail` has not been
defined
---
 src/target.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/target.zig b/src/target.zig
index 3c8eabe01d503f75556beebed5393c85a27fbcf1..405a7fe2bf6c22a081de56db3197d23e0e1d3619 100644
--- a/src/target.zig
+++ b/src/target.zig
@@ -301,8 +301,8 @@ pub fn supportsStackProbing(target: std.Target) bool {
 }
 
 pub fn supportsStackProtector(target: std.Target) bool {
-    _ = target;
-    return true;
+    // TODO: investigate whether stack-protector works on wasm
+    return !target.isWasm();
 }
 
 pub fn libcProvidesStackProtector(target: std.Target) bool {
-- 
2.54.0


From 39f43fea8d0f6aa1c69cb7c3209f57f5ce00b273 Mon Sep 17 00:00:00 2001
From: r00ster91 <r00ster91@proton.me>
Date: Fri, 19 Aug 2022 12:03:14 +0200
Subject: [PATCH 167/290] fix: fix off-by-one for leading zeroes

---
 src/translate_c.zig  |  2 +-
 test/translate_c.zig | 12 ++++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/translate_c.zig b/src/translate_c.zig
index fa23b861e380a9df9f4be4c02ba79c9eba754791..41b87ade21199a4d8c12b3252fe4c92393c3c1bb 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -5647,7 +5647,7 @@ fn parseCNumLit(c: *Context, m: *MacroCtx) ParseError!Node {
     switch (m.list[m.i].id) {
         .IntegerLiteral => |suffix| {
             var radix: []const u8 = "decimal";
-            if (lit_bytes.len > 2 and lit_bytes[0] == '0') {
+            if (lit_bytes.len >= 2 and lit_bytes[0] == '0') {
                 switch (lit_bytes[1]) {
                     '0'...'7' => {
                         // Octal
diff --git a/test/translate_c.zig b/test/translate_c.zig
index 540c560839bc9043407674086b5051d6e5d813f5..637d491f49071efbcc0d8295c3a5dde2491178ab 100644
--- a/test/translate_c.zig
+++ b/test/translate_c.zig
@@ -3842,4 +3842,16 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
     , &[_][]const u8{
         \\pub const FOO = "";
     });
+
+    cases.add("leading zeroes",
+        \\#define O_RDONLY  00
+        \\#define HELLO 000
+        \\#define ZERO 0
+        \\#define WORLD 00000123
+    , &[_][]const u8{
+        \\pub const O_RDONLY = @as(c_int, 0o0);
+        \\pub const HELLO = @as(c_int, 0o00);
+        \\pub const ZERO = @as(c_int, 0);
+        \\pub const WORLD = @as(c_int, 0o0000123);
+    });
 }
-- 
2.54.0


From 73bbd1069a993a0e663033ea3b8cd4ed1a123566 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 7 Aug 2022 18:17:31 -0700
Subject: [PATCH 168/290] build: remove the option to omit stage2

---
 build.zig           | 14 +++++---------
 ci/azure/build.zig  |  2 --
 src/Compilation.zig | 29 ++---------------------------
 src/Sema.zig        |  7 -------
 src/config.zig.in   |  1 -
 test/tests.zig      |  6 ------
 6 files changed, 7 insertions(+), 52 deletions(-)

diff --git a/build.zig b/build.zig
index 0ff528520180b290959854a6c20b2d750fd882e1..1c2212c1a4c7e89ccbd3127a2864df5aaf73b25b 100644
--- a/build.zig
+++ b/build.zig
@@ -65,7 +65,6 @@ pub fn build(b: *Builder) !void {
     const only_install_lib_files = b.option(bool, "lib-files-only", "Only install library files") orelse false;
 
     const is_stage1 = b.option(bool, "stage1", "Build the stage1 compiler, put stage2 behind a feature flag") orelse false;
-    const omit_stage2 = b.option(bool, "omit-stage2", "Do not include stage2 behind a feature flag inside stage1") orelse false;
     const static_llvm = b.option(bool, "static-llvm", "Disable integration with system-installed LLVM, Clang, LLD, and libc++") orelse false;
     const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (is_stage1 or static_llvm);
     const llvm_has_m68k = b.option(
@@ -361,7 +360,6 @@ pub fn build(b: *Builder) !void {
     exe_options.addOption(bool, "enable_tracy_allocation", tracy_allocation);
     exe_options.addOption(bool, "value_tracing", value_tracing);
     exe_options.addOption(bool, "is_stage1", is_stage1);
-    exe_options.addOption(bool, "omit_stage2", omit_stage2);
     if (tracy) |tracy_path| {
         const client_cpp = fs.path.join(
             b.allocator,
@@ -397,7 +395,6 @@ pub fn build(b: *Builder) !void {
     test_cases_options.addOption(bool, "skip_non_native", skip_non_native);
     test_cases_options.addOption(bool, "skip_stage1", skip_stage1);
     test_cases_options.addOption(bool, "is_stage1", is_stage1);
-    test_cases_options.addOption(bool, "omit_stage2", omit_stage2);
     test_cases_options.addOption(bool, "have_llvm", enable_llvm);
     test_cases_options.addOption(bool, "llvm_has_m68k", llvm_has_m68k);
     test_cases_options.addOption(bool, "llvm_has_csky", llvm_has_csky);
@@ -457,7 +454,7 @@ pub fn build(b: *Builder) !void {
         skip_non_native,
         skip_libc,
         skip_stage1,
-        omit_stage2,
+        false,
         is_stage1,
     ));
 
@@ -472,7 +469,7 @@ pub fn build(b: *Builder) !void {
         skip_non_native,
         true, // skip_libc
         skip_stage1,
-        omit_stage2 or true, // TODO get these all passing
+        true, // TODO get these all passing
         is_stage1,
     ));
 
@@ -487,7 +484,7 @@ pub fn build(b: *Builder) !void {
         skip_non_native,
         true, // skip_libc
         skip_stage1,
-        omit_stage2 or true, // TODO get these all passing
+        true, // TODO get these all passing
         is_stage1,
     ));
 
@@ -499,14 +496,13 @@ pub fn build(b: *Builder) !void {
         skip_non_native,
         enable_macos_sdk,
         target,
-        omit_stage2,
         b.enable_darling,
         b.enable_qemu,
         b.enable_rosetta,
         b.enable_wasmtime,
         b.enable_wine,
     ));
-    toolchain_step.dependOn(tests.addLinkTests(b, test_filter, modes, enable_macos_sdk, omit_stage2));
+    toolchain_step.dependOn(tests.addLinkTests(b, test_filter, modes, enable_macos_sdk));
     toolchain_step.dependOn(tests.addStackTraceTests(b, test_filter, modes));
     toolchain_step.dependOn(tests.addCliTests(b, test_filter, modes));
     toolchain_step.dependOn(tests.addAssembleAndLinkTests(b, test_filter, modes));
@@ -528,7 +524,7 @@ pub fn build(b: *Builder) !void {
         skip_non_native,
         skip_libc,
         skip_stage1,
-        omit_stage2 or true, // TODO get these all passing
+        true, // TODO get these all passing
         is_stage1,
     );
 
diff --git a/ci/azure/build.zig b/ci/azure/build.zig
index 3fec5553215f6851ce2973d26a75ad2edc13052c..053065b6997b3375b90f57e9c892ace1a688452c 100644
--- a/ci/azure/build.zig
+++ b/ci/azure/build.zig
@@ -38,7 +38,6 @@ pub fn build(b: *Builder) !void {
     docs_step.dependOn(&docgen_cmd.step);
 
     const is_stage1 = b.option(bool, "stage1", "Build the stage1 compiler, put stage2 behind a feature flag") orelse false;
-    const omit_stage2 = b.option(bool, "omit-stage2", "Do not include stage2 behind a feature flag inside stage1") orelse false;
     const static_llvm = b.option(bool, "static-llvm", "Disable integration with system-installed LLVM, Clang, LLD, and libc++") orelse false;
     const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (is_stage1 or static_llvm);
     const llvm_has_m68k = b.option(
@@ -300,7 +299,6 @@ pub fn build(b: *Builder) !void {
     exe_options.addOption(bool, "enable_tracy_allocation", tracy_allocation);
     exe_options.addOption(bool, "value_tracing", value_tracing);
     exe_options.addOption(bool, "is_stage1", is_stage1);
-    exe_options.addOption(bool, "omit_stage2", omit_stage2);
     if (tracy) |tracy_path| {
         const client_cpp = fs.path.join(
             b.allocator,
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 060afba6948b01d749d2ade35e213932e708e60b..6d778b955a013f7f941e772332c4811ffe429fe6 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -1044,8 +1044,6 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             // Even though we may have no Zig code to compile (depending on `options.main_pkg`),
             // we may need to use stage1 for building compiler-rt and other dependencies.
 
-            if (build_options.omit_stage2)
-                break :blk true;
             if (options.use_llvm) |use_llvm| {
                 if (!use_llvm) {
                     break :blk false;
@@ -2213,8 +2211,7 @@ pub fn update(comp: *Compilation) !void {
         comp.c_object_work_queue.writeItemAssumeCapacity(key);
     }
 
-    const use_stage1 = build_options.omit_stage2 or
-        (build_options.is_stage1 and comp.bin_file.options.use_stage1);
+    const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1;
     if (comp.bin_file.options.module) |module| {
         module.compile_log_text.shrinkAndFree(module.gpa, 0);
         module.generation += 1;
@@ -2390,8 +2387,7 @@ fn flush(comp: *Compilation, prog_node: *std.Progress.Node) !void {
     };
     comp.link_error_flags = comp.bin_file.errorFlags();
 
-    const use_stage1 = build_options.omit_stage2 or
-        (build_options.is_stage1 and comp.bin_file.options.use_stage1);
+    const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1;
     if (!use_stage1) {
         if (comp.bin_file.options.module) |module| {
             try link.File.C.flushEmitH(module);
@@ -2952,9 +2948,6 @@ pub fn performAllTheWork(
 fn processOneJob(comp: *Compilation, job: Job) !void {
     switch (job) {
         .codegen_decl => |decl_index| {
-            if (build_options.omit_stage2)
-                @panic("sadly stage2 is omitted from this build to save memory on the CI server");
-
             const module = comp.bin_file.options.module.?;
             const decl = module.declPtr(decl_index);
 
@@ -2989,9 +2982,6 @@ fn processOneJob(comp: *Compilation, job: Job) !void {
             }
         },
         .codegen_func => |func| {
-            if (build_options.omit_stage2)
-                @panic("sadly stage2 is omitted from this build to save memory on the CI server");
-
             const named_frame = tracy.namedFrame("codegen_func");
             defer named_frame.end();
 
@@ -3002,9 +2992,6 @@ fn processOneJob(comp: *Compilation, job: Job) !void {
             };
         },
         .emit_h_decl => |decl_index| {
-            if (build_options.omit_stage2)
-                @panic("sadly stage2 is omitted from this build to save memory on the CI server");
-
             const module = comp.bin_file.options.module.?;
             const decl = module.declPtr(decl_index);
 
@@ -3063,9 +3050,6 @@ fn processOneJob(comp: *Compilation, job: Job) !void {
             }
         },
         .analyze_decl => |decl_index| {
-            if (build_options.omit_stage2)
-                @panic("sadly stage2 is omitted from this build to save memory on the CI server");
-
             const module = comp.bin_file.options.module.?;
             module.ensureDeclAnalyzed(decl_index) catch |err| switch (err) {
                 error.OutOfMemory => return error.OutOfMemory,
@@ -3073,9 +3057,6 @@ fn processOneJob(comp: *Compilation, job: Job) !void {
             };
         },
         .update_embed_file => |embed_file| {
-            if (build_options.omit_stage2)
-                @panic("sadly stage2 is omitted from this build to save memory on the CI server");
-
             const named_frame = tracy.namedFrame("update_embed_file");
             defer named_frame.end();
 
@@ -3086,9 +3067,6 @@ fn processOneJob(comp: *Compilation, job: Job) !void {
             };
         },
         .update_line_number => |decl_index| {
-            if (build_options.omit_stage2)
-                @panic("sadly stage2 is omitted from this build to save memory on the CI server");
-
             const named_frame = tracy.namedFrame("update_line_number");
             defer named_frame.end();
 
@@ -3107,9 +3085,6 @@ fn processOneJob(comp: *Compilation, job: Job) !void {
             };
         },
         .analyze_pkg => |pkg| {
-            if (build_options.omit_stage2)
-                @panic("sadly stage2 is omitted from this build to save memory on the CI server");
-
             const named_frame = tracy.namedFrame("analyze_pkg");
             defer named_frame.end();
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 091b88e7190fd0383dd649af24ff73f0750c33ce..aa02288df7741eefd302604e55ec688b9adf90eb 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -27358,9 +27358,6 @@ pub fn resolveTypeLayout(
     src: LazySrcLoc,
     ty: Type,
 ) CompileError!void {
-    if (build_options.omit_stage2)
-        @panic("sadly stage2 is omitted from this build to save memory on the CI server");
-
     switch (ty.zigTypeTag()) {
         .Struct => return sema.resolveStructLayout(block, src, ty),
         .Union => return sema.resolveUnionLayout(block, src, ty),
@@ -27699,8 +27696,6 @@ fn resolveUnionFully(
 }
 
 pub fn resolveTypeFields(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) CompileError!Type {
-    if (build_options.omit_stage2)
-        @panic("sadly stage2 is omitted from this build to save memory on the CI server");
     switch (ty.tag()) {
         .@"struct" => {
             const struct_obj = ty.castTag(.@"struct").?.data;
@@ -29323,8 +29318,6 @@ fn typePtrOrOptionalPtrTy(
 /// TODO merge these implementations together with the "advanced"/sema_kit pattern seen
 /// elsewhere in value.zig
 pub fn typeRequiresComptime(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) CompileError!bool {
-    if (build_options.omit_stage2)
-        @panic("sadly stage2 is omitted from this build to save memory on the CI server");
     return switch (ty.tag()) {
         .u1,
         .u8,
diff --git a/src/config.zig.in b/src/config.zig.in
index a886b2d28efa9d9f354dddbc498f38e50527b03b..336a6c45edae736ba350c89d646afc06fa4edcd8 100644
--- a/src/config.zig.in
+++ b/src/config.zig.in
@@ -10,4 +10,3 @@ pub const enable_tracy = false;
 pub const value_tracing = false;
 pub const is_stage1 = true;
 pub const skip_non_native = false;
-pub const omit_stage2: bool = @ZIG_OMIT_STAGE2_BOOL@;
diff --git a/test/tests.zig b/test/tests.zig
index 0bca9a9d16030ceae1322a01008281722f9f536e..e1836dc1e010d95d55262e21b007fc1bbc068937 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -462,7 +462,6 @@ pub fn addStandaloneTests(
     skip_non_native: bool,
     enable_macos_sdk: bool,
     target: std.zig.CrossTarget,
-    omit_stage2: bool,
     enable_darling: bool,
     enable_qemu: bool,
     enable_rosetta: bool,
@@ -479,7 +478,6 @@ pub fn addStandaloneTests(
         .skip_non_native = skip_non_native,
         .enable_macos_sdk = enable_macos_sdk,
         .target = target,
-        .omit_stage2 = omit_stage2,
         .enable_darling = enable_darling,
         .enable_qemu = enable_qemu,
         .enable_rosetta = enable_rosetta,
@@ -497,7 +495,6 @@ pub fn addLinkTests(
     test_filter: ?[]const u8,
     modes: []const Mode,
     enable_macos_sdk: bool,
-    omit_stage2: bool,
 ) *build.Step {
     const cases = b.allocator.create(StandaloneContext) catch unreachable;
     cases.* = StandaloneContext{
@@ -509,7 +506,6 @@ pub fn addLinkTests(
         .skip_non_native = true,
         .enable_macos_sdk = enable_macos_sdk,
         .target = .{},
-        .omit_stage2 = omit_stage2,
     };
     link.addCases(cases);
     return cases.step;
@@ -978,7 +974,6 @@ pub const StandaloneContext = struct {
     skip_non_native: bool,
     enable_macos_sdk: bool,
     target: std.zig.CrossTarget,
-    omit_stage2: bool,
     enable_darling: bool = false,
     enable_qemu: bool = false,
     enable_rosetta: bool = false,
@@ -1003,7 +998,6 @@ pub const StandaloneContext = struct {
         const b = self.b;
 
         if (features.requires_macos_sdk and !self.enable_macos_sdk) return;
-        if (features.requires_stage2 and self.omit_stage2) return;
 
         const annotated_case_name = b.fmt("build {s}", .{build_file});
         if (self.test_filter) |filter| {
-- 
2.54.0


From 507aae4a1a3db498ece2a3a89d74e9e24d952923 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Sun, 7 Aug 2022 23:10:57 -0700
Subject: [PATCH 169/290] make self-hosted the default compiler

stage1 is available behind the -fstage1 flag.

closes #89
---
 CMakeLists.txt                                |   2 +-
 build.zig                                     |  16 +-
 ci/azure/build.zig                            |  10 +-
 ci/azure/macos_script                         |  17 +-
 ci/azure/pipelines.yml                        |   4 +-
 ci/srht/freebsd_script                        |   9 +-
 ci/zinc/linux_test.sh                         |  46 +++--
 doc/docgen.zig                                |  31 +++
 doc/langref.html.in                           | 178 +++++++-----------
 lib/std/builtin.zig                           |   2 +-
 src/Compilation.zig                           |  29 +--
 src/config.zig.in                             |   2 +-
 src/link.zig                                  |   4 +-
 src/link/Coff.zig                             |   4 +-
 src/link/Elf.zig                              |   2 +-
 src/link/MachO.zig                            |   4 +-
 src/link/Wasm.zig                             |   6 +-
 src/main.zig                                  |   2 +-
 src/stage1.zig                                |   2 +-
 src/test.zig                                  |   2 +-
 ...mpty slice with sentinel out of bounds.zig |   2 +-
 .../safety/out of bounds slice access.zig     |   6 +-
 ...h sentinel out of bounds - runtime len.zig |   2 +-
 .../slice with sentinel out of bounds.zig     |   2 +-
 test/tests.zig                                |   3 +-
 25 files changed, 175 insertions(+), 212 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 96d10f1e8354f2bdee137fbcdf4b67ff43c16cd2..d9784090cd0801a584f0aca834b36b6756c1bccd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,7 +12,7 @@ if(NOT CMAKE_BUILD_TYPE)
 endif()
 
 if(NOT CMAKE_INSTALL_PREFIX)
-    set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/stage1" CACHE STRING
+    set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/stage2" CACHE STRING
       "Directory to install zig to" FORCE)
 endif()
 
diff --git a/build.zig b/build.zig
index 1c2212c1a4c7e89ccbd3127a2864df5aaf73b25b..6823248431daadc19ed22bf854d2353999997bac 100644
--- a/build.zig
+++ b/build.zig
@@ -64,9 +64,9 @@ pub fn build(b: *Builder) !void {
 
     const only_install_lib_files = b.option(bool, "lib-files-only", "Only install library files") orelse false;
 
-    const is_stage1 = b.option(bool, "stage1", "Build the stage1 compiler, put stage2 behind a feature flag") orelse false;
+    const have_stage1 = b.option(bool, "enable-stage1", "Include the stage1 compiler behind a feature flag") orelse false;
     const static_llvm = b.option(bool, "static-llvm", "Disable integration with system-installed LLVM, Clang, LLD, and libc++") orelse false;
-    const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (is_stage1 or static_llvm);
+    const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (have_stage1 or static_llvm);
     const llvm_has_m68k = b.option(
         bool,
         "llvm-has-m68k",
@@ -136,7 +136,7 @@ pub fn build(b: *Builder) !void {
     };
 
     const main_file: ?[]const u8 = mf: {
-        if (!is_stage1) break :mf "src/main.zig";
+        if (!have_stage1) break :mf "src/main.zig";
         if (use_zig0) break :mf null;
         break :mf "src/stage1.zig";
     };
@@ -247,7 +247,7 @@ pub fn build(b: *Builder) !void {
             }
         };
 
-        if (is_stage1) {
+        if (have_stage1) {
             const softfloat = b.addStaticLibrary("softfloat", null);
             softfloat.setBuildMode(.ReleaseFast);
             softfloat.setTarget(target);
@@ -359,7 +359,7 @@ pub fn build(b: *Builder) !void {
     exe_options.addOption(bool, "enable_tracy_callstack", tracy_callstack);
     exe_options.addOption(bool, "enable_tracy_allocation", tracy_allocation);
     exe_options.addOption(bool, "value_tracing", value_tracing);
-    exe_options.addOption(bool, "is_stage1", is_stage1);
+    exe_options.addOption(bool, "have_stage1", have_stage1);
     if (tracy) |tracy_path| {
         const client_cpp = fs.path.join(
             b.allocator,
@@ -394,7 +394,7 @@ pub fn build(b: *Builder) !void {
     test_cases_options.addOption(bool, "enable_link_snapshots", enable_link_snapshots);
     test_cases_options.addOption(bool, "skip_non_native", skip_non_native);
     test_cases_options.addOption(bool, "skip_stage1", skip_stage1);
-    test_cases_options.addOption(bool, "is_stage1", is_stage1);
+    test_cases_options.addOption(bool, "have_stage1", have_stage1);
     test_cases_options.addOption(bool, "have_llvm", enable_llvm);
     test_cases_options.addOption(bool, "llvm_has_m68k", llvm_has_m68k);
     test_cases_options.addOption(bool, "llvm_has_csky", llvm_has_csky);
@@ -455,7 +455,6 @@ pub fn build(b: *Builder) !void {
         skip_libc,
         skip_stage1,
         false,
-        is_stage1,
     ));
 
     toolchain_step.dependOn(tests.addPkgTests(
@@ -470,7 +469,6 @@ pub fn build(b: *Builder) !void {
         true, // skip_libc
         skip_stage1,
         true, // TODO get these all passing
-        is_stage1,
     ));
 
     toolchain_step.dependOn(tests.addPkgTests(
@@ -485,7 +483,6 @@ pub fn build(b: *Builder) !void {
         true, // skip_libc
         skip_stage1,
         true, // TODO get these all passing
-        is_stage1,
     ));
 
     toolchain_step.dependOn(tests.addCompareOutputTests(b, test_filter, modes));
@@ -525,7 +522,6 @@ pub fn build(b: *Builder) !void {
         skip_libc,
         skip_stage1,
         true, // TODO get these all passing
-        is_stage1,
     );
 
     const test_step = b.step("test", "Run all the tests");
diff --git a/ci/azure/build.zig b/ci/azure/build.zig
index 053065b6997b3375b90f57e9c892ace1a688452c..00f1cce2bd95eb5597ec8ec33f6c5dc0e4afa328 100644
--- a/ci/azure/build.zig
+++ b/ci/azure/build.zig
@@ -37,9 +37,9 @@ pub fn build(b: *Builder) !void {
     const docs_step = b.step("docs", "Build documentation");
     docs_step.dependOn(&docgen_cmd.step);
 
-    const is_stage1 = b.option(bool, "stage1", "Build the stage1 compiler, put stage2 behind a feature flag") orelse false;
+    const have_stage1 = b.option(bool, "enable-stage1", "Include the stage1 compiler behind a feature flag") orelse false;
     const static_llvm = b.option(bool, "static-llvm", "Disable integration with system-installed LLVM, Clang, LLD, and libc++") orelse false;
-    const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (is_stage1 or static_llvm);
+    const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (have_stage1 or static_llvm);
     const llvm_has_m68k = b.option(
         bool,
         "llvm-has-m68k",
@@ -101,7 +101,7 @@ pub fn build(b: *Builder) !void {
         break :blk 4;
     };
 
-    const main_file: ?[]const u8 = if (is_stage1) null else "src/main.zig";
+    const main_file: ?[]const u8 = if (have_stage1) null else "src/main.zig";
 
     const exe = b.addExecutable("zig", main_file);
     exe.strip = strip;
@@ -190,7 +190,7 @@ pub fn build(b: *Builder) !void {
     if (enable_llvm) {
         const cmake_cfg = if (static_llvm) null else findAndParseConfigH(b, config_h_path_option);
 
-        if (is_stage1) {
+        if (have_stage1) {
             const softfloat = b.addStaticLibrary("softfloat", null);
             softfloat.setBuildMode(.ReleaseFast);
             softfloat.setTarget(target);
@@ -298,7 +298,7 @@ pub fn build(b: *Builder) !void {
     exe_options.addOption(bool, "enable_tracy_callstack", tracy_callstack);
     exe_options.addOption(bool, "enable_tracy_allocation", tracy_allocation);
     exe_options.addOption(bool, "value_tracing", value_tracing);
-    exe_options.addOption(bool, "is_stage1", is_stage1);
+    exe_options.addOption(bool, "have_stage1", have_stage1);
     if (tracy) |tracy_path| {
         const client_cpp = fs.path.join(
             b.allocator,
diff --git a/ci/azure/macos_script b/ci/azure/macos_script
index b244a7386947c1ab0756dbdcf62a7d57655e7c75..d0ad9171ee8e9e9d6cb4118f2cef42475b0676c9 100755
--- a/ci/azure/macos_script
+++ b/ci/azure/macos_script
@@ -34,7 +34,7 @@ git fetch --tags
 mkdir build
 cd build
 cmake .. \
-  -DCMAKE_INSTALL_PREFIX="$(pwd)/release" \
+  -DCMAKE_INSTALL_PREFIX="$(pwd)/stage2" \
   -DCMAKE_PREFIX_PATH="$PREFIX" \
   -DCMAKE_BUILD_TYPE=Release \
   -DZIG_TARGET_TRIPLE="$TARGET" \
@@ -52,23 +52,18 @@ make $JOBS install
 # Here we rebuild zig but this time using the Zig binary we just now produced to
 # build zig1.o rather than relying on the one built with stage0. See
 # https://github.com/ziglang/zig/issues/6830 for more details.
-cmake .. -DZIG_EXECUTABLE="$(pwd)/release/bin/zig"
+cmake .. -DZIG_EXECUTABLE="$(pwd)/stage2/bin/zig"
 make $JOBS install
 
-# Build stage2 standalone so that we can test stage2 against stage2 compiler-rt.
-release/bin/zig build -p stage2 -Denable-llvm
+stage2/bin/zig build -p release -Denable-llvm -Denable-stage1
 
-stage2/bin/zig build test-behavior
-
-# TODO: upgrade these to test stage2 instead of stage1
-# TODO: upgrade these to test stage3 instead of stage2
-release/bin/zig build test-behavior         -Denable-macos-sdk -Domit-stage2
 release/bin/zig build test-compiler-rt      -Denable-macos-sdk
+release/bin/zig build test-behavior         -Denable-macos-sdk
 release/bin/zig build test-std              -Denable-macos-sdk
 release/bin/zig build test-universal-libc   -Denable-macos-sdk
 release/bin/zig build test-compare-output   -Denable-macos-sdk
 release/bin/zig build test-standalone       -Denable-macos-sdk
-release/bin/zig build test-stack-traces     -Denable-macos-sdk
+release/bin/zig build test-stack-traces     -Denable-macos-sdk -fstage1
 release/bin/zig build test-cli              -Denable-macos-sdk
 release/bin/zig build test-asm-link         -Denable-macos-sdk
 release/bin/zig build test-translate-c      -Denable-macos-sdk
@@ -76,7 +71,7 @@ release/bin/zig build test-run-translated-c -Denable-macos-sdk
 release/bin/zig build docs                  -Denable-macos-sdk
 release/bin/zig build test-fmt              -Denable-macos-sdk
 release/bin/zig build test-cases            -Denable-macos-sdk -Dsingle-threaded
-release/bin/zig build test-link             -Denable-macos-sdk -Domit-stage2
+release/bin/zig build test-link             -Denable-macos-sdk
 
 if [ "${BUILD_REASON}" != "PullRequest" ]; then
   mv ../LICENSE release/
diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index 5d208b31a2f732703c288644faf12f25bb89d0e9..16804a0a2b6ea11e3b496d73021fa596c023c298 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -68,9 +68,7 @@ jobs:
       & "${ZIGPREFIXPATH}/bin/zig.exe" build `
         --prefix "$ZIGINSTALLDIR" `
         --search-prefix "$ZIGPREFIXPATH" `
-        -Dstage1 `
-        <# stage2 is omitted until we resolve https://github.com/ziglang/zig/issues/6485 #> `
-        -Domit-stage2 `
+        -Denable-stage1 `
         -Dstatic-llvm `
         -Drelease `
         -Dstrip `
diff --git a/ci/srht/freebsd_script b/ci/srht/freebsd_script
index 9fd7c0be6505ab2ceca8a7c392d4227b127dc399..9c77c7d120c4683b9bb6d0eb5d5513147bfdaff4 100755
--- a/ci/srht/freebsd_script
+++ b/ci/srht/freebsd_script
@@ -38,10 +38,11 @@ cmake .. \
     -GNinja
 samu install
 
-# TODO ld.lld: error: undefined symbol: main
-# >>> referenced by crt1_c.c:75 (/usr/src/lib/csu/amd64/crt1_c.c:75)
-# >>>               /usr/lib/crt1.o:(_start)
-#release/bin/zig test ../test/behavior.zig -fno-stage1 -fLLVM -I ../test
+# Here we rebuild zig but this time using the Zig binary we just now produced to
+# build zig1.o rather than relying on the one built with stage0. This makes it
+# a stage3 build rather than a stage2 build.
+cmake .. -DZIG_EXECUTABLE="$PREFIX/bin/zig"
+samu install
 
 # Here we skip some tests to save time.
 release/bin/zig build test -Dskip-stage1 -Dskip-non-native
diff --git a/ci/zinc/linux_test.sh b/ci/zinc/linux_test.sh
index 3a54e82c38a518cb42868a11950c6eb5182b8c01..1b280fbae5fddb56ebef20853f6cbc18dcd12579 100755
--- a/ci/zinc/linux_test.sh
+++ b/ci/zinc/linux_test.sh
@@ -33,41 +33,39 @@ unset CXX
 
 ninja install
 
-STAGE1_ZIG="$DEBUG_STAGING/bin/zig"
-
 # Here we rebuild zig but this time using the Zig binary we just now produced to
 # build zig1.o rather than relying on the one built with stage0. See
 # https://github.com/ziglang/zig/issues/6830 for more details.
-cmake .. -DZIG_EXECUTABLE="$STAGE1_ZIG"
+cmake .. -DZIG_EXECUTABLE="$DEBUG_STAGING/bin/zig"
 ninja install
 
 cd $WORKSPACE
 
+"$DEBUG_STAGING/bin/zig" build -p stage3 -Denable-stage1 -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+
+# simultaneously test building self-hosted without LLVM and with 32-bit arm
+stage3/bin/zig build -Dtarget=arm-linux-musleabihf
+
 echo "Looking for non-conforming code formatting..."
 echo "Formatting errors can be fixed by running 'zig fmt' on the files printed here."
-$STAGE1_ZIG fmt --check . --exclude test/cases/
+stage3/bin/zig fmt --check . --exclude test/cases/
 
-$STAGE1_ZIG    build -p stage2 -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage2/bin/zig build -p stage3 -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build # test building self-hosted without LLVM
-stage3/bin/zig build -Dtarget=arm-linux-musleabihf # test building self-hosted for 32-bit arm
-
-stage3/bin/zig build test-compiler-rt      -fqemu -fwasmtime -Denable-llvm
-stage3/bin/zig build test-behavior         -fqemu -fwasmtime -Denable-llvm
-stage3/bin/zig build test-std              -fqemu -fwasmtime -Denable-llvm
-stage3/bin/zig build test-universal-libc   -fqemu -fwasmtime -Denable-llvm
-stage3/bin/zig build test-compare-output   -fqemu -fwasmtime -Denable-llvm
-stage3/bin/zig build test-asm-link         -fqemu -fwasmtime -Denable-llvm
-stage3/bin/zig build test-fmt              -fqemu -fwasmtime -Denable-llvm
-stage3/bin/zig build test-translate-c      -fqemu -fwasmtime -Denable-llvm
-stage3/bin/zig build test-run-translated-c -fqemu -fwasmtime -Denable-llvm
-stage3/bin/zig build test-standalone       -fqemu -fwasmtime -Denable-llvm
-stage3/bin/zig build test-cli              -fqemu -fwasmtime -Denable-llvm
+stage3/bin/zig build test-compiler-rt      -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+stage3/bin/zig build test-behavior         -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+stage3/bin/zig build test-std              -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+stage3/bin/zig build test-universal-libc   -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+stage3/bin/zig build test-compare-output   -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+stage3/bin/zig build test-asm-link         -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+stage3/bin/zig build test-fmt              -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+stage3/bin/zig build test-translate-c      -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+stage3/bin/zig build test-run-translated-c -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+stage3/bin/zig build test-standalone       -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+stage3/bin/zig build test-cli              -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
 stage3/bin/zig build test-cases            -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-link             -fqemu -fwasmtime -Denable-llvm
+stage3/bin/zig build test-link             -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+stage3/bin/zig build docs                  -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
 
-$STAGE1_ZIG build test-stack-traces     -fqemu -fwasmtime
-$STAGE1_ZIG build docs                  -fqemu -fwasmtime
+stage3/bin/zig build test-stack-traces -fqemu -fwasmtime -fstage1
 
 # Produce the experimental std lib documentation.
 mkdir -p "$RELEASE_STAGING/docs/std"
@@ -87,7 +85,7 @@ stage3/bin/zig build \
   -Drelease \
   -Dstrip \
   -Dtarget="$TARGET" \
-  -Dstage1
+  -Denable-stage1
 
 # Explicit exit helps show last command duration.
 exit
diff --git a/doc/docgen.zig b/doc/docgen.zig
index a101b96be72d809619475618892760ce1b973891..0f0e212e3c244ce2ba86d0d6fc27a949d3fa5d99 100644
--- a/doc/docgen.zig
+++ b/doc/docgen.zig
@@ -285,6 +285,7 @@ const Code = struct {
     link_objects: []const []const u8,
     target_str: ?[]const u8,
     link_libc: bool,
+    backend_stage1: bool,
     link_mode: ?std.builtin.LinkMode,
     disable_cache: bool,
     verbose_cimport: bool,
@@ -554,6 +555,7 @@ fn genToc(allocator: Allocator, tokenizer: *Tokenizer) !Toc {
                     var link_mode: ?std.builtin.LinkMode = null;
                     var disable_cache = false;
                     var verbose_cimport = false;
+                    var backend_stage1 = false;
 
                     const source_token = while (true) {
                         const content_tok = try eatToken(tokenizer, Token.Id.Content);
@@ -586,6 +588,8 @@ fn genToc(allocator: Allocator, tokenizer: *Tokenizer) !Toc {
                             link_libc = true;
                         } else if (mem.eql(u8, end_tag_name, "link_mode_dynamic")) {
                             link_mode = .Dynamic;
+                        } else if (mem.eql(u8, end_tag_name, "backend_stage1")) {
+                            backend_stage1 = true;
                         } else if (mem.eql(u8, end_tag_name, "code_end")) {
                             _ = try eatToken(tokenizer, Token.Id.BracketClose);
                             break content_tok;
@@ -609,6 +613,7 @@ fn genToc(allocator: Allocator, tokenizer: *Tokenizer) !Toc {
                             .link_objects = link_objects.toOwnedSlice(),
                             .target_str = target_str,
                             .link_libc = link_libc,
+                            .backend_stage1 = backend_stage1,
                             .link_mode = link_mode,
                             .disable_cache = disable_cache,
                             .verbose_cimport = verbose_cimport,
@@ -1187,6 +1192,9 @@ fn printShell(out: anytype, shell_content: []const u8) !void {
     try out.writeAll("</samp></pre></figure>");
 }
 
+// Override this to skip to later tests
+const debug_start_line = 0;
+
 fn genHtml(
     allocator: Allocator,
     tokenizer: *Tokenizer,
@@ -1266,6 +1274,13 @@ fn genHtml(
                     continue;
                 }
 
+                if (debug_start_line > 0) {
+                    const loc = tokenizer.getTokenLocation(code.source_token);
+                    if (debug_start_line > loc.line) {
+                        continue;
+                    }
+                }
+
                 const raw_source = tokenizer.buffer[code.source_token.start..code.source_token.end];
                 const trimmed_raw_source = mem.trim(u8, raw_source, " \n");
                 const tmp_source_file_name = try fs.path.join(
@@ -1311,6 +1326,10 @@ fn genHtml(
                             try build_args.append("-lc");
                             try shell_out.print("-lc ", .{});
                         }
+                        if (code.backend_stage1) {
+                            try build_args.append("-fstage1");
+                            try shell_out.print("-fstage1", .{});
+                        }
                         const target = try std.zig.CrossTarget.parse(.{
                             .arch_os_abi = code.target_str orelse "native",
                         });
@@ -1443,6 +1462,10 @@ fn genHtml(
                             try test_args.append("-lc");
                             try shell_out.print("-lc ", .{});
                         }
+                        if (code.backend_stage1) {
+                            try test_args.append("-fstage1");
+                            try shell_out.print("-fstage1", .{});
+                        }
                         if (code.target_str) |triple| {
                             try test_args.appendSlice(&[_][]const u8{ "-target", triple });
                             try shell_out.print("-target {s} ", .{triple});
@@ -1490,6 +1513,14 @@ fn genHtml(
                                 try shell_out.print("-O {s} ", .{@tagName(code.mode)});
                             },
                         }
+                        if (code.link_libc) {
+                            try test_args.append("-lc");
+                            try shell_out.print("-lc ", .{});
+                        }
+                        if (code.backend_stage1) {
+                            try test_args.append("-fstage1");
+                            try shell_out.print("-fstage1", .{});
+                        }
                         const result = try ChildProcess.exec(.{
                             .allocator = allocator,
                             .argv = test_args.items,
diff --git a/doc/langref.html.in b/doc/langref.html.in
index c61f2d0790fe2a3c79cad3fdf018e976615752e7..ba817f0a4d10aa5f5ce61e5c44c6e14162a72c1d 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -1188,6 +1188,7 @@ test "this will be skipped" {
         (The evented IO mode is enabled using the <kbd>--test-evented-io</kbd> command line parameter.)
       </p>
       {#code_begin|test|async_skip#}
+      {#backend_stage1#}
 const std = @import("std");
 
 test "async skip test" {
@@ -2768,7 +2769,7 @@ test "comptime @intToPtr" {
     }
 }
       {#code_end#}
-      {#see_also|Optional Pointers|@intToPtr|@ptrToInt|C Pointers|Pointers to Zero Bit Types#}
+      {#see_also|Optional Pointers|@intToPtr|@ptrToInt|C Pointers#}
       {#header_open|volatile#}
       <p>Loads and stores are assumed to not have side effects. If a given load or store
       should have side effects, such as Memory Mapped Input/Output (MMIO), use {#syntax#}volatile{#endsyntax#}.
@@ -2862,19 +2863,22 @@ var foo: u8 align(4) = 100;
 test "global variable alignment" {
     try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
     try expect(@TypeOf(&foo) == *align(4) u8);
-    const as_pointer_to_array: *[1]u8 = &foo;
-    const as_slice: []u8 = as_pointer_to_array;
-    try expect(@TypeOf(as_slice) == []align(4) u8);
+    const as_pointer_to_array: *align(4) [1]u8 = &foo;
+    const as_slice: []align(4) u8 = as_pointer_to_array;
+    const as_unaligned_slice: []u8 = as_slice;
+    try expect(as_unaligned_slice[0] == 100);
 }
 
-fn derp() align(@sizeOf(usize) * 2) i32 { return 1234; }
+fn derp() align(@sizeOf(usize) * 2) i32 {
+    return 1234;
+}
 fn noop1() align(1) void {}
 fn noop4() align(4) void {}
 
 test "function alignment" {
     try expect(derp() == 1234);
-    try expect(@TypeOf(noop1) == fn() align(1) void);
-    try expect(@TypeOf(noop4) == fn() align(4) void);
+    try expect(@TypeOf(noop1) == fn () align(1) void);
+    try expect(@TypeOf(noop4) == fn () align(4) void);
     noop1();
     noop4();
 }
@@ -3336,6 +3340,7 @@ fn doTheTest() !void {
       Zig allows the address to be taken of a non-byte-aligned field:
       </p>
       {#code_begin|test|pointer_to_non-byte_aligned_field#}
+      {#backend_stage1#}
 const std = @import("std");
 const expect = std.testing.expect;
 
@@ -3391,7 +3396,8 @@ fn bar(x: *const u3) u3 {
       <p>
       Pointers to non-ABI-aligned fields share the same address as the other fields within their host integer:
       </p>
-      {#code_begin|test|pointer_to_non-bit_aligned_field#}
+      {#code_begin|test|packed_struct_field_addrs#}
+      {#backend_stage1#}
 const std = @import("std");
 const expect = std.testing.expect;
 
@@ -3407,7 +3413,7 @@ var bit_field = BitField{
     .c = 3,
 };
 
-test "pointer to non-bit-aligned field" {
+test "pointers of sub-byte-aligned fields share addresses" {
     try expect(@ptrToInt(&bit_field.a) == @ptrToInt(&bit_field.b));
     try expect(@ptrToInt(&bit_field.a) == @ptrToInt(&bit_field.c));
 }
@@ -3438,20 +3444,22 @@ test "pointer to non-bit-aligned field" {
 }
       {#code_end#}
       <p>
-      Packed structs have 1-byte alignment. However if you have an overaligned pointer to a packed struct,
-      Zig should correctly understand the alignment of fields. However there is
-      <a href="https://github.com/ziglang/zig/issues/1994">a bug</a>:
+      Packed structs have the same alignment as their backing integer, however, overaligned
+      pointers to packed structs can override this:
       </p>
-      {#code_begin|test_err|expected type '*u32', found '*align(1) u32'#}
+      {#code_begin|test|overaligned_packed_struct#}
+const std = @import("std");
+const expect = std.testing.expect;
+
 const S = packed struct {
     a: u32,
     b: u32,
 };
 test "overaligned pointer to packed struct" {
-    var foo: S align(4) = undefined;
+    var foo: S align(4) = .{ .a = 1, .b = 2 };
     const ptr: *align(4) S = &foo;
     const ptr_to_b: *u32 = &ptr.b;
-    _ = ptr_to_b;
+    try expect(ptr_to_b.* == 2);
 }
       {#code_end#}
       <p>When this bug is fixed, the above test in the documentation will unexpectedly pass, which will
@@ -3698,7 +3706,7 @@ test "@tagName" {
       <p>
       By default, enums are not guaranteed to be compatible with the C ABI:
       </p>
-      {#code_begin|obj_err|parameter of type 'Foo' not allowed in function with calling convention 'C'#}
+      {#code_begin|obj_err|parameter of type 'test.Foo' not allowed in function with calling convention 'C'#}
 const Foo = enum { a, b, c };
 export fn entry(foo: Foo) void { _ = foo; }
       {#code_end#}
@@ -4004,7 +4012,7 @@ fn makeNumber() Number {
       This is typically used for type safety when interacting with C code that does not expose struct details.
       Example:
       </p>
-      {#code_begin|test_err|expected type '*Derp', found '*Wat'#}
+      {#code_begin|test_err|expected type '*test.Derp', found '*test.Wat'#}
 const Derp = opaque {};
 const Wat = opaque {};
 
@@ -4203,7 +4211,7 @@ test "switch on tagged union" {
       When a {#syntax#}switch{#endsyntax#} expression does not have an {#syntax#}else{#endsyntax#} clause,
       it must exhaustively list all the possible values. Failure to do so is a compile error:
       </p>
-      {#code_begin|test_err|not handled in switch#}
+      {#code_begin|test_err|unhandled enumeration value#}
 const Color = enum {
     auto,
     off,
@@ -5026,17 +5034,9 @@ test "function" {
     try expect(do_op(sub2, 5, 6) == -1);
 }
       {#code_end#}
-      <p>Function values are like pointers:</p>
-      {#code_begin|obj#}
-const assert = @import("std").debug.assert;
-
-comptime {
-    assert(@TypeOf(foo) == fn()void);
-    assert(@sizeOf(fn()void) == @sizeOf(?fn()void));
-}
-
-fn foo() void { }
-      {#code_end#}
+      <p>There is a difference between a function <em>body</em> and a function <em>pointer</em>.
+      Function bodies are {#link|comptime#}-only types while function {#link|Pointers#} may be
+      runtime-known.</p>
       {#header_open|Pass-by-value Parameters#}
       <p>
       Primitive types such as {#link|Integers#} and {#link|Floats#} passed as parameters
@@ -6123,10 +6123,11 @@ test "float widening" {
       two choices about the coercion.
       </p>
       <ul>
-        <li> Cast {#syntax#}54.0{#endsyntax#} to {#syntax#}comptime_int{#endsyntax#} resulting in {#syntax#}@as(comptime_int, 10){#endsyntax#}, which is casted to {#syntax#}@as(f32, 10){#endsyntax#}</li>
-        <li> Cast {#syntax#}5{#endsyntax#} to {#syntax#}comptime_float{#endsyntax#} resulting in {#syntax#}@as(comptime_float, 10.8){#endsyntax#}, which is casted to {#syntax#}@as(f32, 10.8){#endsyntax#}</li>
+        <li>Cast {#syntax#}54.0{#endsyntax#} to {#syntax#}comptime_int{#endsyntax#} resulting in {#syntax#}@as(comptime_int, 10){#endsyntax#}, which is casted to {#syntax#}@as(f32, 10){#endsyntax#}</li>
+        <li>Cast {#syntax#}5{#endsyntax#} to {#syntax#}comptime_float{#endsyntax#} resulting in {#syntax#}@as(comptime_float, 10.8){#endsyntax#}, which is casted to {#syntax#}@as(f32, 10.8){#endsyntax#}</li>
       </ul>
       {#code_begin|test_err#}
+      {#backend_stage1#}
 // Compile time coercion of float to int
 test "implicit cast to comptime_int" {
     var f: f32 = 54.0 / 5;
@@ -6302,19 +6303,6 @@ test "coercion between unions and enums" {
       {#code_end#}
       {#see_also|union|enum#}
       {#header_close#}
-      {#header_open|Type Coercion: Zero Bit Types#}
-      <p>{#link|Zero Bit Types#} may be coerced to single-item {#link|Pointers#},
-      regardless of const.</p>
-      <p>TODO document the reasoning for this</p>
-      <p>TODO document whether vice versa should work and why</p>
-      {#code_begin|test|coerce_zero_bit_types#}
-test "coercion of zero bit types" {
-    var x: void = {};
-    var y: *void = x;
-    _ = y;
-}
-      {#code_end#}
-      {#header_close#}
       {#header_open|Type Coercion: undefined#}
       <p>{#link|undefined#} can be cast to any type.</p>
       {#header_close#}
@@ -6467,7 +6455,6 @@ test "peer type resolution: *const T and ?*T" {
           <li>An {#link|enum#} with only 1 tag.</li>
           <li>A {#link|struct#} with all fields being zero bit types.</li>
           <li>A {#link|union#} with only 1 field which is a zero bit type.</li>
-          <li>{#link|Pointers to Zero Bit Types#} are themselves zero bit types.</li>
       </ul>
       <p>
       These types can only ever have one possible value, and thus
@@ -6527,7 +6514,7 @@ test "turn HashMap into a set with void" {
       <p>
       Expressions of type {#syntax#}void{#endsyntax#} are the only ones whose value can be ignored. For example:
       </p>
-      {#code_begin|test_err|expression value is ignored#}
+      {#code_begin|test_err|ignored#}
 test "ignoring expression value" {
     foo();
 }
@@ -6553,37 +6540,6 @@ fn foo() i32 {
 }
       {#code_end#}
       {#header_close#}
-
-      {#header_open|Pointers to Zero Bit Types#}
-      <p>Pointers to zero bit types also have zero bits. They always compare equal to each other:</p>
-      {#code_begin|test|pointers_to_zero_bits#}
-const std = @import("std");
-const expect = std.testing.expect;
-
-test "pointer to empty struct" {
-    const Empty = struct {};
-    var a = Empty{};
-    var b = Empty{};
-    var ptr_a = &a;
-    var ptr_b = &b;
-    comptime try expect(ptr_a == ptr_b);
-}
-      {#code_end#}
-      <p>The type being pointed to can only ever be one value; therefore loads and stores are
-      never generated. {#link|ptrToInt#} and {#link|intToPtr#} are not allowed:</p>
-      {#code_begin|test_err#}
-const Empty = struct {};
-
-test "@ptrToInt for pointer to zero bit type" {
-    var a = Empty{};
-    _ = @ptrToInt(&a);
-}
-
-test "@intToPtr for pointer to zero bit type" {
-    _ = @intToPtr(*Empty, 0x1);
-}
-      {#code_end#}
-      {#header_close#}
       {#header_close#}
 
       {#header_open|Result Location Semantics#}
@@ -6666,7 +6622,7 @@ fn gimmeTheBiggerInteger(a: u64, b: u64) u64 {
       <p>
       For example, if we were to introduce another function to the above snippet:
       </p>
-      {#code_begin|test_err|values of type 'type' must be comptime known#}
+      {#code_begin|test_err|value with comptime only type 'type' depends on runtime control flow#}
 fn max(comptime T: type, a: T, b: T) T {
     return if (a > b) a else b;
 }
@@ -6692,7 +6648,7 @@ fn foo(condition: bool) void {
       <p>
       For example:
       </p>
-      {#code_begin|test_err|operator not allowed for type 'bool'#}
+      {#code_begin|test_err|operator > not allowed for type 'bool'#}
 fn max(comptime T: type, a: T, b: T) T {
     return if (a > b) a else b;
 }
@@ -6837,7 +6793,7 @@ fn performFn(start_value: i32) i32 {
       use a {#syntax#}comptime{#endsyntax#} expression to guarantee that the expression will be evaluated at compile-time.
       If this cannot be accomplished, the compiler will emit an error. For example:
       </p>
-      {#code_begin|test_err|unable to evaluate constant expression#}
+      {#code_begin|test_err|comptime call of extern function#}
 extern fn exit() noreturn;
 
 test "foo" {
@@ -6889,7 +6845,7 @@ test "fibonacci" {
       <p>
       Imagine if we had forgotten the base case of the recursive function and tried to run the tests:
       </p>
-      {#code_begin|test_err|operation caused overflow#}
+      {#code_begin|test_err|overflow of integer type#}
 const expect = @import("std").testing.expect;
 
 fn fibonacci(index: u32) u32 {
@@ -6913,7 +6869,8 @@ test "fibonacci" {
       But what would have happened if we used a signed integer?
       </p>
       {#code_begin|test_err|evaluation exceeded 1000 backwards branches#}
-const expect = @import("std").testing.expect;
+      {#backend_stage1#}
+const assert = @import("std").debug.assert;
 
 fn fibonacci(index: i32) i32 {
     //if (index < 2) return index;
@@ -6922,7 +6879,7 @@ fn fibonacci(index: i32) i32 {
 
 test "fibonacci" {
     comptime {
-        try expect(fibonacci(7) == 13);
+        try assert(fibonacci(7) == 13);
     }
 }
       {#code_end#}
@@ -6935,8 +6892,8 @@ test "fibonacci" {
       <p>
       What if we fix the base case, but put the wrong value in the {#syntax#}expect{#endsyntax#} line?
       </p>
-      {#code_begin|test_err|test "fibonacci"... FAIL (TestUnexpectedResult)#}
-const expect = @import("std").testing.expect;
+      {#code_begin|test_err|reached unreachable#}
+const assert = @import("std").debug.assert;
 
 fn fibonacci(index: i32) i32 {
     if (index < 2) return index;
@@ -6945,16 +6902,10 @@ fn fibonacci(index: i32) i32 {
 
 test "fibonacci" {
     comptime {
-        try expect(fibonacci(7) == 99999);
+        try assert(fibonacci(7) == 99999);
     }
 }
       {#code_end#}
-      <p>
-      What happened is Zig started interpreting the {#syntax#}expect{#endsyntax#} function with the
-          parameter {#syntax#}ok{#endsyntax#} set to {#syntax#}false{#endsyntax#}. When the interpreter hit
-                  {#syntax#}@panic{#endsyntax#} it emitted a compile error because a panic during compile
-      causes a compile error if it is detected at compile-time.
-      </p>
 
       <p>
       At container level (outside of any function), all expressions are implicitly
@@ -7280,6 +7231,7 @@ pub fn main() void {
       </p>
       {#code_begin|exe#}
       {#target_linux_x86_64#}
+      {#backend_stage1#}
 pub fn main() noreturn {
     const msg = "hello world\n";
     _ = syscall3(SYS_write, STDOUT_FILENO, @ptrToInt(msg), msg.len);
@@ -7497,6 +7449,7 @@ test "global assembly" {
       or resumer (in the case of subsequent suspensions).
       </p>
       {#code_begin|test|suspend_no_resume#}
+      {#backend_stage1#}
 const std = @import("std");
 const expect = std.testing.expect;
 
@@ -7524,6 +7477,7 @@ fn func() void {
       {#link|@frame#} provides access to the async function frame pointer.
       </p>
       {#code_begin|test|async_suspend_block#}
+      {#backend_stage1#}
 const std = @import("std");
 const expect = std.testing.expect;
 
@@ -7562,6 +7516,7 @@ fn testSuspendBlock() void {
       never returns to its resumer and continues executing.
       </p>
       {#code_begin|test|resume_from_suspend#}
+      {#backend_stage1#}
 const std = @import("std");
 const expect = std.testing.expect;
 
@@ -7598,6 +7553,7 @@ fn testResumeFromSuspend(my_result: *i32) void {
       and the return value of the async function would be lost.
       </p>
       {#code_begin|test|async_await#}
+      {#backend_stage1#}
 const std = @import("std");
 const expect = std.testing.expect;
 
@@ -7642,6 +7598,7 @@ fn func() void {
       return value directly from the target function's frame.
       </p>
       {#code_begin|test|async_await_sequence#}
+      {#backend_stage1#}
 const std = @import("std");
 const expect = std.testing.expect;
 
@@ -7695,6 +7652,7 @@ fn seq(c: u8) void {
       {#syntax#}async{#endsyntax#}/{#syntax#}await{#endsyntax#} usage:
       </p>
       {#code_begin|exe|async#}
+      {#backend_stage1#}
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 
@@ -7773,6 +7731,7 @@ fn readFile(allocator: Allocator, filename: []const u8) ![]u8 {
       observe the same behavior, with one tiny difference:
       </p>
       {#code_begin|exe|blocking#}
+      {#backend_stage1#}
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 
@@ -7910,6 +7869,7 @@ comptime {
       {#syntax#}await{#endsyntax#} will copy the result from {#syntax#}result_ptr{#endsyntax#}.
       </p>
       {#code_begin|test|async_struct_field_fn_pointer#}
+      {#backend_stage1#}
 const std = @import("std");
 const expect = std.testing.expect;
 
@@ -8677,6 +8637,7 @@ test "decl access by string" {
       allows one to, for example, heap-allocate an async function frame:
       </p>
       {#code_begin|test|heap_allocated_frame#}
+      {#backend_stage1#}
 const std = @import("std");
 
 test "heap allocated frame" {
@@ -9423,12 +9384,6 @@ const std = @import("std");
 const expect = std.testing.expect;
 
 test "vector @reduce" {
-    // This test regressed with LLVM 14:
-    // https://github.com/llvm/llvm-project/issues/55522
-    // We'll skip this test unless the self-hosted compiler is being used.
-    // After LLVM 15 is released we can delete this line.
-    if (@import("builtin").zig_backend == .stage1) return;
-
     const value = @Vector(4, i32){ 1, -1, 1, -1 };
     const result = value > @splat(4, @as(i32, 0));
     // result is { true, false, true, false };
@@ -9938,7 +9893,7 @@ pub fn main() void {
       {#header_close#}
       {#header_open|Index out of Bounds#}
       <p>At compile-time:</p>
-      {#code_begin|test_err|index 5 outside array of size 5#}
+      {#code_begin|test_err|index 5 outside array of length 5#}
 comptime {
     const array: [5]u8 = "hello".*;
     const garbage = array[5];
@@ -9959,9 +9914,9 @@ fn foo(x: []const u8) u8 {
       {#header_close#}
       {#header_open|Cast Negative Number to Unsigned Integer#}
       <p>At compile-time:</p>
-      {#code_begin|test_err|attempt to cast negative value to unsigned integer#}
+      {#code_begin|test_err|type 'u32' cannot represent integer value '-1'#}
 comptime {
-    const value: i32 = -1;
+    var value: i32 = -1;
     const unsigned = @intCast(u32, value);
     _ = unsigned;
 }
@@ -9982,7 +9937,7 @@ pub fn main() void {
       {#header_close#}
       {#header_open|Cast Truncates Data#}
       <p>At compile-time:</p>
-      {#code_begin|test_err|cast from 'u16' to 'u8' truncates bits#}
+      {#code_begin|test_err|type 'u8' cannot represent integer value '300'#}
 comptime {
     const spartan_count: u16 = 300;
     const byte = @intCast(u8, spartan_count);
@@ -10017,7 +9972,7 @@ pub fn main() void {
         <li>{#link|@divExact#} (division)</li>
       </ul>
       <p>Example with addition at compile-time:</p>
-      {#code_begin|test_err|operation caused overflow#}
+      {#code_begin|test_err|overflow of integer type 'u8' with value '256'#}
 comptime {
     var byte: u8 = 255;
     byte += 1;
@@ -10118,6 +10073,7 @@ test "wraparound addition and subtraction" {
       {#header_open|Exact Left Shift Overflow#}
       <p>At compile-time:</p>
       {#code_begin|test_err|operation caused overflow#}
+      {#backend_stage1#}
 comptime {
     const x = @shlExact(@as(u8, 0b01010101), 2);
     _ = x;
@@ -10137,6 +10093,7 @@ pub fn main() void {
       {#header_open|Exact Right Shift Overflow#}
       <p>At compile-time:</p>
       {#code_begin|test_err|exact shift shifted out 1 bits#}
+      {#backend_stage1#}
 comptime {
     const x = @shrExact(@as(u8, 0b10101010), 2);
     _ = x;
@@ -10200,6 +10157,7 @@ pub fn main() void {
       {#header_open|Exact Division Remainder#}
       <p>At compile-time:</p>
       {#code_begin|test_err|exact division had a remainder#}
+      {#backend_stage1#}
 comptime {
     const a: u32 = 10;
     const b: u32 = 3;
@@ -10302,7 +10260,7 @@ fn getNumberOrFail() !i32 {
       {#header_close#}
       {#header_open|Invalid Error Code#}
       <p>At compile-time:</p>
-      {#code_begin|test_err|integer value 11 represents no error#}
+      {#code_begin|test_err|integer value '11' represents no error#}
 comptime {
     const err = error.AnError;
     const number = @errorToInt(err) + 10;
@@ -10324,7 +10282,7 @@ pub fn main() void {
       {#header_close#}
       {#header_open|Invalid Enum Cast#}
       <p>At compile-time:</p>
-      {#code_begin|test_err|has no tag matching integer value 3#}
+      {#code_begin|test_err|enum 'test.Foo' has no tag with value '3'#}
 const Foo = enum {
     a,
     b,
@@ -10356,7 +10314,7 @@ pub fn main() void {
 
       {#header_open|Invalid Error Set Cast#}
       <p>At compile-time:</p>
-      {#code_begin|test_err|error.B not a member of error set 'Set2'#}
+      {#code_begin|test_err|'error.B' not a member of error set 'error{A,C}'#}
 const Set1 = error{
     A,
     B,
@@ -10417,7 +10375,7 @@ fn foo(bytes: []u8) u32 {
       {#header_close#}
       {#header_open|Wrong Union Field Access#}
       <p>At compile-time:</p>
-      {#code_begin|test_err|accessing union field 'float' while field 'int' is set#}
+      {#code_begin|test_err|access of union field 'float' while field 'int' is active#}
 comptime {
     var f = Foo{ .int = 42 };
     f.float = 12.34;
@@ -10509,6 +10467,7 @@ fn bar(f: *Foo) void {
       </p>
       <p>At compile-time:</p>
       {#code_begin|test_err|null pointer casted to type#}
+      {#backend_stage1#}
 comptime {
     const opt_ptr: ?*i32 = null;
     const ptr = @ptrCast(*i32, opt_ptr);
@@ -10551,7 +10510,8 @@ const expect = std.testing.expect;
 
 test "using an allocator" {
     var buffer: [100]u8 = undefined;
-    const allocator = std.heap.FixedBufferAllocator.init(&buffer).allocator();
+    var fba = std.heap.FixedBufferAllocator.init(&buffer);
+    const allocator = fba.allocator();
     const result = try concat(allocator, "foo", "bar");
     try expect(std.mem.eql(u8, "foobar", result));
 }
@@ -10647,7 +10607,7 @@ pub fn main() !void {
       <p>String literals such as {#syntax#}"foo"{#endsyntax#} are in the global constant data section.
       This is why it is an error to pass a string literal to a mutable slice, like this:
       </p>
-      {#code_begin|test_err|cannot cast pointer to array literal to slice type '[]u8'#}
+      {#code_begin|test_err|expected type '[]u8', found '*const [5:0]u8'#}
 fn foo(s: []u8) void {
     _ = s;
 }
diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig
index 2c2bc92c96022ec7b2c150d3bcdd77b89cf3740a..69312df838538ad49cbbdee1394a0b5d508263ff 100644
--- a/lib/std/builtin.zig
+++ b/lib/std/builtin.zig
@@ -866,7 +866,7 @@ pub fn panicUnwrapError(st: ?*StackTrace, err: anyerror) noreturn {
 
 pub fn panicOutOfBounds(index: usize, len: usize) noreturn {
     @setCold(true);
-    std.debug.panic("attempt to index out of bound: index {d}, len {d}", .{ index, len });
+    std.debug.panic("index out of bounds: index {d}, len {d}", .{ index, len });
 }
 
 pub noinline fn returnError(st: *StackTrace) void {
diff --git a/src/Compilation.zig b/src/Compilation.zig
index 6d778b955a013f7f941e772332c4811ffe429fe6..84dd2739470a4b3bb0f387832cbdf2fcd76c9869 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -1040,22 +1040,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
         const comp = try arena.create(Compilation);
         const root_name = try arena.dupeZ(u8, options.root_name);
 
-        const use_stage1 = options.use_stage1 orelse blk: {
-            // Even though we may have no Zig code to compile (depending on `options.main_pkg`),
-            // we may need to use stage1 for building compiler-rt and other dependencies.
-
-            if (options.use_llvm) |use_llvm| {
-                if (!use_llvm) {
-                    break :blk false;
-                }
-            }
-
-            // If LLVM does not support the target, then we can't use it.
-            if (!target_util.hasLlvmSupport(options.target, options.target.ofmt))
-                break :blk false;
-
-            break :blk build_options.is_stage1;
-        };
+        const use_stage1 = options.use_stage1 orelse false;
 
         const cache_mode = if (use_stage1 and !options.disable_lld_caching)
             CacheMode.whole
@@ -2211,7 +2196,7 @@ pub fn update(comp: *Compilation) !void {
         comp.c_object_work_queue.writeItemAssumeCapacity(key);
     }
 
-    const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1;
+    const use_stage1 = build_options.have_stage1 and comp.bin_file.options.use_stage1;
     if (comp.bin_file.options.module) |module| {
         module.compile_log_text.shrinkAndFree(module.gpa, 0);
         module.generation += 1;
@@ -2387,7 +2372,7 @@ fn flush(comp: *Compilation, prog_node: *std.Progress.Node) !void {
     };
     comp.link_error_flags = comp.bin_file.errorFlags();
 
-    const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1;
+    const use_stage1 = build_options.have_stage1 and comp.bin_file.options.use_stage1;
     if (!use_stage1) {
         if (comp.bin_file.options.module) |module| {
             try link.File.C.flushEmitH(module);
@@ -2845,7 +2830,7 @@ pub fn performAllTheWork(
     comp.work_queue_wait_group.reset();
     defer comp.work_queue_wait_group.wait();
 
-    const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1;
+    const use_stage1 = build_options.have_stage1 and comp.bin_file.options.use_stage1;
 
     {
         const astgen_frame = tracy.namedFrame("astgen");
@@ -3430,7 +3415,7 @@ pub fn cImport(comp: *Compilation, c_src: []const u8) !CImportResult {
     var man = comp.obtainCObjectCacheManifest();
     defer man.deinit();
 
-    const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1;
+    const use_stage1 = build_options.have_stage1 and comp.bin_file.options.use_stage1;
 
     man.hash.add(@as(u16, 0xb945)); // Random number to distinguish translate-c from compiling C objects
     man.hash.add(use_stage1);
@@ -4745,7 +4730,7 @@ pub fn generateBuiltinZigSource(comp: *Compilation, allocator: Allocator) Alloca
 
     const target = comp.getTarget();
     const generic_arch_name = target.cpu.arch.genericName();
-    const use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1;
+    const use_stage1 = build_options.have_stage1 and comp.bin_file.options.use_stage1;
 
     const zig_backend: std.builtin.CompilerBackend = blk: {
         if (use_stage1) break :blk .stage1;
@@ -5032,7 +5017,7 @@ fn buildOutputFromZig(
         .link_mode = .Static,
         .function_sections = true,
         .no_builtin = true,
-        .use_stage1 = build_options.is_stage1 and comp.bin_file.options.use_stage1,
+        .use_stage1 = build_options.have_stage1 and comp.bin_file.options.use_stage1,
         .want_sanitize_c = false,
         .want_stack_check = false,
         .want_stack_protector = 0,
diff --git a/src/config.zig.in b/src/config.zig.in
index 336a6c45edae736ba350c89d646afc06fa4edcd8..12e13815f84cb6fe42484fb42e1c38e30caa40ea 100644
--- a/src/config.zig.in
+++ b/src/config.zig.in
@@ -8,5 +8,5 @@ pub const enable_logging: bool = @ZIG_ENABLE_LOGGING_BOOL@;
 pub const enable_link_snapshots: bool = false;
 pub const enable_tracy = false;
 pub const value_tracing = false;
-pub const is_stage1 = true;
+pub const have_stage1 = true;
 pub const skip_non_native = false;
diff --git a/src/link.zig b/src/link.zig
index a0c0c5c369ee4d09cc7a4cd5d129946333cb4716..a85969d61eb7bf6d9f30f79c4caabe00e2dc1737 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -279,7 +279,7 @@ pub const File = struct {
             return &(try MachO.openPath(allocator, options)).base;
         }
 
-        const use_stage1 = build_options.is_stage1 and options.use_stage1;
+        const use_stage1 = build_options.have_stage1 and options.use_stage1;
         if (use_stage1 or options.emit == null) {
             return switch (options.target.ofmt) {
                 .coff => &(try Coff.createEmpty(allocator, options)).base,
@@ -817,7 +817,7 @@ pub const File = struct {
         // 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 (base.options.module) |module| blk: {
-            const use_stage1 = build_options.is_stage1 and base.options.use_stage1;
+            const use_stage1 = build_options.have_stage1 and base.options.use_stage1;
             if (use_stage1) {
                 const obj_basename = try std.zig.binNameAlloc(arena, .{
                     .root_name = base.options.root_name,
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index 92e9dce3ad28ec9cc2cb13551d9762ff27add3bb..a01b9cf7c3ac9daf1d39e8431c1163580098c30b 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -411,7 +411,7 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*Coff {
     };
 
     const use_llvm = build_options.have_llvm and options.use_llvm;
-    const use_stage1 = build_options.is_stage1 and options.use_stage1;
+    const use_stage1 = build_options.have_stage1 and options.use_stage1;
     if (use_llvm and !use_stage1) {
         self.llvm_object = try LlvmObject.create(gpa, options);
     }
@@ -949,7 +949,7 @@ fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Node) !
     // 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 (self.base.options.module) |module| blk: {
-        const use_stage1 = build_options.is_stage1 and self.base.options.use_stage1;
+        const use_stage1 = build_options.have_stage1 and self.base.options.use_stage1;
         if (use_stage1) {
             const obj_basename = try std.zig.binNameAlloc(arena, .{
                 .root_name = self.base.options.root_name,
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index 9902886baca5b25c4fc26f8b7b0ce0608c086d3a..ade4f62f91e21e2a1e8fd366316f9f6496089418 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -328,7 +328,7 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*Elf {
         .page_size = page_size,
     };
     const use_llvm = build_options.have_llvm and options.use_llvm;
-    const use_stage1 = build_options.is_stage1 and options.use_stage1;
+    const use_stage1 = build_options.have_stage1 and options.use_stage1;
     if (use_llvm and !use_stage1) {
         self.llvm_object = try LlvmObject.create(gpa, options);
     }
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 7a508430236320fb79c1e16fe17f16802b4c3449..020388cee87138848e88559f949a5cdfde8b4111 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -272,7 +272,7 @@ pub const Export = struct {
 pub fn openPath(allocator: Allocator, options: link.Options) !*MachO {
     assert(options.target.ofmt == .macho);
 
-    const use_stage1 = build_options.is_stage1 and options.use_stage1;
+    const use_stage1 = build_options.have_stage1 and options.use_stage1;
     if (use_stage1 or options.emit == null) {
         return createEmpty(allocator, options);
     }
@@ -363,7 +363,7 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*MachO {
     const cpu_arch = options.target.cpu.arch;
     const page_size: u16 = if (cpu_arch == .aarch64) 0x4000 else 0x1000;
     const use_llvm = build_options.have_llvm and options.use_llvm;
-    const use_stage1 = build_options.is_stage1 and options.use_stage1;
+    const use_stage1 = build_options.have_stage1 and options.use_stage1;
 
     const self = try gpa.create(MachO);
     errdefer gpa.destroy(self);
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 6267865888734f49474456c4d0fdf5abdb7c6353..626f17665215bc3f93f6830ac60a0ce804dc95a0 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -356,7 +356,7 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !*Wasm {
     }
 
     const use_llvm = build_options.have_llvm and options.use_llvm;
-    const use_stage1 = build_options.is_stage1 and options.use_stage1;
+    const use_stage1 = build_options.have_stage1 and options.use_stage1;
     if (use_llvm and !use_stage1) {
         self.llvm_object = try LlvmObject.create(gpa, options);
     }
@@ -2593,7 +2593,7 @@ fn linkWithLLD(self: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
     // 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 (self.base.options.module) |mod| blk: {
-        const use_stage1 = build_options.is_stage1 and self.base.options.use_stage1;
+        const use_stage1 = build_options.have_stage1 and self.base.options.use_stage1;
         if (use_stage1) {
             const obj_basename = try std.zig.binNameAlloc(arena, .{
                 .root_name = self.base.options.root_name,
@@ -2803,7 +2803,7 @@ fn linkWithLLD(self: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
             if (self.base.options.module) |mod| {
                 // when we use stage1, we use the exports that stage1 provided us.
                 // For stage2, we can directly retrieve them from the module.
-                const use_stage1 = build_options.is_stage1 and self.base.options.use_stage1;
+                const use_stage1 = build_options.have_stage1 and self.base.options.use_stage1;
                 if (use_stage1) {
                     for (comp.export_symbol_names.items) |symbol_name| {
                         try argv.append(try std.fmt.allocPrint(arena, "--export={s}", .{symbol_name}));
diff --git a/src/main.zig b/src/main.zig
index 91d171d23764c13873a89ef63116441153c49e2f..dd3a7e797bdbc0b6fdadf3295465b7eaf9eb649e 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -2989,7 +2989,7 @@ fn buildOutputType(
         return std.io.getStdOut().writeAll(try comp.generateBuiltinZigSource(arena));
     }
     if (arg_mode == .translate_c) {
-        const stage1_mode = use_stage1 orelse build_options.is_stage1;
+        const stage1_mode = use_stage1 orelse false;
         return cmdTranslateC(comp, arena, have_enable_cache, stage1_mode);
     }
 
diff --git a/src/stage1.zig b/src/stage1.zig
index 826fdd0f6bb9466883ecd66050b918f865406f56..e3f0daaa44504188cbcad98d64fba6d68b4ed8e8 100644
--- a/src/stage1.zig
+++ b/src/stage1.zig
@@ -18,7 +18,7 @@ const target_util = @import("target.zig");
 
 comptime {
     assert(builtin.link_libc);
-    assert(build_options.is_stage1);
+    assert(build_options.have_stage1);
     assert(build_options.have_llvm);
     if (!builtin.is_test) {
         @export(main, .{ .name = "main" });
diff --git a/src/test.zig b/src/test.zig
index a8567f24928b2d35b87177a451c131f47d2a8b79..babded13f9d71d7324eba4eb0afc34240c804ddb 100644
--- a/src/test.zig
+++ b/src/test.zig
@@ -25,7 +25,7 @@ const skip_stage1 = builtin.zig_backend != .stage1 or build_options.skip_stage1;
 const hr = "=" ** 80;
 
 test {
-    if (build_options.is_stage1) {
+    if (build_options.have_stage1) {
         @import("stage1.zig").os_init();
     }
 
diff --git a/test/cases/safety/empty slice with sentinel out of bounds.zig b/test/cases/safety/empty slice with sentinel out of bounds.zig
index 835b084740c5ed359f778e10a21389ae417ff552..d989a33541c18fa4eff86c4ee81762ee2205d8c9 100644
--- a/test/cases/safety/empty slice with sentinel out of bounds.zig	
+++ b/test/cases/safety/empty slice with sentinel out of bounds.zig	
@@ -2,7 +2,7 @@ const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "attempt to index out of bound: index 1, len 0")) {
+    if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/out of bounds slice access.zig b/test/cases/safety/out of bounds slice access.zig
index a30532aee78c677c6feb157876fb789c60c590a2..ddd9e74cf28565c598f5d04d8007fe2725095ce5 100644
--- a/test/cases/safety/out of bounds slice access.zig	
+++ b/test/cases/safety/out of bounds slice access.zig	
@@ -2,20 +2,20 @@ const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "attempt to index out of bound: index 4, len 4")) {
+    if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) {
         std.process.exit(0);
     }
     std.process.exit(1);
 }
 pub fn main() !void {
-    const a = [_]i32{1, 2, 3, 4};
+    const a = [_]i32{ 1, 2, 3, 4 };
     baz(bar(&a));
     return error.TestFailed;
 }
 fn bar(a: []const i32) i32 {
     return a[4];
 }
-fn baz(_: i32) void { }
+fn baz(_: i32) void {}
 // run
 // backend=llvm
 // target=native
diff --git a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig
index fa2e127107c8bd1af1b0fbd0b259461a4e81e366..524c69d7b7dd45934f09cc9eca0c515d88eb7ca1 100644
--- a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig	
+++ b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig	
@@ -2,7 +2,7 @@ const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "attempt to index out of bound: index 5, len 4")) {
+    if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/slice with sentinel out of bounds.zig b/test/cases/safety/slice with sentinel out of bounds.zig
index 3cc8bfb355a459477c1bf7b8e6172bc342376776..636235a5b34cb34d7a0f94b4c943cb12ae4af39a 100644
--- a/test/cases/safety/slice with sentinel out of bounds.zig	
+++ b/test/cases/safety/slice with sentinel out of bounds.zig	
@@ -2,7 +2,7 @@ const std = @import("std");
 
 pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "attempt to index out of bound: index 5, len 4")) {
+    if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/tests.zig b/test/tests.zig
index e1836dc1e010d95d55262e21b007fc1bbc068937..bd3c1c5dec399c913a0724d0596dd54df74b0d89 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -601,7 +601,6 @@ pub fn addPkgTests(
     skip_libc: bool,
     skip_stage1: bool,
     skip_stage2: bool,
-    is_stage1: bool,
 ) *build.Step {
     const step = b.step(b.fmt("test-{s}", .{name}), desc);
 
@@ -630,7 +629,7 @@ pub fn addPkgTests(
         if (test_target.backend) |backend| switch (backend) {
             .stage1 => if (skip_stage1) continue,
             else => if (skip_stage2) continue,
-        } else if (is_stage1 and skip_stage1) continue;
+        } else if (skip_stage2) continue;
 
         const want_this_mode = for (modes) |m| {
             if (m == test_target.mode) break true;
-- 
2.54.0


From 06c42a0c68b5e3ce54135738704cc7c6c5b92565 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 8 Aug 2022 16:59:38 -0700
Subject: [PATCH 170/290] CI: test both stage3-debug and stage3-release on
 x86-linux

---
 ci/zinc/drone.yml                             | 12 ++-
 ...nux_test.sh => linux_test_stage3_debug.sh} | 29 +-----
 ci/zinc/linux_test_stage3_release.sh          | 91 +++++++++++++++++++
 3 files changed, 104 insertions(+), 28 deletions(-)
 rename ci/zinc/{linux_test.sh => linux_test_stage3_debug.sh} (84%)
 create mode 100755 ci/zinc/linux_test_stage3_release.sh

diff --git a/ci/zinc/drone.yml b/ci/zinc/drone.yml
index 6bb7d73b41c16b568cb72d56a6b78ee742247da6..38185df7e7d75d8846712bd25c718b7299fba2cc 100644
--- a/ci/zinc/drone.yml
+++ b/ci/zinc/drone.yml
@@ -9,14 +9,20 @@ workspace:
   path: /workspace
 
 steps:
-- name: test
+- name: test_stage3_debug
   image: ci/debian-amd64:11.1-6
   commands:
-  - ./ci/zinc/linux_test.sh
+  - ./ci/zinc/linux_test_stage3_debug.sh
+
+- name: test_stage3_release
+  image: ci/debian-amd64:11.1-6
+  commands:
+  - ./ci/zinc/linux_test_stage3_release.sh
 
 - name: package
   depends_on:
-  - test
+  - test_stage3_debug
+  - test_stage3_release
   when:
     branch:
       - master
diff --git a/ci/zinc/linux_test.sh b/ci/zinc/linux_test_stage3_debug.sh
similarity index 84%
rename from ci/zinc/linux_test.sh
rename to ci/zinc/linux_test_stage3_debug.sh
index 1b280fbae5fddb56ebef20853f6cbc18dcd12579..85cfb57b2ef41af31cd20a3d4247384240a7ac53 100755
--- a/ci/zinc/linux_test.sh
+++ b/ci/zinc/linux_test_stage3_debug.sh
@@ -10,13 +10,13 @@ MCPU="baseline"
 # This will affect the cmake command below.
 git config core.abbrev 9
 
-echo "building debug zig with zig version $($OLD_ZIG version)"
+echo "building stage3-debug with zig version $($OLD_ZIG version)"
 
 export CC="$OLD_ZIG cc -target $TARGET -mcpu=$MCPU"
 export CXX="$OLD_ZIG c++ -target $TARGET -mcpu=$MCPU"
 
-mkdir _debug
-cd _debug
+mkdir build-debug
+cd build-debug
 cmake .. \
   -DCMAKE_INSTALL_PREFIX="$DEBUG_STAGING" \
   -DCMAKE_PREFIX_PATH="$DEPS_LOCAL" \
@@ -63,29 +63,8 @@ stage3/bin/zig build test-standalone       -fqemu -fwasmtime -Dstatic-llvm -Dtar
 stage3/bin/zig build test-cli              -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
 stage3/bin/zig build test-cases            -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
 stage3/bin/zig build test-link             -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+stage3/bin/zig build test-stack-traces     -fqemu -fwasmtime -fstage1
 stage3/bin/zig build docs                  -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
 
-stage3/bin/zig build test-stack-traces -fqemu -fwasmtime -fstage1
-
-# Produce the experimental std lib documentation.
-mkdir -p "$RELEASE_STAGING/docs/std"
-stage3/bin/zig test lib/std/std.zig \
-  --zig-lib-dir lib \
-  -femit-docs=$RELEASE_STAGING/docs/std \
-  -fno-emit-bin
-
-# Look for HTML errors.
-tidy --drop-empty-elements no -qe zig-cache/langref.html
-
-# Build release zig.
-stage3/bin/zig build \
-  --prefix "$RELEASE_STAGING" \
-  --search-prefix "$DEPS_LOCAL" \
-  -Dstatic-llvm \
-  -Drelease \
-  -Dstrip \
-  -Dtarget="$TARGET" \
-  -Denable-stage1
-
 # Explicit exit helps show last command duration.
 exit
diff --git a/ci/zinc/linux_test_stage3_release.sh b/ci/zinc/linux_test_stage3_release.sh
new file mode 100755
index 0000000000000000000000000000000000000000..764c89db8fb7411bae1816a928d23e058a93ec47
--- /dev/null
+++ b/ci/zinc/linux_test_stage3_release.sh
@@ -0,0 +1,91 @@
+#!/bin/sh
+
+. ./ci/zinc/linux_base.sh
+
+OLD_ZIG="$DEPS_LOCAL/bin/zig"
+TARGET="${ARCH}-linux-musl"
+MCPU="baseline"
+
+# Make the `zig version` number consistent.
+# This will affect the cmake command below.
+git config core.abbrev 9
+
+echo "building stage3-release with zig version $($OLD_ZIG version)"
+
+export CC="$OLD_ZIG cc -target $TARGET -mcpu=$MCPU"
+export CXX="$OLD_ZIG c++ -target $TARGET -mcpu=$MCPU"
+
+mkdir build-release
+cd build-release
+STAGE2_PREFIX="$(pwd)/stage2"
+cmake .. \
+  -DCMAKE_INSTALL_PREFIX="$STAGE2_PREFIX" \
+  -DCMAKE_PREFIX_PATH="$DEPS_LOCAL" \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DZIG_TARGET_TRIPLE="$TARGET" \
+  -DZIG_TARGET_MCPU="$MCPU" \
+  -DZIG_STATIC=ON \
+  -GNinja
+
+# Now cmake will use zig as the C/C++ compiler. We reset the environment variables
+# so that installation and testing do not get affected by them.
+unset CC
+unset CXX
+
+ninja install
+
+# Here we rebuild zig but this time using the Zig binary we just now produced to
+# build zig1.o rather than relying on the one built with stage0. See
+# https://github.com/ziglang/zig/issues/6830 for more details.
+cmake .. -DZIG_EXECUTABLE="$STAGE2_PREFIX/bin/zig"
+ninja install
+
+# This is the binary we will distribute. We intentionally test this one in this
+# script. If any test failures occur, hopefully they also occur in the debug
+# version of this script for easier troubleshooting. This prevents distribution
+# of a Zig binary that passes tests in debug mode but has a miscompilation in
+# release mode.
+"$STAGE2_PREFIX/bin/zig" build \
+  --prefix "$RELEASE_STAGING" \
+  --search-prefix "$DEPS_LOCAL" \
+  -Dstatic-llvm \
+  -Drelease \
+  -Dstrip \
+  -Dtarget="$TARGET" \
+  -Denable-stage1
+
+cd $WORKSPACE
+
+ZIG="$RELEASE_STAGING/bin/zig"
+
+$ZIG build \
+  test-compiler-rt \
+  test-behavior \
+  test-std \
+  test-universal-libc \
+  test-compare-output \
+  test-asm-link \
+  test-translate-c \
+  test-run-translated-c \
+  test-standalone \
+  test-cli \
+  test-cases \
+  test-link \
+  -fqemu \
+  -fwasmtime \
+  -Dstatic-llvm \
+  -Dtarget=native-native-musl \
+  --search-prefix "$DEPS_LOCAL"
+
+# Produce the experimental std lib documentation.
+mkdir -p "$RELEASE_STAGING/docs/std"
+$ZIG test lib/std/std.zig \
+  --zig-lib-dir lib \
+  -femit-docs=$RELEASE_STAGING/docs/std \
+  -fno-emit-bin
+
+# Look for HTML errors.
+tidy --drop-empty-elements no -qe zig-cache/langref.html
+
+# Explicit exit helps show last command duration.
+exit
-- 
2.54.0


From a73b3a0d70a094514a53aa028ee1321f63d950ab Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 9 Aug 2022 02:58:39 -0700
Subject: [PATCH 171/290] CI: simplify x86 linux test instructions

---
 ci/zinc/linux_package.sh             |  3 ---
 ci/zinc/linux_test_stage3_debug.sh   | 21 ++++++---------------
 ci/zinc/linux_test_stage3_release.sh | 19 +++++--------------
 3 files changed, 11 insertions(+), 32 deletions(-)

diff --git a/ci/zinc/linux_package.sh b/ci/zinc/linux_package.sh
index 547a2d76b8e03cdb5e35ff86d557069ba13d1776..b89e2d851169d5bec055afcd5e2884f1dfa33e4d 100755
--- a/ci/zinc/linux_package.sh
+++ b/ci/zinc/linux_package.sh
@@ -2,9 +2,6 @@
 
 . ./ci/zinc/linux_base.sh
 
-cp LICENSE $RELEASE_STAGING/
-cp zig-cache/langref.html $RELEASE_STAGING/docs/
-
 # Remove the unnecessary bin dir in $prefix/bin/zig
 mv $RELEASE_STAGING/bin/zig $RELEASE_STAGING/
 rmdir $RELEASE_STAGING/bin
diff --git a/ci/zinc/linux_test_stage3_debug.sh b/ci/zinc/linux_test_stage3_debug.sh
index 85cfb57b2ef41af31cd20a3d4247384240a7ac53..d40ad9da11926bf8fef48ace0391bc319e5548e0 100755
--- a/ci/zinc/linux_test_stage3_debug.sh
+++ b/ci/zinc/linux_test_stage3_debug.sh
@@ -50,21 +50,12 @@ echo "Looking for non-conforming code formatting..."
 echo "Formatting errors can be fixed by running 'zig fmt' on the files printed here."
 stage3/bin/zig fmt --check . --exclude test/cases/
 
-stage3/bin/zig build test-compiler-rt      -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-behavior         -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-std              -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-universal-libc   -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-compare-output   -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-asm-link         -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-fmt              -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-translate-c      -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-run-translated-c -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-standalone       -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-cli              -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-cases            -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-link             -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-stage3/bin/zig build test-stack-traces     -fqemu -fwasmtime -fstage1
-stage3/bin/zig build docs                  -fqemu -fwasmtime -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
+stage3/bin/zig build test \
+  -fqemu \
+  -fwasmtime \
+  -Dstatic-llvm \
+  -Dtarget=native-native-musl \
+  --search-prefix "$DEPS_LOCAL"
 
 # Explicit exit helps show last command duration.
 exit
diff --git a/ci/zinc/linux_test_stage3_release.sh b/ci/zinc/linux_test_stage3_release.sh
index 764c89db8fb7411bae1816a928d23e058a93ec47..dd906f70fbce45d1088851ddccb7bbc3adcea474 100755
--- a/ci/zinc/linux_test_stage3_release.sh
+++ b/ci/zinc/linux_test_stage3_release.sh
@@ -58,19 +58,7 @@ cd $WORKSPACE
 
 ZIG="$RELEASE_STAGING/bin/zig"
 
-$ZIG build \
-  test-compiler-rt \
-  test-behavior \
-  test-std \
-  test-universal-libc \
-  test-compare-output \
-  test-asm-link \
-  test-translate-c \
-  test-run-translated-c \
-  test-standalone \
-  test-cli \
-  test-cases \
-  test-link \
+$ZIG build test \
   -fqemu \
   -fwasmtime \
   -Dstatic-llvm \
@@ -84,8 +72,11 @@ $ZIG test lib/std/std.zig \
   -femit-docs=$RELEASE_STAGING/docs/std \
   -fno-emit-bin
 
+cp LICENSE $RELEASE_STAGING/
+cp zig-cache/langref.html $RELEASE_STAGING/docs/
+
 # Look for HTML errors.
-tidy --drop-empty-elements no -qe zig-cache/langref.html
+tidy --drop-empty-elements no -qe $RELEASE_STAGING/docs/langref.html
 
 # Explicit exit helps show last command duration.
 exit
-- 
2.54.0


From 09ec9b03154d909cca0d1719d804a67a11d85f5f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 14:49:42 -0700
Subject: [PATCH 172/290] langref: update to new error message

---
 doc/langref.html.in | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/langref.html.in b/doc/langref.html.in
index ba817f0a4d10aa5f5ce61e5c44c6e14162a72c1d..9247d3bc4394d0022722475aff74ac6dcc7e2174 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -6622,7 +6622,7 @@ fn gimmeTheBiggerInteger(a: u64, b: u64) u64 {
       <p>
       For example, if we were to introduce another function to the above snippet:
       </p>
-      {#code_begin|test_err|value with comptime only type 'type' depends on runtime control flow#}
+      {#code_begin|test_err|unable to resolve comptime value#}
 fn max(comptime T: type, a: T, b: T) T {
     return if (a > b) a else b;
 }
-- 
2.54.0


From e3ccea70dd13ce94f5d2c96c7824fb743282447c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 14:49:56 -0700
Subject: [PATCH 173/290] CI: isolate zig-cache for parallel debug/release
 builds

---
 ci/zinc/linux_test_stage3_debug.sh | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/ci/zinc/linux_test_stage3_debug.sh b/ci/zinc/linux_test_stage3_debug.sh
index d40ad9da11926bf8fef48ace0391bc319e5548e0..2ca2f7bad72737a8bc013f6248e241ad3b899f27 100755
--- a/ci/zinc/linux_test_stage3_debug.sh
+++ b/ci/zinc/linux_test_stage3_debug.sh
@@ -12,6 +12,12 @@ git config core.abbrev 9
 
 echo "building stage3-debug with zig version $($OLD_ZIG version)"
 
+# Override the cache directories so that we don't clobber with the release
+# testing script which is running concurrently and in the same directory.
+# Normally we want processes to cooperate, but in this case we want them isolated.
+export ZIG_LOCAL_CACHE_DIR="$(pwd)/zig-cache-local-debug"
+export ZIG_GLOBAL_CACHE_DIR="$(pwd)/zig-cache-global-debug"
+
 export CC="$OLD_ZIG cc -target $TARGET -mcpu=$MCPU"
 export CXX="$OLD_ZIG c++ -target $TARGET -mcpu=$MCPU"
 
-- 
2.54.0


From 7346600517f5902316e5b8c179d8120b7854a5e1 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 16:33:48 -0700
Subject: [PATCH 174/290] CI: avoid concurrent jobs tripping over each other

---
 ci/zinc/linux_base.sh                |  4 ++++
 ci/zinc/linux_test_stage3_debug.sh   | 12 ++++++------
 ci/zinc/linux_test_stage3_release.sh |  4 ----
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/ci/zinc/linux_base.sh b/ci/zinc/linux_base.sh
index f1e992425832d1919a967b2ea98646b7206cd18c..9a757c8197f996d46de2154196a842210afdeaa1 100755
--- a/ci/zinc/linux_base.sh
+++ b/ci/zinc/linux_base.sh
@@ -25,3 +25,7 @@ DEBUG_STAGING="$WORKSPACE/_debug/staging"
 RELEASE_STAGING="$WORKSPACE/_release/staging"
 
 export PATH=$DEPS_LOCAL/bin:$PATH
+
+# Make the `zig version` number consistent.
+# This will affect the cmake commands that follow.
+git config core.abbrev 9
diff --git a/ci/zinc/linux_test_stage3_debug.sh b/ci/zinc/linux_test_stage3_debug.sh
index 2ca2f7bad72737a8bc013f6248e241ad3b899f27..2bacf6d838e33747faf02485738242fae027ad62 100755
--- a/ci/zinc/linux_test_stage3_debug.sh
+++ b/ci/zinc/linux_test_stage3_debug.sh
@@ -6,10 +6,6 @@ OLD_ZIG="$DEPS_LOCAL/bin/zig"
 TARGET="${ARCH}-linux-musl"
 MCPU="baseline"
 
-# Make the `zig version` number consistent.
-# This will affect the cmake command below.
-git config core.abbrev 9
-
 echo "building stage3-debug with zig version $($OLD_ZIG version)"
 
 # Override the cache directories so that we don't clobber with the release
@@ -53,8 +49,12 @@ cd $WORKSPACE
 stage3/bin/zig build -Dtarget=arm-linux-musleabihf
 
 echo "Looking for non-conforming code formatting..."
-echo "Formatting errors can be fixed by running 'zig fmt' on the files printed here."
-stage3/bin/zig fmt --check . --exclude test/cases/
+stage3/bin/zig fmt --check . \
+  --exclude test/cases/ \
+  --exclude build-debug \
+  --exclude build-release \
+  --exclude "$ZIG_LOCAL_CACHE_DIR" \
+  --exclude "$ZIG_GLOBAL_CACHE_DIR"
 
 stage3/bin/zig build test \
   -fqemu \
diff --git a/ci/zinc/linux_test_stage3_release.sh b/ci/zinc/linux_test_stage3_release.sh
index dd906f70fbce45d1088851ddccb7bbc3adcea474..d3532e0976dc9ebb59ab1155321e46fe08250632 100755
--- a/ci/zinc/linux_test_stage3_release.sh
+++ b/ci/zinc/linux_test_stage3_release.sh
@@ -6,10 +6,6 @@ OLD_ZIG="$DEPS_LOCAL/bin/zig"
 TARGET="${ARCH}-linux-musl"
 MCPU="baseline"
 
-# Make the `zig version` number consistent.
-# This will affect the cmake command below.
-git config core.abbrev 9
-
 echo "building stage3-release with zig version $($OLD_ZIG version)"
 
 export CC="$OLD_ZIG cc -target $TARGET -mcpu=$MCPU"
-- 
2.54.0


From d75d40dfdfeb82dc9b1b2b5cdcd3fdb8105ac97d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 18:00:24 -0700
Subject: [PATCH 175/290] build: make docs a separate step than test

---
 build.zig                            | 1 -
 ci/srht/freebsd_script               | 2 +-
 ci/zinc/linux_test_stage3_release.sh | 2 +-
 3 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/build.zig b/build.zig
index 6823248431daadc19ed22bf854d2353999997bac..bb3db637d63c017ec1a6f2467fe72bcb3fe5ae35 100644
--- a/build.zig
+++ b/build.zig
@@ -527,7 +527,6 @@ pub fn build(b: *Builder) !void {
     const test_step = b.step("test", "Run all the tests");
     test_step.dependOn(toolchain_step);
     test_step.dependOn(std_step);
-    test_step.dependOn(docs_step);
 }
 
 const exe_cflags = [_][]const u8{
diff --git a/ci/srht/freebsd_script b/ci/srht/freebsd_script
index 9c77c7d120c4683b9bb6d0eb5d5513147bfdaff4..45002fda154a437313c0a9f14e079f514ce5d390 100755
--- a/ci/srht/freebsd_script
+++ b/ci/srht/freebsd_script
@@ -45,7 +45,7 @@ cmake .. -DZIG_EXECUTABLE="$PREFIX/bin/zig"
 samu install
 
 # Here we skip some tests to save time.
-release/bin/zig build test -Dskip-stage1 -Dskip-non-native
+release/bin/zig build test docs -Dskip-stage1 -Dskip-non-native
 
 if [ -f ~/.s3cfg ]; then
   mv ../LICENSE release/
diff --git a/ci/zinc/linux_test_stage3_release.sh b/ci/zinc/linux_test_stage3_release.sh
index d3532e0976dc9ebb59ab1155321e46fe08250632..3f330cf548f5bd597191a0cc5f5ccff56b8d7a78 100755
--- a/ci/zinc/linux_test_stage3_release.sh
+++ b/ci/zinc/linux_test_stage3_release.sh
@@ -54,7 +54,7 @@ cd $WORKSPACE
 
 ZIG="$RELEASE_STAGING/bin/zig"
 
-$ZIG build test \
+$ZIG build test docs \
   -fqemu \
   -fwasmtime \
   -Dstatic-llvm \
-- 
2.54.0


From 9f43ebd6ef753e2e6a8ab8266724720329ea5846 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 18:53:09 -0700
Subject: [PATCH 176/290] CI: windows: build stage3 directly from dev kit

---
 ci/azure/pipelines.yml | 28 +++++++---------------------
 1 file changed, 7 insertions(+), 21 deletions(-)

diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index 16804a0a2b6ea11e3b496d73021fa596c023c298..730ecbda23d5b041480a5776a8d4bf0d6ccec4c9 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -56,12 +56,6 @@ jobs:
         git fetch --unshallow # `git describe` won't work on a shallow repo
       }
 
-      # The dev kit zip file that we have here is old, and may be incompatible with
-      # the build.zig script of master branch. So we keep an old version of build.zig
-      # here in the CI directory.
-      mv build.zig build.zig.master
-      mv ci/azure/build.zig build.zig
-
       mkdir $ZIGBUILDDIR
       cd $ZIGBUILDDIR
 
@@ -73,16 +67,11 @@ jobs:
         -Drelease `
         -Dstrip `
         -Duse-zig-libcxx `
-        -Dtarget=$(TARGET)
+        -Dtarget=$(TARGET) `
+        -fno-stage1
       CheckLastExitCode
 
       cd -
-
-      # Now that we have built an up-to-date zig.exe, we restore the original
-      # build script from master branch.
-      rm build.zig
-      mv build.zig.master build.zig
-
     name: build
     displayName: 'Build'
 
@@ -96,15 +85,12 @@ jobs:
         return 0
       }
 
-      # Sadly, stage2 is omitted from this build to save memory on the CI server. Once self-hosted is
-      # built with itself and does not gobble as much memory, we can enable these tests.
-      #& "$ZIGINSTALLDIR\bin\zig.exe" test "..\test\behavior.zig" -fno-stage1 -fLLVM -I "..\test" 2>&1
-      #CheckLastExitCode
+      & "$ZIGINSTALLDIR\bin\zig.exe" build test `
+        --search-prefix "$ZIGPREFIXPATH" `
+        -Dstatic-llvm `
+        -Dskip-non-native
+      CheckLastExitCode
 
-      & "$ZIGINSTALLDIR\bin\zig.exe" build test-toolchain -Dskip-non-native -Dskip-stage2-tests -Domit-stage2 2>&1
-      CheckLastExitCode
-      & "$ZIGINSTALLDIR\bin\zig.exe" build test-std -Dskip-non-native  2>&1
-      CheckLastExitCode
     name: test
     displayName: 'Test'
 
-- 
2.54.0


From 7cf6930e249d578512213dd83d7ff5d97c3fcac5 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 21:46:01 -0700
Subject: [PATCH 177/290] CI: macos: set release mode for zig and simplify

---
 ci/azure/macos_script | 27 +++++++++++----------------
 1 file changed, 11 insertions(+), 16 deletions(-)

diff --git a/ci/azure/macos_script b/ci/azure/macos_script
index d0ad9171ee8e9e9d6cb4118f2cef42475b0676c9..bf55dda51017919232ef208c89eadedd29900b3c 100755
--- a/ci/azure/macos_script
+++ b/ci/azure/macos_script
@@ -55,23 +55,18 @@ make $JOBS install
 cmake .. -DZIG_EXECUTABLE="$(pwd)/stage2/bin/zig"
 make $JOBS install
 
-stage2/bin/zig build -p release -Denable-llvm -Denable-stage1
+stage2/bin/zig build -p release \
+  --search-prefix "$PREFIX" \
+  -Dstatic-llvm \
+  -Drelease \
+  -Dstrip \
+  -Dtarget="$TARGET" \
+  -Denable-stage1
 
-release/bin/zig build test-compiler-rt      -Denable-macos-sdk
-release/bin/zig build test-behavior         -Denable-macos-sdk
-release/bin/zig build test-std              -Denable-macos-sdk
-release/bin/zig build test-universal-libc   -Denable-macos-sdk
-release/bin/zig build test-compare-output   -Denable-macos-sdk
-release/bin/zig build test-standalone       -Denable-macos-sdk
-release/bin/zig build test-stack-traces     -Denable-macos-sdk -fstage1
-release/bin/zig build test-cli              -Denable-macos-sdk
-release/bin/zig build test-asm-link         -Denable-macos-sdk
-release/bin/zig build test-translate-c      -Denable-macos-sdk
-release/bin/zig build test-run-translated-c -Denable-macos-sdk
-release/bin/zig build docs                  -Denable-macos-sdk
-release/bin/zig build test-fmt              -Denable-macos-sdk
-release/bin/zig build test-cases            -Denable-macos-sdk -Dsingle-threaded
-release/bin/zig build test-link             -Denable-macos-sdk
+release/bin/zig build test docs \
+  -Denable-macos-sdk \
+  -Dstatic-llvm \
+  --search-prefix "$PREFIX"
 
 if [ "${BUILD_REASON}" != "PullRequest" ]; then
   mv ../LICENSE release/
-- 
2.54.0


From a8f86291d2c108fbc70de175660742a737b78823 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 10 Aug 2022 22:51:00 -0700
Subject: [PATCH 178/290] CI: update freebsd tarball

This updates to a stage3 freebsd tarball.
---
 ci/srht/freebsd_script | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/ci/srht/freebsd_script b/ci/srht/freebsd_script
index 45002fda154a437313c0a9f14e079f514ce5d390..02ab218756e5d1ef98d8a74da2972988bd659044 100755
--- a/ci/srht/freebsd_script
+++ b/ci/srht/freebsd_script
@@ -7,7 +7,7 @@ sudo pkg update -fq
 sudo pkg install -y cmake py39-s3cmd wget curl jq samurai
 
 ZIGDIR="$(pwd)"
-CACHE_BASENAME="zig+llvm+lld+clang-x86_64-freebsd-gnu-0.10.0-dev.2931+bdf3fa12f"
+CACHE_BASENAME="zig+llvm+lld+clang-x86_64-freebsd-gnu-0.10.0-dev.3524+74673b7f6"
 PREFIX="$HOME/$CACHE_BASENAME"
 
 cd $HOME
@@ -45,7 +45,11 @@ cmake .. -DZIG_EXECUTABLE="$PREFIX/bin/zig"
 samu install
 
 # Here we skip some tests to save time.
-release/bin/zig build test docs -Dskip-stage1 -Dskip-non-native
+release/bin/zig build test docs \
+  --search-prefix "$PREFIX" \
+  -Dstatic-llvm \
+  -Dskip-stage1 \
+  -Dskip-non-native
 
 if [ -f ~/.s3cfg ]; then
   mv ../LICENSE release/
-- 
2.54.0


From 5b486b1851ce3ee930236653fc0f8b0ec3eef5e6 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 11 Aug 2022 00:29:40 -0700
Subject: [PATCH 179/290] CI: use zig build to produce release artifact

For both macOS and FreeBSD.
---
 ci/azure/macos_script  | 27 +++++++++--------------
 ci/srht/freebsd_script | 50 +++++++++++++++++++++++++-----------------
 2 files changed, 40 insertions(+), 37 deletions(-)

diff --git a/ci/azure/macos_script b/ci/azure/macos_script
index bf55dda51017919232ef208c89eadedd29900b3c..4f3c5697b086fa44e0d152b0b52e120d8ee465b0 100755
--- a/ci/azure/macos_script
+++ b/ci/azure/macos_script
@@ -34,13 +34,11 @@ git fetch --tags
 mkdir build
 cd build
 cmake .. \
-  -DCMAKE_INSTALL_PREFIX="$(pwd)/stage2" \
   -DCMAKE_PREFIX_PATH="$PREFIX" \
   -DCMAKE_BUILD_TYPE=Release \
   -DZIG_TARGET_TRIPLE="$TARGET" \
   -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_OMIT_STAGE2=ON
+  -DZIG_STATIC=ON
 
 # Now cmake will use zig as the C/C++ compiler. We reset the environment variables
 # so that installation and testing do not get affected by them.
@@ -49,13 +47,8 @@ unset CXX
 
 make $JOBS install
 
-# Here we rebuild zig but this time using the Zig binary we just now produced to
-# build zig1.o rather than relying on the one built with stage0. See
-# https://github.com/ziglang/zig/issues/6830 for more details.
-cmake .. -DZIG_EXECUTABLE="$(pwd)/stage2/bin/zig"
-make $JOBS install
-
-stage2/bin/zig build -p release \
+stage2/bin/zig build \
+  --prefix stage3-release \
   --search-prefix "$PREFIX" \
   -Dstatic-llvm \
   -Drelease \
@@ -63,21 +56,21 @@ stage2/bin/zig build -p release \
   -Dtarget="$TARGET" \
   -Denable-stage1
 
-release/bin/zig build test docs \
+stage3-release/bin/zig build test docs \
   -Denable-macos-sdk \
   -Dstatic-llvm \
   --search-prefix "$PREFIX"
 
 if [ "${BUILD_REASON}" != "PullRequest" ]; then
-  mv ../LICENSE release/
-  mv ../zig-cache/langref.html release/
-  mv release/bin/zig release/
-  rmdir release/bin
+  mv ../LICENSE stage3-release/
+  mv ../zig-cache/langref.html stage3-release/
+  mv stage3-release/bin/zig stage3-release/
+  rmdir stage3-release/bin
 
-  VERSION=$(release/zig version)
+  VERSION=$(stage3-release/zig version)
   DIRNAME="zig-macos-$ARCH-$VERSION"
   TARBALL="$DIRNAME.tar.xz"
-  mv release "$DIRNAME"
+  mv stage3-release "$DIRNAME"
   tar cfJ "$TARBALL" "$DIRNAME"
 
   mv "$DOWNLOADSECUREFILE_SECUREFILEPATH" "$HOME/.s3cfg"
diff --git a/ci/srht/freebsd_script b/ci/srht/freebsd_script
index 02ab218756e5d1ef98d8a74da2972988bd659044..dc22a02ed590fb86a5fb67823138a3946c5d550b 100755
--- a/ci/srht/freebsd_script
+++ b/ci/srht/freebsd_script
@@ -7,7 +7,9 @@ sudo pkg update -fq
 sudo pkg install -y cmake py39-s3cmd wget curl jq samurai
 
 ZIGDIR="$(pwd)"
-CACHE_BASENAME="zig+llvm+lld+clang-x86_64-freebsd-gnu-0.10.0-dev.3524+74673b7f6"
+TARGET="x86_64-freebsd-gnu"
+MCPU="baseline"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.10.0-dev.3524+74673b7f6"
 PREFIX="$HOME/$CACHE_BASENAME"
 
 cd $HOME
@@ -30,38 +32,46 @@ export TERM=dumb
 mkdir build
 cd build
 cmake .. \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DCMAKE_PREFIX_PATH=$PREFIX \
-    "-DCMAKE_INSTALL_PREFIX=$(pwd)/release" \
-    -DZIG_STATIC=ON \
-    -DZIG_TARGET_TRIPLE=x86_64-freebsd-gnu \
-    -GNinja
+  -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_PREFIX_PATH=$PREFIX \
+  -DZIG_TARGET_TRIPLE="$TARGET" \
+  -DZIG_TARGET_MCPU="$MCPU" \
+  -DZIG_STATIC=ON \
+  -GNinja
 samu install
 
-# Here we rebuild zig but this time using the Zig binary we just now produced to
-# build zig1.o rather than relying on the one built with stage0. This makes it
-# a stage3 build rather than a stage2 build.
-cmake .. -DZIG_EXECUTABLE="$PREFIX/bin/zig"
-samu install
+# TODO: eliminate this workaround. Without this, zig does not end up passing
+# -isystem /usr/include when building libc++, resulting in #include <sys/endian.h>
+# "file not found" errors.
+stage2/bin/zig libc >libc.txt
+
+ZIG_LIBC=libc.txt stage2/bin/zig build \
+  --prefix stage3-release \
+  --search-prefix "$PREFIX" \
+  -Dstatic-llvm \
+  -Drelease \
+  -Dstrip \
+  -Dtarget="$TARGET" \
+  -Denable-stage1
 
 # Here we skip some tests to save time.
-release/bin/zig build test docs \
-  --search-prefix "$PREFIX" \
+stage3-release/bin/zig build test docs \
   -Dstatic-llvm \
+  --search-prefix "$PREFIX" \
   -Dskip-stage1 \
   -Dskip-non-native
 
 if [ -f ~/.s3cfg ]; then
-  mv ../LICENSE release/
-  mv ../zig-cache/langref.html release/
-  mv release/bin/zig release/
-  rmdir release/bin
+  mv ../LICENSE stage3-release/
+  mv ../zig-cache/langref.html stage3-release/
+  mv stage3-release/bin/zig stage3-release/
+  rmdir stage3-release/bin
 
   GITBRANCH=$(basename $GITHUB_REF)
-  VERSION=$(release/zig version)
+  VERSION=$(stage3-release/zig version)
   DIRNAME="zig-freebsd-x86_64-$VERSION"
   TARBALL="$DIRNAME.tar.xz"
-  mv release "$DIRNAME"
+  mv stage3-release "$DIRNAME"
   tar cfJ "$TARBALL" "$DIRNAME"
 
   s3cmd put -P --add-header="cache-control: public, max-age=31536000, immutable" "$TARBALL" s3://ziglang.org/builds/
-- 
2.54.0


From 28e95b324027e08be4f0dd48772970254299b976 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 11 Aug 2022 18:20:30 -0700
Subject: [PATCH 180/290] CI: drone: simplify

Instead of a switch in a bash file we just properly name
the pipeline steps.

Also use zig build to produce the release artifact.
---
 ci/drone/drone.yml                   | 42 +++++++++++------------
 ci/drone/linux_script_build          | 14 ++++----
 ci/drone/linux_script_test           | 51 ----------------------------
 ci/drone/test_linux_behavior         |  8 +++++
 ci/drone/test_linux_cases            |  6 ++++
 ci/drone/test_linux_misc             | 11 ++++++
 ci/drone/test_linux_std_Debug        |  5 +++
 ci/drone/test_linux_std_ReleaseFast  |  5 +++
 ci/drone/test_linux_std_ReleaseSafe  |  5 +++
 ci/drone/test_linux_std_ReleaseSmall |  5 +++
 10 files changed, 74 insertions(+), 78 deletions(-)
 delete mode 100755 ci/drone/linux_script_test
 create mode 100755 ci/drone/test_linux_behavior
 create mode 100755 ci/drone/test_linux_cases
 create mode 100755 ci/drone/test_linux_misc
 create mode 100755 ci/drone/test_linux_std_Debug
 create mode 100755 ci/drone/test_linux_std_ReleaseFast
 create mode 100755 ci/drone/test_linux_std_ReleaseSafe
 create mode 100755 ci/drone/test_linux_std_ReleaseSmall

diff --git a/ci/drone/drone.yml b/ci/drone/drone.yml
index 363d168a212418525261dd996bf3c17ed26f2258..6a66913a5acdbad8ea1f27a70742f7308088f463 100644
--- a/ci/drone/drone.yml
+++ b/ci/drone/drone.yml
@@ -13,65 +13,65 @@ steps:
   commands:
   - ./ci/drone/linux_script_build
 
-- name: test-1
+- name: behavior
   depends_on:
   - build
   image: ziglang/static-base:llvm14-aarch64-3
   commands:
-  - ./ci/drone/linux_script_test 1
+  - ./ci/drone/test_linux_behavior
 
-- name: test-2
+- name: std_Debug
   depends_on:
   - build
   image: ziglang/static-base:llvm14-aarch64-3
   commands:
-  - ./ci/drone/linux_script_test 2
+  - ./ci/drone/test_linux_std_Debug
 
-- name: test-3
+- name: std_ReleaseSafe
   depends_on:
   - build
   image: ziglang/static-base:llvm14-aarch64-3
   commands:
-  - ./ci/drone/linux_script_test 3
+  - ./ci/drone/test_linux_std_ReleaseSafe
 
-- name: test-4
+- name: std_ReleaseFast
   depends_on:
   - build
   image: ziglang/static-base:llvm14-aarch64-3
   commands:
-  - ./ci/drone/linux_script_test 4
+  - ./ci/drone/test_linux_std_ReleaseFast
 
-- name: test-5
+- name: std_ReleaseSmall
   depends_on:
   - build
   image: ziglang/static-base:llvm14-aarch64-3
   commands:
-  - ./ci/drone/linux_script_test 5
+  - ./ci/drone/test_linux_std_ReleaseSmall
 
-- name: test-6
+- name: misc
   depends_on:
   - build
   image: ziglang/static-base:llvm14-aarch64-3
   commands:
-  - ./ci/drone/linux_script_test 6
+  - ./ci/drone/test_linux_misc
 
-- name: test-7
+- name: cases
   depends_on:
   - build
   image: ziglang/static-base:llvm14-aarch64-3
   commands:
-  - ./ci/drone/linux_script_test 7
+  - ./ci/drone/test_linux_cases
 
 - name: finalize
   depends_on:
   - build
-  - test-1
-  - test-2
-  - test-3
-  - test-4
-  - test-5
-  - test-6
-  - test-7
+  - behavior
+  - std_Debug
+  - std_ReleaseSafe
+  - std_ReleaseFast
+  - std_ReleaseSmall
+  - misc
+  - cases
   image: ziglang/static-base:llvm14-aarch64-3
   environment:
     SRHT_OAUTH_TOKEN:
diff --git a/ci/drone/linux_script_build b/ci/drone/linux_script_build
index 58dad5f14c60c3d1fbcb3de17c5b842aab8c84e0..6fe9756b92b2306f216f04c3f8be86b618457578 100755
--- a/ci/drone/linux_script_build
+++ b/ci/drone/linux_script_build
@@ -42,7 +42,6 @@ git fetch --tags
 mkdir build
 cd build
 cmake .. \
-  -DCMAKE_INSTALL_PREFIX="$DISTDIR" \
   -DCMAKE_PREFIX_PATH="$PREFIX" \
   -DCMAKE_BUILD_TYPE=Release \
   -DCMAKE_AR="$PREFIX/bin/ar" \
@@ -58,8 +57,11 @@ unset CC
 unset CXX
 samu install
 
-# Here we rebuild Zig but this time using the Zig binary we just now produced to
-# build zig1.o rather than relying on the one built with stage0. See
-# https://github.com/ziglang/zig/issues/6830 for more details.
-cmake .. -DZIG_EXECUTABLE="$DISTDIR/bin/zig"
-samu install
+stage2/bin/zig build \
+  --prefix "$DISTDIR" \
+  --search-prefix "$PREFIX" \
+  -Dstatic-llvm \
+  -Drelease \
+  -Dstrip \
+  -Dtarget="$TARGET" \
+  -Denable-stage1
diff --git a/ci/drone/linux_script_test b/ci/drone/linux_script_test
deleted file mode 100755
index b748745da9b5acc0b8c04304c84ae624a63b4ebe..0000000000000000000000000000000000000000
--- a/ci/drone/linux_script_test
+++ /dev/null
@@ -1,51 +0,0 @@
-#!/bin/sh
-
-. ./ci/drone/linux_script_base
-
-BUILD_FLAGS="-Dskip-non-native"
-
-case "$1" in
-  1)
-    ./build/zig build $BUILD_FLAGS test-behavior
-    ./build/zig build $BUILD_FLAGS test-compiler-rt
-    ./build/zig build $BUILD_FLAGS test-fmt
-    ./build/zig build $BUILD_FLAGS docs
-    ;;
-  2)
-    # Debug
-    ./build/zig build $BUILD_FLAGS test-std -Dskip-release-safe -Dskip-release-fast -Dskip-release-small
-    ;;
-  3)
-    # ReleaseSafe
-    ./build/zig build $BUILD_FLAGS test-std -Dskip-debug -Dskip-release-fast -Dskip-release-small -Dskip-non-native -Dskip-single-threaded
-    ;;
-  4)
-    # ReleaseFast
-    ./build/zig build $BUILD_FLAGS test-std -Dskip-debug -Dskip-release-safe -Dskip-release-small -Dskip-non-native -Dskip-single-threaded
-    ;;
-  5)
-    # ReleaseSmall
-    ./build/zig build $BUILD_FLAGS test-std -Dskip-debug -Dskip-release-safe -Dskip-release-fast
-    ;;
-  6)
-    ./build/zig build $BUILD_FLAGS test-universal-libc
-    ./build/zig build $BUILD_FLAGS test-compare-output
-    ./build/zig build $BUILD_FLAGS test-standalone -Dskip-release-safe
-    ./build/zig build $BUILD_FLAGS test-stack-traces
-    ./build/zig build $BUILD_FLAGS test-cli
-    ./build/zig build $BUILD_FLAGS test-asm-link
-    ./build/zig build $BUILD_FLAGS test-translate-c
-    ;;
-  7)
-    ./build/zig build $BUILD_FLAGS # test building self-hosted without LLVM
-    ./build/zig build $BUILD_FLAGS test-cases
-    ;;
-  '')
-    echo "error: expecting test group argument"
-    exit 1
-    ;;
-  *)
-    echo "error: unknown test group: $1"
-    exit 1
-    ;;
-esac
diff --git a/ci/drone/test_linux_behavior b/ci/drone/test_linux_behavior
new file mode 100755
index 0000000000000000000000000000000000000000..a06347c16984a9d7829ccf9e524e4836b36c5823
--- /dev/null
+++ b/ci/drone/test_linux_behavior
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+. ./ci/drone/linux_script_base
+
+./build/zig build test-behavior    -Dskip-non-native
+./build/zig build test-compiler-rt -Dskip-non-native
+./build/zig build test-fmt
+./build/zig build docs
diff --git a/ci/drone/test_linux_cases b/ci/drone/test_linux_cases
new file mode 100755
index 0000000000000000000000000000000000000000..702bb45f9148a7bb5576c0b9223b3a83ead5aa7b
--- /dev/null
+++ b/ci/drone/test_linux_cases
@@ -0,0 +1,6 @@
+#!/bin/sh
+
+. ./ci/drone/linux_script_base
+
+./build/zig build -Dskip-non-native # test building self-hosted without LLVM
+./build/zig build -Dskip-non-native test-cases
diff --git a/ci/drone/test_linux_misc b/ci/drone/test_linux_misc
new file mode 100755
index 0000000000000000000000000000000000000000..6a19ee41f37d67a282cda336837c81a39aafa61b
--- /dev/null
+++ b/ci/drone/test_linux_misc
@@ -0,0 +1,11 @@
+#!/bin/sh
+
+. ./ci/drone/linux_script_base
+
+./build/zig build test-universal-libc -Dskip-non-native
+./build/zig build test-compare-output -Dskip-non-native
+./build/zig build test-standalone     -Dskip-non-native -Dskip-release-safe
+./build/zig build test-stack-traces   -Dskip-non-native
+./build/zig build test-cli            -Dskip-non-native
+./build/zig build test-asm-link       -Dskip-non-native
+./build/zig build test-translate-c    -Dskip-non-native
diff --git a/ci/drone/test_linux_std_Debug b/ci/drone/test_linux_std_Debug
new file mode 100755
index 0000000000000000000000000000000000000000..41fb34f8bc09c9a4f39ce8b77d95b2ac2477c52a
--- /dev/null
+++ b/ci/drone/test_linux_std_Debug
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+. ./ci/drone/linux_script_base
+
+./build/zig build test-std -Dskip-release-safe -Dskip-release-fast -Dskip-release-small -Dskip-non-native
diff --git a/ci/drone/test_linux_std_ReleaseFast b/ci/drone/test_linux_std_ReleaseFast
new file mode 100755
index 0000000000000000000000000000000000000000..156406ac35a9a63e42cb23b8af142cd2327e1e4c
--- /dev/null
+++ b/ci/drone/test_linux_std_ReleaseFast
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+. ./ci/drone/linux_script_base
+
+./build/zig build test-std -Dskip-debug -Dskip-release-safe -Dskip-release-small -Dskip-non-native -Dskip-single-threaded
diff --git a/ci/drone/test_linux_std_ReleaseSafe b/ci/drone/test_linux_std_ReleaseSafe
new file mode 100755
index 0000000000000000000000000000000000000000..f972d75f0bc78aabb7c6dd6241c5326e660e51ea
--- /dev/null
+++ b/ci/drone/test_linux_std_ReleaseSafe
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+. ./ci/drone/linux_script_base
+
+./build/zig build test-std -Dskip-debug -Dskip-release-fast -Dskip-release-small -Dskip-non-native -Dskip-single-threaded
diff --git a/ci/drone/test_linux_std_ReleaseSmall b/ci/drone/test_linux_std_ReleaseSmall
new file mode 100755
index 0000000000000000000000000000000000000000..9a5975ffe571c4dd0433e9e054557b243651d68e
--- /dev/null
+++ b/ci/drone/test_linux_std_ReleaseSmall
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+. ./ci/drone/linux_script_base
+
+./build/zig build test-std -Dskip-debug -Dskip-release-safe -Dskip-release-fast -Dskip-non-native
-- 
2.54.0


From 445b33cfc05771d35ca243cde15d0b5594129ae3 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 17 Aug 2022 22:24:07 -0700
Subject: [PATCH 181/290] fix std.os.windows.PathSpace.span

it was returning a pointer to a parameter.
---
 lib/std/os/windows.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index c79ccb511375d5127a21062d497f897d1ba5754d..b0a0f6d407476e670b84525566e6d580c6345271 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -1802,7 +1802,7 @@ pub const PathSpace = struct {
     data: [PATH_MAX_WIDE:0]u16,
     len: usize,
 
-    pub fn span(self: PathSpace) [:0]const u16 {
+    pub fn span(self: *const PathSpace) [:0]const u16 {
         return self.data[0..self.len :0];
     }
 };
-- 
2.54.0


From 5be2e8f941f78a5d1fda3ab4a2b4aa9487f1b519 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 17 Aug 2022 15:38:55 -0700
Subject: [PATCH 182/290] CI: update windows tarball

This includes a few recent bug fixes which may solve the Windows CI
failure.
---
 ci/azure/build.zig     | 974 -----------------------------------------
 ci/azure/pipelines.yml |   8 +-
 2 files changed, 4 insertions(+), 978 deletions(-)
 delete mode 100644 ci/azure/build.zig

diff --git a/ci/azure/build.zig b/ci/azure/build.zig
deleted file mode 100644
index 00f1cce2bd95eb5597ec8ec33f6c5dc0e4afa328..0000000000000000000000000000000000000000
--- a/ci/azure/build.zig
+++ /dev/null
@@ -1,974 +0,0 @@
-const std = @import("std");
-const builtin = std.builtin;
-const Builder = std.build.Builder;
-const BufMap = std.BufMap;
-const mem = std.mem;
-const ArrayList = std.ArrayList;
-const io = std.io;
-const fs = std.fs;
-const InstallDirectoryOptions = std.build.InstallDirectoryOptions;
-const assert = std.debug.assert;
-
-const zig_version = std.builtin.Version{ .major = 0, .minor = 10, .patch = 0 };
-
-pub fn build(b: *Builder) !void {
-    b.setPreferredReleaseMode(.ReleaseFast);
-    const mode = b.standardReleaseOptions();
-    const target = b.standardTargetOptions(.{});
-    const single_threaded = b.option(bool, "single-threaded", "Build artifacts that run in single threaded mode");
-    const use_zig_libcxx = b.option(bool, "use-zig-libcxx", "If libc++ is needed, use zig's bundled version, don't try to integrate with the system") orelse false;
-
-    const docgen_exe = b.addExecutable("docgen", "doc/docgen.zig");
-    docgen_exe.single_threaded = single_threaded;
-
-    const rel_zig_exe = try fs.path.relative(b.allocator, b.build_root, b.zig_exe);
-    const langref_out_path = fs.path.join(
-        b.allocator,
-        &[_][]const u8{ b.cache_root, "langref.html" },
-    ) catch unreachable;
-    const docgen_cmd = docgen_exe.run();
-    docgen_cmd.addArgs(&[_][]const u8{
-        rel_zig_exe,
-        "doc" ++ fs.path.sep_str ++ "langref.html.in",
-        langref_out_path,
-    });
-    docgen_cmd.step.dependOn(&docgen_exe.step);
-
-    const docs_step = b.step("docs", "Build documentation");
-    docs_step.dependOn(&docgen_cmd.step);
-
-    const have_stage1 = b.option(bool, "enable-stage1", "Include the stage1 compiler behind a feature flag") orelse false;
-    const static_llvm = b.option(bool, "static-llvm", "Disable integration with system-installed LLVM, Clang, LLD, and libc++") orelse false;
-    const enable_llvm = b.option(bool, "enable-llvm", "Build self-hosted compiler with LLVM backend enabled") orelse (have_stage1 or static_llvm);
-    const llvm_has_m68k = b.option(
-        bool,
-        "llvm-has-m68k",
-        "Whether LLVM has the experimental target m68k enabled",
-    ) orelse false;
-    const llvm_has_csky = b.option(
-        bool,
-        "llvm-has-csky",
-        "Whether LLVM has the experimental target csky enabled",
-    ) orelse false;
-    const llvm_has_arc = b.option(
-        bool,
-        "llvm-has-arc",
-        "Whether LLVM has the experimental target arc enabled",
-    ) orelse false;
-    const config_h_path_option = b.option([]const u8, "config_h", "Path to the generated config.h");
-
-    b.installDirectory(InstallDirectoryOptions{
-        .source_dir = "lib",
-        .install_dir = .lib,
-        .install_subdir = "zig",
-        .exclude_extensions = &[_][]const u8{
-            // exclude files from lib/std/compress/
-            ".gz",
-            ".z.0",
-            ".z.9",
-            "rfc1951.txt",
-            "rfc1952.txt",
-            // exclude files from lib/std/compress/deflate/testdata
-            ".expect",
-            ".expect-noinput",
-            ".golden",
-            ".input",
-            "compress-e.txt",
-            "compress-gettysburg.txt",
-            "compress-pi.txt",
-            "rfc1951.txt",
-            // exclude files from lib/std/tz/
-            ".tzif",
-            // others
-            "README.md",
-        },
-        .blank_extensions = &[_][]const u8{
-            "test.zig",
-        },
-    });
-
-    const tracy = b.option([]const u8, "tracy", "Enable Tracy integration. Supply path to Tracy source");
-    const tracy_callstack = b.option(bool, "tracy-callstack", "Include callstack information with Tracy data. Does nothing if -Dtracy is not provided") orelse false;
-    const tracy_allocation = b.option(bool, "tracy-allocation", "Include allocation information with Tracy data. Does nothing if -Dtracy is not provided") orelse false;
-    const force_gpa = b.option(bool, "force-gpa", "Force the compiler to use GeneralPurposeAllocator") orelse false;
-    const link_libc = b.option(bool, "force-link-libc", "Force self-hosted compiler to link libc") orelse enable_llvm;
-    const strip = b.option(bool, "strip", "Omit debug information") orelse false;
-    const value_tracing = b.option(bool, "value-tracing", "Enable extra state tracking to help troubleshoot bugs in the compiler (using the std.debug.Trace API)") orelse false;
-
-    const mem_leak_frames: u32 = b.option(u32, "mem-leak-frames", "How many stack frames to print when a memory leak occurs. Tests get 2x this amount.") orelse blk: {
-        if (strip) break :blk @as(u32, 0);
-        if (mode != .Debug) break :blk 0;
-        break :blk 4;
-    };
-
-    const main_file: ?[]const u8 = if (have_stage1) null else "src/main.zig";
-
-    const exe = b.addExecutable("zig", main_file);
-    exe.strip = strip;
-    exe.install();
-    exe.setBuildMode(mode);
-    exe.setTarget(target);
-
-    b.default_step.dependOn(&exe.step);
-    exe.single_threaded = single_threaded;
-
-    if (target.isWindows() and target.getAbi() == .gnu) {
-        // LTO is currently broken on mingw, this can be removed when it's fixed.
-        exe.want_lto = false;
-    }
-
-    const exe_options = b.addOptions();
-    exe.addOptions("build_options", exe_options);
-
-    exe_options.addOption(u32, "mem_leak_frames", mem_leak_frames);
-    exe_options.addOption(bool, "skip_non_native", false);
-    exe_options.addOption(bool, "have_llvm", enable_llvm);
-    exe_options.addOption(bool, "llvm_has_m68k", llvm_has_m68k);
-    exe_options.addOption(bool, "llvm_has_csky", llvm_has_csky);
-    exe_options.addOption(bool, "llvm_has_arc", llvm_has_arc);
-    exe_options.addOption(bool, "force_gpa", force_gpa);
-
-    if (link_libc) {
-        exe.linkLibC();
-    }
-
-    const is_debug = mode == .Debug;
-    const enable_logging = b.option(bool, "log", "Enable debug logging with --debug-log") orelse is_debug;
-    const enable_link_snapshots = b.option(bool, "link-snapshot", "Whether to enable linker state snapshots") orelse false;
-
-    const opt_version_string = b.option([]const u8, "version-string", "Override Zig version string. Default is to find out with git.");
-    const version = if (opt_version_string) |version| version else v: {
-        const version_string = b.fmt("{d}.{d}.{d}", .{ zig_version.major, zig_version.minor, zig_version.patch });
-
-        var code: u8 = undefined;
-        const git_describe_untrimmed = b.execAllowFail(&[_][]const u8{
-            "git", "-C", b.build_root, "describe", "--match", "*.*.*", "--tags",
-        }, &code, .Ignore) catch {
-            break :v version_string;
-        };
-        const git_describe = mem.trim(u8, git_describe_untrimmed, " \n\r");
-
-        switch (mem.count(u8, git_describe, "-")) {
-            0 => {
-                // Tagged release version (e.g. 0.9.0).
-                if (!mem.eql(u8, git_describe, version_string)) {
-                    std.debug.print("Zig version '{s}' does not match Git tag '{s}'\n", .{ version_string, git_describe });
-                    std.process.exit(1);
-                }
-                break :v version_string;
-            },
-            2 => {
-                // Untagged development build (e.g. 0.9.0-dev.2025+ecf0050a9).
-                var it = mem.split(u8, git_describe, "-");
-                const tagged_ancestor = it.next() orelse unreachable;
-                const commit_height = it.next() orelse unreachable;
-                const commit_id = it.next() orelse unreachable;
-
-                const ancestor_ver = try std.builtin.Version.parse(tagged_ancestor);
-                if (zig_version.order(ancestor_ver) != .gt) {
-                    std.debug.print("Zig version '{}' must be greater than tagged ancestor '{}'\n", .{ zig_version, ancestor_ver });
-                    std.process.exit(1);
-                }
-
-                // Check that the commit hash is prefixed with a 'g' (a Git convention).
-                if (commit_id.len < 1 or commit_id[0] != 'g') {
-                    std.debug.print("Unexpected `git describe` output: {s}\n", .{git_describe});
-                    break :v version_string;
-                }
-
-                // The version is reformatted in accordance with the https://semver.org specification.
-                break :v b.fmt("{s}-dev.{s}+{s}", .{ version_string, commit_height, commit_id[1..] });
-            },
-            else => {
-                std.debug.print("Unexpected `git describe` output: {s}\n", .{git_describe});
-                break :v version_string;
-            },
-        }
-    };
-    exe_options.addOption([:0]const u8, "version", try b.allocator.dupeZ(u8, version));
-
-    if (enable_llvm) {
-        const cmake_cfg = if (static_llvm) null else findAndParseConfigH(b, config_h_path_option);
-
-        if (have_stage1) {
-            const softfloat = b.addStaticLibrary("softfloat", null);
-            softfloat.setBuildMode(.ReleaseFast);
-            softfloat.setTarget(target);
-            softfloat.addIncludeDir("deps/SoftFloat-3e-prebuilt");
-            softfloat.addIncludeDir("deps/SoftFloat-3e/source/8086");
-            softfloat.addIncludeDir("deps/SoftFloat-3e/source/include");
-            softfloat.addCSourceFiles(&softfloat_sources, &[_][]const u8{ "-std=c99", "-O3" });
-            softfloat.single_threaded = single_threaded;
-
-            const zig0 = b.addExecutable("zig0", null);
-            zig0.addCSourceFiles(&.{"src/stage1/zig0.cpp"}, &exe_cflags);
-            zig0.addIncludeDir("zig-cache/tmp"); // for config.h
-            zig0.defineCMacro("ZIG_VERSION_MAJOR", b.fmt("{d}", .{zig_version.major}));
-            zig0.defineCMacro("ZIG_VERSION_MINOR", b.fmt("{d}", .{zig_version.minor}));
-            zig0.defineCMacro("ZIG_VERSION_PATCH", b.fmt("{d}", .{zig_version.patch}));
-            zig0.defineCMacro("ZIG_VERSION_STRING", b.fmt("\"{s}\"", .{version}));
-
-            for ([_]*std.build.LibExeObjStep{ zig0, exe }) |artifact| {
-                artifact.addIncludeDir("src");
-                artifact.addIncludeDir("deps/SoftFloat-3e/source/include");
-                artifact.addIncludeDir("deps/SoftFloat-3e-prebuilt");
-
-                artifact.defineCMacro("ZIG_LINK_MODE", "Static");
-
-                artifact.addCSourceFiles(&stage1_sources, &exe_cflags);
-                artifact.addCSourceFiles(&optimized_c_sources, &[_][]const u8{ "-std=c99", "-O3" });
-
-                artifact.linkLibrary(softfloat);
-                artifact.linkLibCpp();
-            }
-
-            try addStaticLlvmOptionsToExe(zig0);
-
-            const zig1_obj_ext = target.getObjectFormat().fileExt(target.getCpuArch());
-            const zig1_obj_path = b.pathJoin(&.{ "zig-cache", "tmp", b.fmt("zig1{s}", .{zig1_obj_ext}) });
-            const zig1_compiler_rt_path = b.pathJoin(&.{ b.pathFromRoot("lib"), "std", "special", "compiler_rt.zig" });
-
-            const zig1_obj = zig0.run();
-            zig1_obj.addArgs(&.{
-                "src/stage1.zig",
-                "-target",
-                try target.zigTriple(b.allocator),
-                "-mcpu=baseline",
-                "--name",
-                "zig1",
-                "--zig-lib-dir",
-                b.pathFromRoot("lib"),
-                b.fmt("-femit-bin={s}", .{b.pathFromRoot(zig1_obj_path)}),
-                "-fcompiler-rt",
-                "-lc",
-            });
-            {
-                zig1_obj.addArgs(&.{ "--pkg-begin", "build_options" });
-                zig1_obj.addFileSourceArg(exe_options.getSource());
-                zig1_obj.addArgs(&.{ "--pkg-end", "--pkg-begin", "compiler_rt", zig1_compiler_rt_path, "--pkg-end" });
-            }
-            switch (mode) {
-                .Debug => {},
-                .ReleaseFast => {
-                    zig1_obj.addArg("-OReleaseFast");
-                    zig1_obj.addArg("--strip");
-                },
-                .ReleaseSafe => {
-                    zig1_obj.addArg("-OReleaseSafe");
-                    zig1_obj.addArg("--strip");
-                },
-                .ReleaseSmall => {
-                    zig1_obj.addArg("-OReleaseSmall");
-                    zig1_obj.addArg("--strip");
-                },
-            }
-            if (single_threaded orelse false) {
-                zig1_obj.addArg("-fsingle-threaded");
-            }
-
-            exe.step.dependOn(&zig1_obj.step);
-            exe.addObjectFile(zig1_obj_path);
-
-            // This is intentionally a dummy path. stage1.zig tries to @import("compiler_rt") in case
-            // of being built by cmake. But when built by zig it's gonna get a compiler_rt so that
-            // is pointless.
-            exe.addPackagePath("compiler_rt", "src/empty.zig");
-        }
-        if (cmake_cfg) |cfg| {
-            // Inside this code path, we have to coordinate with system packaged LLVM, Clang, and LLD.
-            // That means we also have to rely on stage1 compiled c++ files. We parse config.h to find
-            // the information passed on to us from cmake.
-            if (cfg.cmake_prefix_path.len > 0) {
-                b.addSearchPrefix(cfg.cmake_prefix_path);
-            }
-
-            try addCmakeCfgOptionsToExe(b, cfg, exe, use_zig_libcxx);
-        } else {
-            // Here we are -Denable-llvm but no cmake integration.
-            try addStaticLlvmOptionsToExe(exe);
-        }
-    }
-
-    const semver = try std.SemanticVersion.parse(version);
-    exe_options.addOption(std.SemanticVersion, "semver", semver);
-
-    exe_options.addOption(bool, "enable_logging", enable_logging);
-    exe_options.addOption(bool, "enable_link_snapshots", enable_link_snapshots);
-    exe_options.addOption(bool, "enable_tracy", tracy != null);
-    exe_options.addOption(bool, "enable_tracy_callstack", tracy_callstack);
-    exe_options.addOption(bool, "enable_tracy_allocation", tracy_allocation);
-    exe_options.addOption(bool, "value_tracing", value_tracing);
-    exe_options.addOption(bool, "have_stage1", have_stage1);
-    if (tracy) |tracy_path| {
-        const client_cpp = fs.path.join(
-            b.allocator,
-            &[_][]const u8{ tracy_path, "TracyClient.cpp" },
-        ) catch unreachable;
-
-        // On mingw, we need to opt into windows 7+ to get some features required by tracy.
-        const tracy_c_flags: []const []const u8 = if (target.isWindows() and target.getAbi() == .gnu)
-            &[_][]const u8{ "-DTRACY_ENABLE=1", "-fno-sanitize=undefined", "-D_WIN32_WINNT=0x601" }
-        else
-            &[_][]const u8{ "-DTRACY_ENABLE=1", "-fno-sanitize=undefined" };
-
-        exe.addIncludeDir(tracy_path);
-        exe.addCSourceFile(client_cpp, tracy_c_flags);
-        if (!enable_llvm) {
-            exe.linkSystemLibraryName("c++");
-        }
-        exe.linkLibC();
-
-        if (target.isWindows()) {
-            exe.linkSystemLibrary("dbghelp");
-            exe.linkSystemLibrary("ws2_32");
-        }
-    }
-}
-
-const exe_cflags = [_][]const u8{
-    "-std=c++14",
-    "-D__STDC_CONSTANT_MACROS",
-    "-D__STDC_FORMAT_MACROS",
-    "-D__STDC_LIMIT_MACROS",
-    "-D_GNU_SOURCE",
-    "-fvisibility-inlines-hidden",
-    "-fno-exceptions",
-    "-fno-rtti",
-    "-Werror=type-limits",
-    "-Wno-missing-braces",
-    "-Wno-comment",
-};
-
-fn addCmakeCfgOptionsToExe(
-    b: *Builder,
-    cfg: CMakeConfig,
-    exe: *std.build.LibExeObjStep,
-    use_zig_libcxx: bool,
-) !void {
-    exe.addObjectFile(fs.path.join(b.allocator, &[_][]const u8{
-        cfg.cmake_binary_dir,
-        "zigcpp",
-        b.fmt("{s}{s}{s}", .{ exe.target.libPrefix(), "zigcpp", exe.target.staticLibSuffix() }),
-    }) catch unreachable);
-    assert(cfg.lld_include_dir.len != 0);
-    exe.addIncludeDir(cfg.lld_include_dir);
-    addCMakeLibraryList(exe, cfg.clang_libraries);
-    addCMakeLibraryList(exe, cfg.lld_libraries);
-    addCMakeLibraryList(exe, cfg.llvm_libraries);
-
-    if (use_zig_libcxx) {
-        exe.linkLibCpp();
-    } else {
-        const need_cpp_includes = true;
-
-        // System -lc++ must be used because in this code path we are attempting to link
-        // against system-provided LLVM, Clang, LLD.
-        if (exe.target.getOsTag() == .linux) {
-            // First we try to static link against gcc libstdc++. If that doesn't work,
-            // we fall back to -lc++ and cross our fingers.
-            addCxxKnownPath(b, cfg, exe, "libstdc++.a", "", need_cpp_includes) catch |err| switch (err) {
-                error.RequiredLibraryNotFound => {
-                    exe.linkSystemLibrary("c++");
-                },
-                else => |e| return e,
-            };
-            exe.linkSystemLibrary("unwind");
-        } else if (exe.target.isFreeBSD()) {
-            try addCxxKnownPath(b, cfg, exe, "libc++.a", null, need_cpp_includes);
-            exe.linkSystemLibrary("pthread");
-        } else if (exe.target.getOsTag() == .openbsd) {
-            try addCxxKnownPath(b, cfg, exe, "libc++.a", null, need_cpp_includes);
-            try addCxxKnownPath(b, cfg, exe, "libc++abi.a", null, need_cpp_includes);
-        } else if (exe.target.isDarwin()) {
-            exe.linkSystemLibrary("c++");
-        }
-    }
-
-    if (cfg.dia_guids_lib.len != 0) {
-        exe.addObjectFile(cfg.dia_guids_lib);
-    }
-}
-
-fn addStaticLlvmOptionsToExe(
-    exe: *std.build.LibExeObjStep,
-) !void {
-    // Adds the Zig C++ sources which both stage1 and stage2 need.
-    //
-    // We need this because otherwise zig_clang_cc1_main.cpp ends up pulling
-    // in a dependency on llvm::cfg::Update<llvm::BasicBlock*>::dump() which is
-    // unavailable when LLVM is compiled in Release mode.
-    const zig_cpp_cflags = exe_cflags ++ [_][]const u8{"-DNDEBUG=1"};
-    exe.addCSourceFiles(&zig_cpp_sources, &zig_cpp_cflags);
-
-    for (clang_libs) |lib_name| {
-        exe.linkSystemLibrary(lib_name);
-    }
-
-    for (lld_libs) |lib_name| {
-        exe.linkSystemLibrary(lib_name);
-    }
-
-    for (llvm_libs) |lib_name| {
-        exe.linkSystemLibrary(lib_name);
-    }
-
-    exe.linkSystemLibrary("z");
-
-    // This means we rely on clang-or-zig-built LLVM, Clang, LLD libraries.
-    exe.linkSystemLibrary("c++");
-
-    if (exe.target.getOs().tag == .windows) {
-        exe.linkSystemLibrary("version");
-        exe.linkSystemLibrary("uuid");
-        exe.linkSystemLibrary("ole32");
-    }
-}
-
-fn addCxxKnownPath(
-    b: *Builder,
-    ctx: CMakeConfig,
-    exe: *std.build.LibExeObjStep,
-    objname: []const u8,
-    errtxt: ?[]const u8,
-    need_cpp_includes: bool,
-) !void {
-    const path_padded = try b.exec(&[_][]const u8{
-        ctx.cxx_compiler,
-        b.fmt("-print-file-name={s}", .{objname}),
-    });
-    const path_unpadded = mem.tokenize(u8, path_padded, "\r\n").next().?;
-    if (mem.eql(u8, path_unpadded, objname)) {
-        if (errtxt) |msg| {
-            std.debug.print("{s}", .{msg});
-        } else {
-            std.debug.print("Unable to determine path to {s}\n", .{objname});
-        }
-        return error.RequiredLibraryNotFound;
-    }
-    exe.addObjectFile(path_unpadded);
-
-    // TODO a way to integrate with system c++ include files here
-    // cc -E -Wp,-v -xc++ /dev/null
-    if (need_cpp_includes) {
-        // I used these temporarily for testing something but we obviously need a
-        // more general purpose solution here.
-        //exe.addIncludeDir("/nix/store/fvf3qjqa5qpcjjkq37pb6ypnk1mzhf5h-gcc-9.3.0/lib/gcc/x86_64-unknown-linux-gnu/9.3.0/../../../../include/c++/9.3.0");
-        //exe.addIncludeDir("/nix/store/fvf3qjqa5qpcjjkq37pb6ypnk1mzhf5h-gcc-9.3.0/lib/gcc/x86_64-unknown-linux-gnu/9.3.0/../../../../include/c++/9.3.0/x86_64-unknown-linux-gnu");
-        //exe.addIncludeDir("/nix/store/fvf3qjqa5qpcjjkq37pb6ypnk1mzhf5h-gcc-9.3.0/lib/gcc/x86_64-unknown-linux-gnu/9.3.0/../../../../include/c++/9.3.0/backward");
-    }
-}
-
-fn addCMakeLibraryList(exe: *std.build.LibExeObjStep, list: []const u8) void {
-    var it = mem.tokenize(u8, list, ";");
-    while (it.next()) |lib| {
-        if (mem.startsWith(u8, lib, "-l")) {
-            exe.linkSystemLibrary(lib["-l".len..]);
-        } else {
-            exe.addObjectFile(lib);
-        }
-    }
-}
-
-const CMakeConfig = struct {
-    cmake_binary_dir: []const u8,
-    cmake_prefix_path: []const u8,
-    cxx_compiler: []const u8,
-    lld_include_dir: []const u8,
-    lld_libraries: []const u8,
-    clang_libraries: []const u8,
-    llvm_libraries: []const u8,
-    dia_guids_lib: []const u8,
-};
-
-const max_config_h_bytes = 1 * 1024 * 1024;
-
-fn findAndParseConfigH(b: *Builder, config_h_path_option: ?[]const u8) ?CMakeConfig {
-    const config_h_text: []const u8 = if (config_h_path_option) |config_h_path| blk: {
-        break :blk fs.cwd().readFileAlloc(b.allocator, config_h_path, max_config_h_bytes) catch unreachable;
-    } else blk: {
-        // TODO this should stop looking for config.h once it detects we hit the
-        // zig source root directory.
-        var check_dir = fs.path.dirname(b.zig_exe).?;
-        while (true) {
-            var dir = fs.cwd().openDir(check_dir, .{}) catch unreachable;
-            defer dir.close();
-
-            break :blk dir.readFileAlloc(b.allocator, "config.h", max_config_h_bytes) catch |err| switch (err) {
-                error.FileNotFound => {
-                    const new_check_dir = fs.path.dirname(check_dir);
-                    if (new_check_dir == null or mem.eql(u8, new_check_dir.?, check_dir)) {
-                        return null;
-                    }
-                    check_dir = new_check_dir.?;
-                    continue;
-                },
-                else => unreachable,
-            };
-        } else unreachable; // TODO should not need `else unreachable`.
-    };
-
-    var ctx: CMakeConfig = .{
-        .cmake_binary_dir = undefined,
-        .cmake_prefix_path = undefined,
-        .cxx_compiler = undefined,
-        .lld_include_dir = undefined,
-        .lld_libraries = undefined,
-        .clang_libraries = undefined,
-        .llvm_libraries = undefined,
-        .dia_guids_lib = undefined,
-    };
-
-    const mappings = [_]struct { prefix: []const u8, field: []const u8 }{
-        .{
-            .prefix = "#define ZIG_CMAKE_BINARY_DIR ",
-            .field = "cmake_binary_dir",
-        },
-        .{
-            .prefix = "#define ZIG_CMAKE_PREFIX_PATH ",
-            .field = "cmake_prefix_path",
-        },
-        .{
-            .prefix = "#define ZIG_CXX_COMPILER ",
-            .field = "cxx_compiler",
-        },
-        .{
-            .prefix = "#define ZIG_LLD_INCLUDE_PATH ",
-            .field = "lld_include_dir",
-        },
-        .{
-            .prefix = "#define ZIG_LLD_LIBRARIES ",
-            .field = "lld_libraries",
-        },
-        .{
-            .prefix = "#define ZIG_CLANG_LIBRARIES ",
-            .field = "clang_libraries",
-        },
-        .{
-            .prefix = "#define ZIG_LLVM_LIBRARIES ",
-            .field = "llvm_libraries",
-        },
-        .{
-            .prefix = "#define ZIG_DIA_GUIDS_LIB ",
-            .field = "dia_guids_lib",
-        },
-    };
-
-    var lines_it = mem.tokenize(u8, config_h_text, "\r\n");
-    while (lines_it.next()) |line| {
-        inline for (mappings) |mapping| {
-            if (mem.startsWith(u8, line, mapping.prefix)) {
-                var it = mem.split(u8, line, "\"");
-                _ = it.next().?; // skip the stuff before the quote
-                const quoted = it.next().?; // the stuff inside the quote
-                @field(ctx, mapping.field) = toNativePathSep(b, quoted);
-            }
-        }
-    }
-    return ctx;
-}
-
-fn toNativePathSep(b: *Builder, s: []const u8) []u8 {
-    const duplicated = b.allocator.dupe(u8, s) catch unreachable;
-    for (duplicated) |*byte| switch (byte.*) {
-        '/' => byte.* = fs.path.sep,
-        else => {},
-    };
-    return duplicated;
-}
-
-const softfloat_sources = [_][]const u8{
-    "deps/SoftFloat-3e/source/8086/f128M_isSignalingNaN.c",
-    "deps/SoftFloat-3e/source/8086/extF80M_isSignalingNaN.c",
-    "deps/SoftFloat-3e/source/8086/s_commonNaNToF128M.c",
-    "deps/SoftFloat-3e/source/8086/s_commonNaNToExtF80M.c",
-    "deps/SoftFloat-3e/source/8086/s_commonNaNToF16UI.c",
-    "deps/SoftFloat-3e/source/8086/s_commonNaNToF32UI.c",
-    "deps/SoftFloat-3e/source/8086/s_commonNaNToF64UI.c",
-    "deps/SoftFloat-3e/source/8086/s_f128MToCommonNaN.c",
-    "deps/SoftFloat-3e/source/8086/s_extF80MToCommonNaN.c",
-    "deps/SoftFloat-3e/source/8086/s_f16UIToCommonNaN.c",
-    "deps/SoftFloat-3e/source/8086/s_f32UIToCommonNaN.c",
-    "deps/SoftFloat-3e/source/8086/s_f64UIToCommonNaN.c",
-    "deps/SoftFloat-3e/source/8086/s_propagateNaNF128M.c",
-    "deps/SoftFloat-3e/source/8086/s_propagateNaNExtF80M.c",
-    "deps/SoftFloat-3e/source/8086/s_propagateNaNF16UI.c",
-    "deps/SoftFloat-3e/source/8086/softfloat_raiseFlags.c",
-    "deps/SoftFloat-3e/source/f128M_add.c",
-    "deps/SoftFloat-3e/source/f128M_div.c",
-    "deps/SoftFloat-3e/source/f128M_eq.c",
-    "deps/SoftFloat-3e/source/f128M_eq_signaling.c",
-    "deps/SoftFloat-3e/source/f128M_le.c",
-    "deps/SoftFloat-3e/source/f128M_le_quiet.c",
-    "deps/SoftFloat-3e/source/f128M_lt.c",
-    "deps/SoftFloat-3e/source/f128M_lt_quiet.c",
-    "deps/SoftFloat-3e/source/f128M_mul.c",
-    "deps/SoftFloat-3e/source/f128M_mulAdd.c",
-    "deps/SoftFloat-3e/source/f128M_rem.c",
-    "deps/SoftFloat-3e/source/f128M_roundToInt.c",
-    "deps/SoftFloat-3e/source/f128M_sqrt.c",
-    "deps/SoftFloat-3e/source/f128M_sub.c",
-    "deps/SoftFloat-3e/source/f128M_to_f16.c",
-    "deps/SoftFloat-3e/source/f128M_to_f32.c",
-    "deps/SoftFloat-3e/source/f128M_to_f64.c",
-    "deps/SoftFloat-3e/source/f128M_to_extF80M.c",
-    "deps/SoftFloat-3e/source/f128M_to_i32.c",
-    "deps/SoftFloat-3e/source/f128M_to_i32_r_minMag.c",
-    "deps/SoftFloat-3e/source/f128M_to_i64.c",
-    "deps/SoftFloat-3e/source/f128M_to_i64_r_minMag.c",
-    "deps/SoftFloat-3e/source/f128M_to_ui32.c",
-    "deps/SoftFloat-3e/source/f128M_to_ui32_r_minMag.c",
-    "deps/SoftFloat-3e/source/f128M_to_ui64.c",
-    "deps/SoftFloat-3e/source/f128M_to_ui64_r_minMag.c",
-    "deps/SoftFloat-3e/source/extF80M_add.c",
-    "deps/SoftFloat-3e/source/extF80M_div.c",
-    "deps/SoftFloat-3e/source/extF80M_eq.c",
-    "deps/SoftFloat-3e/source/extF80M_le.c",
-    "deps/SoftFloat-3e/source/extF80M_lt.c",
-    "deps/SoftFloat-3e/source/extF80M_mul.c",
-    "deps/SoftFloat-3e/source/extF80M_rem.c",
-    "deps/SoftFloat-3e/source/extF80M_roundToInt.c",
-    "deps/SoftFloat-3e/source/extF80M_sqrt.c",
-    "deps/SoftFloat-3e/source/extF80M_sub.c",
-    "deps/SoftFloat-3e/source/extF80M_to_f16.c",
-    "deps/SoftFloat-3e/source/extF80M_to_f32.c",
-    "deps/SoftFloat-3e/source/extF80M_to_f64.c",
-    "deps/SoftFloat-3e/source/extF80M_to_f128M.c",
-    "deps/SoftFloat-3e/source/f16_add.c",
-    "deps/SoftFloat-3e/source/f16_div.c",
-    "deps/SoftFloat-3e/source/f16_eq.c",
-    "deps/SoftFloat-3e/source/f16_isSignalingNaN.c",
-    "deps/SoftFloat-3e/source/f16_lt.c",
-    "deps/SoftFloat-3e/source/f16_mul.c",
-    "deps/SoftFloat-3e/source/f16_mulAdd.c",
-    "deps/SoftFloat-3e/source/f16_rem.c",
-    "deps/SoftFloat-3e/source/f16_roundToInt.c",
-    "deps/SoftFloat-3e/source/f16_sqrt.c",
-    "deps/SoftFloat-3e/source/f16_sub.c",
-    "deps/SoftFloat-3e/source/f16_to_extF80M.c",
-    "deps/SoftFloat-3e/source/f16_to_f128M.c",
-    "deps/SoftFloat-3e/source/f16_to_f64.c",
-    "deps/SoftFloat-3e/source/f32_to_extF80M.c",
-    "deps/SoftFloat-3e/source/f32_to_f128M.c",
-    "deps/SoftFloat-3e/source/f64_to_extF80M.c",
-    "deps/SoftFloat-3e/source/f64_to_f128M.c",
-    "deps/SoftFloat-3e/source/f64_to_f16.c",
-    "deps/SoftFloat-3e/source/i32_to_f128M.c",
-    "deps/SoftFloat-3e/source/s_add256M.c",
-    "deps/SoftFloat-3e/source/s_addCarryM.c",
-    "deps/SoftFloat-3e/source/s_addComplCarryM.c",
-    "deps/SoftFloat-3e/source/s_addF128M.c",
-    "deps/SoftFloat-3e/source/s_addExtF80M.c",
-    "deps/SoftFloat-3e/source/s_addM.c",
-    "deps/SoftFloat-3e/source/s_addMagsF16.c",
-    "deps/SoftFloat-3e/source/s_addMagsF32.c",
-    "deps/SoftFloat-3e/source/s_addMagsF64.c",
-    "deps/SoftFloat-3e/source/s_approxRecip32_1.c",
-    "deps/SoftFloat-3e/source/s_approxRecipSqrt32_1.c",
-    "deps/SoftFloat-3e/source/s_approxRecipSqrt_1Ks.c",
-    "deps/SoftFloat-3e/source/s_approxRecip_1Ks.c",
-    "deps/SoftFloat-3e/source/s_compare128M.c",
-    "deps/SoftFloat-3e/source/s_compare96M.c",
-    "deps/SoftFloat-3e/source/s_compareNonnormExtF80M.c",
-    "deps/SoftFloat-3e/source/s_countLeadingZeros16.c",
-    "deps/SoftFloat-3e/source/s_countLeadingZeros32.c",
-    "deps/SoftFloat-3e/source/s_countLeadingZeros64.c",
-    "deps/SoftFloat-3e/source/s_countLeadingZeros8.c",
-    "deps/SoftFloat-3e/source/s_eq128.c",
-    "deps/SoftFloat-3e/source/s_invalidF128M.c",
-    "deps/SoftFloat-3e/source/s_invalidExtF80M.c",
-    "deps/SoftFloat-3e/source/s_isNaNF128M.c",
-    "deps/SoftFloat-3e/source/s_le128.c",
-    "deps/SoftFloat-3e/source/s_lt128.c",
-    "deps/SoftFloat-3e/source/s_mul128MTo256M.c",
-    "deps/SoftFloat-3e/source/s_mul64To128M.c",
-    "deps/SoftFloat-3e/source/s_mulAddF128M.c",
-    "deps/SoftFloat-3e/source/s_mulAddF16.c",
-    "deps/SoftFloat-3e/source/s_mulAddF32.c",
-    "deps/SoftFloat-3e/source/s_mulAddF64.c",
-    "deps/SoftFloat-3e/source/s_negXM.c",
-    "deps/SoftFloat-3e/source/s_normExtF80SigM.c",
-    "deps/SoftFloat-3e/source/s_normRoundPackMToF128M.c",
-    "deps/SoftFloat-3e/source/s_normRoundPackMToExtF80M.c",
-    "deps/SoftFloat-3e/source/s_normRoundPackToF16.c",
-    "deps/SoftFloat-3e/source/s_normRoundPackToF32.c",
-    "deps/SoftFloat-3e/source/s_normRoundPackToF64.c",
-    "deps/SoftFloat-3e/source/s_normSubnormalF128SigM.c",
-    "deps/SoftFloat-3e/source/s_normSubnormalF16Sig.c",
-    "deps/SoftFloat-3e/source/s_normSubnormalF32Sig.c",
-    "deps/SoftFloat-3e/source/s_normSubnormalF64Sig.c",
-    "deps/SoftFloat-3e/source/s_remStepMBy32.c",
-    "deps/SoftFloat-3e/source/s_roundMToI64.c",
-    "deps/SoftFloat-3e/source/s_roundMToUI64.c",
-    "deps/SoftFloat-3e/source/s_roundPackMToExtF80M.c",
-    "deps/SoftFloat-3e/source/s_roundPackMToF128M.c",
-    "deps/SoftFloat-3e/source/s_roundPackToF16.c",
-    "deps/SoftFloat-3e/source/s_roundPackToF32.c",
-    "deps/SoftFloat-3e/source/s_roundPackToF64.c",
-    "deps/SoftFloat-3e/source/s_roundToI32.c",
-    "deps/SoftFloat-3e/source/s_roundToI64.c",
-    "deps/SoftFloat-3e/source/s_roundToUI32.c",
-    "deps/SoftFloat-3e/source/s_roundToUI64.c",
-    "deps/SoftFloat-3e/source/s_shiftLeftM.c",
-    "deps/SoftFloat-3e/source/s_shiftNormSigF128M.c",
-    "deps/SoftFloat-3e/source/s_shiftRightJam256M.c",
-    "deps/SoftFloat-3e/source/s_shiftRightJam32.c",
-    "deps/SoftFloat-3e/source/s_shiftRightJam64.c",
-    "deps/SoftFloat-3e/source/s_shiftRightJamM.c",
-    "deps/SoftFloat-3e/source/s_shiftRightM.c",
-    "deps/SoftFloat-3e/source/s_shortShiftLeft64To96M.c",
-    "deps/SoftFloat-3e/source/s_shortShiftLeftM.c",
-    "deps/SoftFloat-3e/source/s_shortShiftRightExtendM.c",
-    "deps/SoftFloat-3e/source/s_shortShiftRightJam64.c",
-    "deps/SoftFloat-3e/source/s_shortShiftRightJamM.c",
-    "deps/SoftFloat-3e/source/s_shortShiftRightM.c",
-    "deps/SoftFloat-3e/source/s_sub1XM.c",
-    "deps/SoftFloat-3e/source/s_sub256M.c",
-    "deps/SoftFloat-3e/source/s_subM.c",
-    "deps/SoftFloat-3e/source/s_subMagsF16.c",
-    "deps/SoftFloat-3e/source/s_subMagsF32.c",
-    "deps/SoftFloat-3e/source/s_subMagsF64.c",
-    "deps/SoftFloat-3e/source/s_tryPropagateNaNF128M.c",
-    "deps/SoftFloat-3e/source/s_tryPropagateNaNExtF80M.c",
-    "deps/SoftFloat-3e/source/softfloat_state.c",
-    "deps/SoftFloat-3e/source/ui32_to_f128M.c",
-    "deps/SoftFloat-3e/source/ui64_to_f128M.c",
-    "deps/SoftFloat-3e/source/ui32_to_extF80M.c",
-    "deps/SoftFloat-3e/source/ui64_to_extF80M.c",
-};
-
-const stage1_sources = [_][]const u8{
-    "src/stage1/analyze.cpp",
-    "src/stage1/astgen.cpp",
-    "src/stage1/bigfloat.cpp",
-    "src/stage1/bigint.cpp",
-    "src/stage1/buffer.cpp",
-    "src/stage1/codegen.cpp",
-    "src/stage1/errmsg.cpp",
-    "src/stage1/error.cpp",
-    "src/stage1/heap.cpp",
-    "src/stage1/ir.cpp",
-    "src/stage1/ir_print.cpp",
-    "src/stage1/mem.cpp",
-    "src/stage1/os.cpp",
-    "src/stage1/parser.cpp",
-    "src/stage1/range_set.cpp",
-    "src/stage1/stage1.cpp",
-    "src/stage1/target.cpp",
-    "src/stage1/tokenizer.cpp",
-    "src/stage1/util.cpp",
-    "src/stage1/softfloat_ext.cpp",
-};
-const optimized_c_sources = [_][]const u8{
-    "src/stage1/parse_f128.c",
-};
-const zig_cpp_sources = [_][]const u8{
-    // These are planned to stay even when we are self-hosted.
-    "src/zig_llvm.cpp",
-    "src/zig_clang.cpp",
-    "src/zig_llvm-ar.cpp",
-    "src/zig_clang_driver.cpp",
-    "src/zig_clang_cc1_main.cpp",
-    "src/zig_clang_cc1as_main.cpp",
-    // https://github.com/ziglang/zig/issues/6363
-    "src/windows_sdk.cpp",
-};
-
-const clang_libs = [_][]const u8{
-    "clangFrontendTool",
-    "clangCodeGen",
-    "clangFrontend",
-    "clangDriver",
-    "clangSerialization",
-    "clangSema",
-    "clangStaticAnalyzerFrontend",
-    "clangStaticAnalyzerCheckers",
-    "clangStaticAnalyzerCore",
-    "clangAnalysis",
-    "clangASTMatchers",
-    "clangAST",
-    "clangParse",
-    "clangSema",
-    "clangBasic",
-    "clangEdit",
-    "clangLex",
-    "clangARCMigrate",
-    "clangRewriteFrontend",
-    "clangRewrite",
-    "clangCrossTU",
-    "clangIndex",
-    "clangToolingCore",
-};
-const lld_libs = [_][]const u8{
-    "lldMinGW",
-    "lldELF",
-    "lldCOFF",
-    "lldWasm",
-    "lldMachO",
-    "lldCommon",
-};
-// This list can be re-generated with `llvm-config --libfiles` and then
-// reformatting using your favorite text editor. Note we do not execute
-// `llvm-config` here because we are cross compiling. Also omit LLVMTableGen
-// from these libs.
-const llvm_libs = [_][]const u8{
-    "LLVMWindowsManifest",
-    "LLVMXRay",
-    "LLVMLibDriver",
-    "LLVMDlltoolDriver",
-    "LLVMCoverage",
-    "LLVMLineEditor",
-    "LLVMXCoreDisassembler",
-    "LLVMXCoreCodeGen",
-    "LLVMXCoreDesc",
-    "LLVMXCoreInfo",
-    "LLVMX86TargetMCA",
-    "LLVMX86Disassembler",
-    "LLVMX86AsmParser",
-    "LLVMX86CodeGen",
-    "LLVMX86Desc",
-    "LLVMX86Info",
-    "LLVMWebAssemblyDisassembler",
-    "LLVMWebAssemblyAsmParser",
-    "LLVMWebAssemblyCodeGen",
-    "LLVMWebAssemblyDesc",
-    "LLVMWebAssemblyUtils",
-    "LLVMWebAssemblyInfo",
-    "LLVMVEDisassembler",
-    "LLVMVEAsmParser",
-    "LLVMVECodeGen",
-    "LLVMVEDesc",
-    "LLVMVEInfo",
-    "LLVMSystemZDisassembler",
-    "LLVMSystemZAsmParser",
-    "LLVMSystemZCodeGen",
-    "LLVMSystemZDesc",
-    "LLVMSystemZInfo",
-    "LLVMSparcDisassembler",
-    "LLVMSparcAsmParser",
-    "LLVMSparcCodeGen",
-    "LLVMSparcDesc",
-    "LLVMSparcInfo",
-    "LLVMRISCVDisassembler",
-    "LLVMRISCVAsmParser",
-    "LLVMRISCVCodeGen",
-    "LLVMRISCVDesc",
-    "LLVMRISCVInfo",
-    "LLVMPowerPCDisassembler",
-    "LLVMPowerPCAsmParser",
-    "LLVMPowerPCCodeGen",
-    "LLVMPowerPCDesc",
-    "LLVMPowerPCInfo",
-    "LLVMNVPTXCodeGen",
-    "LLVMNVPTXDesc",
-    "LLVMNVPTXInfo",
-    "LLVMMSP430Disassembler",
-    "LLVMMSP430AsmParser",
-    "LLVMMSP430CodeGen",
-    "LLVMMSP430Desc",
-    "LLVMMSP430Info",
-    "LLVMMipsDisassembler",
-    "LLVMMipsAsmParser",
-    "LLVMMipsCodeGen",
-    "LLVMMipsDesc",
-    "LLVMMipsInfo",
-    "LLVMLanaiDisassembler",
-    "LLVMLanaiCodeGen",
-    "LLVMLanaiAsmParser",
-    "LLVMLanaiDesc",
-    "LLVMLanaiInfo",
-    "LLVMHexagonDisassembler",
-    "LLVMHexagonCodeGen",
-    "LLVMHexagonAsmParser",
-    "LLVMHexagonDesc",
-    "LLVMHexagonInfo",
-    "LLVMBPFDisassembler",
-    "LLVMBPFAsmParser",
-    "LLVMBPFCodeGen",
-    "LLVMBPFDesc",
-    "LLVMBPFInfo",
-    "LLVMAVRDisassembler",
-    "LLVMAVRAsmParser",
-    "LLVMAVRCodeGen",
-    "LLVMAVRDesc",
-    "LLVMAVRInfo",
-    "LLVMARMDisassembler",
-    "LLVMARMAsmParser",
-    "LLVMARMCodeGen",
-    "LLVMARMDesc",
-    "LLVMARMUtils",
-    "LLVMARMInfo",
-    "LLVMAMDGPUTargetMCA",
-    "LLVMAMDGPUDisassembler",
-    "LLVMAMDGPUAsmParser",
-    "LLVMAMDGPUCodeGen",
-    "LLVMAMDGPUDesc",
-    "LLVMAMDGPUUtils",
-    "LLVMAMDGPUInfo",
-    "LLVMAArch64Disassembler",
-    "LLVMAArch64AsmParser",
-    "LLVMAArch64CodeGen",
-    "LLVMAArch64Desc",
-    "LLVMAArch64Utils",
-    "LLVMAArch64Info",
-    "LLVMOrcJIT",
-    "LLVMMCJIT",
-    "LLVMJITLink",
-    "LLVMInterpreter",
-    "LLVMExecutionEngine",
-    "LLVMRuntimeDyld",
-    "LLVMOrcTargetProcess",
-    "LLVMOrcShared",
-    "LLVMDWP",
-    "LLVMSymbolize",
-    "LLVMDebugInfoPDB",
-    "LLVMDebugInfoGSYM",
-    "LLVMOption",
-    "LLVMObjectYAML",
-    "LLVMMCA",
-    "LLVMMCDisassembler",
-    "LLVMLTO",
-    "LLVMPasses",
-    "LLVMCFGuard",
-    "LLVMCoroutines",
-    "LLVMObjCARCOpts",
-    "LLVMipo",
-    "LLVMVectorize",
-    "LLVMLinker",
-    "LLVMInstrumentation",
-    "LLVMFrontendOpenMP",
-    "LLVMFrontendOpenACC",
-    "LLVMExtensions",
-    "LLVMDWARFLinker",
-    "LLVMGlobalISel",
-    "LLVMMIRParser",
-    "LLVMAsmPrinter",
-    "LLVMDebugInfoMSF",
-    "LLVMSelectionDAG",
-    "LLVMCodeGen",
-    "LLVMIRReader",
-    "LLVMAsmParser",
-    "LLVMInterfaceStub",
-    "LLVMFileCheck",
-    "LLVMFuzzMutate",
-    "LLVMTarget",
-    "LLVMScalarOpts",
-    "LLVMInstCombine",
-    "LLVMAggressiveInstCombine",
-    "LLVMTransformUtils",
-    "LLVMBitWriter",
-    "LLVMAnalysis",
-    "LLVMProfileData",
-    "LLVMDebugInfoDWARF",
-    "LLVMObject",
-    "LLVMTextAPI",
-    "LLVMMCParser",
-    "LLVMMC",
-    "LLVMDebugInfoCodeView",
-    "LLVMBitReader",
-    "LLVMCore",
-    "LLVMRemarks",
-    "LLVMBitstreamReader",
-    "LLVMBinaryFormat",
-    "LLVMSupport",
-    "LLVMDemangle",
-};
diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index 730ecbda23d5b041480a5776a8d4bf0d6ccec4c9..090c133e63ee0b353466ea5a4fc26b2f058ca92d 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -27,7 +27,7 @@ jobs:
     vmImage: 'windows-2019'
   variables:
     TARGET: 'x86_64-windows-gnu'
-    ZIG_LLVM_CLANG_LLD_NAME: 'zig+llvm+lld+clang-${{ variables.TARGET }}-0.10.0-dev.3524+74673b7f6'
+    ZIG_LLVM_CLANG_LLD_NAME: 'zig+llvm+lld+clang-${{ variables.TARGET }}-0.10.0-dev.3619+21f5d73cf'
     ZIG_LLVM_CLANG_LLD_URL: 'https://ziglang.org/deps/${{ variables.ZIG_LLVM_CLANG_LLD_NAME }}.zip'
   steps:
   - pwsh: |
@@ -59,16 +59,16 @@ jobs:
       mkdir $ZIGBUILDDIR
       cd $ZIGBUILDDIR
 
-      & "${ZIGPREFIXPATH}/bin/zig.exe" build `
+      & "$ZIGPREFIXPATH\bin\zig.exe" build `
         --prefix "$ZIGINSTALLDIR" `
         --search-prefix "$ZIGPREFIXPATH" `
+        --zig-lib-dir "..\lib" `
         -Denable-stage1 `
         -Dstatic-llvm `
         -Drelease `
         -Dstrip `
         -Duse-zig-libcxx `
-        -Dtarget=$(TARGET) `
-        -fno-stage1
+        -Dtarget=$(TARGET)
       CheckLastExitCode
 
       cd -
-- 
2.54.0


From c4466496ffb53fe83644ea2b0e43f9f46a3361b8 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 17 Aug 2022 22:17:19 -0700
Subject: [PATCH 183/290] build: hook up -Dskip-stage2-tests and remove
 test-toolchain

---
 build.zig              | 48 +++++++++++++++++++-----------------------
 ci/azure/pipelines.yml |  3 ++-
 test/tests.zig         |  6 ++++++
 3 files changed, 30 insertions(+), 27 deletions(-)

diff --git a/build.zig b/build.zig
index bb3db637d63c017ec1a6f2467fe72bcb3fe5ae35..c8e757dc4ea056f27b968a23050d1511271efbc5 100644
--- a/build.zig
+++ b/build.zig
@@ -15,6 +15,7 @@ const stack_size = 32 * 1024 * 1024;
 
 pub fn build(b: *Builder) !void {
     b.setPreferredReleaseMode(.ReleaseFast);
+    const test_step = b.step("test", "Run all the tests");
     const mode = b.standardReleaseOptions();
     const target = b.standardTargetOptions(.{});
     const single_threaded = b.option(bool, "single-threaded", "Build artifacts that run in single threaded mode");
@@ -39,8 +40,6 @@ pub fn build(b: *Builder) !void {
     const docs_step = b.step("docs", "Build documentation");
     docs_step.dependOn(&docgen_cmd.step);
 
-    const toolchain_step = b.step("test-toolchain", "Run the tests for the toolchain");
-
     var test_cases = b.addTest("src/test.zig");
     test_cases.stack_size = stack_size;
     test_cases.setBuildMode(mode);
@@ -149,7 +148,7 @@ pub fn build(b: *Builder) !void {
     exe.setBuildMode(mode);
     exe.setTarget(target);
     if (!skip_stage2_tests) {
-        toolchain_step.dependOn(&exe.step);
+        test_step.dependOn(&exe.step);
     }
 
     b.default_step.dependOn(&exe.step);
@@ -415,7 +414,7 @@ pub fn build(b: *Builder) !void {
     const test_cases_step = b.step("test-cases", "Run the main compiler test cases");
     test_cases_step.dependOn(&test_cases.step);
     if (!skip_stage2_tests) {
-        toolchain_step.dependOn(test_cases_step);
+        test_step.dependOn(test_cases_step);
     }
 
     var chosen_modes: [4]builtin.Mode = undefined;
@@ -439,11 +438,11 @@ pub fn build(b: *Builder) !void {
     const modes = chosen_modes[0..chosen_mode_index];
 
     // run stage1 `zig fmt` on this build.zig file just to make sure it works
-    toolchain_step.dependOn(&fmt_build_zig.step);
+    test_step.dependOn(&fmt_build_zig.step);
     const fmt_step = b.step("test-fmt", "Run zig fmt against build.zig to make sure it works");
     fmt_step.dependOn(&fmt_build_zig.step);
 
-    toolchain_step.dependOn(tests.addPkgTests(
+    test_step.dependOn(tests.addPkgTests(
         b,
         test_filter,
         "test/behavior.zig",
@@ -454,10 +453,10 @@ pub fn build(b: *Builder) !void {
         skip_non_native,
         skip_libc,
         skip_stage1,
-        false,
+        skip_stage2_tests,
     ));
 
-    toolchain_step.dependOn(tests.addPkgTests(
+    test_step.dependOn(tests.addPkgTests(
         b,
         test_filter,
         "lib/compiler_rt.zig",
@@ -468,10 +467,10 @@ pub fn build(b: *Builder) !void {
         skip_non_native,
         true, // skip_libc
         skip_stage1,
-        true, // TODO get these all passing
+        skip_stage2_tests or true, // TODO get these all passing
     ));
 
-    toolchain_step.dependOn(tests.addPkgTests(
+    test_step.dependOn(tests.addPkgTests(
         b,
         test_filter,
         "lib/c.zig",
@@ -482,35 +481,36 @@ pub fn build(b: *Builder) !void {
         skip_non_native,
         true, // skip_libc
         skip_stage1,
-        true, // TODO get these all passing
+        skip_stage2_tests or true, // TODO get these all passing
     ));
 
-    toolchain_step.dependOn(tests.addCompareOutputTests(b, test_filter, modes));
-    toolchain_step.dependOn(tests.addStandaloneTests(
+    test_step.dependOn(tests.addCompareOutputTests(b, test_filter, modes));
+    test_step.dependOn(tests.addStandaloneTests(
         b,
         test_filter,
         modes,
         skip_non_native,
         enable_macos_sdk,
         target,
+        skip_stage2_tests,
         b.enable_darling,
         b.enable_qemu,
         b.enable_rosetta,
         b.enable_wasmtime,
         b.enable_wine,
     ));
-    toolchain_step.dependOn(tests.addLinkTests(b, test_filter, modes, enable_macos_sdk));
-    toolchain_step.dependOn(tests.addStackTraceTests(b, test_filter, modes));
-    toolchain_step.dependOn(tests.addCliTests(b, test_filter, modes));
-    toolchain_step.dependOn(tests.addAssembleAndLinkTests(b, test_filter, modes));
-    toolchain_step.dependOn(tests.addTranslateCTests(b, test_filter));
+    test_step.dependOn(tests.addLinkTests(b, test_filter, modes, enable_macos_sdk, skip_stage2_tests));
+    test_step.dependOn(tests.addStackTraceTests(b, test_filter, modes));
+    test_step.dependOn(tests.addCliTests(b, test_filter, modes));
+    test_step.dependOn(tests.addAssembleAndLinkTests(b, test_filter, modes));
+    test_step.dependOn(tests.addTranslateCTests(b, test_filter));
     if (!skip_run_translated_c) {
-        toolchain_step.dependOn(tests.addRunTranslatedCTests(b, test_filter, target));
+        test_step.dependOn(tests.addRunTranslatedCTests(b, test_filter, target));
     }
     // tests for this feature are disabled until we have the self-hosted compiler available
-    // toolchain_step.dependOn(tests.addGenHTests(b, test_filter));
+    // test_step.dependOn(tests.addGenHTests(b, test_filter));
 
-    const std_step = tests.addPkgTests(
+    test_step.dependOn(tests.addPkgTests(
         b,
         test_filter,
         "lib/std/std.zig",
@@ -522,11 +522,7 @@ pub fn build(b: *Builder) !void {
         skip_libc,
         skip_stage1,
         true, // TODO get these all passing
-    );
-
-    const test_step = b.step("test", "Run all the tests");
-    test_step.dependOn(toolchain_step);
-    test_step.dependOn(std_step);
+    ));
 }
 
 const exe_cflags = [_][]const u8{
diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index 090c133e63ee0b353466ea5a4fc26b2f058ca92d..e6b65233bd5d243c87a5aab4bb50b303da7c855d 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -88,7 +88,8 @@ jobs:
       & "$ZIGINSTALLDIR\bin\zig.exe" build test `
         --search-prefix "$ZIGPREFIXPATH" `
         -Dstatic-llvm `
-        -Dskip-non-native
+        -Dskip-non-native `
+        -Dskip-stage2-tests
       CheckLastExitCode
 
     name: test
diff --git a/test/tests.zig b/test/tests.zig
index bd3c1c5dec399c913a0724d0596dd54df74b0d89..5a58daecaa7c714ec704cd380139ff9d00e497e4 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -462,6 +462,7 @@ pub fn addStandaloneTests(
     skip_non_native: bool,
     enable_macos_sdk: bool,
     target: std.zig.CrossTarget,
+    omit_stage2: bool,
     enable_darling: bool,
     enable_qemu: bool,
     enable_rosetta: bool,
@@ -478,6 +479,7 @@ pub fn addStandaloneTests(
         .skip_non_native = skip_non_native,
         .enable_macos_sdk = enable_macos_sdk,
         .target = target,
+        .omit_stage2 = omit_stage2,
         .enable_darling = enable_darling,
         .enable_qemu = enable_qemu,
         .enable_rosetta = enable_rosetta,
@@ -495,6 +497,7 @@ pub fn addLinkTests(
     test_filter: ?[]const u8,
     modes: []const Mode,
     enable_macos_sdk: bool,
+    omit_stage2: bool,
 ) *build.Step {
     const cases = b.allocator.create(StandaloneContext) catch unreachable;
     cases.* = StandaloneContext{
@@ -506,6 +509,7 @@ pub fn addLinkTests(
         .skip_non_native = true,
         .enable_macos_sdk = enable_macos_sdk,
         .target = .{},
+        .omit_stage2 = omit_stage2,
     };
     link.addCases(cases);
     return cases.step;
@@ -973,6 +977,7 @@ pub const StandaloneContext = struct {
     skip_non_native: bool,
     enable_macos_sdk: bool,
     target: std.zig.CrossTarget,
+    omit_stage2: bool,
     enable_darling: bool = false,
     enable_qemu: bool = false,
     enable_rosetta: bool = false,
@@ -997,6 +1002,7 @@ pub const StandaloneContext = struct {
         const b = self.b;
 
         if (features.requires_macos_sdk and !self.enable_macos_sdk) return;
+        if (features.requires_stage2 and self.omit_stage2) return;
 
         const annotated_case_name = b.fmt("build {s}", .{build_file});
         if (self.test_filter) |filter| {
-- 
2.54.0


From 35f62bc7aeca5c84f4ddda5736ce902018d23964 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 17 Aug 2022 23:34:57 -0700
Subject: [PATCH 184/290] CI: windows: don't create build directory

Simplify the script by not creating an unnecessary build directory and
then changing directories to and from it.
---
 ci/azure/pipelines.yml | 52 ++++++++++++------------------------------
 1 file changed, 14 insertions(+), 38 deletions(-)

diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index e6b65233bd5d243c87a5aab4bb50b303da7c855d..26befaae79bcf87078b412de18b43a4e5a85667b 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -37,8 +37,8 @@ jobs:
     displayName: 'Install ZIG/LLVM/CLANG/LLD'
 
   - pwsh: |
-      Set-Variable -Name ZIGBUILDDIR -Value "$(Get-Location)\build"
-      Set-Variable -Name ZIGINSTALLDIR -Value "${ZIGBUILDDIR}\dist"
+      Set-Variable -Name ZIGLIBDIR -Value "$(Get-Location)\lib"
+      Set-Variable -Name ZIGINSTALLDIR -Value "$(Get-Location)\stage3-release"
       Set-Variable -Name ZIGPREFIXPATH -Value "$(Get-Location)\$(ZIG_LLVM_CLANG_LLD_NAME)"
 
       function CheckLastExitCode {
@@ -56,13 +56,10 @@ jobs:
         git fetch --unshallow # `git describe` won't work on a shallow repo
       }
 
-      mkdir $ZIGBUILDDIR
-      cd $ZIGBUILDDIR
-
       & "$ZIGPREFIXPATH\bin\zig.exe" build `
         --prefix "$ZIGINSTALLDIR" `
         --search-prefix "$ZIGPREFIXPATH" `
-        --zig-lib-dir "..\lib" `
+        --zig-lib-dir "$ZIGLIBDIR" `
         -Denable-stage1 `
         -Dstatic-llvm `
         -Drelease `
@@ -70,13 +67,11 @@ jobs:
         -Duse-zig-libcxx `
         -Dtarget=$(TARGET)
       CheckLastExitCode
-
-      cd -
     name: build
     displayName: 'Build'
 
   - pwsh: |
-      Set-Variable -Name ZIGINSTALLDIR -Value "$(Get-Location)\build\dist"
+      Set-Variable -Name ZIGINSTALLDIR -Value "$(Get-Location)\stage3-release"
 
       function CheckLastExitCode {
         if (!$?) {
@@ -85,39 +80,21 @@ jobs:
         return 0
       }
 
-      & "$ZIGINSTALLDIR\bin\zig.exe" build test `
+      & "$ZIGINSTALLDIR\bin\zig.exe" build test docs `
         --search-prefix "$ZIGPREFIXPATH" `
         -Dstatic-llvm `
         -Dskip-non-native `
         -Dskip-stage2-tests
       CheckLastExitCode
-
     name: test
     displayName: 'Test'
 
-  - pwsh: |
-      Set-Variable -Name ZIGINSTALLDIR -Value "$(Get-Location)\build\dist"
-
-      function CheckLastExitCode {
-        if (!$?) {
-          exit 1
-        }
-        return 0
-      }
-
-      & "$ZIGINSTALLDIR\bin\zig.exe" build docs
-      CheckLastExitCode
-    timeoutInMinutes: 60
-    name: doc
-    displayName: 'Documentation'
-
   - task: DownloadSecureFile@1
     inputs:
       name: aws_credentials
       secureFile: aws_credentials
 
   - pwsh: |
-      Set-Variable -Name ZIGBUILDDIR -Value "$(Get-Location)\build"
       $Env:AWS_SHARED_CREDENTIALS_FILE = "$Env:DOWNLOADSECUREFILE_SECUREFILEPATH"
 
       # Workaround Azure networking issue
@@ -125,21 +102,20 @@ jobs:
       $Env:AWS_EC2_METADATA_DISABLED = "true"
       $Env:AWS_REGION = "us-west-2"
 
-      cd "$ZIGBUILDDIR"
-      mv ../LICENSE dist/
-      mv ../zig-cache/langref.html dist/
-      mv dist/bin/zig.exe dist/
-      rmdir dist/bin
+      mv LICENSE stage3-release/
+      mv zig-cache/langref.html stage3-release/
+      mv stage3-release/bin/zig.exe stage3-release/
+      rmdir stage3-release/bin
 
       # Remove the unnecessary zig dir in $prefix/lib/zig/std/std.zig
-      mv dist/lib/zig dist/lib2
-      rmdir dist/lib
-      mv dist/lib2 dist/lib
+      mv stage3-release/lib/zig stage3-release/lib2
+      rmdir stage3-release/lib
+      mv stage3-release/lib2 stage3-release/lib
 
-      Set-Variable -Name VERSION -Value $(./dist/zig.exe version)
+      Set-Variable -Name VERSION -Value $(./stage3-release/zig.exe version)
       Set-Variable -Name DIRNAME -Value "zig-windows-x86_64-$VERSION"
       Set-Variable -Name TARBALL -Value "$DIRNAME.zip"
-      mv dist "$DIRNAME"
+      mv stage3-release "$DIRNAME"
       7z a "$TARBALL" "$DIRNAME"
 
       aws s3 cp `
-- 
2.54.0


From 437311756d88984d9bf3057d9cd93986c15434fa Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 18 Aug 2022 10:49:09 -0700
Subject: [PATCH 185/290] LLVM: add DLL export attribute

This was present in stage1 but missing from self-hosted.
---
 src/Compilation.zig           | 2 +-
 src/Module.zig                | 4 ++++
 src/codegen/llvm.zig          | 3 +++
 src/codegen/llvm/bindings.zig | 9 +++++++++
 4 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 84dd2739470a4b3bb0f387832cbdf2fcd76c9869..0914685c77f6fa3d3905ef56e5519789f4f8c236 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -1231,7 +1231,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             break :blk lm;
         } else default_link_mode;
 
-        const dll_export_fns = if (options.dll_export_fns) |explicit| explicit else is_dyn_lib or options.rdynamic;
+        const dll_export_fns = options.dll_export_fns orelse (is_dyn_lib or options.rdynamic);
 
         const libc_dirs = try detectLibCIncludeDirs(
             arena,
diff --git a/src/Module.zig b/src/Module.zig
index 3ae61c264feafa4203595114b77fd5cc14cc3c73..3577115ded112fef1461dc540b8eedc8fa47086c 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -6529,3 +6529,7 @@ pub fn addGlobalAssembly(mod: *Module, decl_index: Decl.Index, source: []const u
 
     mod.global_assembly.putAssumeCapacityNoClobber(decl_index, duped_source);
 }
+
+pub fn wantDllExports(mod: Module) bool {
+    return mod.comp.bin_file.options.dll_export_fns and mod.getTarget().os.tag == .windows;
+}
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 0898c8fe87c6a79df5e4567276f15ea952dc1245..d50b463606c190f6d2756267c940235f15c857f6 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1103,6 +1103,7 @@ pub const Object = struct {
             }
             llvm_global.setUnnamedAddr(.False);
             llvm_global.setLinkage(.External);
+            if (module.wantDllExports()) llvm_global.setDLLStorageClass(.Default);
             if (self.di_map.get(decl)) |di_node| {
                 if (try decl.isFunction()) {
                     const di_func = @ptrCast(*llvm.DISubprogram, di_node);
@@ -1128,6 +1129,7 @@ pub const Object = struct {
             const exp_name = exports[0].options.name;
             llvm_global.setValueName2(exp_name.ptr, exp_name.len);
             llvm_global.setUnnamedAddr(.False);
+            if (module.wantDllExports()) llvm_global.setDLLStorageClass(.DLLExport);
             if (self.di_map.get(decl)) |di_node| {
                 if (try decl.isFunction()) {
                     const di_func = @ptrCast(*llvm.DISubprogram, di_node);
@@ -1187,6 +1189,7 @@ pub const Object = struct {
             defer module.gpa.free(fqn);
             llvm_global.setValueName2(fqn.ptr, fqn.len);
             llvm_global.setLinkage(.Internal);
+            if (module.wantDllExports()) llvm_global.setDLLStorageClass(.Default);
             llvm_global.setUnnamedAddr(.True);
             if (decl.val.castTag(.variable)) |variable| {
                 const single_threaded = module.comp.bin_file.options.single_threaded;
diff --git a/src/codegen/llvm/bindings.zig b/src/codegen/llvm/bindings.zig
index 9daa96eb8ff0397c4e04e801ca60e8d13b71eaec..38f794cfda8413b8d41bd87b56377c6aafe27938 100644
--- a/src/codegen/llvm/bindings.zig
+++ b/src/codegen/llvm/bindings.zig
@@ -223,6 +223,9 @@ pub const Value = opaque {
     pub const setInitializer = LLVMSetInitializer;
     extern fn LLVMSetInitializer(GlobalVar: *const Value, ConstantVal: *const Value) void;
 
+    pub const setDLLStorageClass = LLVMSetDLLStorageClass;
+    extern fn LLVMSetDLLStorageClass(Global: *const Value, Class: DLLStorageClass) void;
+
     pub const addCase = LLVMAddCase;
     extern fn LLVMAddCase(Switch: *const Value, OnVal: *const Value, Dest: *const BasicBlock) void;
 
@@ -1482,6 +1485,12 @@ pub const CallAttr = enum(c_int) {
     AlwaysInline,
 };
 
+pub const DLLStorageClass = enum(c_uint) {
+    Default,
+    DLLImport,
+    DLLExport,
+};
+
 pub const address_space = struct {
     pub const default: c_uint = 0;
 
-- 
2.54.0


From 10b95d89f878c8ba780f573d65604ef79d6cbd9a Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Thu, 18 Aug 2022 23:26:45 +0200
Subject: [PATCH 186/290] coff: change improperly used packed struct into
 extern struct

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

diff --git a/lib/std/coff.zig b/lib/std/coff.zig
index 7c077a9ec850951ecc4f81c2fa7aade0e65f1ddd..4371444b968fb07021619963e1c8a543bfce650c 100644
--- a/lib/std/coff.zig
+++ b/lib/std/coff.zig
@@ -383,7 +383,7 @@ const OptionalHeader = struct {
     image_base: u64,
 };
 
-const DebugDirectoryEntry = packed struct {
+const DebugDirectoryEntry = extern struct {
     characteristiccs: u32,
     time_date_stamp: u32,
     major_version: u16,
-- 
2.54.0


From a85f41ec2c38eff7e64ba32c76c5a60b48274a8a Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 18 Aug 2022 19:40:08 -0700
Subject: [PATCH 187/290] test-stack-traces: relax parsing rules

 * accept forward and backward slashes in file paths
 * strip multiple extensions; e.g. if the basename is "test.exe.obj"
   then it strips to "test".
---
 test/tests.zig | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/tests.zig b/test/tests.zig
index 5a58daecaa7c714ec704cd380139ff9d00e497e4..a622521182edaa6472268baa1257b179c17c65d3 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -923,7 +923,7 @@ pub const StackTracesContext = struct {
                         pos = marks[i] + delim.len;
                     }
                     // locate source basename
-                    pos = mem.lastIndexOfScalar(u8, line[0..marks[0]], fs.path.sep) orelse {
+                    pos = mem.lastIndexOfAny(u8, line[0..marks[0]], "\\/") orelse {
                         // unexpected pattern: emit raw line and cont
                         try buf.appendSlice(line);
                         try buf.appendSlice("\n");
@@ -935,9 +935,9 @@ pub const StackTracesContext = struct {
                     try buf.appendSlice(line[pos + 1 .. marks[2] + delims[2].len]);
                     try buf.appendSlice(" [address]");
                     if (self.mode == .Debug) {
-                        if (mem.lastIndexOfScalar(u8, line[marks[4]..marks[5]], '.')) |idot| {
-                            // On certain platforms (windows) or possibly depending on how we choose to link main
-                            // the object file extension may be present so we simply strip any extension.
+                        // On certain platforms (windows) or possibly depending on how we choose to link main
+                        // the object file extension may be present so we simply strip any extension.
+                        if (mem.indexOfScalar(u8, line[marks[4]..marks[5]], '.')) |idot| {
                             try buf.appendSlice(line[marks[3] .. marks[4] + idot]);
                             try buf.appendSlice(line[marks[5]..]);
                         } else {
-- 
2.54.0


From 4a27d2aac673751142b16ab78434c6978311e706 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 19 Aug 2022 16:25:09 -0700
Subject: [PATCH 188/290] std.os.linux.bpf: fix compile error

---
 lib/std/os/linux/bpf.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/os/linux/bpf.zig b/lib/std/os/linux/bpf.zig
index 4cb9dbf5c53992d0ba8965db0254430896f6b0c5..147bf610d845909e55bdfd9e36d885fc54adb9ab 100644
--- a/lib/std/os/linux/bpf.zig
+++ b/lib/std/os/linux/bpf.zig
@@ -458,7 +458,7 @@ pub const Insn = packed struct {
         else
             ImmOrReg{ .imm = src };
 
-        const src_type = switch (imm_or_reg) {
+        const src_type: u8 = switch (imm_or_reg) {
             .imm => K,
             .reg => X,
         };
-- 
2.54.0


From 3ce80608182f3e4f03c6f59bdc93413332840da0 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 19 Aug 2022 16:34:41 -0700
Subject: [PATCH 189/290] CI: update windows tarball

---
 ci/azure/pipelines.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index 26befaae79bcf87078b412de18b43a4e5a85667b..5eab6defff742c2064a7428a67c286d5eef37790 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -27,7 +27,7 @@ jobs:
     vmImage: 'windows-2019'
   variables:
     TARGET: 'x86_64-windows-gnu'
-    ZIG_LLVM_CLANG_LLD_NAME: 'zig+llvm+lld+clang-${{ variables.TARGET }}-0.10.0-dev.3619+21f5d73cf'
+    ZIG_LLVM_CLANG_LLD_NAME: 'zig+llvm+lld+clang-${{ variables.TARGET }}-0.10.0-dev.3653+7152a58c1'
     ZIG_LLVM_CLANG_LLD_URL: 'https://ziglang.org/deps/${{ variables.ZIG_LLVM_CLANG_LLD_NAME }}.zip'
   steps:
   - pwsh: |
-- 
2.54.0


From e78e9f33c0a29d008838b8f23cb3e59667c5d6e0 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 19 Aug 2022 16:44:24 -0700
Subject: [PATCH 190/290] CI: update x86_64-linux tarball

---
 ci/zinc/drone.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ci/zinc/drone.yml b/ci/zinc/drone.yml
index 38185df7e7d75d8846712bd25c718b7299fba2cc..fc14ad3ec97f1a0432ae4889d565042412b33973 100644
--- a/ci/zinc/drone.yml
+++ b/ci/zinc/drone.yml
@@ -10,12 +10,12 @@ workspace:
 
 steps:
 - name: test_stage3_debug
-  image: ci/debian-amd64:11.1-6
+  image: ci/debian-amd64:11.1-7
   commands:
   - ./ci/zinc/linux_test_stage3_debug.sh
 
 - name: test_stage3_release
-  image: ci/debian-amd64:11.1-6
+  image: ci/debian-amd64:11.1-7
   commands:
   - ./ci/zinc/linux_test_stage3_release.sh
 
@@ -28,7 +28,7 @@ steps:
       - master
     event:
       - push
-  image: ci/debian-amd64:11.1-6
+  image: ci/debian-amd64:11.1-7
   environment:
     AWS_ACCESS_KEY_ID:
       from_secret: AWS_ACCESS_KEY_ID
-- 
2.54.0


From b75eeae5951f2dc4ff19f795ebd856c134722375 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 19 Aug 2022 17:24:23 -0700
Subject: [PATCH 191/290] CI: x86_64-linux: avoid cmake ZIG_EXECUTABLE hack

empirically this avoids a segfault on the CI.
---
 ci/zinc/linux_test_stage3_debug.sh | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/ci/zinc/linux_test_stage3_debug.sh b/ci/zinc/linux_test_stage3_debug.sh
index 2bacf6d838e33747faf02485738242fae027ad62..ba33311a4d094149306b73500a806a6d66c5d763 100755
--- a/ci/zinc/linux_test_stage3_debug.sh
+++ b/ci/zinc/linux_test_stage3_debug.sh
@@ -35,12 +35,6 @@ unset CXX
 
 ninja install
 
-# Here we rebuild zig but this time using the Zig binary we just now produced to
-# build zig1.o rather than relying on the one built with stage0. See
-# https://github.com/ziglang/zig/issues/6830 for more details.
-cmake .. -DZIG_EXECUTABLE="$DEBUG_STAGING/bin/zig"
-ninja install
-
 cd $WORKSPACE
 
 "$DEBUG_STAGING/bin/zig" build -p stage3 -Denable-stage1 -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-- 
2.54.0


From 9740bb242333c7886e662cf5a9e8149896d7e168 Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Fri, 19 Aug 2022 19:06:01 -0700
Subject: [PATCH 192/290] autodoc: Fix border color around field docs in light
 mode

Follow up to https://github.com/ziglang/zig/pull/12305
---
 lib/docs/index.html | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/docs/index.html b/lib/docs/index.html
index 236923c1d89952bd3d34dd0391c3f7047b05be58..616ba54ab37a5f7becf187c5febe6c292bb64270 100644
--- a/lib/docs/index.html
+++ b/lib/docs/index.html
@@ -290,7 +290,7 @@
       }
 
       .fieldDocs {
-        border: 1px solid #2A2A2A;
+        border: 1px solid #F5F5F5;
         border-top: 0px;
         padding: 1px 1em;
       }
@@ -414,6 +414,9 @@
         .docs pre {
           background-color:#2A2A2A;
         }
+        .fieldDocs {
+          border-color:#2A2A2A;
+        }
         #listNav {
           background-color: #333;
         }
-- 
2.54.0


From aca911ca18d43fddcc3d36f44d3750d07b53fb56 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Fri, 19 Aug 2022 19:26:44 +0200
Subject: [PATCH 193/290] wasm/archive: correctly parse long file names

Wasm archive files are encoded the same way as GNU.
This means that the header notates the character index within
the long file name list rather than the length of the name.
The entire name is then delimited by an LF character (0x0a).

This also makes a cosmetic update to remove the `self` name,
and rather label it as `archive` instead.
---
 src/link/Wasm/Archive.zig | 118 ++++++++++++++++++++++----------------
 1 file changed, 67 insertions(+), 51 deletions(-)

diff --git a/src/link/Wasm/Archive.zig b/src/link/Wasm/Archive.zig
index e214d1b1240870b2f9a0ec09282c9da112d5094c..4a0abb1dfa9bb78fd73dd37c46f7f79f55b9d2ac 100644
--- a/src/link/Wasm/Archive.zig
+++ b/src/link/Wasm/Archive.zig
@@ -15,6 +15,12 @@ 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,
+
 /// Parsed table of contents.
 /// Each symbol name points to a list of all definition
 /// sites within the current static archive.
@@ -53,32 +59,33 @@ const ar_hdr = extern struct {
     /// Always contains ARFMAG.
     ar_fmag: [2]u8,
 
-    const NameOrLength = union(enum) {
-        Name: []const u8,
-        Length: u32,
+    const NameOrIndex = union(enum) {
+        name: []const u8,
+        index: u32,
     };
-    fn nameOrLength(self: ar_hdr) !NameOrLength {
-        const value = getValue(&self.ar_name);
+
+    fn nameOrIndex(archive: ar_hdr) !NameOrIndex {
+        const value = getValue(&archive.ar_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 NameOrLength{ .Name = value };
+            return NameOrIndex{ .name = value };
         } else {
             // Name follows the header directly and its length is encoded in
             // the name field.
-            const length = try std.fmt.parseInt(u32, value[slash_index + 1 ..], 10);
-            return NameOrLength{ .Length = length };
+            const index = try std.fmt.parseInt(u32, value[slash_index + 1 ..], 10);
+            return NameOrIndex{ .index = index };
         }
     }
 
-    fn date(self: ar_hdr) !u64 {
-        const value = getValue(&self.ar_date);
+    fn date(archive: ar_hdr) !u64 {
+        const value = getValue(&archive.ar_date);
         return std.fmt.parseInt(u64, value, 10);
     }
 
-    fn size(self: ar_hdr) !u32 {
-        const value = getValue(&self.ar_size);
+    fn size(archive: ar_hdr) !u32 {
+        const value = getValue(&archive.ar_size);
         return std.fmt.parseInt(u32, value, 10);
     }
 
@@ -87,18 +94,19 @@ const ar_hdr = extern struct {
     }
 };
 
-pub fn deinit(self: *Archive, allocator: Allocator) void {
-    for (self.toc.keys()) |*key| {
+pub fn deinit(archive: *Archive, allocator: Allocator) void {
+    for (archive.toc.keys()) |*key| {
         allocator.free(key.*);
     }
-    for (self.toc.values()) |*value| {
+    for (archive.toc.values()) |*value| {
         value.deinit(allocator);
     }
-    self.toc.deinit(allocator);
+    archive.toc.deinit(allocator);
+    allocator.free(archive.long_file_names);
 }
 
-pub fn parse(self: *Archive, allocator: Allocator) !void {
-    const reader = self.file.reader();
+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)) {
@@ -106,38 +114,31 @@ pub fn parse(self: *Archive, allocator: Allocator) !void {
         return error.NotArchive;
     }
 
-    self.header = try reader.readStruct(ar_hdr);
-    if (!mem.eql(u8, &self.header.ar_fmag, ARFMAG)) {
-        log.debug("invalid header delimiter: expected '{s}', found '{s}'", .{ ARFMAG, self.header.ar_fmag });
+    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;
     }
 
-    try self.parseTableOfContents(allocator, reader);
+    try archive.parseTableOfContents(allocator, reader);
+    try archive.parseNameTable(allocator, reader);
 }
 
-fn parseName(allocator: Allocator, header: ar_hdr, reader: anytype) ![]u8 {
-    const name_or_length = try header.nameOrLength();
-    var name: []u8 = undefined;
-    switch (name_or_length) {
-        .Name => |n| {
-            name = try allocator.dupe(u8, n);
-        },
-        .Length => |len| {
-            var n = try allocator.alloc(u8, len);
-            defer allocator.free(n);
-            try reader.readNoEof(n);
-            const actual_len = mem.indexOfScalar(u8, n, @as(u8, 0)) orelse n.len;
-            name = try allocator.dupe(u8, n[0..actual_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, "/");
         },
     }
-    return name;
 }
 
-fn parseTableOfContents(self: *Archive, allocator: Allocator, reader: anytype) !void {
-    log.debug("parsing table of contents for archive file '{s}'", .{self.name});
+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 = std.mem.trim(u8, &self.header.ar_size, " ");
+    const size_trimmed = mem.trim(u8, &archive.header.ar_size, " ");
     const sym_tab_size = try std.fmt.parseInt(u32, size_trimmed, 10);
 
     const num_symbols = try reader.readIntBig(u32);
@@ -157,7 +158,7 @@ fn parseTableOfContents(self: *Archive, allocator: Allocator, reader: anytype) !
 
     var i: usize = 0;
     while (i < sym_tab.len) {
-        const string = std.mem.sliceTo(sym_tab[i..], 0);
+        const string = mem.sliceTo(sym_tab[i..], 0);
         if (string.len == 0) {
             i += 1;
             continue;
@@ -165,7 +166,7 @@ fn parseTableOfContents(self: *Archive, allocator: Allocator, reader: anytype) !
         i += string.len;
         const name = try allocator.dupe(u8, string);
         errdefer allocator.free(name);
-        const gop = try self.toc.getOrPut(allocator, name);
+        const gop = try archive.toc.getOrPut(allocator, name);
         if (gop.found_existing) {
             allocator.free(name);
         } else {
@@ -175,31 +176,46 @@ fn parseTableOfContents(self: *Archive, allocator: Allocator, reader: anytype) !
     }
 }
 
+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)) {
+        log.err("invalid header delimiter: expected '{s}', found '{s}'", .{ ARFMAG, header.ar_fmag });
+        return error.MalformedArchive;
+    }
+    if (!mem.eql(u8, header.ar_name[0..2], "//")) {
+        log.err("invalid archive. Long name table missing", .{});
+        return error.MalformedArchive;
+    }
+    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;
+}
+
 /// 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(self: Archive, allocator: Allocator, file_offset: u32) !Object {
-    try self.file.seekTo(file_offset);
-    const reader = self.file.reader();
+pub fn parseObject(archive: Archive, allocator: Allocator, file_offset: u32) !Object {
+    try archive.file.seekTo(file_offset);
+    const reader = archive.file.reader();
     const header = try reader.readStruct(ar_hdr);
-    const current_offset = try self.file.getPos();
-    try self.file.seekTo(0);
+    const current_offset = try archive.file.getPos();
+    try archive.file.seekTo(0);
 
     if (!mem.eql(u8, &header.ar_fmag, ARFMAG)) {
         log.err("invalid header delimiter: expected '{s}', found '{s}'", .{ ARFMAG, header.ar_fmag });
         return error.MalformedArchive;
     }
 
-    const object_name = try parseName(allocator, header, reader);
-    defer allocator.free(object_name);
-
+    const object_name = try archive.parseName(header);
     const name = name: {
         var buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
-        const path = try std.os.realpath(self.name, &buffer);
+        const path = try std.os.realpath(archive.name, &buffer);
         break :name try std.fmt.allocPrint(allocator, "{s}({s})", .{ path, object_name });
     };
     defer allocator.free(name);
 
-    const object_file = try std.fs.cwd().openFile(self.name, .{});
+    const object_file = try std.fs.cwd().openFile(archive.name, .{});
     errdefer object_file.close();
 
     try object_file.seekTo(current_offset);
-- 
2.54.0


From 1544625df3fb4732f2cd63d1e7c4c738d1b7d0c0 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Fri, 19 Aug 2022 21:15:16 +0200
Subject: [PATCH 194/290] wasm/Object: parse using the correct file size

When an object file is being parsed from within an archive
file, we provide the object file size to ensure we do not
read past the object file. This is because follow up object
files can exist there, as well as an LF character to notate
the end of the file was reached. Such a character is invalid
within the object file.

This also fixes a bug in getting the function/global type
for defined globals/functions from object files as it was missing
the substraction with the import count of the respective type.
---
 src/link/Wasm.zig         | 13 ++++++++-----
 src/link/Wasm/Archive.zig |  3 ++-
 src/link/Wasm/Object.zig  | 23 +++++++++++++++++++++--
 3 files changed, 31 insertions(+), 8 deletions(-)

diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 626f17665215bc3f93f6830ac60a0ce804dc95a0..37e25e436054a746ed0319a73d861079dfe4d2f9 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -378,7 +378,7 @@ fn parseObjectFile(self: *Wasm, path: []const u8) !bool {
     const file = try fs.cwd().openFile(path, .{});
     errdefer file.close();
 
-    var object = Object.create(self.base.allocator, file, path) catch |err| switch (err) {
+    var object = Object.create(self.base.allocator, file, path, null) catch |err| switch (err) {
         error.InvalidMagicByte, error.NotObjectFile => return false,
         else => |e| return e,
     };
@@ -595,8 +595,8 @@ fn resolveSymbolsInArchives(self: *Wasm) !void {
             // Parse object and and resolve symbols again before we check remaining
             // undefined symbols.
             const object_file_index = @intCast(u16, self.objects.items.len);
-            const object = try self.objects.addOne(self.base.allocator);
-            object.* = try archive.parseObject(self.base.allocator, offset.items[0]);
+            var object = try archive.parseObject(self.base.allocator, offset.items[0]);
+            try self.objects.append(self.base.allocator, object);
             try self.resolveSymbolsInObject(object_file_index);
 
             // continue loop for any remaining undefined symbols that still exist
@@ -860,7 +860,8 @@ fn getGlobalType(self: *const Wasm, loc: SymbolLoc) wasm.GlobalType {
         if (is_undefined) {
             return obj.findImport(.global, symbol.index).kind.global;
         }
-        return obj.globals[symbol.index].global_type;
+        const import_global_count = obj.importedCountByKind(.global);
+        return obj.globals[symbol.index - import_global_count].global_type;
     }
     if (is_undefined) {
         return self.imports.get(loc).?.kind.global;
@@ -880,7 +881,9 @@ fn getFunctionSignature(self: *const Wasm, loc: SymbolLoc) wasm.Type {
             const ty_index = obj.findImport(.function, symbol.index).kind.function;
             return obj.func_types[ty_index];
         }
-        return obj.func_types[obj.functions[symbol.index].type_index];
+        const import_function_count = obj.importedCountByKind(.function);
+        const type_index = obj.functions[symbol.index - import_function_count].type_index;
+        return obj.func_types[type_index];
     }
     if (is_undefined) {
         const ty_index = self.imports.get(loc).?.kind.function;
diff --git a/src/link/Wasm/Archive.zig b/src/link/Wasm/Archive.zig
index 4a0abb1dfa9bb78fd73dd37c46f7f79f55b9d2ac..c80d26d17d8f99adf9da50d2bcb57502959c792a 100644
--- a/src/link/Wasm/Archive.zig
+++ b/src/link/Wasm/Archive.zig
@@ -218,6 +218,7 @@ pub fn parseObject(archive: Archive, allocator: Allocator, file_offset: u32) !Ob
     const object_file = try std.fs.cwd().openFile(archive.name, .{});
     errdefer object_file.close();
 
+    const object_file_size = try header.size();
     try object_file.seekTo(current_offset);
-    return Object.create(allocator, object_file, name);
+    return Object.create(allocator, object_file, name, object_file_size);
 }
diff --git a/src/link/Wasm/Object.zig b/src/link/Wasm/Object.zig
index a1308ec0455a2b94362ada864277b110743c47c4..50827ca9fb8174cb97212c6b5f14f0df15783564 100644
--- a/src/link/Wasm/Object.zig
+++ b/src/link/Wasm/Object.zig
@@ -105,14 +105,33 @@ pub const InitError = error{NotObjectFile} || ParseError || std.fs.File.ReadErro
 
 /// Initializes a new `Object` from a wasm object file.
 /// This also parses and verifies the object file.
-pub fn create(gpa: Allocator, file: std.fs.File, name: []const u8) InitError!Object {
+/// 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(gpa: Allocator, file: std.fs.File, name: []const u8, maybe_max_size: ?usize) InitError!Object {
     var object: Object = .{
         .file = file,
         .name = try gpa.dupe(u8, name),
     };
 
     var is_object_file: bool = false;
-    try object.parse(gpa, file.reader(), &is_object_file);
+    const size = maybe_max_size orelse size: {
+        errdefer gpa.free(object.name);
+        const stat = try file.stat();
+        break :size @intCast(usize, stat.size);
+    };
+
+    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, fbs.reader(), &is_object_file);
     errdefer object.deinit(gpa);
     if (!is_object_file) return error.NotObjectFile;
 
-- 
2.54.0


From 7fe2a3d104319835127456d02ba73efc5fe5f207 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Sat, 20 Aug 2022 15:46:39 +0200
Subject: [PATCH 195/290] test/link: add wasm linker-test for archives

Adds a test case that will pull-in compiler-rt symbols,
and therefore link with the compiler-rt archive file.
---
 lib/std/build.zig                |  7 +------
 test/link.zig                    |  5 +++++
 test/link/wasm/archive/build.zig | 27 +++++++++++++++++++++++++++
 test/link/wasm/archive/main.zig  |  6 ++++++
 4 files changed, 39 insertions(+), 6 deletions(-)
 create mode 100644 test/link/wasm/archive/build.zig
 create mode 100644 test/link/wasm/archive/main.zig

diff --git a/lib/std/build.zig b/lib/std/build.zig
index 57f0d126d8c0e9ea4db115e1fccc8986517a8da9..1cbf188d2c16d5d0ff6632eae919a62db700c488 100644
--- a/lib/std/build.zig
+++ b/lib/std/build.zig
@@ -1898,12 +1898,7 @@ pub const LibExeObjStep = struct {
     pub fn runEmulatable(exe: *LibExeObjStep) *EmulatableRunStep {
         assert(exe.kind == .exe or exe.kind == .test_exe);
 
-        const run_step = EmulatableRunStep.create(exe.builder.fmt("run {s}", .{exe.step.name}), exe);
-        if (exe.vcpkg_bin_path) |path| {
-            run_step.addPathDir(path);
-        }
-
-        return run_step;
+        return EmulatableRunStep.create(exe.builder, exe.builder.fmt("run {s}", .{exe.step.name}), exe);
     }
 
     pub fn checkObject(self: *LibExeObjStep, obj_format: std.Target.ObjectFormat) *CheckObjectStep {
diff --git a/test/link.zig b/test/link.zig
index 88b370f343503207a93dde2e0ce0576134bd4d0e..215a0511fc0f9b585bf343a2ea6e965cd8c58c91 100644
--- a/test/link.zig
+++ b/test/link.zig
@@ -47,6 +47,11 @@ fn addWasmCases(cases: *tests.StandaloneContext) void {
         .build_modes = true,
         .requires_stage2 = true,
     });
+
+    cases.addBuildFile("test/link/wasm/archive/build.zig", .{
+        .build_modes = true,
+        .requires_stage2 = true,
+    });
 }
 
 fn addMachOCases(cases: *tests.StandaloneContext) void {
diff --git a/test/link/wasm/archive/build.zig b/test/link/wasm/archive/build.zig
new file mode 100644
index 0000000000000000000000000000000000000000..95ce44465975cbd9047877a50c4ff564c74eacac
--- /dev/null
+++ b/test/link/wasm/archive/build.zig
@@ -0,0 +1,27 @@
+const std = @import("std");
+const Builder = std.build.Builder;
+
+pub fn build(b: *Builder) void {
+    const mode = b.standardReleaseOptions();
+
+    const test_step = b.step("test", "Test");
+    test_step.dependOn(b.getInstallStep());
+
+    // The code in question will pull-in compiler-rt,
+    // and therefore link with its archive file.
+    const lib = b.addSharedLibrary("main", "main.zig", .unversioned);
+    lib.setBuildMode(mode);
+    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    lib.use_llvm = false;
+    lib.use_stage1 = false;
+    lib.use_lld = false;
+
+    const check = lib.checkObject(.wasm);
+    check.checkStart("Section import");
+    check.checkNext("entries 1"); // __truncsfhf2 should have been resolved, so only 1 import (compiler-rt's memcpy).
+
+    check.checkStart("Section custom");
+    check.checkNext("name __truncsfhf2"); // Ensure it was imported and resolved
+
+    test_step.dependOn(&check.step);
+}
diff --git a/test/link/wasm/archive/main.zig b/test/link/wasm/archive/main.zig
new file mode 100644
index 0000000000000000000000000000000000000000..29be3af0ac1cb83426ad948dcec2b3090265fa4d
--- /dev/null
+++ b/test/link/wasm/archive/main.zig
@@ -0,0 +1,6 @@
+export fn foo() void {
+    var a: f16 = 2.2;
+    // this will pull-in compiler-rt
+    var b = @trunc(a);
+    _ = b;
+}
-- 
2.54.0


From 4a98385b0aa3808ab05a1ebfbc90fd0bcd97c0d9 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Sat, 20 Aug 2022 17:34:34 +0200
Subject: [PATCH 196/290] macho: do not leave file descriptors open if unused

This manifested in different `AccessDenied` errors on Windows when
trying to do an atomic file copying in the compiler/linker.
---
 src/link/MachO.zig | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 020388cee87138848e88559f949a5cdfde8b4111..7c04972e4c3b1f3537f1534975287dab13947176 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -273,7 +273,7 @@ pub fn openPath(allocator: Allocator, options: link.Options) !*MachO {
     assert(options.target.ofmt == .macho);
 
     const use_stage1 = build_options.have_stage1 and options.use_stage1;
-    if (use_stage1 or options.emit == null) {
+    if (use_stage1 or options.emit == null or options.module == null) {
         return createEmpty(allocator, options);
     }
 
@@ -293,11 +293,11 @@ pub fn openPath(allocator: Allocator, options: link.Options) !*MachO {
         });
     }
 
-    if (options.output_mode == .Lib and
-        options.link_mode == .Static and self.base.intermediary_basename != null)
-    {
-        return self;
-    }
+    if (self.base.intermediary_basename != null) switch (options.output_mode) {
+        .Obj => return self,
+        .Lib => if (options.link_mode == .Static) return self,
+        else => {},
+    };
 
     const file = try emit.directory.handle.createFile(emit.sub_path, .{
         .truncate = false,
-- 
2.54.0


From a02215795639294a723f8e5c5aa1d39a089962f3 Mon Sep 17 00:00:00 2001
From: Der Teufel <der.teufel.mail@gmail.com>
Date: Sun, 21 Aug 2022 05:29:39 +0200
Subject: [PATCH 197/290] autodoc: compileError now uses index into `exprs`
 instead of a `[]const u8`

---
 lib/docs/main.js |  2 +-
 src/Autodoc.zig  | 12 +++++-------
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 28f8fb1a703194eec24a35ba54d345cf4f0c8b67..b6131f4bb33f8367b7997ec914c52a7255b92fe6 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -866,7 +866,7 @@ var zigAnalysis;
       }
       case "compileError": {
         let compileError = expr.compileError;
-        return compileError;
+        return "@compileError(" + exprName(zigAnalysis.exprs[compileError]) + ")";
       }
       case "enumLiteral": {
         let literal = expr.enumLiteral;
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index bc1b1beebb0d9f4a7a4bd96f1f2a4ff4818ce790..f983bdfdf052a78d1bd7bc0e9f9bd0ec850bab9f 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -632,7 +632,7 @@ const DocData = struct {
         sizeOf: usize, // index in `exprs`
         bitSizeOf: usize, // index in `exprs`
         enumToInt: usize, // index in `exprs`
-        compileError: []const u8,
+        compileError: usize, //index in `exprs`
         errorSets: usize,
         string: []const u8, // direct value
         sliceIndex: usize,
@@ -1027,13 +1027,11 @@ fn walkInstruction(
                 false,
             );
 
+            const operand_index = self.exprs.items.len;
+            try self.exprs.append(self.arena, operand.expr);
+
             return DocData.WalkResult{
-                .expr = .{
-                    .compileError = switch (operand.expr) {
-                        .string => |s| s,
-                        else => "TODO: non-string @compileError arguments",
-                    },
-                },
+                .expr = .{ .compileError = operand_index },
             };
         },
         .enum_literal => {
-- 
2.54.0


From 76c9ee9b303937aef62f5ad10eab7ff56d607e34 Mon Sep 17 00:00:00 2001
From: Der Teufel <der.teufel.mail@gmail.com>
Date: Sun, 21 Aug 2022 06:32:26 +0200
Subject: [PATCH 198/290] autodoc: Fixed compileError case in exprName

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

diff --git a/lib/docs/main.js b/lib/docs/main.js
index b6131f4bb33f8367b7997ec914c52a7255b92fe6..90701b4509f900e31f60b3897642ee3206119d4e 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -866,7 +866,7 @@ var zigAnalysis;
       }
       case "compileError": {
         let compileError = expr.compileError;
-        return "@compileError(" + exprName(zigAnalysis.exprs[compileError]) + ")";
+        return "@compileError(" + exprName(zigAnalysis.exprs[compileError], opts) + ")";
       }
       case "enumLiteral": {
         let literal = expr.enumLiteral;
-- 
2.54.0


From e8102d8738eafb969e03b0609c60be73326610eb Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sat, 20 Aug 2022 01:12:58 +0300
Subject: [PATCH 199/290] Sema: add note about function call being comptime
 because of comptime only return type

---
 src/Sema.zig                                  | 78 +++++++++++++++++--
 .../explain_why_fn_is_called_at_comptime.zig  | 23 ++++++
 ...n_why_generic_fn_is_called_at_comptime.zig | 22 ++++++
 test/compile_errors.zig                       |  1 +
 4 files changed, 117 insertions(+), 7 deletions(-)
 create mode 100644 test/cases/compile_errors/explain_why_fn_is_called_at_comptime.zig
 create mode 100644 test/cases/compile_errors/explain_why_generic_fn_is_called_at_comptime.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index aa02288df7741eefd302604e55ec688b9adf90eb..5c66c8d6a1bf901acced93adbb3da3f2ebf3ef65 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -5643,6 +5643,37 @@ const GenericCallAdapter = struct {
     }
 };
 
+fn addComptimeReturnTypeNote(
+    sema: *Sema,
+    block: *Block,
+    func: Air.Inst.Ref,
+    func_src: LazySrcLoc,
+    return_ty: Type,
+    parent: *Module.ErrorMsg,
+    requires_comptime: bool,
+) !void {
+    if (!requires_comptime) return;
+
+    const src_loc = if (try sema.funcDeclSrc(block, func_src, func)) |capture| blk: {
+        var src_loc = capture;
+        src_loc.lazy = .{ .node_offset_fn_type_ret_ty = 0 };
+        break :blk src_loc;
+    } else blk: {
+        const src_decl = sema.mod.declPtr(block.src_decl);
+        break :blk func_src.toSrcLoc(src_decl);
+    };
+    if (return_ty.tag() == .generic_poison) {
+        return sema.mod.errNoteNonLazy(src_loc, parent, "generic function is instantiated with a comptime only return type", .{});
+    }
+    try sema.mod.errNoteNonLazy(
+        src_loc,
+        parent,
+        "function is being called at comptime because it returns a comptime only type '{}'",
+        .{return_ty.fmt(sema.mod)},
+    );
+    try sema.explainWhyTypeIsComptime(block, func_src, parent, src_loc, return_ty);
+}
+
 fn analyzeCall(
     sema: *Sema,
     block: *Block,
@@ -5733,9 +5764,11 @@ fn analyzeCall(
 
     var is_generic_call = func_ty_info.is_generic;
     var is_comptime_call = block.is_comptime or modifier == .compile_time;
+    var comptime_only_ret_ty = false;
     if (!is_comptime_call) {
         if (sema.typeRequiresComptime(block, func_src, func_ty_info.return_type)) |ct| {
             is_comptime_call = ct;
+            comptime_only_ret_ty = ct;
         } else |err| switch (err) {
             error.GenericPoison => is_generic_call = true,
             else => |e| return e,
@@ -5764,6 +5797,7 @@ fn analyzeCall(
             error.ComptimeReturn => {
                 is_inline_call = true;
                 is_comptime_call = true;
+                comptime_only_ret_ty = true;
             },
             else => |e| return e,
         }
@@ -5774,8 +5808,12 @@ fn analyzeCall(
     }
 
     const result: Air.Inst.Ref = if (is_inline_call) res: {
-        // TODO explain why function is being called at comptime
-        const func_val = try sema.resolveConstValue(block, func_src, func, "function being called at comptime must be comptime known");
+        const func_val = sema.resolveConstValue(block, func_src, func, "function being called at comptime must be comptime known") catch |err| {
+            if (err == error.AnalysisFail and sema.err != null) {
+                try sema.addComptimeReturnTypeNote(block, func, func_src, func_ty_info.return_type, sema.err.?, comptime_only_ret_ty);
+            }
+            return err;
+        };
         const module_fn = switch (func_val.tag()) {
             .decl_ref => mod.declPtr(func_val.castTag(.decl_ref).?.data).val.castTag(.function).?.data,
             .function => func_val.castTag(.function).?.data,
@@ -5887,6 +5925,11 @@ fn analyzeCall(
                 is_comptime_call,
                 &should_memoize,
                 memoized_call_key,
+                // last 4 arguments are only used when reporting errors
+                undefined,
+                undefined,
+                undefined,
+                undefined,
             ) catch |err| switch (err) {
                 error.NeededSourceLocation => {
                     sema.inst_map.clearRetainingCapacity();
@@ -5904,6 +5947,10 @@ fn analyzeCall(
                         is_comptime_call,
                         &should_memoize,
                         memoized_call_key,
+                        func,
+                        func_src,
+                        func_ty_info.return_type,
+                        comptime_only_ret_ty,
                     );
                     return error.AnalysisFail;
                 },
@@ -6119,6 +6166,10 @@ fn analyzeInlineCallArg(
     is_comptime_call: bool,
     should_memoize: *bool,
     memoized_call_key: Module.MemoizedCall.Key,
+    func: Air.Inst.Ref,
+    func_src: LazySrcLoc,
+    ret_ty: Type,
+    comptime_only_ret_ty: bool,
 ) !void {
     const zir_tags = sema.code.instructions.items(.tag);
     switch (zir_tags[inst]) {
@@ -6134,14 +6185,23 @@ fn analyzeInlineCallArg(
             new_fn_info.param_types[arg_i.*] = param_ty;
             const uncasted_arg = uncasted_args[arg_i.*];
             if (try sema.typeRequiresComptime(arg_block, arg_src, param_ty)) {
-                _ = try sema.resolveConstMaybeUndefVal(arg_block, arg_src, uncasted_arg, "argument to parameter with comptime only type must be comptime known");
+                _ = sema.resolveConstMaybeUndefVal(arg_block, arg_src, uncasted_arg, "argument to parameter with comptime only type must be comptime known") catch |err| {
+                    if (err == error.AnalysisFail and sema.err != null) {
+                        try sema.addComptimeReturnTypeNote(arg_block, func, func_src, ret_ty, sema.err.?, comptime_only_ret_ty);
+                    }
+                    return err;
+                };
             }
             const casted_arg = try sema.coerce(arg_block, param_ty, uncasted_arg, arg_src);
             try sema.inst_map.putNoClobber(sema.gpa, inst, casted_arg);
 
             if (is_comptime_call) {
-                // TODO explain why function is being called at comptime
-                const arg_val = try sema.resolveConstMaybeUndefVal(arg_block, arg_src, casted_arg, "argument to function being called at comptime must be comptime known");
+                const arg_val = sema.resolveConstMaybeUndefVal(arg_block, arg_src, casted_arg, "argument to function being called at comptime must be comptime known") catch |err| {
+                    if (err == error.AnalysisFail and sema.err != null) {
+                        try sema.addComptimeReturnTypeNote(arg_block, func, func_src, ret_ty, sema.err.?, comptime_only_ret_ty);
+                    }
+                    return err;
+                };
                 switch (arg_val.tag()) {
                     .generic_poison, .generic_poison_type => {
                         // This function is currently evaluated as part of an as-of-yet unresolvable
@@ -6171,8 +6231,12 @@ fn analyzeInlineCallArg(
             try sema.inst_map.putNoClobber(sema.gpa, inst, uncasted_arg);
 
             if (is_comptime_call) {
-                // TODO explain why function is being called at comptime
-                const arg_val = try sema.resolveConstMaybeUndefVal(arg_block, arg_src, uncasted_arg, "argument to function being called at comptime must be comptime known");
+                const arg_val = sema.resolveConstMaybeUndefVal(arg_block, arg_src, uncasted_arg, "argument to function being called at comptime must be comptime known") catch |err| {
+                    if (err == error.AnalysisFail and sema.err != null) {
+                        try sema.addComptimeReturnTypeNote(arg_block, func, func_src, ret_ty, sema.err.?, comptime_only_ret_ty);
+                    }
+                    return err;
+                };
                 switch (arg_val.tag()) {
                     .generic_poison, .generic_poison_type => {
                         // This function is currently evaluated as part of an as-of-yet unresolvable
diff --git a/test/cases/compile_errors/explain_why_fn_is_called_at_comptime.zig b/test/cases/compile_errors/explain_why_fn_is_called_at_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7ec539dcd1afa9b2584c3dca83ea84440c3e5c22
--- /dev/null
+++ b/test/cases/compile_errors/explain_why_fn_is_called_at_comptime.zig
@@ -0,0 +1,23 @@
+const S = struct {
+    fnPtr: fn () void,
+    a: u8,
+};
+fn bar() void {}
+
+fn foo(a: u8) S {
+    return .{ .fnPtr = bar, .a = a };
+}
+pub export fn entry() void {
+    var a: u8 = 1;
+    _ = foo(a);
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :12:13: error: unable to resolve comptime value
+// :12:13: note: argument to function being called at comptime must be comptime known
+// :7:15: note: function is being called at comptime because it returns a comptime only type 'tmp.S'
+// :2:12: note: struct requires comptime because of this field
+// :2:12: note: use '*const fn() void' for a function pointer type
diff --git a/test/cases/compile_errors/explain_why_generic_fn_is_called_at_comptime.zig b/test/cases/compile_errors/explain_why_generic_fn_is_called_at_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ccd828bd5c3eac183594cafc20ed1cf67c240af9
--- /dev/null
+++ b/test/cases/compile_errors/explain_why_generic_fn_is_called_at_comptime.zig
@@ -0,0 +1,22 @@
+fn S(comptime PtrTy: type) type {
+    return struct {
+        fnPtr: PtrTy,
+        a: u8,
+    };
+}
+fn bar() void {}
+
+fn foo(a: u8, comptime PtrTy: type) S(PtrTy) {
+    return .{ .fnPtr = bar, .a = a };
+}
+pub export fn entry() void {
+    var a: u8 = 1;
+    _ = foo(a, fn () void);
+}
+// error
+// backend=stage2
+// target=native
+//
+// :14:13: error: unable to resolve comptime value
+// :14:13: note: argument to function being called at comptime must be comptime known
+// :9:38: note: generic function is instantiated with a comptime only return type
diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index 180cf74bcb30c43a8614f3cb24fd76d2232dde8a..f8ede21a9d6d8553f7426e4533dd6ebb3ccb4652 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -204,6 +204,7 @@ pub fn addCases(ctx: *TestContext) !void {
         , &[_][]const u8{
             ":3:12: error: unable to resolve comptime value",
             ":3:12: note: argument to function being called at comptime must be comptime known",
+            ":2:55: note: generic function is instantiated with a comptime only return type",
         });
     }
 
-- 
2.54.0


From d48af541c7aa235948621cdbc250d983af303977 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sun, 21 Aug 2022 12:25:19 +0300
Subject: [PATCH 200/290] Sema: handle union and enum field order being
 different

Closes #12543
---
 src/Sema.zig            | 33 ++++++++++++++++++---------------
 src/codegen.zig         |  2 +-
 src/codegen/c.zig       |  3 +--
 src/codegen/llvm.zig    |  2 +-
 src/type.zig            |  9 ++++++++-
 test/behavior/union.zig | 24 ++++++++++++++++++++++++
 6 files changed, 53 insertions(+), 20 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 5c66c8d6a1bf901acced93adbb3da3f2ebf3ef65..28ff4cc1c20bafce838b3fa199c363cd52c75e28 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -3615,8 +3615,6 @@ fn validateUnionInit(
     union_ptr: Air.Inst.Ref,
     is_comptime: bool,
 ) CompileError!void {
-    const union_obj = union_ty.cast(Type.Payload.Union).?.data;
-
     if (instrs.len != 1) {
         const msg = msg: {
             const msg = try sema.errMsg(
@@ -3650,7 +3648,8 @@ fn validateUnionInit(
     const field_src: LazySrcLoc = .{ .node_offset_initializer = field_ptr_data.src_node };
     const field_ptr_extra = sema.code.extraData(Zir.Inst.Field, field_ptr_data.payload_index).data;
     const field_name = sema.code.nullTerminatedString(field_ptr_extra.field_name_start);
-    const field_index = try sema.unionFieldIndex(block, union_ty, field_name, field_src);
+    // Validate the field access but ignore the index since we want the tag enum field index.
+    _ = try sema.unionFieldIndex(block, union_ty, field_name, field_src);
     const air_tags = sema.air_instructions.items(.tag);
     const air_datas = sema.air_instructions.items(.data);
     const field_ptr_air_ref = sema.inst_map.get(field_ptr).?;
@@ -3709,7 +3708,9 @@ fn validateUnionInit(
         break;
     }
 
-    const tag_val = try Value.Tag.enum_field_index.create(sema.arena, field_index);
+    const tag_ty = union_ty.unionTagTypeHypothetical();
+    const enum_field_index = @intCast(u32, tag_ty.enumFieldIndex(field_name).?);
+    const tag_val = try Value.Tag.enum_field_index.create(sema.arena, enum_field_index);
 
     if (init_val) |val| {
         // Our task is to delete all the `field_ptr` and `store` instructions, and insert
@@ -3726,7 +3727,7 @@ fn validateUnionInit(
     }
 
     try sema.requireFunctionBlock(block, init_src);
-    const new_tag = try sema.addConstant(union_obj.tag_ty, tag_val);
+    const new_tag = try sema.addConstant(tag_ty, tag_val);
     _ = try block.addBinOp(.set_union_tag, union_ptr, new_tag);
 }
 
@@ -8838,13 +8839,11 @@ fn zirSwitchCapture(
     switch (operand_ty.zigTypeTag()) {
         .Union => {
             const union_obj = operand_ty.cast(Type.Payload.Union).?.data;
-            const enum_ty = union_obj.tag_ty;
-
             const first_item = try sema.resolveInst(items[0]);
             // Previous switch validation ensured this will succeed
             const first_item_val = sema.resolveConstValue(block, .unneeded, first_item, undefined) catch unreachable;
 
-            const first_field_index = @intCast(u32, enum_ty.enumTagFieldIndex(first_item_val, sema.mod).?);
+            const first_field_index = @intCast(u32, operand_ty.unionTagFieldIndex(first_item_val, sema.mod).?);
             const first_field = union_obj.fields.values()[first_field_index];
 
             for (items[1..]) |item, i| {
@@ -8852,7 +8851,7 @@ fn zirSwitchCapture(
                 // Previous switch validation ensured this will succeed
                 const item_val = sema.resolveConstValue(block, .unneeded, item_ref, undefined) catch unreachable;
 
-                const field_index = enum_ty.enumTagFieldIndex(item_val, sema.mod).?;
+                const field_index = operand_ty.unionTagFieldIndex(item_val, sema.mod).?;
                 const field = union_obj.fields.values()[field_index];
                 if (!field.ty.eql(first_field.ty, sema.mod)) {
                     const msg = msg: {
@@ -15585,7 +15584,9 @@ fn unionInit(
     const init = try sema.coerce(block, field.ty, uncasted_init, init_src);
 
     if (try sema.resolveMaybeUndefVal(block, init_src, init)) |init_val| {
-        const tag_val = try Value.Tag.enum_field_index.create(sema.arena, field_index);
+        const tag_ty = union_ty.unionTagTypeHypothetical();
+        const enum_field_index = @intCast(u32, tag_ty.enumFieldIndex(field_name).?);
+        const tag_val = try Value.Tag.enum_field_index.create(sema.arena, enum_field_index);
         return sema.addConstant(union_ty, try Value.Tag.@"union".create(sema.arena, .{
             .tag = tag_val,
             .val = init_val,
@@ -15683,7 +15684,9 @@ fn zirStructInit(
         const field_type_extra = sema.code.extraData(Zir.Inst.FieldType, field_type_data.payload_index).data;
         const field_name = sema.code.nullTerminatedString(field_type_extra.name_start);
         const field_index = try sema.unionFieldIndex(block, resolved_ty, field_name, field_src);
-        const tag_val = try Value.Tag.enum_field_index.create(sema.arena, field_index);
+        const tag_ty = resolved_ty.unionTagTypeHypothetical();
+        const enum_field_index = @intCast(u32, tag_ty.enumFieldIndex(field_name).?);
+        const tag_val = try Value.Tag.enum_field_index.create(sema.arena, enum_field_index);
 
         const init_inst = try sema.resolveInst(item.data.init);
         if (try sema.resolveMaybeUndefVal(block, field_src, init_inst)) |val| {
@@ -16448,9 +16451,8 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
     const type_info = try sema.coerce(block, type_info_ty, uncasted_operand, operand_src);
     const val = try sema.resolveConstValue(block, operand_src, type_info, "operand to @Type must be comptime known");
     const union_val = val.cast(Value.Payload.Union).?.data;
-    const tag_ty = type_info_ty.unionTagType().?;
     const target = mod.getTarget();
-    const tag_index = tag_ty.enumTagFieldIndex(union_val.tag, mod).?;
+    const tag_index = type_info_ty.unionTagFieldIndex(union_val.tag, mod).?;
     if (union_val.val.anyUndef()) return sema.failWithUseOfUndef(block, src);
     switch (@intToEnum(std.builtin.TypeId, tag_index)) {
         .Type => return Air.Inst.Ref.type_type,
@@ -25155,8 +25157,7 @@ fn coerceEnumToUnion(
 
     const enum_tag = try sema.coerce(block, tag_ty, inst, inst_src);
     if (try sema.resolveDefinedValue(block, inst_src, enum_tag)) |val| {
-        const union_obj = union_ty.cast(Type.Payload.Union).?.data;
-        const field_index = union_obj.tag_ty.enumTagFieldIndex(val, sema.mod) orelse {
+        const field_index = union_ty.unionTagFieldIndex(val, sema.mod) orelse {
             const msg = msg: {
                 const msg = try sema.errMsg(block, inst_src, "union '{}' has no tag with value '{}'", .{
                     union_ty.fmt(sema.mod), val.fmtValue(tag_ty, sema.mod),
@@ -25167,6 +25168,8 @@ fn coerceEnumToUnion(
             };
             return sema.failWithOwnedErrorMsg(msg);
         };
+
+        const union_obj = union_ty.cast(Type.Payload.Union).?.data;
         const field = union_obj.fields.values()[field_index];
         const field_ty = try sema.resolveTypeFields(block, inst_src, field.ty);
         if (field_ty.zigTypeTag() == .NoReturn) {
diff --git a/src/codegen.zig b/src/codegen.zig
index 025decdb4bcc65701ff30b95a4722c5e6dfce56d..f5340458a58f58645029e6a9b191ea09d92b1431 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -607,7 +607,7 @@ pub fn generateSymbol(
 
             const union_ty = typed_value.ty.cast(Type.Payload.Union).?.data;
             const mod = bin_file.options.module.?;
-            const field_index = union_ty.tag_ty.enumTagFieldIndex(union_obj.tag, mod).?;
+            const field_index = typed_value.ty.unionTagFieldIndex(union_obj.tag, mod).?;
             assert(union_ty.haveFieldTypes());
             const field_ty = union_ty.fields.values()[field_index].ty;
             if (!field_ty.hasRuntimeBits()) {
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 81a892183f1dca201878af7fc1ddff0b83b89a62..4a09c09cc9d489107934f2484636e791e106494c 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -835,7 +835,6 @@ pub const DeclGen = struct {
             },
             .Union => {
                 const union_obj = val.castTag(.@"union").?.data;
-                const union_ty = ty.cast(Type.Payload.Union).?.data;
                 const layout = ty.unionGetLayout(target);
 
                 try writer.writeAll("(");
@@ -851,7 +850,7 @@ pub const DeclGen = struct {
                     try writer.writeAll(".payload = {");
                 }
 
-                const index = union_ty.tag_ty.enumTagFieldIndex(union_obj.tag, dg.module).?;
+                const index = ty.unionTagFieldIndex(union_obj.tag, dg.module).?;
                 const field_ty = ty.unionFields().values()[index].ty;
                 const field_name = ty.unionFields().keys()[index];
                 if (field_ty.hasRuntimeBits()) {
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index d50b463606c190f6d2756267c940235f15c857f6..5c537cd5bcb2362406fdad8c652a9dd3a5280f75 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -3502,7 +3502,7 @@ pub const DeclGen = struct {
                     });
                 }
                 const union_obj = tv.ty.cast(Type.Payload.Union).?.data;
-                const field_index = union_obj.tag_ty.enumTagFieldIndex(tag_and_val.tag, dg.module).?;
+                const field_index = tv.ty.unionTagFieldIndex(tag_and_val.tag, dg.module).?;
                 assert(union_obj.haveFieldTypes());
 
                 // Sometimes we must make an unnamed struct because LLVM does
diff --git a/src/type.zig b/src/type.zig
index f6afa33df16ddb2ad1da69fea43f9a9395c089a3..d2885f537fe9de6258f1f4e9825b53468b78e363 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -4285,11 +4285,18 @@ pub const Type = extern union {
 
     pub fn unionFieldType(ty: Type, enum_tag: Value, mod: *Module) Type {
         const union_obj = ty.cast(Payload.Union).?.data;
-        const index = union_obj.tag_ty.enumTagFieldIndex(enum_tag, mod).?;
+        const index = ty.unionTagFieldIndex(enum_tag, mod).?;
         assert(union_obj.haveFieldTypes());
         return union_obj.fields.values()[index].ty;
     }
 
+    pub fn unionTagFieldIndex(ty: Type, enum_tag: Value, mod: *Module) ?usize {
+        const union_obj = ty.cast(Payload.Union).?.data;
+        const index = union_obj.tag_ty.enumTagFieldIndex(enum_tag, mod) orelse return null;
+        const name = union_obj.tag_ty.enumFieldName(index);
+        return union_obj.fields.getIndex(name);
+    }
+
     pub fn unionHasAllZeroBitFieldTypes(ty: Type) bool {
         return ty.cast(Payload.Union).?.data.hasAllZeroBitFieldTypes();
     }
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index efca75af30ed3b9d4251f13b5c69327be5383999..92f277b946548db54ba93c2bef22cc2d9a165567 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1301,3 +1301,27 @@ test "noreturn field in union" {
     }
     try expect(count == 5);
 }
+
+test "union and enum field order doesn't match" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
+    const MyTag = enum(u32) {
+        b = 1337,
+        a = 1666,
+    };
+    const MyUnion = union(MyTag) {
+        a: f32,
+        b: void,
+    };
+    var x: MyUnion = .{ .a = 666 };
+    switch (x) {
+        .a => |my_f32| {
+            try expect(@TypeOf(my_f32) == f32);
+        },
+        .b => unreachable,
+    }
+    x = .b;
+    try expect(x == .b);
+}
-- 
2.54.0


From 20d0018d79c25a0def440040eab2970e7a314130 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sun, 21 Aug 2022 12:48:26 +0300
Subject: [PATCH 201/290] Sema: ignore dbg_block instructions when checking for
 comptimeness

Closes #12514
---
 src/Sema.zig           | 10 +++++-----
 test/behavior/eval.zig | 15 +++++++++++++++
 2 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 28ff4cc1c20bafce838b3fa199c363cd52c75e28..f3ddf21206e4c5fe765446dbcfaa55f4e5396776 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -3087,7 +3087,7 @@ fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
 
             const candidate = block.instructions.items[search_index];
             switch (air_tags[candidate]) {
-                .dbg_stmt => continue,
+                .dbg_stmt, .dbg_block_begin, .dbg_block_end => continue,
                 .store => break candidate,
                 else => break :ct,
             }
@@ -3099,7 +3099,7 @@ fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
 
             const candidate = block.instructions.items[search_index];
             switch (air_tags[candidate]) {
-                .dbg_stmt => continue,
+                .dbg_stmt, .dbg_block_begin, .dbg_block_end => continue,
                 .alloc => {
                     if (Air.indexToRef(candidate) != alloc) break :ct;
                     break;
@@ -3317,7 +3317,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
 
                     const candidate = block.instructions.items[search_index];
                     switch (air_tags[candidate]) {
-                        .dbg_stmt => continue,
+                        .dbg_stmt, .dbg_block_begin, .dbg_block_end => continue,
                         .store => break candidate,
                         else => break :ct,
                     }
@@ -3329,7 +3329,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
 
                     const candidate = block.instructions.items[search_index];
                     switch (air_tags[candidate]) {
-                        .dbg_stmt => continue,
+                        .dbg_stmt, .dbg_block_begin, .dbg_block_end => continue,
                         .bitcast => break candidate,
                         else => break :ct,
                     }
@@ -3341,7 +3341,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
 
                     const candidate = block.instructions.items[search_index];
                     switch (air_tags[candidate]) {
-                        .dbg_stmt => continue,
+                        .dbg_stmt, .dbg_block_begin, .dbg_block_end => continue,
                         .constant => break candidate,
                         else => break :ct,
                     }
diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
index 8a872f63781374b4edd56224b6ab1586369ca1e7..49183227b5114443a0727d021cf8251554436152 100644
--- a/test/behavior/eval.zig
+++ b/test/behavior/eval.zig
@@ -1310,3 +1310,18 @@ test "repeated value is correctly expanded" {
         } }, res);
     }
 }
+
+test "value in if block is comptime known" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+
+    const first = blk: {
+        const s = if (false) "a" else "b";
+        break :blk "foo" ++ s;
+    };
+    const second = blk: {
+        const S = struct { str: []const u8 };
+        const s = if (false) S{ .str = "a" } else S{ .str = "b" };
+        break :blk "foo" ++ s.str;
+    };
+    comptime try expect(std.mem.eql(u8, first, second));
+}
-- 
2.54.0


From d4c56804dfd3f53de1f0950fac9478b096a2a0b4 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Sun, 21 Aug 2022 16:42:11 +0200
Subject: [PATCH 202/290] std: fix EmulatableRunStep

Fixes a compilation error when using the `EmulatableRunStep`
that is being generated from a step directly using `runEmulatable`.
---
 lib/std/build.zig         | 6 +++++-
 lib/std/build/RunStep.zig | 2 +-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/lib/std/build.zig b/lib/std/build.zig
index 1cbf188d2c16d5d0ff6632eae919a62db700c488..b47f962a9dfbcb32d775ccef3d7cbbbe4a1dfd87 100644
--- a/lib/std/build.zig
+++ b/lib/std/build.zig
@@ -1898,7 +1898,11 @@ pub const LibExeObjStep = struct {
     pub fn runEmulatable(exe: *LibExeObjStep) *EmulatableRunStep {
         assert(exe.kind == .exe or exe.kind == .test_exe);
 
-        return EmulatableRunStep.create(exe.builder, exe.builder.fmt("run {s}", .{exe.step.name}), exe);
+        const run_step = EmulatableRunStep.create(exe.builder, exe.builder.fmt("run {s}", .{exe.step.name}), exe);
+        if (exe.vcpkg_bin_path) |path| {
+            RunStep.addPathDirInternal(&run_step.step, exe.builder, path);
+        }
+        return run_step;
     }
 
     pub fn checkObject(self: *LibExeObjStep, obj_format: std.Target.ObjectFormat) *CheckObjectStep {
diff --git a/lib/std/build/RunStep.zig b/lib/std/build/RunStep.zig
index 1e22fd10a3f668cacf7343d66bf680d011c93ed7..168f5d9d581a1820918072670693173089604085 100644
--- a/lib/std/build/RunStep.zig
+++ b/lib/std/build/RunStep.zig
@@ -101,7 +101,7 @@ pub fn addPathDir(self: *RunStep, search_path: []const u8) void {
 }
 
 /// For internal use only, users of `RunStep` should use `addPathDir` directly.
-fn addPathDirInternal(step: *Step, builder: *Builder, search_path: []const u8) void {
+pub fn addPathDirInternal(step: *Step, builder: *Builder, search_path: []const u8) void {
     const env_map = getEnvMapInternal(step, builder.allocator);
 
     const key = "PATH";
-- 
2.54.0


From 9cf667a21bfef3660183ed67baacb5b32c0f06e2 Mon Sep 17 00:00:00 2001
From: John Schmidt <john.schmidt.h@gmail.com>
Date: Sun, 21 Aug 2022 18:12:13 +0200
Subject: [PATCH 203/290] Enable unexpectedErrno error tracing for stage2 LLVM

Stage2 seems to be able to handle this now.
---
 lib/std/os.zig | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/lib/std/os.zig b/lib/std/os.zig
index c757561b0717b53251238980ba40c5d28c0a68cb..24b438a53e65aaa8ee25cef90796a2f8f778c8b1 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -5447,11 +5447,7 @@ pub fn toPosixPath(file_path: []const u8) ![MAX_PATH_BYTES - 1:0]u8 {
 /// if this happens the fix is to add the error code to the corresponding
 /// switch expression, possibly introduce a new error in the error set, and
 /// send a patch to Zig.
-/// The self-hosted compiler is not fully capable of handle the related code.
-/// Until then, unexpected error tracing is disabled for the self-hosted compiler.
-/// TODO remove this once self-hosted is capable enough to handle printing and
-/// stack trace dumping.
-pub const unexpected_error_tracing = builtin.zig_backend == .stage1 and builtin.mode == .Debug;
+pub const unexpected_error_tracing = (builtin.zig_backend == .stage1 or builtin.zig_backend == .stage2_llvm) and builtin.mode == .Debug;
 
 pub const UnexpectedError = error{
     /// The Operating System returned an undocumented error code.
-- 
2.54.0


From b2f02a820f1ed46721ed55243cead52efed055d7 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sun, 21 Aug 2022 17:07:22 +0300
Subject: [PATCH 204/290] Sema: check for astgen failures in `semaStructFields`

The struct might be a top level struct in which case it might not have Zir.

Closes #12548
---
 src/Sema.zig            |  4 +++-
 test/compile_errors.zig | 19 ++++++++++++++++++-
 2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index f3ddf21206e4c5fe765446dbcfaa55f4e5396776..582299bc9e765bec1da23bc1c3a9cadb0586567e 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -27909,7 +27909,9 @@ fn resolveInferredErrorSetTy(
 fn semaStructFields(mod: *Module, struct_obj: *Module.Struct) CompileError!void {
     const gpa = mod.gpa;
     const decl_index = struct_obj.owner_decl;
-    const zir = struct_obj.namespace.file_scope.zir;
+    const file_scope = struct_obj.namespace.file_scope;
+    if (file_scope.status != .success_zir) return error.AnalysisFail;
+    const zir = file_scope.zir;
     const extended = zir.instructions.items(.data)[struct_obj.zir_index].extended;
     assert(extended.opcode == .struct_decl);
     const small = @bitCast(Zir.Inst.StructDecl.Small, extended.small);
diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index f8ede21a9d6d8553f7426e4533dd6ebb3ccb4652..60de07d1e3ef329c8662488653a84e0fa812eede 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -184,7 +184,7 @@ pub fn addCases(ctx: *TestContext) !void {
     }
 
     {
-        const case = ctx.obj("argument causes error ", .{});
+        const case = ctx.obj("argument causes error", .{});
         case.backend = .stage2;
 
         case.addSourceFile("b.zig",
@@ -208,6 +208,23 @@ pub fn addCases(ctx: *TestContext) !void {
         });
     }
 
+    {
+        const case = ctx.obj("astgen failure in file struct", .{});
+        case.backend = .stage2;
+
+        case.addSourceFile("b.zig",
+            \\bad
+        );
+
+        case.addError(
+            \\pub export fn entry() void {
+            \\    _ = (@sizeOf(@import("b.zig")));
+            \\}
+        , &[_][]const u8{
+            ":1:1: error: struct field missing type",
+        });
+    }
+
     // TODO test this in stage2, but we won't even try in stage1
     //ctx.objErrStage1("inline fn calls itself indirectly",
     //    \\export fn foo() void {
-- 
2.54.0


From b55a5007faad1de054e86e00bfdc9a58e5fc4ff8 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sun, 21 Aug 2022 18:04:46 +0300
Subject: [PATCH 205/290] Sema: fix parameter of type 'T' must be comptime
 error

Closes #12519
Closes #12505
---
 doc/langref.html.in                           |  4 ++--
 lib/std/fs/path.zig                           |  2 +-
 lib/std/math.zig                              |  2 +-
 lib/std/math/float.zig                        |  2 +-
 lib/std/zig/c_translation.zig                 |  2 +-
 lib/std/zig/parse.zig                         |  2 +-
 src/Module.zig                                |  8 +++----
 src/Sema.zig                                  | 18 ++++++++++-----
 src/type.zig                                  |  2 +-
 test/behavior/cast.zig                        |  2 +-
 test/behavior/error.zig                       |  2 +-
 test/behavior/fn.zig                          |  2 +-
 test/behavior/struct.zig                      |  2 +-
 ...omptime_parameter_not_declared_as_such.zig | 23 +++++++++++++++++++
 14 files changed, 51 insertions(+), 22 deletions(-)
 create mode 100644 test/cases/compile_errors/comptime_parameter_not_declared_as_such.zig

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 9247d3bc4394d0022722475aff74ac6dcc7e2174..04d736609a90d30172d852fc2d7f0ed4e6a8a7b0 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -5023,8 +5023,8 @@ fn shiftLeftOne(a: u32) callconv(.Inline) u32 {
 // Another file can use @import and call sub2
 pub fn sub2(a: i8, b: i8) i8 { return a - b; }
 
-// Functions can be used as values and are equivalent to pointers.
-const call2_op = fn (a: i8, b: i8) i8;
+// Function pointers are prefixed with `*const `.
+const call2_op = *const fn (a: i8, b: i8) i8;
 fn do_op(fn_call: call2_op, op1: i8, op2: i8) i8 {
     return fn_call(op1, op2);
 }
diff --git a/lib/std/fs/path.zig b/lib/std/fs/path.zig
index d5583dcc80d8e5a8dc1b1eb11916040a5351f6a1..9dc33676888d59cfd845b450c75024ff183c14bd 100644
--- a/lib/std/fs/path.zig
+++ b/lib/std/fs/path.zig
@@ -42,7 +42,7 @@ pub fn isSep(byte: u8) bool {
 
 /// This is different from mem.join in that the separator will not be repeated if
 /// it is found at the end or beginning of a pair of consecutive paths.
-fn joinSepMaybeZ(allocator: Allocator, separator: u8, sepPredicate: fn (u8) bool, paths: []const []const u8, zero: bool) ![]u8 {
+fn joinSepMaybeZ(allocator: Allocator, separator: u8, comptime sepPredicate: fn (u8) bool, paths: []const []const u8, zero: bool) ![]u8 {
     if (paths.len == 0) return if (zero) try allocator.dupe(u8, &[1]u8{0}) else &[0]u8{};
 
     // Find first non-empty path index.
diff --git a/lib/std/math.zig b/lib/std/math.zig
index 40b5eb9204b7deb15c21665a3b7cee06fc5027fb..1ed96046121a43006c95aea9a92df01f74717ccb 100644
--- a/lib/std/math.zig
+++ b/lib/std/math.zig
@@ -1548,7 +1548,7 @@ test "boolMask" {
 }
 
 /// Return the mod of `num` with the smallest integer type
-pub fn comptimeMod(num: anytype, denom: comptime_int) IntFittingRange(0, denom - 1) {
+pub fn comptimeMod(num: anytype, comptime denom: comptime_int) IntFittingRange(0, denom - 1) {
     return @intCast(IntFittingRange(0, denom - 1), @mod(num, denom));
 }
 
diff --git a/lib/std/math/float.zig b/lib/std/math/float.zig
index 30e456fcbd8792897bc2544c1aaa06c0fb9a31b1..768cc032852a02d4002efa5e568eed23fe085265 100644
--- a/lib/std/math/float.zig
+++ b/lib/std/math/float.zig
@@ -8,7 +8,7 @@ inline fn mantissaOne(comptime T: type) comptime_int {
 }
 
 /// Creates floating point type T from an unbiased exponent and raw mantissa.
-inline fn reconstructFloat(comptime T: type, exponent: comptime_int, mantissa: comptime_int) T {
+inline fn reconstructFloat(comptime T: type, comptime exponent: comptime_int, comptime mantissa: comptime_int) T {
     const TBits = @Type(.{ .Int = .{ .signedness = .unsigned, .bits = @bitSizeOf(T) } });
     const biased_exponent = @as(TBits, exponent + floatExponentMax(T));
     return @bitCast(T, (biased_exponent << floatMantissaBits(T)) | @as(TBits, mantissa));
diff --git a/lib/std/zig/c_translation.zig b/lib/std/zig/c_translation.zig
index 8a2086e9ad350896313fdc137e2d4f9053e1a02c..348e3a71331e1d6b62b5a593f1973a3384b4e252 100644
--- a/lib/std/zig/c_translation.zig
+++ b/lib/std/zig/c_translation.zig
@@ -349,7 +349,7 @@ test "shuffleVectorIndex" {
 
 /// Constructs a [*c] pointer with the const and volatile annotations
 /// from SelfType for pointing to a C flexible array of ElementType.
-pub fn FlexibleArrayType(comptime SelfType: type, ElementType: type) type {
+pub fn FlexibleArrayType(comptime SelfType: type, comptime ElementType: type) type {
     switch (@typeInfo(SelfType)) {
         .Pointer => |ptr| {
             return @Type(.{ .Pointer = .{
diff --git a/lib/std/zig/parse.zig b/lib/std/zig/parse.zig
index a03764a91cc6b53e3879bd7a87c30c5774ea319d..fda6ad98b94ad139678b542961173bb095989697 100644
--- a/lib/std/zig/parse.zig
+++ b/lib/std/zig/parse.zig
@@ -3670,7 +3670,7 @@ const Parser = struct {
     }
 
     /// KEYWORD_if LPAREN Expr RPAREN PtrPayload? Body (KEYWORD_else Payload? Body)?
-    fn parseIf(p: *Parser, bodyParseFn: fn (p: *Parser) Error!Node.Index) !Node.Index {
+    fn parseIf(p: *Parser, comptime bodyParseFn: fn (p: *Parser) Error!Node.Index) !Node.Index {
         const if_token = p.eatToken(.keyword_if) orelse return null_node;
         _ = try p.expectToken(.l_paren);
         const condition = try p.expectExpr();
diff --git a/src/Module.zig b/src/Module.zig
index 3577115ded112fef1461dc540b8eedc8fa47086c..45e0779c54afcf3df853c4aef5f2e731e8295008 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -6072,17 +6072,17 @@ pub fn paramSrc(
         else => unreachable,
     };
     var it = full.iterate(tree);
-    while (true) {
-        if (it.param_i == param_i) {
-            const param = it.next().?;
+    var i: usize = 0;
+    while (it.next()) |param| : (i += 1) {
+        if (i == param_i) {
             if (param.anytype_ellipsis3) |some| {
                 const main_token = tree.nodes.items(.main_token)[decl.src_node];
                 return .{ .token_offset_param = @bitCast(i32, some) - @bitCast(i32, main_token) };
             }
             return .{ .node_offset_param = decl.nodeIndexToRelative(param.type_expr) };
         }
-        _ = it.next();
     }
+    unreachable;
 }
 
 pub fn argSrc(
diff --git a/src/Sema.zig b/src/Sema.zig
index 582299bc9e765bec1da23bc1c3a9cadb0586567e..a3207b8539b895ee304a593a419ee3102f9242ce 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -76,6 +76,8 @@ types_to_resolve: std.ArrayListUnmanaged(Air.Inst.Ref) = .{},
 post_hoc_blocks: std.AutoHashMapUnmanaged(Air.Inst.Index, *LabeledBlock) = .{},
 /// Populated with the last compile error created.
 err: ?*Module.ErrorMsg = null,
+/// True when analyzing a generic instantiation. Used to suppress some errors.
+is_generic_instantiation: bool = false,
 
 const std = @import("std");
 const math = std.math;
@@ -6495,6 +6497,7 @@ fn instantiateGenericCall(
             .comptime_args = try new_decl_arena_allocator.alloc(TypedValue, uncasted_args.len),
             .comptime_args_fn_inst = module_fn.zir_body_inst,
             .preallocated_new_func = new_module_func,
+            .is_generic_instantiation = true,
         };
         defer child_sema.deinit();
 
@@ -7789,6 +7792,7 @@ fn funcCommon(
                 &is_generic,
                 is_extern,
                 cc_workaround,
+                has_body,
             ) catch |err| switch (err) {
                 error.NeededSourceLocation => {
                     const decl = sema.mod.declPtr(block.src_decl);
@@ -7802,6 +7806,7 @@ fn funcCommon(
                         &is_generic,
                         is_extern,
                         cc_workaround,
+                        has_body,
                     );
                     return error.AnalysisFail;
                 },
@@ -8005,6 +8010,7 @@ fn analyzeParameter(
     is_generic: *bool,
     is_extern: bool,
     cc: std.builtin.CallingConvention,
+    has_body: bool,
 ) !void {
     const requires_comptime = try sema.typeRequiresComptime(block, param_src, param.ty);
     comptime_params[i] = param.is_comptime or requires_comptime;
@@ -8053,9 +8059,9 @@ fn analyzeParameter(
         };
         return sema.failWithOwnedErrorMsg(msg);
     }
-    if (requires_comptime and !param.is_comptime) {
+    if (!sema.is_generic_instantiation and requires_comptime and !param.is_comptime and has_body) {
         const msg = msg: {
-            const msg = try sema.errMsg(block, param_src, "parametter of type '{}' must be declared comptime", .{
+            const msg = try sema.errMsg(block, param_src, "parameter of type '{}' must be declared comptime", .{
                 param.ty.fmt(sema.mod),
             });
             errdefer msg.destroy(sema.gpa);
@@ -8153,7 +8159,7 @@ fn zirParam(
 
     try block.params.append(sema.gpa, .{
         .ty = param_ty,
-        .is_comptime = is_comptime,
+        .is_comptime = comptime_syntax,
         .name = param_name,
     });
     const result = try sema.addConstant(param_ty, Value.initTag(.generic_poison));
@@ -16318,7 +16324,7 @@ fn zirUnaryMath(
     block: *Block,
     inst: Zir.Inst.Index,
     air_tag: Air.Inst.Tag,
-    eval: fn (Value, Type, Allocator, std.Target) Allocator.Error!Value,
+    comptime eval: fn (Value, Type, Allocator, std.Target) Allocator.Error!Value,
 ) CompileError!Air.Inst.Ref {
     const tracy = trace(@src());
     defer tracy.end();
@@ -17777,7 +17783,7 @@ fn zirBitCount(
     block: *Block,
     inst: Zir.Inst.Index,
     air_tag: Air.Inst.Tag,
-    comptimeOp: fn (val: Value, ty: Type, target: std.Target) u64,
+    comptime comptimeOp: fn (val: Value, ty: Type, target: std.Target) u64,
 ) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
@@ -29491,7 +29497,7 @@ pub fn typeRequiresComptime(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Typ
         => {
             const child_ty = ty.childType();
             if (child_ty.zigTypeTag() == .Fn) {
-                return false;
+                return child_ty.fnInfo().is_generic;
             } else {
                 return sema.typeRequiresComptime(block, src, child_ty);
             }
diff --git a/src/type.zig b/src/type.zig
index d2885f537fe9de6258f1f4e9825b53468b78e363..1592dcf469260c63805d8fce60cf0b13d134b305 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -2394,7 +2394,7 @@ pub const Type = extern union {
                 if (ignore_comptime_only) {
                     return true;
                 } else if (ty.childType().zigTypeTag() == .Fn) {
-                    return true;
+                    return !ty.childType().fnInfo().is_generic;
                 } else if (sema_kit) |sk| {
                     return !(try sk.sema.typeRequiresComptime(sk.block, sk.src, ty));
                 } else {
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index ac3a4daeab443157dd0f7e640739af680dd68f82..fa0877258c4069e708787e35129ad39f4c2e740b 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -1281,7 +1281,7 @@ test "*const [N]null u8 to ?[]const u8" {
 test "cast between [*c]T and ?[*:0]T on fn parameter" {
     const S = struct {
         const Handler = ?fn ([*c]const u8) callconv(.C) void;
-        fn addCallback(handler: Handler) void {
+        fn addCallback(comptime handler: Handler) void {
             _ = handler;
         }
 
diff --git a/test/behavior/error.zig b/test/behavior/error.zig
index 84b18a27383ebd053b33614245a0031b003c20a7..b355c858190e17dfa601c7dc44fb61fbf2d83c39 100644
--- a/test/behavior/error.zig
+++ b/test/behavior/error.zig
@@ -168,7 +168,7 @@ fn entryPtr() void {
     fooPtr(ptr);
 }
 
-fn foo2(f: fn () anyerror!void) void {
+fn foo2(comptime f: fn () anyerror!void) void {
     const x = f();
     x catch {
         @panic("fail");
diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig
index 044e4ff049e95c48bf207667b7f40580fa042669..d68cd89210f5079e2b56b5562cdc73c79136c7f4 100644
--- a/test/behavior/fn.zig
+++ b/test/behavior/fn.zig
@@ -137,7 +137,7 @@ test "implicit cast function unreachable return" {
     wantsFnWithVoid(fnWithUnreachable);
 }
 
-fn wantsFnWithVoid(f: fn () void) void {
+fn wantsFnWithVoid(comptime f: fn () void) void {
     _ = f;
 }
 
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index eb29c9038d7a452362cc745e40c8dca7fba03d21..12c874f8baba24078a5b750ed10b92a004c1b0d2 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -147,7 +147,7 @@ test "fn call of struct field" {
             return 13;
         }
 
-        fn callStructField(foo: Foo) i32 {
+        fn callStructField(comptime foo: Foo) i32 {
             return foo.ptr();
         }
     };
diff --git a/test/cases/compile_errors/comptime_parameter_not_declared_as_such.zig b/test/cases/compile_errors/comptime_parameter_not_declared_as_such.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e4d9eed07918af8f188f1fd03d0dcf72f20dab1d
--- /dev/null
+++ b/test/cases/compile_errors/comptime_parameter_not_declared_as_such.zig
@@ -0,0 +1,23 @@
+fn f(_: anytype) void {}
+fn g(h: *const fn (anytype) void) void {
+    h({});
+}
+pub export fn entry() void {
+    g(f);
+}
+
+pub fn comptimeMod(num: anytype, denom: comptime_int) void {
+    _ = num;
+    _ = denom;
+}
+
+pub export fn entry1() void {
+    _ = comptimeMod(1, 2);
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:6: error: parameter of type '*const fn(anytype) void' must be declared comptime
+// :9:34: error: parameter of type 'comptime_int' must be declared comptime
-- 
2.54.0


From c1afe57d70606a20af42cb761b4919765295dcd4 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 22 Aug 2022 00:28:08 +0300
Subject: [PATCH 206/290] Sema: resolve lazy values in
 `resolveMaybeUndefValIntable`

Closes #12512
Closes #12513
---
 src/Sema.zig           |  5 ++++-
 test/behavior/eval.zig | 22 ++++++++++++++++++++++
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index a3207b8539b895ee304a593a419ee3102f9242ce..24bbdb0b0c0e9b220be2f01013ebd9b5ee31e993 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -1698,7 +1698,10 @@ fn resolveMaybeUndefValIntable(
         .elem_ptr => check = check.castTag(.elem_ptr).?.data.array_ptr,
         .eu_payload_ptr, .opt_payload_ptr => check = check.cast(Value.Payload.PayloadPtr).?.data.container_ptr,
         .generic_poison => return error.GenericPoison,
-        else => return val,
+        else => {
+            try sema.resolveLazyValue(block, src, val);
+            return val;
+        },
     };
 }
 
diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
index 49183227b5114443a0727d021cf8251554436152..bc1c3628d77a8a17e25b2673899c19bb57e8c7f9 100644
--- a/test/behavior/eval.zig
+++ b/test/behavior/eval.zig
@@ -1325,3 +1325,25 @@ test "value in if block is comptime known" {
     };
     comptime try expect(std.mem.eql(u8, first, second));
 }
+
+test "lazy sizeof is resolved in division" {
+    const A = struct {
+        a: u32,
+    };
+    const a = 2;
+    try expect(@sizeOf(A) / a == 2);
+    try expect(@sizeOf(A) - a == 2);
+}
+
+test "lazy value is resolved as slice operand" {
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+
+    const A = struct { a: u32 };
+    var a: [512]u64 = undefined;
+
+    const ptr1 = a[0..@sizeOf(A)];
+    const ptr2 = @ptrCast([*]u8, &a)[0..@sizeOf(A)];
+    try expect(@ptrToInt(ptr1) == @ptrToInt(ptr2));
+    try expect(ptr1.len == ptr2.len);
+}
-- 
2.54.0


From 74c7782c6083d398a4f0f126a4597c605d5223cd Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 22 Aug 2022 00:33:57 +0300
Subject: [PATCH 207/290] Sema: make orelse with C pointers behave like stage1
 for now

Closes #12537
---
 src/Sema.zig               | 2 ++
 test/behavior/optional.zig | 7 +++++++
 2 files changed, 9 insertions(+)

diff --git a/src/Sema.zig b/src/Sema.zig
index 24bbdb0b0c0e9b220be2f01013ebd9b5ee31e993..2355e8374d557668770da184fda2e0180482ef77 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -7261,6 +7261,8 @@ fn zirOptionalPayload(
             if (operand_ty.ptrSize() != .C) {
                 return sema.failWithExpectedOptionalType(block, src, operand_ty);
             }
+            // TODO https://github.com/ziglang/zig/issues/6597
+            if (true) break :t operand_ty;
             const ptr_info = operand_ty.ptrInfo().data;
             break :t try Type.ptr(sema.arena, sema.mod, .{
                 .pointee_type = try ptr_info.pointee_type.copy(sema.arena),
diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig
index c13a3b7e4fd2c82de872d373bf10d9fbb7c7e78a..28261daf1f97242558522dad2468e6f400260c44 100644
--- a/test/behavior/optional.zig
+++ b/test/behavior/optional.zig
@@ -405,3 +405,10 @@ test "optional of noreturn used with orelse" {
     const val = NoReturn.testOrelse();
     try expect(val == 123);
 }
+
+test "orelse on C pointer" {
+    // TODO https://github.com/ziglang/zig/issues/6597
+    const foo: [*c]const u8 = "hey";
+    const d = foo orelse @compileError("bad");
+    try expectEqual([*c]const u8, @TypeOf(d));
+}
-- 
2.54.0


From b0bcd4add29b6fbbe2bbc22719703d3c81ed594b Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 22 Aug 2022 10:17:58 +0300
Subject: [PATCH 208/290] Sema: allow optional pointers in packed structs

Closes #12572
---
 src/Sema.zig                    |  2 +-
 src/codegen/llvm.zig            |  9 ++++++---
 test/behavior/packed-struct.zig | 12 ++++++++++++
 3 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 2355e8374d557668770da184fda2e0180482ef77..9538073e5cf1518d8b8f5f4bfaacae8bbbdf66cf 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -20565,8 +20565,8 @@ fn validatePackedType(ty: Type) bool {
         .AnyFrame,
         .Fn,
         .Array,
-        .Optional,
         => return false,
+        .Optional => return ty.isPtrLikeOptional(),
         .Void,
         .Bool,
         .Float,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 5c537cd5bcb2362406fdad8c652a9dd3a5280f75..98458854d1803306abc56275050ea7aff95beae5 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -3417,7 +3417,10 @@ pub const DeclGen = struct {
                         });
                         const ty_bit_size = @intCast(u16, field.ty.bitSize(target));
                         const small_int_ty = dg.context.intType(ty_bit_size);
-                        const small_int_val = non_int_val.constBitCast(small_int_ty);
+                        const small_int_val = if (field.ty.isPtrAtRuntime())
+                            non_int_val.constPtrToInt(small_int_ty)
+                        else
+                            non_int_val.constBitCast(small_int_ty);
                         const shift_rhs = int_llvm_ty.constInt(running_bits, .False);
                         // If the field is as large as the entire packed struct, this
                         // zext would go from, e.g. i16 to i16. This is legal with
@@ -5343,7 +5346,7 @@ pub const FuncGen = struct {
                             const same_size_int = self.context.intType(elem_bits);
                             const truncated_int = self.builder.buildTrunc(shifted_value, same_size_int, "");
                             return self.builder.buildBitCast(truncated_int, elem_llvm_ty, "");
-                        } else if (field_ty.zigTypeTag() == .Pointer) {
+                        } else if (field_ty.isPtrAtRuntime()) {
                             const elem_bits = @intCast(c_uint, field_ty.bitSize(target));
                             const same_size_int = self.context.intType(elem_bits);
                             const truncated_int = self.builder.buildTrunc(shifted_value, same_size_int, "");
@@ -8408,7 +8411,7 @@ pub const FuncGen = struct {
                         const non_int_val = try self.resolveInst(elem);
                         const ty_bit_size = @intCast(u16, field.ty.bitSize(target));
                         const small_int_ty = self.dg.context.intType(ty_bit_size);
-                        const small_int_val = if (field.ty.zigTypeTag() == .Pointer)
+                        const small_int_val = if (field.ty.isPtrAtRuntime())
                             self.builder.buildPtrToInt(non_int_val, small_int_ty, "")
                         else
                             self.builder.buildBitCast(non_int_val, small_int_ty, "");
diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index 8c34f5741b4f17fad1d3e4fd4b70528648ca45b9..540914bd259722d27a0ec5db85c233ed184fe4a7 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -434,3 +434,15 @@ test "@ptrToInt on a packed struct field" {
     };
     try expect(@ptrToInt(&S.p0.z) - @ptrToInt(&S.p0.x) == 2);
 }
+
+test "optional pointer in packed struct" {
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+
+    const T = packed struct { ptr: ?*const u8 };
+    var n: u8 = 0;
+    const x = T{ .ptr = &n };
+    try expect(x.ptr.? == &n);
+}
-- 
2.54.0


From 560baf67ce77de41da3d03183300cdf1b6d90567 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 22 Aug 2022 10:54:07 +0300
Subject: [PATCH 209/290] Sema: fix implicit cast from extern fn to fn ptr

Closes #12570
---
 src/Sema.zig         |  2 +-
 test/behavior/fn.zig | 21 +++++++++++++++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 9538073e5cf1518d8b8f5f4bfaacae8bbbdf66cf..42d5e96d3dfe7d832c60626295328614072a71ae 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -22564,7 +22564,7 @@ fn coerceExtra(
             // Function body to function pointer.
             if (inst_ty.zigTypeTag() == .Fn) {
                 const fn_val = try sema.resolveConstValue(block, .unneeded, inst, undefined);
-                const fn_decl = fn_val.castTag(.function).?.data.owner_decl;
+                const fn_decl = fn_val.pointerDecl().?;
                 const inst_as_ptr = try sema.analyzeDeclRef(fn_decl);
                 return sema.coerce(block, dest_ty, inst_as_ptr, inst_src);
             }
diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig
index d68cd89210f5079e2b56b5562cdc73c79136c7f4..47ba63c429582d41df0d1949c09ad3c2c0e4face 100644
--- a/test/behavior/fn.zig
+++ b/test/behavior/fn.zig
@@ -422,3 +422,24 @@ test "import passed byref to function in return type" {
     var list = S.get();
     try expect(list.items.len == 0);
 }
+
+test "implicit cast function to function ptr" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+    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_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+
+    const S1 = struct {
+        export fn someFunctionThatReturnsAValue() c_int {
+            return 123;
+        }
+    };
+    var fnPtr1: *const fn () callconv(.C) c_int = S1.someFunctionThatReturnsAValue;
+    try expect(fnPtr1() == 123);
+    const S2 = struct {
+        extern fn someFunctionThatReturnsAValue() c_int;
+    };
+    var fnPtr2: *const fn () callconv(.C) c_int = S2.someFunctionThatReturnsAValue;
+    try expect(fnPtr2() == 123);
+}
-- 
2.54.0


From 62ff8871ed9c8c4e46d8acd1d227ed3fb802be7f Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sun, 21 Aug 2022 17:24:04 +0300
Subject: [PATCH 210/290] stage2+stage1: remove type parameter from bit
 builtins

Closes #12529
Closes #12511
Closes #6835
---
 doc/langref.html.in                           | 20 ++--
 lib/compiler_rt/addf3.zig                     |  4 +-
 lib/compiler_rt/common.zig                    |  2 +-
 lib/compiler_rt/extendf.zig                   |  8 +-
 lib/compiler_rt/extendxftf2.zig               |  2 +-
 lib/compiler_rt/int.zig                       |  2 +-
 lib/compiler_rt/int_to_float.zig              |  4 +-
 lib/compiler_rt/mulf3.zig                     |  2 +-
 lib/compiler_rt/udivmod.zig                   | 10 +-
 lib/std/Thread/Futex.zig                      |  4 +-
 lib/std/Thread/Mutex.zig                      |  2 +-
 lib/std/Thread/RwLock.zig                     |  4 +-
 lib/std/bit_set.zig                           | 26 ++---
 lib/std/compress/deflate/bits_utils.zig       |  2 +-
 lib/std/crypto/aes_ocb.zig                    | 10 +-
 lib/std/crypto/ghash.zig                      | 32 +++----
 lib/std/elf.zig                               |  6 +-
 lib/std/event/channel.zig                     |  2 +-
 lib/std/fmt.zig                               |  4 +-
 .../fmt/parse_float/convert_eisel_lemire.zig  |  2 +-
 lib/std/hash/cityhash.zig                     | 10 +-
 lib/std/hash/murmur.zig                       | 22 ++---
 lib/std/heap.zig                              |  4 +-
 lib/std/leb128.zig                            |  2 +-
 lib/std/math.zig                              |  4 +-
 lib/std/math/big/int.zig                      | 14 +--
 lib/std/mem.zig                               | 26 ++---
 lib/std/os/linux.zig                          |  2 +-
 lib/std/os/uefi.zig                           |  6 +-
 lib/std/packed_int_array.zig                  |  6 +-
 lib/std/priority_dequeue.zig                  |  2 +-
 lib/std/rand.zig                              | 10 +-
 lib/std/zig/c_builtins.zig                    | 12 +--
 lib/std/zig/system/NativeTargetInfo.zig       |  4 +-
 src/AstGen.zig                                | 18 +---
 src/BuiltinFn.zig                             | 10 +-
 src/Sema.zig                                  | 19 ++--
 src/arch/aarch64/Emit.zig                     |  4 +-
 src/arch/wasm/Emit.zig                        |  2 +-
 src/link/MachO/Object.zig                     |  2 +-
 src/link/Wasm.zig                             |  4 +-
 src/stage1/astgen.cpp                         |  6 +-
 src/stage1/codegen.cpp                        | 10 +-
 src/value.zig                                 | 10 +-
 test/behavior/bitreverse.zig                  | 94 +++++++++----------
 test/behavior/bugs/10147.zig                  |  5 +-
 test/behavior/bugs/2114.zig                   |  2 +-
 test/behavior/byteswap.zig                    | 15 ++-
 test/behavior/comptime_memory.zig             |  2 +-
 test/behavior/math.zig                        | 14 +--
 test/behavior/popcount.zig                    | 29 +++---
 ...rors_in_for_loop_bodies_are_propagated.zig |  4 +-
 .../compile_errors/popCount-non-integer.zig   |  4 +-
 tools/gen_spirv_spec.zig                      |  4 +-
 tools/gen_stubs.zig                           |  2 +-
 55 files changed, 264 insertions(+), 268 deletions(-)

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 9247d3bc4394d0022722475aff74ac6dcc7e2174..37631a967849b8e3d5e05f22e098308442703436 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -8031,8 +8031,8 @@ fn func(y: *i32) void {
       {#header_close#}
 
       {#header_open|@byteSwap#}
-      <pre>{#syntax#}@byteSwap(comptime T: type, operand: T) T{#endsyntax#}</pre>
-      <p>{#syntax#}T{#endsyntax#} must be an integer type with bit count evenly divisible by 8.</p>
+      <pre>{#syntax#}@byteSwap(operand: anytype) T{#endsyntax#}</pre>
+      <p>{#syntax#}@TypeOf(operand){#endsyntax#} must be an integer type or an integer vector type with bit count evenly divisible by 8.</p>
       <p>{#syntax#}operand{#endsyntax#} may be an {#link|integer|Integers#} or {#link|vector|Vectors#}.</p>
       <p>
       Swaps the byte order of the integer. This converts a big endian integer to a little endian integer,
@@ -8049,8 +8049,8 @@ fn func(y: *i32) void {
       {#header_close#}
 
       {#header_open|@bitReverse#}
-      <pre>{#syntax#}@bitReverse(comptime T: type, integer: T) T{#endsyntax#}</pre>
-      <p>{#syntax#}T{#endsyntax#} accepts any integer type.</p>
+      <pre>{#syntax#}@bitReverse(integer: anytype) T{#endsyntax#}</pre>
+      <p>{#syntax#}@TypeOf(anytype){#endsyntax#} accepts any integer type or integer vector type.</p>
       <p>
       Reverses the bitpattern of an integer value, including the sign bit if applicable.
       </p>
@@ -8189,8 +8189,8 @@ pub const CallOptions = struct {
       {#header_close#}
 
       {#header_open|@clz#}
-      <pre>{#syntax#}@clz(comptime T: type, operand: T){#endsyntax#}</pre>
-      <p>{#syntax#}T{#endsyntax#} must be an integer type.</p>
+      <pre>{#syntax#}@clz(operand: anytype){#endsyntax#}</pre>
+      <p>{#syntax#}@TypeOf(operand){#endsyntax#} must be an integer type or an integer vector type.</p>
       <p>{#syntax#}operand{#endsyntax#} may be an {#link|integer|Integers#} or {#link|vector|Vectors#}.</p>
       <p>
       This function counts the number of most-significant (leading in a big-Endian sense) zeroes in an integer.
@@ -8335,8 +8335,8 @@ test "main" {
       {#header_close#}
 
       {#header_open|@ctz#}
-      <pre>{#syntax#}@ctz(comptime T: type, operand: T){#endsyntax#}</pre>
-      <p>{#syntax#}T{#endsyntax#} must be an integer type.</p>
+      <pre>{#syntax#}@ctz(operand: anytype){#endsyntax#}</pre>
+      <p>{#syntax#}@TypeOf(operand){#endsyntax#} must be an integer type or an integer vector type.</p>
       <p>{#syntax#}operand{#endsyntax#} may be an {#link|integer|Integers#} or {#link|vector|Vectors#}.</p>
       <p>
       This function counts the number of least-significant (trailing in a big-Endian sense) zeroes in an integer.
@@ -8972,8 +8972,8 @@ test "@wasmMemoryGrow" {
       {#header_close#}
 
       {#header_open|@popCount#}
-      <pre>{#syntax#}@popCount(comptime T: type, operand: T){#endsyntax#}</pre>
-      <p>{#syntax#}T{#endsyntax#} must be an integer type.</p>
+      <pre>{#syntax#}@popCount(operand: anytype){#endsyntax#}</pre>
+      <p>{#syntax#}@TypeOf(operand){#endsyntax#} must be an integer type.</p>
       <p>{#syntax#}operand{#endsyntax#} may be an {#link|integer|Integers#} or {#link|vector|Vectors#}.</p>
       <p>Counts the number of bits set in an integer.</p>
       <p>
diff --git a/lib/compiler_rt/addf3.zig b/lib/compiler_rt/addf3.zig
index 7f2e368121b76a8d6acd92ec51175fa1053e987f..8edfef98381c4779331ab9b896f5040a46d6f61e 100644
--- a/lib/compiler_rt/addf3.zig
+++ b/lib/compiler_rt/addf3.zig
@@ -9,7 +9,7 @@ const normalize = common.normalize;
 pub inline fn addf3(comptime T: type, a: T, b: T) T {
     const bits = @typeInfo(T).Float.bits;
     const Z = std.meta.Int(.unsigned, bits);
-    const S = std.meta.Int(.unsigned, bits - @clz(Z, @as(Z, bits) - 1));
+    const S = std.meta.Int(.unsigned, bits - @clz(@as(Z, bits) - 1));
 
     const typeWidth = bits;
     const significandBits = math.floatMantissaBits(T);
@@ -118,7 +118,7 @@ pub inline fn addf3(comptime T: type, a: T, b: T) T {
         // If partial cancellation occured, we need to left-shift the result
         // and adjust the exponent:
         if (aSignificand < integerBit << 3) {
-            const shift = @intCast(i32, @clz(Z, aSignificand)) - @intCast(i32, @clz(std.meta.Int(.unsigned, bits), integerBit << 3));
+            const shift = @intCast(i32, @clz(aSignificand)) - @intCast(i32, @clz(integerBit << 3));
             aSignificand <<= @intCast(S, shift);
             aExponent -= shift;
         }
diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig
index 3f91a0c79b4ca5abdd30fec293059bbca168bc5e..d619926f9989eeab095c8b39507ee5cb5e4d6ae0 100644
--- a/lib/compiler_rt/common.zig
+++ b/lib/compiler_rt/common.zig
@@ -192,7 +192,7 @@ pub fn normalize(comptime T: type, significand: *std.meta.Int(.unsigned, @typeIn
     const Z = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
     const integerBit = @as(Z, 1) << std.math.floatFractionalBits(T);
 
-    const shift = @clz(Z, significand.*) - @clz(Z, integerBit);
+    const shift = @clz(significand.*) - @clz(integerBit);
     significand.* <<= @intCast(std.math.Log2Int(Z), shift);
     return @as(i32, 1) - shift;
 }
diff --git a/lib/compiler_rt/extendf.zig b/lib/compiler_rt/extendf.zig
index 8eb23c1d82f4c5e8684e1892f06c43223a7161f6..2bb40fc2bd924bc1bb504308fec79c1842e35f81 100644
--- a/lib/compiler_rt/extendf.zig
+++ b/lib/compiler_rt/extendf.zig
@@ -56,8 +56,8 @@ pub inline fn extendf(
         // a is denormal.
         // renormalize the significand and clear the leading bit, then insert
         // the correct adjusted exponent in the destination type.
-        const scale: u32 = @clz(src_rep_t, aAbs) -
-            @clz(src_rep_t, @as(src_rep_t, srcMinNormal));
+        const scale: u32 = @clz(aAbs) -
+            @clz(@as(src_rep_t, srcMinNormal));
         absResult = @as(dst_rep_t, aAbs) << @intCast(DstShift, dstSigBits - srcSigBits + scale);
         absResult ^= dstMinNormal;
         const resultExponent: u32 = dstExpBias - srcExpBias - scale + 1;
@@ -119,8 +119,8 @@ pub inline fn extend_f80(comptime src_t: type, a: std.meta.Int(.unsigned, @typeI
         // a is denormal.
         // renormalize the significand and clear the leading bit, then insert
         // the correct adjusted exponent in the destination type.
-        const scale: u16 = @clz(src_rep_t, a_abs) -
-            @clz(src_rep_t, @as(src_rep_t, src_min_normal));
+        const scale: u16 = @clz(a_abs) -
+            @clz(@as(src_rep_t, src_min_normal));
 
         dst.fraction = @as(u64, a_abs) << @intCast(u6, dst_sig_bits - src_sig_bits + scale);
         dst.fraction |= dst_int_bit; // bit 64 is always set for normal numbers
diff --git a/lib/compiler_rt/extendxftf2.zig b/lib/compiler_rt/extendxftf2.zig
index bb5d6a377bd5106200191b0d49f7eeb2e83a2695..077d510646439302535afeeae8bf22de64424498 100644
--- a/lib/compiler_rt/extendxftf2.zig
+++ b/lib/compiler_rt/extendxftf2.zig
@@ -38,7 +38,7 @@ fn __extendxftf2(a: f80) callconv(.C) f128 {
         // a is denormal
         // renormalize the significand and clear the leading bit and integer part,
         // then insert the correct adjusted exponent in the destination type.
-        const scale: u32 = @clz(u64, a_rep.fraction);
+        const scale: u32 = @clz(a_rep.fraction);
         abs_result = @as(u128, a_rep.fraction) << @intCast(u7, dst_sig_bits - src_sig_bits + scale + 1);
         abs_result ^= dst_min_normal;
         abs_result |= @as(u128, scale + 1) << dst_sig_bits;
diff --git a/lib/compiler_rt/int.zig b/lib/compiler_rt/int.zig
index 53205e2ed95affab26b21b185904c3966f16a5e6..43bc160cda9fcf84d8c2e5cf98a114ea7773d06a 100644
--- a/lib/compiler_rt/int.zig
+++ b/lib/compiler_rt/int.zig
@@ -243,7 +243,7 @@ inline fn div_u32(n: u32, d: u32) u32 {
     // special cases
     if (d == 0) return 0; // ?!
     if (n == 0) return 0;
-    var sr = @bitCast(c_uint, @as(c_int, @clz(u32, d)) - @as(c_int, @clz(u32, n)));
+    var sr = @bitCast(c_uint, @as(c_int, @clz(d)) - @as(c_int, @clz(n)));
     // 0 <= sr <= n_uword_bits - 1 or sr large
     if (sr > n_uword_bits - 1) {
         // d > r
diff --git a/lib/compiler_rt/int_to_float.zig b/lib/compiler_rt/int_to_float.zig
index 233dfec815af138ef8ee96b88eb43e6df18cbd0b..2eb7b5ade8ed914b443d936cccb57b742fc5d054 100644
--- a/lib/compiler_rt/int_to_float.zig
+++ b/lib/compiler_rt/int_to_float.zig
@@ -23,7 +23,7 @@ pub fn intToFloat(comptime T: type, x: anytype) T {
     var result: uT = sign_bit;
 
     // Compute significand
-    var exp = int_bits - @clz(Z, abs_val) - 1;
+    var exp = int_bits - @clz(abs_val) - 1;
     if (int_bits <= fractional_bits or exp <= fractional_bits) {
         const shift_amt = fractional_bits - @intCast(math.Log2Int(uT), exp);
 
@@ -32,7 +32,7 @@ pub fn intToFloat(comptime T: type, x: anytype) T {
         result ^= implicit_bit; // Remove implicit integer bit
     } else {
         var shift_amt = @intCast(math.Log2Int(Z), exp - fractional_bits);
-        const exact_tie: bool = @ctz(Z, abs_val) == shift_amt - 1;
+        const exact_tie: bool = @ctz(abs_val) == shift_amt - 1;
 
         // Shift down result and remove implicit integer bit
         result = @intCast(uT, (abs_val >> (shift_amt - 1))) ^ (implicit_bit << 1);
diff --git a/lib/compiler_rt/mulf3.zig b/lib/compiler_rt/mulf3.zig
index f6949ee3ce52063c0ee5a5310f7bc81b6c515ed5..770721cb80bc8aee09d610ba8dbbc8c82945daef 100644
--- a/lib/compiler_rt/mulf3.zig
+++ b/lib/compiler_rt/mulf3.zig
@@ -186,7 +186,7 @@ fn normalize(comptime T: type, significand: *PowerOfTwoSignificandZ(T)) i32 {
     const Z = PowerOfTwoSignificandZ(T);
     const integerBit = @as(Z, 1) << math.floatFractionalBits(T);
 
-    const shift = @clz(Z, significand.*) - @clz(Z, integerBit);
+    const shift = @clz(significand.*) - @clz(integerBit);
     significand.* <<= @intCast(math.Log2Int(Z), shift);
     return @as(i32, 1) - shift;
 }
diff --git a/lib/compiler_rt/udivmod.zig b/lib/compiler_rt/udivmod.zig
index d941c242d2cff3b6fc57e4a4516103c72e4e9f6a..065ea448960be55979a9c1f43f9bce0fb7ff3906 100644
--- a/lib/compiler_rt/udivmod.zig
+++ b/lib/compiler_rt/udivmod.zig
@@ -75,12 +75,12 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
                 r[high] = n[high] & (d[high] - 1);
                 rem.* = @ptrCast(*align(@alignOf(SingleInt)) DoubleInt, &r[0]).*; // TODO issue #421
             }
-            return n[high] >> @intCast(Log2SingleInt, @ctz(SingleInt, d[high]));
+            return n[high] >> @intCast(Log2SingleInt, @ctz(d[high]));
         }
         // K K
         // ---
         // K 0
-        sr = @bitCast(c_uint, @as(c_int, @clz(SingleInt, d[high])) - @as(c_int, @clz(SingleInt, n[high])));
+        sr = @bitCast(c_uint, @as(c_int, @clz(d[high])) - @as(c_int, @clz(n[high])));
         // 0 <= sr <= single_int_bits - 2 or sr large
         if (sr > single_int_bits - 2) {
             if (maybe_rem) |rem| {
@@ -110,7 +110,7 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
                 if (d[low] == 1) {
                     return a;
                 }
-                sr = @ctz(SingleInt, d[low]);
+                sr = @ctz(d[low]);
                 q[high] = n[high] >> @intCast(Log2SingleInt, sr);
                 q[low] = (n[high] << @intCast(Log2SingleInt, single_int_bits - sr)) | (n[low] >> @intCast(Log2SingleInt, sr));
                 return @ptrCast(*align(@alignOf(SingleInt)) DoubleInt, &q[0]).*; // TODO issue #421
@@ -118,7 +118,7 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
             // K X
             // ---
             // 0 K
-            sr = 1 + single_int_bits + @as(c_uint, @clz(SingleInt, d[low])) - @as(c_uint, @clz(SingleInt, n[high]));
+            sr = 1 + single_int_bits + @as(c_uint, @clz(d[low])) - @as(c_uint, @clz(n[high]));
             // 2 <= sr <= double_int_bits - 1
             // q.all = a << (double_int_bits - sr);
             // r.all = a >> sr;
@@ -144,7 +144,7 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
             // K X
             // ---
             // K K
-            sr = @bitCast(c_uint, @as(c_int, @clz(SingleInt, d[high])) - @as(c_int, @clz(SingleInt, n[high])));
+            sr = @bitCast(c_uint, @as(c_int, @clz(d[high])) - @as(c_int, @clz(n[high])));
             // 0 <= sr <= single_int_bits - 1 or sr large
             if (sr > single_int_bits - 1) {
                 if (maybe_rem) |rem| {
diff --git a/lib/std/Thread/Futex.zig b/lib/std/Thread/Futex.zig
index 0d9ccc89692fde2cd9ddf899ddeb13a0bb929769..58f49c483ecdb10dc9ebe9b4fbbc766a18e71adf 100644
--- a/lib/std/Thread/Futex.zig
+++ b/lib/std/Thread/Futex.zig
@@ -703,7 +703,7 @@ const PosixImpl = struct {
             const max_multiplier_bits = @bitSizeOf(usize);
             const fibonacci_multiplier = 0x9E3779B97F4A7C15 >> (64 - max_multiplier_bits);
 
-            const max_bucket_bits = @ctz(usize, buckets.len);
+            const max_bucket_bits = @ctz(buckets.len);
             comptime assert(std.math.isPowerOfTwo(buckets.len));
 
             const index = (address *% fibonacci_multiplier) >> (max_multiplier_bits - max_bucket_bits);
@@ -721,7 +721,7 @@ const PosixImpl = struct {
             // then cut off the zero bits from the alignment to get the unique address.
             const addr = @ptrToInt(ptr);
             assert(addr & (alignment - 1) == 0);
-            return addr >> @ctz(usize, alignment);
+            return addr >> @ctz(alignment);
         }
     };
 
diff --git a/lib/std/Thread/Mutex.zig b/lib/std/Thread/Mutex.zig
index 35d754ad19c3a27fd401db62a1696878b3994a73..973a312665e0e0a8ed0c770a9692f04769a01431 100644
--- a/lib/std/Thread/Mutex.zig
+++ b/lib/std/Thread/Mutex.zig
@@ -140,7 +140,7 @@ const FutexImpl = struct {
         // - they both seem to mark the cache-line as modified regardless: https://stackoverflow.com/a/63350048
         // - `lock bts` is smaller instruction-wise which makes it better for inlining
         if (comptime builtin.target.cpu.arch.isX86()) {
-            const locked_bit = @ctz(u32, @as(u32, locked));
+            const locked_bit = @ctz(@as(u32, locked));
             return self.state.bitSet(locked_bit, .Acquire) == 0;
         }
 
diff --git a/lib/std/Thread/RwLock.zig b/lib/std/Thread/RwLock.zig
index 201e1cc8604e777dd8b7afc3048baf5d082ca46d..46d46cdfa42a9282c974c2781b95cf1ff4db5251 100644
--- a/lib/std/Thread/RwLock.zig
+++ b/lib/std/Thread/RwLock.zig
@@ -168,8 +168,8 @@ pub const DefaultRwLock = struct {
     const IS_WRITING: usize = 1;
     const WRITER: usize = 1 << 1;
     const READER: usize = 1 << (1 + @bitSizeOf(Count));
-    const WRITER_MASK: usize = std.math.maxInt(Count) << @ctz(usize, WRITER);
-    const READER_MASK: usize = std.math.maxInt(Count) << @ctz(usize, READER);
+    const WRITER_MASK: usize = std.math.maxInt(Count) << @ctz(WRITER);
+    const READER_MASK: usize = std.math.maxInt(Count) << @ctz(READER);
     const Count = std.meta.Int(.unsigned, @divFloor(@bitSizeOf(usize) - 1, 2));
 
     pub fn tryLock(rwl: *DefaultRwLock) bool {
diff --git a/lib/std/bit_set.zig b/lib/std/bit_set.zig
index 8006a623b5bcbd1aee19f4bba24ec7f18841459b..2da3f1ac21ff64d0a892b422e0611f2a39891341 100644
--- a/lib/std/bit_set.zig
+++ b/lib/std/bit_set.zig
@@ -91,7 +91,7 @@ pub fn IntegerBitSet(comptime size: u16) type {
 
         /// Returns the total number of set bits in this bit set.
         pub fn count(self: Self) usize {
-            return @popCount(MaskInt, self.mask);
+            return @popCount(self.mask);
         }
 
         /// Changes the value of the specified bit of the bit
@@ -179,7 +179,7 @@ pub fn IntegerBitSet(comptime size: u16) type {
         pub fn findFirstSet(self: Self) ?usize {
             const mask = self.mask;
             if (mask == 0) return null;
-            return @ctz(MaskInt, mask);
+            return @ctz(mask);
         }
 
         /// Finds the index of the first set bit, and unsets it.
@@ -187,7 +187,7 @@ pub fn IntegerBitSet(comptime size: u16) type {
         pub fn toggleFirstSet(self: *Self) ?usize {
             const mask = self.mask;
             if (mask == 0) return null;
-            const index = @ctz(MaskInt, mask);
+            const index = @ctz(mask);
             self.mask = mask & (mask - 1);
             return index;
         }
@@ -222,12 +222,12 @@ pub fn IntegerBitSet(comptime size: u16) type {
 
                     switch (direction) {
                         .forward => {
-                            const next_index = @ctz(MaskInt, self.bits_remain);
+                            const next_index = @ctz(self.bits_remain);
                             self.bits_remain &= self.bits_remain - 1;
                             return next_index;
                         },
                         .reverse => {
-                            const leading_zeroes = @clz(MaskInt, self.bits_remain);
+                            const leading_zeroes = @clz(self.bits_remain);
                             const top_bit = (@bitSizeOf(MaskInt) - 1) - leading_zeroes;
                             self.bits_remain &= (@as(MaskInt, 1) << @intCast(ShiftInt, top_bit)) - 1;
                             return top_bit;
@@ -347,7 +347,7 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
         pub fn count(self: Self) usize {
             var total: usize = 0;
             for (self.masks) |mask| {
-                total += @popCount(MaskInt, mask);
+                total += @popCount(mask);
             }
             return total;
         }
@@ -475,7 +475,7 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
                 if (mask != 0) break mask;
                 offset += @bitSizeOf(MaskInt);
             } else return null;
-            return offset + @ctz(MaskInt, mask);
+            return offset + @ctz(mask);
         }
 
         /// Finds the index of the first set bit, and unsets it.
@@ -486,7 +486,7 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
                 if (mask.* != 0) break mask;
                 offset += @bitSizeOf(MaskInt);
             } else return null;
-            const index = @ctz(MaskInt, mask.*);
+            const index = @ctz(mask.*);
             mask.* &= (mask.* - 1);
             return offset + index;
         }
@@ -657,7 +657,7 @@ pub const DynamicBitSetUnmanaged = struct {
         var total: usize = 0;
         for (self.masks[0..num_masks]) |mask| {
             // Note: This is where we depend on padding bits being zero
-            total += @popCount(MaskInt, mask);
+            total += @popCount(mask);
         }
         return total;
     }
@@ -795,7 +795,7 @@ pub const DynamicBitSetUnmanaged = struct {
             mask += 1;
             offset += @bitSizeOf(MaskInt);
         } else return null;
-        return offset + @ctz(MaskInt, mask[0]);
+        return offset + @ctz(mask[0]);
     }
 
     /// Finds the index of the first set bit, and unsets it.
@@ -808,7 +808,7 @@ pub const DynamicBitSetUnmanaged = struct {
             mask += 1;
             offset += @bitSizeOf(MaskInt);
         } else return null;
-        const index = @ctz(MaskInt, mask[0]);
+        const index = @ctz(mask[0]);
         mask[0] &= (mask[0] - 1);
         return offset + index;
     }
@@ -1067,12 +1067,12 @@ fn BitSetIterator(comptime MaskInt: type, comptime options: IteratorOptions) typ
 
             switch (direction) {
                 .forward => {
-                    const next_index = @ctz(MaskInt, self.bits_remain) + self.bit_offset;
+                    const next_index = @ctz(self.bits_remain) + self.bit_offset;
                     self.bits_remain &= self.bits_remain - 1;
                     return next_index;
                 },
                 .reverse => {
-                    const leading_zeroes = @clz(MaskInt, self.bits_remain);
+                    const leading_zeroes = @clz(self.bits_remain);
                     const top_bit = (@bitSizeOf(MaskInt) - 1) - leading_zeroes;
                     const no_top_bit_mask = (@as(MaskInt, 1) << @intCast(ShiftInt, top_bit)) - 1;
                     self.bits_remain &= no_top_bit_mask;
diff --git a/lib/std/compress/deflate/bits_utils.zig b/lib/std/compress/deflate/bits_utils.zig
index cb1237c90099392d3b6794c2b44c04221f5c5c14..1620a8e380842ed1d46eeacf6b141bf6d5bbcf49 100644
--- a/lib/std/compress/deflate/bits_utils.zig
+++ b/lib/std/compress/deflate/bits_utils.zig
@@ -2,7 +2,7 @@ const math = @import("std").math;
 
 // Reverse bit-by-bit a N-bit code.
 pub fn bitReverse(comptime T: type, value: T, N: usize) T {
-    const r = @bitReverse(T, value);
+    const r = @bitReverse(value);
     return r >> @intCast(math.Log2Int(T), @typeInfo(T).Int.bits - N);
 }
 
diff --git a/lib/std/crypto/aes_ocb.zig b/lib/std/crypto/aes_ocb.zig
index cc50bbbe45b20f4fcfccbfba14edd5cd5ed6ae7b..68f5bc4a9a047d04c4d47dbfdf9e6919c7c593bb 100644
--- a/lib/std/crypto/aes_ocb.zig
+++ b/lib/std/crypto/aes_ocb.zig
@@ -66,7 +66,7 @@ fn AesOcb(comptime Aes: anytype) type {
             var offset = [_]u8{0} ** 16;
             var i: usize = 0;
             while (i < full_blocks) : (i += 1) {
-                xorWith(&offset, lt[@ctz(usize, i + 1)]);
+                xorWith(&offset, lt[@ctz(i + 1)]);
                 var e = xorBlocks(offset, a[i * 16 ..][0..16].*);
                 aes_enc_ctx.encrypt(&e, &e);
                 xorWith(&sum, e);
@@ -129,7 +129,7 @@ fn AesOcb(comptime Aes: anytype) type {
                 var es: [16 * wb]u8 align(16) = undefined;
                 var j: usize = 0;
                 while (j < wb) : (j += 1) {
-                    xorWith(&offset, lt[@ctz(usize, i + 1 + j)]);
+                    xorWith(&offset, lt[@ctz(i + 1 + j)]);
                     offsets[j] = offset;
                     const p = m[(i + j) * 16 ..][0..16].*;
                     mem.copy(u8, es[j * 16 ..][0..16], &xorBlocks(p, offsets[j]));
@@ -143,7 +143,7 @@ fn AesOcb(comptime Aes: anytype) type {
                 }
             }
             while (i < full_blocks) : (i += 1) {
-                xorWith(&offset, lt[@ctz(usize, i + 1)]);
+                xorWith(&offset, lt[@ctz(i + 1)]);
                 const p = m[i * 16 ..][0..16].*;
                 var e = xorBlocks(p, offset);
                 aes_enc_ctx.encrypt(&e, &e);
@@ -193,7 +193,7 @@ fn AesOcb(comptime Aes: anytype) type {
                 var es: [16 * wb]u8 align(16) = undefined;
                 var j: usize = 0;
                 while (j < wb) : (j += 1) {
-                    xorWith(&offset, lt[@ctz(usize, i + 1 + j)]);
+                    xorWith(&offset, lt[@ctz(i + 1 + j)]);
                     offsets[j] = offset;
                     const q = c[(i + j) * 16 ..][0..16].*;
                     mem.copy(u8, es[j * 16 ..][0..16], &xorBlocks(q, offsets[j]));
@@ -207,7 +207,7 @@ fn AesOcb(comptime Aes: anytype) type {
                 }
             }
             while (i < full_blocks) : (i += 1) {
-                xorWith(&offset, lt[@ctz(usize, i + 1)]);
+                xorWith(&offset, lt[@ctz(i + 1)]);
                 const q = c[i * 16 ..][0..16].*;
                 var e = xorBlocks(q, offset);
                 aes_dec_ctx.decrypt(&e, &e);
diff --git a/lib/std/crypto/ghash.zig b/lib/std/crypto/ghash.zig
index f3fac0038e036e835e0aa7b6e73ffbf012d3b443..8f57f9033ae91d1cf22e7ae970d700abb6cc8e15 100644
--- a/lib/std/crypto/ghash.zig
+++ b/lib/std/crypto/ghash.zig
@@ -41,8 +41,8 @@ pub const Ghash = struct {
     pub fn init(key: *const [key_length]u8) Ghash {
         const h1 = mem.readIntBig(u64, key[0..8]);
         const h0 = mem.readIntBig(u64, key[8..16]);
-        const h1r = @bitReverse(u64, h1);
-        const h0r = @bitReverse(u64, h0);
+        const h1r = @bitReverse(h1);
+        const h0r = @bitReverse(h0);
         const h2 = h0 ^ h1;
         const h2r = h0r ^ h1r;
 
@@ -68,8 +68,8 @@ pub const Ghash = struct {
             hh.update(key);
             const hh1 = hh.y1;
             const hh0 = hh.y0;
-            const hh1r = @bitReverse(u64, hh1);
-            const hh0r = @bitReverse(u64, hh0);
+            const hh1r = @bitReverse(hh1);
+            const hh0r = @bitReverse(hh0);
             const hh2 = hh0 ^ hh1;
             const hh2r = hh0r ^ hh1r;
 
@@ -156,8 +156,8 @@ pub const Ghash = struct {
                 y1 ^= mem.readIntBig(u64, msg[i..][0..8]);
                 y0 ^= mem.readIntBig(u64, msg[i..][8..16]);
 
-                const y1r = @bitReverse(u64, y1);
-                const y0r = @bitReverse(u64, y0);
+                const y1r = @bitReverse(y1);
+                const y0r = @bitReverse(y0);
                 const y2 = y0 ^ y1;
                 const y2r = y0r ^ y1r;
 
@@ -172,8 +172,8 @@ pub const Ghash = struct {
                 const sy1 = mem.readIntBig(u64, msg[i..][16..24]);
                 const sy0 = mem.readIntBig(u64, msg[i..][24..32]);
 
-                const sy1r = @bitReverse(u64, sy1);
-                const sy0r = @bitReverse(u64, sy0);
+                const sy1r = @bitReverse(sy1);
+                const sy0r = @bitReverse(sy0);
                 const sy2 = sy0 ^ sy1;
                 const sy2r = sy0r ^ sy1r;
 
@@ -191,9 +191,9 @@ pub const Ghash = struct {
                 z0h ^= sz0h;
                 z1h ^= sz1h;
                 z2h ^= sz2h;
-                z0h = @bitReverse(u64, z0h) >> 1;
-                z1h = @bitReverse(u64, z1h) >> 1;
-                z2h = @bitReverse(u64, z2h) >> 1;
+                z0h = @bitReverse(z0h) >> 1;
+                z1h = @bitReverse(z1h) >> 1;
+                z2h = @bitReverse(z2h) >> 1;
 
                 var v3 = z1h;
                 var v2 = z1 ^ z2h;
@@ -217,8 +217,8 @@ pub const Ghash = struct {
             y1 ^= mem.readIntBig(u64, msg[i..][0..8]);
             y0 ^= mem.readIntBig(u64, msg[i..][8..16]);
 
-            const y1r = @bitReverse(u64, y1);
-            const y0r = @bitReverse(u64, y0);
+            const y1r = @bitReverse(y1);
+            const y0r = @bitReverse(y0);
             const y2 = y0 ^ y1;
             const y2r = y0r ^ y1r;
 
@@ -228,9 +228,9 @@ pub const Ghash = struct {
             var z0h = clmul(y0r, st.h0r);
             var z1h = clmul(y1r, st.h1r);
             var z2h = clmul(y2r, st.h2r) ^ z0h ^ z1h;
-            z0h = @bitReverse(u64, z0h) >> 1;
-            z1h = @bitReverse(u64, z1h) >> 1;
-            z2h = @bitReverse(u64, z2h) >> 1;
+            z0h = @bitReverse(z0h) >> 1;
+            z1h = @bitReverse(z1h) >> 1;
+            z2h = @bitReverse(z2h) >> 1;
 
             // shift & reduce
             var v3 = z1h;
diff --git a/lib/std/elf.zig b/lib/std/elf.zig
index d80ae2f6a0f7c3d53d5d77403f4fc4965a99ce90..16581b7782b66886daf7ec995322a017e7e31ed1 100644
--- a/lib/std/elf.zig
+++ b/lib/std/elf.zig
@@ -387,7 +387,7 @@ pub const Header = struct {
 
         const machine = if (need_bswap) blk: {
             const value = @enumToInt(hdr32.e_machine);
-            break :blk @intToEnum(EM, @byteSwap(@TypeOf(value), value));
+            break :blk @intToEnum(EM, @byteSwap(value));
         } else hdr32.e_machine;
 
         return @as(Header, .{
@@ -511,7 +511,7 @@ pub fn SectionHeaderIterator(ParseSource: anytype) type {
 pub fn int(is_64: bool, need_bswap: bool, int_32: anytype, int_64: anytype) @TypeOf(int_64) {
     if (is_64) {
         if (need_bswap) {
-            return @byteSwap(@TypeOf(int_64), int_64);
+            return @byteSwap(int_64);
         } else {
             return int_64;
         }
@@ -522,7 +522,7 @@ pub fn int(is_64: bool, need_bswap: bool, int_32: anytype, int_64: anytype) @Typ
 
 pub fn int32(need_bswap: bool, int_32: anytype, comptime Int64: anytype) Int64 {
     if (need_bswap) {
-        return @byteSwap(@TypeOf(int_32), int_32);
+        return @byteSwap(int_32);
     } else {
         return int_32;
     }
diff --git a/lib/std/event/channel.zig b/lib/std/event/channel.zig
index fb478ed6ed3aebaf22bcd013c021a379afface7c..e1c147d25a3d03a329d85081168acc705eda6648 100644
--- a/lib/std/event/channel.zig
+++ b/lib/std/event/channel.zig
@@ -56,7 +56,7 @@ pub fn Channel(comptime T: type) type {
         pub fn init(self: *SelfChannel, buffer: []T) void {
             // The ring buffer implementation only works with power of 2 buffer sizes
             // because of relying on subtracting across zero. For example (0 -% 1) % 10 == 5
-            assert(buffer.len == 0 or @popCount(usize, buffer.len) == 1);
+            assert(buffer.len == 0 or @popCount(buffer.len) == 1);
 
             self.* = SelfChannel{
                 .buffer_len = 0,
diff --git a/lib/std/fmt.zig b/lib/std/fmt.zig
index a1269ad252cd3130446ae42a6154eee14f0e3baa..9133477017863e298ed11f53866f3662b9478124 100644
--- a/lib/std/fmt.zig
+++ b/lib/std/fmt.zig
@@ -195,7 +195,7 @@ pub fn format(
     }
 
     if (comptime arg_state.hasUnusedArgs()) {
-        const missing_count = arg_state.args_len - @popCount(ArgSetType, arg_state.used_args);
+        const missing_count = arg_state.args_len - @popCount(arg_state.used_args);
         switch (missing_count) {
             0 => unreachable,
             1 => @compileError("unused argument in '" ++ fmt ++ "'"),
@@ -380,7 +380,7 @@ const ArgState = struct {
     args_len: usize,
 
     fn hasUnusedArgs(self: *@This()) bool {
-        return @popCount(ArgSetType, self.used_args) != self.args_len;
+        return @popCount(self.used_args) != self.args_len;
     }
 
     fn nextArg(self: *@This(), arg_index: ?usize) ?usize {
diff --git a/lib/std/fmt/parse_float/convert_eisel_lemire.zig b/lib/std/fmt/parse_float/convert_eisel_lemire.zig
index 724be4518127e7824363b946c98572430a4901d0..ff7169530371985bf9e7e51cb8a13b76c75b8ad1 100644
--- a/lib/std/fmt/parse_float/convert_eisel_lemire.zig
+++ b/lib/std/fmt/parse_float/convert_eisel_lemire.zig
@@ -36,7 +36,7 @@ pub fn convertEiselLemire(comptime T: type, q: i64, w_: u64) ?BiasedFp(f64) {
     }
 
     // Normalize our significant digits, so the most-significant bit is set.
-    const lz = @clz(u64, @bitCast(u64, w));
+    const lz = @clz(@bitCast(u64, w));
     w = math.shl(u64, w, lz);
 
     const r = computeProductApprox(q, w, float_info.mantissa_explicit_bits + 3);
diff --git a/lib/std/hash/cityhash.zig b/lib/std/hash/cityhash.zig
index 8a535f372e6e67e3c28cabdad53f21022749c243..7c8e42f10575fa0d47a70881ee11a24110b777a8 100644
--- a/lib/std/hash/cityhash.zig
+++ b/lib/std/hash/cityhash.zig
@@ -143,9 +143,9 @@ pub const CityHash32 = struct {
             h = rotr32(h, 19);
             h = h *% 5 +% 0xe6546b64;
             g ^= b4;
-            g = @byteSwap(u32, g) *% 5;
+            g = @byteSwap(g) *% 5;
             h +%= b4 *% 5;
-            h = @byteSwap(u32, h);
+            h = @byteSwap(h);
             f +%= b0;
             const t: u32 = h;
             h = f;
@@ -252,11 +252,11 @@ pub const CityHash64 = struct {
 
         const u: u64 = rotr64(a +% g, 43) +% (rotr64(b, 30) +% c) *% 9;
         const v: u64 = ((a +% g) ^ d) +% f +% 1;
-        const w: u64 = @byteSwap(u64, (u +% v) *% mul) +% h;
+        const w: u64 = @byteSwap((u +% v) *% mul) +% h;
         const x: u64 = rotr64(e +% f, 42) +% c;
-        const y: u64 = (@byteSwap(u64, (v +% w) *% mul) +% g) *% mul;
+        const y: u64 = (@byteSwap((v +% w) *% mul) +% g) *% mul;
         const z: u64 = e +% f +% c;
-        const a1: u64 = @byteSwap(u64, (x +% z) *% mul +% y) +% b;
+        const a1: u64 = @byteSwap((x +% z) *% mul +% y) +% b;
         const b1: u64 = shiftmix((z +% a1) *% mul +% d +% h) *% mul;
         return b1 +% x;
     }
diff --git a/lib/std/hash/murmur.zig b/lib/std/hash/murmur.zig
index adb150446d3eaf5c8a6fb4f39978245d9956edbf..44b411bb2c5a86382904b894533e57a4265ad3c5 100644
--- a/lib/std/hash/murmur.zig
+++ b/lib/std/hash/murmur.zig
@@ -19,7 +19,7 @@ pub const Murmur2_32 = struct {
         for (@ptrCast([*]align(1) const u32, str.ptr)[0..(len >> 2)]) |v| {
             var k1: u32 = v;
             if (native_endian == .Big)
-                k1 = @byteSwap(u32, k1);
+                k1 = @byteSwap(k1);
             k1 *%= m;
             k1 ^= k1 >> 24;
             k1 *%= m;
@@ -104,7 +104,7 @@ pub const Murmur2_64 = struct {
         for (@ptrCast([*]align(1) const u64, str.ptr)[0..@intCast(usize, len >> 3)]) |v| {
             var k1: u64 = v;
             if (native_endian == .Big)
-                k1 = @byteSwap(u64, k1);
+                k1 = @byteSwap(k1);
             k1 *%= m;
             k1 ^= k1 >> 47;
             k1 *%= m;
@@ -117,7 +117,7 @@ pub const Murmur2_64 = struct {
             var k1: u64 = 0;
             @memcpy(@ptrCast([*]u8, &k1), @ptrCast([*]const u8, &str[@intCast(usize, offset)]), @intCast(usize, rest));
             if (native_endian == .Big)
-                k1 = @byteSwap(u64, k1);
+                k1 = @byteSwap(k1);
             h1 ^= k1;
             h1 *%= m;
         }
@@ -184,7 +184,7 @@ pub const Murmur3_32 = struct {
         for (@ptrCast([*]align(1) const u32, str.ptr)[0..(len >> 2)]) |v| {
             var k1: u32 = v;
             if (native_endian == .Big)
-                k1 = @byteSwap(u32, k1);
+                k1 = @byteSwap(k1);
             k1 *%= c1;
             k1 = rotl32(k1, 15);
             k1 *%= c2;
@@ -296,7 +296,7 @@ fn SMHasherTest(comptime hash_fn: anytype, comptime hashbits: u32) u32 {
 
         var h = hash_fn(key[0..i], 256 - i);
         if (native_endian == .Big)
-            h = @byteSwap(@TypeOf(h), h);
+            h = @byteSwap(h);
         @memcpy(@ptrCast([*]u8, &hashes[i * hashbytes]), @ptrCast([*]u8, &h), hashbytes);
     }
 
@@ -310,8 +310,8 @@ test "murmur2_32" {
     var v0le: u32 = v0;
     var v1le: u64 = v1;
     if (native_endian == .Big) {
-        v0le = @byteSwap(u32, v0le);
-        v1le = @byteSwap(u64, v1le);
+        v0le = @byteSwap(v0le);
+        v1le = @byteSwap(v1le);
     }
     try testing.expectEqual(Murmur2_32.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur2_32.hashUint32(v0));
     try testing.expectEqual(Murmur2_32.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur2_32.hashUint64(v1));
@@ -324,8 +324,8 @@ test "murmur2_64" {
     var v0le: u32 = v0;
     var v1le: u64 = v1;
     if (native_endian == .Big) {
-        v0le = @byteSwap(u32, v0le);
-        v1le = @byteSwap(u64, v1le);
+        v0le = @byteSwap(v0le);
+        v1le = @byteSwap(v1le);
     }
     try testing.expectEqual(Murmur2_64.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur2_64.hashUint32(v0));
     try testing.expectEqual(Murmur2_64.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur2_64.hashUint64(v1));
@@ -338,8 +338,8 @@ test "murmur3_32" {
     var v0le: u32 = v0;
     var v1le: u64 = v1;
     if (native_endian == .Big) {
-        v0le = @byteSwap(u32, v0le);
-        v1le = @byteSwap(u64, v1le);
+        v0le = @byteSwap(v0le);
+        v1le = @byteSwap(v1le);
     }
     try testing.expectEqual(Murmur3_32.hash(@ptrCast([*]u8, &v0le)[0..4]), Murmur3_32.hashUint32(v0));
     try testing.expectEqual(Murmur3_32.hash(@ptrCast([*]u8, &v1le)[0..8]), Murmur3_32.hashUint64(v1));
diff --git a/lib/std/heap.zig b/lib/std/heap.zig
index b71cdb79321469b656fb49412c4fbe9b074d1c2b..e0e8cf51cc2ff76fbb51c3669eb12746ebcbe721 100644
--- a/lib/std/heap.zig
+++ b/lib/std/heap.zig
@@ -479,7 +479,7 @@ const WasmPageAllocator = struct {
             @setCold(true);
             for (self.data) |segment, i| {
                 const spills_into_next = @bitCast(i128, segment) < 0;
-                const has_enough_bits = @popCount(u128, segment) >= num_pages;
+                const has_enough_bits = @popCount(segment) >= num_pages;
 
                 if (!spills_into_next and !has_enough_bits) continue;
 
@@ -1185,7 +1185,7 @@ pub fn testAllocatorLargeAlignment(base_allocator: mem.Allocator) !void {
     const large_align = @as(u29, mem.page_size << 2);
 
     var align_mask: usize = undefined;
-    _ = @shlWithOverflow(usize, ~@as(usize, 0), @as(USizeShift, @ctz(u29, large_align)), &align_mask);
+    _ = @shlWithOverflow(usize, ~@as(usize, 0), @as(USizeShift, @ctz(large_align)), &align_mask);
 
     var slice = try allocator.alignedAlloc(u8, large_align, 500);
     try testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr));
diff --git a/lib/std/leb128.zig b/lib/std/leb128.zig
index b18ca9fab0f72690ad5141b0bb331392cc02bb0a..8e3a007849c578c067b6c3d1451d5d5ffb98db96 100644
--- a/lib/std/leb128.zig
+++ b/lib/std/leb128.zig
@@ -317,7 +317,7 @@ fn test_write_leb128(value: anytype) !void {
     const bytes_needed = bn: {
         if (@typeInfo(T).Int.bits <= 7) break :bn @as(u16, 1);
 
-        const unused_bits = if (value < 0) @clz(T, ~value) else @clz(T, value);
+        const unused_bits = if (value < 0) @clz(~value) else @clz(value);
         const used_bits: u16 = (@typeInfo(T).Int.bits - unused_bits) + @boolToInt(t_signed);
         if (used_bits <= 7) break :bn @as(u16, 1);
         break :bn ((used_bits + 6) / 7);
diff --git a/lib/std/math.zig b/lib/std/math.zig
index 40b5eb9204b7deb15c21665a3b7cee06fc5027fb..0b858d061b43dabc3cd668b15a20710162442b83 100644
--- a/lib/std/math.zig
+++ b/lib/std/math.zig
@@ -1146,7 +1146,7 @@ pub fn ceilPowerOfTwoPromote(comptime T: type, value: T) std.meta.Int(@typeInfo(
     assert(value != 0);
     const PromotedType = std.meta.Int(@typeInfo(T).Int.signedness, @typeInfo(T).Int.bits + 1);
     const ShiftType = std.math.Log2Int(PromotedType);
-    return @as(PromotedType, 1) << @intCast(ShiftType, @typeInfo(T).Int.bits - @clz(T, value - 1));
+    return @as(PromotedType, 1) << @intCast(ShiftType, @typeInfo(T).Int.bits - @clz(value - 1));
 }
 
 /// Returns the next power of two (if the value is not already a power of two).
@@ -1212,7 +1212,7 @@ pub fn log2_int(comptime T: type, x: T) Log2Int(T) {
     if (@typeInfo(T) != .Int or @typeInfo(T).Int.signedness != .unsigned)
         @compileError("log2_int requires an unsigned integer, found " ++ @typeName(T));
     assert(x != 0);
-    return @intCast(Log2Int(T), @typeInfo(T).Int.bits - 1 - @clz(T, x));
+    return @intCast(Log2Int(T), @typeInfo(T).Int.bits - 1 - @clz(x));
 }
 
 /// Return the log base 2 of integer value x, rounding up to the
diff --git a/lib/std/math/big/int.zig b/lib/std/math/big/int.zig
index 2a141ac2431507fa589d678594d58148bee7118a..ee6ccaacac9c1092723ef00f06e200cc0645bda2 100644
--- a/lib/std/math/big/int.zig
+++ b/lib/std/math/big/int.zig
@@ -887,7 +887,7 @@ pub const Mutable = struct {
 
         var sum: Limb = 0;
         for (r.limbs[0..r.len]) |limb| {
-            sum += @popCount(Limb, limb);
+            sum += @popCount(limb);
         }
         r.set(sum);
     }
@@ -1520,7 +1520,7 @@ pub const Mutable = struct {
     ) void {
         // 0.
         // Normalize so that y[t] > b/2
-        const lz = @clz(Limb, y.limbs[y.len - 1]);
+        const lz = @clz(y.limbs[y.len - 1]);
         const norm_shift = if (lz == 0 and y.toConst().isOdd())
             limb_bits // Force an extra limb so that y is even.
         else
@@ -1917,7 +1917,7 @@ pub const Const = struct {
 
     /// Returns the number of bits required to represent the absolute value of an integer.
     pub fn bitCountAbs(self: Const) usize {
-        return (self.limbs.len - 1) * limb_bits + (limb_bits - @clz(Limb, self.limbs[self.limbs.len - 1]));
+        return (self.limbs.len - 1) * limb_bits + (limb_bits - @clz(self.limbs[self.limbs.len - 1]));
     }
 
     /// Returns the number of bits required to represent the integer in twos-complement form.
@@ -1936,9 +1936,9 @@ pub const Const = struct {
         if (!self.positive) block: {
             bits += 1;
 
-            if (@popCount(Limb, self.limbs[self.limbs.len - 1]) == 1) {
+            if (@popCount(self.limbs[self.limbs.len - 1]) == 1) {
                 for (self.limbs[0 .. self.limbs.len - 1]) |limb| {
-                    if (@popCount(Limb, limb) != 0) {
+                    if (@popCount(limb) != 0) {
                         break :block;
                     }
                 }
@@ -3895,8 +3895,8 @@ fn llpow(r: []Limb, a: []const Limb, b: u32, tmp_limbs: []Limb) void {
     // The initial assignment makes the result end in `r` so an extra memory
     // copy is saved, each 1 flips the index twice so it's only the zeros that
     // matter.
-    const b_leading_zeros = @clz(u32, b);
-    const exp_zeros = @popCount(u32, ~b) - b_leading_zeros;
+    const b_leading_zeros = @clz(b);
+    const exp_zeros = @popCount(~b) - b_leading_zeros;
     if (exp_zeros & 1 != 0) {
         tmp1 = tmp_limbs;
         tmp2 = r;
diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index aef0e0eb190128a3e36143edcd6705a2ed7badd4..8ab1b8a6d2d844c95ab0c703ddd6415159a163db 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -1319,7 +1319,7 @@ pub fn readIntNative(comptime T: type, bytes: *const [@divExact(@typeInfo(T).Int
 /// This function cannot fail and cannot cause undefined behavior.
 /// Assumes the endianness of memory is foreign, so it must byte-swap.
 pub fn readIntForeign(comptime T: type, bytes: *const [@divExact(@typeInfo(T).Int.bits, 8)]u8) T {
-    return @byteSwap(T, readIntNative(T, bytes));
+    return @byteSwap(readIntNative(T, bytes));
 }
 
 pub const readIntLittle = switch (native_endian) {
@@ -1348,7 +1348,7 @@ pub fn readIntSliceNative(comptime T: type, bytes: []const u8) T {
 /// The bit count of T must be evenly divisible by 8.
 /// Assumes the endianness of memory is foreign, so it must byte-swap.
 pub fn readIntSliceForeign(comptime T: type, bytes: []const u8) T {
-    return @byteSwap(T, readIntSliceNative(T, bytes));
+    return @byteSwap(readIntSliceNative(T, bytes));
 }
 
 pub const readIntSliceLittle = switch (native_endian) {
@@ -1430,7 +1430,7 @@ pub fn writeIntNative(comptime T: type, buf: *[(@typeInfo(T).Int.bits + 7) / 8]u
 /// the integer bit width must be divisible by 8.
 /// This function stores in foreign endian, which means it does a @byteSwap first.
 pub fn writeIntForeign(comptime T: type, buf: *[@divExact(@typeInfo(T).Int.bits, 8)]u8, value: T) void {
-    writeIntNative(T, buf, @byteSwap(T, value));
+    writeIntNative(T, buf, @byteSwap(value));
 }
 
 pub const writeIntLittle = switch (native_endian) {
@@ -1575,7 +1575,7 @@ pub const bswapAllFields = @compileError("bswapAllFields has been renamed to byt
 pub fn byteSwapAllFields(comptime S: type, ptr: *S) void {
     if (@typeInfo(S) != .Struct) @compileError("byteSwapAllFields expects a struct as the first argument");
     inline for (std.meta.fields(S)) |f| {
-        @field(ptr, f.name) = @byteSwap(f.field_type, @field(ptr, f.name));
+        @field(ptr, f.name) = @byteSwap(@field(ptr, f.name));
     }
 }
 
@@ -2752,14 +2752,14 @@ test "replaceOwned" {
 pub fn littleToNative(comptime T: type, x: T) T {
     return switch (native_endian) {
         .Little => x,
-        .Big => @byteSwap(T, x),
+        .Big => @byteSwap(x),
     };
 }
 
 /// Converts a big-endian integer to host endianness.
 pub fn bigToNative(comptime T: type, x: T) T {
     return switch (native_endian) {
-        .Little => @byteSwap(T, x),
+        .Little => @byteSwap(x),
         .Big => x,
     };
 }
@@ -2784,14 +2784,14 @@ pub fn nativeTo(comptime T: type, x: T, desired_endianness: Endian) T {
 pub fn nativeToLittle(comptime T: type, x: T) T {
     return switch (native_endian) {
         .Little => x,
-        .Big => @byteSwap(T, x),
+        .Big => @byteSwap(x),
     };
 }
 
 /// Converts an integer which has host endianness to big endian.
 pub fn nativeToBig(comptime T: type, x: T) T {
     return switch (native_endian) {
-        .Little => @byteSwap(T, x),
+        .Little => @byteSwap(x),
         .Big => x,
     };
 }
@@ -2803,7 +2803,7 @@ pub fn nativeToBig(comptime T: type, x: T) T {
 /// - The delta required to align the pointer is not a multiple of the pointee's
 ///   type.
 pub fn alignPointerOffset(ptr: anytype, align_to: u29) ?usize {
-    assert(align_to != 0 and @popCount(u29, align_to) == 1);
+    assert(align_to != 0 and @popCount(align_to) == 1);
 
     const T = @TypeOf(ptr);
     const info = @typeInfo(T);
@@ -3293,7 +3293,7 @@ test "alignForward" {
 /// Round an address up to the previous aligned address
 /// Unlike `alignBackward`, `alignment` can be any positive number, not just a power of 2.
 pub fn alignBackwardAnyAlign(i: usize, alignment: usize) usize {
-    if (@popCount(usize, alignment) == 1)
+    if (@popCount(alignment) == 1)
         return alignBackward(i, alignment);
     assert(alignment != 0);
     return i - @mod(i, alignment);
@@ -3308,7 +3308,7 @@ pub fn alignBackward(addr: usize, alignment: usize) usize {
 /// Round an address up to the previous aligned address
 /// The alignment must be a power of 2 and greater than 0.
 pub fn alignBackwardGeneric(comptime T: type, addr: T, alignment: T) T {
-    assert(@popCount(T, alignment) == 1);
+    assert(@popCount(alignment) == 1);
     // 000010000 // example alignment
     // 000001111 // subtract 1
     // 111110000 // binary not
@@ -3318,11 +3318,11 @@ pub fn alignBackwardGeneric(comptime T: type, addr: T, alignment: T) T {
 /// Returns whether `alignment` is a valid alignment, meaning it is
 /// a positive power of 2.
 pub fn isValidAlign(alignment: u29) bool {
-    return @popCount(u29, alignment) == 1;
+    return @popCount(alignment) == 1;
 }
 
 pub fn isAlignedAnyAlign(i: usize, alignment: usize) bool {
-    if (@popCount(usize, alignment) == 1)
+    if (@popCount(alignment) == 1)
         return isAligned(i, alignment);
     assert(alignment != 0);
     return 0 == @mod(i, alignment);
diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index 539f3612f91878967433f182d2339d32978f9e23..c4dafcd3b84639f5dbeed04af5c8a8dd58018362 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -3377,7 +3377,7 @@ pub const cpu_count_t = std.meta.Int(.unsigned, std.math.log2(CPU_SETSIZE * 8));
 pub fn CPU_COUNT(set: cpu_set_t) cpu_count_t {
     var sum: cpu_count_t = 0;
     for (set) |x| {
-        sum += @popCount(usize, x);
+        sum += @popCount(x);
     }
     return sum;
 }
diff --git a/lib/std/os/uefi.zig b/lib/std/os/uefi.zig
index 386ad7796a498757b6a4ef92588aa3f8b379318a..be975dddbf7aca664210e660e9a52b0a95d4522f 100644
--- a/lib/std/os/uefi.zig
+++ b/lib/std/os/uefi.zig
@@ -55,9 +55,9 @@ pub const Guid = extern struct {
         if (f.len == 0) {
             const fmt = std.fmt.fmtSliceHexLower;
 
-            const time_low = @byteSwap(u32, self.time_low);
-            const time_mid = @byteSwap(u16, self.time_mid);
-            const time_high_and_version = @byteSwap(u16, self.time_high_and_version);
+            const time_low = @byteSwap(self.time_low);
+            const time_mid = @byteSwap(self.time_mid);
+            const time_high_and_version = @byteSwap(self.time_high_and_version);
 
             return std.fmt.format(writer, "{:0>8}-{:0>4}-{:0>4}-{:0>2}{:0>2}-{:0>12}", .{
                 fmt(std.mem.asBytes(&time_low)),
diff --git a/lib/std/packed_int_array.zig b/lib/std/packed_int_array.zig
index a07fc13af15bfb5026f4e41037baae5eacfc2a0f..902e3ee19c914e6a45da63c5a57d41151f653ce9 100644
--- a/lib/std/packed_int_array.zig
+++ b/lib/std/packed_int_array.zig
@@ -76,7 +76,7 @@ pub fn PackedIntIo(comptime Int: type, comptime endian: Endian) type {
             const value_ptr = @ptrCast(*align(1) const Container, &bytes[start_byte]);
             var value = value_ptr.*;
 
-            if (endian != native_endian) value = @byteSwap(Container, value);
+            if (endian != native_endian) value = @byteSwap(value);
 
             switch (endian) {
                 .Big => {
@@ -126,7 +126,7 @@ pub fn PackedIntIo(comptime Int: type, comptime endian: Endian) type {
             const target_ptr = @ptrCast(*align(1) Container, &bytes[start_byte]);
             var target = target_ptr.*;
 
-            if (endian != native_endian) target = @byteSwap(Container, target);
+            if (endian != native_endian) target = @byteSwap(target);
 
             //zero the bits we want to replace in the existing bytes
             const inv_mask = @intCast(Container, std.math.maxInt(UnInt)) << keep_shift;
@@ -136,7 +136,7 @@ pub fn PackedIntIo(comptime Int: type, comptime endian: Endian) type {
             //merge the new value
             target |= value;
 
-            if (endian != native_endian) target = @byteSwap(Container, target);
+            if (endian != native_endian) target = @byteSwap(target);
 
             //save it back
             target_ptr.* = target;
diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig
index 228c6d62ae84c34f8add42dd5bb01a2966da33a1..ae403c1d03a7d9d6003b8d01c1ac74b71a84bd10 100644
--- a/lib/std/priority_dequeue.zig
+++ b/lib/std/priority_dequeue.zig
@@ -69,7 +69,7 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
             // The first element is on a min layer;
             // next two are on a max layer;
             // next four are on a min layer, and so on.
-            const leading_zeros = @clz(usize, index + 1);
+            const leading_zeros = @clz(index + 1);
             const highest_set_bit = @bitSizeOf(usize) - 1 - leading_zeros;
             return (highest_set_bit & 1) == 0;
         }
diff --git a/lib/std/rand.zig b/lib/std/rand.zig
index a121a3f5baf00491f92cdabf6a752272937133a9..c562230ccad9375d8823293bfcff1d1381fb3245 100644
--- a/lib/std/rand.zig
+++ b/lib/std/rand.zig
@@ -257,15 +257,15 @@ pub const Random = struct {
                 // If all 41 bits are zero, generate additional random bits, until a
                 // set bit is found, or 126 bits have been generated.
                 const rand = r.int(u64);
-                var rand_lz = @clz(u64, rand);
+                var rand_lz = @clz(rand);
                 if (rand_lz >= 41) {
                     // TODO: when #5177 or #489 is implemented,
                     // tell the compiler it is unlikely (1/2^41) to reach this point.
                     // (Same for the if branch and the f64 calculations below.)
-                    rand_lz = 41 + @clz(u64, r.int(u64));
+                    rand_lz = 41 + @clz(r.int(u64));
                     if (rand_lz == 41 + 64) {
                         // It is astronomically unlikely to reach this point.
-                        rand_lz += @clz(u32, r.int(u32) | 0x7FF);
+                        rand_lz += @clz(r.int(u32) | 0x7FF);
                     }
                 }
                 const mantissa = @truncate(u23, rand);
@@ -277,12 +277,12 @@ pub const Random = struct {
                 // If all 12 bits are zero, generate additional random bits, until a
                 // set bit is found, or 1022 bits have been generated.
                 const rand = r.int(u64);
-                var rand_lz: u64 = @clz(u64, rand);
+                var rand_lz: u64 = @clz(rand);
                 if (rand_lz >= 12) {
                     rand_lz = 12;
                     while (true) {
                         // It is astronomically unlikely for this loop to execute more than once.
-                        const addl_rand_lz = @clz(u64, r.int(u64));
+                        const addl_rand_lz = @clz(r.int(u64));
                         rand_lz += addl_rand_lz;
                         if (addl_rand_lz != 64) {
                             break;
diff --git a/lib/std/zig/c_builtins.zig b/lib/std/zig/c_builtins.zig
index 8f2eebccd4ce01679d3f36f7e057c8c89a0bee0a..08a2ec78c4e13e3dac68555c33ade6da56fb4fe8 100644
--- a/lib/std/zig/c_builtins.zig
+++ b/lib/std/zig/c_builtins.zig
@@ -1,13 +1,13 @@
 const std = @import("std");
 
 pub inline fn __builtin_bswap16(val: u16) u16 {
-    return @byteSwap(u16, val);
+    return @byteSwap(val);
 }
 pub inline fn __builtin_bswap32(val: u32) u32 {
-    return @byteSwap(u32, val);
+    return @byteSwap(val);
 }
 pub inline fn __builtin_bswap64(val: u64) u64 {
-    return @byteSwap(u64, val);
+    return @byteSwap(val);
 }
 
 pub inline fn __builtin_signbit(val: f64) c_int {
@@ -20,19 +20,19 @@ pub inline fn __builtin_signbitf(val: f32) c_int {
 pub inline fn __builtin_popcount(val: c_uint) c_int {
     // popcount of a c_uint will never exceed the capacity of a c_int
     @setRuntimeSafety(false);
-    return @bitCast(c_int, @as(c_uint, @popCount(c_uint, val)));
+    return @bitCast(c_int, @as(c_uint, @popCount(val)));
 }
 pub inline fn __builtin_ctz(val: c_uint) c_int {
     // Returns the number of trailing 0-bits in val, starting at the least significant bit position.
     // In C if `val` is 0, the result is undefined; in zig it's the number of bits in a c_uint
     @setRuntimeSafety(false);
-    return @bitCast(c_int, @as(c_uint, @ctz(c_uint, val)));
+    return @bitCast(c_int, @as(c_uint, @ctz(val)));
 }
 pub inline fn __builtin_clz(val: c_uint) c_int {
     // Returns the number of leading 0-bits in x, starting at the most significant bit position.
     // In C if `val` is 0, the result is undefined; in zig it's the number of bits in a c_uint
     @setRuntimeSafety(false);
-    return @bitCast(c_int, @as(c_uint, @clz(c_uint, val)));
+    return @bitCast(c_int, @as(c_uint, @clz(val)));
 }
 
 pub inline fn __builtin_sqrt(val: f64) f64 {
diff --git a/lib/std/zig/system/NativeTargetInfo.zig b/lib/std/zig/system/NativeTargetInfo.zig
index 4f8c0025c5dda3ce0b1b7bc8868bd1536501cc2f..824a1a26b651eb4c8b7ad223151781115f7e727d 100644
--- a/lib/std/zig/system/NativeTargetInfo.zig
+++ b/lib/std/zig/system/NativeTargetInfo.zig
@@ -852,13 +852,13 @@ pub const LdInfo = struct {
 pub fn elfInt(is_64: bool, need_bswap: bool, int_32: anytype, int_64: anytype) @TypeOf(int_64) {
     if (is_64) {
         if (need_bswap) {
-            return @byteSwap(@TypeOf(int_64), int_64);
+            return @byteSwap(int_64);
         } else {
             return int_64;
         }
     } else {
         if (need_bswap) {
-            return @byteSwap(@TypeOf(int_32), int_32);
+            return @byteSwap(int_32);
         } else {
             return int_32;
         }
diff --git a/src/AstGen.zig b/src/AstGen.zig
index 2001e6950a44ac183411a16192401d465c072032..1924fb444b7a461c5d63df90cc20377e50d53601 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -7733,11 +7733,11 @@ fn builtinCall(
         .has_decl  => return hasDeclOrField(gz, scope, rl, node, params[0], params[1], .has_decl),
         .has_field => return hasDeclOrField(gz, scope, rl, node, params[0], params[1], .has_field),
 
-        .clz         => return bitBuiltin(gz, scope, rl, node, params[0], params[1], .clz),
-        .ctz         => return bitBuiltin(gz, scope, rl, node, params[0], params[1], .ctz),
-        .pop_count   => return bitBuiltin(gz, scope, rl, node, params[0], params[1], .pop_count),
-        .byte_swap   => return bitBuiltin(gz, scope, rl, node, params[0], params[1], .byte_swap),
-        .bit_reverse => return bitBuiltin(gz, scope, rl, node, params[0], params[1], .bit_reverse),
+        .clz         => return bitBuiltin(gz, scope, rl, node, params[0], .clz),
+        .ctz         => return bitBuiltin(gz, scope, rl, node, params[0], .ctz),
+        .pop_count   => return bitBuiltin(gz, scope, rl, node, params[0], .pop_count),
+        .byte_swap   => return bitBuiltin(gz, scope, rl, node, params[0], .byte_swap),
+        .bit_reverse => return bitBuiltin(gz, scope, rl, node, params[0], .bit_reverse),
 
         .div_exact => return divBuiltin(gz, scope, rl, node, params[0], params[1], .div_exact),
         .div_floor => return divBuiltin(gz, scope, rl, node, params[0], params[1], .div_floor),
@@ -8100,17 +8100,9 @@ fn bitBuiltin(
     scope: *Scope,
     rl: ResultLoc,
     node: Ast.Node.Index,
-    int_type_node: Ast.Node.Index,
     operand_node: Ast.Node.Index,
     tag: Zir.Inst.Tag,
 ) InnerError!Zir.Inst.Ref {
-    // The accepted proposal https://github.com/ziglang/zig/issues/6835
-    // tells us to remove the type parameter from these builtins. To stay
-    // source-compatible with stage1, we still observe the parameter here,
-    // but we do not encode it into the ZIR. To implement this proposal in
-    // stage2, only AstGen code will need to be changed.
-    _ = try typeExpr(gz, scope, int_type_node);
-
     const operand = try expr(gz, scope, .none, operand_node);
     const result = try gz.addUnNode(tag, operand, node);
     return rvalue(gz, rl, result, node);
diff --git a/src/BuiltinFn.zig b/src/BuiltinFn.zig
index 04cad19354523898ce610021016e9de95a3edb72..3a13dde1abc9d4d8942112e6633617b0d72526e2 100644
--- a/src/BuiltinFn.zig
+++ b/src/BuiltinFn.zig
@@ -250,14 +250,14 @@ pub const list = list: {
             "@byteSwap",
             .{
                 .tag = .byte_swap,
-                .param_count = 2,
+                .param_count = 1,
             },
         },
         .{
             "@bitReverse",
             .{
                 .tag = .bit_reverse,
-                .param_count = 2,
+                .param_count = 1,
             },
         },
         .{
@@ -301,7 +301,7 @@ pub const list = list: {
             "@clz",
             .{
                 .tag = .clz,
-                .param_count = 2,
+                .param_count = 1,
             },
         },
         .{
@@ -336,7 +336,7 @@ pub const list = list: {
             "@ctz",
             .{
                 .tag = .ctz,
-                .param_count = 2,
+                .param_count = 1,
             },
         },
         .{
@@ -614,7 +614,7 @@ pub const list = list: {
             "@popCount",
             .{
                 .tag = .pop_count,
-                .param_count = 2,
+                .param_count = 1,
             },
         },
         .{
diff --git a/src/Sema.zig b/src/Sema.zig
index f3ddf21206e4c5fe765446dbcfaa55f4e5396776..579f423e762cf3e128e8335267dd9b1af6bdc16f 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -13032,7 +13032,7 @@ fn analyzePtrArithmetic(
         // The resulting pointer is aligned to the lcd between the offset (an
         // arbitrary number) and the alignment factor (always a power of two,
         // non zero).
-        const new_align = @as(u32, 1) << @intCast(u5, @ctz(u64, addend | ptr_info.@"align"));
+        const new_align = @as(u32, 1) << @intCast(u5, @ctz(addend | ptr_info.@"align"));
 
         break :t try Type.ptr(sema.arena, sema.mod, .{
             .pointee_type = ptr_info.pointee_type,
@@ -17781,7 +17781,7 @@ fn zirBitCount(
 ) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
-    const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
+    const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     _ = try checkIntOrVector(sema, block, operand, operand_src);
@@ -17833,17 +17833,16 @@ fn zirBitCount(
 fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
-    const ty_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
-    const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
+    const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
-    const scalar_ty = try sema.checkIntOrVectorAllowComptime(block, operand_ty, operand_src);
+    const scalar_ty = try sema.checkIntOrVector(block, operand, operand_src);
     const target = sema.mod.getTarget();
     const bits = scalar_ty.intInfo(target).bits;
     if (bits % 8 != 0) {
         return sema.fail(
             block,
-            ty_src,
+            operand_src,
             "@byteSwap requires the number of bits to be evenly divisible by 8, but {} has {} bits",
             .{ scalar_ty.fmt(sema.mod), bits },
         );
@@ -17854,7 +17853,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     }
 
     switch (operand_ty.zigTypeTag()) {
-        .Int, .ComptimeInt => {
+        .Int => {
             const runtime_src = if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |val| {
                 if (val.isUndef()) return sema.addConstUndef(operand_ty);
                 const result_val = try val.byteSwap(operand_ty, target, sema.arena);
@@ -17892,7 +17891,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
-    const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
+    const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
     const operand = try sema.resolveInst(inst_data.operand);
     const operand_ty = sema.typeOf(operand);
     _ = try sema.checkIntOrVectorAllowComptime(block, operand_ty, operand_src);
@@ -21656,7 +21655,7 @@ fn structFieldPtrByIndex(
             const elem_size_bits = ptr_ty_data.pointee_type.bitSize(target);
             if (elem_size_bytes * 8 == elem_size_bits) {
                 const byte_offset = ptr_ty_data.bit_offset / 8;
-                const new_align = @as(u32, 1) << @intCast(u5, @ctz(u64, byte_offset | parent_align));
+                const new_align = @as(u32, 1) << @intCast(u5, @ctz(byte_offset | parent_align));
                 ptr_ty_data.bit_offset = 0;
                 ptr_ty_data.host_size = 0;
                 ptr_ty_data.@"align" = new_align;
@@ -30426,7 +30425,7 @@ fn elemPtrType(sema: *Sema, ptr_ty: Type, offset: ?usize) !Type {
         // The resulting pointer is aligned to the lcd between the offset (an
         // arbitrary number) and the alignment factor (always a power of two,
         // non zero).
-        const new_align = @as(u32, 1) << @intCast(u5, @ctz(u64, addend | ptr_info.@"align"));
+        const new_align = @as(u32, 1) << @intCast(u5, @ctz(addend | ptr_info.@"align"));
         break :a new_align;
     };
     return try Type.ptr(sema.arena, sema.mod, .{
diff --git a/src/arch/aarch64/Emit.zig b/src/arch/aarch64/Emit.zig
index 8abc083a1eecf1f334243d4c104a3eedfb494e1a..00a2ff380aa50378ab4c59f08b8c1d4d95f570ae 100644
--- a/src/arch/aarch64/Emit.zig
+++ b/src/arch/aarch64/Emit.zig
@@ -277,7 +277,7 @@ fn instructionSize(emit: *Emit, inst: Mir.Inst.Index) usize {
         => return 2 * 4,
         .pop_regs, .push_regs => {
             const reg_list = emit.mir.instructions.items(.data)[inst].reg_list;
-            const number_of_regs = @popCount(u32, reg_list);
+            const number_of_regs = @popCount(reg_list);
             const number_of_insts = std.math.divCeil(u6, number_of_regs, 2) catch unreachable;
             return number_of_insts * 4;
         },
@@ -1183,7 +1183,7 @@ fn mirPushPopRegs(emit: *Emit, inst: Mir.Inst.Index) !void {
     // sp must be aligned at all times, so we only use stp and ldp
     // instructions for minimal instruction count. However, if we do
     // not have an even number of registers, we use str and ldr
-    const number_of_regs = @popCount(u32, reg_list);
+    const number_of_regs = @popCount(reg_list);
 
     switch (tag) {
         .pop_regs => {
diff --git a/src/arch/wasm/Emit.zig b/src/arch/wasm/Emit.zig
index 0081dc4d5d286ded80e4859c1eb2893a740f8265..0f3ee9a2a29b908f88caad441964b51653566412 100644
--- a/src/arch/wasm/Emit.zig
+++ b/src/arch/wasm/Emit.zig
@@ -343,7 +343,7 @@ fn emitMemArg(emit: *Emit, tag: Mir.Inst.Tag, inst: Mir.Inst.Index) !void {
     try emit.code.append(@enumToInt(tag));
 
     // wasm encodes alignment as power of 2, rather than natural alignment
-    const encoded_alignment = @ctz(u32, mem_arg.alignment);
+    const encoded_alignment = @ctz(mem_arg.alignment);
     try leb128.writeULEB128(emit.code.writer(), encoded_alignment);
     try leb128.writeULEB128(emit.code.writer(), mem_arg.offset);
 }
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index 935183bbc6f1b1da3cc58be997b77bc574145140..2ec7b3e140e2a45279adde5f3d1cced7c28b290b 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -391,7 +391,7 @@ pub fn splitIntoAtomsOneShot(self: *Object, macho_file: *MachO, object_id: u32)
                     break :blk cc[start..][0..size];
                 } else null;
                 const atom_align = if (addr > 0)
-                    math.min(@ctz(u64, addr), sect.@"align")
+                    math.min(@ctz(addr), sect.@"align")
                 else
                     sect.@"align";
                 const atom = try self.createAtomFromSubsection(
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 37e25e436054a746ed0319a73d861079dfe4d2f9..727f329f4bd6b7182afbc80c6e3b5ed9004ce3d6 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -3135,12 +3135,12 @@ fn emitSegmentInfo(self: *Wasm, file: fs.File, arena: Allocator) !void {
     for (self.segment_info.items) |segment_info| {
         log.debug("Emit segment: {s} align({d}) flags({b})", .{
             segment_info.name,
-            @ctz(u32, segment_info.alignment),
+            @ctz(segment_info.alignment),
             segment_info.flags,
         });
         try leb.writeULEB128(writer, @intCast(u32, segment_info.name.len));
         try writer.writeAll(segment_info.name);
-        try leb.writeULEB128(writer, @ctz(u32, segment_info.alignment));
+        try leb.writeULEB128(writer, @ctz(segment_info.alignment));
         try leb.writeULEB128(writer, segment_info.flags);
     }
 
diff --git a/src/stage1/astgen.cpp b/src/stage1/astgen.cpp
index 367bed69cf0a9a20d22cc48a6741bd99f825461b..54d9c969a5f3796d0b03b46d2fc3867b0fa65b45 100644
--- a/src/stage1/astgen.cpp
+++ b/src/stage1/astgen.cpp
@@ -5374,10 +5374,8 @@ static Stage1ZirInst *astgen_builtin_fn_call(Stage1AstGen *ag, Scope *scope, Ast
                 if (arg0_value == ag->codegen->invalid_inst_src)
                     return arg0_value;
 
-                AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
-                Stage1ZirInst *arg1_value = astgen_node(ag, arg1_node, scope);
-                if (arg1_value == ag->codegen->invalid_inst_src)
-                    return arg1_value;
+                Stage1ZirInst *arg1_value = arg0_value;
+                arg0_value = ir_build_typeof_1(ag, scope, arg0_node, arg1_value);
 
                 Stage1ZirInst *result;
                 switch (builtin_fn->id) {
diff --git a/src/stage1/codegen.cpp b/src/stage1/codegen.cpp
index d4a09f79687ca6ef70e37ea3184faea48b44682d..cc6c0f22a7efd9ac2ca5ce3684ef6a0104fbb2f8 100644
--- a/src/stage1/codegen.cpp
+++ b/src/stage1/codegen.cpp
@@ -9792,11 +9792,11 @@ static void define_builtin_fns(CodeGen *g) {
     create_builtin_fn(g, BuiltinFnIdCInclude, "cInclude", 1);
     create_builtin_fn(g, BuiltinFnIdCDefine, "cDefine", 2);
     create_builtin_fn(g, BuiltinFnIdCUndef, "cUndef", 1);
-    create_builtin_fn(g, BuiltinFnIdCtz, "ctz", 2);
-    create_builtin_fn(g, BuiltinFnIdClz, "clz", 2);
-    create_builtin_fn(g, BuiltinFnIdPopCount, "popCount", 2);
-    create_builtin_fn(g, BuiltinFnIdBswap, "byteSwap", 2);
-    create_builtin_fn(g, BuiltinFnIdBitReverse, "bitReverse", 2);
+    create_builtin_fn(g, BuiltinFnIdCtz, "ctz", 1);
+    create_builtin_fn(g, BuiltinFnIdClz, "clz", 1);
+    create_builtin_fn(g, BuiltinFnIdPopCount, "popCount", 1);
+    create_builtin_fn(g, BuiltinFnIdBswap, "byteSwap", 1);
+    create_builtin_fn(g, BuiltinFnIdBitReverse, "bitReverse", 1);
     create_builtin_fn(g, BuiltinFnIdImport, "import", 1);
     create_builtin_fn(g, BuiltinFnIdCImport, "cImport", 1);
     create_builtin_fn(g, BuiltinFnIdErrName, "errorName", 1);
diff --git a/src/value.zig b/src/value.zig
index 9909cab5ce535dcbcf73078e3a5fbb2932e2d9a5..ea423e848883934a8487ffa115b34ee62b2e7934 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -1582,7 +1582,7 @@ pub const Value = extern union {
             .one, .bool_true => return ty_bits - 1,
 
             .int_u64 => {
-                const big = @clz(u64, val.castTag(.int_u64).?.data);
+                const big = @clz(val.castTag(.int_u64).?.data);
                 return big + ty_bits - 64;
             },
             .int_i64 => {
@@ -1599,7 +1599,7 @@ pub const Value = extern union {
                 while (i != 0) {
                     i -= 1;
                     const limb = bigint.limbs[i];
-                    const this_limb_lz = @clz(std.math.big.Limb, limb);
+                    const this_limb_lz = @clz(limb);
                     total_limb_lz += this_limb_lz;
                     if (this_limb_lz != bits_per_limb) break;
                 }
@@ -1626,7 +1626,7 @@ pub const Value = extern union {
             .one, .bool_true => return 0,
 
             .int_u64 => {
-                const big = @ctz(u64, val.castTag(.int_u64).?.data);
+                const big = @ctz(val.castTag(.int_u64).?.data);
                 return if (big == 64) ty_bits else big;
             },
             .int_i64 => {
@@ -1638,7 +1638,7 @@ pub const Value = extern union {
                 // Limbs are stored in little-endian order.
                 var result: u64 = 0;
                 for (bigint.limbs) |limb| {
-                    const limb_tz = @ctz(std.math.big.Limb, limb);
+                    const limb_tz = @ctz(limb);
                     result += limb_tz;
                     if (limb_tz != @sizeOf(std.math.big.Limb) * 8) break;
                 }
@@ -1663,7 +1663,7 @@ pub const Value = extern union {
             .zero, .bool_false => return 0,
             .one, .bool_true => return 1,
 
-            .int_u64 => return @popCount(u64, val.castTag(.int_u64).?.data),
+            .int_u64 => return @popCount(val.castTag(.int_u64).?.data),
 
             else => {
                 const info = ty.intInfo(target);
diff --git a/test/behavior/bitreverse.zig b/test/behavior/bitreverse.zig
index 585fe381b0fbc2eecc624024210a6a4a573ac124..092f3a1feda38fdad588cfb013dbff8f4d14abb5 100644
--- a/test/behavior/bitreverse.zig
+++ b/test/behavior/bitreverse.zig
@@ -8,7 +8,7 @@ test "@bitReverse large exotic integer" {
     // Currently failing on stage1 for big-endian targets
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
 
-    try expect(@bitReverse(u95, @as(u95, 0x123456789abcdef111213141)) == 0x4146424447bd9eac8f351624);
+    try expect(@bitReverse(@as(u95, 0x123456789abcdef111213141)) == 0x4146424447bd9eac8f351624);
 }
 
 test "@bitReverse" {
@@ -23,74 +23,74 @@ test "@bitReverse" {
 
 fn testBitReverse() !void {
     // using comptime_ints, unsigned
-    try expect(@bitReverse(u0, @as(u0, 0)) == 0);
-    try expect(@bitReverse(u5, @as(u5, 0x12)) == 0x9);
-    try expect(@bitReverse(u8, @as(u8, 0x12)) == 0x48);
-    try expect(@bitReverse(u16, @as(u16, 0x1234)) == 0x2c48);
-    try expect(@bitReverse(u24, @as(u24, 0x123456)) == 0x6a2c48);
-    try expect(@bitReverse(u32, @as(u32, 0x12345678)) == 0x1e6a2c48);
-    try expect(@bitReverse(u40, @as(u40, 0x123456789a)) == 0x591e6a2c48);
-    try expect(@bitReverse(u48, @as(u48, 0x123456789abc)) == 0x3d591e6a2c48);
-    try expect(@bitReverse(u56, @as(u56, 0x123456789abcde)) == 0x7b3d591e6a2c48);
-    try expect(@bitReverse(u64, @as(u64, 0x123456789abcdef1)) == 0x8f7b3d591e6a2c48);
-    try expect(@bitReverse(u96, @as(u96, 0x123456789abcdef111213141)) == 0x828c84888f7b3d591e6a2c48);
-    try expect(@bitReverse(u128, @as(u128, 0x123456789abcdef11121314151617181)) == 0x818e868a828c84888f7b3d591e6a2c48);
+    try expect(@bitReverse(@as(u0, 0)) == 0);
+    try expect(@bitReverse(@as(u5, 0x12)) == 0x9);
+    try expect(@bitReverse(@as(u8, 0x12)) == 0x48);
+    try expect(@bitReverse(@as(u16, 0x1234)) == 0x2c48);
+    try expect(@bitReverse(@as(u24, 0x123456)) == 0x6a2c48);
+    try expect(@bitReverse(@as(u32, 0x12345678)) == 0x1e6a2c48);
+    try expect(@bitReverse(@as(u40, 0x123456789a)) == 0x591e6a2c48);
+    try expect(@bitReverse(@as(u48, 0x123456789abc)) == 0x3d591e6a2c48);
+    try expect(@bitReverse(@as(u56, 0x123456789abcde)) == 0x7b3d591e6a2c48);
+    try expect(@bitReverse(@as(u64, 0x123456789abcdef1)) == 0x8f7b3d591e6a2c48);
+    try expect(@bitReverse(@as(u96, 0x123456789abcdef111213141)) == 0x828c84888f7b3d591e6a2c48);
+    try expect(@bitReverse(@as(u128, 0x123456789abcdef11121314151617181)) == 0x818e868a828c84888f7b3d591e6a2c48);
 
     // using runtime uints, unsigned
     var num0: u0 = 0;
-    try expect(@bitReverse(u0, num0) == 0);
+    try expect(@bitReverse(num0) == 0);
     var num5: u5 = 0x12;
-    try expect(@bitReverse(u5, num5) == 0x9);
+    try expect(@bitReverse(num5) == 0x9);
     var num8: u8 = 0x12;
-    try expect(@bitReverse(u8, num8) == 0x48);
+    try expect(@bitReverse(num8) == 0x48);
     var num16: u16 = 0x1234;
-    try expect(@bitReverse(u16, num16) == 0x2c48);
+    try expect(@bitReverse(num16) == 0x2c48);
     var num24: u24 = 0x123456;
-    try expect(@bitReverse(u24, num24) == 0x6a2c48);
+    try expect(@bitReverse(num24) == 0x6a2c48);
     var num32: u32 = 0x12345678;
-    try expect(@bitReverse(u32, num32) == 0x1e6a2c48);
+    try expect(@bitReverse(num32) == 0x1e6a2c48);
     var num40: u40 = 0x123456789a;
-    try expect(@bitReverse(u40, num40) == 0x591e6a2c48);
+    try expect(@bitReverse(num40) == 0x591e6a2c48);
     var num48: u48 = 0x123456789abc;
-    try expect(@bitReverse(u48, num48) == 0x3d591e6a2c48);
+    try expect(@bitReverse(num48) == 0x3d591e6a2c48);
     var num56: u56 = 0x123456789abcde;
-    try expect(@bitReverse(u56, num56) == 0x7b3d591e6a2c48);
+    try expect(@bitReverse(num56) == 0x7b3d591e6a2c48);
     var num64: u64 = 0x123456789abcdef1;
-    try expect(@bitReverse(u64, num64) == 0x8f7b3d591e6a2c48);
+    try expect(@bitReverse(num64) == 0x8f7b3d591e6a2c48);
     var num128: u128 = 0x123456789abcdef11121314151617181;
-    try expect(@bitReverse(u128, num128) == 0x818e868a828c84888f7b3d591e6a2c48);
+    try expect(@bitReverse(num128) == 0x818e868a828c84888f7b3d591e6a2c48);
 
     // using comptime_ints, signed, positive
-    try expect(@bitReverse(u8, @as(u8, 0)) == 0);
-    try expect(@bitReverse(i8, @bitCast(i8, @as(u8, 0x92))) == @bitCast(i8, @as(u8, 0x49)));
-    try expect(@bitReverse(i16, @bitCast(i16, @as(u16, 0x1234))) == @bitCast(i16, @as(u16, 0x2c48)));
-    try expect(@bitReverse(i24, @bitCast(i24, @as(u24, 0x123456))) == @bitCast(i24, @as(u24, 0x6a2c48)));
-    try expect(@bitReverse(i24, @bitCast(i24, @as(u24, 0x12345f))) == @bitCast(i24, @as(u24, 0xfa2c48)));
-    try expect(@bitReverse(i24, @bitCast(i24, @as(u24, 0xf23456))) == @bitCast(i24, @as(u24, 0x6a2c4f)));
-    try expect(@bitReverse(i32, @bitCast(i32, @as(u32, 0x12345678))) == @bitCast(i32, @as(u32, 0x1e6a2c48)));
-    try expect(@bitReverse(i32, @bitCast(i32, @as(u32, 0xf2345678))) == @bitCast(i32, @as(u32, 0x1e6a2c4f)));
-    try expect(@bitReverse(i32, @bitCast(i32, @as(u32, 0x1234567f))) == @bitCast(i32, @as(u32, 0xfe6a2c48)));
-    try expect(@bitReverse(i40, @bitCast(i40, @as(u40, 0x123456789a))) == @bitCast(i40, @as(u40, 0x591e6a2c48)));
-    try expect(@bitReverse(i48, @bitCast(i48, @as(u48, 0x123456789abc))) == @bitCast(i48, @as(u48, 0x3d591e6a2c48)));
-    try expect(@bitReverse(i56, @bitCast(i56, @as(u56, 0x123456789abcde))) == @bitCast(i56, @as(u56, 0x7b3d591e6a2c48)));
-    try expect(@bitReverse(i64, @bitCast(i64, @as(u64, 0x123456789abcdef1))) == @bitCast(i64, @as(u64, 0x8f7b3d591e6a2c48)));
-    try expect(@bitReverse(i96, @bitCast(i96, @as(u96, 0x123456789abcdef111213141))) == @bitCast(i96, @as(u96, 0x828c84888f7b3d591e6a2c48)));
-    try expect(@bitReverse(i128, @bitCast(i128, @as(u128, 0x123456789abcdef11121314151617181))) == @bitCast(i128, @as(u128, 0x818e868a828c84888f7b3d591e6a2c48)));
+    try expect(@bitReverse(@as(u8, 0)) == 0);
+    try expect(@bitReverse(@bitCast(i8, @as(u8, 0x92))) == @bitCast(i8, @as(u8, 0x49)));
+    try expect(@bitReverse(@bitCast(i16, @as(u16, 0x1234))) == @bitCast(i16, @as(u16, 0x2c48)));
+    try expect(@bitReverse(@bitCast(i24, @as(u24, 0x123456))) == @bitCast(i24, @as(u24, 0x6a2c48)));
+    try expect(@bitReverse(@bitCast(i24, @as(u24, 0x12345f))) == @bitCast(i24, @as(u24, 0xfa2c48)));
+    try expect(@bitReverse(@bitCast(i24, @as(u24, 0xf23456))) == @bitCast(i24, @as(u24, 0x6a2c4f)));
+    try expect(@bitReverse(@bitCast(i32, @as(u32, 0x12345678))) == @bitCast(i32, @as(u32, 0x1e6a2c48)));
+    try expect(@bitReverse(@bitCast(i32, @as(u32, 0xf2345678))) == @bitCast(i32, @as(u32, 0x1e6a2c4f)));
+    try expect(@bitReverse(@bitCast(i32, @as(u32, 0x1234567f))) == @bitCast(i32, @as(u32, 0xfe6a2c48)));
+    try expect(@bitReverse(@bitCast(i40, @as(u40, 0x123456789a))) == @bitCast(i40, @as(u40, 0x591e6a2c48)));
+    try expect(@bitReverse(@bitCast(i48, @as(u48, 0x123456789abc))) == @bitCast(i48, @as(u48, 0x3d591e6a2c48)));
+    try expect(@bitReverse(@bitCast(i56, @as(u56, 0x123456789abcde))) == @bitCast(i56, @as(u56, 0x7b3d591e6a2c48)));
+    try expect(@bitReverse(@bitCast(i64, @as(u64, 0x123456789abcdef1))) == @bitCast(i64, @as(u64, 0x8f7b3d591e6a2c48)));
+    try expect(@bitReverse(@bitCast(i96, @as(u96, 0x123456789abcdef111213141))) == @bitCast(i96, @as(u96, 0x828c84888f7b3d591e6a2c48)));
+    try expect(@bitReverse(@bitCast(i128, @as(u128, 0x123456789abcdef11121314151617181))) == @bitCast(i128, @as(u128, 0x818e868a828c84888f7b3d591e6a2c48)));
 
     // using signed, negative. Compare to runtime ints returned from llvm.
     var neg8: i8 = -18;
-    try expect(@bitReverse(i8, @as(i8, -18)) == @bitReverse(i8, neg8));
+    try expect(@bitReverse(@as(i8, -18)) == @bitReverse(neg8));
     var neg16: i16 = -32694;
-    try expect(@bitReverse(i16, @as(i16, -32694)) == @bitReverse(i16, neg16));
+    try expect(@bitReverse(@as(i16, -32694)) == @bitReverse(neg16));
     var neg24: i24 = -6773785;
-    try expect(@bitReverse(i24, @as(i24, -6773785)) == @bitReverse(i24, neg24));
+    try expect(@bitReverse(@as(i24, -6773785)) == @bitReverse(neg24));
     var neg32: i32 = -16773785;
-    try expect(@bitReverse(i32, @as(i32, -16773785)) == @bitReverse(i32, neg32));
+    try expect(@bitReverse(@as(i32, -16773785)) == @bitReverse(neg32));
 }
 
 fn vector8() !void {
     var v = @Vector(2, u8){ 0x12, 0x23 };
-    var result = @bitReverse(u8, v);
+    var result = @bitReverse(v);
     try expect(result[0] == 0x48);
     try expect(result[1] == 0xc4);
 }
@@ -109,7 +109,7 @@ test "bitReverse vectors u8" {
 
 fn vector16() !void {
     var v = @Vector(2, u16){ 0x1234, 0x2345 };
-    var result = @bitReverse(u16, v);
+    var result = @bitReverse(v);
     try expect(result[0] == 0x2c48);
     try expect(result[1] == 0xa2c4);
 }
@@ -128,7 +128,7 @@ test "bitReverse vectors u16" {
 
 fn vector24() !void {
     var v = @Vector(2, u24){ 0x123456, 0x234567 };
-    var result = @bitReverse(u24, v);
+    var result = @bitReverse(v);
     try expect(result[0] == 0x6a2c48);
     try expect(result[1] == 0xe6a2c4);
 }
@@ -147,7 +147,7 @@ test "bitReverse vectors u24" {
 
 fn vector0() !void {
     var v = @Vector(2, u0){ 0, 0 };
-    var result = @bitReverse(u0, v);
+    var result = @bitReverse(v);
     try expect(result[0] == 0);
     try expect(result[1] == 0);
 }
diff --git a/test/behavior/bugs/10147.zig b/test/behavior/bugs/10147.zig
index b519c71865740577f7d0dcb700aa997fe7641005..221120bb730101df57801f8f2414aa2b9319f24e 100644
--- a/test/behavior/bugs/10147.zig
+++ b/test/behavior/bugs/10147.zig
@@ -2,6 +2,7 @@ const builtin = @import("builtin");
 const std = @import("std");
 
 test "uses correct LLVM builtin" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -12,8 +13,8 @@ test "uses correct LLVM builtin" {
     var y: @Vector(4, u32) = [_]u32{ 0x1, 0x1, 0x1, 0x1 };
     // The stage1 compiler used to call the same builtin function for both
     // scalar and vector inputs, causing the LLVM module verification to fail.
-    var a = @clz(u32, x);
-    var b = @clz(u32, y);
+    var a = @clz(x);
+    var b = @clz(y);
     try std.testing.expectEqual(@as(u6, 31), a);
     try std.testing.expectEqual([_]u6{ 31, 31, 31, 31 }, b);
 }
diff --git a/test/behavior/bugs/2114.zig b/test/behavior/bugs/2114.zig
index 54826cb0d1cbfdb074266265d049d6427f81e886..a013688f4e6d8cb0817bb7c2b11e216349712a3e 100644
--- a/test/behavior/bugs/2114.zig
+++ b/test/behavior/bugs/2114.zig
@@ -4,7 +4,7 @@ const expect = std.testing.expect;
 const math = std.math;
 
 fn ctz(x: anytype) usize {
-    return @ctz(@TypeOf(x), x);
+    return @ctz(x);
 }
 
 test "fixed" {
diff --git a/test/behavior/byteswap.zig b/test/behavior/byteswap.zig
index 263f2c046e4ed350ef38ddaba9af37d486b8f290..5313b612b07a5de14c1d214be5ff621e3391bb0a 100644
--- a/test/behavior/byteswap.zig
+++ b/test/behavior/byteswap.zig
@@ -3,6 +3,7 @@ const builtin = @import("builtin");
 const expect = std.testing.expect;
 
 test "@byteSwap integers" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
@@ -46,7 +47,7 @@ test "@byteSwap integers" {
             );
         }
         fn t(comptime I: type, input: I, expected_output: I) !void {
-            try std.testing.expect(expected_output == @byteSwap(I, input));
+            try std.testing.expect(expected_output == @byteSwap(input));
         }
     };
     comptime try ByteSwapIntTest.run();
@@ -55,12 +56,13 @@ test "@byteSwap integers" {
 
 fn vector8() !void {
     var v = @Vector(2, u8){ 0x12, 0x13 };
-    var result = @byteSwap(u8, v);
+    var result = @byteSwap(v);
     try expect(result[0] == 0x12);
     try expect(result[1] == 0x13);
 }
 
 test "@byteSwap vectors u8" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@@ -73,12 +75,13 @@ test "@byteSwap vectors u8" {
 
 fn vector16() !void {
     var v = @Vector(2, u16){ 0x1234, 0x2345 };
-    var result = @byteSwap(u16, v);
+    var result = @byteSwap(v);
     try expect(result[0] == 0x3412);
     try expect(result[1] == 0x4523);
 }
 
 test "@byteSwap vectors u16" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@@ -91,12 +94,13 @@ test "@byteSwap vectors u16" {
 
 fn vector24() !void {
     var v = @Vector(2, u24){ 0x123456, 0x234567 };
-    var result = @byteSwap(u24, v);
+    var result = @byteSwap(v);
     try expect(result[0] == 0x563412);
     try expect(result[1] == 0x674523);
 }
 
 test "@byteSwap vectors u24" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@@ -109,12 +113,13 @@ test "@byteSwap vectors u24" {
 
 fn vector0() !void {
     var v = @Vector(2, u0){ 0, 0 };
-    var result = @byteSwap(u0, v);
+    var result = @byteSwap(v);
     try expect(result[0] == 0);
     try expect(result[1] == 0);
 }
 
 test "@byteSwap vectors u0" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
diff --git a/test/behavior/comptime_memory.zig b/test/behavior/comptime_memory.zig
index 1fc3f64cda605f0c1dab807fd5c67bf08522a13f..8fa5fc503e5256ad3e0171b3e37a093c70c16b64 100644
--- a/test/behavior/comptime_memory.zig
+++ b/test/behavior/comptime_memory.zig
@@ -82,7 +82,7 @@ test "type pun value and struct" {
 }
 
 fn bigToNativeEndian(comptime T: type, v: T) T {
-    return if (endian == .Big) v else @byteSwap(T, v);
+    return if (endian == .Big) v else @byteSwap(v);
 }
 test "type pun endianness" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
diff --git a/test/behavior/math.zig b/test/behavior/math.zig
index d3f9676f11523c2a407d73cea935f47f242157a6..8cf0f311af03577f049778db92cd19deb2b864b7 100644
--- a/test/behavior/math.zig
+++ b/test/behavior/math.zig
@@ -90,10 +90,11 @@ fn testClzBigInts() !void {
 }
 
 fn testOneClz(comptime T: type, x: T) u32 {
-    return @clz(T, x);
+    return @clz(x);
 }
 
 test "@clz vectors" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
@@ -120,7 +121,7 @@ fn testOneClzVector(
     x: @Vector(len, T),
     expected: @Vector(len, u32),
 ) !void {
-    try expectVectorsEqual(@clz(T, x), expected);
+    try expectVectorsEqual(@clz(x), expected);
 }
 
 fn expectVectorsEqual(a: anytype, b: anytype) !void {
@@ -151,19 +152,18 @@ fn testCtz() !void {
 }
 
 fn testOneCtz(comptime T: type, x: T) u32 {
-    return @ctz(T, x);
+    return @ctz(x);
 }
 
 test "@ctz vectors" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) 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_c) return error.SkipZigTest; // TODO
 
-    if ((builtin.zig_backend == .stage1 or builtin.zig_backend == .stage2_llvm) and
-        builtin.cpu.arch == .aarch64)
-    {
+    if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
         // This regressed with LLVM 14:
         // https://github.com/ziglang/zig/issues/12013
         return error.SkipZigTest;
@@ -187,7 +187,7 @@ fn testOneCtzVector(
     x: @Vector(len, T),
     expected: @Vector(len, u32),
 ) !void {
-    try expectVectorsEqual(@ctz(T, x), expected);
+    try expectVectorsEqual(@ctz(x), expected);
 }
 
 test "const number literal" {
diff --git a/test/behavior/popcount.zig b/test/behavior/popcount.zig
index dbfeb64111e3bf77025d3f4c4f052129a75effdc..e0618146922fc0bc274f87e697e4755aa948cd0c 100644
--- a/test/behavior/popcount.zig
+++ b/test/behavior/popcount.zig
@@ -18,53 +18,54 @@ test "@popCount 128bit integer" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     comptime {
-        try expect(@popCount(u128, @as(u128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
-        try expect(@popCount(i128, @as(i128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
+        try expect(@popCount(@as(u128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
+        try expect(@popCount(@as(i128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
     }
 
     {
         var x: u128 = 0b11111111000110001100010000100001000011000011100101010001;
-        try expect(@popCount(u128, x) == 24);
+        try expect(@popCount(x) == 24);
     }
 
-    try expect(@popCount(i128, @as(i128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
+    try expect(@popCount(@as(i128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
 }
 
 fn testPopCountIntegers() !void {
     {
         var x: u32 = 0xffffffff;
-        try expect(@popCount(u32, x) == 32);
+        try expect(@popCount(x) == 32);
     }
     {
         var x: u5 = 0x1f;
-        try expect(@popCount(u5, x) == 5);
+        try expect(@popCount(x) == 5);
     }
     {
         var x: u32 = 0xaa;
-        try expect(@popCount(u32, x) == 4);
+        try expect(@popCount(x) == 4);
     }
     {
         var x: u32 = 0xaaaaaaaa;
-        try expect(@popCount(u32, x) == 16);
+        try expect(@popCount(x) == 16);
     }
     {
         var x: u32 = 0xaaaaaaaa;
-        try expect(@popCount(u32, x) == 16);
+        try expect(@popCount(x) == 16);
     }
     {
         var x: i16 = -1;
-        try expect(@popCount(i16, x) == 16);
+        try expect(@popCount(x) == 16);
     }
     {
         var x: i8 = -120;
-        try expect(@popCount(i8, x) == 2);
+        try expect(@popCount(x) == 2);
     }
     comptime {
-        try expect(@popCount(u8, @bitCast(u8, @as(i8, -120))) == 2);
+        try expect(@popCount(@bitCast(u8, @as(i8, -120))) == 2);
     }
 }
 
 test "@popCount vectors" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
@@ -79,13 +80,13 @@ fn testPopCountVectors() !void {
     {
         var x: @Vector(8, u32) = [1]u32{0xffffffff} ** 8;
         const expected = [1]u6{32} ** 8;
-        const result: [8]u6 = @popCount(u32, x);
+        const result: [8]u6 = @popCount(x);
         try expect(std.mem.eql(u6, &expected, &result));
     }
     {
         var x: @Vector(8, i16) = [1]i16{-1} ** 8;
         const expected = [1]u5{16} ** 8;
-        const result: [8]u5 = @popCount(i16, x);
+        const result: [8]u5 = @popCount(x);
         try expect(std.mem.eql(u5, &expected, &result));
     }
 }
diff --git a/test/cases/compile_errors/errors_in_for_loop_bodies_are_propagated.zig b/test/cases/compile_errors/errors_in_for_loop_bodies_are_propagated.zig
index bc30b5cbe609b670d79be8a5000cbb7bea8aee58..016dfb1412cba9e8ec0227a7abc0e6ce5b26dd62 100644
--- a/test/cases/compile_errors/errors_in_for_loop_bodies_are_propagated.zig
+++ b/test/cases/compile_errors/errors_in_for_loop_bodies_are_propagated.zig
@@ -1,10 +1,10 @@
 pub export fn entry() void {
     var arr: [100]u8 = undefined;
-    for (arr) |bits| _ = @popCount(bits);
+    for (arr) |bits| _ = @popCount(u8, bits);
 }
 
 // error
 // backend=stage2
 // target=native
 //
-// :3:26: error: expected 2 arguments, found 1
+// :3:26: error: expected 1 argument, found 2
diff --git a/test/cases/compile_errors/popCount-non-integer.zig b/test/cases/compile_errors/popCount-non-integer.zig
index af1c79f5f4162abfe10c88eb8cc859af88f1595b..b218416e394462c846b19c21aaa8f68522f7f5d9 100644
--- a/test/cases/compile_errors/popCount-non-integer.zig
+++ b/test/cases/compile_errors/popCount-non-integer.zig
@@ -1,9 +1,9 @@
 export fn entry(x: f32) u32 {
-    return @popCount(f32, x);
+    return @popCount(x);
 }
 
 // error
 // backend=stage2
 // target=native
 //
-// :2:27: error: expected integer or vector, found 'f32'
+// :2:22: error: expected integer or vector, found 'f32'
diff --git a/tools/gen_spirv_spec.zig b/tools/gen_spirv_spec.zig
index 01c36ad72d39361514d1d20584cee2ffea118756..11ccce35a242fb603da08b366f2a2e68ca34201c 100644
--- a/tools/gen_spirv_spec.zig
+++ b/tools/gen_spirv_spec.zig
@@ -299,11 +299,11 @@ fn renderBitEnum(
     for (enumerants) |enumerant, i| {
         if (enumerant.value != .bitflag) return error.InvalidRegistry;
         const value = try parseHexInt(enumerant.value.bitflag);
-        if (@popCount(u32, value) == 0) {
+        if (@popCount(value) == 0) {
             continue; // Skip 'none' items
         }
 
-        std.debug.assert(@popCount(u32, value) == 1);
+        std.debug.assert(@popCount(value) == 1);
 
         var bitpos = std.math.log2_int(u32, value);
         if (flags_by_bitpos[bitpos]) |*existing| {
diff --git a/tools/gen_stubs.zig b/tools/gen_stubs.zig
index a153d0f2eba4d67c63c994bb06b1f71d4b65ac78..b7c1ae16470caf58b3a7792debefb2f98e60d504 100644
--- a/tools/gen_stubs.zig
+++ b/tools/gen_stubs.zig
@@ -389,7 +389,7 @@ fn parseElf(parse: Parse, comptime is_64: bool, comptime endian: builtin.Endian)
     const S = struct {
         fn endianSwap(x: anytype) @TypeOf(x) {
             if (endian != native_endian) {
-                return @byteSwap(@TypeOf(x), x);
+                return @byteSwap(x);
             } else {
                 return x;
             }
-- 
2.54.0


From 24d718e7ebcf9b13044ead80510c6c703eebd929 Mon Sep 17 00:00:00 2001
From: Justas Zabulionis <38244149+jazzzooo@users.noreply.github.com>
Date: Mon, 22 Aug 2022 04:55:00 -0600
Subject: [PATCH 211/290] std.valgrind.callgrind: fix string type

Fixes the error when using std.vallgrind.callgrind:
error: expected type '[2]u8', found '*const [2:0]u8'
---
 lib/std/valgrind/callgrind.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/std/valgrind/callgrind.zig b/lib/std/valgrind/callgrind.zig
index 6c7dadf1e196d2870f9a03a10196cf0125eedb46..fd6967bb96867e43a250a97c63fdd95d677de0c3 100644
--- a/lib/std/valgrind/callgrind.zig
+++ b/lib/std/valgrind/callgrind.zig
@@ -2,7 +2,7 @@ const std = @import("../std.zig");
 const valgrind = std.valgrind;
 
 pub const CallgrindClientRequest = enum(usize) {
-    DumpStats = valgrind.ToolBase("CT"),
+    DumpStats = valgrind.ToolBase("CT".*),
     ZeroStats,
     ToggleCollect,
     DumpStatsAt,
-- 
2.54.0


From cd5a9ba1f4e38292d8e8c122c2e8ce4d3879367f Mon Sep 17 00:00:00 2001
From: Shane Kennedy <shane.kennedy19@gmail.com>
Date: Mon, 22 Aug 2022 12:57:51 +0200
Subject: [PATCH 212/290] lagnref: add signed integer repr documentation

Closes #11103
---
 doc/langref.html.in | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 9247d3bc4394d0022722475aff74ac6dcc7e2174..98db21eebf62c2560a8c6b0c39947e9f0d42a366 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -1521,7 +1521,8 @@ fn divide(a: i32, b: i32) i32 {
       Zig supports arbitrary bit-width integers, referenced by using
       an identifier of <code>i</code> or <code>u</code> followed by digits. For example, the identifier
       {#syntax#}i7{#endsyntax#} refers to a signed 7-bit integer. The maximum allowed bit-width of an
-      integer type is {#syntax#}65535{#endsyntax#}.
+      integer type is {#syntax#}65535{#endsyntax#}. For signed integer types, Zig uses a
+      <a href="https://en.wikipedia.org/wiki/Two's_complement">two's complement</a> representation.
       </p>
       {#see_also|Wrapping Operations#}
       {#header_close#}
-- 
2.54.0


From f1999712b0a8560bd84726c8a5e8fd37dbdf5375 Mon Sep 17 00:00:00 2001
From: InKryption <inkryption07@gmail.com>
Date: Thu, 11 Aug 2022 18:28:35 +0200
Subject: [PATCH 213/290] std.io.Reader: bounded array functions  * Add
 readIntoBoundedBytes  * Add readBoundedBytes

---
 lib/std/io/reader.zig | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/lib/std/io/reader.zig b/lib/std/io/reader.zig
index 16acef8e48148011f3cf5dc97eb33b30e8e680c9..6acc00485130724f0146ea2b8baacaebadd76cf9 100644
--- a/lib/std/io/reader.zig
+++ b/lib/std/io/reader.zig
@@ -247,6 +247,27 @@ pub fn Reader(
             return bytes;
         }
 
+        /// Reads bytes into the bounded array, until
+        /// the bounded array is full, or the stream ends.
+        pub fn readIntoBoundedBytes(
+            self: Self,
+            comptime num_bytes: usize,
+            bounded: *std.BoundedArray(u8, num_bytes),
+        ) !void {
+            while (bounded.len < num_bytes) {
+                const bytes_read = try self.read(bounded.unusedCapacitySlice());
+                if (bytes_read == 0) return;
+                bounded.len += bytes_read;
+            }
+        }
+
+        /// Reads at most `num_bytes` and returns as a bounded array.
+        pub fn readBoundedBytes(self: Self, comptime num_bytes: usize) !std.BoundedArray(u8, num_bytes) {
+            var result = std.BoundedArray(u8, num_bytes){};
+            try self.readIntoBoundedBytes(num_bytes, &result);
+            return result;
+        }
+
         /// Reads a native-endian integer
         pub fn readIntNative(self: Self, comptime T: type) !T {
             const bytes = try self.readBytesNoEof((@typeInfo(T).Int.bits + 7) / 8);
-- 
2.54.0


From 5404dcdfd844e4b9f47dc49a1f43f0e1075a563f Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 22 Aug 2022 11:13:01 +0300
Subject: [PATCH 214/290] Sema: fix fieldCallBind on tuples and anon structs

Closes #12573
---
 src/Sema.zig                                  | 30 ++++++++++++++-----
 .../bogus_method_call_on_slice.zig            |  8 +++++
 2 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 42d5e96d3dfe7d832c60626295328614072a71ae..4f558ccae48ba85108955cb0ebfaf680eec5adcb 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -21394,14 +21394,30 @@ fn fieldCallBind(
         switch (concrete_ty.zigTypeTag()) {
             .Struct => {
                 const struct_ty = try sema.resolveTypeFields(block, src, concrete_ty);
-                const struct_obj = struct_ty.castTag(.@"struct").?.data;
+                if (struct_ty.castTag(.@"struct")) |struct_obj| {
+                    const field_index_usize = struct_obj.data.fields.getIndex(field_name) orelse
+                        break :find_field;
+                    const field_index = @intCast(u32, field_index_usize);
+                    const field = struct_obj.data.fields.values()[field_index];
 
-                const field_index_usize = struct_obj.fields.getIndex(field_name) orelse
-                    break :find_field;
-                const field_index = @intCast(u32, field_index_usize);
-                const field = struct_obj.fields.values()[field_index];
-
-                return finishFieldCallBind(sema, block, src, ptr_ty, field.ty, field_index, object_ptr);
+                    return finishFieldCallBind(sema, block, src, ptr_ty, field.ty, field_index, object_ptr);
+                } else if (struct_ty.isTuple()) {
+                    if (mem.eql(u8, field_name, "len")) {
+                        return sema.addIntUnsigned(Type.usize, struct_ty.structFieldCount());
+                    }
+                    if (std.fmt.parseUnsigned(u32, field_name, 10)) |field_index| {
+                        if (field_index >= struct_ty.structFieldCount()) break :find_field;
+                        return finishFieldCallBind(sema, block, src, ptr_ty, struct_ty.structFieldType(field_index), field_index, object_ptr);
+                    } else |_| {}
+                } else {
+                    const max = struct_ty.structFieldCount();
+                    var i: u32 = 0;
+                    while (i < max) : (i += 1) {
+                        if (mem.eql(u8, struct_ty.structFieldName(i), field_name)) {
+                            return finishFieldCallBind(sema, block, src, ptr_ty, struct_ty.structFieldType(i), i, object_ptr);
+                        }
+                    }
+                }
             },
             .Union => {
                 const union_ty = try sema.resolveTypeFields(block, src, concrete_ty);
diff --git a/test/cases/compile_errors/bogus_method_call_on_slice.zig b/test/cases/compile_errors/bogus_method_call_on_slice.zig
index b5cb5e472afd5b3e935f0832820f9c60806c46a7..ed18f43f48bfc0761ad4f2992816c7498494277f 100644
--- a/test/cases/compile_errors/bogus_method_call_on_slice.zig
+++ b/test/cases/compile_errors/bogus_method_call_on_slice.zig
@@ -3,9 +3,17 @@ fn f(m: []const u8) void {
     m.copy(u8, self[0..], m);
 }
 export fn entry() usize { return @sizeOf(@TypeOf(&f)); }
+pub export fn entry1() void {
+    .{}.bar();
+}
+pub export fn entry2() void {
+    .{ .foo = 1 }.bar();
+}
 
 // error
 // backend=stage2
 // target=native
 //
+// :7:8: error: no field or member function named 'bar' in '@TypeOf(.{})'
+// :10:18: error: no field or member function named 'bar' in 'struct{comptime foo: comptime_int = 1}'
 // :3:6: error: no field or member function named 'copy' in '[]const u8'
-- 
2.54.0


From 1a32f2a7f40328799537cc94240a57054a1275bc Mon Sep 17 00:00:00 2001
From: Techcable <techcable@techcable.net>
Date: Mon, 22 Aug 2022 04:38:03 -0700
Subject: [PATCH 215/290] test_runner: workaround #1923, isolating error traces
 in tests

Essentially #1923 means "caught" errors still show up in error return traces.
The correct fix would require the compiler to fix this, but that could affect performance.

For now, simply workaround this issue by clearing the return traces
between tests.

This means that "caught" errors in one test will not show up in the
error traces of other tests.
---
 lib/test_runner.zig | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/lib/test_runner.zig b/lib/test_runner.zig
index 8a3c1f0ca79254676ba4d33caafddae0f3ea169a..46b24deb45d5e0ff2242526771f3cd12c479acde 100644
--- a/lib/test_runner.zig
+++ b/lib/test_runner.zig
@@ -96,6 +96,13 @@ pub fn main() void {
                 test_node.end();
             },
         }
+        // Workaround issue #1923 by clearing error stack traces between tests
+        //
+        // This is not a true fix, but helps isolate errors to the tests where they
+        // originate instead of confusing them all together
+        if (@errorReturnTrace()) |trace| {
+            trace.index = 0;
+        }
     }
     root_node.end();
     if (ok_count == test_fn_list.len) {
-- 
2.54.0


From c955379504d4866f9c474c50317b2a0da18ee631 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 22 Aug 2022 11:46:54 -0700
Subject: [PATCH 216/290] Revert "test_runner: workaround #1923, isolating
 error traces in tests"

This reverts commit 1a32f2a7f40328799537cc94240a57054a1275bc.

Sorry, this workaround is not welcome. Instead, please solve the actual
issue by doing the accepted behavior in the compiler itself:

> in a catch or else (handling a returned error), if the block does not
> try or return error.xyz, set the index to 0

This also applies to if statements, such as the one that test runner is
doing just above this hack.
---
 lib/test_runner.zig | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/lib/test_runner.zig b/lib/test_runner.zig
index 46b24deb45d5e0ff2242526771f3cd12c479acde..8a3c1f0ca79254676ba4d33caafddae0f3ea169a 100644
--- a/lib/test_runner.zig
+++ b/lib/test_runner.zig
@@ -96,13 +96,6 @@ pub fn main() void {
                 test_node.end();
             },
         }
-        // Workaround issue #1923 by clearing error stack traces between tests
-        //
-        // This is not a true fix, but helps isolate errors to the tests where they
-        // originate instead of confusing them all together
-        if (@errorReturnTrace()) |trace| {
-            trace.index = 0;
-        }
     }
     root_node.end();
     if (ok_count == test_fn_list.len) {
-- 
2.54.0


From ecdd4a9fe805c9b5b76cbb883b806ceb61aaddfe Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 22 Aug 2022 15:11:34 -0700
Subject: [PATCH 217/290] build system: add flag for -fstack-protector

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

diff --git a/lib/std/build.zig b/lib/std/build.zig
index b47f962a9dfbcb32d775ccef3d7cbbbe4a1dfd87..4c05586159c6e0aa3ac9afa70f1be5a712bbfb14 100644
--- a/lib/std/build.zig
+++ b/lib/std/build.zig
@@ -1495,6 +1495,7 @@ pub const LibExeObjStep = struct {
     emit_h: bool = false,
     bundle_compiler_rt: ?bool = null,
     single_threaded: ?bool = null,
+    stack_protector: ?bool = null,
     disable_stack_probing: bool,
     disable_sanitize_c: bool,
     sanitize_thread: bool,
@@ -2825,6 +2826,13 @@ pub const LibExeObjStep = struct {
         if (self.disable_stack_probing) {
             try zig_args.append("-fno-stack-check");
         }
+        if (self.stack_protector) |stack_protector| {
+            if (stack_protector) {
+                try zig_args.append("-fstack-protector");
+            } else {
+                try zig_args.append("-fno-stack-protector");
+            }
+        }
         if (self.red_zone) |red_zone| {
             if (red_zone) {
                 try zig_args.append("-mred-zone");
-- 
2.54.0


From 7b14d614d91df7b9b5d802f34bf628293fc714f0 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 22 Aug 2022 15:55:38 -0700
Subject: [PATCH 218/290] CI: update windows tarball

---
 ci/azure/pipelines.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index 5eab6defff742c2064a7428a67c286d5eef37790..e77c7592753f0b1cf689a7bb92b2cc9d21458187 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -27,7 +27,7 @@ jobs:
     vmImage: 'windows-2019'
   variables:
     TARGET: 'x86_64-windows-gnu'
-    ZIG_LLVM_CLANG_LLD_NAME: 'zig+llvm+lld+clang-${{ variables.TARGET }}-0.10.0-dev.3653+7152a58c1'
+    ZIG_LLVM_CLANG_LLD_NAME: 'zig+llvm+lld+clang-${{ variables.TARGET }}-0.10.0-dev.3671+62ff8871e'
     ZIG_LLVM_CLANG_LLD_URL: 'https://ziglang.org/deps/${{ variables.ZIG_LLVM_CLANG_LLD_NAME }}.zip'
   steps:
   - pwsh: |
-- 
2.54.0


From dae7aeb33779d0214c3efe0960af0059416aed51 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 22 Aug 2022 16:04:07 -0700
Subject: [PATCH 219/290] llvm: add valgrind client request integration for
 x86_64

closes #12500
---
 src/codegen/llvm.zig | 92 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 88 insertions(+), 4 deletions(-)

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 98458854d1803306abc56275050ea7aff95beae5..cddbdc6822cd5b4cc1fd2b53172229cb2ceab3a3 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -4019,6 +4019,9 @@ pub const FuncGen = struct {
     /// Note that this can disagree with isByRef for the return type in the case
     /// of C ABI functions.
     ret_ptr: ?*const llvm.Value,
+    /// Any function that needs to perform Valgrind client requests needs an array alloca
+    /// instruction, however a maximum of one per function is needed.
+    valgrind_client_request_array: ?*const llvm.Value = null,
     /// These fields are used to refer to the LLVM value of the function parameters
     /// in an Arg instruction.
     /// This list may be shorter than the list according to the zig type system;
@@ -7530,8 +7533,7 @@ pub const FuncGen = struct {
             const len = usize_llvm_ty.constInt(operand_size, .False);
             _ = self.builder.buildMemSet(dest_ptr_u8, fill_char, len, dest_ptr_align, ptr_ty.isVolatilePtr());
             if (self.dg.module.comp.bin_file.options.valgrind) {
-                // TODO generate valgrind client request to mark byte range as undefined
-                // see gen_valgrind_undef() in codegen.cpp
+                self.valgrindMarkUndef(dest_ptr, len);
             }
         } else {
             const src_operand = try self.resolveInst(bin_op.rhs);
@@ -7790,8 +7792,7 @@ pub const FuncGen = struct {
         _ = self.builder.buildMemSet(dest_ptr_u8, fill_char, len, dest_ptr_align, ptr_ty.isVolatilePtr());
 
         if (val_is_undef and self.dg.module.comp.bin_file.options.valgrind) {
-            // TODO generate valgrind client request to mark byte range as undefined
-            // see gen_valgrind_undef() in codegen.cpp
+            self.valgrindMarkUndef(dest_ptr_u8, len);
         }
         return null;
     }
@@ -9098,6 +9099,89 @@ pub const FuncGen = struct {
             info.@"volatile",
         );
     }
+
+    fn valgrindMarkUndef(fg: *FuncGen, ptr: *const llvm.Value, len: *const llvm.Value) void {
+        const VG_USERREQ__MAKE_MEM_UNDEFINED = 1296236545;
+        const target = fg.dg.module.getTarget();
+        const usize_llvm_ty = fg.context.intType(target.cpu.arch.ptrBitWidth());
+        const zero = usize_llvm_ty.constInt(0, .False);
+        const req = usize_llvm_ty.constInt(VG_USERREQ__MAKE_MEM_UNDEFINED, .False);
+        const ptr_as_usize = fg.builder.buildPtrToInt(ptr, usize_llvm_ty, "");
+        _ = valgrindClientRequest(fg, zero, req, ptr_as_usize, len, zero, zero, zero);
+    }
+
+    fn valgrindClientRequest(
+        fg: *FuncGen,
+        default_value: *const llvm.Value,
+        request: *const llvm.Value,
+        a1: *const llvm.Value,
+        a2: *const llvm.Value,
+        a3: *const llvm.Value,
+        a4: *const llvm.Value,
+        a5: *const llvm.Value,
+    ) *const llvm.Value {
+        const target = fg.dg.module.getTarget();
+        if (!target_util.hasValgrindSupport(target)) return default_value;
+
+        const usize_llvm_ty = fg.context.intType(target.cpu.arch.ptrBitWidth());
+        const usize_alignment = @intCast(c_uint, Type.usize.abiSize(target));
+
+        switch (target.cpu.arch) {
+            .x86_64 => {
+                const array_ptr = fg.valgrind_client_request_array orelse a: {
+                    const array_ptr = fg.buildAlloca(usize_llvm_ty.arrayType(6));
+                    array_ptr.setAlignment(usize_alignment);
+                    fg.valgrind_client_request_array = array_ptr;
+                    break :a array_ptr;
+                };
+                const array_elements = [_]*const llvm.Value{ request, a1, a2, a3, a4, a5 };
+                const zero = usize_llvm_ty.constInt(0, .False);
+                for (array_elements) |elem, i| {
+                    const indexes = [_]*const llvm.Value{
+                        zero, usize_llvm_ty.constInt(@intCast(c_uint, i), .False),
+                    };
+                    const elem_ptr = fg.builder.buildInBoundsGEP(array_ptr, &indexes, indexes.len, "");
+                    const store_inst = fg.builder.buildStore(elem, elem_ptr);
+                    store_inst.setAlignment(usize_alignment);
+                }
+
+                const asm_template =
+                    \\rolq $$3,  %rdi ; rolq $$13, %rdi
+                    \\rolq $$61, %rdi ; rolq $$51, %rdi
+                    \\xchgq %rbx,%rbx
+                ;
+
+                const asm_constraints = "={rdx},{rax},0,~{cc},~{memory}";
+
+                const array_ptr_as_usize = fg.builder.buildPtrToInt(array_ptr, usize_llvm_ty, "");
+                const args = [_]*const llvm.Value{ array_ptr_as_usize, default_value };
+                const param_types = [_]*const llvm.Type{ usize_llvm_ty, usize_llvm_ty };
+                const fn_llvm_ty = llvm.functionType(usize_llvm_ty, &param_types, args.len, .False);
+                const asm_fn = llvm.getInlineAsm(
+                    fn_llvm_ty,
+                    asm_template,
+                    asm_template.len,
+                    asm_constraints,
+                    asm_constraints.len,
+                    .True, // has side effects
+                    .False, // alignstack
+                    .ATT,
+                    .False,
+                );
+
+                const call = fg.builder.buildCall(
+                    asm_fn,
+                    &args,
+                    args.len,
+                    .C,
+                    .Auto,
+                    "",
+                );
+                return call;
+            },
+            else => unreachable,
+        }
+    }
 };
 
 fn initializeLLVMTarget(arch: std.Target.Cpu.Arch) void {
-- 
2.54.0


From 5d2e9a12443e7f6aae1e9289f15b02f85be4bb32 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 22 Aug 2022 14:10:45 -0700
Subject: [PATCH 220/290] test harness: don't skip tests

The meaning of this "skip_stage2" flag was intended to mean the
self-hosted backends, not the stage2 frontend. Sorry for the confusion.

closes #12541
---
 test/tests.zig | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/tests.zig b/test/tests.zig
index a622521182edaa6472268baa1257b179c17c65d3..a329233199799af663e7f64773b25f0d1f5488ec 100644
--- a/test/tests.zig
+++ b/test/tests.zig
@@ -632,8 +632,9 @@ pub fn addPkgTests(
 
         if (test_target.backend) |backend| switch (backend) {
             .stage1 => if (skip_stage1) continue,
+            .stage2_llvm => {},
             else => if (skip_stage2) continue,
-        } else if (skip_stage2) continue;
+        };
 
         const want_this_mode = for (modes) |m| {
             if (m == test_target.mode) break true;
-- 
2.54.0


From 6d679eb2bcbe76e389c02e0bb4d4c4feb2847783 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 22 Aug 2022 16:57:03 -0700
Subject: [PATCH 221/290] LLVM: update to DWARF version 5

clang-14 uses DWARF 5 as the default. Let's join them.
---
 src/zig_llvm.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/zig_llvm.cpp b/src/zig_llvm.cpp
index 52c202fdedac147ed23adba1c4a81dcfaf0d0f03..e03d26d7c42d2bd456378b7df66bb2aa89d73a2a 100644
--- a/src/zig_llvm.cpp
+++ b/src/zig_llvm.cpp
@@ -1130,7 +1130,7 @@ void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type,
 
 void ZigLLVMAddModuleDebugInfoFlag(LLVMModuleRef module) {
     unwrap(module)->addModuleFlag(Module::Warning, "Debug Info Version", DEBUG_METADATA_VERSION);
-    unwrap(module)->addModuleFlag(Module::Warning, "Dwarf Version", 4);
+    unwrap(module)->addModuleFlag(Module::Warning, "Dwarf Version", 5);
 }
 
 void ZigLLVMAddModuleCodeViewFlag(LLVMModuleRef module) {
-- 
2.54.0


From 96737ef499e66d8ab3e32fd4641599b1843f5b8c Mon Sep 17 00:00:00 2001
From: Keith Chambers <KD.Chambers97@Gmail.com>
Date: Mon, 22 Aug 2022 19:50:06 -0500
Subject: [PATCH 222/290] Dwarf: Added stroffsetsptr support (#12270)

* Added support for stroffsetsptr class in Dwarf stdlib

* Proper initializion of debug_str_offsets in DwarfInfo

* Added missing null initializer to DwarfInfo in Macho

* Added missing is_64 field to getAttrString in DwarfInfo

* Fixed formatting

* Added missing is_64 param to getAttrString

* Added required cast to usize

* Adding missing .debug_str_offsets initialization

* getAttrString now uses the str_offsets_base attr
---
 lib/std/debug.zig         |  9 ++++++++-
 lib/std/dwarf.zig         | 30 +++++++++++++++++++++++++++---
 src/link/MachO.zig        |  5 +++--
 src/link/MachO/Object.zig |  1 +
 4 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 33b8a98d7fbc715694490241305d3853b6732dbc..3ce9f3c1d32c722927e728c092c9e0299a884b64 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -846,6 +846,7 @@ fn readCoffDebugInfo(allocator: mem.Allocator, coff_file: File) !ModuleDebugInfo
                 .debug_info = debug_info_data orelse return error.MissingDebugInfo,
                 .debug_abbrev = debug_abbrev_data orelse return error.MissingDebugInfo,
                 .debug_str = debug_str_data orelse return error.MissingDebugInfo,
+                .debug_str_offsets = null,
                 .debug_line = debug_line_data orelse return error.MissingDebugInfo,
                 .debug_line_str = debug_line_str_data,
                 .debug_ranges = debug_ranges_data,
@@ -912,6 +913,7 @@ pub fn readElfDebugInfo(allocator: mem.Allocator, elf_file: File) !ModuleDebugIn
         var opt_debug_info: ?[]const u8 = null;
         var opt_debug_abbrev: ?[]const u8 = null;
         var opt_debug_str: ?[]const u8 = null;
+        var opt_debug_str_offsets: ?[]const u8 = null;
         var opt_debug_line: ?[]const u8 = null;
         var opt_debug_line_str: ?[]const u8 = null;
         var opt_debug_ranges: ?[]const u8 = null;
@@ -926,6 +928,8 @@ pub fn readElfDebugInfo(allocator: mem.Allocator, elf_file: File) !ModuleDebugIn
                 opt_debug_abbrev = try chopSlice(mapped_mem, shdr.sh_offset, shdr.sh_size);
             } else if (mem.eql(u8, name, ".debug_str")) {
                 opt_debug_str = try chopSlice(mapped_mem, shdr.sh_offset, shdr.sh_size);
+            } else if (mem.eql(u8, name, ".debug_str_offsets")) {
+                opt_debug_str_offsets = try chopSlice(mapped_mem, shdr.sh_offset, shdr.sh_size);
             } else if (mem.eql(u8, name, ".debug_line")) {
                 opt_debug_line = try chopSlice(mapped_mem, shdr.sh_offset, shdr.sh_size);
             } else if (mem.eql(u8, name, ".debug_line_str")) {
@@ -940,6 +944,7 @@ pub fn readElfDebugInfo(allocator: mem.Allocator, elf_file: File) !ModuleDebugIn
             .debug_info = opt_debug_info orelse return error.MissingDebugInfo,
             .debug_abbrev = opt_debug_abbrev orelse return error.MissingDebugInfo,
             .debug_str = opt_debug_str orelse return error.MissingDebugInfo,
+            .debug_str_offsets = opt_debug_str_offsets,
             .debug_line = opt_debug_line orelse return error.MissingDebugInfo,
             .debug_line_str = opt_debug_line_str,
             .debug_ranges = opt_debug_ranges,
@@ -1515,6 +1520,7 @@ pub const ModuleDebugInfo = switch (native_os) {
                 .debug_info = try chopSlice(mapped_mem, debug_info.offset, debug_info.size),
                 .debug_abbrev = try chopSlice(mapped_mem, debug_abbrev.offset, debug_abbrev.size),
                 .debug_str = try chopSlice(mapped_mem, debug_str.offset, debug_str.size),
+                .debug_str_offsets = null,
                 .debug_line = try chopSlice(mapped_mem, debug_line.offset, debug_line.size),
                 .debug_line_str = if (opt_debug_line_str) |debug_line_str|
                     try chopSlice(mapped_mem, debug_line_str.offset, debug_line_str.size)
@@ -1578,6 +1584,7 @@ pub const ModuleDebugInfo = switch (native_os) {
                         .compile_unit_name = compile_unit.die.getAttrString(
                             o_file_di,
                             DW.AT.name,
+                            compile_unit.is_64,
                         ) catch |err| switch (err) {
                             error.MissingDebugInfo, error.InvalidDebugInfo => "???",
                         },
@@ -1698,7 +1705,7 @@ fn getSymbolFromDwarf(allocator: mem.Allocator, address: u64, di: *DW.DwarfInfo)
     if (nosuspend di.findCompileUnit(address)) |compile_unit| {
         return SymbolInfo{
             .symbol_name = nosuspend di.getSymbolName(address) orelse "???",
-            .compile_unit_name = compile_unit.die.getAttrString(di, DW.AT.name) catch |err| switch (err) {
+            .compile_unit_name = compile_unit.die.getAttrString(di, DW.AT.name, compile_unit.is_64) catch |err| switch (err) {
                 error.MissingDebugInfo, error.InvalidDebugInfo => "???",
             },
             .line_info = nosuspend di.getLineNumberInfo(allocator, compile_unit.*, address) catch |err| switch (err) {
diff --git a/lib/std/dwarf.zig b/lib/std/dwarf.zig
index d61d198c7eb56e54febc664ab1d807ee8006cd4a..40dfc8cebb4aa6671f479331ba53497e4191f19b 100644
--- a/lib/std/dwarf.zig
+++ b/lib/std/dwarf.zig
@@ -214,6 +214,7 @@ const FormValue = union(enum) {
     RefAddr: u64,
     String: []const u8,
     StrPtr: u64,
+    StrOffset: u64,
     LineStrPtr: u64,
 };
 
@@ -284,11 +285,15 @@ const Die = struct {
         };
     }
 
-    pub fn getAttrString(self: *const Die, di: *DwarfInfo, id: u64) ![]const u8 {
+    pub fn getAttrString(self: *const Die, di: *DwarfInfo, id: u64, is_64: bool) ![]const u8 {
         const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
         return switch (form_value.*) {
             FormValue.String => |value| value,
             FormValue.StrPtr => |offset| di.getString(offset),
+            FormValue.StrOffset => |index| blk: {
+                const base_offset = self.getAttrSecOffset(AT.str_offsets_base) catch 0;
+                break :blk di.getLineString(try di.getStringOffset(base_offset + index, is_64));
+            },
             FormValue.LineStrPtr => |offset| di.getLineString(offset),
             else => error.InvalidDebugInfo,
         };
@@ -522,6 +527,10 @@ fn parseFormValue(allocator: mem.Allocator, in_stream: anytype, form_id: u64, en
 
         FORM.string => FormValue{ .String = try in_stream.readUntilDelimiterAlloc(allocator, 0, math.maxInt(usize)) },
         FORM.strp => FormValue{ .StrPtr = try readAddress(in_stream, endian, is_64) },
+        FORM.strx1 => return FormValue{ .StrOffset = @intCast(u64, try in_stream.readInt(u8, endian)) },
+        FORM.strx2 => return FormValue{ .StrOffset = @intCast(u64, try in_stream.readInt(u16, endian)) },
+        FORM.strx3 => return FormValue{ .StrOffset = @intCast(u64, try in_stream.readInt(u24, endian)) },
+        FORM.strx4 => return FormValue{ .StrOffset = @intCast(u64, try in_stream.readInt(u32, endian)) },
         FORM.line_strp => FormValue{ .LineStrPtr = try readAddress(in_stream, endian, is_64) },
         FORM.indirect => {
             const child_form_id = try nosuspend leb.readULEB128(u64, in_stream);
@@ -554,6 +563,7 @@ pub const DwarfInfo = struct {
     debug_info: []const u8,
     debug_abbrev: []const u8,
     debug_str: []const u8,
+    debug_str_offsets: ?[]const u8,
     debug_line: []const u8,
     debug_line_str: ?[]const u8,
     debug_ranges: ?[]const u8,
@@ -652,7 +662,7 @@ pub const DwarfInfo = struct {
                             // Prevent endless loops
                             while (depth > 0) : (depth -= 1) {
                                 if (this_die_obj.getAttr(AT.name)) |_| {
-                                    const name = try this_die_obj.getAttrString(di, AT.name);
+                                    const name = try this_die_obj.getAttrString(di, AT.name, is_64);
                                     break :x try allocator.dupe(u8, name);
                                 } else if (this_die_obj.getAttr(AT.abstract_origin)) |_| {
                                     // Follow the DIE it points to and repeat
@@ -956,7 +966,7 @@ pub const DwarfInfo = struct {
         const in = &stream.reader();
         const seekable = &stream.seekableStream();
 
-        const compile_unit_cwd = try compile_unit.die.getAttrString(di, AT.comp_dir);
+        const compile_unit_cwd = try compile_unit.die.getAttrString(di, AT.comp_dir, compile_unit.is_64);
         const line_info_offset = try compile_unit.die.getAttrSecOffset(AT.stmt_list);
 
         try seekable.seekTo(line_info_offset);
@@ -1144,6 +1154,20 @@ pub const DwarfInfo = struct {
         return error.InvalidDebugInfo;
     }
 
+    fn getStringOffset(di: *DwarfInfo, offset: u64, is_64: bool) !u64 {
+        if (di.debug_str_offsets) |debug_str_offsets| {
+            if (offset >= debug_str_offsets.len) {
+                return error.InvalidDebugInfo;
+            }
+            const offset_casted = @intCast(usize, offset);
+            if (is_64) {
+                return std.mem.readIntSlice(u64, debug_str_offsets[offset_casted .. offset_casted + 8], di.endian);
+            }
+            return @intCast(u64, std.mem.readIntSlice(u32, debug_str_offsets[offset_casted .. offset_casted + 4], di.endian));
+        }
+        return error.InvalidDebugInfo;
+    }
+
     fn getLineString(di: *DwarfInfo, offset: u64) ![]const u8 {
         const debug_line_str = di.debug_line_str orelse return error.InvalidDebugInfo;
         if (offset > debug_line_str.len)
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 7c04972e4c3b1f3537f1534975287dab13947176..8eb29dcfc7d57b0377d29edac1947a38da27c311 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -5861,8 +5861,9 @@ pub fn generateSymbolStabs(
         },
         else => |e| return e,
     };
-    const tu_name = try compile_unit.die.getAttrString(&debug_info, dwarf.AT.name);
-    const tu_comp_dir = try compile_unit.die.getAttrString(&debug_info, dwarf.AT.comp_dir);
+
+    const tu_name = try compile_unit.die.getAttrString(&debug_info, dwarf.AT.name, compile_unit.is_64);
+    const tu_comp_dir = try compile_unit.die.getAttrString(&debug_info, dwarf.AT.comp_dir, compile_unit.is_64);
 
     // Open scope
     try locals.ensureUnusedCapacity(3);
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index 935183bbc6f1b1da3cc58be997b77bc574145140..9bcf5243c18c1af2338e8f483a645f6258ad7035 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -580,6 +580,7 @@ pub fn parseDwarfInfo(self: Object) error{Overflow}!dwarf.DwarfInfo {
         .debug_info = &[0]u8{},
         .debug_abbrev = &[0]u8{},
         .debug_str = &[0]u8{},
+        .debug_str_offsets = null,
         .debug_line = &[0]u8{},
         .debug_line_str = &[0]u8{},
         .debug_ranges = &[0]u8{},
-- 
2.54.0


From 95c43e20b45aafa6b34b0aae927dbabbb0b65e32 Mon Sep 17 00:00:00 2001
From: Ryan Liptak <squeek502@hotmail.com>
Date: Sat, 18 Jun 2022 01:12:47 -0700
Subject: [PATCH 223/290] Windows: Fix incorrect output when .pdb file is not
 found during stack trace

This `pdb.Pdb.init` call can return `error.FileNotFound`, which was previously resulting in:

    Unable to print stack trace: FileNotFound

which also aborts the stack trace printing (so any deeper stack traces are not printed).

It makes more sense to treat it as `MissingDebugInfo` which then gets printed as:

    ???:?:?: 0x7fffa8817033 in ??? (???)

and allows the stack trace to continue printing.

Note: locally, the error.FileNotFound was being triggered for me when looking for kernel32.pdb and ntdll.pdb
---
 lib/std/debug.zig | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 3ce9f3c1d32c722927e728c092c9e0299a884b64..5e217890b79289218c6156b4da6997f4d9d05639 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -864,7 +864,10 @@ fn readCoffDebugInfo(allocator: mem.Allocator, coff_file: File) !ModuleDebugInfo
         defer allocator.free(path);
 
         di.debug_data = PdbOrDwarf{ .pdb = undefined };
-        di.debug_data.pdb = try pdb.Pdb.init(allocator, path);
+        di.debug_data.pdb = pdb.Pdb.init(allocator, path) catch |err| switch (err) {
+            error.FileNotFound, error.IsDir => return error.MissingDebugInfo,
+            else => return err,
+        };
         try di.debug_data.pdb.parseInfoStream();
         try di.debug_data.pdb.parseDbiStream();
 
-- 
2.54.0


From 9043e665a549b87fa73ade7af06682368092d8a9 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Mon, 22 Aug 2022 18:37:42 -0700
Subject: [PATCH 224/290] add behavior test for copying array of vectors

closes #12026
---
 test/behavior/vector.zig | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig
index 863a8030c02671921db812e7074b84b96178798f..829d20057a8a09d57410655229b0480e37280de5 100644
--- a/test/behavior/vector.zig
+++ b/test/behavior/vector.zig
@@ -1111,3 +1111,26 @@ test "loading the second vector from a slice of vectors" {
     var a4 = a[1][1];
     try expect(a4 == 3);
 }
+
+test "array of vectors is copied" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
+    const Vec3 = @Vector(3, i32);
+    var points = [_]Vec3{
+        Vec3{ 404, -588, -901 },
+        Vec3{ 528, -643, 409 },
+        Vec3{ -838, 591, 734 },
+        Vec3{ 390, -675, -793 },
+        Vec3{ -537, -823, -458 },
+        Vec3{ -485, -357, 347 },
+        Vec3{ -345, -311, 381 },
+        Vec3{ -661, -816, -575 },
+    };
+    var points2: [20]Vec3 = undefined;
+    points2[0..points.len].* = points;
+    try std.testing.expectEqual(points2[6], Vec3{ -345, -311, 381 });
+}
-- 
2.54.0


From 970268d1f55eb7e08b273c3110fbdbc4ccfff34f Mon Sep 17 00:00:00 2001
From: Der Teufel <der.teufel.mail@gmail.com>
Date: Tue, 23 Aug 2022 08:35:13 +0200
Subject: [PATCH 225/290] autodoc: error sets now display all their members

---
 lib/docs/main.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 28f8fb1a703194eec24a35ba54d345cf4f0c8b67..01d2443a316554e37af4873e4113c8fc7bcfe86d 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1770,7 +1770,9 @@ var zigAnalysis;
               return '<span class="tok-type">anyerror</span>';
             } else {
               // throw "TODO";
-              let html = "error{" + errSetObj.fields[0].name + "}";
+              let html = "error{" + errSetObj.fields[0].name;
+              for (let i = 1; i < errSetObj.fields.length; i++) html += ", " + errSetObj.fields[i].name;
+              html += "}";
               return html;
             }
           }
-- 
2.54.0


From c84e5ee87852eafff0cbf986bf02c5221cbcec35 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Mon, 22 Aug 2022 19:48:14 +0200
Subject: [PATCH 226/290] coff: improve default COFF/PE object parser

We now do not allocate memory for headers and other metadata unless
requested by the caller. Instead, we read-in the entire contents
of the image into memory and operate on pointers and casts wherever
possible. I have a left a TODO to hook up Windows' memory-mapped API
here in-place of standard `readToEndAlloc` which should be more memory
proof on memory constrained hosts.

This commit also supplements our `std.coff` with a lot missing basic
extern structs required to make our COFF linker.
---
 lib/std/coff.zig  | 1246 +++++++++++++++++++++++++++++++++++----------
 lib/std/debug.zig |   40 +-
 src/link/Coff.zig |   29 +-
 3 files changed, 1027 insertions(+), 288 deletions(-)

diff --git a/lib/std/coff.zig b/lib/std/coff.zig
index 4371444b968fb07021619963e1c8a543bfce650c..a017ae842241370ab95ff871fa0e302e18ea9838 100644
--- a/lib/std/coff.zig
+++ b/lib/std/coff.zig
@@ -1,14 +1,731 @@
 const std = @import("std.zig");
+const assert = std.debug.assert;
 const io = std.io;
 const mem = std.mem;
 const os = std.os;
-const File = std.fs.File;
+const fs = std.fs;
 
-// CoffHeader.machine values
-// see https://msdn.microsoft.com/en-us/library/windows/desktop/ms680313(v=vs.85).aspx
-const IMAGE_FILE_MACHINE_I386 = 0x014c;
-const IMAGE_FILE_MACHINE_IA64 = 0x0200;
-const IMAGE_FILE_MACHINE_AMD64 = 0x8664;
+pub const CoffHeaderFlags = packed struct {
+    /// Image only, Windows CE, and Microsoft Windows NT and later.
+    /// This indicates that the file does not contain base relocations
+    /// and must therefore be loaded at its preferred base address.
+    /// If the base address is not available, the loader reports an error.
+    /// The default behavior of the linker is to strip base relocations
+    /// from executable (EXE) files.
+    RELOCS_STRIPPED: u1 = 0,
+
+    /// Image only. This indicates that the image file is valid and can be run.
+    /// If this flag is not set, it indicates a linker error.
+    EXECUTABLE_IMAGE: u1 = 0,
+
+    /// COFF line numbers have been removed. This flag is deprecated and should be zero.
+    LINE_NUMS_STRIPPED: u1 = 0,
+
+    /// COFF symbol table entries for local symbols have been removed.
+    /// This flag is deprecated and should be zero.
+    LOCAL_SYMS_STRIPPED: u1 = 0,
+
+    /// Obsolete. Aggressively trim working set.
+    /// This flag is deprecated for Windows 2000 and later and must be zero.
+    AGGRESSIVE_WS_TRIM: u1 = 0,
+
+    /// Application can handle > 2-GB addresses.
+    LARGE_ADDRESS_AWARE: u1 = 0,
+
+    /// This flag is reserved for future use.
+    RESERVED: u1 = 0,
+
+    /// Little endian: the least significant bit (LSB) precedes the
+    /// most significant bit (MSB) in memory. This flag is deprecated and should be zero.
+    BYTES_REVERSED_LO: u1 = 0,
+
+    /// Machine is based on a 32-bit-word architecture.
+    @"32BIT_MACHINE": u1 = 0,
+
+    /// Debugging information is removed from the image file.
+    DEBUG_STRIPPED: u1 = 0,
+
+    /// If the image is on removable media, fully load it and copy it to the swap file.
+    REMOVABLE_RUN_FROM_SWAP: u1 = 0,
+
+    /// If the image is on network media, fully load it and copy it to the swap file.
+    NET_RUN_FROM_SWAP: u1 = 0,
+
+    /// The image file is a system file, not a user program.
+    SYSTEM: u1 = 0,
+
+    /// The image file is a dynamic-link library (DLL).
+    /// Such files are considered executable files for almost all purposes,
+    /// although they cannot be directly run.
+    DLL: u1 = 0,
+
+    /// The file should be run only on a uniprocessor machine.
+    UP_SYSTEM_ONLY: u1 = 0,
+
+    /// Big endian: the MSB precedes the LSB in memory. This flag is deprecated and should be zero.
+    BYTES_REVERSED_HI: u1 = 0,
+};
+
+pub const CoffHeader = extern struct {
+    /// The number that identifies the type of target machine.
+    machine: MachineType,
+
+    /// The number of sections. This indicates the size of the section table, which immediately follows the headers.
+    number_of_sections: u16,
+
+    /// The low 32 bits of the number of seconds since 00:00 January 1, 1970 (a C run-time time_t value),
+    /// which indicates when the file was created.
+    time_date_stamp: u32,
+
+    /// The file offset of the COFF symbol table, or zero if no COFF symbol table is present.
+    /// This value should be zero for an image because COFF debugging information is deprecated.
+    pointer_to_symbol_table: u32,
+
+    /// The number of entries in the symbol table.
+    /// This data can be used to locate the string table, which immediately follows the symbol table.
+    /// This value should be zero for an image because COFF debugging information is deprecated.
+    number_of_symbols: u32,
+
+    /// The size of the optional header, which is required for executable files but not for object files.
+    /// This value should be zero for an object file. For a description of the header format, see Optional Header (Image Only).
+    size_of_optional_header: u16,
+
+    /// The flags that indicate the attributes of the file.
+    flags: CoffHeaderFlags,
+};
+
+// OptionalHeader.magic values
+// see https://msdn.microsoft.com/en-us/library/windows/desktop/ms680339(v=vs.85).aspx
+pub const IMAGE_NT_OPTIONAL_HDR32_MAGIC = 0x10b;
+pub const IMAGE_NT_OPTIONAL_HDR64_MAGIC = 0x20b;
+
+pub const DllFlags = packed struct {
+    _reserved_0: u5 = 0,
+
+    /// Image can handle a high entropy 64-bit virtual address space.
+    HIGH_ENTROPY_VA: u1 = 0,
+
+    /// DLL can be relocated at load time.
+    DYNAMIC_BASE: u1 = 0,
+
+    /// Code Integrity checks are enforced.
+    FORCE_INTEGRITY: u1 = 0,
+
+    /// Image is NX compatible.
+    NX_COMPAT: u1 = 0,
+
+    /// Isolation aware, but do not isolate the image.
+    NO_ISOLATION: u1 = 0,
+
+    /// Does not use structured exception (SE) handling. No SE handler may be called in this image.
+    NO_SEH: u1 = 0,
+
+    /// Do not bind the image.
+    NO_BIND: u1 = 0,
+
+    /// Image must execute in an AppContainer.
+    APPCONTAINER: u1 = 0,
+
+    /// A WDM driver.
+    WDM_DRIVER: u1 = 0,
+
+    /// Image supports Control Flow Guard.
+    GUARD_CF: u1 = 0,
+
+    /// Terminal Server aware.
+    TERMINAL_SERVER_AWARE: u1 = 0,
+};
+
+pub const Subsystem = enum(u16) {
+    /// An unknown subsystem
+    UNKNOWN = 0,
+
+    /// Device drivers and native Windows processes
+    NATIVE = 1,
+
+    /// The Windows graphical user interface (GUI) subsystem
+    WINDOWS_GUI = 2,
+
+    /// The Windows character subsystem
+    WINDOWS_CUI = 3,
+
+    /// The OS/2 character subsystem
+    OS2_CUI = 5,
+
+    /// The Posix character subsystem
+    POSIX_CUI = 7,
+
+    /// Native Win9x driver
+    NATIVE_WINDOWS = 8,
+
+    /// Windows CE
+    WINDOWS_CE_GUI = 9,
+
+    /// An Extensible Firmware Interface (EFI) application
+    EFI_APPLICATION = 10,
+
+    /// An EFI driver with boot services
+    EFI_BOOT_SERVICE_DRIVER = 11,
+
+    /// An EFI driver with run-time services
+    EFI_RUNTIME_DRIVER = 12,
+
+    /// An EFI ROM image
+    EFI_ROM = 13,
+
+    /// XBOX
+    XBOX = 14,
+
+    /// Windows boot application
+    WINDOWS_BOOT_APPLICATION = 16,
+};
+
+pub const OptionalHeader = extern struct {
+    magic: u16,
+    major_linker_version: u8,
+    minor_linker_version: u8,
+    size_of_code: u32,
+    size_of_initialized_data: u32,
+    size_of_uninitialized_data: u32,
+    address_of_entry_point: u32,
+    base_of_code: u32,
+};
+
+pub const OptionalHeaderPE32 = extern struct {
+    magic: u16,
+    major_linker_version: u8,
+    minor_linker_version: u8,
+    size_of_code: u32,
+    size_of_initialized_data: u32,
+    size_of_uninitialized_data: u32,
+    address_of_entry_point: u32,
+    base_of_code: u32,
+    base_of_data: u32,
+    image_base: u32,
+    section_alignment: u32,
+    file_alignment: u32,
+    major_operating_system_version: u16,
+    minor_operating_system_version: u16,
+    major_image_version: u16,
+    minor_image_version: u16,
+    major_subsystem_version: u16,
+    minor_subsystem_version: u16,
+    win32_version_value: u32,
+    size_of_image: u32,
+    size_of_headers: u32,
+    checksum: u32,
+    subsystem: Subsystem,
+    dll_flags: DllFlags,
+    size_of_stack_reserve: u32,
+    size_of_stack_commit: u32,
+    size_of_heap_reserve: u32,
+    size_of_heap_commit: u32,
+    loader_flags: u32,
+    number_of_rva_and_sizes: u32,
+};
+
+pub const OptionalHeaderPE64 = extern struct {
+    magic: u16,
+    major_linker_version: u8,
+    minor_linker_version: u8,
+    size_of_code: u32,
+    size_of_initialized_data: u32,
+    size_of_uninitialized_data: u32,
+    address_of_entry_point: u32,
+    base_of_code: u32,
+    image_base: u64,
+    section_alignment: u32,
+    file_alignment: u32,
+    major_operating_system_version: u16,
+    minor_operating_system_version: u16,
+    major_image_version: u16,
+    minor_image_version: u16,
+    major_subsystem_version: u16,
+    minor_subsystem_version: u16,
+    win32_version_value: u32,
+    size_of_image: u32,
+    size_of_headers: u32,
+    checksum: u32,
+    subsystem: Subsystem,
+    dll_flags: DllFlags,
+    size_of_stack_reserve: u64,
+    size_of_stack_commit: u64,
+    size_of_heap_reserve: u64,
+    size_of_heap_commit: u64,
+    loader_flags: u32,
+    number_of_rva_and_sizes: u32,
+};
+
+pub const DebugDirectoryEntry = extern struct {
+    characteristiccs: u32,
+    time_date_stamp: u32,
+    major_version: u16,
+    minor_version: u16,
+    @"type": u32,
+    size_of_data: u32,
+    address_of_raw_data: u32,
+    pointer_to_raw_data: u32,
+};
+
+pub const ImageDataDirectory = extern struct {
+    virtual_address: u32,
+    size: u32,
+};
+
+pub const SectionHeader = extern struct {
+    name: [8]u8,
+    virtual_size: u32,
+    virtual_address: u32,
+    size_of_raw_data: u32,
+    pointer_to_raw_data: u32,
+    pointer_to_relocations: u32,
+    pointer_to_linenumbers: u32,
+    number_of_relocations: u16,
+    number_of_linenumbers: u16,
+    flags: SectionHeaderFlags,
+
+    pub fn getName(self: *align(1) const SectionHeader) ?[]const u8 {
+        if (self.name[0] == '/') return null;
+        const len = std.mem.indexOfScalar(u8, &self.name, @as(u8, 0)) orelse self.name.len;
+        return self.name[0..len];
+    }
+
+    pub fn getNameOffset(self: SectionHeader) ?u32 {
+        if (self.name[0] != '/') return null;
+        const len = std.mem.indexOfScalar(u8, &self.name, @as(u8, 0)) orelse self.name.len;
+        const offset = std.fmt.parseInt(u32, self.name[1..len], 10) catch unreachable;
+        return offset;
+    }
+
+    /// Applicable only to section headers in COFF objects.
+    pub fn getAlignment(self: SectionHeader) ?u16 {
+        if (self.flags.ALIGN == 0) return null;
+        return std.math.powi(u16, 2, self.flags.ALIGN - 1) catch unreachable;
+    }
+
+    pub fn isComdat(self: SectionHeader) bool {
+        return self.flags.LNK_COMDAT == 0b1;
+    }
+};
+
+pub const SectionHeaderFlags = packed struct {
+    _reserved_0: u3 = 0,
+
+    /// The section should not be padded to the next boundary.
+    /// This flag is obsolete and is replaced by IMAGE_SCN_ALIGN_1BYTES.
+    /// This is valid only for object files.
+    TYPE_NO_PAD: u1 = 0,
+
+    _reserved_1: u1 = 0,
+
+    /// The section contains executable code.
+    CNT_CODE: u1 = 0,
+
+    /// The section contains initialized data.
+    CNT_INITIALIZED_DATA: u1 = 0,
+
+    /// The section contains uninitialized data.
+    CNT_UNINITIALIZED_DATA: u1 = 0,
+
+    /// Reserved for future use.
+    LNK_OTHER: u1 = 0,
+
+    /// The section contains comments or other information.
+    /// The .drectve section has this type.
+    /// This is valid for object files only.
+    LNK_INFO: u1 = 0,
+
+    _reserverd_2: u1 = 0,
+
+    /// The section will not become part of the image.
+    /// This is valid only for object files.
+    LNK_REMOVE: u1 = 0,
+
+    /// The section contains COMDAT data.
+    /// For more information, see COMDAT Sections (Object Only).
+    /// This is valid only for object files.
+    LNK_COMDAT: u1 = 0,
+
+    _reserved_3: u2 = 0,
+
+    /// The section contains data referenced through the global pointer (GP).
+    GPREL: u1 = 0,
+
+    /// Reserved for future use.
+    MEM_PURGEABLE: u1 = 0,
+
+    /// Reserved for future use.
+    MEM_16BIT: u1 = 0,
+
+    /// Reserved for future use.
+    MEM_LOCKED: u1 = 0,
+
+    /// Reserved for future use.
+    MEM_PRELOAD: u1 = 0,
+
+    /// Takes on multiple values according to flags:
+    /// pub const IMAGE_SCN_ALIGN_1BYTES: u32 = 0x100000;
+    /// pub const IMAGE_SCN_ALIGN_2BYTES: u32 = 0x200000;
+    /// pub const IMAGE_SCN_ALIGN_4BYTES: u32 = 0x300000;
+    /// pub const IMAGE_SCN_ALIGN_8BYTES: u32 = 0x400000;
+    /// pub const IMAGE_SCN_ALIGN_16BYTES: u32 = 0x500000;
+    /// pub const IMAGE_SCN_ALIGN_32BYTES: u32 = 0x600000;
+    /// pub const IMAGE_SCN_ALIGN_64BYTES: u32 = 0x700000;
+    /// pub const IMAGE_SCN_ALIGN_128BYTES: u32 = 0x800000;
+    /// pub const IMAGE_SCN_ALIGN_256BYTES: u32 = 0x900000;
+    /// pub const IMAGE_SCN_ALIGN_512BYTES: u32 = 0xA00000;
+    /// pub const IMAGE_SCN_ALIGN_1024BYTES: u32 = 0xB00000;
+    /// pub const IMAGE_SCN_ALIGN_2048BYTES: u32 = 0xC00000;
+    /// pub const IMAGE_SCN_ALIGN_4096BYTES: u32 = 0xD00000;
+    /// pub const IMAGE_SCN_ALIGN_8192BYTES: u32 = 0xE00000;
+    ALIGN: u4 = 0,
+
+    /// The section contains extended relocations.
+    LNK_NRELOC_OVFL: u1 = 0,
+
+    /// The section can be discarded as needed.
+    MEM_DISCARDABLE: u1 = 0,
+
+    /// The section cannot be cached.
+    MEM_NOT_CACHED: u1 = 0,
+
+    /// The section is not pageable.
+    MEM_NOT_PAGED: u1 = 0,
+
+    /// The section can be shared in memory.
+    MEM_SHARED: u1 = 0,
+
+    /// The section can be executed as code.
+    MEM_EXECUTE: u1 = 0,
+
+    /// The section can be read.
+    MEM_READ: u1 = 0,
+
+    /// The section can be written to.
+    MEM_WRITE: u1 = 0,
+};
+
+pub const Symbol = struct {
+    name: [8]u8,
+    value: u32,
+    section_number: SectionNumber,
+    @"type": SymType,
+    storage_class: StorageClass,
+    number_of_aux_symbols: u8,
+
+    pub fn sizeOf() usize {
+        return 18;
+    }
+
+    pub fn getName(self: *const Symbol) ?[]const u8 {
+        if (std.mem.eql(u8, self.name[0..4], "\x00\x00\x00\x00")) return null;
+        const len = std.mem.indexOfScalar(u8, &self.name, @as(u8, 0)) orelse self.name.len;
+        return self.name[0..len];
+    }
+
+    pub fn getNameOffset(self: Symbol) ?u32 {
+        if (!std.mem.eql(u8, self.name[0..4], "\x00\x00\x00\x00")) return null;
+        const offset = std.mem.readIntLittle(u32, self.name[4..8]);
+        return offset;
+    }
+};
+
+pub const SectionNumber = enum(u16) {
+    /// The symbol record is not yet assigned a section.
+    /// A value of zero indicates that a reference to an external symbol is defined elsewhere.
+    /// A value of non-zero is a common symbol with a size that is specified by the value.
+    UNDEFINED = 0,
+
+    /// The symbol has an absolute (non-relocatable) value and is not an address.
+    ABSOLUTE = 0xffff,
+
+    /// The symbol provides general type or debugging information but does not correspond to a section.
+    /// Microsoft tools use this setting along with .file records (storage class FILE).
+    DEBUG = 0xfffe,
+    _,
+};
+
+pub const SymType = packed struct {
+    complex_type: ComplexType,
+    base_type: BaseType,
+};
+
+pub const BaseType = enum(u8) {
+    /// No type information or unknown base type. Microsoft tools use this setting
+    NULL = 0,
+
+    /// No valid type; used with void pointers and functions
+    VOID = 1,
+
+    /// A character (signed byte)
+    CHAR = 2,
+
+    /// A 2-byte signed integer
+    SHORT = 3,
+
+    /// A natural integer type (normally 4 bytes in Windows)
+    INT = 4,
+
+    /// A 4-byte signed integer
+    LONG = 5,
+
+    /// A 4-byte floating-point number
+    FLOAT = 6,
+
+    /// An 8-byte floating-point number
+    DOUBLE = 7,
+
+    /// A structure
+    STRUCT = 8,
+
+    /// A union
+    UNION = 9,
+
+    /// An enumerated type
+    ENUM = 10,
+
+    /// A member of enumeration (a specified value)
+    MOE = 11,
+
+    /// A byte; unsigned 1-byte integer
+    BYTE = 12,
+
+    /// A word; unsigned 2-byte integer
+    WORD = 13,
+
+    /// An unsigned integer of natural size (normally, 4 bytes)
+    UINT = 14,
+
+    /// An unsigned 4-byte integer
+    DWORD = 15,
+};
+
+pub const ComplexType = enum(u8) {
+    /// No derived type; the symbol is a simple scalar variable.
+    NULL = 0,
+
+    /// The symbol is a pointer to base type.
+    POINTER = 16,
+
+    /// The symbol is a function that returns a base type.
+    FUNCTION = 32,
+
+    /// The symbol is an array of base type.
+    ARRAY = 48,
+};
+
+pub const StorageClass = enum(u8) {
+    /// A special symbol that represents the end of function, for debugging purposes.
+    END_OF_FUNCTION = 0xff,
+
+    /// No assigned storage class.
+    NULL = 0,
+
+    /// The automatic (stack) variable. The Value field specifies the stack frame offset.
+    AUTOMATIC = 1,
+
+    /// A value that Microsoft tools use for external symbols.
+    /// The Value field indicates the size if the section number is IMAGE_SYM_UNDEFINED (0).
+    /// If the section number is not zero, then the Value field specifies the offset within the section.
+    EXTERNAL = 2,
+
+    /// The offset of the symbol within the section.
+    /// If the Value field is zero, then the symbol represents a section name.
+    STATIC = 3,
+
+    /// A register variable.
+    /// The Value field specifies the register number.
+    REGISTER = 4,
+
+    /// A symbol that is defined externally.
+    EXTERNAL_DEF = 5,
+
+    /// A code label that is defined within the module.
+    /// The Value field specifies the offset of the symbol within the section.
+    LABEL = 6,
+
+    /// A reference to a code label that is not defined.
+    UNDEFINED_LABEL = 7,
+
+    /// The structure member. The Value field specifies the n th member.
+    MEMBER_OF_STRUCT = 8,
+
+    /// A formal argument (parameter) of a function. The Value field specifies the n th argument.
+    ARGUMENT = 9,
+
+    /// The structure tag-name entry.
+    STRUCT_TAG = 10,
+
+    /// A union member. The Value field specifies the n th member.
+    MEMBER_OF_UNION = 11,
+
+    /// The Union tag-name entry.
+    UNION_TAG = 12,
+
+    /// A Typedef entry.
+    TYPE_DEFINITION = 13,
+
+    /// A static data declaration.
+    UNDEFINED_STATIC = 14,
+
+    /// An enumerated type tagname entry.
+    ENUM_TAG = 15,
+
+    /// A member of an enumeration. The Value field specifies the n th member.
+    MEMBER_OF_ENUM = 16,
+
+    /// A register parameter.
+    REGISTER_PARAM = 17,
+
+    /// A bit-field reference. The Value field specifies the n th bit in the bit field.
+    BIT_FIELD = 18,
+
+    /// A .bb (beginning of block) or .eb (end of block) record.
+    /// The Value field is the relocatable address of the code location.
+    BLOCK = 100,
+
+    /// A value that Microsoft tools use for symbol records that define the extent of a function: begin function (.bf ), end function ( .ef ), and lines in function ( .lf ).
+    /// For .lf records, the Value field gives the number of source lines in the function.
+    /// For .ef records, the Value field gives the size of the function code.
+    FUNCTION = 101,
+
+    /// An end-of-structure entry.
+    END_OF_STRUCT = 102,
+
+    /// A value that Microsoft tools, as well as traditional COFF format, use for the source-file symbol record.
+    /// The symbol is followed by auxiliary records that name the file.
+    FILE = 103,
+
+    /// A definition of a section (Microsoft tools use STATIC storage class instead).
+    SECTION = 104,
+
+    /// A weak external. For more information, see Auxiliary Format 3: Weak Externals.
+    WEAK_EXTERNAL = 105,
+
+    /// A CLR token symbol. The name is an ASCII string that consists of the hexadecimal value of the token.
+    /// For more information, see CLR Token Definition (Object Only).
+    CLR_TOKEN = 107,
+};
+
+pub const FunctionDefinition = struct {
+    /// The symbol-table index of the corresponding .bf (begin function) symbol record.
+    tag_index: u32,
+
+    /// The size of the executable code for the function itself.
+    /// If the function is in its own section, the SizeOfRawData in the section header is greater or equal to this field,
+    /// depending on alignment considerations.
+    total_size: u32,
+
+    /// The file offset of the first COFF line-number entry for the function, or zero if none exists.
+    pointer_to_linenumber: u32,
+
+    /// The symbol-table index of the record for the next function.
+    /// If the function is the last in the symbol table, this field is set to zero.
+    pointer_to_next_function: u32,
+
+    unused: [2]u8,
+};
+
+pub const SectionDefinition = struct {
+    /// The size of section data; the same as SizeOfRawData in the section header.
+    length: u32,
+
+    /// The number of relocation entries for the section.
+    number_of_relocations: u16,
+
+    /// The number of line-number entries for the section.
+    number_of_linenumbers: u16,
+
+    /// The checksum for communal data. It is applicable if the IMAGE_SCN_LNK_COMDAT flag is set in the section header.
+    checksum: u32,
+
+    /// One-based index into the section table for the associated section. This is used when the COMDAT selection setting is 5.
+    number: u16,
+
+    /// The COMDAT selection number. This is applicable if the section is a COMDAT section.
+    selection: ComdatSelection,
+
+    unused: [3]u8,
+};
+
+pub const FileDefinition = struct {
+    /// An ANSI string that gives the name of the source file.
+    /// This is padded with nulls if it is less than the maximum length.
+    file_name: [18]u8,
+
+    pub fn getFileName(self: *const FileDefinition) []const u8 {
+        const len = std.mem.indexOfScalar(u8, &self.file_name, @as(u8, 0)) orelse self.file_name.len;
+        return self.file_name[0..len];
+    }
+};
+
+pub const WeakExternalDefinition = struct {
+    /// The symbol-table index of sym2, the symbol to be linked if sym1 is not found.
+    tag_index: u32,
+
+    /// A value of IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY indicates that no library search for sym1 should be performed.
+    /// A value of IMAGE_WEAK_EXTERN_SEARCH_LIBRARY indicates that a library search for sym1 should be performed.
+    /// A value of IMAGE_WEAK_EXTERN_SEARCH_ALIAS indicates that sym1 is an alias for sym2.
+    flag: WeakExternalFlag,
+
+    unused: [10]u8,
+};
+
+// https://github.com/tpn/winsdk-10/blob/master/Include/10.0.16299.0/km/ntimage.h
+pub const WeakExternalFlag = enum(u32) {
+    SEARCH_NOLIBRARY = 1,
+    SEARCH_LIBRARY = 2,
+    SEARCH_ALIAS = 3,
+    ANTI_DEPENDENCY = 4,
+};
+
+pub const ComdatSelection = enum(u8) {
+    /// Not a COMDAT section.
+    NONE = 0,
+
+    /// If this symbol is already defined, the linker issues a "multiply defined symbol" error.
+    NODUPLICATES = 1,
+
+    /// Any section that defines the same COMDAT symbol can be linked; the rest are removed.
+    ANY = 2,
+
+    /// The linker chooses an arbitrary section among the definitions for this symbol.
+    /// If all definitions are not the same size, a "multiply defined symbol" error is issued.
+    SAME_SIZE = 3,
+
+    /// The linker chooses an arbitrary section among the definitions for this symbol.
+    /// If all definitions do not match exactly, a "multiply defined symbol" error is issued.
+    EXACT_MATCH = 4,
+
+    /// The section is linked if a certain other COMDAT section is linked.
+    /// This other section is indicated by the Number field of the auxiliary symbol record for the section definition.
+    /// This setting is useful for definitions that have components in multiple sections
+    /// (for example, code in one and data in another), but where all must be linked or discarded as a set.
+    /// The other section this section is associated with must be a COMDAT section, which can be another
+    /// associative COMDAT section. An associative COMDAT section's section association chain can't form a loop.
+    /// The section association chain must eventually come to a COMDAT section that doesn't have IMAGE_COMDAT_SELECT_ASSOCIATIVE set.
+    ASSOCIATIVE = 5,
+
+    /// The linker chooses the largest definition from among all of the definitions for this symbol.
+    /// If multiple definitions have this size, the choice between them is arbitrary.
+    LARGEST = 6,
+};
+
+pub const DebugInfoDefinition = struct {
+    unused_1: [4]u8,
+
+    /// The actual ordinal line number (1, 2, 3, and so on) within the source file, corresponding to the .bf or .ef record.
+    linenumber: u16,
+
+    unused_2: [6]u8,
+
+    /// The symbol-table index of the next .bf symbol record.
+    /// If the function is the last in the symbol table, this field is set to zero.
+    /// It is not used for .ef records.
+    pointer_to_next_function: u32,
+
+    unused_3: [2]u8,
+};
 
 pub const MachineType = enum(u16) {
     Unknown = 0x0,
@@ -77,25 +794,6 @@ pub const MachineType = enum(u16) {
     }
 };
 
-// OptionalHeader.magic values
-// see https://msdn.microsoft.com/en-us/library/windows/desktop/ms680339(v=vs.85).aspx
-const IMAGE_NT_OPTIONAL_HDR32_MAGIC = 0x10b;
-const IMAGE_NT_OPTIONAL_HDR64_MAGIC = 0x20b;
-
-// Image Characteristics
-pub const IMAGE_FILE_RELOCS_STRIPPED = 0x1;
-pub const IMAGE_FILE_DEBUG_STRIPPED = 0x200;
-pub const IMAGE_FILE_EXECUTABLE_IMAGE = 0x2;
-pub const IMAGE_FILE_32BIT_MACHINE = 0x100;
-pub const IMAGE_FILE_LARGE_ADDRESS_AWARE = 0x20;
-
-// Section flags
-pub const IMAGE_SCN_CNT_INITIALIZED_DATA = 0x40;
-pub const IMAGE_SCN_MEM_READ = 0x40000000;
-pub const IMAGE_SCN_CNT_CODE = 0x20;
-pub const IMAGE_SCN_MEM_EXECUTE = 0x20000000;
-pub const IMAGE_SCN_MEM_WRITE = 0x80000000;
-
 const IMAGE_NUMBEROF_DIRECTORY_ENTRIES = 16;
 const IMAGE_DEBUG_TYPE_CODEVIEW = 2;
 const DEBUG_DIRECTORY = 6;
@@ -104,166 +802,90 @@ pub const CoffError = error{
     InvalidPEMagic,
     InvalidPEHeader,
     InvalidMachine,
+    MissingPEHeader,
     MissingCoffSection,
     MissingStringTable,
 };
 
 // Official documentation of the format: https://docs.microsoft.com/en-us/windows/win32/debug/pe-format
 pub const Coff = struct {
-    in_file: File,
     allocator: mem.Allocator,
+    data: []const u8 = undefined,
+    is_image: bool = false,
+    coff_header_offset: usize = 0,
 
-    coff_header: CoffHeader,
-    pe_header: OptionalHeader,
-    sections: std.ArrayListUnmanaged(Section) = .{},
-
-    guid: [16]u8,
-    age: u32,
-
-    pub fn init(allocator: mem.Allocator, in_file: File) Coff {
-        return Coff{
-            .in_file = in_file,
-            .allocator = allocator,
-            .coff_header = undefined,
-            .pe_header = undefined,
-            .guid = undefined,
-            .age = undefined,
-        };
-    }
+    guid: [16]u8 = undefined,
+    age: u32 = undefined,
 
     pub fn deinit(self: *Coff) void {
-        self.sections.deinit(self.allocator);
+        self.allocator.free(self.data);
     }
 
-    pub fn loadHeader(self: *Coff) !void {
+    /// Takes ownership of `data`.
+    pub fn parse(self: *Coff, data: []const u8) !void {
+        self.data = data;
+
         const pe_pointer_offset = 0x3C;
-
-        const in = self.in_file.reader();
-
-        var magic: [2]u8 = undefined;
-        try in.readNoEof(magic[0..]);
-        if (!mem.eql(u8, &magic, "MZ"))
-            return error.InvalidPEMagic;
-
-        // Seek to PE File Header (coff header)
-        try self.in_file.seekTo(pe_pointer_offset);
-        const pe_magic_offset = try in.readIntLittle(u32);
-        try self.in_file.seekTo(pe_magic_offset);
-
-        var pe_header_magic: [4]u8 = undefined;
-        try in.readNoEof(pe_header_magic[0..]);
-        if (!mem.eql(u8, &pe_header_magic, &[_]u8{ 'P', 'E', 0, 0 }))
-            return error.InvalidPEHeader;
-
-        self.coff_header = CoffHeader{
-            .machine = try in.readIntLittle(u16),
-            .number_of_sections = try in.readIntLittle(u16),
-            .timedate_stamp = try in.readIntLittle(u32),
-            .pointer_to_symbol_table = try in.readIntLittle(u32),
-            .number_of_symbols = try in.readIntLittle(u32),
-            .size_of_optional_header = try in.readIntLittle(u16),
-            .characteristics = try in.readIntLittle(u16),
-        };
-
-        switch (self.coff_header.machine) {
-            IMAGE_FILE_MACHINE_I386, IMAGE_FILE_MACHINE_AMD64, IMAGE_FILE_MACHINE_IA64 => {},
-            else => return error.InvalidMachine,
-        }
-
-        try self.loadOptionalHeader();
-    }
-
-    fn readStringFromTable(self: *Coff, offset: usize, buf: []u8) ![]const u8 {
-        if (self.coff_header.pointer_to_symbol_table == 0) {
-            // No symbol table therefore no string table
-            return error.MissingStringTable;
-        }
-        // The string table is at the end of the symbol table and symbols are 18 bytes long
-        const string_table_offset = self.coff_header.pointer_to_symbol_table + (self.coff_header.number_of_symbols * 18) + offset;
-        const in = self.in_file.reader();
-        const old_pos = try self.in_file.getPos();
-
-        try self.in_file.seekTo(string_table_offset);
-        defer {
-            self.in_file.seekTo(old_pos) catch unreachable;
+        const pe_magic = "PE\x00\x00";
+
+        var stream = std.io.fixedBufferStream(self.data);
+        const reader = stream.reader();
+        try stream.seekTo(pe_pointer_offset);
+        const coff_header_offset = try reader.readByte();
+        try stream.seekTo(coff_header_offset);
+        var buf: [4]u8 = undefined;
+        try reader.readNoEof(&buf);
+        self.is_image = mem.eql(u8, pe_magic, &buf);
+
+        // Do some basic validation upfront
+        if (self.is_image) {
+            self.coff_header_offset = coff_header_offset + 4;
+            const coff_header = self.getCoffHeader();
+            if (coff_header.size_of_optional_header == 0) {
+                std.log.err("Required PE header missing for image file", .{});
+                return error.MissingPEHeader;
+            }
         }
 
-        const str = try in.readUntilDelimiterOrEof(buf, 0);
-        return str orelse "";
-    }
-
-    fn loadOptionalHeader(self: *Coff) !void {
-        const in = self.in_file.reader();
-        const opt_header_pos = try self.in_file.getPos();
-
-        self.pe_header.magic = try in.readIntLittle(u16);
-        try self.in_file.seekTo(opt_header_pos + 16);
-        self.pe_header.entry_addr = try in.readIntLittle(u32);
-        try self.in_file.seekTo(opt_header_pos + 20);
-        self.pe_header.code_base = try in.readIntLittle(u32);
-
-        // The header structure is different for 32 or 64 bit
-        var num_rva_pos: u64 = undefined;
-        if (self.pe_header.magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
-            num_rva_pos = opt_header_pos + 92;
-
-            try self.in_file.seekTo(opt_header_pos + 28);
-            const image_base32 = try in.readIntLittle(u32);
-            self.pe_header.image_base = image_base32;
-        } else if (self.pe_header.magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
-            num_rva_pos = opt_header_pos + 108;
-
-            try self.in_file.seekTo(opt_header_pos + 24);
-            self.pe_header.image_base = try in.readIntLittle(u64);
-        } else return error.InvalidPEMagic;
-
-        try self.in_file.seekTo(num_rva_pos);
-
-        const number_of_rva_and_sizes = try in.readIntLittle(u32);
-        if (number_of_rva_and_sizes != IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
-            return error.InvalidPEHeader;
-
-        for (self.pe_header.data_directory) |*data_dir| {
-            data_dir.* = OptionalHeader.DataDirectory{
-                .virtual_address = try in.readIntLittle(u32),
-                .size = try in.readIntLittle(u32),
-            };
-        }
+        // JK: we used to check for architecture here and throw an error if not x86 or derivative.
+        // However I am willing to take a leap of faith and let aarch64 have a shot also.
     }
 
     pub fn getPdbPath(self: *Coff, buffer: []u8) !usize {
-        try self.loadSections();
+        assert(self.is_image);
 
         const header = blk: {
-            if (self.getSection(".buildid")) |section| {
-                break :blk section.header;
-            } else if (self.getSection(".rdata")) |section| {
-                break :blk section.header;
+            if (self.getSectionByName(".buildid")) |hdr| {
+                break :blk hdr;
+            } else if (self.getSectionByName(".rdata")) |hdr| {
+                break :blk hdr;
             } else {
                 return error.MissingCoffSection;
             }
         };
 
-        const debug_dir = &self.pe_header.data_directory[DEBUG_DIRECTORY];
+        const data_dirs = self.getDataDirectories();
+        const debug_dir = data_dirs[DEBUG_DIRECTORY];
         const file_offset = debug_dir.virtual_address - header.virtual_address + header.pointer_to_raw_data;
 
-        const in = self.in_file.reader();
-        try self.in_file.seekTo(file_offset);
+        var stream = std.io.fixedBufferStream(self.data);
+        const reader = stream.reader();
+        try stream.seekTo(file_offset);
 
         // Find the correct DebugDirectoryEntry, and where its data is stored.
         // It can be in any section.
         const debug_dir_entry_count = debug_dir.size / @sizeOf(DebugDirectoryEntry);
         var i: u32 = 0;
         blk: while (i < debug_dir_entry_count) : (i += 1) {
-            const debug_dir_entry = try in.readStruct(DebugDirectoryEntry);
+            const debug_dir_entry = try reader.readStruct(DebugDirectoryEntry);
             if (debug_dir_entry.type == IMAGE_DEBUG_TYPE_CODEVIEW) {
-                for (self.sections.items) |*section| {
-                    const section_start = section.header.virtual_address;
-                    const section_size = section.header.misc.virtual_size;
+                for (self.getSectionHeaders()) |*section| {
+                    const section_start = section.virtual_address;
+                    const section_size = section.virtual_size;
                     const rva = debug_dir_entry.address_of_raw_data;
                     const offset = rva - section_start;
                     if (section_start <= rva and offset < section_size and debug_dir_entry.size_of_data <= section_size - offset) {
-                        try self.in_file.seekTo(section.header.pointer_to_raw_data + offset);
+                        try stream.seekTo(section.pointer_to_raw_data + offset);
                         break :blk;
                     }
                 }
@@ -271,19 +893,19 @@ pub const Coff = struct {
         }
 
         var cv_signature: [4]u8 = undefined; // CodeView signature
-        try in.readNoEof(cv_signature[0..]);
+        try reader.readNoEof(cv_signature[0..]);
         // 'RSDS' indicates PDB70 format, used by lld.
         if (!mem.eql(u8, &cv_signature, "RSDS"))
             return error.InvalidPEMagic;
-        try in.readNoEof(self.guid[0..]);
-        self.age = try in.readIntLittle(u32);
+        try reader.readNoEof(self.guid[0..]);
+        self.age = try reader.readIntLittle(u32);
 
         // Finally read the null-terminated string.
-        var byte = try in.readByte();
+        var byte = try reader.readByte();
         i = 0;
         while (byte != 0 and i < buffer.len) : (i += 1) {
             buffer[i] = byte;
-            byte = try in.readByte();
+            byte = try reader.readByte();
         }
 
         if (byte != 0 and i == buffer.len)
@@ -292,126 +914,232 @@ pub const Coff = struct {
         return @as(usize, i);
     }
 
-    pub fn loadSections(self: *Coff) !void {
-        if (self.sections.items.len == self.coff_header.number_of_sections)
-            return;
-
-        try self.sections.ensureTotalCapacityPrecise(self.allocator, self.coff_header.number_of_sections);
-
-        const in = self.in_file.reader();
-
-        var name: [32]u8 = undefined;
-
-        var i: u16 = 0;
-        while (i < self.coff_header.number_of_sections) : (i += 1) {
-            try in.readNoEof(name[0..8]);
-
-            if (name[0] == '/') {
-                // This is a long name and stored in the string table
-                const offset_len = mem.indexOfScalar(u8, name[1..], 0) orelse 7;
-
-                const str_offset = try std.fmt.parseInt(u32, name[1 .. offset_len + 1], 10);
-                const str = try self.readStringFromTable(str_offset, &name);
-                std.mem.set(u8, name[str.len..], 0);
-            } else {
-                std.mem.set(u8, name[8..], 0);
-            }
-
-            self.sections.appendAssumeCapacity(Section{
-                .header = SectionHeader{
-                    .name = name,
-                    .misc = SectionHeader.Misc{ .virtual_size = try in.readIntLittle(u32) },
-                    .virtual_address = try in.readIntLittle(u32),
-                    .size_of_raw_data = try in.readIntLittle(u32),
-                    .pointer_to_raw_data = try in.readIntLittle(u32),
-                    .pointer_to_relocations = try in.readIntLittle(u32),
-                    .pointer_to_line_numbers = try in.readIntLittle(u32),
-                    .number_of_relocations = try in.readIntLittle(u16),
-                    .number_of_line_numbers = try in.readIntLittle(u16),
-                    .characteristics = try in.readIntLittle(u32),
-                },
-            });
-        }
-    }
-
-    pub fn getSection(self: *Coff, comptime name: []const u8) ?*Section {
-        for (self.sections.items) |*sec| {
-            if (mem.eql(u8, sec.header.name[0..name.len], name)) {
-                return sec;
+    pub fn getCoffHeader(self: Coff) CoffHeader {
+        return @ptrCast(*align(1) CoffHeader, self.data[self.coff_header_offset..][0..@sizeOf(CoffHeader)]).*;
+    }
+
+    pub fn getOptionalHeader(self: Coff) OptionalHeader {
+        assert(self.is_image);
+        const offset = self.coff_header_offset + @sizeOf(CoffHeader);
+        return @ptrCast(*align(1) OptionalHeader, self.data[offset..][0..@sizeOf(OptionalHeader)]).*;
+    }
+
+    pub fn getOptionalHeader32(self: Coff) OptionalHeaderPE32 {
+        assert(self.is_image);
+        const offset = self.coff_header_offset + @sizeOf(CoffHeader);
+        return @ptrCast(*align(1) OptionalHeaderPE32, self.data[offset..][0..@sizeOf(OptionalHeaderPE32)]).*;
+    }
+
+    pub fn getOptionalHeader64(self: Coff) OptionalHeaderPE64 {
+        assert(self.is_image);
+        const offset = self.coff_header_offset + @sizeOf(CoffHeader);
+        return @ptrCast(*align(1) OptionalHeaderPE64, self.data[offset..][0..@sizeOf(OptionalHeaderPE64)]).*;
+    }
+
+    pub fn getImageBase(self: Coff) u64 {
+        const hdr = self.getOptionalHeader();
+        return switch (hdr.magic) {
+            IMAGE_NT_OPTIONAL_HDR32_MAGIC => self.getOptionalHeader32().image_base,
+            IMAGE_NT_OPTIONAL_HDR64_MAGIC => self.getOptionalHeader64().image_base,
+            else => unreachable, // We assume we have validated the header already
+        };
+    }
+
+    pub fn getNumberOfDataDirectories(self: Coff) u32 {
+        const hdr = self.getOptionalHeader();
+        return switch (hdr.magic) {
+            IMAGE_NT_OPTIONAL_HDR32_MAGIC => self.getOptionalHeader32().number_of_rva_and_sizes,
+            IMAGE_NT_OPTIONAL_HDR64_MAGIC => self.getOptionalHeader64().number_of_rva_and_sizes,
+            else => unreachable, // We assume we have validated the header already
+        };
+    }
+
+    pub fn getDataDirectories(self: *const Coff) []align(1) const ImageDataDirectory {
+        const hdr = self.getOptionalHeader();
+        const size: usize = switch (hdr.magic) {
+            IMAGE_NT_OPTIONAL_HDR32_MAGIC => @sizeOf(OptionalHeaderPE32),
+            IMAGE_NT_OPTIONAL_HDR64_MAGIC => @sizeOf(OptionalHeaderPE64),
+            else => unreachable, // We assume we have validated the header already
+        };
+        const offset = self.coff_header_offset + @sizeOf(CoffHeader) + size;
+        return @ptrCast([*]align(1) ImageDataDirectory, self.data[offset..])[0..self.getNumberOfDataDirectories()];
+    }
+
+    pub fn getSymtab(self: *const Coff) ?Symtab {
+        const coff_header = self.getCoffHeader();
+        if (coff_header.pointer_to_symbol_table == 0) return null;
+
+        const offset = coff_header.pointer_to_symbol_table;
+        const size = coff_header.number_of_symbols * Symbol.sizeOf();
+        return .{ .buffer = self.data[offset..][0..size] };
+    }
+
+    pub fn getStrtab(self: *const Coff) ?Strtab {
+        const coff_header = self.getCoffHeader();
+        if (coff_header.pointer_to_symbol_table == 0) return null;
+
+        const offset = coff_header.pointer_to_symbol_table + Symbol.sizeOf() * coff_header.number_of_symbols;
+        const size = mem.readIntLittle(u32, self.data[offset..][0..4]);
+        return .{ .buffer = self.data[offset..][0..size] };
+    }
+
+    pub fn getSectionHeaders(self: *const Coff) []align(1) const SectionHeader {
+        const coff_header = self.getCoffHeader();
+        const offset = self.coff_header_offset + @sizeOf(CoffHeader) + coff_header.size_of_optional_header;
+        return @ptrCast([*]align(1) SectionHeader, self.data.ptr + offset)[0..coff_header.number_of_sections];
+    }
+
+    pub fn getSectionName(self: *const Coff, sect_hdr: *align(1) const SectionHeader) []const u8 {
+        const name = sect_hdr.getName() orelse blk: {
+            const strtab = self.getStrtab().?;
+            const name_offset = sect_hdr.getNameOffset().?;
+            break :blk strtab.get(name_offset);
+        };
+        return name;
+    }
+
+    pub fn getSectionByName(self: *const Coff, comptime name: []const u8) ?*align(1) const SectionHeader {
+        for (self.getSectionHeaders()) |*sect| {
+            if (mem.eql(u8, self.getSectionName(sect), name)) {
+                return sect;
             }
         }
         return null;
     }
 
     // Return an owned slice full of the section data
-    pub fn getSectionData(self: *Coff, comptime name: []const u8, allocator: mem.Allocator) ![]u8 {
-        const sec = for (self.sections.items) |*sec| {
-            if (mem.eql(u8, sec.header.name[0..name.len], name)) {
-                break sec;
-            }
-        } else {
-            return error.MissingCoffSection;
-        };
-        const in = self.in_file.reader();
-        try self.in_file.seekTo(sec.header.pointer_to_raw_data);
-        const out_buff = try allocator.alloc(u8, sec.header.misc.virtual_size);
-        try in.readNoEof(out_buff);
+    pub fn getSectionDataAlloc(self: *const Coff, comptime name: []const u8, allocator: mem.Allocator) ![]u8 {
+        const sec = self.getSectionByName(name) orelse return error.MissingCoffSection;
+        const out_buff = try allocator.alloc(u8, sec.virtual_size);
+        mem.copy(u8, out_buff, self.data[sec.pointer_to_raw_data..][0..sec.virtual_size]);
         return out_buff;
     }
-};
 
-const CoffHeader = struct {
-    machine: u16,
-    number_of_sections: u16,
-    timedate_stamp: u32,
-    pointer_to_symbol_table: u32,
-    number_of_symbols: u32,
-    size_of_optional_header: u16,
-    characteristics: u16,
-};
+    pub const Symtab = struct {
+        buffer: []const u8,
 
-const OptionalHeader = struct {
-    const DataDirectory = struct {
-        virtual_address: u32,
-        size: u32,
-    };
+        fn len(self: Symtab) usize {
+            return @divExact(self.buffer.len, Symbol.sizeOf());
+        }
 
-    magic: u16,
-    data_directory: [IMAGE_NUMBEROF_DIRECTORY_ENTRIES]DataDirectory,
-    entry_addr: u32,
-    code_base: u32,
-    image_base: u64,
-};
+        const Tag = enum {
+            symbol,
+            func_def,
+            debug_info,
+            weak_ext,
+            file_def,
+            sect_def,
+        };
 
-const DebugDirectoryEntry = extern struct {
-    characteristiccs: u32,
-    time_date_stamp: u32,
-    major_version: u16,
-    minor_version: u16,
-    @"type": u32,
-    size_of_data: u32,
-    address_of_raw_data: u32,
-    pointer_to_raw_data: u32,
-};
+        const Record = union(Tag) {
+            symbol: Symbol,
+            debug_info: DebugInfoDefinition,
+            func_def: FunctionDefinition,
+            weak_ext: WeakExternalDefinition,
+            file_def: FileDefinition,
+            sect_def: SectionDefinition,
+        };
 
-pub const Section = struct {
-    header: SectionHeader,
-};
+        /// Lives as long as Symtab instance.
+        fn at(self: Symtab, index: usize, tag: Tag) Record {
+            const offset = index * Symbol.sizeOf();
+            const raw = self.buffer[offset..][0..Symbol.sizeOf()];
+            return switch (tag) {
+                .symbol => .{ .symbol = asSymbol(raw) },
+                .debug_info => .{ .debug_info = asDebugInfo(raw) },
+                .func_def => .{ .func_def = asFuncDef(raw) },
+                .weak_ext => .{ .weak_ext = asWeakExtDef(raw) },
+                .file_def => .{ .file_def = asFileDef(raw) },
+                .sect_def => .{ .sect_def = asSectDef(raw) },
+            };
+        }
+
+        fn asSymbol(raw: []const u8) Symbol {
+            return .{
+                .name = raw[0..8].*,
+                .value = mem.readIntLittle(u32, raw[8..12]),
+                .section_number = @intToEnum(SectionNumber, mem.readIntLittle(u16, raw[12..14])),
+                .@"type" = @bitCast(SymType, mem.readIntLittle(u16, raw[14..16])),
+                .storage_class = @intToEnum(StorageClass, raw[16]),
+                .number_of_aux_symbols = raw[17],
+            };
+        }
+
+        fn asDebugInfo(raw: []const u8) DebugInfoDefinition {
+            return .{
+                .unused_1 = raw[0..4].*,
+                .linenumber = mem.readIntLittle(u16, raw[4..6]),
+                .unused_2 = raw[6..12].*,
+                .pointer_to_next_function = mem.readIntLittle(u32, raw[12..16]),
+                .unused_3 = raw[16..18].*,
+            };
+        }
 
-const SectionHeader = struct {
-    const Misc = union {
-        physical_address: u32,
-        virtual_size: u32,
+        fn asFuncDef(raw: []const u8) FunctionDefinition {
+            return .{
+                .tag_index = mem.readIntLittle(u32, raw[0..4]),
+                .total_size = mem.readIntLittle(u32, raw[4..8]),
+                .pointer_to_linenumber = mem.readIntLittle(u32, raw[8..12]),
+                .pointer_to_next_function = mem.readIntLittle(u32, raw[12..16]),
+                .unused = raw[16..18].*,
+            };
+        }
+
+        fn asWeakExtDef(raw: []const u8) WeakExternalDefinition {
+            return .{
+                .tag_index = mem.readIntLittle(u32, raw[0..4]),
+                .flag = @intToEnum(WeakExternalFlag, mem.readIntLittle(u32, raw[4..8])),
+                .unused = raw[8..18].*,
+            };
+        }
+
+        fn asFileDef(raw: []const u8) FileDefinition {
+            return .{
+                .file_name = raw[0..18].*,
+            };
+        }
+
+        fn asSectDef(raw: []const u8) SectionDefinition {
+            return .{
+                .length = mem.readIntLittle(u32, raw[0..4]),
+                .number_of_relocations = mem.readIntLittle(u16, raw[4..6]),
+                .number_of_linenumbers = mem.readIntLittle(u16, raw[6..8]),
+                .checksum = mem.readIntLittle(u32, raw[8..12]),
+                .number = mem.readIntLittle(u16, raw[12..14]),
+                .selection = @intToEnum(ComdatSelection, raw[14]),
+                .unused = raw[15..18].*,
+            };
+        }
+
+        const Slice = struct {
+            buffer: []const u8,
+            num: usize,
+            count: usize = 0,
+
+            /// Lives as long as Symtab instance.
+            fn next(self: *Slice) ?Symbol {
+                if (self.count >= self.num) return null;
+                const sym = asSymbol(self.buffer[0..Symbol.sizeOf()]);
+                self.count += 1;
+                self.buffer = self.buffer[Symbol.sizeOf()..];
+                return sym;
+            }
+        };
+
+        fn slice(self: Symtab, start: usize, end: ?usize) Slice {
+            const offset = start * Symbol.sizeOf();
+            const llen = if (end) |e| e * Symbol.sizeOf() else self.buffer.len;
+            const num = @divExact(llen - offset, Symbol.sizeOf());
+            return Slice{ .buffer = self.buffer[offset..][0..llen], .num = num };
+        }
     };
 
-    name: [32]u8,
-    misc: Misc,
-    virtual_address: u32,
-    size_of_raw_data: u32,
-    pointer_to_raw_data: u32,
-    pointer_to_relocations: u32,
-    pointer_to_line_numbers: u32,
-    number_of_relocations: u16,
-    number_of_line_numbers: u16,
-    characteristics: u32,
+    pub const Strtab = struct {
+        buffer: []const u8,
+
+        fn get(self: Strtab, off: u32) []const u8 {
+            assert(off < self.buffer.len);
+            return mem.sliceTo(@ptrCast([*:0]const u8, self.buffer.ptr + off), 0);
+        }
+    };
 };
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 5e217890b79289218c6156b4da6997f4d9d05639..917354edf7e1241bcd740fdf031f149ced4426e8 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -816,11 +816,11 @@ pub fn openSelfDebugInfo(allocator: mem.Allocator) anyerror!DebugInfo {
 /// TODO it's weird to take ownership even on error, rework this code.
 fn readCoffDebugInfo(allocator: mem.Allocator, coff_file: File) !ModuleDebugInfo {
     nosuspend {
-        errdefer coff_file.close();
+        defer coff_file.close();
 
         const coff_obj = try allocator.create(coff.Coff);
         errdefer allocator.destroy(coff_obj);
-        coff_obj.* = coff.Coff.init(allocator, coff_file);
+        coff_obj.* = .{ .allocator = allocator };
 
         var di = ModuleDebugInfo{
             .base_address = undefined,
@@ -828,18 +828,21 @@ fn readCoffDebugInfo(allocator: mem.Allocator, coff_file: File) !ModuleDebugInfo
             .debug_data = undefined,
         };
 
-        try di.coff.loadHeader();
-        try di.coff.loadSections();
-        if (di.coff.getSection(".debug_info")) |sec| {
+        // TODO convert to Windows' memory-mapped file API
+        const file_len = math.cast(usize, try coff_file.getEndPos()) orelse math.maxInt(usize);
+        const data = try coff_file.readToEndAlloc(allocator, file_len);
+        try di.coff.parse(data);
+
+        if (di.coff.getSectionByName(".debug_info")) |sec| {
             // This coff file has embedded DWARF debug info
             _ = sec;
             // TODO: free the section data slices
-            const debug_info_data = di.coff.getSectionData(".debug_info", allocator) catch null;
-            const debug_abbrev_data = di.coff.getSectionData(".debug_abbrev", allocator) catch null;
-            const debug_str_data = di.coff.getSectionData(".debug_str", allocator) catch null;
-            const debug_line_data = di.coff.getSectionData(".debug_line", allocator) catch null;
-            const debug_line_str_data = di.coff.getSectionData(".debug_line_str", allocator) catch null;
-            const debug_ranges_data = di.coff.getSectionData(".debug_ranges", allocator) catch null;
+            const debug_info_data = di.coff.getSectionDataAlloc(".debug_info", allocator) catch null;
+            const debug_abbrev_data = di.coff.getSectionDataAlloc(".debug_abbrev", allocator) catch null;
+            const debug_str_data = di.coff.getSectionDataAlloc(".debug_str", allocator) catch null;
+            const debug_line_data = di.coff.getSectionDataAlloc(".debug_line", allocator) catch null;
+            const debug_line_str_data = di.coff.getSectionDataAlloc(".debug_line_str", allocator) catch null;
+            const debug_ranges_data = di.coff.getSectionDataAlloc(".debug_ranges", allocator) catch null;
 
             var dwarf = DW.DwarfInfo{
                 .endian = native_endian,
@@ -1628,7 +1631,7 @@ pub const ModuleDebugInfo = switch (native_os) {
 
             switch (self.debug_data) {
                 .dwarf => |*dwarf| {
-                    const dwarf_address = relocated_address + self.coff.pe_header.image_base;
+                    const dwarf_address = relocated_address + self.coff.getImageBase();
                     return getSymbolFromDwarf(allocator, dwarf_address, dwarf);
                 },
                 .pdb => {
@@ -1636,13 +1639,14 @@ pub const ModuleDebugInfo = switch (native_os) {
                 },
             }
 
-            var coff_section: *coff.Section = undefined;
+            var coff_section: *align(1) const coff.SectionHeader = undefined;
             const mod_index = for (self.debug_data.pdb.sect_contribs) |sect_contrib| {
-                if (sect_contrib.Section > self.coff.sections.items.len) continue;
+                const sections = self.coff.getSectionHeaders();
+                if (sect_contrib.Section > sections.len) continue;
                 // Remember that SectionContribEntry.Section is 1-based.
-                coff_section = &self.coff.sections.items[sect_contrib.Section - 1];
+                coff_section = &sections[sect_contrib.Section - 1];
 
-                const vaddr_start = coff_section.header.virtual_address + sect_contrib.Offset;
+                const vaddr_start = coff_section.virtual_address + sect_contrib.Offset;
                 const vaddr_end = vaddr_start + sect_contrib.Size;
                 if (relocated_address >= vaddr_start and relocated_address < vaddr_end) {
                     break sect_contrib.ModuleIndex;
@@ -1658,11 +1662,11 @@ pub const ModuleDebugInfo = switch (native_os) {
 
             const symbol_name = self.debug_data.pdb.getSymbolName(
                 module,
-                relocated_address - coff_section.header.virtual_address,
+                relocated_address - coff_section.virtual_address,
             ) orelse "???";
             const opt_line_info = try self.debug_data.pdb.getLineNumberInfo(
                 module,
-                relocated_address - coff_section.header.virtual_address,
+                relocated_address - coff_section.virtual_address,
             );
 
             return SymbolInfo{
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index a01b9cf7c3ac9daf1d39e8431c1163580098c30b..6536fbd1ace38753f65630f0f07bd7f436ed04f0 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -204,15 +204,18 @@ pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Option
     index += 2;
 
     // Characteristics
-    var characteristics: u16 = std.coff.IMAGE_FILE_DEBUG_STRIPPED | std.coff.IMAGE_FILE_RELOCS_STRIPPED; // TODO Remove debug info stripped flag when necessary
+    var characteristics: std.coff.CoffHeaderFlags = .{
+        .DEBUG_STRIPPED = 1, // TODO remove debug info stripped flag when necessary
+        .RELOCS_STRIPPED = 1,
+    };
     if (options.output_mode == .Exe) {
-        characteristics |= std.coff.IMAGE_FILE_EXECUTABLE_IMAGE;
+        characteristics.EXECUTABLE_IMAGE = 1;
     }
     switch (self.ptr_width) {
-        .p32 => characteristics |= std.coff.IMAGE_FILE_32BIT_MACHINE,
-        .p64 => characteristics |= std.coff.IMAGE_FILE_LARGE_ADDRESS_AWARE,
+        .p32 => characteristics.@"32BIT_MACHINE" = 1,
+        .p64 => characteristics.LARGE_ADDRESS_AWARE = 1,
     }
-    mem.writeIntLittle(u16, hdr_data[index..][0..2], characteristics);
+    mem.writeIntLittle(u16, hdr_data[index..][0..2], @bitCast(u16, characteristics));
     index += 2;
 
     assert(index == 20);
@@ -352,7 +355,10 @@ pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Option
     mem.set(u8, hdr_data[index..][0..12], 0);
     index += 12;
     // Section flags
-    mem.writeIntLittle(u32, hdr_data[index..][0..4], std.coff.IMAGE_SCN_CNT_INITIALIZED_DATA | std.coff.IMAGE_SCN_MEM_READ);
+    mem.writeIntLittle(u32, hdr_data[index..][0..4], @bitCast(u32, std.coff.SectionHeaderFlags{
+        .CNT_INITIALIZED_DATA = 1,
+        .MEM_READ = 1,
+    }));
     index += 4;
     // Then, the .text section
     hdr_data[index..][0..8].* = ".text\x00\x00\x00".*;
@@ -378,11 +384,12 @@ pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Option
     mem.set(u8, hdr_data[index..][0..12], 0);
     index += 12;
     // Section flags
-    mem.writeIntLittle(
-        u32,
-        hdr_data[index..][0..4],
-        std.coff.IMAGE_SCN_CNT_CODE | std.coff.IMAGE_SCN_MEM_EXECUTE | std.coff.IMAGE_SCN_MEM_READ | std.coff.IMAGE_SCN_MEM_WRITE,
-    );
+    mem.writeIntLittle(u32, hdr_data[index..][0..4], @bitCast(u32, std.coff.SectionHeaderFlags{
+        .CNT_CODE = 1,
+        .MEM_EXECUTE = 1,
+        .MEM_READ = 1,
+        .MEM_WRITE = 1,
+    }));
     index += 4;
 
     assert(index == optional_header_size + section_table_size);
-- 
2.54.0


From 1ce71c86bff351a4ade4321e188a13c9d3cff8b4 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 23 Aug 2022 00:28:15 -0700
Subject: [PATCH 227/290] std.debug: implement support for DWARFv5

---
 lib/std/debug.zig         |  44 +++-
 lib/std/dwarf.zig         | 508 ++++++++++++++++++++++++++------------
 src/link/MachO.zig        |   4 +-
 src/link/MachO/Object.zig |  15 ++
 test/stack_traces.zig     |   8 +-
 5 files changed, 417 insertions(+), 162 deletions(-)

diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 917354edf7e1241bcd740fdf031f149ced4426e8..bfe45569d745aa2e8eff117479e56d11d877840b 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -923,6 +923,11 @@ pub fn readElfDebugInfo(allocator: mem.Allocator, elf_file: File) !ModuleDebugIn
         var opt_debug_line: ?[]const u8 = null;
         var opt_debug_line_str: ?[]const u8 = null;
         var opt_debug_ranges: ?[]const u8 = null;
+        var opt_debug_loclists: ?[]const u8 = null;
+        var opt_debug_rnglists: ?[]const u8 = null;
+        var opt_debug_addr: ?[]const u8 = null;
+        var opt_debug_names: ?[]const u8 = null;
+        var opt_debug_frame: ?[]const u8 = null;
 
         for (shdrs) |*shdr| {
             if (shdr.sh_type == elf.SHT_NULL) continue;
@@ -942,6 +947,16 @@ pub fn readElfDebugInfo(allocator: mem.Allocator, elf_file: File) !ModuleDebugIn
                 opt_debug_line_str = try chopSlice(mapped_mem, shdr.sh_offset, shdr.sh_size);
             } else if (mem.eql(u8, name, ".debug_ranges")) {
                 opt_debug_ranges = try chopSlice(mapped_mem, shdr.sh_offset, shdr.sh_size);
+            } else if (mem.eql(u8, name, ".debug_loclists")) {
+                opt_debug_loclists = try chopSlice(mapped_mem, shdr.sh_offset, shdr.sh_size);
+            } else if (mem.eql(u8, name, ".debug_rnglists")) {
+                opt_debug_rnglists = try chopSlice(mapped_mem, shdr.sh_offset, shdr.sh_size);
+            } else if (mem.eql(u8, name, ".debug_addr")) {
+                opt_debug_addr = try chopSlice(mapped_mem, shdr.sh_offset, shdr.sh_size);
+            } else if (mem.eql(u8, name, ".debug_names")) {
+                opt_debug_names = try chopSlice(mapped_mem, shdr.sh_offset, shdr.sh_size);
+            } else if (mem.eql(u8, name, ".debug_frame")) {
+                opt_debug_frame = try chopSlice(mapped_mem, shdr.sh_offset, shdr.sh_size);
             }
         }
 
@@ -954,6 +969,11 @@ pub fn readElfDebugInfo(allocator: mem.Allocator, elf_file: File) !ModuleDebugIn
             .debug_line = opt_debug_line orelse return error.MissingDebugInfo,
             .debug_line_str = opt_debug_line_str,
             .debug_ranges = opt_debug_ranges,
+            .debug_loclists = opt_debug_loclists,
+            .debug_rnglists = opt_debug_rnglists,
+            .debug_addr = opt_debug_addr,
+            .debug_names = opt_debug_names,
+            .debug_frame = opt_debug_frame,
         };
 
         try DW.openDwarfDebugInfo(&di, allocator);
@@ -1494,6 +1514,11 @@ pub const ModuleDebugInfo = switch (native_os) {
             var opt_debug_str: ?macho.section_64 = null;
             var opt_debug_line_str: ?macho.section_64 = null;
             var opt_debug_ranges: ?macho.section_64 = null;
+            var opt_debug_loclists: ?macho.section_64 = null;
+            var opt_debug_rnglists: ?macho.section_64 = null;
+            var opt_debug_addr: ?macho.section_64 = null;
+            var opt_debug_names: ?macho.section_64 = null;
+            var opt_debug_frame: ?macho.section_64 = null;
 
             for (segcmd.?.getSections()) |sect| {
                 const name = sect.sectName();
@@ -1509,6 +1534,16 @@ pub const ModuleDebugInfo = switch (native_os) {
                     opt_debug_line_str = sect;
                 } else if (mem.eql(u8, name, "__debug_ranges")) {
                     opt_debug_ranges = sect;
+                } else if (mem.eql(u8, name, "__debug_loclists")) {
+                    opt_debug_loclists = sect;
+                } else if (mem.eql(u8, name, "__debug_rnglists")) {
+                    opt_debug_rnglists = sect;
+                } else if (mem.eql(u8, name, "__debug_addr")) {
+                    opt_debug_addr = sect;
+                } else if (mem.eql(u8, name, "__debug_names")) {
+                    opt_debug_names = sect;
+                } else if (mem.eql(u8, name, "__debug_frame")) {
+                    opt_debug_frame = sect;
                 }
             }
 
@@ -1536,6 +1571,11 @@ pub const ModuleDebugInfo = switch (native_os) {
                     try chopSlice(mapped_mem, debug_ranges.offset, debug_ranges.size)
                 else
                     null,
+                .debug_loclists = opt_debug_loclists,
+                .debug_rnglists = opt_debug_rnglists,
+                .debug_addr = opt_debug_addr,
+                .debug_names = opt_debug_names,
+                .debug_frame = opt_debug_frame,
             };
 
             try DW.openDwarfDebugInfo(&di, allocator);
@@ -1590,7 +1630,7 @@ pub const ModuleDebugInfo = switch (native_os) {
                         .compile_unit_name = compile_unit.die.getAttrString(
                             o_file_di,
                             DW.AT.name,
-                            compile_unit.is_64,
+                            self.di.debug_str,
                         ) catch |err| switch (err) {
                             error.MissingDebugInfo, error.InvalidDebugInfo => "???",
                         },
@@ -1712,7 +1752,7 @@ fn getSymbolFromDwarf(allocator: mem.Allocator, address: u64, di: *DW.DwarfInfo)
     if (nosuspend di.findCompileUnit(address)) |compile_unit| {
         return SymbolInfo{
             .symbol_name = nosuspend di.getSymbolName(address) orelse "???",
-            .compile_unit_name = compile_unit.die.getAttrString(di, DW.AT.name, compile_unit.is_64) catch |err| switch (err) {
+            .compile_unit_name = compile_unit.die.getAttrString(di, DW.AT.name, di.debug_str) catch |err| switch (err) {
                 error.MissingDebugInfo, error.InvalidDebugInfo => "???",
             },
             .line_info = nosuspend di.getLineNumberInfo(allocator, compile_unit.*, address) catch |err| switch (err) {
diff --git a/lib/std/dwarf.zig b/lib/std/dwarf.zig
index 40dfc8cebb4aa6671f479331ba53497e4191f19b..5ddc8cb3dc81bff89897a198e978390d0fa14cc5 100644
--- a/lib/std/dwarf.zig
+++ b/lib/std/dwarf.zig
@@ -205,6 +205,7 @@ const AbbrevAttr = struct {
 
 const FormValue = union(enum) {
     Address: u64,
+    AddrOffset: u64,
     Block: []u8,
     Const: Constant,
     ExprLoc: []u8,
@@ -216,14 +217,35 @@ const FormValue = union(enum) {
     StrPtr: u64,
     StrOffset: u64,
     LineStrPtr: u64,
+    LocListOffset: u64,
+    RangeListOffset: u64,
+
+    fn getString(fv: FormValue, di: DwarfInfo) ![]const u8 {
+        switch (fv) {
+            .String => |s| return s,
+            .StrPtr => |off| return di.getString(off),
+            .LineStrPtr => |off| return di.getLineString(off),
+            else => return badDwarf(),
+        }
+    }
+
+    fn getUInt(fv: FormValue, comptime U: type) !U {
+        switch (fv) {
+            .Const => |c| {
+                const int = try c.asUnsignedLe();
+                return math.cast(U, int) orelse return badDwarf();
+            },
+            else => return badDwarf(),
+        }
+    }
 };
 
 const Constant = struct {
     payload: u64,
     signed: bool,
 
-    fn asUnsignedLe(self: *const Constant) !u64 {
-        if (self.signed) return error.InvalidDebugInfo;
+    fn asUnsignedLe(self: Constant) !u64 {
+        if (self.signed) return badDwarf();
         return self.payload;
     }
 };
@@ -252,16 +274,57 @@ const Die = struct {
         return null;
     }
 
-    fn getAttrAddr(self: *const Die, id: u64) !u64 {
-        const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
+    fn getAttrAddr(self: *const Die, di: *DwarfInfo, id: u64) error{ InvalidDebugInfo, MissingDebugInfo }!u64 {
+        const form_value = self.getAttr(id) orelse return missingDwarf();
         return switch (form_value.*) {
             FormValue.Address => |value| value,
+            FormValue.AddrOffset => |index| {
+                const debug_addr = di.debug_addr orelse return badDwarf();
+                if (debug_addr.len < 8) return badDwarf();
+                const first_32_bits = mem.readInt(u32, debug_addr[0..4], di.endian);
+                const is_64 = first_32_bits == 0xffffffff;
+                var off: usize = undefined;
+                const length: u64 = l: {
+                    if (is_64) {
+                        if (debug_addr.len < 16) return badDwarf();
+                        off = 12;
+                        break :l mem.readInt(u64, debug_addr[4..12], di.endian);
+                    } else {
+                        if (debug_addr.len < 8) return badDwarf();
+                        if (first_32_bits >= 0xfffffff0) return badDwarf();
+                        off = 4;
+                        break :l first_32_bits;
+                    }
+                };
+                if (index > length) return badDwarf();
+
+                const version = mem.readInt(u16, debug_addr[off..][0..2], di.endian);
+                off += 2;
+                if (version < 5) return badDwarf();
+
+                const addr_size = debug_addr[off];
+                off += 1;
+
+                const seg_size = debug_addr[off];
+                off += 1;
+
+                const base_offset = self.getAttrSecOffset(AT.addr_base) catch off;
+                const byte_offset = base_offset + (addr_size + seg_size) * index;
+                if (byte_offset + addr_size > debug_addr.len) return badDwarf();
+                switch (addr_size) {
+                    1 => return debug_addr[byte_offset],
+                    2 => return mem.readInt(u16, debug_addr[byte_offset..][0..2], di.endian),
+                    4 => return mem.readInt(u32, debug_addr[byte_offset..][0..4], di.endian),
+                    8 => return mem.readInt(u64, debug_addr[byte_offset..][0..8], di.endian),
+                    else => return badDwarf(),
+                }
+            },
             else => error.InvalidDebugInfo,
         };
     }
 
     fn getAttrSecOffset(self: *const Die, id: u64) !u64 {
-        const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
+        const form_value = self.getAttr(id) orelse return missingDwarf();
         return switch (form_value.*) {
             FormValue.Const => |value| value.asUnsignedLe(),
             FormValue.SecOffset => |value| value,
@@ -270,7 +333,7 @@ const Die = struct {
     }
 
     fn getAttrUnsignedLe(self: *const Die, id: u64) !u64 {
-        const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
+        const form_value = self.getAttr(id) orelse return missingDwarf();
         return switch (form_value.*) {
             FormValue.Const => |value| value.asUnsignedLe(),
             else => error.InvalidDebugInfo,
@@ -278,33 +341,67 @@ const Die = struct {
     }
 
     fn getAttrRef(self: *const Die, id: u64) !u64 {
-        const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
+        const form_value = self.getAttr(id) orelse return missingDwarf();
         return switch (form_value.*) {
             FormValue.Ref => |value| value,
             else => error.InvalidDebugInfo,
         };
     }
 
-    pub fn getAttrString(self: *const Die, di: *DwarfInfo, id: u64, is_64: bool) ![]const u8 {
-        const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
-        return switch (form_value.*) {
-            FormValue.String => |value| value,
-            FormValue.StrPtr => |offset| di.getString(offset),
-            FormValue.StrOffset => |index| blk: {
-                const base_offset = self.getAttrSecOffset(AT.str_offsets_base) catch 0;
-                break :blk di.getLineString(try di.getStringOffset(base_offset + index, is_64));
+    pub fn getAttrString(self: *const Die, di: *DwarfInfo, id: u64, opt_str: ?[]const u8) error{ InvalidDebugInfo, MissingDebugInfo }![]const u8 {
+        const form_value = self.getAttr(id) orelse return missingDwarf();
+        switch (form_value.*) {
+            FormValue.String => |value| return value,
+            FormValue.StrPtr => |offset| return di.getString(offset),
+            FormValue.StrOffset => |index| {
+                const debug_str_offsets = di.debug_str_offsets orelse return badDwarf();
+                if (debug_str_offsets.len < 8) return badDwarf();
+                const first_32_bits = mem.readInt(u32, debug_str_offsets[0..4], di.endian);
+                const is_64 = first_32_bits == 0xffffffff;
+                var off: usize = undefined;
+                const length: u64 = l: {
+                    if (is_64) {
+                        if (debug_str_offsets.len < 16) return badDwarf();
+                        off = 12;
+                        break :l mem.readInt(u64, debug_str_offsets[4..12], di.endian);
+                    } else {
+                        if (debug_str_offsets.len < 8) return badDwarf();
+                        if (first_32_bits >= 0xfffffff0) return badDwarf();
+                        off = 4;
+                        break :l first_32_bits;
+                    }
+                };
+                if (index > length) return badDwarf();
+
+                const version = mem.readInt(u16, debug_str_offsets[off..][0..2], di.endian);
+                off += 2;
+                if (version < 5) return badDwarf();
+
+                off += 2; // reserved
+
+                const base_offset = self.getAttrSecOffset(AT.str_offsets_base) catch off;
+                if (is_64) {
+                    const byte_offset = base_offset + 8 * index;
+                    const offset = mem.readInt(u64, debug_str_offsets[byte_offset..][0..8], di.endian);
+                    return getStringGeneric(opt_str, offset);
+                } else {
+                    const byte_offset = base_offset + 4 * index;
+                    const offset = mem.readInt(u32, debug_str_offsets[byte_offset..][0..4], di.endian);
+                    return getStringGeneric(opt_str, offset);
+                }
             },
-            FormValue.LineStrPtr => |offset| di.getLineString(offset),
-            else => error.InvalidDebugInfo,
-        };
+            FormValue.LineStrPtr => |offset| return di.getLineString(offset),
+            else => return badDwarf(),
+        }
     }
 };
 
 const FileEntry = struct {
-    file_name: []const u8,
-    dir_index: usize,
-    mtime: usize,
-    len_bytes: usize,
+    path: []const u8,
+    dir_index: u32 = 0,
+    mtime: u64 = 0,
+    size: u64 = 0,
+    md5: u128 = 0,
 };
 
 const LineNumberProgram = struct {
@@ -312,13 +409,14 @@ const LineNumberProgram = struct {
     file: usize,
     line: i64,
     column: u64,
+    version: u16,
     is_stmt: bool,
     basic_block: bool,
     end_sequence: bool,
 
     default_is_stmt: bool,
     target_address: u64,
-    include_dirs: []const []const u8,
+    include_dirs: []const FileEntry,
 
     prev_valid: bool,
     prev_address: u64,
@@ -349,12 +447,18 @@ const LineNumberProgram = struct {
         self.prev_end_sequence = undefined;
     }
 
-    pub fn init(is_stmt: bool, include_dirs: []const []const u8, target_address: u64) LineNumberProgram {
+    pub fn init(
+        is_stmt: bool,
+        include_dirs: []const FileEntry,
+        target_address: u64,
+        version: u16,
+    ) LineNumberProgram {
         return LineNumberProgram{
             .address = 0,
             .file = 1,
             .line = 1,
             .column = 0,
+            .version = version,
             .is_stmt = is_stmt,
             .basic_block = false,
             .end_sequence = false,
@@ -377,18 +481,24 @@ const LineNumberProgram = struct {
         allocator: mem.Allocator,
         file_entries: []const FileEntry,
     ) !?debug.LineInfo {
-        if (self.prev_valid and self.target_address >= self.prev_address and self.target_address < self.address) {
-            const file_entry = if (self.prev_file == 0) {
-                return error.MissingDebugInfo;
-            } else if (self.prev_file - 1 >= file_entries.len) {
-                return error.InvalidDebugInfo;
-            } else &file_entries[self.prev_file - 1];
+        if (self.prev_valid and
+            self.target_address >= self.prev_address and
+            self.target_address < self.address)
+        {
+            const file_index = if (self.version >= 5) self.prev_file else i: {
+                if (self.prev_file == 0) return missingDwarf();
+                break :i self.prev_file - 1;
+            };
 
-            const dir_name = if (file_entry.dir_index >= self.include_dirs.len) {
-                return error.InvalidDebugInfo;
-            } else self.include_dirs[file_entry.dir_index];
+            if (file_index >= file_entries.len) return badDwarf();
+            const file_entry = &file_entries[file_index];
 
-            const file_name = try fs.path.join(allocator, &[_][]const u8{ dir_name, file_entry.file_name });
+            if (file_entry.dir_index >= self.include_dirs.len) return badDwarf();
+            const dir_name = self.include_dirs[file_entry.dir_index].path;
+
+            const file_name = try fs.path.join(allocator, &[_][]const u8{
+                dir_name, file_entry.path,
+            });
 
             return debug.LineInfo{
                 .line = if (self.prev_line >= 0) @intCast(u64, self.prev_line) else 0,
@@ -415,7 +525,7 @@ fn readUnitLength(in_stream: anytype, endian: std.builtin.Endian, is_64: *bool)
     if (is_64.*) {
         return in_stream.readInt(u64, endian);
     } else {
-        if (first_32_bits >= 0xfffffff0) return error.InvalidDebugInfo;
+        if (first_32_bits >= 0xfffffff0) return badDwarf();
         // TODO this cast should not be needed
         return @as(u64, first_32_bits);
     }
@@ -492,6 +602,12 @@ fn parseFormValueRef(in_stream: anytype, endian: std.builtin.Endian, size: i32)
 fn parseFormValue(allocator: mem.Allocator, in_stream: anytype, form_id: u64, endian: std.builtin.Endian, is_64: bool) anyerror!FormValue {
     return switch (form_id) {
         FORM.addr => FormValue{ .Address = try readAddress(in_stream, endian, @sizeOf(usize) == 8) },
+        FORM.addrx1 => return FormValue{ .AddrOffset = try in_stream.readInt(u8, endian) },
+        FORM.addrx2 => return FormValue{ .AddrOffset = try in_stream.readInt(u16, endian) },
+        FORM.addrx3 => return FormValue{ .AddrOffset = try in_stream.readInt(u24, endian) },
+        FORM.addrx4 => return FormValue{ .AddrOffset = try in_stream.readInt(u32, endian) },
+        FORM.addrx => return FormValue{ .AddrOffset = try nosuspend leb.readULEB128(u64, in_stream) },
+
         FORM.block1 => parseFormValueBlock(allocator, in_stream, endian, 1),
         FORM.block2 => parseFormValueBlock(allocator, in_stream, endian, 2),
         FORM.block4 => parseFormValueBlock(allocator, in_stream, endian, 4),
@@ -527,10 +643,11 @@ fn parseFormValue(allocator: mem.Allocator, in_stream: anytype, form_id: u64, en
 
         FORM.string => FormValue{ .String = try in_stream.readUntilDelimiterAlloc(allocator, 0, math.maxInt(usize)) },
         FORM.strp => FormValue{ .StrPtr = try readAddress(in_stream, endian, is_64) },
-        FORM.strx1 => return FormValue{ .StrOffset = @intCast(u64, try in_stream.readInt(u8, endian)) },
-        FORM.strx2 => return FormValue{ .StrOffset = @intCast(u64, try in_stream.readInt(u16, endian)) },
-        FORM.strx3 => return FormValue{ .StrOffset = @intCast(u64, try in_stream.readInt(u24, endian)) },
-        FORM.strx4 => return FormValue{ .StrOffset = @intCast(u64, try in_stream.readInt(u32, endian)) },
+        FORM.strx1 => return FormValue{ .StrOffset = try in_stream.readInt(u8, endian) },
+        FORM.strx2 => return FormValue{ .StrOffset = try in_stream.readInt(u16, endian) },
+        FORM.strx3 => return FormValue{ .StrOffset = try in_stream.readInt(u24, endian) },
+        FORM.strx4 => return FormValue{ .StrOffset = try in_stream.readInt(u32, endian) },
+        FORM.strx => return FormValue{ .StrOffset = try nosuspend leb.readULEB128(u64, in_stream) },
         FORM.line_strp => FormValue{ .LineStrPtr = try readAddress(in_stream, endian, is_64) },
         FORM.indirect => {
             const child_form_id = try nosuspend leb.readULEB128(u64, in_stream);
@@ -543,9 +660,11 @@ fn parseFormValue(allocator: mem.Allocator, in_stream: anytype, form_id: u64, en
             return await @asyncCall(frame, {}, parseFormValue, .{ allocator, in_stream, child_form_id, endian, is_64 });
         },
         FORM.implicit_const => FormValue{ .Const = Constant{ .signed = true, .payload = undefined } },
-
+        FORM.loclistx => return FormValue{ .LocListOffset = try nosuspend leb.readULEB128(u64, in_stream) },
+        FORM.rnglistx => return FormValue{ .RangeListOffset = try nosuspend leb.readULEB128(u64, in_stream) },
         else => {
-            return error.InvalidDebugInfo;
+            std.debug.print("unrecognized form id: {x}\n", .{form_id});
+            return badDwarf();
         },
     };
 }
@@ -567,6 +686,11 @@ pub const DwarfInfo = struct {
     debug_line: []const u8,
     debug_line_str: ?[]const u8,
     debug_ranges: ?[]const u8,
+    debug_loclists: ?[]const u8,
+    debug_rnglists: ?[]const u8,
+    debug_addr: ?[]const u8,
+    debug_names: ?[]const u8,
+    debug_frame: ?[]const u8,
     // Filled later by the initializer
     abbrev_table_list: std.ArrayListUnmanaged(AbbrevTableHeader) = .{},
     compile_unit_list: std.ArrayListUnmanaged(CompileUnit) = .{},
@@ -602,7 +726,7 @@ pub const DwarfInfo = struct {
 
     fn scanAllFunctions(di: *DwarfInfo, allocator: mem.Allocator) !void {
         var stream = io.fixedBufferStream(di.debug_info);
-        const in = &stream.reader();
+        const in = stream.reader();
         const seekable = &stream.seekableStream();
         var this_unit_offset: u64 = 0;
 
@@ -619,29 +743,26 @@ pub const DwarfInfo = struct {
             const next_offset = unit_length + (if (is_64) @as(usize, 12) else @as(usize, 4));
 
             const version = try in.readInt(u16, di.endian);
-            if (version < 2 or version > 5) return error.InvalidDebugInfo;
+            if (version < 2 or version > 5) return badDwarf();
 
             var address_size: u8 = undefined;
             var debug_abbrev_offset: u64 = undefined;
-            switch (version) {
-                5 => {
-                    const unit_type = try in.readInt(u8, di.endian);
-                    if (unit_type != UT.compile) return error.InvalidDebugInfo;
-                    address_size = try in.readByte();
-                    debug_abbrev_offset = if (is_64)
-                        try in.readInt(u64, di.endian)
-                    else
-                        try in.readInt(u32, di.endian);
-                },
-                else => {
-                    debug_abbrev_offset = if (is_64)
-                        try in.readInt(u64, di.endian)
-                    else
-                        try in.readInt(u32, di.endian);
-                    address_size = try in.readByte();
-                },
+            if (version >= 5) {
+                const unit_type = try in.readInt(u8, di.endian);
+                if (unit_type != UT.compile) return badDwarf();
+                address_size = try in.readByte();
+                debug_abbrev_offset = if (is_64)
+                    try in.readInt(u64, di.endian)
+                else
+                    try in.readInt(u32, di.endian);
+            } else {
+                debug_abbrev_offset = if (is_64)
+                    try in.readInt(u64, di.endian)
+                else
+                    try in.readInt(u32, di.endian);
+                address_size = try in.readByte();
             }
-            if (address_size != @sizeOf(usize)) return error.InvalidDebugInfo;
+            if (address_size != @sizeOf(usize)) return badDwarf();
 
             const compile_unit_pos = try seekable.getPos();
             const abbrev_table = try di.getAbbrevTable(allocator, debug_abbrev_offset);
@@ -662,30 +783,30 @@ pub const DwarfInfo = struct {
                             // Prevent endless loops
                             while (depth > 0) : (depth -= 1) {
                                 if (this_die_obj.getAttr(AT.name)) |_| {
-                                    const name = try this_die_obj.getAttrString(di, AT.name, is_64);
+                                    const name = try this_die_obj.getAttrString(di, AT.name, di.debug_str);
                                     break :x try allocator.dupe(u8, name);
                                 } else if (this_die_obj.getAttr(AT.abstract_origin)) |_| {
                                     // Follow the DIE it points to and repeat
                                     const ref_offset = try this_die_obj.getAttrRef(AT.abstract_origin);
-                                    if (ref_offset > next_offset) return error.InvalidDebugInfo;
+                                    if (ref_offset > next_offset) return badDwarf();
                                     try seekable.seekTo(this_unit_offset + ref_offset);
                                     this_die_obj = (try di.parseDie(
                                         arena,
                                         in,
                                         abbrev_table,
                                         is_64,
-                                    )) orelse return error.InvalidDebugInfo;
+                                    )) orelse return badDwarf();
                                 } else if (this_die_obj.getAttr(AT.specification)) |_| {
                                     // Follow the DIE it points to and repeat
                                     const ref_offset = try this_die_obj.getAttrRef(AT.specification);
-                                    if (ref_offset > next_offset) return error.InvalidDebugInfo;
+                                    if (ref_offset > next_offset) return badDwarf();
                                     try seekable.seekTo(this_unit_offset + ref_offset);
                                     this_die_obj = (try di.parseDie(
                                         arena,
                                         in,
                                         abbrev_table,
                                         is_64,
-                                    )) orelse return error.InvalidDebugInfo;
+                                    )) orelse return badDwarf();
                                 } else {
                                     break :x null;
                                 }
@@ -695,7 +816,7 @@ pub const DwarfInfo = struct {
                         };
 
                         const pc_range = x: {
-                            if (die_obj.getAttrAddr(AT.low_pc)) |low_pc| {
+                            if (die_obj.getAttrAddr(di, AT.low_pc)) |low_pc| {
                                 if (die_obj.getAttr(AT.high_pc)) |high_pc_value| {
                                     const pc_end = switch (high_pc_value.*) {
                                         FormValue.Address => |value| value,
@@ -703,7 +824,7 @@ pub const DwarfInfo = struct {
                                             const offset = try value.asUnsignedLe();
                                             break :b (low_pc + offset);
                                         },
-                                        else => return error.InvalidDebugInfo,
+                                        else => return badDwarf(),
                                     };
                                     break :x PcRange{
                                         .start = low_pc,
@@ -748,14 +869,14 @@ pub const DwarfInfo = struct {
             const next_offset = unit_length + (if (is_64) @as(usize, 12) else @as(usize, 4));
 
             const version = try in.readInt(u16, di.endian);
-            if (version < 2 or version > 5) return error.InvalidDebugInfo;
+            if (version < 2 or version > 5) return badDwarf();
 
             var address_size: u8 = undefined;
             var debug_abbrev_offset: u64 = undefined;
             switch (version) {
                 5 => {
                     const unit_type = try in.readInt(u8, di.endian);
-                    if (unit_type != UT.compile) return error.InvalidDebugInfo;
+                    if (unit_type != UT.compile) return badDwarf();
                     address_size = try in.readByte();
                     debug_abbrev_offset = if (is_64)
                         try in.readInt(u64, di.endian)
@@ -770,7 +891,7 @@ pub const DwarfInfo = struct {
                     address_size = try in.readByte();
                 },
             }
-            if (address_size != @sizeOf(usize)) return error.InvalidDebugInfo;
+            if (address_size != @sizeOf(usize)) return badDwarf();
 
             const compile_unit_pos = try seekable.getPos();
             const abbrev_table = try di.getAbbrevTable(allocator, debug_abbrev_offset);
@@ -780,12 +901,12 @@ pub const DwarfInfo = struct {
             const compile_unit_die = try allocator.create(Die);
             errdefer allocator.destroy(compile_unit_die);
             compile_unit_die.* = (try di.parseDie(allocator, in, abbrev_table, is_64)) orelse
-                return error.InvalidDebugInfo;
+                return badDwarf();
 
-            if (compile_unit_die.tag_id != TAG.compile_unit) return error.InvalidDebugInfo;
+            if (compile_unit_die.tag_id != TAG.compile_unit) return badDwarf();
 
             const pc_range = x: {
-                if (compile_unit_die.getAttrAddr(AT.low_pc)) |low_pc| {
+                if (compile_unit_die.getAttrAddr(di, AT.low_pc)) |low_pc| {
                     if (compile_unit_die.getAttr(AT.high_pc)) |high_pc_value| {
                         const pc_end = switch (high_pc_value.*) {
                             FormValue.Address => |value| value,
@@ -793,7 +914,7 @@ pub const DwarfInfo = struct {
                                 const offset = try value.asUnsignedLe();
                                 break :b (low_pc + offset);
                             },
-                            else => return error.InvalidDebugInfo,
+                            else => return badDwarf(),
                         };
                         break :x PcRange{
                             .start = low_pc,
@@ -834,7 +955,7 @@ pub const DwarfInfo = struct {
                     // specified by DW_AT.low_pc or to some other value encoded
                     // in the list itself.
                     // If no starting value is specified use zero.
-                    var base_address = compile_unit.die.getAttrAddr(AT.low_pc) catch |err| switch (err) {
+                    var base_address = compile_unit.die.getAttrAddr(di, AT.low_pc) catch |err| switch (err) {
                         error.MissingDebugInfo => @as(u64, 0), // TODO https://github.com/ziglang/zig/issues/11135
                         else => return err,
                     };
@@ -862,7 +983,7 @@ pub const DwarfInfo = struct {
                 }
             }
         }
-        return error.MissingDebugInfo;
+        return missingDwarf();
     }
 
     /// Gets an already existing AbbrevTable given the abbrev_offset, or if not found,
@@ -929,7 +1050,7 @@ pub const DwarfInfo = struct {
     ) !?Die {
         const abbrev_code = try leb.readULEB128(u64, in_stream);
         if (abbrev_code == 0) return null;
-        const table_entry = getAbbrevTableEntry(abbrev_table, abbrev_code) orelse return error.InvalidDebugInfo;
+        const table_entry = getAbbrevTableEntry(abbrev_table, abbrev_code) orelse return badDwarf();
 
         var result = Die{
             // Lives as long as the Die.
@@ -966,7 +1087,7 @@ pub const DwarfInfo = struct {
         const in = &stream.reader();
         const seekable = &stream.seekableStream();
 
-        const compile_unit_cwd = try compile_unit.die.getAttrString(di, AT.comp_dir, compile_unit.is_64);
+        const compile_unit_cwd = try compile_unit.die.getAttrString(di, AT.comp_dir, di.debug_line_str);
         const line_info_offset = try compile_unit.die.getAttrSecOffset(AT.stmt_list);
 
         try seekable.seekTo(line_info_offset);
@@ -974,18 +1095,25 @@ pub const DwarfInfo = struct {
         var is_64: bool = undefined;
         const unit_length = try readUnitLength(in, di.endian, &is_64);
         if (unit_length == 0) {
-            return error.MissingDebugInfo;
+            return missingDwarf();
         }
         const next_offset = unit_length + (if (is_64) @as(usize, 12) else @as(usize, 4));
 
         const version = try in.readInt(u16, di.endian);
-        if (version < 2 or version > 4) return error.InvalidDebugInfo;
+        if (version < 2) return badDwarf();
+
+        var addr_size: u8 = if (is_64) 8 else 4;
+        var seg_size: u8 = 0;
+        if (version >= 5) {
+            addr_size = try in.readByte();
+            seg_size = try in.readByte();
+        }
 
         const prologue_length = if (is_64) try in.readInt(u64, di.endian) else try in.readInt(u32, di.endian);
         const prog_start_offset = (try seekable.getPos()) + prologue_length;
 
         const minimum_instruction_length = try in.readByte();
-        if (minimum_instruction_length == 0) return error.InvalidDebugInfo;
+        if (minimum_instruction_length == 0) return badDwarf();
 
         if (version >= 4) {
             // maximum_operations_per_instruction
@@ -996,7 +1124,7 @@ pub const DwarfInfo = struct {
         const line_base = try in.readByteSigned();
 
         const line_range = try in.readByte();
-        if (line_range == 0) return error.InvalidDebugInfo;
+        if (line_range == 0) return badDwarf();
 
         const opcode_base = try in.readByte();
 
@@ -1014,36 +1142,120 @@ pub const DwarfInfo = struct {
         defer tmp_arena.deinit();
         const arena = tmp_arena.allocator();
 
-        var include_directories = std.ArrayList([]const u8).init(arena);
-        try include_directories.append(compile_unit_cwd);
-
-        while (true) {
-            const dir = try in.readUntilDelimiterAlloc(arena, 0, math.maxInt(usize));
-            if (dir.len == 0) break;
-            try include_directories.append(dir);
-        }
-
+        var include_directories = std.ArrayList(FileEntry).init(arena);
         var file_entries = std.ArrayList(FileEntry).init(arena);
+
+        if (version < 5) {
+            try include_directories.append(.{ .path = compile_unit_cwd });
+
+            while (true) {
+                const dir = try in.readUntilDelimiterAlloc(arena, 0, math.maxInt(usize));
+                if (dir.len == 0) break;
+                try include_directories.append(.{ .path = dir });
+            }
+
+            while (true) {
+                const file_name = try in.readUntilDelimiterAlloc(arena, 0, math.maxInt(usize));
+                if (file_name.len == 0) break;
+                const dir_index = try leb.readULEB128(u32, in);
+                const mtime = try leb.readULEB128(u64, in);
+                const size = try leb.readULEB128(u64, in);
+                try file_entries.append(FileEntry{
+                    .path = file_name,
+                    .dir_index = dir_index,
+                    .mtime = mtime,
+                    .size = size,
+                });
+            }
+        } else {
+            const FileEntFmt = struct {
+                content_type_code: u8,
+                form_code: u16,
+            };
+            {
+                var dir_ent_fmt_buf: [10]FileEntFmt = undefined;
+                const directory_entry_format_count = try in.readByte();
+                if (directory_entry_format_count > dir_ent_fmt_buf.len) return badDwarf();
+                for (dir_ent_fmt_buf[0..directory_entry_format_count]) |*ent_fmt| {
+                    ent_fmt.* = .{
+                        .content_type_code = try leb.readULEB128(u8, in),
+                        .form_code = try leb.readULEB128(u16, in),
+                    };
+                }
+
+                const directories_count = try leb.readULEB128(usize, in);
+                try include_directories.ensureUnusedCapacity(directories_count);
+                {
+                    var i: usize = 0;
+                    while (i < directories_count) : (i += 1) {
+                        var e: FileEntry = .{ .path = &.{} };
+                        for (dir_ent_fmt_buf[0..directory_entry_format_count]) |ent_fmt| {
+                            const form_value = try parseFormValue(
+                                arena,
+                                in,
+                                ent_fmt.form_code,
+                                di.endian,
+                                is_64,
+                            );
+                            switch (ent_fmt.content_type_code) {
+                                LNCT.path => e.path = try form_value.getString(di.*),
+                                LNCT.directory_index => e.dir_index = try form_value.getUInt(u32),
+                                LNCT.timestamp => e.mtime = try form_value.getUInt(u64),
+                                LNCT.size => e.size = try form_value.getUInt(u64),
+                                LNCT.MD5 => e.md5 = try form_value.getUInt(u128),
+                                else => continue,
+                            }
+                        }
+                        include_directories.appendAssumeCapacity(e);
+                    }
+                }
+            }
+
+            var file_ent_fmt_buf: [10]FileEntFmt = undefined;
+            const file_name_entry_format_count = try in.readByte();
+            if (file_name_entry_format_count > file_ent_fmt_buf.len) return badDwarf();
+            for (file_ent_fmt_buf[0..file_name_entry_format_count]) |*ent_fmt| {
+                ent_fmt.* = .{
+                    .content_type_code = try leb.readULEB128(u8, in),
+                    .form_code = try leb.readULEB128(u16, in),
+                };
+            }
+
+            const file_names_count = try leb.readULEB128(usize, in);
+            try file_entries.ensureUnusedCapacity(file_names_count);
+            {
+                var i: usize = 0;
+                while (i < file_names_count) : (i += 1) {
+                    var e: FileEntry = .{ .path = &.{} };
+                    for (file_ent_fmt_buf[0..file_name_entry_format_count]) |ent_fmt| {
+                        const form_value = try parseFormValue(
+                            arena,
+                            in,
+                            ent_fmt.form_code,
+                            di.endian,
+                            is_64,
+                        );
+                        switch (ent_fmt.content_type_code) {
+                            LNCT.path => e.path = try form_value.getString(di.*),
+                            LNCT.directory_index => e.dir_index = try form_value.getUInt(u32),
+                            LNCT.timestamp => e.mtime = try form_value.getUInt(u64),
+                            LNCT.size => e.size = try form_value.getUInt(u64),
+                            LNCT.MD5 => e.md5 = try form_value.getUInt(u128),
+                            else => continue,
+                        }
+                    }
+                    file_entries.appendAssumeCapacity(e);
+                }
+            }
+        }
+
         var prog = LineNumberProgram.init(
             default_is_stmt,
             include_directories.items,
             target_address,
+            version,
         );
 
-        while (true) {
-            const file_name = try in.readUntilDelimiterAlloc(arena, 0, math.maxInt(usize));
-            if (file_name.len == 0) break;
-            const dir_index = try leb.readULEB128(usize, in);
-            const mtime = try leb.readULEB128(usize, in);
-            const len_bytes = try leb.readULEB128(usize, in);
-            try file_entries.append(FileEntry{
-                .file_name = file_name,
-                .dir_index = dir_index,
-                .mtime = mtime,
-                .len_bytes = len_bytes,
-            });
-        }
-
         try seekable.seekTo(prog_start_offset);
 
         const next_unit_pos = line_info_offset + next_offset;
@@ -1053,7 +1265,7 @@ pub const DwarfInfo = struct {
 
             if (opcode == LNS.extended_op) {
                 const op_size = try leb.readULEB128(u64, in);
-                if (op_size < 1) return error.InvalidDebugInfo;
+                if (op_size < 1) return badDwarf();
                 var sub_op = try in.readByte();
                 switch (sub_op) {
                     LNE.end_sequence => {
@@ -1066,19 +1278,19 @@ pub const DwarfInfo = struct {
                         prog.address = addr;
                     },
                     LNE.define_file => {
-                        const file_name = try in.readUntilDelimiterAlloc(arena, 0, math.maxInt(usize));
-                        const dir_index = try leb.readULEB128(usize, in);
-                        const mtime = try leb.readULEB128(usize, in);
-                        const len_bytes = try leb.readULEB128(usize, in);
+                        const path = try in.readUntilDelimiterAlloc(arena, 0, math.maxInt(usize));
+                        const dir_index = try leb.readULEB128(u32, in);
+                        const mtime = try leb.readULEB128(u64, in);
+                        const size = try leb.readULEB128(u64, in);
                         try file_entries.append(FileEntry{
-                            .file_name = file_name,
+                            .path = path,
                             .dir_index = dir_index,
                             .mtime = mtime,
-                            .len_bytes = len_bytes,
+                            .size = size,
                         });
                     },
                     else => {
-                        const fwd_amt = math.cast(isize, op_size - 1) orelse return error.InvalidDebugInfo;
+                        const fwd_amt = math.cast(isize, op_size - 1) orelse return badDwarf();
                         try seekable.seekBy(fwd_amt);
                     },
                 }
@@ -1129,7 +1341,7 @@ pub const DwarfInfo = struct {
                     },
                     LNS.set_prologue_end => {},
                     else => {
-                        if (opcode - 1 >= standard_opcode_lengths.len) return error.InvalidDebugInfo;
+                        if (opcode - 1 >= standard_opcode_lengths.len) return badDwarf();
                         const len_bytes = standard_opcode_lengths[opcode - 1];
                         try seekable.seekBy(len_bytes);
                     },
@@ -1137,50 +1349,15 @@ pub const DwarfInfo = struct {
             }
         }
 
-        return error.MissingDebugInfo;
+        return missingDwarf();
     }
 
-    fn getString(di: *DwarfInfo, offset: u64) ![]const u8 {
-        if (offset > di.debug_str.len)
-            return error.InvalidDebugInfo;
-        const casted_offset = math.cast(usize, offset) orelse
-            return error.InvalidDebugInfo;
-
-        // Valid strings always have a terminating zero byte
-        if (mem.indexOfScalarPos(u8, di.debug_str, casted_offset, 0)) |last| {
-            return di.debug_str[casted_offset..last];
-        }
-
-        return error.InvalidDebugInfo;
-    }
-
-    fn getStringOffset(di: *DwarfInfo, offset: u64, is_64: bool) !u64 {
-        if (di.debug_str_offsets) |debug_str_offsets| {
-            if (offset >= debug_str_offsets.len) {
-                return error.InvalidDebugInfo;
-            }
-            const offset_casted = @intCast(usize, offset);
-            if (is_64) {
-                return std.mem.readIntSlice(u64, debug_str_offsets[offset_casted .. offset_casted + 8], di.endian);
-            }
-            return @intCast(u64, std.mem.readIntSlice(u32, debug_str_offsets[offset_casted .. offset_casted + 4], di.endian));
-        }
-        return error.InvalidDebugInfo;
+    fn getString(di: DwarfInfo, offset: u64) ![]const u8 {
+        return getStringGeneric(di.debug_str, offset);
     }
 
-    fn getLineString(di: *DwarfInfo, offset: u64) ![]const u8 {
-        const debug_line_str = di.debug_line_str orelse return error.InvalidDebugInfo;
-        if (offset > debug_line_str.len)
-            return error.InvalidDebugInfo;
-        const casted_offset = math.cast(usize, offset) orelse
-            return error.InvalidDebugInfo;
-
-        // Valid strings always have a terminating zero byte
-        if (mem.indexOfScalarPos(u8, debug_line_str, casted_offset, 0)) |last| {
-            return debug_line_str[casted_offset..last];
-        }
-
-        return error.InvalidDebugInfo;
+    fn getLineString(di: DwarfInfo, offset: u64) ![]const u8 {
+        return getStringGeneric(di.debug_line_str, offset);
     }
 };
 
@@ -1190,3 +1367,24 @@ pub fn openDwarfDebugInfo(di: *DwarfInfo, allocator: mem.Allocator) !void {
     try di.scanAllFunctions(allocator);
     try di.scanAllCompileUnits(allocator);
 }
+
+/// This function is to make it handy to comment out the return and make it
+/// into a crash when working on this file.
+inline fn badDwarf() error{InvalidDebugInfo} {
+    //std.os.abort(); // can be handy to uncomment when working on this file
+    return error.InvalidDebugInfo;
+}
+
+inline fn missingDwarf() error{MissingDebugInfo} {
+    //std.os.abort(); // can be handy to uncomment when working on this file
+    return error.MissingDebugInfo;
+}
+
+fn getStringGeneric(opt_str: ?[]const u8, offset: u64) ![:0]const u8 {
+    const str = opt_str orelse return badDwarf();
+    if (offset > str.len) return badDwarf();
+    const casted_offset = math.cast(usize, offset) orelse return badDwarf();
+    // Valid strings always have a terminating zero byte
+    const last = mem.indexOfScalarPos(u8, str, casted_offset, 0) orelse return badDwarf();
+    return str[casted_offset..last :0];
+}
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 8eb29dcfc7d57b0377d29edac1947a38da27c311..91eaedc7349038d485d53f850b2209cd64f45b9f 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -5862,8 +5862,8 @@ pub fn generateSymbolStabs(
         else => |e| return e,
     };
 
-    const tu_name = try compile_unit.die.getAttrString(&debug_info, dwarf.AT.name, compile_unit.is_64);
-    const tu_comp_dir = try compile_unit.die.getAttrString(&debug_info, dwarf.AT.comp_dir, compile_unit.is_64);
+    const tu_name = try compile_unit.die.getAttrString(&debug_info, dwarf.AT.name, debug_info.debug_str);
+    const tu_comp_dir = try compile_unit.die.getAttrString(&debug_info, dwarf.AT.comp_dir, debug_info.debug_str);
 
     // Open scope
     try locals.ensureUnusedCapacity(3);
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index 9bcf5243c18c1af2338e8f483a645f6258ad7035..22627975f26f1da7d78d966bac575b1fc7a180ca 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -584,6 +584,11 @@ pub fn parseDwarfInfo(self: Object) error{Overflow}!dwarf.DwarfInfo {
         .debug_line = &[0]u8{},
         .debug_line_str = &[0]u8{},
         .debug_ranges = &[0]u8{},
+        .debug_loclists = &[0]u8{},
+        .debug_rnglists = &[0]u8{},
+        .debug_addr = &[0]u8{},
+        .debug_names = &[0]u8{},
+        .debug_frame = &[0]u8{},
     };
     for (self.sections.items) |sect| {
         const segname = sect.segName();
@@ -601,6 +606,16 @@ pub fn parseDwarfInfo(self: Object) error{Overflow}!dwarf.DwarfInfo {
                 di.debug_line_str = try self.getSectionContents(sect);
             } else if (mem.eql(u8, sectname, "__debug_ranges")) {
                 di.debug_ranges = try self.getSectionContents(sect);
+            } else if (mem.eql(u8, sectname, "__debug_loclists")) {
+                di.debug_loclists = try self.getSectionContents(sect);
+            } else if (mem.eql(u8, sectname, "__debug_rnglists")) {
+                di.debug_rnglists = try self.getSectionContents(sect);
+            } else if (mem.eql(u8, sectname, "__debug_addr")) {
+                di.debug_addr = try self.getSectionContents(sect);
+            } else if (mem.eql(u8, sectname, "__debug_names")) {
+                di.debug_names = try self.getSectionContents(sect);
+            } else if (mem.eql(u8, sectname, "__debug_frame")) {
+                di.debug_frame = try self.getSectionContents(sect);
             }
         }
     }
diff --git a/test/stack_traces.zig b/test/stack_traces.zig
index 06534a2f7e45c489a0ca08a85396cfe00395865f..ed0dc9e235bbf94a902ea6cf89efd815fdd2328f 100644
--- a/test/stack_traces.zig
+++ b/test/stack_traces.zig
@@ -21,7 +21,7 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
         },
         .ReleaseSafe = .{
             .exclude_os = .{
-                .windows, // segfault
+                .windows, // TODO
                 .linux, // defeated by aggressive inlining
             },
             .expect = 
@@ -71,7 +71,8 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
         },
         .ReleaseSafe = .{
             .exclude_os = .{
-                .windows, // segfault
+                .windows, // TODO
+                .linux, // TODO
             },
             .expect = 
             \\error: TheSkyIsFalling
@@ -137,7 +138,8 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
         },
         .ReleaseSafe = .{
             .exclude_os = .{
-                .windows, // segfault
+                .windows, // TODO
+                .linux, // TODO
             },
             .expect = 
             \\error: TheSkyIsFalling
-- 
2.54.0


From 583175dc1d8d14bc92838476eb226f0e91077abc Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Tue, 23 Aug 2022 15:59:09 +0200
Subject: [PATCH 228/290] ci: upload rendered source listings in stdlib docs

---
 ci/srht/update_download_page | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/ci/srht/update_download_page b/ci/srht/update_download_page
index 5277da7d2bb361c2fa3dd3406940ffd6d078d291..e84fcd910a2c61069357fad67dbfd42ef3b5e1a1 100755
--- a/ci/srht/update_download_page
+++ b/ci/srht/update_download_page
@@ -103,14 +103,18 @@ cd "$HOME"
 
 # Upload new stdlib autodocs 
 mkdir -p docs_to_upload/documentation/master/std/
-
 gzip -c -9 "$ZIGDIR/docs/std/index.html" >  docs_to_upload/documentation/master/std/index.html
 gzip -c -9 "$ZIGDIR/docs/std/data.js" > docs_to_upload/documentation/master/std/data.js
 gzip -c -9 "$ZIGDIR/docs/std/main.js" > docs_to_upload/documentation/master/std/main.js
 gzip -c -9 "$LANGREF" > docs_to_upload/documentation/master/index.html
 $S3CMD put -P --no-mime-magic --recursive --add-header="Content-Encoding:gzip" --add-header="Cache-Control: max-age=0, must-revalidate" "docs_to_upload/" s3://ziglang.org/
 
+mkdir -p docs_src_to_upload/documentation/master/std/
+cp -r "$ZIGDIR/docs/src" docs_src_to_upload/documentation/master/std/
+$S3CMD put -P --no-mime-magic --recursive --add-header:"Content-Type:text/html" --add-header="Cache-Control: max-age=0, must-revalidate" "docs_src_to_upload/" s3://ziglang.org/
+
 ## Copy without compression:
+# mkdir -p docs_to_upload/documentation/master/std/
 # cp "$ZIGDIR/docs/std/index.html" docs_to_upload/documentation/master/std/index.html
 # cp "$ZIGDIR/docs/std/data.js" docs_to_upload/documentation/master/std/data.js
 # cp "$ZIGDIR/docs/std/main.js" docs_to_upload/documentation/master/std/main.js
-- 
2.54.0


From 0482e8ba9d63ea009a9e0c2d497371261764d3e1 Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Sun, 21 Aug 2022 18:53:00 +0200
Subject: [PATCH 229/290] autodoc: initial support for struct_init_anon

---
 lib/docs/main.js |  27 +++++----
 src/Autodoc.zig  | 150 +++++++++++++++++++++++++++++++++++------------
 2 files changed, 129 insertions(+), 48 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 5a3572a62944f65daba9b8ce31e0aaeb7d3f264a..8f6bbcedd219ef952c473018da980c0128782d83 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1430,20 +1430,25 @@ var zigAnalysis;
         return lhs + "!" + rhs;
       }
       case "struct": {
-        const struct_name =
-          zigAnalysis.decls[expr.struct[0].val.typeRef.refPath[0].declRef].name;
+        // const struct_name =
+        //   zigAnalysis.decls[expr.struct[0].val.typeRef.refPath[0].declRef].name;
+        const struct_name = ".";
         let struct_body = "";
         struct_body += struct_name + "{ ";
         for (let i = 0; i < expr.struct.length; i++) {
-          const val = expr.struct[i].name;
-          const exprArg = zigAnalysis.exprs[expr.struct[i].val.expr.as.exprArg];
-          let value_field = exprArg[Object.keys(exprArg)[0]];
-          if (value_field instanceof Object) {
-            value_field =
-              zigAnalysis.decls[value_field[0].val.typeRef.refPath[0].declRef]
-                .name;
-          }
-          struct_body += "." + val + " = " + value_field;
+          const fv = expr.struct[i];
+          const field_name = fv.name;
+          const exprArg = zigAnalysis.exprs[fv.val.expr.as.exprArg];
+          let field_value = exprName(exprArg, opts);
+          // TODO: commented out because it seems not needed. if it deals
+          //       with a corner case, please add a comment when re-enabling it.
+          // let field_value = exprArg[Object.keys(exprArg)[0]];
+          // if (field_value instanceof Object) {
+          //   value_field = exprName(value_field)
+          //     zigAnalysis.decls[value_field[0].val.typeRef.refPath[0].declRef]
+          //       .name;
+          // }
+          struct_body += "." + field_name + " = " + field_value;
           if (i !== expr.struct.length - 1) {
             struct_body += ", ";
           } else {
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index f983bdfdf052a78d1bd7bc0e9f9bd0ec850bab9f..128e09faf2c640e258b75753056c27425590d431 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -69,6 +69,8 @@ pub fn generateZirData(self: *Autodoc) !void {
         }
     }
 
+    log.debug("Ref map size: {}", .{Ref.typed_value_map.len});
+
     const root_src_dir = self.module.main_pkg.root_src_directory;
     const root_src_path = self.module.main_pkg.root_src_path;
     const joined_src_path = try root_src_dir.join(self.arena, &.{root_src_path});
@@ -159,6 +161,9 @@ pub fn generateZirData(self: *Autodoc) !void {
                     .void_type => .{
                         .Void = .{ .name = tmpbuf.toOwnedSlice() },
                     },
+                    .type_info_type => .{
+                        .Unanalyzed = .{},
+                    },
                     .type_type => .{
                         .Type = .{ .name = tmpbuf.toOwnedSlice() },
                     },
@@ -608,6 +613,7 @@ const DocData = struct {
         type: usize, // index in `types`
         this: usize, // index in `types`
         declRef: usize, // index in `decls`
+        builtinField: enum { len, ptr },
         fieldRef: FieldRef,
         refPath: []Expr,
         int: struct {
@@ -697,20 +703,26 @@ const DocData = struct {
             var jsw = std.json.writeStream(w, 15);
             try jsw.beginObject();
             try jsw.objectField(@tagName(active_tag));
-            inline for (comptime std.meta.fields(Expr)) |case| {
-                if (@field(Expr, case.name) == active_tag) {
-                    switch (active_tag) {
-                        .int => {
-                            if (self.int.negated) try w.writeAll("-");
-                            try jsw.emitNumber(self.int.value);
-                        },
-                        .int_big => {
+            switch (self) {
+                .int => {
+                    if (self.int.negated) try w.writeAll("-");
+                    try jsw.emitNumber(self.int.value);
+                },
+                .int_big => {
 
-                            //@panic("TODO: json serialization of big ints!");
-                            //if (v.negated) try w.writeAll("-");
-                            //try jsw.emitNumber(v.value);
-                        },
-                        else => {
+                    //@panic("TODO: json serialization of big ints!");
+                    //if (v.negated) try w.writeAll("-");
+                    //try jsw.emitNumber(v.value);
+                },
+                .builtinField => {
+                    try jsw.emitString(@tagName(self.builtinField));
+                },
+                else => {
+                    inline for (comptime std.meta.fields(Expr)) |case| {
+                        // TODO: this is super ugly, fix once `inline else` is a thing
+                        if (comptime std.mem.eql(u8, case.name, "builtinField"))
+                            continue;
+                        if (@field(Expr, case.name) == active_tag) {
                             try std.json.stringify(@field(self, case.name), opt, w);
                             jsw.state_index -= 1;
                             // TODO: we should not reach into the state of the
@@ -719,9 +731,9 @@ const DocData = struct {
                             //       would be nice to have a proper integration
                             //       between the json writer and the generic
                             //       std.json.stringify implementation
-                        },
+                        }
                     }
-                }
+                },
             }
             try jsw.endObject();
         }
@@ -1905,31 +1917,38 @@ fn walkInstruction(
             const extra = file.zir.extraData(Zir.Inst.Field, pl_node.payload_index);
 
             var path: std.ArrayListUnmanaged(DocData.Expr) = .{};
-            var lhs = @enumToInt(extra.data.lhs) - Ref.typed_value_map.len; // underflow = need to handle Refs
-
             try path.append(self.arena, .{
                 .string = file.zir.nullTerminatedString(extra.data.field_name_start),
             });
+
             // Put inside path the starting index of each decl name that
-            // we encounter as we navigate through all the field_vals
-            while (tags[lhs] == .field_val or
-                tags[lhs] == .field_call_bind or
-                tags[lhs] == .field_ptr or
-                tags[lhs] == .field_type)
-            {
-                const lhs_extra = file.zir.extraData(
-                    Zir.Inst.Field,
-                    data[lhs].pl_node.payload_index,
-                );
+            // we encounter as we navigate through all the field_*s
+            const lhs_ref = blk: {
+                var lhs_extra = extra;
+                while (true) {
+                    if (@enumToInt(lhs_extra.data.lhs) < Ref.typed_value_map.len) {
+                        break :blk lhs_extra.data.lhs;
+                    }
 
-                try path.append(self.arena, .{
-                    .string = file.zir.nullTerminatedString(lhs_extra.data.field_name_start),
-                });
-                lhs = @enumToInt(lhs_extra.data.lhs) - Ref.typed_value_map.len; // underflow = need to handle Refs
-            }
+                    const lhs = @enumToInt(lhs_extra.data.lhs) - Ref.typed_value_map.len;
+                    if (tags[lhs] != .field_val and
+                        tags[lhs] != .field_call_bind and
+                        tags[lhs] != .field_ptr and
+                        tags[lhs] != .field_type) break :blk lhs_extra.data.lhs;
+
+                    lhs_extra = file.zir.extraData(
+                        Zir.Inst.Field,
+                        data[lhs].pl_node.payload_index,
+                    );
+
+                    try path.append(self.arena, .{
+                        .string = file.zir.nullTerminatedString(lhs_extra.data.field_name_start),
+                    });
+                }
+            };
 
             // TODO: double check that we really don't need type info here
-            const wr = try self.walkInstruction(file, parent_scope, lhs, false);
+            const wr = try self.walkRef(file, parent_scope, lhs_ref, false);
             try path.append(self.arena, wr.expr);
 
             // This way the data in `path` has the same ordering that the ref
@@ -1948,7 +1967,7 @@ fn walkInstruction(
             // - (2) Paths can sometimes never resolve fully. This means that
             //       any value that depends on that will have to become a
             //       comptimeExpr.
-            try self.tryResolveRefPath(file, lhs, path.items);
+            try self.tryResolveRefPath(file, inst_index, path.items);
             return DocData.WalkResult{ .expr = .{ .refPath = path.items } };
         },
         .int_type => {
@@ -2053,6 +2072,46 @@ fn walkInstruction(
             );
             return self.cteTodo(@tagName(tags[inst_index]));
         },
+        .struct_init_anon => {
+            const pl_node = data[inst_index].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.StructInitAnon, pl_node.payload_index);
+
+            const field_vals = try self.arena.alloc(
+                DocData.Expr.FieldVal,
+                extra.data.fields_len,
+            );
+
+            log.debug("number of fields: {}", .{extra.data.fields_len});
+            var idx = extra.end;
+            for (field_vals) |*fv| {
+                const init_extra = file.zir.extraData(Zir.Inst.StructInitAnon.Item, idx);
+                const field_name = file.zir.nullTerminatedString(init_extra.data.field_name);
+                fv.* = .{
+                    .name = field_name,
+                    .val = DocData.WalkResult{
+                        .expr = .{ .comptimeExpr = 0 },
+                    },
+                };
+                // printWithContext(
+                //     file,
+                //     inst_index,
+                //     "analyzing field [{}] %{} `{s}`",
+                //     .{ i, init_extra.data.init, field_name },
+                // );
+                // const value = try self.walkRef(
+                //     file,
+                //     parent_scope,
+                //     init_extra.data.init,
+                //     need_type,
+                // );
+                // fv.* = .{ .name = field_name, .val = value };
+                // idx = init_extra.end;
+            }
+
+            return DocData.WalkResult{
+                .expr = .{ .@"struct" = field_vals },
+            };
+        },
         .error_set_decl => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.ErrorSetDecl, pl_node.payload_index);
@@ -3094,6 +3153,20 @@ fn tryResolveRefPath(
 
                     return;
                 },
+                .Array => {
+                    if (std.mem.eql(u8, child_string, "len")) {
+                        path[i + 1] = .{
+                            .builtinField = .len,
+                        };
+                    } else {
+                        panicWithContext(
+                            file,
+                            inst_index,
+                            "TODO: handle `{s}` in tryResolveDeclPath.type.Array\nInfo: {}",
+                            .{ child_string, resolved_parent },
+                        );
+                    }
+                },
                 .Enum => |t_enum| {
                     for (t_enum.pubDecls) |d| {
                         // TODO: this could be improved a lot
@@ -3820,9 +3893,12 @@ fn walkRef(
     } else if (enum_value < Ref.typed_value_map.len) {
         switch (ref) {
             else => {
-                std.debug.panic("TODO: handle {s} in `walkRef`\n", .{
-                    @tagName(ref),
-                });
+                panicWithContext(
+                    file,
+                    0,
+                    "TODO: handle {s} in walkRef",
+                    .{@tagName(ref)},
+                );
             },
             .undef => {
                 return DocData.WalkResult{ .expr = .@"undefined" };
-- 
2.54.0


From b32e5a14ce20ae2943576de76d1af4c8bcc9dd72 Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Tue, 23 Aug 2022 17:37:06 +0200
Subject: [PATCH 230/290] autodoc: handle self-referential call+field_type
 instructions

---
 lib/docs/main.js |  3 +--
 src/Autodoc.zig  | 59 +++++++++++++++++++++++++++++-------------------
 2 files changed, 37 insertions(+), 25 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 8f6bbcedd219ef952c473018da980c0128782d83..47bbc9591a7ce18ee6f1097dfaa857f96ec6f59c 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1438,8 +1438,7 @@ var zigAnalysis;
         for (let i = 0; i < expr.struct.length; i++) {
           const fv = expr.struct[i];
           const field_name = fv.name;
-          const exprArg = zigAnalysis.exprs[fv.val.expr.as.exprArg];
-          let field_value = exprName(exprArg, opts);
+          const field_value = exprName(fv.val.expr, opts);
           // TODO: commented out because it seems not needed. if it deals
           //       with a corner case, please add a comment when re-enabling it.
           // let field_value = exprArg[Object.keys(exprArg)[0]];
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index 128e09faf2c640e258b75753056c27425590d431..f8560407feb851da4269d65a8acf6ee5a2599fe2 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -162,7 +162,7 @@ pub fn generateZirData(self: *Autodoc) !void {
                         .Void = .{ .name = tmpbuf.toOwnedSlice() },
                     },
                     .type_info_type => .{
-                        .Unanalyzed = .{},
+                        .ComptimeExpr = .{ .name = tmpbuf.toOwnedSlice() },
                     },
                     .type_type => .{
                         .Type = .{ .name = tmpbuf.toOwnedSlice() },
@@ -1947,8 +1947,30 @@ fn walkInstruction(
                 }
             };
 
+            // If the lhs is a `call` instruction, it means that we're inside
+            // a function call and we're referring to one of its arguments.
+            // We can't just blindly analyze the instruction or we will
+            // start recursing forever.
+            // TODO: add proper resolution of the container type for `calls`
+            // TODO: we're like testing lhs as an instruction twice
+            //       (above and below) this todo, maybe a cleaer solution woul
+            //       avoid that.
             // TODO: double check that we really don't need type info here
-            const wr = try self.walkRef(file, parent_scope, lhs_ref, false);
+
+            const wr = blk: {
+                if (@enumToInt(lhs_ref) >= Ref.typed_value_map.len) {
+                    const lhs_inst = @enumToInt(lhs_ref) - Ref.typed_value_map.len;
+                    if (tags[lhs_inst] == .call) {
+                        break :blk DocData.WalkResult{
+                            .expr = .{
+                                .comptimeExpr = 0,
+                            },
+                        };
+                    }
+                }
+
+                break :blk try self.walkRef(file, parent_scope, lhs_ref, false);
+            };
             try path.append(self.arena, wr.expr);
 
             // This way the data in `path` has the same ordering that the ref
@@ -2081,31 +2103,18 @@ fn walkInstruction(
                 extra.data.fields_len,
             );
 
-            log.debug("number of fields: {}", .{extra.data.fields_len});
             var idx = extra.end;
             for (field_vals) |*fv| {
                 const init_extra = file.zir.extraData(Zir.Inst.StructInitAnon.Item, idx);
                 const field_name = file.zir.nullTerminatedString(init_extra.data.field_name);
-                fv.* = .{
-                    .name = field_name,
-                    .val = DocData.WalkResult{
-                        .expr = .{ .comptimeExpr = 0 },
-                    },
-                };
-                // printWithContext(
-                //     file,
-                //     inst_index,
-                //     "analyzing field [{}] %{} `{s}`",
-                //     .{ i, init_extra.data.init, field_name },
-                // );
-                // const value = try self.walkRef(
-                //     file,
-                //     parent_scope,
-                //     init_extra.data.init,
-                //     need_type,
-                // );
-                // fv.* = .{ .name = field_name, .val = value };
-                // idx = init_extra.end;
+                const value = try self.walkRef(
+                    file,
+                    parent_scope,
+                    init_extra.data.init,
+                    need_type,
+                );
+                fv.* = .{ .name = field_name, .val = value };
+                idx = init_extra.end;
             }
 
             return DocData.WalkResult{
@@ -3131,6 +3140,10 @@ fn tryResolveRefPath(
                         .{ @tagName(self.types.items[t_index]), resolved_parent },
                     );
                 },
+                .ComptimeExpr => {
+                    // Same as the comptimeExpr branch above
+                    break :outer;
+                },
                 .Unanalyzed => {
                     // This decl path is pending completion
                     {
-- 
2.54.0


From e0f8198c2f84559d4cd29f2d87d19424f9f2e2ee Mon Sep 17 00:00:00 2001
From: ominitay <37453713+ominitay@users.noreply.github.com>
Date: Tue, 23 Aug 2022 18:08:50 +0100
Subject: [PATCH 231/290] autodocs: improve error set rendering

---
 lib/docs/main.js | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 5a3572a62944f65daba9b8ce31e0aaeb7d3f264a..f33646d258381dabb27f3d027389a717d47b6fe4 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -1768,11 +1768,15 @@ var zigAnalysis;
             let errSetObj = typeObj;
             if (errSetObj.fields == null) {
               return '<span class="tok-type">anyerror</span>';
+            } else if (errSetObj.fields.length == 0) {
+              return "error{}";
+            } else if (errSetObj.fields.length == 1) {
+              return "error{" + errSetObj.fields[0].name + "}";
             } else {
               // throw "TODO";
-              let html = "error{" + errSetObj.fields[0].name;
+              let html = "error{ " + errSetObj.fields[0].name;
               for (let i = 1; i < errSetObj.fields.length; i++) html += ", " + errSetObj.fields[i].name;
-              html += "}";
+              html += " }";
               return html;
             }
           }
-- 
2.54.0


From b63667dda33aa8b2f9aafd5923f8c3b9034e90db Mon Sep 17 00:00:00 2001
From: ominitay <37453713+ominitay@users.noreply.github.com>
Date: Tue, 23 Aug 2022 18:42:46 +0100
Subject: [PATCH 232/290] autodocs: improve first-line descriptions

---
 lib/docs/main.js | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 5a3572a62944f65daba9b8ce31e0aaeb7d3f264a..cd8af7c8e9fb1896f56bae9f290d616e37a5a337 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -2835,16 +2835,20 @@ var zigAnalysis;
 
   function shortDescMarkdown(docs) {
     const trimmed_docs = docs.trim();
-    let index = trimmed_docs.indexOf(".");
-    if (index < 0) {
-      index = trimmed_docs.indexOf("\n");
-      if (index < 0) {
-        index = trimmed_docs.length;
-      }
-    } else {
-      index += 1; // include the period
+    let index = trimmed_docs.indexOf("\n\n");
+    let cut = false;
+
+    if (index < 0 || index > 80) {
+        if (trimmed_docs.length > 80) {
+            index = 80;
+            cut = true;
+        } else {
+            index = trimmed_docs.length;
+        }
     }
-    const slice = trimmed_docs.slice(0, index);
+
+    let slice = trimmed_docs.slice(0, index);
+    if (cut) slice += "...";
     return markdown(slice);
   }
 
-- 
2.54.0


From cf9f6fd7f090b175858e7c0109215ddf0922655d Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Tue, 23 Aug 2022 10:28:56 +0200
Subject: [PATCH 233/290] macho: fix compile errors in std.debug

---
 lib/std/debug.zig         | 35 ++++++++++++++++++++++++++++-------
 src/link/MachO/Object.zig |  4 +++-
 2 files changed, 31 insertions(+), 8 deletions(-)

diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index bfe45569d745aa2e8eff117479e56d11d877840b..39dcfe72a64e81e3014c93b5ed41d9a3aa5fdd4f 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -1512,6 +1512,7 @@ pub const ModuleDebugInfo = switch (native_os) {
             var opt_debug_info: ?macho.section_64 = null;
             var opt_debug_abbrev: ?macho.section_64 = null;
             var opt_debug_str: ?macho.section_64 = null;
+            var opt_debug_str_offsets: ?macho.section_64 = null;
             var opt_debug_line_str: ?macho.section_64 = null;
             var opt_debug_ranges: ?macho.section_64 = null;
             var opt_debug_loclists: ?macho.section_64 = null;
@@ -1530,6 +1531,8 @@ pub const ModuleDebugInfo = switch (native_os) {
                     opt_debug_abbrev = sect;
                 } else if (mem.eql(u8, name, "__debug_str")) {
                     opt_debug_str = sect;
+                } else if (mem.eql(u8, name, "__debug_str_offsets")) {
+                    opt_debug_str_offsets = sect;
                 } else if (mem.eql(u8, name, "__debug_line_str")) {
                     opt_debug_line_str = sect;
                 } else if (mem.eql(u8, name, "__debug_ranges")) {
@@ -1561,7 +1564,10 @@ pub const ModuleDebugInfo = switch (native_os) {
                 .debug_info = try chopSlice(mapped_mem, debug_info.offset, debug_info.size),
                 .debug_abbrev = try chopSlice(mapped_mem, debug_abbrev.offset, debug_abbrev.size),
                 .debug_str = try chopSlice(mapped_mem, debug_str.offset, debug_str.size),
-                .debug_str_offsets = null,
+                .debug_str_offsets = if (opt_debug_str_offsets) |debug_str_offsets|
+                    try chopSlice(mapped_mem, debug_str_offsets.offset, debug_str_offsets.size)
+                else
+                    null,
                 .debug_line = try chopSlice(mapped_mem, debug_line.offset, debug_line.size),
                 .debug_line_str = if (opt_debug_line_str) |debug_line_str|
                     try chopSlice(mapped_mem, debug_line_str.offset, debug_line_str.size)
@@ -1571,11 +1577,26 @@ pub const ModuleDebugInfo = switch (native_os) {
                     try chopSlice(mapped_mem, debug_ranges.offset, debug_ranges.size)
                 else
                     null,
-                .debug_loclists = opt_debug_loclists,
-                .debug_rnglists = opt_debug_rnglists,
-                .debug_addr = opt_debug_addr,
-                .debug_names = opt_debug_names,
-                .debug_frame = opt_debug_frame,
+                .debug_loclists = if (opt_debug_loclists) |debug_loclists|
+                    try chopSlice(mapped_mem, debug_loclists.offset, debug_loclists.size)
+                else
+                    null,
+                .debug_rnglists = if (opt_debug_rnglists) |debug_rnglists|
+                    try chopSlice(mapped_mem, debug_rnglists.offset, debug_rnglists.size)
+                else
+                    null,
+                .debug_addr = if (opt_debug_addr) |debug_addr|
+                    try chopSlice(mapped_mem, debug_addr.offset, debug_addr.size)
+                else
+                    null,
+                .debug_names = if (opt_debug_names) |debug_names|
+                    try chopSlice(mapped_mem, debug_names.offset, debug_names.size)
+                else
+                    null,
+                .debug_frame = if (opt_debug_frame) |debug_frame|
+                    try chopSlice(mapped_mem, debug_frame.offset, debug_frame.size)
+                else
+                    null,
             };
 
             try DW.openDwarfDebugInfo(&di, allocator);
@@ -1630,7 +1651,7 @@ pub const ModuleDebugInfo = switch (native_os) {
                         .compile_unit_name = compile_unit.die.getAttrString(
                             o_file_di,
                             DW.AT.name,
-                            self.di.debug_str,
+                            o_file_di.debug_str,
                         ) catch |err| switch (err) {
                             error.MissingDebugInfo, error.InvalidDebugInfo => "???",
                         },
diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig
index 22627975f26f1da7d78d966bac575b1fc7a180ca..00fd16054bf2c11b392fd12f9fad418c4079774d 100644
--- a/src/link/MachO/Object.zig
+++ b/src/link/MachO/Object.zig
@@ -580,7 +580,7 @@ pub fn parseDwarfInfo(self: Object) error{Overflow}!dwarf.DwarfInfo {
         .debug_info = &[0]u8{},
         .debug_abbrev = &[0]u8{},
         .debug_str = &[0]u8{},
-        .debug_str_offsets = null,
+        .debug_str_offsets = &[0]u8{},
         .debug_line = &[0]u8{},
         .debug_line_str = &[0]u8{},
         .debug_ranges = &[0]u8{},
@@ -600,6 +600,8 @@ pub fn parseDwarfInfo(self: Object) error{Overflow}!dwarf.DwarfInfo {
                 di.debug_abbrev = try self.getSectionContents(sect);
             } else if (mem.eql(u8, sectname, "__debug_str")) {
                 di.debug_str = try self.getSectionContents(sect);
+            } else if (mem.eql(u8, sectname, "__debug_str_offsets")) {
+                di.debug_str_offsets = try self.getSectionContents(sect);
             } else if (mem.eql(u8, sectname, "__debug_line")) {
                 di.debug_line = try self.getSectionContents(sect);
             } else if (mem.eql(u8, sectname, "__debug_line_str")) {
-- 
2.54.0


From f907f742823f277bf346b06a693e16074f9302f9 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Tue, 23 Aug 2022 10:29:09 +0200
Subject: [PATCH 234/290] coff: fix compile errors in std.debug

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

diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 39dcfe72a64e81e3014c93b5ed41d9a3aa5fdd4f..201545c18db2d6528aa7283b5a9a053e0587e4a6 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -840,19 +840,30 @@ fn readCoffDebugInfo(allocator: mem.Allocator, coff_file: File) !ModuleDebugInfo
             const debug_info_data = di.coff.getSectionDataAlloc(".debug_info", allocator) catch null;
             const debug_abbrev_data = di.coff.getSectionDataAlloc(".debug_abbrev", allocator) catch null;
             const debug_str_data = di.coff.getSectionDataAlloc(".debug_str", allocator) catch null;
+            const debug_str_offsets = di.coff.getSectionDataAlloc(".debug_str_offsets", allocator) catch null;
             const debug_line_data = di.coff.getSectionDataAlloc(".debug_line", allocator) catch null;
             const debug_line_str_data = di.coff.getSectionDataAlloc(".debug_line_str", allocator) catch null;
-            const debug_ranges_data = di.coff.getSectionDataAlloc(".debug_ranges", allocator) catch null;
+            const debug_ranges = di.coff.getSectionDataAlloc(".debug_ranges", allocator) catch null;
+            const debug_loclists = di.coff.getSectionDataAlloc(".debug_loclists", allocator) catch null;
+            const debug_rnglists = di.coff.getSectionDataAlloc(".debug_rnglists", allocator) catch null;
+            const debug_addr = di.coff.getSectionDataAlloc(".debug_addr", allocator) catch null;
+            const debug_names = di.coff.getSectionDataAlloc(".debug_names", allocator) catch null;
+            const debug_frame = di.coff.getSectionDataAlloc(".debug_frame", allocator) catch null;
 
             var dwarf = DW.DwarfInfo{
                 .endian = native_endian,
                 .debug_info = debug_info_data orelse return error.MissingDebugInfo,
                 .debug_abbrev = debug_abbrev_data orelse return error.MissingDebugInfo,
                 .debug_str = debug_str_data orelse return error.MissingDebugInfo,
-                .debug_str_offsets = null,
+                .debug_str_offsets = debug_str_offsets,
                 .debug_line = debug_line_data orelse return error.MissingDebugInfo,
                 .debug_line_str = debug_line_str_data,
-                .debug_ranges = debug_ranges_data,
+                .debug_ranges = debug_ranges,
+                .debug_loclists = debug_loclists,
+                .debug_rnglists = debug_rnglists,
+                .debug_addr = debug_addr,
+                .debug_names = debug_names,
+                .debug_frame = debug_frame,
             };
             try DW.openDwarfDebugInfo(&dwarf, allocator);
             di.debug_data = PdbOrDwarf{ .dwarf = dwarf };
-- 
2.54.0


From abfe21a4fee5380eb2068be0d2b64422cbc3b9fe Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Tue, 23 Aug 2022 22:43:19 +0200
Subject: [PATCH 235/290] skip failing f80 behavior tests on Windows

---
 test/behavior/math.zig   | 7 +++++++
 test/behavior/muladd.zig | 2 ++
 2 files changed, 9 insertions(+)

diff --git a/test/behavior/math.zig b/test/behavior/math.zig
index d3f9676f11523c2a407d73cea935f47f242157a6..804a061da22d3b1c0dcfc843e206940d278b0800 100644
--- a/test/behavior/math.zig
+++ b/test/behavior/math.zig
@@ -1167,6 +1167,7 @@ test "remainder division" {
     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_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
 
     comptime try remdiv(f16);
     comptime try remdiv(f32);
@@ -1198,6 +1199,7 @@ test "float remainder division using @rem" {
     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_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
 
     comptime try frem(f16);
     comptime try frem(f32);
@@ -1240,6 +1242,7 @@ test "float modulo division using @mod" {
     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_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
 
     comptime try fmod(f16);
     comptime try fmod(f32);
@@ -1367,6 +1370,7 @@ test "@floor f80" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
 
     try testFloor(f80, 12.0);
     comptime try testFloor(f80, 12.0);
@@ -1415,6 +1419,7 @@ test "@ceil f80" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
 
     try testCeil(f80, 12.0);
     comptime try testCeil(f80, 12.0);
@@ -1463,6 +1468,7 @@ test "@trunc f80" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
 
     try testTrunc(f80, 12.0);
     comptime try testTrunc(f80, 12.0);
@@ -1525,6 +1531,7 @@ test "@round f80" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     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_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
 
     try testRound(f80, 12.0);
     comptime try testRound(f80, 12.0);
diff --git a/test/behavior/muladd.zig b/test/behavior/muladd.zig
index 01ef8c7d297e5149c21fa2aee4b6cf90960afe3c..861b786a56c6469e2e836d16d8d296faa540db60 100644
--- a/test/behavior/muladd.zig
+++ b/test/behavior/muladd.zig
@@ -51,6 +51,7 @@ test "@mulAdd f80" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
 
     comptime try testMulAdd80();
     try testMulAdd80();
@@ -182,6 +183,7 @@ test "vector f80" {
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     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_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
 
     comptime try vector80();
     try vector80();
-- 
2.54.0


From d852894dcf6143ff76575245f092d9e26b0e8fa6 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Tue, 23 Aug 2022 22:59:11 +0200
Subject: [PATCH 236/290] skip failing compiler-rt divxf3 tests on Windows

---
 lib/compiler_rt/divxf3.zig | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/compiler_rt/divxf3.zig b/lib/compiler_rt/divxf3.zig
index b8d27a6da01603957aede8f4454ddd05a6821397..2282c2129902b147ea3cb6b2094560b325785156 100644
--- a/lib/compiler_rt/divxf3.zig
+++ b/lib/compiler_rt/divxf3.zig
@@ -206,5 +206,7 @@ pub fn __divxf3(a: f80, b: f80) callconv(.C) f80 {
 }
 
 test {
+    if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12603
+
     _ = @import("divxf3_test.zig");
 }
-- 
2.54.0


From 0f01e812ff054ea83661272bf0a96af228f2ffe3 Mon Sep 17 00:00:00 2001
From: yyny <6576327+yyny@users.noreply.github.com>
Date: Wed, 24 Aug 2022 02:44:42 +0200
Subject: [PATCH 237/290] std.os: add INVALID_SOCKET (#12081)

This constant returns an invalid `socket_t` that can be used as a sentinel
value.
---
 lib/std/os.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/std/os.zig b/lib/std/os.zig
index 24b438a53e65aaa8ee25cef90796a2f8f778c8b1..5cc55518add0ce3ae5d4450018b10fafafada926 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -235,6 +235,7 @@ pub const RelativePathWasi = struct {
 };
 
 pub const socket_t = if (builtin.os.tag == .windows) windows.ws2_32.SOCKET else fd_t;
+pub const INVALID_SOCKET = if (builtin.os.tag == .windows) windows.ws2_32.INVALID_SOCKET else @as(socket_t, -1);
 
 /// See also `getenv`. Populated by startup code before main().
 /// TODO this is a footgun because the value will be undefined when using `zig build-lib`.
-- 
2.54.0


From 60722261fa465ecff559c9903e0855d538826ed4 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 23 Aug 2022 21:09:12 -0700
Subject: [PATCH 238/290] std.debug: DWARFv5 fixes

handle str_offsets_base and addr_base correctly.
handle data16
fix compilation on 32-bit hosts
remove stray debug print statement

closes #12120
---
 lib/std/debug.zig  |  23 ++---
 lib/std/dwarf.zig  | 219 +++++++++++++++++++++++----------------------
 src/link/MachO.zig |   4 +-
 3 files changed, 126 insertions(+), 120 deletions(-)

diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 201545c18db2d6528aa7283b5a9a053e0587e4a6..a7f0b202cbd3d869a953496f04e238a16022a985 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -837,12 +837,12 @@ fn readCoffDebugInfo(allocator: mem.Allocator, coff_file: File) !ModuleDebugInfo
             // This coff file has embedded DWARF debug info
             _ = sec;
             // TODO: free the section data slices
-            const debug_info_data = di.coff.getSectionDataAlloc(".debug_info", allocator) catch null;
-            const debug_abbrev_data = di.coff.getSectionDataAlloc(".debug_abbrev", allocator) catch null;
-            const debug_str_data = di.coff.getSectionDataAlloc(".debug_str", allocator) catch null;
+            const debug_info = di.coff.getSectionDataAlloc(".debug_info", allocator) catch null;
+            const debug_abbrev = di.coff.getSectionDataAlloc(".debug_abbrev", allocator) catch null;
+            const debug_str = di.coff.getSectionDataAlloc(".debug_str", allocator) catch null;
             const debug_str_offsets = di.coff.getSectionDataAlloc(".debug_str_offsets", allocator) catch null;
-            const debug_line_data = di.coff.getSectionDataAlloc(".debug_line", allocator) catch null;
-            const debug_line_str_data = di.coff.getSectionDataAlloc(".debug_line_str", allocator) catch null;
+            const debug_line = di.coff.getSectionDataAlloc(".debug_line", allocator) catch null;
+            const debug_line_str = di.coff.getSectionDataAlloc(".debug_line_str", allocator) catch null;
             const debug_ranges = di.coff.getSectionDataAlloc(".debug_ranges", allocator) catch null;
             const debug_loclists = di.coff.getSectionDataAlloc(".debug_loclists", allocator) catch null;
             const debug_rnglists = di.coff.getSectionDataAlloc(".debug_rnglists", allocator) catch null;
@@ -852,12 +852,12 @@ fn readCoffDebugInfo(allocator: mem.Allocator, coff_file: File) !ModuleDebugInfo
 
             var dwarf = DW.DwarfInfo{
                 .endian = native_endian,
-                .debug_info = debug_info_data orelse return error.MissingDebugInfo,
-                .debug_abbrev = debug_abbrev_data orelse return error.MissingDebugInfo,
-                .debug_str = debug_str_data orelse return error.MissingDebugInfo,
+                .debug_info = debug_info orelse return error.MissingDebugInfo,
+                .debug_abbrev = debug_abbrev orelse return error.MissingDebugInfo,
+                .debug_str = debug_str orelse return error.MissingDebugInfo,
                 .debug_str_offsets = debug_str_offsets,
-                .debug_line = debug_line_data orelse return error.MissingDebugInfo,
-                .debug_line_str = debug_line_str_data,
+                .debug_line = debug_line orelse return error.MissingDebugInfo,
+                .debug_line_str = debug_line_str,
                 .debug_ranges = debug_ranges,
                 .debug_loclists = debug_loclists,
                 .debug_rnglists = debug_rnglists,
@@ -1663,6 +1663,7 @@ pub const ModuleDebugInfo = switch (native_os) {
                             o_file_di,
                             DW.AT.name,
                             o_file_di.debug_str,
+                            compile_unit.*,
                         ) catch |err| switch (err) {
                             error.MissingDebugInfo, error.InvalidDebugInfo => "???",
                         },
@@ -1784,7 +1785,7 @@ fn getSymbolFromDwarf(allocator: mem.Allocator, address: u64, di: *DW.DwarfInfo)
     if (nosuspend di.findCompileUnit(address)) |compile_unit| {
         return SymbolInfo{
             .symbol_name = nosuspend di.getSymbolName(address) orelse "???",
-            .compile_unit_name = compile_unit.die.getAttrString(di, DW.AT.name, di.debug_str) catch |err| switch (err) {
+            .compile_unit_name = compile_unit.die.getAttrString(di, DW.AT.name, di.debug_str, compile_unit.*) catch |err| switch (err) {
                 error.MissingDebugInfo, error.InvalidDebugInfo => "???",
             },
             .line_info = nosuspend di.getLineNumberInfo(allocator, compile_unit.*, address) catch |err| switch (err) {
diff --git a/lib/std/dwarf.zig b/lib/std/dwarf.zig
index 5ddc8cb3dc81bff89897a198e978390d0fa14cc5..c307cdb733a3f47b20715fc256afdcde45e9915d 100644
--- a/lib/std/dwarf.zig
+++ b/lib/std/dwarf.zig
@@ -168,6 +168,11 @@ const CompileUnit = struct {
     is_64: bool,
     die: *Die,
     pc_range: ?PcRange,
+
+    str_offsets_base: usize,
+    addr_base: usize,
+    rnglists_base: usize,
+    loclists_base: usize,
 };
 
 const AbbrevTable = std.ArrayList(AbbrevTableEntry);
@@ -205,7 +210,7 @@ const AbbrevAttr = struct {
 
 const FormValue = union(enum) {
     Address: u64,
-    AddrOffset: u64,
+    AddrOffset: usize,
     Block: []u8,
     Const: Constant,
     ExprLoc: []u8,
@@ -215,10 +220,11 @@ const FormValue = union(enum) {
     RefAddr: u64,
     String: []const u8,
     StrPtr: u64,
-    StrOffset: u64,
+    StrOffset: usize,
     LineStrPtr: u64,
     LocListOffset: u64,
     RangeListOffset: u64,
+    data16: [16]u8,
 
     fn getString(fv: FormValue, di: DwarfInfo) ![]const u8 {
         switch (fv) {
@@ -235,6 +241,14 @@ const FormValue = union(enum) {
                 const int = try c.asUnsignedLe();
                 return math.cast(U, int) orelse return badDwarf();
             },
+            .SecOffset => |x| return math.cast(U, x) orelse return badDwarf(),
+            else => return badDwarf(),
+        }
+    }
+
+    fn getData16(fv: FormValue) ![16]u8 {
+        switch (fv) {
+            .data16 => |d| return d,
             else => return badDwarf(),
         }
     }
@@ -274,42 +288,30 @@ const Die = struct {
         return null;
     }
 
-    fn getAttrAddr(self: *const Die, di: *DwarfInfo, id: u64) error{ InvalidDebugInfo, MissingDebugInfo }!u64 {
-        const form_value = self.getAttr(id) orelse return missingDwarf();
+    fn getAttrAddr(
+        self: *const Die,
+        di: *DwarfInfo,
+        id: u64,
+        compile_unit: CompileUnit,
+    ) error{ InvalidDebugInfo, MissingDebugInfo }!u64 {
+        const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
         return switch (form_value.*) {
             FormValue.Address => |value| value,
             FormValue.AddrOffset => |index| {
                 const debug_addr = di.debug_addr orelse return badDwarf();
-                if (debug_addr.len < 8) return badDwarf();
-                const first_32_bits = mem.readInt(u32, debug_addr[0..4], di.endian);
-                const is_64 = first_32_bits == 0xffffffff;
-                var off: usize = undefined;
-                const length: u64 = l: {
-                    if (is_64) {
-                        if (debug_addr.len < 16) return badDwarf();
-                        off = 12;
-                        break :l mem.readInt(u64, debug_addr[4..12], di.endian);
-                    } else {
-                        if (debug_addr.len < 8) return badDwarf();
-                        if (first_32_bits >= 0xfffffff0) return badDwarf();
-                        off = 4;
-                        break :l first_32_bits;
-                    }
-                };
-                if (index > length) return badDwarf();
+                // addr_base points to the first item after the header, however we
+                // need to read the header to know the size of each item. Empirically,
+                // it may disagree with is_64 on the compile unit.
+                // The header is 8 or 12 bytes depending on is_64.
+                if (compile_unit.addr_base < 8) return badDwarf();
 
-                const version = mem.readInt(u16, debug_addr[off..][0..2], di.endian);
-                off += 2;
-                if (version < 5) return badDwarf();
+                const version = mem.readInt(u16, debug_addr[compile_unit.addr_base - 4 ..][0..2], di.endian);
+                if (version != 5) return badDwarf();
 
-                const addr_size = debug_addr[off];
-                off += 1;
+                const addr_size = debug_addr[compile_unit.addr_base - 2];
+                const seg_size = debug_addr[compile_unit.addr_base - 1];
 
-                const seg_size = debug_addr[off];
-                off += 1;
-
-                const base_offset = self.getAttrSecOffset(AT.addr_base) catch off;
-                const byte_offset = base_offset + (addr_size + seg_size) * index;
+                const byte_offset = compile_unit.addr_base + (addr_size + seg_size) * index;
                 if (byte_offset + addr_size > debug_addr.len) return badDwarf();
                 switch (addr_size) {
                     1 => return debug_addr[byte_offset],
@@ -324,16 +326,12 @@ const Die = struct {
     }
 
     fn getAttrSecOffset(self: *const Die, id: u64) !u64 {
-        const form_value = self.getAttr(id) orelse return missingDwarf();
-        return switch (form_value.*) {
-            FormValue.Const => |value| value.asUnsignedLe(),
-            FormValue.SecOffset => |value| value,
-            else => error.InvalidDebugInfo,
-        };
+        const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
+        return form_value.getUInt(u64);
     }
 
     fn getAttrUnsignedLe(self: *const Die, id: u64) !u64 {
-        const form_value = self.getAttr(id) orelse return missingDwarf();
+        const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
         return switch (form_value.*) {
             FormValue.Const => |value| value.asUnsignedLe(),
             else => error.InvalidDebugInfo,
@@ -341,51 +339,35 @@ const Die = struct {
     }
 
     fn getAttrRef(self: *const Die, id: u64) !u64 {
-        const form_value = self.getAttr(id) orelse return missingDwarf();
+        const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
         return switch (form_value.*) {
             FormValue.Ref => |value| value,
             else => error.InvalidDebugInfo,
         };
     }
 
-    pub fn getAttrString(self: *const Die, di: *DwarfInfo, id: u64, opt_str: ?[]const u8) error{ InvalidDebugInfo, MissingDebugInfo }![]const u8 {
-        const form_value = self.getAttr(id) orelse return missingDwarf();
+    pub fn getAttrString(
+        self: *const Die,
+        di: *DwarfInfo,
+        id: u64,
+        opt_str: ?[]const u8,
+        compile_unit: CompileUnit,
+    ) error{ InvalidDebugInfo, MissingDebugInfo }![]const u8 {
+        const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
         switch (form_value.*) {
             FormValue.String => |value| return value,
             FormValue.StrPtr => |offset| return di.getString(offset),
             FormValue.StrOffset => |index| {
                 const debug_str_offsets = di.debug_str_offsets orelse return badDwarf();
-                if (debug_str_offsets.len < 8) return badDwarf();
-                const first_32_bits = mem.readInt(u32, debug_str_offsets[0..4], di.endian);
-                const is_64 = first_32_bits == 0xffffffff;
-                var off: usize = undefined;
-                const length: u64 = l: {
-                    if (is_64) {
-                        if (debug_str_offsets.len < 16) return badDwarf();
-                        off = 12;
-                        break :l mem.readInt(u64, debug_str_offsets[4..12], di.endian);
-                    } else {
-                        if (debug_str_offsets.len < 8) return badDwarf();
-                        if (first_32_bits >= 0xfffffff0) return badDwarf();
-                        off = 4;
-                        break :l first_32_bits;
-                    }
-                };
-                if (index > length) return badDwarf();
-
-                const version = mem.readInt(u16, debug_str_offsets[off..][0..2], di.endian);
-                off += 2;
-                if (version < 5) return badDwarf();
-
-                off += 2; // reserved
-
-                const base_offset = self.getAttrSecOffset(AT.str_offsets_base) catch off;
-                if (is_64) {
-                    const byte_offset = base_offset + 8 * index;
+                if (compile_unit.str_offsets_base == 0) return badDwarf();
+                if (compile_unit.is_64) {
+                    const byte_offset = compile_unit.str_offsets_base + 8 * index;
+                    if (byte_offset + 8 > debug_str_offsets.len) return badDwarf();
                     const offset = mem.readInt(u64, debug_str_offsets[byte_offset..][0..8], di.endian);
                     return getStringGeneric(opt_str, offset);
                 } else {
-                    const byte_offset = base_offset + 4 * index;
+                    const byte_offset = compile_unit.str_offsets_base + 4 * index;
+                    if (byte_offset + 4 > debug_str_offsets.len) return badDwarf();
                     const offset = mem.readInt(u32, debug_str_offsets[byte_offset..][0..4], di.endian);
                     return getStringGeneric(opt_str, offset);
                 }
@@ -401,7 +383,7 @@ const FileEntry = struct {
     dir_index: u32 = 0,
     mtime: u64 = 0,
     size: u64 = 0,
-    md5: u128 = 0,
+    md5: [16]u8 = [1]u8{0} ** 16,
 };
 
 const LineNumberProgram = struct {
@@ -606,7 +588,7 @@ fn parseFormValue(allocator: mem.Allocator, in_stream: anytype, form_id: u64, en
         FORM.addrx2 => return FormValue{ .AddrOffset = try in_stream.readInt(u16, endian) },
         FORM.addrx3 => return FormValue{ .AddrOffset = try in_stream.readInt(u24, endian) },
         FORM.addrx4 => return FormValue{ .AddrOffset = try in_stream.readInt(u32, endian) },
-        FORM.addrx => return FormValue{ .AddrOffset = try nosuspend leb.readULEB128(u64, in_stream) },
+        FORM.addrx => return FormValue{ .AddrOffset = try nosuspend leb.readULEB128(usize, in_stream) },
 
         FORM.block1 => parseFormValueBlock(allocator, in_stream, endian, 1),
         FORM.block2 => parseFormValueBlock(allocator, in_stream, endian, 2),
@@ -619,6 +601,11 @@ fn parseFormValue(allocator: mem.Allocator, in_stream: anytype, form_id: u64, en
         FORM.data2 => parseFormValueConstant(in_stream, false, endian, 2),
         FORM.data4 => parseFormValueConstant(in_stream, false, endian, 4),
         FORM.data8 => parseFormValueConstant(in_stream, false, endian, 8),
+        FORM.data16 => {
+            var buf: [16]u8 = undefined;
+            if ((try nosuspend in_stream.readAll(&buf)) < 16) return error.EndOfFile;
+            return FormValue{ .data16 = buf };
+        },
         FORM.udata, FORM.sdata => {
             const signed = form_id == FORM.sdata;
             return parseFormValueConstant(in_stream, signed, endian, -1);
@@ -647,7 +634,7 @@ fn parseFormValue(allocator: mem.Allocator, in_stream: anytype, form_id: u64, en
         FORM.strx2 => return FormValue{ .StrOffset = try in_stream.readInt(u16, endian) },
         FORM.strx3 => return FormValue{ .StrOffset = try in_stream.readInt(u24, endian) },
         FORM.strx4 => return FormValue{ .StrOffset = try in_stream.readInt(u32, endian) },
-        FORM.strx => return FormValue{ .StrOffset = try nosuspend leb.readULEB128(u64, in_stream) },
+        FORM.strx => return FormValue{ .StrOffset = try nosuspend leb.readULEB128(usize, in_stream) },
         FORM.line_strp => FormValue{ .LineStrPtr = try readAddress(in_stream, endian, is_64) },
         FORM.indirect => {
             const child_form_id = try nosuspend leb.readULEB128(u64, in_stream);
@@ -663,7 +650,7 @@ fn parseFormValue(allocator: mem.Allocator, in_stream: anytype, form_id: u64, en
         FORM.loclistx => return FormValue{ .LocListOffset = try nosuspend leb.readULEB128(u64, in_stream) },
         FORM.rnglistx => return FormValue{ .RangeListOffset = try nosuspend leb.readULEB128(u64, in_stream) },
         else => {
-            std.debug.print("unrecognized form id: {x}\n", .{form_id});
+            //std.debug.print("unrecognized form id: {x}\n", .{form_id});
             return badDwarf();
         },
     };
@@ -771,11 +758,26 @@ pub const DwarfInfo = struct {
 
             const next_unit_pos = this_unit_offset + next_offset;
 
+            var compile_unit: CompileUnit = undefined;
+
             while ((try seekable.getPos()) < next_unit_pos) {
-                const die_obj = (try di.parseDie(arena, in, abbrev_table, is_64)) orelse continue;
+                var die_obj = (try di.parseDie(arena, in, abbrev_table, is_64)) orelse continue;
                 const after_die_offset = try seekable.getPos();
 
                 switch (die_obj.tag_id) {
+                    TAG.compile_unit => {
+                        compile_unit = .{
+                            .version = version,
+                            .is_64 = is_64,
+                            .die = &die_obj,
+                            .pc_range = null,
+
+                            .str_offsets_base = if (die_obj.getAttr(AT.str_offsets_base)) |fv| try fv.getUInt(usize) else 0,
+                            .addr_base = if (die_obj.getAttr(AT.addr_base)) |fv| try fv.getUInt(usize) else 0,
+                            .rnglists_base = if (die_obj.getAttr(AT.rnglists_base)) |fv| try fv.getUInt(usize) else 0,
+                            .loclists_base = if (die_obj.getAttr(AT.loclists_base)) |fv| try fv.getUInt(usize) else 0,
+                        };
+                    },
                     TAG.subprogram, TAG.inlined_subroutine, TAG.subroutine, TAG.entry_point => {
                         const fn_name = x: {
                             var depth: i32 = 3;
@@ -783,7 +785,7 @@ pub const DwarfInfo = struct {
                             // Prevent endless loops
                             while (depth > 0) : (depth -= 1) {
                                 if (this_die_obj.getAttr(AT.name)) |_| {
-                                    const name = try this_die_obj.getAttrString(di, AT.name, di.debug_str);
+                                    const name = try this_die_obj.getAttrString(di, AT.name, di.debug_str, compile_unit);
                                     break :x try allocator.dupe(u8, name);
                                 } else if (this_die_obj.getAttr(AT.abstract_origin)) |_| {
                                     // Follow the DIE it points to and repeat
@@ -816,7 +818,7 @@ pub const DwarfInfo = struct {
                         };
 
                         const pc_range = x: {
-                            if (die_obj.getAttrAddr(di, AT.low_pc)) |low_pc| {
+                            if (die_obj.getAttrAddr(di, AT.low_pc, compile_unit)) |low_pc| {
                                 if (die_obj.getAttr(AT.high_pc)) |high_pc_value| {
                                     const pc_end = switch (high_pc_value.*) {
                                         FormValue.Address => |value| value,
@@ -873,23 +875,20 @@ pub const DwarfInfo = struct {
 
             var address_size: u8 = undefined;
             var debug_abbrev_offset: u64 = undefined;
-            switch (version) {
-                5 => {
-                    const unit_type = try in.readInt(u8, di.endian);
-                    if (unit_type != UT.compile) return badDwarf();
-                    address_size = try in.readByte();
-                    debug_abbrev_offset = if (is_64)
-                        try in.readInt(u64, di.endian)
-                    else
-                        try in.readInt(u32, di.endian);
-                },
-                else => {
-                    debug_abbrev_offset = if (is_64)
-                        try in.readInt(u64, di.endian)
-                    else
-                        try in.readInt(u32, di.endian);
-                    address_size = try in.readByte();
-                },
+            if (version >= 5) {
+                const unit_type = try in.readInt(u8, di.endian);
+                if (unit_type != UT.compile) return badDwarf();
+                address_size = try in.readByte();
+                debug_abbrev_offset = if (is_64)
+                    try in.readInt(u64, di.endian)
+                else
+                    try in.readInt(u32, di.endian);
+            } else {
+                debug_abbrev_offset = if (is_64)
+                    try in.readInt(u64, di.endian)
+                else
+                    try in.readInt(u32, di.endian);
+                address_size = try in.readByte();
             }
             if (address_size != @sizeOf(usize)) return badDwarf();
 
@@ -905,8 +904,19 @@ pub const DwarfInfo = struct {
 
             if (compile_unit_die.tag_id != TAG.compile_unit) return badDwarf();
 
-            const pc_range = x: {
-                if (compile_unit_die.getAttrAddr(di, AT.low_pc)) |low_pc| {
+            var compile_unit: CompileUnit = .{
+                .version = version,
+                .is_64 = is_64,
+                .pc_range = null,
+                .die = compile_unit_die,
+                .str_offsets_base = if (compile_unit_die.getAttr(AT.str_offsets_base)) |fv| try fv.getUInt(usize) else 0,
+                .addr_base = if (compile_unit_die.getAttr(AT.addr_base)) |fv| try fv.getUInt(usize) else 0,
+                .rnglists_base = if (compile_unit_die.getAttr(AT.rnglists_base)) |fv| try fv.getUInt(usize) else 0,
+                .loclists_base = if (compile_unit_die.getAttr(AT.loclists_base)) |fv| try fv.getUInt(usize) else 0,
+            };
+
+            compile_unit.pc_range = x: {
+                if (compile_unit_die.getAttrAddr(di, AT.low_pc, compile_unit)) |low_pc| {
                     if (compile_unit_die.getAttr(AT.high_pc)) |high_pc_value| {
                         const pc_end = switch (high_pc_value.*) {
                             FormValue.Address => |value| value,
@@ -929,12 +939,7 @@ pub const DwarfInfo = struct {
                 }
             };
 
-            try di.compile_unit_list.append(allocator, CompileUnit{
-                .version = version,
-                .is_64 = is_64,
-                .pc_range = pc_range,
-                .die = compile_unit_die,
-            });
+            try di.compile_unit_list.append(allocator, compile_unit);
 
             this_unit_offset += next_offset;
         }
@@ -955,7 +960,7 @@ pub const DwarfInfo = struct {
                     // specified by DW_AT.low_pc or to some other value encoded
                     // in the list itself.
                     // If no starting value is specified use zero.
-                    var base_address = compile_unit.die.getAttrAddr(di, AT.low_pc) catch |err| switch (err) {
+                    var base_address = compile_unit.die.getAttrAddr(di, AT.low_pc, compile_unit.*) catch |err| switch (err) {
                         error.MissingDebugInfo => @as(u64, 0), // TODO https://github.com/ziglang/zig/issues/11135
                         else => return err,
                     };
@@ -1087,7 +1092,7 @@ pub const DwarfInfo = struct {
         const in = &stream.reader();
         const seekable = &stream.seekableStream();
 
-        const compile_unit_cwd = try compile_unit.die.getAttrString(di, AT.comp_dir, di.debug_line_str);
+        const compile_unit_cwd = try compile_unit.die.getAttrString(di, AT.comp_dir, di.debug_line_str, compile_unit);
         const line_info_offset = try compile_unit.die.getAttrSecOffset(AT.stmt_list);
 
         try seekable.seekTo(line_info_offset);
@@ -1202,7 +1207,7 @@ pub const DwarfInfo = struct {
                                 LNCT.directory_index => e.dir_index = try form_value.getUInt(u32),
                                 LNCT.timestamp => e.mtime = try form_value.getUInt(u64),
                                 LNCT.size => e.size = try form_value.getUInt(u64),
-                                LNCT.MD5 => e.md5 = try form_value.getUInt(u128),
+                                LNCT.MD5 => e.md5 = try form_value.getData16(),
                                 else => continue,
                             }
                         }
@@ -1240,7 +1245,7 @@ pub const DwarfInfo = struct {
                             LNCT.directory_index => e.dir_index = try form_value.getUInt(u32),
                             LNCT.timestamp => e.mtime = try form_value.getUInt(u64),
                             LNCT.size => e.size = try form_value.getUInt(u64),
-                            LNCT.MD5 => e.md5 = try form_value.getUInt(u128),
+                            LNCT.MD5 => e.md5 = try form_value.getData16(),
                             else => continue,
                         }
                     }
@@ -1370,12 +1375,12 @@ pub fn openDwarfDebugInfo(di: *DwarfInfo, allocator: mem.Allocator) !void {
 
 /// This function is to make it handy to comment out the return and make it
 /// into a crash when working on this file.
-inline fn badDwarf() error{InvalidDebugInfo} {
+fn badDwarf() error{InvalidDebugInfo} {
     //std.os.abort(); // can be handy to uncomment when working on this file
     return error.InvalidDebugInfo;
 }
 
-inline fn missingDwarf() error{MissingDebugInfo} {
+fn missingDwarf() error{MissingDebugInfo} {
     //std.os.abort(); // can be handy to uncomment when working on this file
     return error.MissingDebugInfo;
 }
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 91eaedc7349038d485d53f850b2209cd64f45b9f..764e4e71b2d38db4ac965f6835c0d263e7cbac45 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -5862,8 +5862,8 @@ pub fn generateSymbolStabs(
         else => |e| return e,
     };
 
-    const tu_name = try compile_unit.die.getAttrString(&debug_info, dwarf.AT.name, debug_info.debug_str);
-    const tu_comp_dir = try compile_unit.die.getAttrString(&debug_info, dwarf.AT.comp_dir, debug_info.debug_str);
+    const tu_name = try compile_unit.die.getAttrString(&debug_info, dwarf.AT.name, debug_info.debug_str, compile_unit.*);
+    const tu_comp_dir = try compile_unit.die.getAttrString(&debug_info, dwarf.AT.comp_dir, debug_info.debug_str, compile_unit.*);
 
     // Open scope
     try locals.ensureUnusedCapacity(3);
-- 
2.54.0


From a31b449b55c32eba1cb61a48753a6fc98696c98f Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 23 Aug 2022 21:24:03 -0700
Subject: [PATCH 239/290] make LLVM and Clang emit DWARF 4 instead of 5

This reverts 6d679eb2bcbe76e389c02e0bb4d4c4feb2847783 and additionally
changes the command line parameters passed to Clang to match.

Clang 14 defaults to DWARFv5 which is an interesting choice. v5 has been
out for 5 years and yet Valgrind does not support it, and apparently
neither does either GDB or LLD, I haven't determined which, but I wasn't
able to use GDB to debug my LLVM-emitted dwarf 5 zig code that was linked
with LLD.

A couple years ago when I was working on the self-hosted ELF linker, I
emitted DWARFv5 but then downgraded to v4 when I realized that third
party tools were stuck in the past. Years later, they still are.

Hopefully, Clang 14's bold move will inspire third party tools to get
their shit together, however, in the meantime, everything's broken, so
we're passing `-gdwarf-4` to clang and instructing LLVM to emit DWARFv4.

Note that Zig's std.debug code *does* support DWARFv5 already as of a
previous commit that I made today.
---
 src/Compilation.zig | 4 ++--
 src/zig_llvm.cpp    | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 0914685c77f6fa3d3905ef56e5519789f4f8c236..1bc9719e1b1c0bb3bdf1349bd578c73c6b2a910e 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -4085,10 +4085,10 @@ pub fn addCCArgs(
             }
 
             if (!comp.bin_file.options.strip) {
-                try argv.append("-g");
                 switch (target.ofmt) {
                     .coff => try argv.append("-gcodeview"),
-                    else => {},
+                    .elf, .macho => try argv.append("-gdwarf-4"),
+                    else => try argv.append("-g"),
                 }
             }
 
diff --git a/src/zig_llvm.cpp b/src/zig_llvm.cpp
index e03d26d7c42d2bd456378b7df66bb2aa89d73a2a..52c202fdedac147ed23adba1c4a81dcfaf0d0f03 100644
--- a/src/zig_llvm.cpp
+++ b/src/zig_llvm.cpp
@@ -1130,7 +1130,7 @@ void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type,
 
 void ZigLLVMAddModuleDebugInfoFlag(LLVMModuleRef module) {
     unwrap(module)->addModuleFlag(Module::Warning, "Debug Info Version", DEBUG_METADATA_VERSION);
-    unwrap(module)->addModuleFlag(Module::Warning, "Dwarf Version", 5);
+    unwrap(module)->addModuleFlag(Module::Warning, "Dwarf Version", 4);
 }
 
 void ZigLLVMAddModuleCodeViewFlag(LLVMModuleRef module) {
-- 
2.54.0


From 5db80a051fea684e1d28fadb66f04932b090521c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 23 Aug 2022 21:30:23 -0700
Subject: [PATCH 240/290] Revert "std.os: add INVALID_SOCKET (#12081)"

This reverts commit 0f01e812ff054ea83661272bf0a96af228f2ffe3.

This does not belong in `std.posix`, and it is already provided at
`std.os.windows.ws2_32.INVALID_SOCKET`.

See related issue #5019.
---
 lib/std/os.zig | 1 -
 1 file changed, 1 deletion(-)

diff --git a/lib/std/os.zig b/lib/std/os.zig
index 5cc55518add0ce3ae5d4450018b10fafafada926..24b438a53e65aaa8ee25cef90796a2f8f778c8b1 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -235,7 +235,6 @@ pub const RelativePathWasi = struct {
 };
 
 pub const socket_t = if (builtin.os.tag == .windows) windows.ws2_32.SOCKET else fd_t;
-pub const INVALID_SOCKET = if (builtin.os.tag == .windows) windows.ws2_32.INVALID_SOCKET else @as(socket_t, -1);
 
 /// See also `getenv`. Populated by startup code before main().
 /// TODO this is a footgun because the value will be undefined when using `zig build-lib`.
-- 
2.54.0


From 5696cc8ab65370e3c8d63a7d26fd5346db9cc25f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20=22xq=22=20Quei=C3=9Fner?= <xq@random-projects.net>
Date: Wed, 24 Aug 2022 09:08:30 +0200
Subject: [PATCH 241/290] Adds std.meta.FnPtr for easier stage1/stage2
 compatibility

---
 lib/std/meta.zig | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/lib/std/meta.zig b/lib/std/meta.zig
index d5006bf81fae523f4f7cbaaca70887d5613eefa9..937b1998ff1b5a2b8effa66d9bd5837ba0d10714 100644
--- a/lib/std/meta.zig
+++ b/lib/std/meta.zig
@@ -1149,3 +1149,27 @@ test "isError" {
     try std.testing.expect(isError(math.absInt(@as(i8, -128))));
     try std.testing.expect(!isError(math.absInt(@as(i8, -127))));
 }
+
+/// This function returns a function pointer for a given function signature.
+/// It's a helper to make code compatible to both stage1 and stage2.
+///
+/// **WARNING:** This function is deprecated and will be removed together with stage1.
+pub fn FnPtr(comptime Fn: type) type {
+    return if (@import("builtin").zig_backend != .stage1)
+        *const Fn
+    else
+        Fn;
+}
+
+test "FnPtr" {
+    var func: FnPtr(fn () i64) = undefined;
+
+    // verify that we can perform runtime exchange
+    // and not have a function body in stage2:
+
+    func = std.time.timestamp;
+    _ = func();
+
+    func = std.time.milliTimestamp;
+    _ = func();
+}
-- 
2.54.0


From 38215ccc3e7bd4c79e70731c6d50556356c76c39 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 24 Aug 2022 15:04:31 +0300
Subject: [PATCH 242/290] stage2: handle `int_u64` in `elemValueAdvanced`

Closes #12599
---
 src/value.zig | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/value.zig b/src/value.zig
index 9909cab5ce535dcbcf73078e3a5fbb2932e2d9a5..4e9ea882e9d9596504fd5deb9d4b15fb9747186c 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -2689,6 +2689,12 @@ pub const Value = extern union {
             // to have only one possible value itself.
             .the_only_possible_value => return val,
 
+            // pointer to integer casted to pointer of array
+            .int_u64, .int_i64 => {
+                assert(index == 0);
+                return val;
+            },
+
             else => unreachable,
         }
     }
-- 
2.54.0


From d515d37934476365929401a0ba7e5639b09a648a Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 24 Aug 2022 15:26:49 +0300
Subject: [PATCH 243/290] AstGen: make root decls relative to beginning of file

Closes #12610
---
 src/AstGen.zig | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/AstGen.zig b/src/AstGen.zig
index 2001e6950a44ac183411a16192401d465c072032..db0ed47a04a756d2ef3a2ceadb70f40061c17569 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -4265,10 +4265,13 @@ fn structDeclInner(
     // are in scope, so that field types, alignments, and default value expressions
     // can refer to decls within the struct itself.
     astgen.advanceSourceCursorToNode(node);
+    // If `node == 0` then this is the root struct and all the declarations should
+    // be relative to the beginning of the file.
+    const decl_line = if (node == 0) 0 else astgen.source_line;
     var block_scope: GenZir = .{
         .parent = &namespace.base,
         .decl_node_index = node,
-        .decl_line = astgen.source_line,
+        .decl_line = decl_line,
         .astgen = astgen,
         .force_comptime = true,
         .in_defer = false,
@@ -11764,7 +11767,6 @@ fn scanDecls(astgen: *AstGen, namespace: *Scope.Namespace, members: []const Ast.
             }
         }
 
-        // const index_name = try astgen.identAsString(index_token);
         var s = namespace.parent;
         while (true) switch (s.tag) {
             .local_val => {
-- 
2.54.0


From 5fd5950c9277d5d0bb52e5968dc7d020dbcdd3d8 Mon Sep 17 00:00:00 2001
From: Will Hawkins <whh8b@obs.cr>
Date: Tue, 23 Aug 2022 01:31:14 -0400
Subject: [PATCH 244/290] Doc: Add hyphenation for top-level doc

---
 doc/langref.html.in | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 0c8f9b0861f326ce2f3e8cc73990676829478a2b..2de9db63d10e286c708a828c7563c20c3e9dd9d4 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -535,8 +535,8 @@ const Timestamp = struct {
       {#header_close#}
       {#header_open|Top-Level Doc Comments#}
       <p>User documentation that doesn't belong to whatever
-      immediately follows it, like container level documentation, goes
-      in top level doc comments. A top level doc comment is one that
+      immediately follows it, like container-level documentation, goes
+      in top-level doc comments. A top-level doc comment is one that
       begins with two slashes and an exclamation point:
       {#syntax#}//!{#endsyntax#}.</p>
       {#code_begin|syntax|tldoc_comments#}
-- 
2.54.0


From cd1833044ab7505bc101c85f59889bd3ea3fac80 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 24 Aug 2022 19:52:52 +0300
Subject: [PATCH 245/290] Sema: do not construct nested partial function types

Closes #12616
---
 src/Sema.zig                                     | 16 +++++++---------
 test/behavior/generics.zig                       | 15 +++++++++++++++
 .../comptime_parameter_not_declared_as_such.zig  |  7 ++++---
 3 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 4f558ccae48ba85108955cb0ebfaf680eec5adcb..846b6af3bdeed9d48da5fba4878ffa40afe9ab80 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -78,6 +78,9 @@ post_hoc_blocks: std.AutoHashMapUnmanaged(Air.Inst.Index, *LabeledBlock) = .{},
 err: ?*Module.ErrorMsg = null,
 /// True when analyzing a generic instantiation. Used to suppress some errors.
 is_generic_instantiation: bool = false,
+/// Set to true when analyzing a func type instruction so that nested generic
+/// function types will emit generic poison instead of a partial type.
+no_partial_func_ty: bool = false,
 
 const std = @import("std");
 const math = std.math;
@@ -7917,6 +7920,7 @@ fn funcCommon(
         if (cc_workaround == .Inline and is_noinline) {
             return sema.fail(block, cc_src, "'noinline' function cannot have callconv 'Inline'", .{});
         }
+        if (is_generic and sema.no_partial_func_ty) return error.GenericPoison;
 
         break :fn_ty try Type.Tag.function.create(sema.arena, .{
             .param_types = param_types,
@@ -8097,25 +8101,19 @@ fn zirParam(
             // Make sure any nested param instructions don't clobber our work.
             const prev_params = block.params;
             const prev_preallocated_new_func = sema.preallocated_new_func;
+            const prev_no_partial_func_type = sema.no_partial_func_ty;
             block.params = .{};
             sema.preallocated_new_func = null;
+            sema.no_partial_func_ty = true;
             defer {
                 block.params.deinit(sema.gpa);
                 block.params = prev_params;
                 sema.preallocated_new_func = prev_preallocated_new_func;
+                sema.no_partial_func_ty = prev_no_partial_func_type;
             }
 
             if (sema.resolveBody(block, body, inst)) |param_ty_inst| {
                 if (sema.analyzeAsType(block, src, param_ty_inst)) |param_ty| {
-                    if (param_ty.zigTypeTag() == .Fn and param_ty.fnInfo().is_generic) {
-                        // zirFunc will not emit error.GenericPoison to build a
-                        // partial type for generic functions but we still need to
-                        // detect if a function parameter is a generic function
-                        // to force the parent function to also be generic.
-                        if (!sema.inst_map.contains(inst)) {
-                            break :err error.GenericPoison;
-                        }
-                    }
                     break :param_ty param_ty;
                 } else |err| break :err err;
             } else |err| break :err err;
diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig
index d930fb7d27d1369544d166f22948705d19c2da64..ba4bca0c1a974c6c9843b7b214305a88af8fac5c 100644
--- a/test/behavior/generics.zig
+++ b/test/behavior/generics.zig
@@ -342,3 +342,18 @@ test "generic instantiation of tagged union with only one field" {
     try expect(S.foo(.{ .s = "a" }) == 1);
     try expect(S.foo(.{ .s = "ab" }) == 2);
 }
+
+test "nested generic function" {
+    const S = struct {
+        fn foo(comptime T: type, callback: *const fn (user_data: T) anyerror!void, data: T) anyerror!void {
+            try callback(data);
+        }
+        fn bar(a: u32) anyerror!void {
+            try expect(a == 123);
+        }
+
+        fn g(_: *const fn (anytype) void) void {}
+    };
+    try expect(@typeInfo(@TypeOf(S.g)).Fn.is_generic);
+    try S.foo(u32, S.bar, 123);
+}
diff --git a/test/cases/compile_errors/comptime_parameter_not_declared_as_such.zig b/test/cases/compile_errors/comptime_parameter_not_declared_as_such.zig
index e4d9eed07918af8f188f1fd03d0dcf72f20dab1d..008d14f2fccdf5a3a8362030af3b85e27040ec8a 100644
--- a/test/cases/compile_errors/comptime_parameter_not_declared_as_such.zig
+++ b/test/cases/compile_errors/comptime_parameter_not_declared_as_such.zig
@@ -1,5 +1,6 @@
 fn f(_: anytype) void {}
-fn g(h: *const fn (anytype) void) void {
+const T = *const fn (anytype) void;
+fn g(h: T) void {
     h({});
 }
 pub export fn entry() void {
@@ -19,5 +20,5 @@ pub export fn entry1() void {
 // backend=stage2
 // target=native
 //
-// :2:6: error: parameter of type '*const fn(anytype) void' must be declared comptime
-// :9:34: error: parameter of type 'comptime_int' must be declared comptime
+// :3:6: error: parameter of type '*const fn(anytype) void' must be declared comptime
+// :10:34: error: parameter of type 'comptime_int' must be declared comptime
-- 
2.54.0


From 1d0b729f28dd5f9341c4f4fe8ab4b25592e6834a Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 24 Aug 2022 20:29:13 +0300
Subject: [PATCH 246/290] Sema: fix crash on slice of non-array type

Closes #12621
---
 src/Sema.zig                                          | 3 ++-
 test/cases/compile_errors/slice_of_non_array_type.zig | 9 +++++++++
 2 files changed, 11 insertions(+), 1 deletion(-)
 create mode 100644 test/cases/compile_errors/slice_of_non_array_type.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index 846b6af3bdeed9d48da5fba4878ffa40afe9ab80..4e1b88548681a415959ad38bddb15173fe574b20 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -26139,11 +26139,12 @@ fn analyzeSlice(
     var array_ty = ptr_ptr_child_ty;
     var slice_ty = ptr_ptr_ty;
     var ptr_or_slice = ptr_ptr;
-    var elem_ty = ptr_ptr_child_ty.childType();
+    var elem_ty: Type = undefined;
     var ptr_sentinel: ?Value = null;
     switch (ptr_ptr_child_ty.zigTypeTag()) {
         .Array => {
             ptr_sentinel = ptr_ptr_child_ty.sentinel();
+            elem_ty = ptr_ptr_child_ty.childType();
         },
         .Pointer => switch (ptr_ptr_child_ty.ptrSize()) {
             .One => {
diff --git a/test/cases/compile_errors/slice_of_non_array_type.zig b/test/cases/compile_errors/slice_of_non_array_type.zig
new file mode 100644
index 0000000000000000000000000000000000000000..734b026038959ca69603fea0d49d1f45d7526eb2
--- /dev/null
+++ b/test/cases/compile_errors/slice_of_non_array_type.zig
@@ -0,0 +1,9 @@
+comptime {
+    _ = 1[0..];
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:10: error: slice of non-array type 'comptime_int'
-- 
2.54.0


From f49dff64c64baf8be48cc987b4ed61712afabc3d Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 24 Aug 2022 20:50:43 +0300
Subject: [PATCH 247/290] Sema: check one possible value earlier in
 `zirValidateArrayInit`

Closes #12566
---
 src/Sema.zig            | 26 +++++++++++++-------------
 test/behavior/tuple.zig | 11 +++++++++++
 2 files changed, 24 insertions(+), 13 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 4e1b88548681a415959ad38bddb15173fe574b20..22aa26f7375e6228d976ae17c70e551bec45cd33 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -4071,6 +4071,19 @@ fn zirValidateArrayInit(
 
         // Determine whether the value stored to this pointer is comptime-known.
 
+        if (array_ty.isTuple()) {
+            if (array_ty.structFieldValueComptime(i)) |opv| {
+                element_vals[i] = opv;
+                continue;
+            }
+        } else {
+            // Array has one possible value, so value is always comptime-known
+            if (opt_opv) |opv| {
+                element_vals[i] = opv;
+                continue;
+            }
+        }
+
         const elem_ptr_air_ref = sema.inst_map.get(elem_ptr).?;
         const elem_ptr_air_inst = Air.refToIndex(elem_ptr_air_ref).?;
         // Find the block index of the elem_ptr so that we can look at the next
@@ -4087,19 +4100,6 @@ fn zirValidateArrayInit(
         }
         first_block_index = @minimum(first_block_index, block_index);
 
-        if (array_ty.isTuple()) {
-            if (array_ty.structFieldValueComptime(i)) |opv| {
-                element_vals[i] = opv;
-                continue;
-            }
-        } else {
-            // Array has one possible value, so value is always comptime-known
-            if (opt_opv) |opv| {
-                element_vals[i] = opv;
-                continue;
-            }
-        }
-
         // If the next instructon is a store with a comptime operand, this element
         // is comptime.
         const next_air_inst = block.instructions.items[block_index + 1];
diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig
index 14297bd61c68cf2a23bd6eec2ec56966456c4a64..971e52a0b5e1ce2517cf1a582c8f384a412a8eef 100644
--- a/test/behavior/tuple.zig
+++ b/test/behavior/tuple.zig
@@ -290,3 +290,14 @@ test "coerce tuple to tuple" {
     };
     try S.foo(.{123});
 }
+
+test "tuple type with void field" {
+    if (builtin.zig_backend == .stage2_c) 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_x86_64) return error.SkipZigTest; // TODO
+
+    const T = std.meta.Tuple(&[_]type{void});
+    const x = T{{}};
+    try expect(@TypeOf(x[0]) == void);
+}
-- 
2.54.0


From 69a3c4e279238874cc74cf6acd5eb0426d5b65ee Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 24 Aug 2022 21:12:13 +0300
Subject: [PATCH 248/290] Sema: correctly reset inst_map for
 analyzeInlineCallArg

Closes #12622
---
 src/Sema.zig                                       |  3 +--
 .../cases/compile_errors/error_in_typeof_param.zig | 14 ++++++++++++++
 2 files changed, 15 insertions(+), 2 deletions(-)
 create mode 100644 test/cases/compile_errors/error_in_typeof_param.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index 22aa26f7375e6228d976ae17c70e551bec45cd33..4af9c80e02581e740d2b8333405bf2faf21c81d6 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -5941,10 +5941,9 @@ fn analyzeCall(
                 undefined,
             ) catch |err| switch (err) {
                 error.NeededSourceLocation => {
-                    sema.inst_map.clearRetainingCapacity();
+                    _ = sema.inst_map.remove(inst);
                     const decl = sema.mod.declPtr(block.src_decl);
                     child_block.src_decl = block.src_decl;
-                    arg_i = 0;
                     try sema.analyzeInlineCallArg(
                         block,
                         &child_block,
diff --git a/test/cases/compile_errors/error_in_typeof_param.zig b/test/cases/compile_errors/error_in_typeof_param.zig
new file mode 100644
index 0000000000000000000000000000000000000000..747cdf3df6612f6a923ba6d9cf77e6bedd708378
--- /dev/null
+++ b/test/cases/compile_errors/error_in_typeof_param.zig
@@ -0,0 +1,14 @@
+fn getSize() usize {
+    return 2;
+}
+pub fn expectEqual(expected: anytype, _: @TypeOf(expected)) !void {}
+pub export fn entry() void {
+    try expectEqual(2, getSize());
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :6:31: error: unable to resolve comptime value
+// :6:31: note: argument to parameter with comptime only type must be comptime known
-- 
2.54.0


From b466f8c81707dd44e905f1bae1b2d30aa026b84b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Felix=20=22xq=22=20Quei=C3=9Fner?= <xq@random-projects.net>
Date: Wed, 24 Aug 2022 14:42:52 +0200
Subject: [PATCH 249/290] Enables std.build.TranslateCStep to use stage1/stage2
 selectively. Unbreaks projects using stage1 and manual TranslateC

---
 lib/std/build/TranslateCStep.zig | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/lib/std/build/TranslateCStep.zig b/lib/std/build/TranslateCStep.zig
index 1f9bee463c7497cd93b3ff3ffd04806793c4576c..7d7f2a62a46bea7678f0cc13f24265cc5dff8e20 100644
--- a/lib/std/build/TranslateCStep.zig
+++ b/lib/std/build/TranslateCStep.zig
@@ -21,6 +21,7 @@ output_dir: ?[]const u8,
 out_basename: []const u8,
 target: CrossTarget = CrossTarget{},
 output_file: build.GeneratedFile,
+use_stage1: ?bool = null,
 
 pub fn create(builder: *Builder, source: build.FileSource) *TranslateCStep {
     const self = builder.allocator.create(TranslateCStep) catch unreachable;
@@ -91,6 +92,19 @@ fn make(step: *Step) !void {
         try argv_list.append("-D");
         try argv_list.append(c_macro);
     }
+    if (self.use_stage1) |stage1| {
+        if (stage1) {
+            try argv_list.append("-fstage1");
+        } else {
+            try argv_list.append("-fno-stage1");
+        }
+    } else if (self.builder.use_stage1) |stage1| {
+        if (stage1) {
+            try argv_list.append("-fstage1");
+        } else {
+            try argv_list.append("-fno-stage1");
+        }
+    }
 
     try argv_list.append(self.source.getPath(self.builder));
 
-- 
2.54.0


From 40c9b13608d89032c95d16aa33fc0003fb1e324d Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 24 Aug 2022 12:56:27 -0700
Subject: [PATCH 250/290] CI: x86_64-linux: update tarball

I thought this would be needed for dwarf 4 but I think it's not actually
needed. Anyway the tarball is fresher, might as well use it.
---
 ci/zinc/drone.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ci/zinc/drone.yml b/ci/zinc/drone.yml
index fc14ad3ec97f1a0432ae4889d565042412b33973..c7d8470268a68abf7652f5f0f9b52026cf51708b 100644
--- a/ci/zinc/drone.yml
+++ b/ci/zinc/drone.yml
@@ -10,12 +10,12 @@ workspace:
 
 steps:
 - name: test_stage3_debug
-  image: ci/debian-amd64:11.1-7
+  image: ci/debian-amd64:11.1-8
   commands:
   - ./ci/zinc/linux_test_stage3_debug.sh
 
 - name: test_stage3_release
-  image: ci/debian-amd64:11.1-7
+  image: ci/debian-amd64:11.1-8
   commands:
   - ./ci/zinc/linux_test_stage3_release.sh
 
@@ -28,7 +28,7 @@ steps:
       - master
     event:
       - push
-  image: ci/debian-amd64:11.1-7
+  image: ci/debian-amd64:11.1-8
   environment:
     AWS_ACCESS_KEY_ID:
       from_secret: AWS_ACCESS_KEY_ID
-- 
2.54.0


From 80b8294bccdbdf3bc0dd9248676e5c9718354125 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 24 Aug 2022 12:56:56 -0700
Subject: [PATCH 251/290] test-stack-traces: restore test coverage

reverts 1ce71c86bff351a4ade4321e188a13c9d3cff8b4
---
 test/stack_traces.zig | 2 --
 1 file changed, 2 deletions(-)

diff --git a/test/stack_traces.zig b/test/stack_traces.zig
index ed0dc9e235bbf94a902ea6cf89efd815fdd2328f..3a8682b5a5dcd740b37a7f2e513d0b035d8749cf 100644
--- a/test/stack_traces.zig
+++ b/test/stack_traces.zig
@@ -72,7 +72,6 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
         .ReleaseSafe = .{
             .exclude_os = .{
                 .windows, // TODO
-                .linux, // TODO
             },
             .expect = 
             \\error: TheSkyIsFalling
@@ -139,7 +138,6 @@ pub fn addCases(cases: *tests.StackTracesContext) void {
         .ReleaseSafe = .{
             .exclude_os = .{
                 .windows, // TODO
-                .linux, // TODO
             },
             .expect = 
             \\error: TheSkyIsFalling
-- 
2.54.0


From eb3f7d2f37cab1d3df7c4493b8239e802b83e521 Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Tue, 23 Aug 2022 23:43:16 +0200
Subject: [PATCH 252/290] compilation: avoid pointless caching

When the entire purpose of this compilation is to perform a single zig
cc operation we could "tail call" clang by doing an execve, and any use
of the caching system would actually be problematic since the user is
presumably doing their own caching by using dep file flags.

Fixes #12317
---
 src/Compilation.zig | 52 +++++++++++++++++++++++++++++++++++++++------
 1 file changed, 46 insertions(+), 6 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 1bc9719e1b1c0bb3bdf1349bd578c73c6b2a910e..1b424a400190ba6a8774f9bfbac3fec8022037bb 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -3753,22 +3753,64 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.P
         };
         const o_basename = try std.fmt.allocPrint(arena, "{s}{s}", .{ o_basename_noext, out_ext });
 
+        try argv.appendSlice(&[_][]const u8{
+            self_exe_path,
+            "clang",
+            c_object.src.src_path,
+        });
+        try argv.appendSlice(c_object.src.extra_flags);
+
+        const ext = classifyFileExt(c_object.src.src_path);
+
+        // When all these flags are true, it means that the entire purpose of
+        // this compilation is to perform a single zig cc operation. This means
+        // that we could "tail call" clang by doing an execve, and any use of
+        // the caching system would actually be problematic since the user is
+        // presumably doing their own caching by using dep file flags.
+        if (comp.disable_c_depfile and comp.clang_passthrough_mode and std.process.can_execv and direct_o) {
+            try comp.addCCArgs(arena, &argv, ext, null);
+
+            const out_obj_path = if (comp.bin_file.options.emit) |emit|
+                try emit.directory.join(arena, &.{emit.sub_path})
+            else
+                "/dev/null";
+
+            try argv.ensureUnusedCapacity(5);
+            switch (comp.clang_preprocessor_mode) {
+                .no => argv.appendSliceAssumeCapacity(&[_][]const u8{ "-c", "-o", out_obj_path }),
+                .yes => argv.appendSliceAssumeCapacity(&[_][]const u8{ "-E", "-o", out_obj_path }),
+                .stdout => argv.appendAssumeCapacity("-E"),
+            }
+
+            if (comp.emit_asm != null) {
+                argv.appendAssumeCapacity("-S");
+            } else if (comp.emit_llvm_ir != null) {
+                argv.appendSliceAssumeCapacity(&[_][]const u8{ "-emit-llvm", "-S" });
+            } else if (comp.emit_llvm_bc != null) {
+                argv.appendAssumeCapacity("-emit-llvm");
+            }
+
+            if (comp.verbose_cc) {
+                dump_argv(argv.items);
+            }
+
+            const err = std.process.execv(arena, argv.items);
+            fatal("unable to execv clang: {s}", .{@errorName(err)});
+        }
+
         // We can't know the digest until we do the C compiler invocation,
         // so we need a temporary filename.
         const out_obj_path = try comp.tmpFilePath(arena, o_basename);
         var zig_cache_tmp_dir = try comp.local_cache_directory.handle.makeOpenPath("tmp", .{});
         defer zig_cache_tmp_dir.close();
 
-        try argv.appendSlice(&[_][]const u8{ self_exe_path, "clang" });
-
-        const ext = classifyFileExt(c_object.src.src_path);
         const out_dep_path: ?[]const u8 = if (comp.disable_c_depfile or !ext.clangSupportsDepFile())
             null
         else
             try std.fmt.allocPrint(arena, "{s}.d", .{out_obj_path});
         try comp.addCCArgs(arena, &argv, ext, out_dep_path);
 
-        try argv.ensureUnusedCapacity(6 + c_object.src.extra_flags.len);
+        try argv.ensureUnusedCapacity(5);
         switch (comp.clang_preprocessor_mode) {
             .no => argv.appendSliceAssumeCapacity(&[_][]const u8{ "-c", "-o", out_obj_path }),
             .yes => argv.appendSliceAssumeCapacity(&[_][]const u8{ "-E", "-o", out_obj_path }),
@@ -3783,8 +3825,6 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.P
                 argv.appendAssumeCapacity("-emit-llvm");
             }
         }
-        argv.appendAssumeCapacity(c_object.src.src_path);
-        argv.appendSliceAssumeCapacity(c_object.src.extra_flags);
 
         if (comp.verbose_cc) {
             dump_argv(argv.items);
-- 
2.54.0


From 397099b7ee16e5422adc8b8412a9adef18d0f019 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Marie?= <semarie@online.fr>
Date: Tue, 23 Aug 2022 08:57:50 +0000
Subject: [PATCH 253/290] pthread_key_create: make it build with stage2

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

diff --git a/lib/std/c.zig b/lib/std/c.zig
index c33d7b35ab115a1d46a6e8eec8f131bea1371afc..f01f580083e64687f4dda4ef3a23612b5084b5d6 100644
--- a/lib/std/c.zig
+++ b/lib/std/c.zig
@@ -263,7 +263,11 @@ const PThreadForkFn = if (builtin.zig_backend == .stage1)
     fn () callconv(.C) void
 else
     *const fn () callconv(.C) void;
-pub extern "c" fn pthread_key_create(key: *c.pthread_key_t, destructor: ?fn (value: *anyopaque) callconv(.C) void) c.E;
+pub extern "c" fn pthread_key_create(key: *c.pthread_key_t, destructor: ?PThreadKeyCreateFn) c.E;
+const PThreadKeyCreateFn = if (builtin.zig_backend == .stage1)
+    fn (value: *anyopaque) callconv(.C) void
+else
+    *const fn (value: *anyopaque) callconv(.C) void;
 pub extern "c" fn pthread_key_delete(key: c.pthread_key_t) c.E;
 pub extern "c" fn pthread_getspecific(key: c.pthread_key_t) ?*anyopaque;
 pub extern "c" fn pthread_setspecific(key: c.pthread_key_t, value: ?*anyopaque) c_int;
-- 
2.54.0


From d8e22fcb208e2b52b272fb2c988f2123773b23e8 Mon Sep 17 00:00:00 2001
From: max <zhaoguowei@gmail.com>
Date: Wed, 24 Aug 2022 16:05:24 +0800
Subject: [PATCH 254/290] fix coff.zig with const qualifier convert problem

---
 lib/std/coff.zig | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/lib/std/coff.zig b/lib/std/coff.zig
index a017ae842241370ab95ff871fa0e302e18ea9838..45d5d3d79e2a86802a1fa39cebc655f451bedbdc 100644
--- a/lib/std/coff.zig
+++ b/lib/std/coff.zig
@@ -915,25 +915,25 @@ pub const Coff = struct {
     }
 
     pub fn getCoffHeader(self: Coff) CoffHeader {
-        return @ptrCast(*align(1) CoffHeader, self.data[self.coff_header_offset..][0..@sizeOf(CoffHeader)]).*;
+        return @ptrCast(*align(1) const CoffHeader, self.data[self.coff_header_offset..][0..@sizeOf(CoffHeader)]).*;
     }
 
     pub fn getOptionalHeader(self: Coff) OptionalHeader {
         assert(self.is_image);
         const offset = self.coff_header_offset + @sizeOf(CoffHeader);
-        return @ptrCast(*align(1) OptionalHeader, self.data[offset..][0..@sizeOf(OptionalHeader)]).*;
+        return @ptrCast(*align(1) const OptionalHeader, self.data[offset..][0..@sizeOf(OptionalHeader)]).*;
     }
 
     pub fn getOptionalHeader32(self: Coff) OptionalHeaderPE32 {
         assert(self.is_image);
         const offset = self.coff_header_offset + @sizeOf(CoffHeader);
-        return @ptrCast(*align(1) OptionalHeaderPE32, self.data[offset..][0..@sizeOf(OptionalHeaderPE32)]).*;
+        return @ptrCast(*align(1) const OptionalHeaderPE32, self.data[offset..][0..@sizeOf(OptionalHeaderPE32)]).*;
     }
 
     pub fn getOptionalHeader64(self: Coff) OptionalHeaderPE64 {
         assert(self.is_image);
         const offset = self.coff_header_offset + @sizeOf(CoffHeader);
-        return @ptrCast(*align(1) OptionalHeaderPE64, self.data[offset..][0..@sizeOf(OptionalHeaderPE64)]).*;
+        return @ptrCast(*align(1) const OptionalHeaderPE64, self.data[offset..][0..@sizeOf(OptionalHeaderPE64)]).*;
     }
 
     pub fn getImageBase(self: Coff) u64 {
@@ -962,7 +962,7 @@ pub const Coff = struct {
             else => unreachable, // We assume we have validated the header already
         };
         const offset = self.coff_header_offset + @sizeOf(CoffHeader) + size;
-        return @ptrCast([*]align(1) ImageDataDirectory, self.data[offset..])[0..self.getNumberOfDataDirectories()];
+        return @ptrCast([*]align(1) const ImageDataDirectory, self.data[offset..])[0..self.getNumberOfDataDirectories()];
     }
 
     pub fn getSymtab(self: *const Coff) ?Symtab {
@@ -980,13 +980,13 @@ pub const Coff = struct {
 
         const offset = coff_header.pointer_to_symbol_table + Symbol.sizeOf() * coff_header.number_of_symbols;
         const size = mem.readIntLittle(u32, self.data[offset..][0..4]);
-        return .{ .buffer = self.data[offset..][0..size] };
+        return Strtab{ .buffer = self.data[offset..][0..size] };
     }
 
     pub fn getSectionHeaders(self: *const Coff) []align(1) const SectionHeader {
         const coff_header = self.getCoffHeader();
         const offset = self.coff_header_offset + @sizeOf(CoffHeader) + coff_header.size_of_optional_header;
-        return @ptrCast([*]align(1) SectionHeader, self.data.ptr + offset)[0..coff_header.number_of_sections];
+        return @ptrCast([*]align(1) const SectionHeader, self.data.ptr + offset)[0..coff_header.number_of_sections];
     }
 
     pub fn getSectionName(self: *const Coff, sect_hdr: *align(1) const SectionHeader) []const u8 {
-- 
2.54.0


From 07afd5bdbaef991a177e2df03af0502fce5dde23 Mon Sep 17 00:00:00 2001
From: Jonas Gollenz <jgollenz@outlook.com>
Date: Wed, 24 Aug 2022 01:35:45 +0200
Subject: [PATCH 255/290] docs: remove confusion about align[For|Back]ward

---
 lib/std/mem.zig | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 8ab1b8a6d2d844c95ab0c703ddd6415159a163db..b7f95e636600bc941177d258616e3121accb68a3 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -3252,13 +3252,13 @@ test "sliceAsBytes preserves pointer attributes" {
     try testing.expectEqual(in.alignment, out.alignment);
 }
 
-/// Round an address up to the nearest aligned address
+/// Round an address up to the next (or current) aligned address.
 /// The alignment must be a power of 2 and greater than 0.
 pub fn alignForward(addr: usize, alignment: usize) usize {
     return alignForwardGeneric(usize, addr, alignment);
 }
 
-/// Round an address up to the nearest aligned address
+/// Round an address up to the next (or current) aligned address.
 /// The alignment must be a power of 2 and greater than 0.
 pub fn alignForwardGeneric(comptime T: type, addr: T, alignment: T) T {
     return alignBackwardGeneric(T, addr + (alignment - 1), alignment);
@@ -3290,7 +3290,7 @@ test "alignForward" {
     try testing.expect(alignForward(17, 8) == 24);
 }
 
-/// Round an address up to the previous aligned address
+/// Round an address down to the previous (or current) aligned address.
 /// Unlike `alignBackward`, `alignment` can be any positive number, not just a power of 2.
 pub fn alignBackwardAnyAlign(i: usize, alignment: usize) usize {
     if (@popCount(alignment) == 1)
@@ -3299,13 +3299,13 @@ pub fn alignBackwardAnyAlign(i: usize, alignment: usize) usize {
     return i - @mod(i, alignment);
 }
 
-/// Round an address up to the previous aligned address
+/// Round an address down to the previous (or current) aligned address.
 /// The alignment must be a power of 2 and greater than 0.
 pub fn alignBackward(addr: usize, alignment: usize) usize {
     return alignBackwardGeneric(usize, addr, alignment);
 }
 
-/// Round an address up to the previous aligned address
+/// Round an address down to the previous (or current) aligned address.
 /// The alignment must be a power of 2 and greater than 0.
 pub fn alignBackwardGeneric(comptime T: type, addr: T, alignment: T) T {
     assert(@popCount(alignment) == 1);
-- 
2.54.0


From a9af4727286734cd9b05d3b031e6d5c1834a6a8b Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 24 Aug 2022 15:19:31 -0700
Subject: [PATCH 256/290] Compilation: move comptime condition first

Avoids compile error on Windows due to not having execv capabilities.

Fixup for eb3f7d2f37cab1d3df7c4493b8239e802b83e521.

See #6768
---
 src/Compilation.zig | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 1b424a400190ba6a8774f9bfbac3fec8022037bb..d6bf121adb761737f6548b417148b985432c2776 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -3767,7 +3767,9 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.P
         // that we could "tail call" clang by doing an execve, and any use of
         // the caching system would actually be problematic since the user is
         // presumably doing their own caching by using dep file flags.
-        if (comp.disable_c_depfile and comp.clang_passthrough_mode and std.process.can_execv and direct_o) {
+        if (std.process.can_execv and direct_o and
+            comp.disable_c_depfile and comp.clang_passthrough_mode)
+        {
             try comp.addCCArgs(arena, &argv, ext, null);
 
             const out_obj_path = if (comp.bin_file.options.emit) |emit|
-- 
2.54.0


From f4980a480023c36692da52083f421e068e40f6b3 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 24 Aug 2022 16:18:42 -0700
Subject: [PATCH 257/290] CI: windows: update tarball

needed because of some changes to std.dwarf
---
 ci/azure/pipelines.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index e77c7592753f0b1cf689a7bb92b2cc9d21458187..33747d4d183068b0b60c4cc3738fc9c6e5656b4c 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -27,7 +27,7 @@ jobs:
     vmImage: 'windows-2019'
   variables:
     TARGET: 'x86_64-windows-gnu'
-    ZIG_LLVM_CLANG_LLD_NAME: 'zig+llvm+lld+clang-${{ variables.TARGET }}-0.10.0-dev.3671+62ff8871e'
+    ZIG_LLVM_CLANG_LLD_NAME: 'zig+llvm+lld+clang-${{ variables.TARGET }}-0.10.0-dev.3733+a9af47272'
     ZIG_LLVM_CLANG_LLD_URL: 'https://ziglang.org/deps/${{ variables.ZIG_LLVM_CLANG_LLD_NAME }}.zip'
   steps:
   - pwsh: |
-- 
2.54.0


From af19909b9cde3d009f0306ac825f39912644bca6 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 24 Aug 2022 16:41:10 -0700
Subject: [PATCH 258/290] stage2: fix generic function cleanup

When removing generic function instantiations from monomorphed_funcs, we
need to first make sure the function is generic, otherwise the hash map
tries to access the `hash` field of the function which is undefined.

closes #12614
---
 src/Module.zig | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/Module.zig b/src/Module.zig
index 45e0779c54afcf3df853c4aef5f2e731e8295008..34617ed3e28467a9bac428650640c54f9e981939 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -559,7 +559,9 @@ pub const Decl = struct {
         }
         if (decl.getFunction()) |func| {
             _ = mod.align_stack_fns.remove(func);
-            _ = mod.monomorphed_funcs.remove(func);
+            if (func.comptime_args != null) {
+                _ = mod.monomorphed_funcs.remove(func);
+            }
             func.deinit(gpa);
             gpa.destroy(func);
         }
@@ -1478,6 +1480,7 @@ pub const Fn = struct {
     /// This is important because it may be accessed when resizing monomorphed_funcs
     /// while this Fn has already been added to the set, but does not have the
     /// owner_decl, comptime_args, or other fields populated yet.
+    /// This field is undefined if comptime_args == null.
     hash: u64,
 
     /// Relative to owner Decl.
-- 
2.54.0


From 7453f56e678c80928ababa2868c69cfe41647fed Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 24 Aug 2022 20:27:11 -0700
Subject: [PATCH 259/290] stage2: explicitly tagged enums no longer have one
 possible value

Previously, Zig had inconsistent semantics for an enum like this:

`enum(u8){zero = 0}`

Although in theory this can only hold one possible value, the tag
`zero`, Zig no longer will treat the type this way. It will do loads and
stores, as if the type has runtime bits.

Closes #12619

Tests passed locally:
 * test-behavior
 * test-cases
---
 lib/std/elf.zig             | 14 +++++-----
 src/Module.zig              | 26 ++++++++++---------
 src/Sema.zig                |  7 +++++
 src/arch/x86_64/CodeGen.zig |  4 +--
 src/codegen/llvm.zig        |  8 +++---
 src/type.zig                | 51 ++++++++++++++++++++++++-------------
 test/behavior.zig           |  1 -
 test/behavior/bugs/1111.zig | 11 --------
 test/behavior/enum.zig      | 42 ++++++++++++++++++++++++++++++
 test/behavior/union.zig     |  9 +++----
 10 files changed, 113 insertions(+), 60 deletions(-)
 delete mode 100644 test/behavior/bugs/1111.zig

diff --git a/lib/std/elf.zig b/lib/std/elf.zig
index 16581b7782b66886daf7ec995322a017e7e31ed1..cc43e11a7da1cc429d47b873a1eb9d122a79b7c9 100644
--- a/lib/std/elf.zig
+++ b/lib/std/elf.zig
@@ -3,7 +3,7 @@ const io = std.io;
 const os = std.os;
 const math = std.math;
 const mem = std.mem;
-const debug = std.debug;
+const assert = std.debug.assert;
 const File = std.fs.File;
 const native_endian = @import("builtin").target.cpu.arch.endian();
 
@@ -872,14 +872,14 @@ pub const Elf_MIPS_ABIFlags_v0 = extern struct {
 };
 
 comptime {
-    debug.assert(@sizeOf(Elf32_Ehdr) == 52);
-    debug.assert(@sizeOf(Elf64_Ehdr) == 64);
+    assert(@sizeOf(Elf32_Ehdr) == 52);
+    assert(@sizeOf(Elf64_Ehdr) == 64);
 
-    debug.assert(@sizeOf(Elf32_Phdr) == 32);
-    debug.assert(@sizeOf(Elf64_Phdr) == 56);
+    assert(@sizeOf(Elf32_Phdr) == 32);
+    assert(@sizeOf(Elf64_Phdr) == 56);
 
-    debug.assert(@sizeOf(Elf32_Shdr) == 40);
-    debug.assert(@sizeOf(Elf64_Shdr) == 64);
+    assert(@sizeOf(Elf32_Shdr) == 40);
+    assert(@sizeOf(Elf64_Shdr) == 64);
 }
 
 pub const Auxv = switch (@sizeOf(usize)) {
diff --git a/src/Module.zig b/src/Module.zig
index 34617ed3e28467a9bac428650640c54f9e981939..a92849e127e4c6df05285b1ae890b90698e0b14d 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -1368,18 +1368,20 @@ pub const Union = struct {
             }
         }
         payload_align = @maximum(payload_align, 1);
-        if (!have_tag or fields.len <= 1) return .{
-            .abi_size = std.mem.alignForwardGeneric(u64, payload_size, payload_align),
-            .abi_align = payload_align,
-            .most_aligned_field = most_aligned_field,
-            .most_aligned_field_size = most_aligned_field_size,
-            .biggest_field = biggest_field,
-            .payload_size = payload_size,
-            .payload_align = payload_align,
-            .tag_align = 0,
-            .tag_size = 0,
-            .padding = 0,
-        };
+        if (!have_tag or !u.tag_ty.hasRuntimeBits()) {
+            return .{
+                .abi_size = std.mem.alignForwardGeneric(u64, payload_size, payload_align),
+                .abi_align = payload_align,
+                .most_aligned_field = most_aligned_field,
+                .most_aligned_field_size = most_aligned_field_size,
+                .biggest_field = biggest_field,
+                .payload_size = payload_size,
+                .payload_align = payload_align,
+                .tag_align = 0,
+                .tag_size = 0,
+                .padding = 0,
+            };
+        }
         // Put the tag before or after the payload depending on which one's
         // alignment is greater.
         const tag_size = u.tag_ty.abiSize(target);
diff --git a/src/Sema.zig b/src/Sema.zig
index b24a00150acbebbd34bd6035352214ca3b59e6c9..3e8005269f6c95069186ef2a8249bd9440599752 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -28844,6 +28844,10 @@ pub fn typeHasOnePossibleValue(
         .enum_numbered => {
             const resolved_ty = try sema.resolveTypeFields(block, src, ty);
             const enum_obj = resolved_ty.castTag(.enum_numbered).?.data;
+            // An explicit tag type is always provided for enum_numbered.
+            if (enum_obj.tag_ty.hasRuntimeBits()) {
+                return null;
+            }
             if (enum_obj.fields.count() == 1) {
                 if (enum_obj.values.count() == 0) {
                     return Value.zero; // auto-numbered
@@ -28857,6 +28861,9 @@ pub fn typeHasOnePossibleValue(
         .enum_full => {
             const resolved_ty = try sema.resolveTypeFields(block, src, ty);
             const enum_obj = resolved_ty.castTag(.enum_full).?.data;
+            if (enum_obj.tag_ty.hasRuntimeBits()) {
+                return null;
+            }
             if (enum_obj.fields.count() == 1) {
                 if (enum_obj.values.count() == 0) {
                     return Value.zero; // auto-numbered
diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig
index 0f6b6baee360de34ff5ae4b076e06686c2f5afa0..106d2feec02bf213ed1ef3ea3528f097c54baf92 100644
--- a/src/arch/x86_64/CodeGen.zig
+++ b/src/arch/x86_64/CodeGen.zig
@@ -6524,13 +6524,13 @@ fn airCmpxchg(self: *Self, inst: Air.Inst.Index) !void {
     const extra = self.air.extraData(Air.Block, ty_pl.payload);
     _ = ty_pl;
     _ = extra;
-    return self.fail("TODO implement airCmpxchg for {}", .{self.target.cpu.arch});
+    return self.fail("TODO implement x86 airCmpxchg", .{});
     // return self.finishAir(inst, result, .{ extra.ptr, extra.expected_value, extra.new_value });
 }
 
 fn airAtomicRmw(self: *Self, inst: Air.Inst.Index) !void {
     _ = inst;
-    return self.fail("TODO implement airCmpxchg for {}", .{self.target.cpu.arch});
+    return self.fail("TODO implement x86 airAtomicRaw", .{});
 }
 
 fn airAtomicLoad(self: *Self, inst: Air.Inst.Index) !void {
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index cddbdc6822cd5b4cc1fd2b53172229cb2ceab3a3..d872057beb6c0ff55d28e37500515eab49fec5c6 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1860,7 +1860,7 @@ pub const Object = struct {
                 var offset: u64 = 0;
 
                 for (fields.values()) |field, i| {
-                    if (field.is_comptime or !field.ty.hasRuntimeBitsIgnoreComptime()) continue;
+                    if (field.is_comptime or !field.ty.hasRuntimeBits()) continue;
 
                     const field_size = field.ty.abiSize(target);
                     const field_align = field.alignment(target, layout);
@@ -2764,7 +2764,7 @@ pub const DeclGen = struct {
                 var any_underaligned_fields = false;
 
                 for (struct_obj.fields.values()) |field| {
-                    if (field.is_comptime or !field.ty.hasRuntimeBitsIgnoreComptime()) continue;
+                    if (field.is_comptime or !field.ty.hasRuntimeBits()) continue;
 
                     const field_align = field.alignment(target, struct_obj.layout);
                     const field_ty_align = field.ty.abiAlignment(target);
@@ -3443,7 +3443,7 @@ pub const DeclGen = struct {
                 var need_unnamed = false;
 
                 for (struct_obj.fields.values()) |field, i| {
-                    if (field.is_comptime or !field.ty.hasRuntimeBitsIgnoreComptime()) continue;
+                    if (field.is_comptime or !field.ty.hasRuntimeBits()) continue;
 
                     const field_align = field.alignment(target, struct_obj.layout);
                     big_align = @maximum(big_align, field_align);
@@ -9477,7 +9477,7 @@ fn llvmFieldIndex(
 
     var llvm_field_index: c_uint = 0;
     for (ty.structFields().values()) |field, i| {
-        if (field.is_comptime or !field.ty.hasRuntimeBitsIgnoreComptime()) continue;
+        if (field.is_comptime or !field.ty.hasRuntimeBits()) continue;
 
         const field_align = field.alignment(target, layout);
         big_align = @maximum(big_align, field_align);
diff --git a/src/type.zig b/src/type.zig
index 1592dcf469260c63805d8fce60cf0b13d134b305..cc6e5706ee6ad8d0a851601b1d99223e66a2ed5e 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -2310,6 +2310,8 @@ pub const Type = extern union {
     ///     fields will count towards the ABI size. For example, `struct {T: type, x: i32}`
     ///     hasRuntimeBits()=true and abiSize()=4
     /// * the type has only one possible value, making its ABI size 0.
+    ///   - an enum with an explicit tag type has the ABI size of the integer tag type,
+    ///     making it one-possible-value only if the integer tag type has 0 bits.
     /// When `ignore_comptime_only` is true, then types that are comptime only
     /// may return false positives.
     pub fn hasRuntimeBitsAdvanced(
@@ -2452,9 +2454,9 @@ pub const Type = extern union {
                     _ = try sk.sema.resolveTypeFields(sk.block, sk.src, ty);
                 }
                 assert(struct_obj.haveFieldTypes());
-                for (struct_obj.fields.values()) |value| {
-                    if (value.is_comptime) continue;
-                    if (try value.ty.hasRuntimeBitsAdvanced(ignore_comptime_only, sema_kit))
+                for (struct_obj.fields.values()) |field| {
+                    if (field.is_comptime) continue;
+                    if (try field.ty.hasRuntimeBitsAdvanced(ignore_comptime_only, sema_kit))
                         return true;
                 } else {
                     return false;
@@ -2463,7 +2465,7 @@ pub const Type = extern union {
 
             .enum_full => {
                 const enum_full = ty.castTag(.enum_full).?.data;
-                return enum_full.fields.count() >= 2;
+                return enum_full.tag_ty.hasRuntimeBitsAdvanced(ignore_comptime_only, sema_kit);
             },
             .enum_simple => {
                 const enum_simple = ty.castTag(.enum_simple).?.data;
@@ -2490,9 +2492,10 @@ pub const Type = extern union {
             },
             .union_safety_tagged, .union_tagged => {
                 const union_obj = ty.cast(Payload.Union).?.data;
-                if (union_obj.fields.count() > 0 and try union_obj.tag_ty.hasRuntimeBitsAdvanced(ignore_comptime_only, sema_kit)) {
+                if (try union_obj.tag_ty.hasRuntimeBitsAdvanced(ignore_comptime_only, sema_kit)) {
                     return true;
                 }
+
                 if (sema_kit) |sk| {
                     _ = try sk.sema.resolveTypeFields(sk.block, sk.src, ty);
                 }
@@ -3125,7 +3128,11 @@ pub const Type = extern union {
             .lazy => |arena| return AbiAlignmentAdvanced{ .val = try Value.Tag.lazy_align.create(arena, ty) },
         };
         if (union_obj.fields.count() == 0) {
-            return AbiAlignmentAdvanced{ .scalar = @boolToInt(union_obj.layout == .Extern) };
+            if (have_tag) {
+                return abiAlignmentAdvanced(union_obj.tag_ty, target, strat);
+            } else {
+                return AbiAlignmentAdvanced{ .scalar = @boolToInt(union_obj.layout == .Extern) };
+            }
         }
 
         var max_align: u32 = 0;
@@ -4991,14 +4998,18 @@ pub const Type = extern union {
 
             .enum_numbered => {
                 const enum_numbered = ty.castTag(.enum_numbered).?.data;
-                if (enum_numbered.fields.count() == 1) {
-                    return enum_numbered.values.keys()[0];
-                } else {
+                // An explicit tag type is always provided for enum_numbered.
+                if (enum_numbered.tag_ty.hasRuntimeBits()) {
                     return null;
                 }
+                assert(enum_numbered.fields.count() == 1);
+                return enum_numbered.values.keys()[0];
             },
             .enum_full => {
                 const enum_full = ty.castTag(.enum_full).?.data;
+                if (enum_full.tag_ty.hasRuntimeBits()) {
+                    return null;
+                }
                 if (enum_full.fields.count() == 1) {
                     if (enum_full.values.count() == 0) {
                         return Value.zero;
@@ -5333,7 +5344,8 @@ pub const Type = extern union {
             .enum_numbered => return ty.castTag(.enum_numbered).?.data.tag_ty,
             .enum_simple => {
                 const enum_simple = ty.castTag(.enum_simple).?.data;
-                const bits = std.math.log2_int_ceil(usize, enum_simple.fields.count());
+                const field_count = enum_simple.fields.count();
+                const bits: u16 = if (field_count == 0) 0 else std.math.log2_int_ceil(usize, field_count);
                 buffer.* = .{
                     .base = .{ .tag = .int_unsigned },
                     .data = bits,
@@ -5653,19 +5665,22 @@ pub const Type = extern union {
         target: Target,
 
         pub fn next(it: *StructOffsetIterator) ?FieldOffset {
-            if (it.struct_obj.fields.count() <= it.field)
+            const i = it.field;
+            if (it.struct_obj.fields.count() <= i)
                 return null;
 
-            const field = it.struct_obj.fields.values()[it.field];
-            defer it.field += 1;
-            if (!field.ty.hasRuntimeBits() or field.is_comptime)
-                return FieldOffset{ .field = it.field, .offset = it.offset };
+            const field = it.struct_obj.fields.values()[i];
+            it.field += 1;
+
+            if (field.is_comptime or !field.ty.hasRuntimeBits()) {
+                return FieldOffset{ .field = i, .offset = it.offset };
+            }
 
             const field_align = field.alignment(it.target, it.struct_obj.layout);
             it.big_align = @maximum(it.big_align, field_align);
-            it.offset = std.mem.alignForwardGeneric(u64, it.offset, field_align);
-            defer it.offset += field.ty.abiSize(it.target);
-            return FieldOffset{ .field = it.field, .offset = it.offset };
+            const field_offset = std.mem.alignForwardGeneric(u64, it.offset, field_align);
+            it.offset = field_offset + field.ty.abiSize(it.target);
+            return FieldOffset{ .field = i, .offset = field_offset };
         }
     };
 
diff --git a/test/behavior.zig b/test/behavior.zig
index ba8379cd723b85ae2af0a51580ec5893d2d35db0..12edd6f9a3eb9f5ea9678c66d31bbea16e692efc 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -26,7 +26,6 @@ test {
     _ = @import("behavior/bugs/920.zig");
     _ = @import("behavior/bugs/1025.zig");
     _ = @import("behavior/bugs/1076.zig");
-    _ = @import("behavior/bugs/1111.zig");
     _ = @import("behavior/bugs/1277.zig");
     _ = @import("behavior/bugs/1310.zig");
     _ = @import("behavior/bugs/1381.zig");
diff --git a/test/behavior/bugs/1111.zig b/test/behavior/bugs/1111.zig
deleted file mode 100644
index d274befaf31c010d8353010320631c981173ebe6..0000000000000000000000000000000000000000
--- a/test/behavior/bugs/1111.zig
+++ /dev/null
@@ -1,11 +0,0 @@
-const Foo = enum(c_int) {
-    Bar = -1,
-};
-
-test "issue 1111 fixed" {
-    const v = Foo.Bar;
-
-    switch (v) {
-        Foo.Bar => return,
-    }
-}
diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig
index 709d30af33139101939fb0bd5b10c9cbdd55d27b..9e96163cc02fb67a7c0574e2e58ff2d747ed7a41 100644
--- a/test/behavior/enum.zig
+++ b/test/behavior/enum.zig
@@ -1,6 +1,7 @@
 const builtin = @import("builtin");
 const std = @import("std");
 const expect = std.testing.expect;
+const assert = std.debug.assert;
 const mem = std.mem;
 const Tag = std.meta.Tag;
 
@@ -1128,3 +1129,44 @@ test "tag name functions are unique" {
         _ = a;
     }
 }
+
+test "size of enum with only one tag which has explicit integer tag type" {
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+
+    const E = enum(u8) { nope = 10 };
+    const S0 = struct { e: E };
+    const S1 = extern struct { e: E };
+    //const U = union(E) { nope: void };
+    comptime assert(@sizeOf(E) == 1);
+    comptime assert(@sizeOf(S0) == 1);
+    comptime assert(@sizeOf(S1) == 1);
+    //comptime assert(@sizeOf(U) == 1);
+
+    var s1: S1 = undefined;
+    s1.e = .nope;
+    try expect(s1.e == .nope);
+    const ptr = @ptrCast(*u8, &s1);
+    try expect(ptr.* == 10);
+
+    var s0: S0 = undefined;
+    s0.e = .nope;
+    try expect(s0.e == .nope);
+}
+
+test "switch on an extern enum with negative value" {
+    // TODO x86, wasm backends fail because they assume that enum tag types are unsigned
+    if (@import("builtin").zig_backend == .stage2_x86_64) return error.SkipZigTest;
+    if (@import("builtin").zig_backend == .stage2_wasm) return error.SkipZigTest;
+
+    const Foo = enum(c_int) {
+        Bar = -1,
+    };
+
+    const v = Foo.Bar;
+
+    switch (v) {
+        Foo.Bar => return,
+    }
+}
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index 92f277b946548db54ba93c2bef22cc2d9a165567..e2078c66df2f7d7fd11c47fad18fc849f58eb4bc 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -1,6 +1,7 @@
 const builtin = @import("builtin");
 const std = @import("std");
 const expect = std.testing.expect;
+const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
 const Tag = std.meta.Tag;
 
@@ -1065,6 +1066,8 @@ test "@unionInit on union with tag but no fields" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     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_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
 
     const S = struct {
         const Type = enum(u8) { no_op = 105 };
@@ -1079,11 +1082,7 @@ test "@unionInit on union with tag but no fields" {
         };
 
         comptime {
-            if (builtin.zig_backend == .stage1) {
-                // stage1 gets the wrong answer here
-            } else {
-                std.debug.assert(@sizeOf(Data) == 0);
-            }
+            assert(@sizeOf(Data) == 1);
         }
 
         fn doTheTest() !void {
-- 
2.54.0


From 3a7ea0b65e4edb3e13218023eb667792ab2d0d51 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 25 Aug 2022 03:10:41 -0700
Subject: [PATCH 260/290] fix order of CLI args passed to clang

Commit eb3f7d2f37cab1d3df7c4493b8239e802b83e521 changed the order of CLI
args passed to clang, making object-specific "extra flags" passed first.
However, these are supposed to be able to override other flags, and this
behavior is exploited by workarounds in mingw.zig to disable LTO.

This commit rectifies the situation by moving extra flags back to being
passed after the call to addCCArgs().
---
 src/Compilation.zig | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index d6bf121adb761737f6548b417148b985432c2776..03d7962ccc771bb412f0d1c72fe7e5074fb354f5 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -3758,7 +3758,6 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.P
             "clang",
             c_object.src.src_path,
         });
-        try argv.appendSlice(c_object.src.extra_flags);
 
         const ext = classifyFileExt(c_object.src.src_path);
 
@@ -3771,6 +3770,7 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.P
             comp.disable_c_depfile and comp.clang_passthrough_mode)
         {
             try comp.addCCArgs(arena, &argv, ext, null);
+            try argv.appendSlice(c_object.src.extra_flags);
 
             const out_obj_path = if (comp.bin_file.options.emit) |emit|
                 try emit.directory.join(arena, &.{emit.sub_path})
@@ -3811,6 +3811,7 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.P
         else
             try std.fmt.allocPrint(arena, "{s}.d", .{out_obj_path});
         try comp.addCCArgs(arena, &argv, ext, out_dep_path);
+        try argv.appendSlice(c_object.src.extra_flags);
 
         try argv.ensureUnusedCapacity(5);
         switch (comp.clang_preprocessor_mode) {
-- 
2.54.0


From 4405188cf728755d41439e2606b2cba55af96ad9 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Thu, 25 Aug 2022 11:52:58 +0300
Subject: [PATCH 261/290] Sema: ignore comptime params in partial func type
 check

This fixes a bug exposed by cd1833044ab7505bc101c85f59889bd3ea3fac80
where a function type would be converted to generic_poison even after
being instantiated due to containing comptime only types.

This could also be fixed by just checking `is_generic_instantiation`
but this way also provides better type names.

Closes #12625
---
 src/Sema.zig                                  | 27 +++++--------------
 test/behavior/typename.zig                    | 11 ++++++++
 ...xport_function_with_comptime_parameter.zig |  2 +-
 ...xtern_function_with_comptime_parameter.zig |  9 +++----
 4 files changed, 22 insertions(+), 27 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 3e8005269f6c95069186ef2a8249bd9440599752..fc2a7f872ad842f6a16acbc45cb39f5ffc6a6cbb 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -7720,7 +7720,6 @@ fn funcCommon(
     noalias_bits: u32,
     is_noinline: bool,
 ) CompileError!Air.Inst.Ref {
-    const fn_src = LazySrcLoc.nodeOffset(src_node_offset);
     const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = src_node_offset };
     const cc_src: LazySrcLoc = .{ .node_offset_fn_type_cc = src_node_offset };
 
@@ -7791,13 +7790,11 @@ fn funcCommon(
             param_types[i] = param.ty;
             sema.analyzeParameter(
                 block,
-                fn_src,
                 .unneeded,
                 param,
                 comptime_params,
                 i,
                 &is_generic,
-                is_extern,
                 cc_workaround,
                 has_body,
             ) catch |err| switch (err) {
@@ -7805,13 +7802,11 @@ fn funcCommon(
                     const decl = sema.mod.declPtr(block.src_decl);
                     try sema.analyzeParameter(
                         block,
-                        fn_src,
                         Module.paramSrc(src_node_offset, sema.gpa, decl, i),
                         param,
                         comptime_params,
                         i,
                         &is_generic,
-                        is_extern,
                         cc_workaround,
                         has_body,
                     );
@@ -7821,9 +7816,10 @@ fn funcCommon(
             };
         }
 
+        var is_comptime_ret = false;
         const ret_poison = if (!is_generic) rp: {
             if (sema.typeRequiresComptime(block, ret_ty_src, bare_return_type)) |ret_comptime| {
-                is_generic = ret_comptime;
+                is_comptime_ret = ret_comptime;
                 break :rp bare_return_type.tag() == .generic_poison;
             } else |err| switch (err) {
                 error.GenericPoison => {
@@ -7920,6 +7916,8 @@ fn funcCommon(
             return sema.fail(block, cc_src, "'noinline' function cannot have callconv 'Inline'", .{});
         }
         if (is_generic and sema.no_partial_func_ty) return error.GenericPoison;
+        for (comptime_params) |ct| is_generic = is_generic or ct;
+        is_generic = is_generic or is_comptime_ret;
 
         break :fn_ty try Type.Tag.function.create(sema.arena, .{
             .param_types = param_types,
@@ -8010,31 +8008,20 @@ fn funcCommon(
 fn analyzeParameter(
     sema: *Sema,
     block: *Block,
-    func_src: LazySrcLoc,
     param_src: LazySrcLoc,
     param: Block.Param,
     comptime_params: []bool,
     i: usize,
     is_generic: *bool,
-    is_extern: bool,
     cc: std.builtin.CallingConvention,
     has_body: bool,
 ) !void {
     const requires_comptime = try sema.typeRequiresComptime(block, param_src, param.ty);
     comptime_params[i] = param.is_comptime or requires_comptime;
-    const this_generic = comptime_params[i] or param.ty.tag() == .generic_poison;
+    const this_generic = param.ty.tag() == .generic_poison;
     is_generic.* = is_generic.* or this_generic;
-    if (is_extern and this_generic) {
-        // TODO this check should exist somewhere for notes.
-        if (param_src == .unneeded) return error.NeededSourceLocation;
-        const msg = msg: {
-            const msg = try sema.errMsg(block, func_src, "extern function cannot be generic", .{});
-            errdefer msg.destroy(sema.gpa);
-
-            try sema.errNote(block, param_src, msg, "function is generic because of this parameter", .{});
-            break :msg msg;
-        };
-        return sema.failWithOwnedErrorMsg(msg);
+    if (param.is_comptime and !Type.fnCallingConventionAllowsZigTypes(cc)) {
+        return sema.fail(block, param_src, "comptime parameters not allowed in function with calling convention '{s}'", .{@tagName(cc)});
     }
     if (this_generic and !Type.fnCallingConventionAllowsZigTypes(cc)) {
         return sema.fail(block, param_src, "generic parameters not allowed in function with calling convention '{s}'", .{@tagName(cc)});
diff --git a/test/behavior/typename.zig b/test/behavior/typename.zig
index e0cb5ba68c157f473c685ebf173fd5f24c52b4a9..3bc8c58389fcc4ba413171e7b1bb829d9671bd10 100644
--- a/test/behavior/typename.zig
+++ b/test/behavior/typename.zig
@@ -235,3 +235,14 @@ test "local variable" {
     try expectEqualStrings("behavior.typename.test.local variable.Qux", @typeName(Qux));
     try expectEqualStrings("behavior.typename.test.local variable.Quux", @typeName(Quux));
 }
+
+test "comptime parameters not converted to anytype in function type" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
+    const T = fn (fn (type) void, void) void;
+    try expectEqualStrings("fn(fn(type) void, void) void", @typeName(T));
+}
diff --git a/test/cases/compile_errors/export_function_with_comptime_parameter.zig b/test/cases/compile_errors/export_function_with_comptime_parameter.zig
index 94c8f6de505fe7e253c54aa7a1dd5c6c99b67da7..4491a98e9cb069b0fd35dcf4f09d62b194dfe4c3 100644
--- a/test/cases/compile_errors/export_function_with_comptime_parameter.zig
+++ b/test/cases/compile_errors/export_function_with_comptime_parameter.zig
@@ -6,4 +6,4 @@ export fn foo(comptime x: anytype, y: i32) i32{
 // backend=stage2
 // target=native
 //
-// :1:15: error: generic parameters not allowed in function with calling convention 'C'
+// :1:15: error: comptime parameters not allowed in function with calling convention 'C'
diff --git a/test/cases/compile_errors/extern_function_with_comptime_parameter.zig b/test/cases/compile_errors/extern_function_with_comptime_parameter.zig
index cac4c7e5e21345fb3435e54db7b7a0d857deba49..de69fa409fb549a5ef1a11ea249df66ff91f3ce7 100644
--- a/test/cases/compile_errors/extern_function_with_comptime_parameter.zig
+++ b/test/cases/compile_errors/extern_function_with_comptime_parameter.zig
@@ -12,9 +12,6 @@ comptime { _ = entry2; }
 // backend=stage2
 // target=native
 //
-// :5:12: error: extern function cannot be generic
-// :5:30: note: function is generic because of this parameter
-// :6:12: error: extern function cannot be generic
-// :6:30: note: function is generic because of this parameter
-// :1:8: error: extern function cannot be generic
-// :1:15: note: function is generic because of this parameter
+// :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'
-- 
2.54.0


From ea785f70ef5148f372c897e503e71c080b69e8da Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Motiejus=20Jak=C5=A1tys?= <motiejus@uber.com>
Date: Thu, 25 Aug 2022 16:36:10 +0300
Subject: [PATCH 262/290] glibc/abilists: add libresolv stubs

Generated with https://github.com/ziglang/glibc-abi-tool/pull/2

Fixes #12628
---
 lib/libc/glibc/abilists | Bin 205284 -> 210531 bytes
 src/glibc.zig           |   5 +++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/libc/glibc/abilists b/lib/libc/glibc/abilists
index 205d3c15fb8175e508e2e07230b6d757822a687e..179e3f6f3fb50cb33fbe6e0e9f52da77859b78d5 100644
GIT binary patch
delta 6617
zcmbtZdvH`&8NcW3lHG*xFbg3K(DJmQ6v%7h5(wE$DXrp=WKim~%JuH<-Q<${;@-On
zaSAMywc01)mN})$*i5Y{El})Lj}9W>s{&T0GvajUbPBbOifx5)kQOWPJ9jsPL}qt$
z`Gfi9hCSao=X?CV-}jyOe^vVD4@yz64^<W!qN&N<Kdjt|aYMbmA5X_p)H#8l3bnxh
z@ExMnshL)^R}~bomYc+JTwv$Lrb#%E;v&^tU@w<~zdXTl5ial;2Ooj&!cTSt(g`7I
z+U?&CJ9hagyfxZT&#RWEk5qtR>46+-P+%aVOj1RQcmH|Q;b$juzIxlsxL!4RMd%V^
zf~u+9;E~p%z;5owa|~T!TVTM@l4@M+7FBYt0Zp;z&Y0D#CoQv6Gc1qya9U<;E{^a#
zvuvlTb$L_c9GQRG*TVBUpV-LU;!R81d1Aq}NsV!p7dPpG8XwkD6iAOS$;~_r=5fBY
zw7(?6BIK4#vS8&Z-)F%qpr@`jw?`cHzHljAoSAQ9QZ#zwnj%Q*SWoV}xb}lma_%$^
z*72rjZS2%Wdm>k4J3GJr*NMy6!cI$6M@2%eg=s~LClU?yM3C`Rd+W(@&a>K{&?<Hr
z$<&gDDH`3PF?<=8VmC(S&D?N3L!2d#^r2=J6ERsZO>bK4qdN|-1y?|n=X1qC#$z=N
zxji<(gP{~s^A8+ycBO03{n@C!g|M|c1Vs_-bCr!`NgEz#2OnMS`qFiYF*aYOlX9#}
z?}^(&W!TyE=)MVevD*va3f{8h+*flNcdK|}03QT2+#X1ool1vDS{_1;&IJ;{3qg^o
z8<J`nMk2SO0ek#&Z`haiRN|OmN4~M#DgVy$qM94l=UJXi7@CsM?f#=7a_&4Xa*Y0E
zxZXwXF$So8;Dx5eY~y4!n_0O5GG<D4_0>lE+Khm+`1@_+A`pFX^%i{VJiL$h-^=p=
zN-<6GS}l|=OH}OsiZI#oIu1B@9Gr+7SRKn&v5~ovGh>~*4_zL&jAf|m;?3~V0x^=z
z{uiD;h39!8zQK|daZ^J*H`r8~!Uvr-Kj|I6@_J#@EhtALs%yciZ%=-!+#Wohv|m3y
z$FY9-NT_Nkhz%om=s5pA6Y$T55YFx9*UmnP8izr5_?U$m!Fl}c7g3lczA45`ON$HE
zsFIb-2hNgrBn+@&_9{Fq_G%<m++@YI9(&`u3WvVCW>&U}sHW(l@)^1!Sfu?FUi#yE
zP*ng5Iv}R3sU5?n854NZt^oSY<Yt}MbW8GlMS^Cc)ug%tRZ_bG{mj2s)?&Qi-DEtU
zkTt;q4kVcgj;rQUcqcJuBC#C25fkL7B#L59ZJ2St6t_P~CSJzV=*5}n??rA=V;Lif
zCYUPL>CG_oPxH{)P%VTr!xY}^l5}oxa4>JcO7`I2rjq6`SV9h?#6kwfEb1(cMPTln
zpl`;|{YAysah=ZCfPPTs!ZDnoFj(v~G|epq&5Sz>vLtvc$n@I7sE-v*7Z8)G#mhoe
zls#%o)2Fwf=g|s=XCrw1Nblsz#&kj<$Je7ql1ia=Qj<a<dOC$Z4&?_Cdh!|cR1nfG
zq5mJ4jwM;>1AEaO{yQ1OC9S;lgLe0$DW$7j1PAv?qhWk3JEtWxDhs4<5?V_BasV}v
z>f2EX*>wO-rE?CVHpJr8giYM~mm5)Ix}j}I)YZCFkUsq?dc{|r4RYv`@(_;!RTPY9
zFKL6OgsyeaW5Ec!pVs5Kp-9uW52JgTa~Nd6351amQE(}uvwn>#imJg7k}6p)k;<KI
z1Cl9gJ>*h5T0jyf(V4~!Z5eyJ8578%^>{k{$|-bWYLi>60NVxQM(8Q5Tn*4!=h2dK
za`Ah(ctRF#G8B(|M!-#^{|fpVX}yA`l51DcT|ww30pIvqyRUVrt^GDgw|$IacvYrJ
zQI#%lyg@R1It)R#FC7fix&J|-;uWm^foD9XKCScPf8HJ$q8pz5J7+E~L-%AZ2d$Sp
zx^XHvQpo4$;Z}b_5jNS!&xGi6^Kja?4C2NGdY23p0`$;ZFjf`Ubo=64^T|aC2g!yi
ze4$*G<53wfKOUDk?o)0D_Y%){oAwcYI^D4V??g>HZ}sY<Xh`9QFI$LDEMknth-vZb
zTG%k*$q_Bv@Gya#U5J0$FcjTzu2GF%F3_cYcjNz}7N`NN0(z&{^zp^`ioc10#ZBr`
zVc9{q*5Q5rB@F7|Ecpl~q<0KDAlcqlTtyay@r0sm_jbNAJfR)t7abN1c)0C2O<xV;
zy*?Mnyygtg_o`&}Gk7-DmgAPPOsN@_eq+LWdT0%P53OKM^G@zaUmLC{0bCViF{Y{A
z1bv9ZB-oBy$-Xu`6H6xfupKR;-)zU-{u^k=;Fs}(WvleeoWmm=^L$T?g}HtFp+>r=
z6E~Kw%%tu});lJn2u25qti#L6fuExiIwOgNAd3b!Zw*bBqe84J59ZU&oACv-g3ScI
zw>>nz6@Q@|I5TvdP;@<7i0<EwA1E0%yS=nNLJl{eV%qvVMrDiOW{TOtA|N3P9r^Cn
z_8RUSmmTlLJy&B&DSkFsH)PbLs=FpFfcKKtW4O8mC>9K-AmX}g{c=4y8b(2S_85LJ
zFjPZ4_SLlJclZ<E`h;dc$;&?<VG|-ZDp)5Em;=1KfGf}yzsGf%K^8-HuWsG=2EKFJ
zeJ<H#TU)}YIbFd}51v=ayT8DZY(<aB&_j4URU$4aq`w>8Mn8EUpAEwC7!+qHskcey
zfToM8eTgVUe+LKck9L>Pbsym^<LBpZkxW&v&rb-G&{h0$(-10n<4Z@b;uDDRCI9m4
zZN=CsTpG;UVV|%3oL%+GWcuc(_yt_D-^T;Dk|B<XhJDk>G30Bee;mZ`VVBNpIxD>y
zIs|VI@Fr2pflRUI1bBsT-z7l8%Y+YugyAXcQZsK9k?bo4eA6Fc-{~pqSuJ-5r)<uU
zQTnB<QjqQ(7Nq-D@lsYfNLM*XS2;-c0R(=>o<I<MyRR1@$@Xc!FS>g$G#=if3TMs@
n(%k~2yG5HnbAFKS79ia%K)PGN@7yim+uZ_Wn*L#$ue{`cdC!$Y

delta 1415
zcmYjRZEO@(6rFo#c4ylz{o3vV1(ag2A*Iq%3f;Cu3P~G+KuJIm(d{rh+m79xZg+Ou
z1%fG9zDl6QL0_VT)?f-KrPddGKtNN8wgd_mqo6?wNc=z$P^|ty*4dh>@85lSFX!BI
z&$-{-w%<H$2XQxK_DpHT#~a+aepQP^bE~xorx&>MqW`Ned+6u5%OUurHM-HWvxr`D
zokg0Rc@T}f3l<|bv4}<|txuq{vd{B$LC&KTx}l^!k*+Q;=joY+bL@2fvp?HOY7*FJ
zy?ixU2-JCfuS+<I+}e&wv^%uRK{sz{1!MWP6Lj_Vg+RJ*plEz@*KK6)s1zf9xi;A7
zCCk$IBKqr&Lt{jbN7Xe+i{H4Z_03!qx8f1KCQxli))KmYuZYIF_DrK|-+)Dy<T~9*
zbGhlo_EIZEj3v*HCv`nwr7Js25G2yE2}<dVLwhU<dN`yjK~I59>MJ0Jy1S<dLZCLR
zkios^rbE<;H0Q$ymUNHgeL1WKl<4ePTx_nr36GGNg`XhmvgBXm*GTUjoI`^1Oo)M#
zg-OO>{}iLVe}^DTx=QjJF@q+ZsddoyD^?-Vq^)RPT?sXijjN!PbSI%mQ?D-o+InL@
z(At|dNZN)$AVa^Q#keTCXu%IlCbLr__(UeBz^AF?gUOJ|>q?je8?c<6n+(T=Y@feQ
z3P&`rs{1%Dk88p<k7tCPswhhS%p#7P$2D<>$>ph_7-ODEU@trge_GkzT&Q$_N-7_M
zlN6LerbE*`niNnxdaWAdVzHRXmn|*>Uk)4cLxq)(*E4kJOee4f=CY<O&<1SfHs}EI
zaSJ%#I0P1RjHVhbunZd-NqsYnWA|F%ieu#Koqe#&MuNX%BI`Q<83Mz@kYOizcC?Y}
z$4nBdkHLC2d<-gq1y4Xf&*YC_zfF|uG@m&w(z6ksV4*%3Z)4{!z&I;Q`3iWj#+BA;
z2$aKkre1<RC)4i0Q!bL%3KplYU?vy)D<<Lr4ozjcRP(KG#9QPpk1rZkf`#}5oSLkA
z>LW^M?P%NE1w4Yhsy7--mzJ`lB03Vty&SNT-VNYjQ_}E@$4p;JVM&`wVm0U_%kps8
z=?h3v6EQjh$&EmAU8E%+m$F~-aVwwU@o0YU8o$RYdA)v)d&o6&2U%w!W&z)z|0CGH
zQwWCZv{5?4v+*?`eMQ(uPP&l^vR@06s%9)<KNaICV7E%~fxsS{kDUU^tiWV)yBzb<
zgC1XXm^05N+#If!0s$!=4Hl`uw|HD@2I@J;V)cu#EFEQ?+~?83Y%k#ej5T{O3I5l~
z!MJ#4Cnu}S6z5doZd7%0eih_0n}iL5%``@}5{`t8w+oBeX9`Y8XIW8PXJ=QM@m-rm
z*6TxIqxWtxd$1GV19q(yD_pFm6IUe0jbYp?oJU@H8WLDa4?;Sddm3vjiMm>?sXkSf
zG$ZRvH=A|_m)ppU6_`Md4`Q}+)T<FKD9N>>I$ayY4w3bKjl(=?8bk~E@msW8O$;UE
zBWV*LgH6AR6G3d0&4B0%>5!qA^$+3qF2Uzj1IC~@mfRmUleOm${Kj^)hX;Fn*~Iq`
z={XC9#6E`a0-dDhLK%7g5elp{nST|`dDK;#+RkCKQ+bNe#%`taWju?z_<;=aP7c3_
KEuPN168{GMs11w&

diff --git a/src/glibc.zig b/src/glibc.zig
index ceb60ff096596f7fd456dcae99a42308547e5096..c02989294b96d21b63c01b68c5fcb90f4173d256 100644
--- a/src/glibc.zig
+++ b/src/glibc.zig
@@ -41,6 +41,7 @@ pub const libs = [_]Lib{
     .{ .name = "rt", .sover = 1 },
     .{ .name = "ld", .sover = 2 },
     .{ .name = "util", .sover = 1 },
+    .{ .name = "resolv", .sover = 2 },
 };
 
 // glibc's naming of Zig architectures
@@ -59,7 +60,7 @@ const Arch = enum(c_int) {
     riscv32,
     riscv64,
     sparc,
-    sparcv9,
+    sparc64,
     sparcel,
     s390x,
     i386,
@@ -1155,7 +1156,7 @@ fn glibcToZigArch(arch_tag: Arch) std.Target.Cpu.Arch {
         .riscv32 => .riscv32,
         .riscv64 => .riscv64,
         .sparc => .sparc,
-        .sparcv9 => .sparc64, // In glibc, sparc64 is called sparcv9.
+        .sparc64 => .sparc64,
         .sparcel => .sparcel,
         .s390x => .s390x,
         .i386 => .i386,
-- 
2.54.0


From 29e90efbb131b21eb7f41425a4dd4b74e6989942 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Motiejus=20Jak=C5=A1tys?= <motiejus@uber.com>
Date: Thu, 25 Aug 2022 16:46:32 +0300
Subject: [PATCH 263/290] src/glibc: remove redundant Arch

abilists now use Zig's arch, no need for a separate one.
---
 src/glibc.zig | 51 ++-------------------------------------------------
 1 file changed, 2 insertions(+), 49 deletions(-)

diff --git a/src/glibc.zig b/src/glibc.zig
index c02989294b96d21b63c01b68c5fcb90f4173d256..4e338671696f125914a78cb9fd6b7105b21ba2b6 100644
--- a/src/glibc.zig
+++ b/src/glibc.zig
@@ -44,29 +44,6 @@ pub const libs = [_]Lib{
     .{ .name = "resolv", .sover = 2 },
 };
 
-// glibc's naming of Zig architectures
-const Arch = enum(c_int) {
-    arm,
-    armeb,
-    aarch64,
-    aarch64_be,
-    mips,
-    mipsel,
-    mips64,
-    mips64el,
-    powerpc,
-    powerpc64,
-    powerpc64le,
-    riscv32,
-    riscv64,
-    sparc,
-    sparc64,
-    sparcel,
-    s390x,
-    i386,
-    x86_64,
-};
-
 pub const LoadMetaDataError = error{
     /// The files that ship with the Zig compiler were unable to be read, or otherwise had malformed data.
     ZigInstallationCorrupt,
@@ -158,7 +135,7 @@ pub fn loadMetaData(gpa: Allocator, zig_lib_dir: fs.Dir) LoadMetaDataError!*ABI
                 log.err("abilists: expected ABI name", .{});
                 return error.ZigInstallationCorrupt;
             };
-            const arch_tag = std.meta.stringToEnum(Arch, arch_name) orelse {
+            const arch_tag = std.meta.stringToEnum(std.Target.Cpu.Arch, arch_name) orelse {
                 log.err("abilists: unrecognized arch: '{s}'", .{arch_name});
                 return error.ZigInstallationCorrupt;
             };
@@ -172,7 +149,7 @@ pub fn loadMetaData(gpa: Allocator, zig_lib_dir: fs.Dir) LoadMetaDataError!*ABI
             };
 
             targets[i] = .{
-                .arch = glibcToZigArch(arch_tag),
+                .arch = arch_tag,
                 .os = .linux,
                 .abi = abi_tag,
             };
@@ -1140,30 +1117,6 @@ fn buildSharedLib(
     try sub_compilation.updateSubCompilation();
 }
 
-fn glibcToZigArch(arch_tag: Arch) std.Target.Cpu.Arch {
-    return switch (arch_tag) {
-        .arm => .arm,
-        .armeb => .armeb,
-        .aarch64 => .aarch64,
-        .aarch64_be => .aarch64_be,
-        .mips => .mips,
-        .mipsel => .mipsel,
-        .mips64 => .mips64,
-        .mips64el => .mips64el,
-        .powerpc => .powerpc,
-        .powerpc64 => .powerpc64,
-        .powerpc64le => .powerpc64le,
-        .riscv32 => .riscv32,
-        .riscv64 => .riscv64,
-        .sparc => .sparc,
-        .sparc64 => .sparc64,
-        .sparcel => .sparcel,
-        .s390x => .s390x,
-        .i386 => .i386,
-        .x86_64 => .x86_64,
-    };
-}
-
 // Return true if glibc has crti/crtn sources for that architecture.
 pub fn needsCrtiCrtn(target: std.Target) bool {
     return switch (target.cpu.arch) {
-- 
2.54.0


From ba346ecfe9b8ee246e084183f34fa9ed941f9fa3 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Thu, 25 Aug 2022 17:01:18 +0200
Subject: [PATCH 264/290] run_translated_c: disable failing test on Windows

ziglang/zig#12630
---
 test/run_translated_c.zig | 68 +++++++++++++++++++++------------------
 1 file changed, 36 insertions(+), 32 deletions(-)

diff --git a/test/run_translated_c.zig b/test/run_translated_c.zig
index 4345625dc1f2d4f89f710ae530db9e6df4547532..1687e07f9c3a917fb584878314389ad1c3305a60 100644
--- a/test/run_translated_c.zig
+++ b/test/run_translated_c.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const tests = @import("tests.zig");
 const nl = std.cstr.line_sep;
 
@@ -1683,38 +1684,41 @@ pub fn addCases(cases: *tests.RunTranslatedCContext) void {
     // TODO: add isnan check for long double once bitfield support is added
     //       (needed for x86_64-windows-gnu)
     // TODO: add isinf check for long double once std.math.isInf supports c_longdouble
-    cases.add("NAN and INFINITY",
-        \\#include <math.h>
-        \\#include <stdint.h>
-        \\#include <stdlib.h>
-        \\union uf { uint32_t u; float f; };
-        \\#define CHECK_NAN(STR, VAL) { \
-        \\    union uf unpack = {.f = __builtin_nanf(STR)}; \
-        \\    if (!isnan(unpack.f)) abort(); \
-        \\    if (unpack.u != VAL) abort(); \
-        \\}
-        \\int main(void) {
-        \\    float f_nan = NAN;
-        \\    if (!isnan(f_nan)) abort();
-        \\    double d_nan = NAN;
-        \\    if (!isnan(d_nan)) abort();
-        \\    CHECK_NAN("0", 0x7FC00000);
-        \\    CHECK_NAN("", 0x7FC00000);
-        \\    CHECK_NAN("1", 0x7FC00001);
-        \\    CHECK_NAN("0x7FC00000", 0x7FC00000);
-        \\    CHECK_NAN("0x7FC0000F", 0x7FC0000F);
-        \\    CHECK_NAN("0x7FC000F0", 0x7FC000F0);
-        \\    CHECK_NAN("0x7FC00F00", 0x7FC00F00);
-        \\    CHECK_NAN("0x7FC0F000", 0x7FC0F000);
-        \\    CHECK_NAN("0x7FCF0000", 0x7FCF0000);
-        \\    CHECK_NAN("0xFFFFFFFF", 0x7FFFFFFF);
-        \\    float f_inf = INFINITY;
-        \\    if (!isinf(f_inf)) abort();
-        \\    double d_inf = INFINITY;
-        \\    if (!isinf(d_inf)) abort();
-        \\    return 0;
-        \\}
-    , "");
+    // TODO https://github.com/ziglang/zig/issues/12630
+    if (!(builtin.zig_backend == .stage2_llvm and builtin.target.os.tag == .windows)) {
+        cases.add("NAN and INFINITY",
+            \\#include <math.h>
+            \\#include <stdint.h>
+            \\#include <stdlib.h>
+            \\union uf { uint32_t u; float f; };
+            \\#define CHECK_NAN(STR, VAL) { \
+            \\    union uf unpack = {.f = __builtin_nanf(STR)}; \
+            \\    if (!isnan(unpack.f)) abort(); \
+            \\    if (unpack.u != VAL) abort(); \
+            \\}
+            \\int main(void) {
+            \\    float f_nan = NAN;
+            \\    if (!isnan(f_nan)) abort();
+            \\    double d_nan = NAN;
+            \\    if (!isnan(d_nan)) abort();
+            \\    CHECK_NAN("0", 0x7FC00000);
+            \\    CHECK_NAN("", 0x7FC00000);
+            \\    CHECK_NAN("1", 0x7FC00001);
+            \\    CHECK_NAN("0x7FC00000", 0x7FC00000);
+            \\    CHECK_NAN("0x7FC0000F", 0x7FC0000F);
+            \\    CHECK_NAN("0x7FC000F0", 0x7FC000F0);
+            \\    CHECK_NAN("0x7FC00F00", 0x7FC00F00);
+            \\    CHECK_NAN("0x7FC0F000", 0x7FC0F000);
+            \\    CHECK_NAN("0x7FCF0000", 0x7FCF0000);
+            \\    CHECK_NAN("0xFFFFFFFF", 0x7FFFFFFF);
+            \\    float f_inf = INFINITY;
+            \\    if (!isinf(f_inf)) abort();
+            \\    double d_inf = INFINITY;
+            \\    if (!isinf(d_inf)) abort();
+            \\    return 0;
+            \\}
+        , "");
+    }
 
     cases.add("signed array subscript. Issue #8556",
         \\#include <stdint.h>
-- 
2.54.0


From d5233ee85ce13cba3dd03e4c0c938cee193b9b19 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Thu, 25 Aug 2022 12:38:56 +0200
Subject: [PATCH 265/290] add ability to pass force undefined symbols to the
 linker

This commit enables `-u <symbol>` for ELF and `-include:<symbol>` for
COFF linkers for use internally. This means we do not expose these
flags to the users just yet, however, we make use of them internally
whenever required. One such use case is forcing inclusion of
`_tls_index` when linking for Windows with mingw and LTO and dead
code stripping enabled. This ensures we add `_tls_index` to the symbol
resolver as an undefined symbol and force the linker to include an atom
that provides it marking it a dead-code-stripping root - meaning it will
not be garbage collected by the linker no matter what.
---
 src/Compilation.zig | 8 +++++---
 src/link.zig        | 6 ++++++
 src/link/Coff.zig   | 4 ++++
 src/link/Elf.zig    | 5 +++++
 src/mingw.zig       | 6 ------
 5 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 03d7962ccc771bb412f0d1c72fe7e5074fb354f5..353a2f1ca3492899f3d724092b45d869603f64eb 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -1165,9 +1165,6 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
                 break :blk false;
             } else if (options.c_source_files.len == 0) {
                 break :blk false;
-            } else if (options.target.os.tag == .windows and link_libcpp) {
-                // https://github.com/ziglang/zig/issues/8531
-                break :blk false;
             } else if (options.target.cpu.arch.isRISCV()) {
                 // Clang and LLVM currently don't support RISC-V target-abi for LTO.
                 // Compiling with LTO may fail or produce undesired results.
@@ -1793,6 +1790,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             .headerpad_size = options.headerpad_size,
             .headerpad_max_install_names = options.headerpad_max_install_names,
             .dead_strip_dylibs = options.dead_strip_dylibs,
+            .force_undefined_symbols = .{},
         });
         errdefer bin_file.destroy();
         comp.* = .{
@@ -1943,6 +1941,10 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             for (mingw.always_link_libs) |name| {
                 try comp.bin_file.options.system_libs.put(comp.gpa, name, .{});
             }
+
+            // LLD might drop some symbols as unused during LTO and GCing, therefore,
+            // we force mark them for resolution here.
+            try comp.bin_file.options.force_undefined_symbols.put(comp.gpa, "_tls_index", {});
         }
         // Generate Windows import libs.
         if (target.os.tag == .windows) {
diff --git a/src/link.zig b/src/link.zig
index a85969d61eb7bf6d9f30f79c4caabe00e2dc1737..b46ea51013b7957684bf8d9d8e650dbac0d2fce9 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -175,6 +175,12 @@ pub const Options = struct {
     lib_dirs: []const []const u8,
     rpath_list: []const []const u8,
 
+    /// List of symbols forced as undefined in the symbol table
+    /// thus forcing their resolution by the linker.
+    /// Corresponds to `-u <symbol>` for ELF and `/include:<symbol>` for COFF/PE.
+    /// TODO add handling for MachO.
+    force_undefined_symbols: std.StringArrayHashMapUnmanaged(void),
+
     version: ?std.builtin.Version,
     compatibility_version: ?std.builtin.Version,
     libc_installation: ?*const LibCInstallation,
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index 6536fbd1ace38753f65630f0f07bd7f436ed04f0..c30544d3b7c7296dfdbf86c192fb5707c9b2f11f 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -1133,6 +1133,10 @@ fn linkWithLLD(self: *Coff, comp: *Compilation, prog_node: *std.Progress.Node) !
             }
         }
 
+        for (self.base.options.force_undefined_symbols.keys()) |symbol| {
+            try argv.append(try allocPrint(arena, "-INCLUDE:{s}", .{symbol}));
+        }
+
         if (is_dyn_lib) {
             try argv.append("-DLL");
         }
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index ade4f62f91e21e2a1e8fd366316f9f6496089418..293771dd2a8fcc83fc889f66b83e7b0729788a4b 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -1448,6 +1448,11 @@ fn linkWithLLD(self: *Elf, comp: *Compilation, prog_node: *std.Progress.Node) !v
             try argv.append(entry);
         }
 
+        for (self.base.options.force_undefined_symbols.keys()) |symbol| {
+            try argv.append("-u");
+            try argv.append(symbol);
+        }
+
         switch (self.base.options.hash_style) {
             .gnu => try argv.append("--hash-style=gnu"),
             .sysv => try argv.append("--hash-style=sysv"),
diff --git a/src/mingw.zig b/src/mingw.zig
index e99a1af8fc6b5a72b5b4693fea629929275916df..b50cc4b00994b102853e3d1f4c7c128f53e95bff 100644
--- a/src/mingw.zig
+++ b/src/mingw.zig
@@ -93,12 +93,6 @@ pub fn buildCRTFile(comp: *Compilation, crt_file: CRTFile) !void {
                     "-D_WIN32_WINNT=0x0f00",
                     "-D__MSVCRT_VERSION__=0x700",
                 });
-                if (std.mem.eql(u8, dep, "tlssup.c") and comp.bin_file.options.lto) {
-                    // LLD will incorrectly drop the `_tls_index` symbol. Here we work
-                    // around it by not using LTO for this one file.
-                    // https://github.com/ziglang/zig/issues/8531
-                    try args.append("-fno-lto");
-                }
                 c_source_files[i] = .{
                     .src_path = try comp.zig_lib_directory.join(arena, &[_][]const u8{
                         "libc", "mingw", "crt", dep,
-- 
2.54.0


From 9d231c4991ec1e33c3f4a96e5941848705ef5050 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 25 Aug 2022 15:23:01 -0700
Subject: [PATCH 266/290] CI: drone: reduce duration of the bottleneck

Empirically, the ReleaseSmall std lib tsets take about 55 minutes on the
CI, and is the bottleneck causing timeouts. So this commit disables full
coverage in favor of running a smaller set of ReleaseSmall std lib tests.
---
 ci/drone/test_linux_std_ReleaseSmall | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/ci/drone/test_linux_std_ReleaseSmall b/ci/drone/test_linux_std_ReleaseSmall
index 9a5975ffe571c4dd0433e9e054557b243651d68e..6271a8b15d5d91d1f0cd39fb46dd1eacacf733a0 100755
--- a/ci/drone/test_linux_std_ReleaseSmall
+++ b/ci/drone/test_linux_std_ReleaseSmall
@@ -2,4 +2,10 @@
 
 . ./ci/drone/linux_script_base
 
-./build/zig build test-std -Dskip-debug -Dskip-release-safe -Dskip-release-fast -Dskip-non-native
+# Empirically, this takes about 55 minutes on the CI, and is the bottleneck
+# causing timeouts. So this is disabled in favor of running a smaller set
+# of ReleaseSmall std lib tests.
+# ./build/zig build test-std -Dskip-debug -Dskip-release-safe -Dskip-release-fast -Dskip-non-native
+
+./build/zig test lib/std/std.zig -OReleaseSmall
+./build/zig test lib/std/std.zig -OReleaseSmall -lc
-- 
2.54.0


From d2ad8afff4c404f6e1a566cce3fa6e7f768503e5 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 25 Aug 2022 16:10:36 -0700
Subject: [PATCH 267/290] LLVM: fix missing alignment on wrapping instructions

Previously, when lowering AIR instructions `wrap_errunion_payload`,
`wrap_errunion_err`, and `wrap_optional`, the LLVM backend would create
an alloca instruction to store the result, but did not set the alignment
on it. This caused UB which went undetected for a long time until we
started enabling the stack protector.

Closes #12594
Unblocks #12508
Inspires #12634

Tests passed locally:
 * test-behavior
 * test-cases
---
 src/codegen/llvm.zig       | 10 +++++++---
 test/behavior/error.zig    | 16 ++++++++++++++++
 test/behavior/optional.zig | 16 ++++++++++++++++
 3 files changed, 39 insertions(+), 3 deletions(-)

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index d872057beb6c0ff55d28e37500515eab49fec5c6..d1c68b430cd935cd6566374fe72ad7536345ee70 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -6188,7 +6188,9 @@ pub const FuncGen = struct {
         }
         const llvm_optional_ty = try self.dg.lowerType(optional_ty);
         if (isByRef(optional_ty)) {
+            const target = self.dg.module.getTarget();
             const optional_ptr = self.buildAlloca(llvm_optional_ty);
+            optional_ptr.setAlignment(optional_ty.abiAlignment(target));
             const payload_ptr = self.builder.buildStructGEP(optional_ptr, 0, "");
             var ptr_ty_payload: Type.Payload.ElemType = .{
                 .base = .{ .tag = .single_mut_pointer },
@@ -6208,20 +6210,21 @@ pub const FuncGen = struct {
         if (self.liveness.isUnused(inst)) return null;
 
         const ty_op = self.air.instructions.items(.data)[inst].ty_op;
-        const inst_ty = self.air.typeOfIndex(inst);
+        const err_un_ty = self.air.typeOfIndex(inst);
         const operand = try self.resolveInst(ty_op.operand);
         const payload_ty = self.air.typeOf(ty_op.operand);
         if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
             return operand;
         }
         const ok_err_code = (try self.dg.lowerType(Type.anyerror)).constNull();
-        const err_un_llvm_ty = try self.dg.lowerType(inst_ty);
+        const err_un_llvm_ty = try self.dg.lowerType(err_un_ty);
 
         const target = self.dg.module.getTarget();
         const payload_offset = errUnionPayloadOffset(payload_ty, target);
         const error_offset = errUnionErrorOffset(payload_ty, target);
-        if (isByRef(inst_ty)) {
+        if (isByRef(err_un_ty)) {
             const result_ptr = self.buildAlloca(err_un_llvm_ty);
+            result_ptr.setAlignment(err_un_ty.abiAlignment(target));
             const err_ptr = self.builder.buildStructGEP(result_ptr, error_offset, "");
             const store_inst = self.builder.buildStore(ok_err_code, err_ptr);
             store_inst.setAlignment(Type.anyerror.abiAlignment(target));
@@ -6256,6 +6259,7 @@ pub const FuncGen = struct {
         const error_offset = errUnionErrorOffset(payload_ty, target);
         if (isByRef(err_un_ty)) {
             const result_ptr = self.buildAlloca(err_un_llvm_ty);
+            result_ptr.setAlignment(err_un_ty.abiAlignment(target));
             const err_ptr = self.builder.buildStructGEP(result_ptr, error_offset, "");
             const store_inst = self.builder.buildStore(operand, err_ptr);
             store_inst.setAlignment(Type.anyerror.abiAlignment(target));
diff --git a/test/behavior/error.zig b/test/behavior/error.zig
index b355c858190e17dfa601c7dc44fb61fbf2d83c39..684b01a797dfa50401e6c7fc5bbc0add60db66da 100644
--- a/test/behavior/error.zig
+++ b/test/behavior/error.zig
@@ -796,3 +796,19 @@ test "error union of noreturn used with catch" {
     const err = NoReturn.testCatch();
     try expect(err == error.OtherFailure);
 }
+
+test "alignment of wrapping an error union payload" {
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+
+    const S = struct {
+        const I = extern struct { x: i128 };
+
+        fn foo() anyerror!I {
+            var i: I = .{ .x = 1234 };
+            return i;
+        }
+    };
+    try expect((S.foo() catch unreachable).x == 1234);
+}
diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig
index 28261daf1f97242558522dad2468e6f400260c44..eb693147e6b5a18110077a55020a123da99d44cb 100644
--- a/test/behavior/optional.zig
+++ b/test/behavior/optional.zig
@@ -412,3 +412,19 @@ test "orelse on C pointer" {
     const d = foo orelse @compileError("bad");
     try expectEqual([*c]const u8, @TypeOf(d));
 }
+
+test "alignment of wrapping an optional payload" {
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+
+    const S = struct {
+        const I = extern struct { x: i128 };
+
+        fn foo() ?I {
+            var i: I = .{ .x = 1234 };
+            return i;
+        }
+    };
+    try expect(S.foo().?.x == 1234);
+}
-- 
2.54.0


From d6bb9af18da6f1e6d4e62a111c69a58c91b21a7e Mon Sep 17 00:00:00 2001
From: David Gonzalez Martin <davidgm94.work@protonmail.com>
Date: Thu, 25 Aug 2022 21:17:20 +0200
Subject: [PATCH 268/290] stage2: Reference to void constants Closes #7567

---
 test/behavior/void.zig | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/test/behavior/void.zig b/test/behavior/void.zig
index 66b969d0bf20746697708bc3473eb843938e74c2..4cce1cf71b6c2b8bd9b404945fb12e807c4560f9 100644
--- a/test/behavior/void.zig
+++ b/test/behavior/void.zig
@@ -45,3 +45,9 @@ test "void array as a local variable initializer" {
     var x = [_]void{{}} ** 1004;
     _ = x[0];
 }
+
+const void_constant = {};
+test "reference to void constants" {
+    var a = void_constant;
+    _ = a;
+}
-- 
2.54.0


From bcaa9df5b42747577dcb529a99f6da6d69e09309 Mon Sep 17 00:00:00 2001
From: Evan Haas <evan@lagerdata.com>
Date: Sun, 21 Aug 2022 10:58:08 -0700
Subject: [PATCH 269/290] translate-c: Don't add self-defined macros to global
 name table

A self-defined macro is one of the form `#define FOO FOO`

Those types of macros have never been translated; this change will cause
any macros which refer to them to be translated as `@compileError` instead
of referring to a non-existent identifier.

Closes #12471
---
 src/translate_c.zig                  | 46 ++++++++++++++++++++++------
 test/standalone.zig                  |  1 +
 test/standalone/issue_12471/main.zig | 12 ++++++++
 3 files changed, 50 insertions(+), 9 deletions(-)
 create mode 100644 test/standalone/issue_12471/main.zig

diff --git a/src/translate_c.zig b/src/translate_c.zig
index 41b87ade21199a4d8c12b3252fe4c92393c3c1bb..b0fae81475235ece607e79141bfbbc85915b8e87 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -439,6 +439,24 @@ pub fn translate(
     return ast.render(gpa, context.global_scope.nodes.items);
 }
 
+/// Determines whether macro is of the form: `#define FOO FOO` (Possibly with trailing tokens)
+/// Macros of this form will not be translated.
+fn isSelfDefinedMacro(unit: *const clang.ASTUnit, c: *const Context, macro: *const clang.MacroDefinitionRecord) bool {
+    const source = getMacroText(unit, c, macro);
+    var tokenizer = std.c.Tokenizer{
+        .buffer = source,
+    };
+    const name_tok = tokenizer.next();
+    const name = source[name_tok.start..name_tok.end];
+
+    const first_tok = tokenizer.next();
+    // We do not just check for `.Identifier` below because keyword tokens are preferentially matched first by
+    // the tokenizer.
+    // In other words we would miss `#define inline inline` (`inline` is a valid c89 identifier)
+    if (first_tok.id == .Eof) return false;
+    return mem.eql(u8, name, source[first_tok.start..first_tok.end]);
+}
+
 fn prepopulateGlobalNameTable(ast_unit: *clang.ASTUnit, c: *Context) !void {
     if (!ast_unit.visitLocalTopLevelDecls(c, declVisitorNamesOnlyC)) {
         return error.OutOfMemory;
@@ -455,7 +473,10 @@ fn prepopulateGlobalNameTable(ast_unit: *clang.ASTUnit, c: *Context) !void {
                 const macro = @ptrCast(*clang.MacroDefinitionRecord, entity);
                 const raw_name = macro.getName_getNameStart();
                 const name = try c.str(raw_name);
-                try c.global_names.put(c.gpa, name, {});
+
+                if (!isSelfDefinedMacro(ast_unit, c, macro)) {
+                    try c.global_names.put(c.gpa, name, {});
+                }
             },
             else => {},
         }
@@ -5446,6 +5467,16 @@ fn tokenizeMacro(source: []const u8, tok_list: *std.ArrayList(CToken)) Error!voi
     }
 }
 
+fn getMacroText(unit: *const clang.ASTUnit, c: *const Context, macro: *const clang.MacroDefinitionRecord) []const u8 {
+    const begin_loc = macro.getSourceRange_getBegin();
+    const end_loc = clang.Lexer.getLocForEndOfToken(macro.getSourceRange_getEnd(), c.source_manager, unit);
+
+    const begin_c = c.source_manager.getCharacterData(begin_loc);
+    const end_c = c.source_manager.getCharacterData(end_loc);
+    const slice_len = @ptrToInt(end_c) - @ptrToInt(begin_c);
+    return begin_c[0..slice_len];
+}
+
 fn transPreprocessorEntities(c: *Context, unit: *clang.ASTUnit) Error!void {
     // TODO if we see #undef, delete it from the table
     var it = unit.getLocalPreprocessingEntities_begin();
@@ -5462,22 +5493,18 @@ fn transPreprocessorEntities(c: *Context, unit: *clang.ASTUnit) Error!void {
                 const macro = @ptrCast(*clang.MacroDefinitionRecord, entity);
                 const raw_name = macro.getName_getNameStart();
                 const begin_loc = macro.getSourceRange_getBegin();
-                const end_loc = clang.Lexer.getLocForEndOfToken(macro.getSourceRange_getEnd(), c.source_manager, unit);
 
                 const name = try c.str(raw_name);
                 if (scope.containsNow(name)) {
                     continue;
                 }
 
-                const begin_c = c.source_manager.getCharacterData(begin_loc);
-                const end_c = c.source_manager.getCharacterData(end_loc);
-                const slice_len = @ptrToInt(end_c) - @ptrToInt(begin_c);
-                const slice = begin_c[0..slice_len];
+                const source = getMacroText(unit, c, macro);
 
-                try tokenizeMacro(slice, &tok_list);
+                try tokenizeMacro(source, &tok_list);
 
                 var macro_ctx = MacroCtx{
-                    .source = slice,
+                    .source = source,
                     .list = tok_list.items,
                     .name = name,
                     .loc = begin_loc,
@@ -5490,7 +5517,8 @@ fn transPreprocessorEntities(c: *Context, unit: *clang.ASTUnit) Error!void {
                         // if it equals itself, ignore. for example, from stdio.h:
                         // #define stdin stdin
                         const tok = macro_ctx.list[1];
-                        if (mem.eql(u8, name, slice[tok.start..tok.end])) {
+                        if (mem.eql(u8, name, source[tok.start..tok.end])) {
+                            assert(!c.global_names.contains(source[tok.start..tok.end]));
                             continue;
                         }
                     },
diff --git a/test/standalone.zig b/test/standalone.zig
index 2a7902dfb25835c9e3f81d7df9df628830dfacae..bfd683ec4c5b7ac68f4842e1073ef3ff8b326fa7 100644
--- a/test/standalone.zig
+++ b/test/standalone.zig
@@ -9,6 +9,7 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
     if (builtin.zig_backend == .stage1) { // https://github.com/ziglang/zig/issues/6025
         cases.add("test/standalone/issue_9693/main.zig");
     }
+    cases.add("test/standalone/issue_12471/main.zig");
     cases.add("test/standalone/guess_number/main.zig");
     cases.add("test/standalone/main_return_error/error_u8.zig");
     cases.add("test/standalone/main_return_error/error_u8_non_zero.zig");
diff --git a/test/standalone/issue_12471/main.zig b/test/standalone/issue_12471/main.zig
new file mode 100644
index 0000000000000000000000000000000000000000..08be1fd4713563e0e6051739aed33630f8c65501
--- /dev/null
+++ b/test/standalone/issue_12471/main.zig
@@ -0,0 +1,12 @@
+const c = @cImport({
+    @cDefine("FOO", "FOO");
+    @cDefine("BAR", "FOO");
+
+    @cDefine("BAZ", "QUX");
+    @cDefine("QUX", "QUX");
+});
+
+pub fn main() u8 {
+    _ = c;
+    return 0;
+}
-- 
2.54.0


From 3fa5415253695001149ad65ae6f2ca8d0fa63565 Mon Sep 17 00:00:00 2001
From: martinhath <martinhath@users.noreply.github.com>
Date: Fri, 26 Aug 2022 10:37:17 +0200
Subject: [PATCH 270/290] Sema: ensure resolveTypeFields is called for optional
 and error union types

We call `sema.resolveTypeFields` in order to get the fields of structs
and unions inserted into their data structures. If it isn't called, it
can happen that the fields of a type is queried before those fields are
inserted into (for instance) `Module.Union.fields`, which would result in
a wrong 'no field named' error.

Fixes: #12486
---
 src/Sema.zig                 |  5 ++--
 test/behavior.zig            |  1 +
 test/behavior/bugs/12486.zig | 49 ++++++++++++++++++++++++++++++++++++
 3 files changed, 53 insertions(+), 2 deletions(-)
 create mode 100644 test/behavior/bugs/12486.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index fc2a7f872ad842f6a16acbc45cb39f5ffc6a6cbb..2907999c25abdc03b8b8b0226f7268251e04b758 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -16190,9 +16190,10 @@ fn fieldType(
     field_src: LazySrcLoc,
     ty_src: LazySrcLoc,
 ) CompileError!Air.Inst.Ref {
-    const resolved_ty = try sema.resolveTypeFields(block, ty_src, aggregate_ty);
-    var cur_ty = resolved_ty;
+    var cur_ty = aggregate_ty;
     while (true) {
+        const resolved_ty = try sema.resolveTypeFields(block, ty_src, cur_ty);
+        cur_ty = resolved_ty;
         switch (cur_ty.zigTypeTag()) {
             .Struct => {
                 if (cur_ty.isAnonStruct()) {
diff --git a/test/behavior.zig b/test/behavior.zig
index 12edd6f9a3eb9f5ea9678c66d31bbea16e692efc..8f581f372ef55698201e4c7d330592956c1a915e 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -84,6 +84,7 @@ test {
     _ = @import("behavior/bugs/12003.zig");
     _ = @import("behavior/bugs/12033.zig");
     _ = @import("behavior/bugs/12430.zig");
+    _ = @import("behavior/bugs/12486.zig");
     _ = @import("behavior/byteswap.zig");
     _ = @import("behavior/byval_arg_var.zig");
     _ = @import("behavior/call.zig");
diff --git a/test/behavior/bugs/12486.zig b/test/behavior/bugs/12486.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f0d357efd1a6f77cdd70155bd03c48e9995244c6
--- /dev/null
+++ b/test/behavior/bugs/12486.zig
@@ -0,0 +1,49 @@
+const SomeEnum = union(enum) {
+    EnumVariant: u8,
+};
+
+const SomeStruct = struct {
+    struct_field: u8,
+};
+
+const OptEnum = struct {
+    opt_enum: ?SomeEnum,
+};
+
+const ErrEnum = struct {
+    err_enum: anyerror!SomeEnum,
+};
+
+const OptStruct = struct {
+    opt_struct: ?SomeStruct,
+};
+
+const ErrStruct = struct {
+    err_struct: anyerror!SomeStruct,
+};
+
+test {
+    _ = OptEnum{
+        .opt_enum = .{
+            .EnumVariant = 1,
+        },
+    };
+
+    _ = ErrEnum{
+        .err_enum = .{
+            .EnumVariant = 1,
+        },
+    };
+
+    _ = OptStruct{
+        .opt_struct = .{
+            .struct_field = 1,
+        },
+    };
+
+    _ = ErrStruct{
+        .err_struct = .{
+            .struct_field = 1,
+        },
+    };
+}
-- 
2.54.0


From 9038528187932babc86558ec343511c635446a28 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Motiejus=20Jak=C5=A1tys?= <motiejus@jakstys.lt>
Date: Fri, 19 Aug 2022 09:42:42 +0300
Subject: [PATCH 271/290] copy_file_range: fix zigification of TXTBSY

From `copy_file_range(2)` errors:

    ETXTBSY
           Either fd_in or fd_out refers to an active swap file.

Same error will be used in the upcoming `ioctl_ficlonerange(2)`:

    ETXTBSY
           One of the files is a swap file.  Swap files cannot share storage.
---
 lib/std/os.zig | 4 ++--
 src/link.zig   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/std/os.zig b/lib/std/os.zig
index 24b438a53e65aaa8ee25cef90796a2f8f778c8b1..59f2a2173f279dfb23f2c6ee11bff28b29ce8318 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -6251,7 +6251,7 @@ pub const CopyFileRangeError = error{
     NoSpaceLeft,
     Unseekable,
     PermissionDenied,
-    FileBusy,
+    SwapFile,
 } || PReadError || PWriteError || UnexpectedError;
 
 var has_copy_file_range_syscall = std.atomic.Atomic(bool).init(true);
@@ -6305,7 +6305,7 @@ pub fn copy_file_range(fd_in: fd_t, off_in: u64, fd_out: fd_t, off_out: u64, len
             .NOSPC => return error.NoSpaceLeft,
             .OVERFLOW => return error.Unseekable,
             .PERM => return error.PermissionDenied,
-            .TXTBSY => return error.FileBusy,
+            .TXTBSY => return error.SwapFile,
             // these may not be regular files, try fallback
             .INVAL => {},
             // support for cross-filesystem copy added in Linux 5.3, use fallback
diff --git a/src/link.zig b/src/link.zig
index b46ea51013b7957684bf8d9d8e650dbac0d2fce9..60c6b24640e0f592cc441a7870f263535d56c338 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -426,7 +426,7 @@ pub const File = struct {
         NoSpaceLeft,
         Unseekable,
         PermissionDenied,
-        FileBusy,
+        SwapFile,
         SystemResources,
         OperationAborted,
         BrokenPipe,
-- 
2.54.0


From 02e696096633bc588b0931d4dc5aba4be4cd97f1 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Fri, 26 Aug 2022 14:13:57 +0200
Subject: [PATCH 272/290] coff: do not pull in std.log into coff.zig
 definitions

---
 lib/std/coff.zig          |  5 +--
 test/run_translated_c.zig | 68 ++++++++++++++++++---------------------
 2 files changed, 33 insertions(+), 40 deletions(-)

diff --git a/lib/std/coff.zig b/lib/std/coff.zig
index 45d5d3d79e2a86802a1fa39cebc655f451bedbdc..f9de318e7a6932b005de7f78da244aac437d0ddf 100644
--- a/lib/std/coff.zig
+++ b/lib/std/coff.zig
@@ -841,10 +841,7 @@ pub const Coff = struct {
         if (self.is_image) {
             self.coff_header_offset = coff_header_offset + 4;
             const coff_header = self.getCoffHeader();
-            if (coff_header.size_of_optional_header == 0) {
-                std.log.err("Required PE header missing for image file", .{});
-                return error.MissingPEHeader;
-            }
+            if (coff_header.size_of_optional_header == 0) return error.MissingPEHeader;
         }
 
         // JK: we used to check for architecture here and throw an error if not x86 or derivative.
diff --git a/test/run_translated_c.zig b/test/run_translated_c.zig
index 1687e07f9c3a917fb584878314389ad1c3305a60..4345625dc1f2d4f89f710ae530db9e6df4547532 100644
--- a/test/run_translated_c.zig
+++ b/test/run_translated_c.zig
@@ -1,5 +1,4 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const tests = @import("tests.zig");
 const nl = std.cstr.line_sep;
 
@@ -1684,41 +1683,38 @@ pub fn addCases(cases: *tests.RunTranslatedCContext) void {
     // TODO: add isnan check for long double once bitfield support is added
     //       (needed for x86_64-windows-gnu)
     // TODO: add isinf check for long double once std.math.isInf supports c_longdouble
-    // TODO https://github.com/ziglang/zig/issues/12630
-    if (!(builtin.zig_backend == .stage2_llvm and builtin.target.os.tag == .windows)) {
-        cases.add("NAN and INFINITY",
-            \\#include <math.h>
-            \\#include <stdint.h>
-            \\#include <stdlib.h>
-            \\union uf { uint32_t u; float f; };
-            \\#define CHECK_NAN(STR, VAL) { \
-            \\    union uf unpack = {.f = __builtin_nanf(STR)}; \
-            \\    if (!isnan(unpack.f)) abort(); \
-            \\    if (unpack.u != VAL) abort(); \
-            \\}
-            \\int main(void) {
-            \\    float f_nan = NAN;
-            \\    if (!isnan(f_nan)) abort();
-            \\    double d_nan = NAN;
-            \\    if (!isnan(d_nan)) abort();
-            \\    CHECK_NAN("0", 0x7FC00000);
-            \\    CHECK_NAN("", 0x7FC00000);
-            \\    CHECK_NAN("1", 0x7FC00001);
-            \\    CHECK_NAN("0x7FC00000", 0x7FC00000);
-            \\    CHECK_NAN("0x7FC0000F", 0x7FC0000F);
-            \\    CHECK_NAN("0x7FC000F0", 0x7FC000F0);
-            \\    CHECK_NAN("0x7FC00F00", 0x7FC00F00);
-            \\    CHECK_NAN("0x7FC0F000", 0x7FC0F000);
-            \\    CHECK_NAN("0x7FCF0000", 0x7FCF0000);
-            \\    CHECK_NAN("0xFFFFFFFF", 0x7FFFFFFF);
-            \\    float f_inf = INFINITY;
-            \\    if (!isinf(f_inf)) abort();
-            \\    double d_inf = INFINITY;
-            \\    if (!isinf(d_inf)) abort();
-            \\    return 0;
-            \\}
-        , "");
-    }
+    cases.add("NAN and INFINITY",
+        \\#include <math.h>
+        \\#include <stdint.h>
+        \\#include <stdlib.h>
+        \\union uf { uint32_t u; float f; };
+        \\#define CHECK_NAN(STR, VAL) { \
+        \\    union uf unpack = {.f = __builtin_nanf(STR)}; \
+        \\    if (!isnan(unpack.f)) abort(); \
+        \\    if (unpack.u != VAL) abort(); \
+        \\}
+        \\int main(void) {
+        \\    float f_nan = NAN;
+        \\    if (!isnan(f_nan)) abort();
+        \\    double d_nan = NAN;
+        \\    if (!isnan(d_nan)) abort();
+        \\    CHECK_NAN("0", 0x7FC00000);
+        \\    CHECK_NAN("", 0x7FC00000);
+        \\    CHECK_NAN("1", 0x7FC00001);
+        \\    CHECK_NAN("0x7FC00000", 0x7FC00000);
+        \\    CHECK_NAN("0x7FC0000F", 0x7FC0000F);
+        \\    CHECK_NAN("0x7FC000F0", 0x7FC000F0);
+        \\    CHECK_NAN("0x7FC00F00", 0x7FC00F00);
+        \\    CHECK_NAN("0x7FC0F000", 0x7FC0F000);
+        \\    CHECK_NAN("0x7FCF0000", 0x7FCF0000);
+        \\    CHECK_NAN("0xFFFFFFFF", 0x7FFFFFFF);
+        \\    float f_inf = INFINITY;
+        \\    if (!isinf(f_inf)) abort();
+        \\    double d_inf = INFINITY;
+        \\    if (!isinf(d_inf)) abort();
+        \\    return 0;
+        \\}
+    , "");
 
     cases.add("signed array subscript. Issue #8556",
         \\#include <stdint.h>
-- 
2.54.0


From 8bcb962ada2ea5cfeeff303e1063937ee13af6ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Marie?= <semarie@online.fr>
Date: Tue, 23 Aug 2022 10:29:46 +0000
Subject: [PATCH 273/290] openbsd: fix sigcontext struct and avoid defining
 fxsave64

`sc_fpstate` member of `struct sigcontext` is a `struct fxsave64 *`.
use *anyopaque to represent it.

avoid to defining `fxsave64` as it is a packed struct with some arrays.
---
 lib/std/c/openbsd.zig | 17 +----------------
 1 file changed, 1 insertion(+), 16 deletions(-)

diff --git a/lib/std/c/openbsd.zig b/lib/std/c/openbsd.zig
index 5c259bc41ae3c929cda4d4f56c9591dca48f218c..ddcb24ffd349323bee44c4abdc770fc2e758e219 100644
--- a/lib/std/c/openbsd.zig
+++ b/lib/std/c/openbsd.zig
@@ -1119,26 +1119,11 @@ pub usingnamespace switch (builtin.cpu.arch) {
             sc_rsp: c_long,
             sc_ss: c_long,
 
-            sc_fpstate: fxsave64,
+            sc_fpstate: *anyopaque, // struct fxsave64 *
             __sc_unused: c_int,
             sc_mask: c_int,
             sc_cookie: c_long,
         };
-
-        pub const fxsave64 = packed struct {
-            fx_fcw: u16,
-            fx_fsw: u16,
-            fx_ftw: u8,
-            fx_unused1: u8,
-            fx_fop: u16,
-            fx_rip: u64,
-            fx_rdp: u64,
-            fx_mxcsr: u32,
-            fx_mxcsr_mask: u32,
-            fx_st: [8][2]u64,
-            fx_xmm: [16][2]u64,
-            fx_unused3: [96]u8,
-        };
     },
     else => struct {},
 };
-- 
2.54.0


From da95da438ed5c934a9f42811651f5ffa524e48a8 Mon Sep 17 00:00:00 2001
From: David Gonzalez Martin <davidgm94.work@protonmail.com>
Date: Fri, 26 Aug 2022 12:25:02 +0200
Subject: [PATCH 274/290] Add behavior test coverage for nested packed struct
 field access Closes #3091

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

diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index 540914bd259722d27a0ec5db85c233ed184fe4a7..9bc1c1f8249244322fdc5b01a939cdaccad6f36c 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -446,3 +446,121 @@ test "optional pointer in packed struct" {
     const x = T{ .ptr = &n };
     try expect(x.ptr.? == &n);
 }
+
+test "nested packed struct field access test" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    //
+    const Vec2 = packed struct {
+        x: f32,
+        y: f32,
+    };
+
+    const Vec3 = packed struct {
+        x: f32,
+        y: f32,
+        z: f32,
+    };
+
+    const NestedVec2 = packed struct {
+        nested: Vec2,
+    };
+
+    const NestedVec3 = packed struct {
+        nested: Vec3,
+    };
+
+    const vec2 = Vec2{
+        .x = 1.0,
+        .y = 2.0,
+    };
+
+    try std.testing.expectEqual(vec2.x, 1.0);
+    try std.testing.expectEqual(vec2.y, 2.0);
+
+    var vec2_o: Vec2 = undefined;
+    const vec2_o_ptr: *Vec2 = &vec2_o;
+    vec2_o_ptr.* = vec2;
+
+    try std.testing.expectEqual(vec2_o.x, 1.0);
+    try std.testing.expectEqual(vec2_o.y, 2.0);
+
+    const nested_vec2 = NestedVec2{
+        .nested = Vec2{
+            .x = 1.0,
+            .y = 2.0,
+        },
+    };
+
+    try std.testing.expectEqual(nested_vec2.nested.x, 1.0);
+    try std.testing.expectEqual(nested_vec2.nested.y, 2.0);
+
+    var nested_o: NestedVec2 = undefined;
+    const nested_o_ptr: *NestedVec2 = &nested_o;
+    nested_o_ptr.* = nested_vec2;
+
+    try std.testing.expectEqual(nested_o.nested.x, 1.0);
+    try std.testing.expectEqual(nested_o.nested.y, 2.0);
+
+    const vec3 = Vec3{
+        .x = 1.0,
+        .y = 2.0,
+        .z = 3.0,
+    };
+
+    try std.testing.expectEqual(vec3.x, 1.0);
+    try std.testing.expectEqual(vec3.y, 2.0);
+    try std.testing.expectEqual(vec3.z, 3.0);
+
+    var vec3_o: Vec3 = undefined;
+    const vec3_o_ptr: *Vec3 = &vec3_o;
+    vec3_o_ptr.* = vec3;
+
+    try std.testing.expectEqual(vec3_o.x, 1.0);
+    try std.testing.expectEqual(vec3_o.y, 2.0);
+    try std.testing.expectEqual(vec3_o.z, 3.0);
+
+    const nested_vec3 = NestedVec3{
+        .nested = Vec3{
+            .x = 1.0,
+            .y = 2.0,
+            .z = 3.0,
+        },
+    };
+
+    try std.testing.expectEqual(nested_vec3.nested.x, 1.0);
+    try std.testing.expectEqual(nested_vec3.nested.y, 2.0);
+    try std.testing.expectEqual(nested_vec3.nested.z, 3.0);
+
+    var nested_vec3_o: NestedVec3 = undefined;
+    const nested_vec3_o_ptr: *NestedVec3 = &nested_vec3_o;
+    nested_vec3_o_ptr.* = nested_vec3;
+
+    try std.testing.expectEqual(nested_vec3_o.nested.x, 1.0);
+    try std.testing.expectEqual(nested_vec3_o.nested.y, 2.0);
+    try std.testing.expectEqual(nested_vec3_o.nested.z, 3.0);
+
+    const hld = packed struct {
+        c: u64,
+        d: u32,
+    };
+
+    const mld = packed struct {
+        h: u64,
+        i: u64,
+    };
+
+    const a = packed struct {
+        b: hld,
+        g: mld,
+    };
+
+    var arg = a{ .b = hld{ .c = 1, .d = 2 }, .g = mld{ .h = 6, .i = 8 } };
+    try std.testing.expect(arg.b.c == 1);
+    try std.testing.expect(arg.b.d == 2);
+    try std.testing.expect(arg.g.h == 6);
+    try std.testing.expect(arg.g.i == 8);
+}
-- 
2.54.0


From ae8d26a6a00a528bdf555689c2a93cb35a3287f2 Mon Sep 17 00:00:00 2001
From: antlilja <liljaanton2001@gmail.com>
Date: Sat, 6 Aug 2022 22:32:00 +0200
Subject: [PATCH 275/290] Sema: add error for non-comptime param in comptime
 func

Adds error for taking a non comptime parameter in a function returning a
comptime-only type but not when that type is dependent on a parameter.

Co-authored-by: Veikka Tuominen <git@vexu.eu>
---
 lib/std/c.zig                                 |  2 +-
 lib/std/elf.zig                               |  4 +-
 lib/std/io/bit_reader.zig                     |  2 +-
 lib/std/io/bit_writer.zig                     |  2 +-
 lib/std/meta.zig                              |  2 +-
 lib/std/multi_array_list.zig                  |  2 +-
 src/Sema.zig                                  | 61 ++++++++++++++-----
 test/behavior/union.zig                       |  2 +-
 .../explain_why_fn_is_called_at_comptime.zig  |  8 +--
 ...on_comptime_param_in_comptime_function.zig | 36 +++++++++++
 10 files changed, 95 insertions(+), 26 deletions(-)
 create mode 100644 test/cases/compile_errors/non_comptime_param_in_comptime_function.zig

diff --git a/lib/std/c.zig b/lib/std/c.zig
index f01f580083e64687f4dda4ef3a23612b5084b5d6..7b018f62d5026b7e228f3408548cd07a015e0711 100644
--- a/lib/std/c.zig
+++ b/lib/std/c.zig
@@ -20,7 +20,7 @@ pub const Tokenizer = tokenizer.Tokenizer;
 /// If linking gnu libc (glibc), the `ok` value will be true if the target
 /// version is greater than or equal to `glibc_version`.
 /// If linking a libc other than these, returns `false`.
-pub fn versionCheck(glibc_version: std.builtin.Version) type {
+pub fn versionCheck(comptime glibc_version: std.builtin.Version) type {
     return struct {
         pub const ok = blk: {
             if (!builtin.link_libc) break :blk false;
diff --git a/lib/std/elf.zig b/lib/std/elf.zig
index cc43e11a7da1cc429d47b873a1eb9d122a79b7c9..4a9b7a498fc476a209e841f4d4c554f95fec7a2b 100644
--- a/lib/std/elf.zig
+++ b/lib/std/elf.zig
@@ -406,7 +406,7 @@ pub const Header = struct {
     }
 };
 
-pub fn ProgramHeaderIterator(ParseSource: anytype) type {
+pub fn ProgramHeaderIterator(comptime ParseSource: anytype) type {
     return struct {
         elf_header: Header,
         parse_source: ParseSource,
@@ -456,7 +456,7 @@ pub fn ProgramHeaderIterator(ParseSource: anytype) type {
     };
 }
 
-pub fn SectionHeaderIterator(ParseSource: anytype) type {
+pub fn SectionHeaderIterator(comptime ParseSource: anytype) type {
     return struct {
         elf_header: Header,
         parse_source: ParseSource,
diff --git a/lib/std/io/bit_reader.zig b/lib/std/io/bit_reader.zig
index 15262f67a2e2036dc0255c9f79d9df81f7f20051..e897850b83fd4d7db967313e58263b70bc26eb0e 100644
--- a/lib/std/io/bit_reader.zig
+++ b/lib/std/io/bit_reader.zig
@@ -7,7 +7,7 @@ const meta = std.meta;
 const math = std.math;
 
 /// Creates a stream which allows for reading bit fields from another stream
-pub fn BitReader(endian: std.builtin.Endian, comptime ReaderType: type) type {
+pub fn BitReader(comptime endian: std.builtin.Endian, comptime ReaderType: type) type {
     return struct {
         forward_reader: ReaderType,
         bit_buffer: u7,
diff --git a/lib/std/io/bit_writer.zig b/lib/std/io/bit_writer.zig
index d71afe5fe52d513e6139a6caa39778021fbe0d2e..0be2e7ab08fcc6b88c7818565cf0895c1cd401b5 100644
--- a/lib/std/io/bit_writer.zig
+++ b/lib/std/io/bit_writer.zig
@@ -7,7 +7,7 @@ const meta = std.meta;
 const math = std.math;
 
 /// Creates a stream which allows for writing bit fields to another stream
-pub fn BitWriter(endian: std.builtin.Endian, comptime WriterType: type) type {
+pub fn BitWriter(comptime endian: std.builtin.Endian, comptime WriterType: type) type {
     return struct {
         forward_writer: WriterType,
         bit_buffer: u8,
diff --git a/lib/std/meta.zig b/lib/std/meta.zig
index 937b1998ff1b5a2b8effa66d9bd5837ba0d10714..7e64eff49fa91efdb6c9a3b23ca43b913e7ef3b4 100644
--- a/lib/std/meta.zig
+++ b/lib/std/meta.zig
@@ -764,7 +764,7 @@ const TagPayloadType = TagPayload;
 
 ///Given a tagged union type, and an enum, return the type of the union
 /// field corresponding to the enum tag.
-pub fn TagPayload(comptime U: type, tag: Tag(U)) type {
+pub fn TagPayload(comptime U: type, comptime tag: Tag(U)) type {
     comptime debug.assert(trait.is(.Union)(U));
 
     const info = @typeInfo(U).Union;
diff --git a/lib/std/multi_array_list.zig b/lib/std/multi_array_list.zig
index 48dddf636d978fb59ff30a8b9fb98f204896b347..11aec707abd3e597a9f9779f87d2493f0b82507f 100644
--- a/lib/std/multi_array_list.zig
+++ b/lib/std/multi_array_list.zig
@@ -459,7 +459,7 @@ pub fn MultiArrayList(comptime S: type) type {
             return self.bytes[0..capacityInBytes(self.capacity)];
         }
 
-        fn FieldType(field: Field) type {
+        fn FieldType(comptime field: Field) type {
             return meta.fieldInfo(S, field).field_type;
         }
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 2907999c25abdc03b8b8b0226f7268251e04b758..047d3f84c25b1abf2439133eaaabc1f1d9c373b0 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -7816,19 +7816,17 @@ fn funcCommon(
             };
         }
 
-        var is_comptime_ret = false;
-        const ret_poison = if (!is_generic) rp: {
-            if (sema.typeRequiresComptime(block, ret_ty_src, bare_return_type)) |ret_comptime| {
-                is_comptime_ret = ret_comptime;
-                break :rp bare_return_type.tag() == .generic_poison;
-            } else |err| switch (err) {
-                error.GenericPoison => {
-                    is_generic = true;
-                    break :rp true;
-                },
-                else => |e| return e,
-            }
-        } else bare_return_type.tag() == .generic_poison;
+        var ret_ty_requires_comptime = false;
+        const ret_poison = if (sema.typeRequiresComptime(block, ret_ty_src, bare_return_type)) |ret_comptime| rp: {
+            ret_ty_requires_comptime = ret_comptime;
+            break :rp bare_return_type.tag() == .generic_poison;
+        } else |err| switch (err) {
+            error.GenericPoison => rp: {
+                is_generic = true;
+                break :rp true;
+            },
+            else => |e| return e,
+        };
 
         const return_type = if (!inferred_error_set or ret_poison)
             bare_return_type
@@ -7873,6 +7871,41 @@ fn funcCommon(
             return sema.failWithOwnedErrorMsg(msg);
         }
 
+        // If the return type is comptime only but not dependent on parameters then all parameter types also need to be comptime
+        if (!sema.is_generic_instantiation and has_body and ret_ty_requires_comptime) comptime_check: {
+            for (block.params.items) |param| {
+                if (!param.is_comptime) break;
+            } else break :comptime_check;
+
+            const msg = try sema.errMsg(
+                block,
+                ret_ty_src,
+                "function with comptime only return type '{}' requires all parameters to be comptime",
+                .{return_type.fmt(sema.mod)},
+            );
+            try sema.explainWhyTypeIsComptime(block, ret_ty_src, msg, ret_ty_src.toSrcLoc(sema.owner_decl), return_type);
+
+            const tags = sema.code.instructions.items(.tag);
+            const data = sema.code.instructions.items(.data);
+            const param_body = sema.code.getParamBody(func_inst);
+            for (block.params.items) |param, i| {
+                if (!param.is_comptime) {
+                    const param_index = param_body[i];
+                    const param_src = switch (tags[param_index]) {
+                        .param => data[param_index].pl_tok.src(),
+                        .param_anytype => data[param_index].str_tok.src(),
+                        else => unreachable,
+                    };
+                    if (param.name.len != 0) {
+                        try sema.errNote(block, param_src, msg, "param '{s}' is required to be comptime", .{param.name});
+                    } else {
+                        try sema.errNote(block, param_src, msg, "param is required to be comptime", .{});
+                    }
+                }
+            }
+            return sema.failWithOwnedErrorMsg(msg);
+        }
+
         const arch = sema.mod.getTarget().cpu.arch;
         if (switch (cc_workaround) {
             .Unspecified, .C, .Naked, .Async, .Inline => null,
@@ -7917,7 +7950,7 @@ fn funcCommon(
         }
         if (is_generic and sema.no_partial_func_ty) return error.GenericPoison;
         for (comptime_params) |ct| is_generic = is_generic or ct;
-        is_generic = is_generic or is_comptime_ret;
+        is_generic = is_generic or ret_ty_requires_comptime;
 
         break :fn_ty try Type.Tag.function.create(sema.arena, .{
             .param_types = param_types,
diff --git a/test/behavior/union.zig b/test/behavior/union.zig
index e2078c66df2f7d7fd11c47fad18fc849f58eb4bc..5d6b084be5dbe9da25558433725f85c0c87f2e86 100644
--- a/test/behavior/union.zig
+++ b/test/behavior/union.zig
@@ -745,7 +745,7 @@ fn setAttribute(attr: Attribute) void {
     _ = attr;
 }
 
-fn Setter(attr: Attribute) type {
+fn Setter(comptime attr: Attribute) type {
     return struct {
         fn set() void {
             setAttribute(attr);
diff --git a/test/cases/compile_errors/explain_why_fn_is_called_at_comptime.zig b/test/cases/compile_errors/explain_why_fn_is_called_at_comptime.zig
index 7ec539dcd1afa9b2584c3dca83ea84440c3e5c22..04f64c2303bd0288b854660c45d76078d5f2ee5d 100644
--- a/test/cases/compile_errors/explain_why_fn_is_called_at_comptime.zig
+++ b/test/cases/compile_errors/explain_why_fn_is_called_at_comptime.zig
@@ -4,12 +4,12 @@ const S = struct {
 };
 fn bar() void {}
 
-fn foo(a: u8) S {
-    return .{ .fnPtr = bar, .a = a };
+fn foo(comptime a: *u8) S {
+    return .{ .fnPtr = bar, .a = a.* };
 }
 pub export fn entry() void {
     var a: u8 = 1;
-    _ = foo(a);
+    _ = foo(&a);
 }
 
 // error
@@ -18,6 +18,6 @@ pub export fn entry() void {
 //
 // :12:13: error: unable to resolve comptime value
 // :12:13: note: argument to function being called at comptime must be comptime known
-// :7:15: note: function is being called at comptime because it returns a comptime only type 'tmp.S'
+// :7:25: note: function is being called at comptime because it returns a comptime only type 'tmp.S'
 // :2:12: note: struct requires comptime because of this field
 // :2:12: note: use '*const fn() void' for a function pointer type
diff --git a/test/cases/compile_errors/non_comptime_param_in_comptime_function.zig b/test/cases/compile_errors/non_comptime_param_in_comptime_function.zig
new file mode 100644
index 0000000000000000000000000000000000000000..758166dd7f51e1a06e9945760681316bcba639ed
--- /dev/null
+++ b/test/cases/compile_errors/non_comptime_param_in_comptime_function.zig
@@ -0,0 +1,36 @@
+fn F(val: anytype) type {
+    _ = val;
+    return struct {};
+}
+export fn entry() void {
+    _ = F(void{});
+}
+const S = struct {
+    foo: fn () void,
+};
+fn bar(_: u32) S {
+    return undefined;
+}
+export fn entry1() void {
+    _ = bar();
+}
+// prioritize other return type errors
+fn foo(a: u32) callconv(.C) comptime_int {
+    return a;
+}
+export fn entry2() void {
+    _ = foo(1);
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :1:20: error: function with comptime only return type 'type' requires all parameters to be comptime
+// :1:20: note: types are not available at runtime
+// :1:6: note: param 'val' is required to be comptime
+// :11:16: error: function with comptime only return type 'tmp.S' requires all parameters to be comptime
+// :9:10: note: struct requires comptime because of this field
+// :9:10: note: use '*const fn() void' for a function pointer type
+// :11:8: note: param is required to be comptime
+// :18:29: error: return type 'comptime_int' not allowed in function with calling convention 'C'
-- 
2.54.0


From ee122643872b2a5958233cfeb24172c181d10be6 Mon Sep 17 00:00:00 2001
From: Henrique Dante de Almeida <hdante@gmail.com>
Date: Sat, 27 Aug 2022 11:44:05 -0300
Subject: [PATCH 276/290] docs: Remove mention of type inference on anytype
 struct fields

It was removed from the language.
---
 doc/langref.html.in | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/langref.html.in b/doc/langref.html.in
index 7a540a15f1e4f26eef2328d33138d57109622130..0d10119cb735a0e87f008fde44e5664e1f693e70 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -11793,8 +11793,8 @@ fn readU32Be() u32 {}
             <pre>{#syntax#}anytype{#endsyntax#}</pre>
           </th>
           <td>
-            Function parameters and struct fields can be declared with {#syntax#}anytype{#endsyntax#} in place of the type.
-            The type will be inferred where the function is called or the struct is instantiated.
+            Function parameters can be declared with {#syntax#}anytype{#endsyntax#} in place of the type.
+            The type will be inferred where the function is called.
             <ul>
               <li>See also {#link|Function Parameter Type Inference#}</li>
             </ul>
-- 
2.54.0


From e0103704c5258ef887640df95fa9ccff9c1b331a Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Sat, 27 Aug 2022 22:47:58 +0200
Subject: [PATCH 277/290] autodoc: better line counting for decls

---
 lib/docs/main.js |  16 ++---
 src/Autodoc.zig  | 167 +++++++++++++++++++++++++++++++++--------------
 2 files changed, 123 insertions(+), 60 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 703ae846047c81ecc79006b1324a35bf25a35446..6a3f2620f27d0ca692a35c95e03197848a2f86a1 100644
--- a/lib/docs/main.js
+++ b/lib/docs/main.js
@@ -54,7 +54,6 @@ var zigAnalysis;
   const sourceFileUrlTemplate = "src/{{file}}#L{{line}}"
   const domLangRefLink = document.getElementById("langRefLink");
 
-  let lineCounter = 1;
   let searchTimer = null;
   let searchTrimResults = true;
 
@@ -413,8 +412,7 @@ var zigAnalysis;
     if (curNavSearch !== "") {
       return renderSearch();
     }
-    
-    lineCounter = 1;
+
 
     let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg];
     let pkg = rootPkg;
@@ -445,10 +443,6 @@ var zigAnalysis;
       }
 
       currentType = childDecl;
-      if ("src" in currentType) {
-        const ast_node = zigAnalysis.astNodes[currentType.src];
-        lineCounter += ast_node.line; 
-      }
       curNav.declObjs.push(currentType);
     }
 
@@ -2289,9 +2283,9 @@ var zigAnalysis;
   function renderSourceFileLink(decl) {
     let srcNode = zigAnalysis.astNodes[decl.src];
 
-    return  "<a style=\"float: right;\" href=\"" + 
-      sourceFileUrlTemplate.replace("{{file}}", 
-        zigAnalysis.files[srcNode.file]).replace("{{line}}", lineCounter + srcNode.line) + "\">[src]</a>";
+    return  "<a style=\"float: right;\" href=\"" +
+      sourceFileUrlTemplate.replace("{{file}}",
+        zigAnalysis.files[srcNode.file]).replace("{{line}}", srcNode.line) + "\">[src]</a>";
   }
 
   function renderContainer(container) {
@@ -3290,6 +3284,8 @@ var zigAnalysis;
         break;
       case "s":
         if (domHelpModal.classList.contains("hidden")) {
+          if (ev.target == domSearch) break;
+
           domSearch.focus();
           domSearch.select();
           domDocs.scrollTo(0, 0);
diff --git a/src/Autodoc.zig b/src/Autodoc.zig
index f8560407feb851da4269d65a8acf6ee5a2599fe2..db681157aed66e4fd701dabc45f2b579f745d52c 100644
--- a/src/Autodoc.zig
+++ b/src/Autodoc.zig
@@ -195,10 +195,14 @@ pub fn generateZirData(self: *Autodoc) !void {
         );
     }
 
-    var root_scope = Scope{ .parent = null, .enclosing_type = main_type_index };
+    var root_scope = Scope{
+        .parent = null,
+        .enclosing_type = main_type_index,
+    };
+
     try self.ast_nodes.append(self.arena, .{ .name = "(root)" });
     try self.files.put(self.arena, file, main_type_index);
-    _ = try self.walkInstruction(file, &root_scope, Zir.main_struct_inst, false);
+    _ = try self.walkInstruction(file, &root_scope, 1, Zir.main_struct_inst, false);
 
     if (self.ref_paths_pending_on_decls.count() > 0) {
         @panic("some decl paths were never fully analized (pending on decls)");
@@ -769,6 +773,7 @@ fn walkInstruction(
     self: *Autodoc,
     file: *File,
     parent_scope: *Scope,
+    parent_line: usize,
     inst_index: usize,
     need_type: bool, // true if the caller needs us to provide also a typeRef
 ) AutodocErrors!DocData.WalkResult {
@@ -851,12 +856,16 @@ fn walkInstruction(
 
                 const new_file = self.module.import_table.get(abs_root_src_path).?;
 
-                var root_scope = Scope{ .parent = null, .enclosing_type = main_type_index };
+                var root_scope = Scope{
+                    .parent = null,
+                    .enclosing_type = main_type_index,
+                };
                 try self.ast_nodes.append(self.arena, .{ .name = "(root)" });
                 try self.files.put(self.arena, new_file, main_type_index);
                 return self.walkInstruction(
                     new_file,
                     &root_scope,
+                    1,
                     Zir.main_struct_inst,
                     false,
                 );
@@ -881,13 +890,14 @@ fn walkInstruction(
             return self.walkInstruction(
                 new_file.file,
                 &new_scope,
+                1,
                 Zir.main_struct_inst,
                 need_type,
             );
         },
         .ret_node => {
             const un_node = data[inst_index].un_node;
-            return self.walkRef(file, parent_scope, un_node.operand, false);
+            return self.walkRef(file, parent_scope, parent_line, un_node.operand, false);
         },
         .ret_load => {
             const un_node = data[inst_index].un_node;
@@ -918,7 +928,7 @@ fn walkInstruction(
             }
 
             if (result_ref) |rr| {
-                return self.walkRef(file, parent_scope, rr, need_type);
+                return self.walkRef(file, parent_scope, parent_line, rr, need_type);
             }
 
             return DocData.WalkResult{
@@ -927,11 +937,11 @@ fn walkInstruction(
         },
         .closure_get => {
             const inst_node = data[inst_index].inst_node;
-            return try self.walkInstruction(file, parent_scope, inst_node.inst, need_type);
+            return try self.walkInstruction(file, parent_scope, parent_line, inst_node.inst, need_type);
         },
         .closure_capture => {
             const un_tok = data[inst_index].un_tok;
-            return try self.walkRef(file, parent_scope, un_tok.operand, need_type);
+            return try self.walkRef(file, parent_scope, parent_line, un_tok.operand, need_type);
         },
         .cmpxchg_strong, .cmpxchg_weak => {
             const pl_node = data[inst_index].pl_node;
@@ -946,6 +956,7 @@ fn walkInstruction(
             var ptr: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.ptr,
                 false,
             );
@@ -955,6 +966,7 @@ fn walkInstruction(
             var expected_value: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.expected_value,
                 false,
             );
@@ -964,6 +976,7 @@ fn walkInstruction(
             var new_value: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.new_value,
                 false,
             );
@@ -973,6 +986,7 @@ fn walkInstruction(
             var success_order: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.success_order,
                 false,
             );
@@ -982,6 +996,7 @@ fn walkInstruction(
             var failure_order: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.failure_order,
                 false,
             );
@@ -1035,6 +1050,7 @@ fn walkInstruction(
             var operand: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 un_node.operand,
                 false,
             );
@@ -1089,12 +1105,14 @@ fn walkInstruction(
             var lhs: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.lhs,
                 false,
             );
             var start: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.start,
                 false,
             );
@@ -1120,18 +1138,21 @@ fn walkInstruction(
             var lhs: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.lhs,
                 false,
             );
             var start: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.start,
                 false,
             );
             var end: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.end,
                 false,
             );
@@ -1159,24 +1180,28 @@ fn walkInstruction(
             var lhs: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.lhs,
                 false,
             );
             var start: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.start,
                 false,
             );
             var end: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.end,
                 false,
             );
             var sentinel: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.sentinel,
                 false,
             );
@@ -1226,12 +1251,14 @@ fn walkInstruction(
             var lhs: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.lhs,
                 false,
             );
             var rhs: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.rhs,
                 false,
             );
@@ -1292,7 +1319,7 @@ fn walkInstruction(
             const un_node = data[inst_index].un_node;
             const bin_index = self.exprs.items.len;
             try self.exprs.append(self.arena, .{ .builtin = .{ .param = 0 } });
-            const param = try self.walkRef(file, parent_scope, un_node.operand, false);
+            const param = try self.walkRef(file, parent_scope, parent_line, un_node.operand, false);
 
             const param_index = self.exprs.items.len;
             try self.exprs.append(self.arena, param.expr);
@@ -1341,12 +1368,14 @@ fn walkInstruction(
             var lhs: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.lhs,
                 false,
             );
             var rhs: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.rhs,
                 false,
             );
@@ -1369,12 +1398,14 @@ fn walkInstruction(
             var lhs: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.lhs,
                 false,
             );
             var rhs: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.rhs,
                 false,
             );
@@ -1397,12 +1428,14 @@ fn walkInstruction(
             var lhs: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.lhs,
                 false,
             );
             var rhs: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.rhs,
                 false,
             );
@@ -1422,7 +1455,7 @@ fn walkInstruction(
 
         //     var operand: DocData.WalkResult = try self.walkRef(
         //         file,
-        //         parent_scope,
+        //         parent_scope, parent_line,
         //         un_node.operand,
         //         false,
         //     );
@@ -1431,7 +1464,7 @@ fn walkInstruction(
         // },
         .overflow_arithmetic_ptr => {
             const un_node = data[inst_index].un_node;
-            const elem_type_ref = try self.walkRef(file, parent_scope, un_node.operand, false);
+            const elem_type_ref = try self.walkRef(file, parent_scope, parent_line, un_node.operand, false);
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
                 .Pointer = .{
@@ -1456,6 +1489,7 @@ fn walkInstruction(
             const elem_type_ref = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.elem_type,
                 false,
             );
@@ -1465,7 +1499,7 @@ fn walkInstruction(
             var sentinel: ?DocData.Expr = null;
             if (ptr.flags.has_sentinel) {
                 const ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
-                const ref_result = try self.walkRef(file, parent_scope, ref, false);
+                const ref_result = try self.walkRef(file, parent_scope, parent_line, ref, false);
                 sentinel = ref_result.expr;
                 extra_index += 1;
             }
@@ -1473,21 +1507,21 @@ fn walkInstruction(
             var @"align": ?DocData.Expr = null;
             if (ptr.flags.has_align) {
                 const ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
-                const ref_result = try self.walkRef(file, parent_scope, ref, false);
+                const ref_result = try self.walkRef(file, parent_scope, parent_line, ref, false);
                 @"align" = ref_result.expr;
                 extra_index += 1;
             }
             var address_space: ?DocData.Expr = null;
             if (ptr.flags.has_addrspace) {
                 const ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
-                const ref_result = try self.walkRef(file, parent_scope, ref, false);
+                const ref_result = try self.walkRef(file, parent_scope, parent_line, ref, false);
                 address_space = ref_result.expr;
                 extra_index += 1;
             }
             var bit_start: ?DocData.Expr = null;
             if (ptr.flags.has_bit_range) {
                 const ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
-                const ref_result = try self.walkRef(file, parent_scope, ref, false);
+                const ref_result = try self.walkRef(file, parent_scope, parent_line, ref, false);
                 address_space = ref_result.expr;
                 extra_index += 1;
             }
@@ -1495,7 +1529,7 @@ fn walkInstruction(
             var host_size: ?DocData.Expr = null;
             if (ptr.flags.has_bit_range) {
                 const ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
-                const ref_result = try self.walkRef(file, parent_scope, ref, false);
+                const ref_result = try self.walkRef(file, parent_scope, parent_line, ref, false);
                 host_size = ref_result.expr;
             }
 
@@ -1525,8 +1559,8 @@ fn walkInstruction(
         .array_type => {
             const pl_node = data[inst_index].pl_node;
             const bin = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index).data;
-            const len = try self.walkRef(file, parent_scope, bin.lhs, false);
-            const child = try self.walkRef(file, parent_scope, bin.rhs, false);
+            const len = try self.walkRef(file, parent_scope, parent_line, bin.lhs, false);
+            const child = try self.walkRef(file, parent_scope, parent_line, bin.rhs, false);
 
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
@@ -1544,9 +1578,9 @@ fn walkInstruction(
         .array_type_sentinel => {
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.ArrayTypeSentinel, pl_node.payload_index);
-            const len = try self.walkRef(file, parent_scope, extra.data.len, false);
-            const sentinel = try self.walkRef(file, parent_scope, extra.data.sentinel, false);
-            const elem_type = try self.walkRef(file, parent_scope, extra.data.elem_type, false);
+            const len = try self.walkRef(file, parent_scope, parent_line, extra.data.len, false);
+            const sentinel = try self.walkRef(file, parent_scope, parent_line, extra.data.sentinel, false);
+            const elem_type = try self.walkRef(file, parent_scope, parent_line, extra.data.elem_type, false);
 
             const type_slot_index = self.types.items.len;
             try self.types.append(self.arena, .{
@@ -1568,10 +1602,10 @@ fn walkInstruction(
             const array_data = try self.arena.alloc(usize, operands.len - 1);
 
             std.debug.assert(operands.len > 0);
-            var array_type = try self.walkRef(file, parent_scope, operands[0], false);
+            var array_type = try self.walkRef(file, parent_scope, parent_line, operands[0], false);
 
             for (operands[1..]) |op, idx| {
-                const wr = try self.walkRef(file, parent_scope, op, false);
+                const wr = try self.walkRef(file, parent_scope, parent_line, op, false);
                 const expr_index = self.exprs.items.len;
                 try self.exprs.append(self.arena, wr.expr);
                 array_data[idx] = expr_index;
@@ -1589,7 +1623,7 @@ fn walkInstruction(
             const array_data = try self.arena.alloc(usize, operands.len);
 
             for (operands) |op, idx| {
-                const wr = try self.walkRef(file, parent_scope, op, false);
+                const wr = try self.walkRef(file, parent_scope, parent_line, op, false);
                 const expr_index = self.exprs.items.len;
                 try self.exprs.append(self.arena, wr.expr);
                 array_data[idx] = expr_index;
@@ -1607,10 +1641,10 @@ fn walkInstruction(
             const array_data = try self.arena.alloc(usize, operands.len - 1);
 
             std.debug.assert(operands.len > 0);
-            var array_type = try self.walkRef(file, parent_scope, operands[0], false);
+            var array_type = try self.walkRef(file, parent_scope, parent_line, operands[0], false);
 
             for (operands[1..]) |op, idx| {
-                const wr = try self.walkRef(file, parent_scope, op, false);
+                const wr = try self.walkRef(file, parent_scope, parent_line, op, false);
                 const expr_index = self.exprs.items.len;
                 try self.exprs.append(self.arena, wr.expr);
                 array_data[idx] = expr_index;
@@ -1639,7 +1673,7 @@ fn walkInstruction(
             const array_data = try self.arena.alloc(usize, operands.len);
 
             for (operands) |op, idx| {
-                const wr = try self.walkRef(file, parent_scope, op, false);
+                const wr = try self.walkRef(file, parent_scope, parent_line, op, false);
                 const expr_index = self.exprs.items.len;
                 try self.exprs.append(self.arena, wr.expr);
                 array_data[idx] = expr_index;
@@ -1674,6 +1708,7 @@ fn walkInstruction(
             var operand: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 un_node.operand,
                 need_type,
             );
@@ -1695,6 +1730,7 @@ fn walkInstruction(
             const operand = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 un_node.operand,
                 false,
             );
@@ -1711,6 +1747,7 @@ fn walkInstruction(
             const operand = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 un_node.operand,
                 need_type,
             );
@@ -1728,6 +1765,7 @@ fn walkInstruction(
             const operand = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 un_node.operand,
                 false,
             );
@@ -1744,7 +1782,7 @@ fn walkInstruction(
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.SwitchBlock, pl_node.payload_index);
             const cond_index = self.exprs.items.len;
-            _ = try self.walkRef(file, parent_scope, extra.data.operand, false);
+            _ = try self.walkRef(file, parent_scope, parent_line, extra.data.operand, false);
 
             const ast_index = self.ast_nodes.items.len;
             const type_index = self.types.items.len - 1;
@@ -1772,6 +1810,7 @@ fn walkInstruction(
             const operand = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 un_node.operand,
                 need_type,
             );
@@ -1797,6 +1836,7 @@ fn walkInstruction(
             const operand = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 un_node.operand,
                 need_type,
             );
@@ -1816,6 +1856,7 @@ fn walkInstruction(
             var operand: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 data[body].@"break".operand,
                 false,
             );
@@ -1834,6 +1875,7 @@ fn walkInstruction(
             const operand = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 un_node.operand,
                 need_type,
             );
@@ -1852,6 +1894,7 @@ fn walkInstruction(
             const dest_type_walk = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.dest_type,
                 false,
             );
@@ -1859,6 +1902,7 @@ fn walkInstruction(
             const operand = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 extra.data.operand,
                 false,
             );
@@ -1886,6 +1930,7 @@ fn walkInstruction(
             const operand: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 un_node.operand,
                 false,
             );
@@ -1969,7 +2014,7 @@ fn walkInstruction(
                     }
                 }
 
-                break :blk try self.walkRef(file, parent_scope, lhs_ref, false);
+                break :blk try self.walkRef(file, parent_scope, parent_line, lhs_ref, false);
             };
             try path.append(self.arena, wr.expr);
 
@@ -2020,6 +2065,7 @@ fn walkInstruction(
             return self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 getBlockInlineBreak(file.zir, inst_index),
                 need_type,
             );
@@ -2052,6 +2098,7 @@ fn walkInstruction(
                         const wr = try self.walkRef(
                             file,
                             parent_scope,
+                            parent_line,
                             field_extra.data.container_type,
                             false,
                         );
@@ -2062,6 +2109,7 @@ fn walkInstruction(
                 const value = try self.walkRef(
                     file,
                     parent_scope,
+                    parent_line,
                     init_extra.data.init,
                     need_type,
                 );
@@ -2078,6 +2126,7 @@ fn walkInstruction(
             var operand: DocData.WalkResult = try self.walkRef(
                 file,
                 parent_scope,
+                parent_line,
                 un_node.operand,
                 false,
             );
@@ -2110,6 +2159,7 @@ fn walkInstruction(
                 const value = try self.walkRef(
                     file,
                     parent_scope,
+                    parent_line,
                     init_extra.data.init,
                     need_type,
                 );
@@ -2185,7 +2235,7 @@ fn walkInstruction(
             const pl_node = data[inst_index].pl_node;
             const extra = file.zir.extraData(Zir.Inst.Call, pl_node.payload_index);
 
-            const callee = try self.walkRef(file, parent_scope, extra.data.callee, need_type);
+            const callee = try self.walkRef(file, parent_scope, parent_line, extra.data.callee, need_type);
 
             const args_len = extra.data.flags.args_len;
             var args = try self.arena.alloc(DocData.Expr, args_len);
@@ -2200,7 +2250,7 @@ fn walkInstruction(
                 //       to show discrepancies between the types of provided
                 //       arguments and the types declared in the function
                 //       signature for its parameters.
-                const wr = try self.walkRef(file, parent_scope, ref, false);
+                const wr = try self.walkRef(file, parent_scope, parent_line, ref, false);
                 args[i] = wr.expr;
             }
 
@@ -2231,6 +2281,7 @@ fn walkInstruction(
             const result = self.analyzeFunction(
                 file,
                 parent_scope,
+                parent_line,
                 inst_index,
                 self_ast_node_index,
                 type_slot_index,
@@ -2246,6 +2297,7 @@ fn walkInstruction(
             const result = self.analyzeFancyFunction(
                 file,
                 parent_scope,
+                parent_line,
                 inst_index,
                 self_ast_node_index,
                 type_slot_index,
@@ -2273,7 +2325,7 @@ fn walkInstruction(
 
                     var array_type: ?DocData.Expr = null;
                     for (args) |arg, idx| {
-                        const wr = try self.walkRef(file, parent_scope, arg, idx == 0);
+                        const wr = try self.walkRef(file, parent_scope, parent_line, arg, idx == 0);
                         if (idx == 0) {
                             array_type = wr.typeRef;
                         }
@@ -2418,6 +2470,7 @@ fn walkInstruction(
                     extra_index = try self.walkDecls(
                         file,
                         &scope,
+                        parent_line,
                         decls_first_index,
                         decls_len,
                         &decl_indexes,
@@ -2438,6 +2491,7 @@ fn walkInstruction(
                     try self.collectUnionFieldInfo(
                         file,
                         &scope,
+                        parent_line,
                         fields_len,
                         &field_type_refs,
                         &field_name_indexes,
@@ -2538,6 +2592,7 @@ fn walkInstruction(
                     extra_index = try self.walkDecls(
                         file,
                         &scope,
+                        parent_line,
                         decls_first_index,
                         decls_len,
                         &decl_indexes,
@@ -2681,6 +2736,7 @@ fn walkInstruction(
                     extra_index = try self.walkDecls(
                         file,
                         &scope,
+                        parent_line,
                         decls_first_index,
                         decls_len,
                         &decl_indexes,
@@ -2693,6 +2749,7 @@ fn walkInstruction(
                     try self.collectStructFieldInfo(
                         file,
                         &scope,
+                        parent_line,
                         fields_len,
                         &field_type_refs,
                         &field_name_indexes,
@@ -2736,7 +2793,7 @@ fn walkInstruction(
                     const extra = file.zir.extraData(Zir.Inst.UnNode, extended.operand).data;
                     const bin_index = self.exprs.items.len;
                     try self.exprs.append(self.arena, .{ .builtin = .{ .param = 0 } });
-                    const param = try self.walkRef(file, parent_scope, extra.operand, false);
+                    const param = try self.walkRef(file, parent_scope, parent_line, extra.operand, false);
 
                     const param_index = self.exprs.items.len;
                     try self.exprs.append(self.arena, param.expr);
@@ -2764,6 +2821,7 @@ fn walkDecls(
     self: *Autodoc,
     file: *File,
     scope: *Scope,
+    parent_line: usize,
     decls_first_index: usize,
     decls_len: u32,
     decl_indexes: *std.ArrayListUnmanaged(usize),
@@ -2796,7 +2854,7 @@ fn walkDecls(
 
         // const hash_u32s = file.zir.extra[extra_index..][0..4];
         extra_index += 4;
-        const line = file.zir.extra[extra_index];
+        const line = parent_line + file.zir.extra[extra_index];
         extra_index += 1;
         const decl_name_index = file.zir.extra[extra_index];
         extra_index += 1;
@@ -2936,7 +2994,7 @@ fn walkDecls(
             const idx = self.ast_nodes.items.len;
             try self.ast_nodes.append(self.arena, .{
                 .file = self.files.getIndex(file) orelse unreachable,
-                .line = line, // TODO: calculate absolute line
+                .line = line,
                 .col = 0,
                 .docs = doc_comment,
                 .fields = null, // walkInstruction will fill `fields` if necessary
@@ -2947,7 +3005,7 @@ fn walkDecls(
         const walk_result = if (is_test) // TODO: decide if tests should show up at all
             DocData.WalkResult{ .expr = .{ .void = .{} } }
         else
-            try self.walkInstruction(file, scope, value_index, true);
+            try self.walkInstruction(file, scope, line, value_index, true);
 
         if (is_pub) {
             try decl_indexes.append(self.arena, decls_slot_index);
@@ -3343,6 +3401,7 @@ fn analyzeFancyFunction(
     self: *Autodoc,
     file: *File,
     scope: *Scope,
+    parent_line: usize,
     inst_index: usize,
     self_ast_node_index: usize,
     type_slot_index: usize,
@@ -3407,7 +3466,7 @@ fn analyzeFancyFunction(
 
                 const break_index = file.zir.extra[extra.end..][extra.data.body_len - 1];
                 const break_operand = data[break_index].@"break".operand;
-                const param_type_ref = try self.walkRef(file, scope, break_operand, false);
+                const param_type_ref = try self.walkRef(file, scope, parent_line, break_operand, false);
 
                 param_type_refs.appendAssumeCapacity(param_type_ref.expr);
             },
@@ -3431,7 +3490,7 @@ fn analyzeFancyFunction(
     if (extra.data.bits.has_align_ref) {
         const align_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
         align_index = self.exprs.items.len;
-        _ = try self.walkRef(file, scope, align_ref, false);
+        _ = try self.walkRef(file, scope, parent_line, align_ref, false);
         extra_index += 1;
     } else if (extra.data.bits.has_align_body) {
         const align_body_len = file.zir.extra[extra_index];
@@ -3448,7 +3507,7 @@ fn analyzeFancyFunction(
     if (extra.data.bits.has_addrspace_ref) {
         const addrspace_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
         addrspace_index = self.exprs.items.len;
-        _ = try self.walkRef(file, scope, addrspace_ref, false);
+        _ = try self.walkRef(file, scope, parent_line, addrspace_ref, false);
         extra_index += 1;
     } else if (extra.data.bits.has_addrspace_body) {
         const addrspace_body_len = file.zir.extra[extra_index];
@@ -3465,7 +3524,7 @@ fn analyzeFancyFunction(
     if (extra.data.bits.has_section_ref) {
         const section_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
         section_index = self.exprs.items.len;
-        _ = try self.walkRef(file, scope, section_ref, false);
+        _ = try self.walkRef(file, scope, parent_line, section_ref, false);
         extra_index += 1;
     } else if (extra.data.bits.has_section_body) {
         const section_body_len = file.zir.extra[extra_index];
@@ -3482,7 +3541,7 @@ fn analyzeFancyFunction(
     if (extra.data.bits.has_cc_ref) {
         const cc_ref = @intToEnum(Zir.Inst.Ref, file.zir.extra[extra_index]);
         cc_index = self.exprs.items.len;
-        _ = try self.walkRef(file, scope, cc_ref, false);
+        _ = try self.walkRef(file, scope, parent_line, cc_ref, false);
         extra_index += 1;
     } else if (extra.data.bits.has_cc_body) {
         const cc_body_len = file.zir.extra[extra_index];
@@ -3501,14 +3560,14 @@ fn analyzeFancyFunction(
             .none => DocData.Expr{ .void = .{} },
             else => blk: {
                 const ref = fn_info.ret_ty_ref;
-                const wr = try self.walkRef(file, scope, ref, false);
+                const wr = try self.walkRef(file, scope, parent_line, ref, false);
                 break :blk wr.expr;
             },
         },
         else => blk: {
             const last_instr_index = fn_info.ret_ty_body[fn_info.ret_ty_body.len - 1];
             const break_operand = data[last_instr_index].@"break".operand;
-            const wr = try self.walkRef(file, scope, break_operand, false);
+            const wr = try self.walkRef(file, scope, parent_line, break_operand, false);
             break :blk wr.expr;
         },
     };
@@ -3523,6 +3582,7 @@ fn analyzeFancyFunction(
                 break :blk try self.getGenericReturnType(
                     file,
                     scope,
+                    parent_line,
                     fn_info.body[fn_info.body.len - 1],
                 );
             } else {
@@ -3559,6 +3619,7 @@ fn analyzeFunction(
     self: *Autodoc,
     file: *File,
     scope: *Scope,
+    parent_line: usize,
     inst_index: usize,
     self_ast_node_index: usize,
     type_slot_index: usize,
@@ -3624,7 +3685,7 @@ fn analyzeFunction(
 
                 const break_index = file.zir.extra[extra.end..][extra.data.body_len - 1];
                 const break_operand = data[break_index].@"break".operand;
-                const param_type_ref = try self.walkRef(file, scope, break_operand, false);
+                const param_type_ref = try self.walkRef(file, scope, parent_line, break_operand, false);
 
                 param_type_refs.appendAssumeCapacity(param_type_ref.expr);
             },
@@ -3637,14 +3698,14 @@ fn analyzeFunction(
             .none => DocData.Expr{ .void = .{} },
             else => blk: {
                 const ref = fn_info.ret_ty_ref;
-                const wr = try self.walkRef(file, scope, ref, false);
+                const wr = try self.walkRef(file, scope, parent_line, ref, false);
                 break :blk wr.expr;
             },
         },
         else => blk: {
             const last_instr_index = fn_info.ret_ty_body[fn_info.ret_ty_body.len - 1];
             const break_operand = data[last_instr_index].@"break".operand;
-            const wr = try self.walkRef(file, scope, break_operand, false);
+            const wr = try self.walkRef(file, scope, parent_line, break_operand, false);
             break :blk wr.expr;
         },
     };
@@ -3659,6 +3720,7 @@ fn analyzeFunction(
                 break :blk try self.getGenericReturnType(
                     file,
                     scope,
+                    parent_line,
                     fn_info.body[fn_info.body.len - 1],
                 );
             } else {
@@ -3699,9 +3761,11 @@ fn getGenericReturnType(
     self: *Autodoc,
     file: *File,
     scope: *Scope,
+    parent_line: usize, // function decl line
     body_end: usize,
 ) !DocData.Expr {
-    const wr = try self.walkInstruction(file, scope, body_end, false);
+    // TODO: compute the correct line offset
+    const wr = try self.walkInstruction(file, scope, parent_line, body_end, false);
     return wr.expr;
 }
 
@@ -3709,6 +3773,7 @@ fn collectUnionFieldInfo(
     self: *Autodoc,
     file: *File,
     scope: *Scope,
+    parent_line: usize,
     fields_len: usize,
     field_type_refs: *std.ArrayListUnmanaged(DocData.Expr),
     field_name_indexes: *std.ArrayListUnmanaged(usize),
@@ -3755,7 +3820,7 @@ fn collectUnionFieldInfo(
 
         // type
         {
-            const walk_result = try self.walkRef(file, scope, field_type, false);
+            const walk_result = try self.walkRef(file, scope, parent_line, field_type, false);
             try field_type_refs.append(self.arena, walk_result.expr);
         }
 
@@ -3778,6 +3843,7 @@ fn collectStructFieldInfo(
     self: *Autodoc,
     file: *File,
     scope: *Scope,
+    parent_line: usize,
     fields_len: usize,
     field_type_refs: *std.ArrayListUnmanaged(DocData.Expr),
     field_name_indexes: *std.ArrayListUnmanaged(usize),
@@ -3851,7 +3917,7 @@ fn collectStructFieldInfo(
     for (fields) |field| {
         const type_expr = expr: {
             if (field.type_ref != .none) {
-                const walk_result = try self.walkRef(file, scope, field.type_ref, false);
+                const walk_result = try self.walkRef(file, scope, parent_line, field.type_ref, false);
                 break :expr walk_result.expr;
             }
 
@@ -3861,7 +3927,7 @@ fn collectStructFieldInfo(
 
             const break_inst = body[body.len - 1];
             const operand = data[break_inst].@"break".operand;
-            const walk_result = try self.walkRef(file, scope, operand, false);
+            const walk_result = try self.walkRef(file, scope, parent_line, operand, false);
             break :expr walk_result.expr;
         };
 
@@ -3891,6 +3957,7 @@ fn walkRef(
     self: *Autodoc,
     file: *File,
     parent_scope: *Scope,
+    parent_line: usize,
     ref: Ref,
     need_type: bool, // true when the caller needs also a typeRef for the return value
 ) AutodocErrors!DocData.WalkResult {
@@ -4002,7 +4069,7 @@ fn walkRef(
         }
     } else {
         const zir_index = enum_value - Ref.typed_value_map.len;
-        return self.walkInstruction(file, parent_scope, zir_index, need_type);
+        return self.walkInstruction(file, parent_scope, parent_line, zir_index, need_type);
     }
 }
 
-- 
2.54.0


From 0f27836c218ee84f5fb7d4c47dd93a920663c037 Mon Sep 17 00:00:00 2001
From: Loris Cro <kappaloris@gmail.com>
Date: Sun, 28 Aug 2022 01:20:38 +0200
Subject: [PATCH 278/290] ci: fix wrong path when deploying stdlib docs

---
 ci/srht/update_download_page | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ci/srht/update_download_page b/ci/srht/update_download_page
index e84fcd910a2c61069357fad67dbfd42ef3b5e1a1..89c26952e5238cf027e6959af9871e30a5a2e099 100755
--- a/ci/srht/update_download_page
+++ b/ci/srht/update_download_page
@@ -101,7 +101,7 @@ CIDIR="$(pwd)"
 
 cd "$HOME"
 
-# Upload new stdlib autodocs 
+# Upload new stdlib autodocs
 mkdir -p docs_to_upload/documentation/master/std/
 gzip -c -9 "$ZIGDIR/docs/std/index.html" >  docs_to_upload/documentation/master/std/index.html
 gzip -c -9 "$ZIGDIR/docs/std/data.js" > docs_to_upload/documentation/master/std/data.js
@@ -110,7 +110,7 @@ gzip -c -9 "$LANGREF" > docs_to_upload/documentation/master/index.html
 $S3CMD put -P --no-mime-magic --recursive --add-header="Content-Encoding:gzip" --add-header="Cache-Control: max-age=0, must-revalidate" "docs_to_upload/" s3://ziglang.org/
 
 mkdir -p docs_src_to_upload/documentation/master/std/
-cp -r "$ZIGDIR/docs/src" docs_src_to_upload/documentation/master/std/
+cp -r "$ZIGDIR/docs/std/src" docs_src_to_upload/documentation/master/std/
 $S3CMD put -P --no-mime-magic --recursive --add-header:"Content-Type:text/html" --add-header="Cache-Control: max-age=0, must-revalidate" "docs_src_to_upload/" s3://ziglang.org/
 
 ## Copy without compression:
-- 
2.54.0


From 5bb8c03697fce798a966feb131f6d906863047ae Mon Sep 17 00:00:00 2001
From: Justin Whear <justin.whear@gmail.com>
Date: Sun, 28 Aug 2022 04:19:51 -0700
Subject: [PATCH 279/290] std.random: add weightedIndex function

`weightedIndex` picks from a selection of weighted indices.
---
 lib/std/rand.zig      | 36 ++++++++++++++++++++++++++++++++++++
 lib/std/rand/test.zig | 26 ++++++++++++++++++++++++++
 2 files changed, 62 insertions(+)

diff --git a/lib/std/rand.zig b/lib/std/rand.zig
index c562230ccad9375d8823293bfcff1d1381fb3245..c13d2895c9fc2508c06ba26fa4ebd1840bd553bb 100644
--- a/lib/std/rand.zig
+++ b/lib/std/rand.zig
@@ -337,6 +337,42 @@ pub const Random = struct {
             mem.swap(T, &buf[i], &buf[j]);
         }
     }
+
+    /// Randomly selects an index into `proportions`, where the likelihood of each
+    /// index is weighted by that proportion.
+    ///
+    /// This is useful for selecting an item from a slice where weights are not equal.
+    /// `T` must be a numeric type capable of holding the sum of `proportions`.
+    pub fn weightedIndex(r: std.rand.Random, comptime T: type, proportions: []T) usize {
+        // This implementation works by summing the proportions and picking a random
+        //  point in [0, sum).  We then loop over the proportions, accumulating
+        //  until our accumulator is greater than the random point.
+
+        var sum: T = 0;
+        for (proportions) |v| {
+            sum += v;
+        }
+
+        const point = if (comptime std.meta.trait.isSignedInt(T))
+            r.intRangeLessThan(T, 0, sum)
+        else if (comptime std.meta.trait.isUnsignedInt(T))
+            r.uintLessThan(T, sum)
+        else if (comptime std.meta.trait.isFloat(T))
+            // take care that imprecision doesn't lead to a value slightly greater than sum
+            std.math.min(r.float(T) * sum, sum - std.math.epsilon(T))
+        else
+            @compileError("weightedIndex does not support proportions of type " ++ @typeName(T));
+
+        std.debug.assert(point < sum);
+
+        var accumulator: T = 0;
+        for (proportions) |p, index| {
+            accumulator += p;
+            if (point < accumulator) return index;
+        }
+
+        unreachable;
+    }
 };
 
 /// Convert a random integer 0 <= random_int <= maxValue(T),
diff --git a/lib/std/rand/test.zig b/lib/std/rand/test.zig
index 7c2016901f2a8e2e998c736b5b995f3a45f42d34..cae77d6e37eeb309336601a69db1a9e463257dc5 100644
--- a/lib/std/rand/test.zig
+++ b/lib/std/rand/test.zig
@@ -445,3 +445,29 @@ test "CSPRNG" {
     const c = random.int(u64);
     try expect(a ^ b ^ c != 0);
 }
+
+test "Random weightedIndex" {
+    // Make sure weightedIndex works for various integers and floats
+    inline for (.{ u64, i4, f32, f64 }) |T| {
+        var prng = DefaultPrng.init(0);
+        const random = prng.random();
+
+        var proportions = [_]T{ 2, 1, 1, 2 };
+        var counts = [_]f64{ 0, 0, 0, 0 };
+
+        const n_trials: u64 = 10_000;
+        var i: usize = 0;
+        while (i < n_trials) : (i += 1) {
+            const pick = random.weightedIndex(T, &proportions);
+            counts[pick] += 1;
+        }
+
+        // We expect the first and last counts to be roughly 2x the second and third
+        const approxEqRel = std.math.approxEqRel;
+        // Define "roughly" to be within 10%
+        const tolerance = 0.1;
+        try std.testing.expect(approxEqRel(f64, counts[0], counts[1] * 2, tolerance));
+        try std.testing.expect(approxEqRel(f64, counts[1], counts[2], tolerance));
+        try std.testing.expect(approxEqRel(f64, counts[2] * 2, counts[3], tolerance));
+    }
+}
-- 
2.54.0


From fc213e2d61c9ae6e643ddebf502c699abe4055e8 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sun, 28 Aug 2022 13:08:27 +0300
Subject: [PATCH 280/290] AstGen: add error for named function type

Closes #12660
---
 src/AstGen.zig                                    | 4 ++++
 test/cases/compile_errors/function_type_named.zig | 7 +++++++
 2 files changed, 11 insertions(+)
 create mode 100644 test/cases/compile_errors/function_type_named.zig

diff --git a/src/AstGen.zig b/src/AstGen.zig
index 339847826639317ac0be492e4c7a9aef03a60342..943d0aad0874fb67de7e078321e1c7e619b3b6cc 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -1164,6 +1164,10 @@ fn fnProtoExpr(
     const tree = astgen.tree;
     const token_tags = tree.tokens.items(.tag);
 
+    if (fn_proto.name_token) |some| {
+        return astgen.failTok(some, "function type cannot have a name", .{});
+    }
+
     const is_extern = blk: {
         const maybe_extern_token = fn_proto.extern_export_inline_token orelse break :blk false;
         break :blk token_tags[maybe_extern_token] == .keyword_extern;
diff --git a/test/cases/compile_errors/function_type_named.zig b/test/cases/compile_errors/function_type_named.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ad670fe88c53c09559d44d8bcabd7acd7fa98a08
--- /dev/null
+++ b/test/cases/compile_errors/function_type_named.zig
@@ -0,0 +1,7 @@
+const aFunc = fn someFunc(x: i32) void;
+
+// error
+// backend=stage2
+// target=native
+//
+// :1:18: error: function type cannot have a name
-- 
2.54.0


From 1401890ed5194aff3469be0b6919fd8fe2614c7b Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sun, 28 Aug 2022 13:11:33 +0300
Subject: [PATCH 281/290] Sema: add error for switch on slice

Closes #12651
---
 src/Sema.zig                                  |  3 +++
 test/cases/compile_errors/switch_on_slice.zig | 13 +++++++++++++
 2 files changed, 16 insertions(+)
 create mode 100644 test/cases/compile_errors/switch_on_slice.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index 047d3f84c25b1abf2439133eaaabc1f1d9c373b0..17d3b02da3c1b7621b234300a6639e3a82a0f535 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -9003,6 +9003,9 @@ fn zirSwitchCond(
         .ErrorSet,
         .Enum,
         => {
+            if (operand_ty.isSlice()) {
+                return sema.fail(block, src, "switch on type '{}'", .{operand_ty.fmt(sema.mod)});
+            }
             if ((try sema.typeHasOnePossibleValue(block, operand_src, operand_ty))) |opv| {
                 return sema.addConstant(operand_ty, opv);
             }
diff --git a/test/cases/compile_errors/switch_on_slice.zig b/test/cases/compile_errors/switch_on_slice.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b4644b132c7dbb1ad2fc2eec62623f3091c4e70c
--- /dev/null
+++ b/test/cases/compile_errors/switch_on_slice.zig
@@ -0,0 +1,13 @@
+pub export fn entry() void {
+    var a: [:0]const u8 = "foo";
+    switch (a) {
+        "--version", "version" => unreachable,
+        else => {},
+    }
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:13: error: switch on type '[:0]const u8'
-- 
2.54.0


From 6aead18ab332a3cf809b5c824d70cdc52f0e5156 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sun, 28 Aug 2022 13:17:25 +0300
Subject: [PATCH 282/290] add error tests for now correctly behaving cases

Closes #6377
---
 .../duplicate_field_in_discarded_anon_init.zig     | 10 ++++++++++
 .../struct_init_passed_to_type_param.zig           | 14 ++++++++++++++
 2 files changed, 24 insertions(+)
 create mode 100644 test/cases/compile_errors/duplicate_field_in_discarded_anon_init.zig
 create mode 100644 test/cases/compile_errors/struct_init_passed_to_type_param.zig

diff --git a/test/cases/compile_errors/duplicate_field_in_discarded_anon_init.zig b/test/cases/compile_errors/duplicate_field_in_discarded_anon_init.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6f850e6fe431c8e33fde632bff29f19de4a594c5
--- /dev/null
+++ b/test/cases/compile_errors/duplicate_field_in_discarded_anon_init.zig
@@ -0,0 +1,10 @@
+pub export fn entry() void {
+    _ = .{ .a = 0, .a = 1 };
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:21: error: duplicate field
+// :2:13: note: other field here
diff --git a/test/cases/compile_errors/struct_init_passed_to_type_param.zig b/test/cases/compile_errors/struct_init_passed_to_type_param.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b00c27986fd3fe59a1957a60596c368b7cf8ec0e
--- /dev/null
+++ b/test/cases/compile_errors/struct_init_passed_to_type_param.zig
@@ -0,0 +1,14 @@
+const MyStruct = struct { x: i32 };
+
+fn hi(comptime T: type) usize {
+    return @sizeOf(T);
+}
+
+export const value = hi(MyStruct{ .x = 12 });
+
+// error
+// backend=stage2
+// target=native
+//
+// :7:33: error: expected type 'type', found 'tmp.MyStruct'
+// :1:18: note: struct declared here
-- 
2.54.0


From 776caaf99927181a2bb135afa9b502014782691c Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sun, 28 Aug 2022 13:37:38 +0300
Subject: [PATCH 283/290] Sema: fix handling of non-standard int types in empty
 non-exhaustive enums

Closes #12649
---
 src/Sema.zig           | 15 +++------------
 src/print_zir.zig      | 10 +++++-----
 test/behavior/enum.zig |  5 +++++
 3 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 17d3b02da3c1b7621b234300a6639e3a82a0f535..586f1b2ee8f1bb78307d64a7e4983fabf501370a 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -2497,18 +2497,6 @@ fn zirEnumDecl(
     extra_index = try mod.scanNamespace(&enum_obj.namespace, extra_index, decls_len, new_decl);
 
     const body = sema.code.extra[extra_index..][0..body_len];
-    if (fields_len == 0) {
-        assert(body.len == 0);
-        if (tag_type_ref != .none) {
-            const ty = try sema.resolveType(block, tag_ty_src, tag_type_ref);
-            if (ty.zigTypeTag() != .Int and ty.zigTypeTag() != .ComptimeInt) {
-                return sema.fail(block, tag_ty_src, "expected integer tag type, found '{}'", .{ty.fmt(sema.mod)});
-            }
-            enum_obj.tag_ty = try ty.copy(new_decl_arena_allocator);
-            enum_obj.tag_ty_inferred = false;
-        }
-        return decl_val;
-    }
     extra_index += body.len;
 
     const bit_bags_count = std.math.divCeil(usize, fields_len, 32) catch unreachable;
@@ -2566,6 +2554,9 @@ fn zirEnumDecl(
             }
             enum_obj.tag_ty = try ty.copy(decl_arena_allocator);
             enum_obj.tag_ty_inferred = false;
+        } else if (fields_len == 0) {
+            enum_obj.tag_ty = try Type.Tag.int_unsigned.create(decl_arena_allocator, 0);
+            enum_obj.tag_ty_inferred = true;
         } else {
             const bits = std.math.log2_int_ceil(usize, fields_len);
             enum_obj.tag_ty = try Type.Tag.int_unsigned.create(decl_arena_allocator, bits);
diff --git a/src/print_zir.zig b/src/print_zir.zig
index 579a7970b7de5a0a716f6941204f6bce66d6d609..f315d7f0147610526abf061716dfc39ff99eef3c 100644
--- a/src/print_zir.zig
+++ b/src/print_zir.zig
@@ -1721,13 +1721,13 @@ const Writer = struct {
         const body = self.code.extra[extra_index..][0..body_len];
         extra_index += body.len;
 
+        const prev_parent_decl_node = self.parent_decl_node;
+        if (src_node) |off| self.parent_decl_node = self.relativeToNodeIndex(off);
+        try self.writeBracedDecl(stream, body);
         if (fields_len == 0) {
-            assert(body.len == 0);
-            try stream.writeAll("{}, {})");
+            try stream.writeAll(", {})");
+            self.parent_decl_node = prev_parent_decl_node;
         } else {
-            const prev_parent_decl_node = self.parent_decl_node;
-            if (src_node) |off| self.parent_decl_node = self.relativeToNodeIndex(off);
-            try self.writeBracedDecl(stream, body);
             try stream.writeAll(", {\n");
 
             self.indent += 2;
diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig
index 9e96163cc02fb67a7c0574e2e58ff2d747ed7a41..517414780b40741660b86e7116fec53853e6a29d 100644
--- a/test/behavior/enum.zig
+++ b/test/behavior/enum.zig
@@ -1170,3 +1170,8 @@ test "switch on an extern enum with negative value" {
         Foo.Bar => return,
     }
 }
+
+test "Non-exhaustive enum with nonstandard int size behaves correctly" {
+    const E = enum(u15) { _ };
+    try expect(@sizeOf(E) == @sizeOf(u15));
+}
-- 
2.54.0


From e2dc77ab62edf5446af830356eceef8eefb67cfa Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sun, 28 Aug 2022 14:00:26 +0300
Subject: [PATCH 284/290] Sema: correct one possible value for tuples

Closes #12376
---
 src/Sema.zig            | 12 ++++++------
 src/type.zig            | 15 ++++++++-------
 test/behavior/tuple.zig | 27 +++++++++++++++++++++++++++
 3 files changed, 41 insertions(+), 13 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 586f1b2ee8f1bb78307d64a7e4983fabf501370a..1030fe04734d9c5efada24d7f9fc2985a50f15a3 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -22248,8 +22248,7 @@ fn tupleField(
 
     if (try sema.resolveMaybeUndefVal(block, tuple_src, tuple)) |tuple_val| {
         if (tuple_val.isUndef()) return sema.addConstUndef(field_ty);
-        const field_values = tuple_val.castTag(.aggregate).?.data;
-        return sema.addConstant(field_ty, field_values[field_index]);
+        return sema.addConstant(field_ty, tuple_val.fieldValue(tuple_ty, field_index));
     }
 
     try sema.validateRuntimeElemAccess(block, field_index_src, field_ty, tuple_ty, tuple_src);
@@ -28848,10 +28847,11 @@ pub fn typeHasOnePossibleValue(
 
         .tuple, .anon_struct => {
             const tuple = ty.tupleFields();
-            for (tuple.values) |val| {
-                if (val.tag() == .unreachable_value) {
-                    return null; // non-comptime field
-                }
+            for (tuple.values) |val, i| {
+                const is_comptime = val.tag() != .unreachable_value;
+                if (is_comptime) continue;
+                if ((try sema.typeHasOnePossibleValue(block, src, tuple.types[i])) != null) continue; 
+                return null;
             }
             return Value.initTag(.empty_struct_value);
         },
diff --git a/src/type.zig b/src/type.zig
index cc6e5706ee6ad8d0a851601b1d99223e66a2ed5e..5ff9da89130688d7cd2567f1cfbf3c2ee91d8ec9 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -4979,19 +4979,20 @@ pub const Type = extern union {
                 const s = ty.castTag(.@"struct").?.data;
                 assert(s.haveFieldTypes());
                 for (s.fields.values()) |field| {
-                    if (field.ty.onePossibleValue() == null) {
-                        return null;
-                    }
+                    if (field.is_comptime) continue;
+                    if (field.ty.onePossibleValue() != null) continue;
+                    return null;
                 }
                 return Value.initTag(.empty_struct_value);
             },
 
             .tuple, .anon_struct => {
                 const tuple = ty.tupleFields();
-                for (tuple.values) |val| {
-                    if (val.tag() == .unreachable_value) {
-                        return null; // non-comptime field
-                    }
+                for (tuple.values) |val, i| {
+                    const is_comptime = val.tag() != .unreachable_value;
+                    if (is_comptime) continue;
+                    if (tuple.types[i].onePossibleValue() != null) continue;
+                    return null;
                 }
                 return Value.initTag(.empty_struct_value);
             },
diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig
index 971e52a0b5e1ce2517cf1a582c8f384a412a8eef..2b715c3b23c1848febb2389f56b3bcb6b4025d40 100644
--- a/test/behavior/tuple.zig
+++ b/test/behavior/tuple.zig
@@ -301,3 +301,30 @@ test "tuple type with void field" {
     const x = T{{}};
     try expect(@TypeOf(x[0]) == void);
 }
+
+test "zero sized struct in tuple handled correctly" {
+    const State = struct {
+        const Self = @This();
+        data: @Type(.{
+            .Struct = .{
+                .is_tuple = true,
+                .layout = .Auto,
+                .decls = &.{},
+                .fields = &.{.{
+                    .name = "0",
+                    .field_type = struct {},
+                    .default_value = null,
+                    .is_comptime = false,
+                    .alignment = 0,
+                }},
+            },
+        }),
+
+        pub fn do(this: Self) usize {
+            return @sizeOf(@TypeOf(this));
+        }
+    };
+
+    var s: State = undefined;
+    try expect(s.do() == 0);
+}
-- 
2.54.0


From 15cc4514e0566430ed1d95e85aaa462642b70364 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Sun, 28 Aug 2022 14:07:01 +0300
Subject: [PATCH 285/290] Sema: add missing calls to resolveStructLayout

Closes #12645
---
 src/Sema.zig                    |  5 ++++-
 test/behavior/packed-struct.zig | 15 +++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 1030fe04734d9c5efada24d7f9fc2985a50f15a3..ff32dc4b33c2331713961a21530f8c552eee0684 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -3779,6 +3779,7 @@ fn validateStructInit(
     if ((is_comptime or block.is_comptime) and
         (try sema.resolveDefinedValue(block, init_src, struct_ptr)) != null)
     {
+        try sema.resolveStructLayout(block, init_src, struct_ty);
         // In this case the only thing we need to do is evaluate the implicit
         // store instructions for default field values, and report any missing fields.
         // Avoid the cost of the extra machinery for detecting a comptime struct init value.
@@ -3973,6 +3974,7 @@ fn validateStructInit(
         try sema.storePtr2(block, init_src, struct_ptr, init_src, struct_init, init_src, .store);
         return;
     }
+    try sema.resolveStructLayout(block, init_src, struct_ty);
 
     // Our task is to insert `store` instructions for all the default field values.
     for (found_fields) |field_ptr, i| {
@@ -15843,6 +15845,7 @@ fn finishStructInit(
     }
 
     if (is_ref) {
+        try sema.resolveStructLayout(block, dest_src, struct_ty);
         const target = sema.mod.getTarget();
         const alloc_ty = try Type.ptr(sema.arena, sema.mod, .{
             .pointee_type = struct_ty,
@@ -28850,7 +28853,7 @@ pub fn typeHasOnePossibleValue(
             for (tuple.values) |val, i| {
                 const is_comptime = val.tag() != .unreachable_value;
                 if (is_comptime) continue;
-                if ((try sema.typeHasOnePossibleValue(block, src, tuple.types[i])) != null) continue; 
+                if ((try sema.typeHasOnePossibleValue(block, src, tuple.types[i])) != null) continue;
                 return null;
             }
             return Value.initTag(.empty_struct_value);
diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index 9bc1c1f8249244322fdc5b01a939cdaccad6f36c..bd312e9cda79f6792989b2aeabc9817e25ed55a2 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -564,3 +564,18 @@ test "nested packed struct field access test" {
     try std.testing.expect(arg.g.h == 6);
     try std.testing.expect(arg.g.i == 8);
 }
+
+test "runtime init of unnamed packed struct type" {
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+
+    var z: u8 = 123;
+    try (packed struct {
+        x: u8,
+        pub fn m(s: @This()) !void {
+            try expect(s.x == 123);
+        }
+    }{ .x = z }).m();
+}
-- 
2.54.0


From 56129d26ebd8c54563e92a78b9dab20f69dbc646 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 19 Aug 2022 22:06:15 -0700
Subject: [PATCH 286/290] cmake: build stage3 by default

This is a simplification of the cmake build script which introduces a
new "stage3" target that is built by default, which builds and installs
a stage3 zig.

It greatly simplifies the build instructions for Zig, making it conform
to the regular cmake routine, while still producing a stage3 artifact.
---
 CMakeLists.txt                       | 134 +++++++++++++--------------
 ci/zinc/linux_test_stage3_debug.sh   |  23 ++---
 ci/zinc/linux_test_stage3_release.sh |  35 +------
 cmake/install.cmake                  |  37 --------
 4 files changed, 81 insertions(+), 148 deletions(-)
 delete mode 100644 cmake/install.cmake

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d9784090cd0801a584f0aca834b36b6756c1bccd..f50d8b48dcc59ec901a133dc39d5ede7512a85f3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,7 +12,7 @@ if(NOT CMAKE_BUILD_TYPE)
 endif()
 
 if(NOT CMAKE_INSTALL_PREFIX)
-    set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/stage2" CACHE STRING
+    set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/stage3" CACHE STRING
       "Directory to install zig to" FORCE)
 endif()
 
@@ -65,6 +65,9 @@ if("${ZIG_VERSION}" STREQUAL "")
 endif()
 message(STATUS "Configuring zig version ${ZIG_VERSION}")
 
+set(ZIG_SKIP_INSTALL_LIB_FILES off CACHE BOOL
+    "Disable copying lib/ files to install prefix during the build phase")
+
 set(ZIG_STATIC off CACHE BOOL "Attempt to build a static zig executable (not compatible with glibc)")
 set(ZIG_SHARED_LLVM off CACHE BOOL "Prefer linking against shared LLVM libraries")
 set(ZIG_STATIC_LLVM off CACHE BOOL "Prefer linking against static LLVM libraries")
@@ -333,7 +336,7 @@ set(ZIG_CONFIG_H_OUT "${CMAKE_BINARY_DIR}/config.h")
 set(ZIG_CONFIG_ZIG_OUT "${CMAKE_BINARY_DIR}/config.zig")
 
 # This is our shim which will be replaced by stage1.zig.
-set(ZIG0_SOURCES
+set(ZIG1_SOURCES
     "${CMAKE_SOURCE_DIR}/src/stage1/zig0.cpp"
 )
 
@@ -373,9 +376,9 @@ set(ZIG_CPP_SOURCES
     # https://github.com/ziglang/zig/issues/6363
     "${CMAKE_SOURCE_DIR}/src/windows_sdk.cpp"
 )
-# Needed because we use cmake, not the zig build system, to build zig1.o.
+# Needed because we use cmake, not the zig build system, to build zig2.o.
 # This list is generated by building zig and then clearing the zig-cache directory,
-# then manually running the build-obj command (see BUILD_ZIG1_ARGS), and then looking
+# then manually running the build-obj command (see BUILD_ZIG2_ARGS), and then looking
 # in the zig-cache directory for the compiler-generated list of zig file dependencies.
 set(ZIG_STAGE2_SOURCES
     "${ZIG_CONFIG_ZIG_OUT}"
@@ -942,40 +945,47 @@ if(MSVC OR MINGW)
 endif()
 
 if("${ZIG_EXECUTABLE}" STREQUAL "")
-  add_executable(zig0 ${ZIG0_SOURCES})
-  set_target_properties(zig0 PROPERTIES
+  add_executable(zig1 ${ZIG1_SOURCES})
+  set_target_properties(zig1 PROPERTIES
       COMPILE_FLAGS ${EXE_CFLAGS}
       LINK_FLAGS ${EXE_LDFLAGS}
   )
-  target_link_libraries(zig0 zigstage1)
+  target_link_libraries(zig1 zigstage1)
 endif()
 
 if(MSVC)
-    set(ZIG1_OBJECT "${CMAKE_BINARY_DIR}/zig1.obj")
+  set(ZIG2_OBJECT "${CMAKE_BINARY_DIR}/zig2.obj")
 else()
-    set(ZIG1_OBJECT "${CMAKE_BINARY_DIR}/zig1.o")
+  set(ZIG2_OBJECT "${CMAKE_BINARY_DIR}/zig2.o")
 endif()
 if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-    set(ZIG1_RELEASE_ARG "")
+    set(ZIG_RELEASE_ARG "")
 else()
-    set(ZIG1_RELEASE_ARG -OReleaseFast --strip)
+    set(ZIG_RELEASE_ARG -Drelease)
+endif()
+if(ZIG_SKIP_INSTALL_LIB_FILES)
+  set(ZIG_SKIP_INSTALL_LIB_FILES_ARG "-Dskip-install-lib-files")
+else()
+  set(ZIG_SKIP_INSTALL_LIB_FILES_ARG "-Dskip-install-lib-files=false")
 endif()
 if(ZIG_SINGLE_THREADED)
-  set(ZIG1_SINGLE_THREADED_ARG "-fsingle-threaded")
+  set(ZIG_SINGLE_THREADED_ARG "-fsingle-threaded")
 else()
-  set(ZIG1_SINGLE_THREADED_ARG "")
+  set(ZIG_SINGLE_THREADED_ARG "")
+endif()
+if(ZIG_STATIC)
+  set(ZIG_STATIC_ARG "-Duse-zig-libcxx")
+else()
+  set(ZIG_STATIC_ARG "")
 endif()
 
-set(BUILD_ZIG1_ARGS
+set(BUILD_ZIG2_ARGS
     "src/stage1.zig"
-    -target "${ZIG_TARGET_TRIPLE}"
-    "-mcpu=${ZIG_TARGET_MCPU}"
-    --name zig1
+    --name zig2
     --zig-lib-dir "${CMAKE_SOURCE_DIR}/lib"
-    "-femit-bin=${ZIG1_OBJECT}"
+    "-femit-bin=${ZIG2_OBJECT}"
     -fcompiler-rt
-    "${ZIG1_RELEASE_ARG}"
-    "${ZIG1_SINGLE_THREADED_ARG}"
+    "${ZIG_SINGLE_THREADED_ARG}"
     -lc
     --pkg-begin build_options "${ZIG_CONFIG_ZIG_OUT}"
     --pkg-end
@@ -985,68 +995,58 @@ set(BUILD_ZIG1_ARGS
 
 if("${ZIG_EXECUTABLE}" STREQUAL "")
   add_custom_command(
-      OUTPUT "${ZIG1_OBJECT}"
-      COMMAND zig0 ${BUILD_ZIG1_ARGS}
-      DEPENDS zig0 "${ZIG_STAGE2_SOURCES}"
-      COMMENT STATUS "Building self-hosted component ${ZIG1_OBJECT}"
-      WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+    OUTPUT "${ZIG2_OBJECT}"
+    COMMAND zig1 ${BUILD_ZIG2_ARGS}
+    DEPENDS zig1 "${ZIG_STAGE2_SOURCES}"
+    COMMENT STATUS "Building stage2 object ${ZIG2_OBJECT}"
+    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
   )
-  set(ZIG_EXECUTABLE "${zig_BINARY_DIR}/zig")
   if (WIN32)
-    set(ZIG_EXECUTABLE "${ZIG_EXECUTABLE}.exe")
+    set(ZIG_EXECUTABLE "${zig2_BINARY_DIR}/zig2.exe")
+  else()
+    set(ZIG_EXECUTABLE "${zig2_BINARY_DIR}/zig2")
   endif()
 else()
   add_custom_command(
-      OUTPUT "${ZIG1_OBJECT}"
-      COMMAND "${ZIG_EXECUTABLE}" "build-obj" ${BUILD_ZIG1_ARGS}
-      DEPENDS ${ZIG_STAGE2_SOURCES}
-      COMMENT STATUS "Building self-hosted component ${ZIG1_OBJECT}"
-      WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+    OUTPUT "${ZIG2_OBJECT}"
+    COMMAND "${ZIG_EXECUTABLE}" "build-obj" ${BUILD_ZIG2_ARGS}
+    DEPENDS ${ZIG_STAGE2_SOURCES}
+    COMMENT STATUS "Building stage2 component ${ZIG2_OBJECT}"
+    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
   )
 endif()
 
 # cmake won't let us configure an executable without C sources.
-add_executable(zig "${CMAKE_SOURCE_DIR}/src/stage1/empty.cpp" "${ZIG1_OBJECT}")
+add_executable(zig2 "${CMAKE_SOURCE_DIR}/src/stage1/empty.cpp" "${ZIG2_OBJECT}")
 
-set_target_properties(zig PROPERTIES
+set_target_properties(zig2 PROPERTIES
     COMPILE_FLAGS ${EXE_CFLAGS}
     LINK_FLAGS ${EXE_LDFLAGS}
 )
-target_link_libraries(zig zigstage1)
+target_link_libraries(zig2 zigstage1)
 if(MSVC)
-  target_link_libraries(zig ntdll.lib)
+  target_link_libraries(zig2 ntdll.lib)
 elseif(MINGW)
-  target_link_libraries(zig ntdll)
+  target_link_libraries(zig2 ntdll)
 endif()
 
-install(TARGETS zig DESTINATION bin)
+set(ZIG_INSTALL_ARGS "build"
+    --zig-lib-dir "${CMAKE_SOURCE_DIR}/lib"
+    --prefix "${CMAKE_INSTALL_PREFIX}"
+    "-Dconfig_h=${ZIG_CONFIG_H_OUT}"
+    "-Denable-llvm"
+    "-Denable-stage1"
+    "${ZIG_RELEASE_ARG}"
+    "${ZIG_STATIC_ARG}"
+    "${ZIG_SKIP_INSTALL_LIB_FILES_ARG}"
+    "${ZIG_SINGLE_THREADED_ARG}"
+    "-Dtarget=${ZIG_TARGET_TRIPLE}"
+    "-Dcpu=${ZIG_TARGET_MCPU}"
+)
 
-set(ZIG_SKIP_INSTALL_LIB_FILES off CACHE BOOL
-    "Disable copying lib/ files to install prefix during the build phase")
-
-if(NOT ZIG_SKIP_INSTALL_LIB_FILES)
-    set(ZIG_INSTALL_ARGS "build"
-        --zig-lib-dir "${CMAKE_SOURCE_DIR}/lib"
-        "-Dlib-files-only"
-        --prefix "${CMAKE_INSTALL_PREFIX}"
-        "-Dconfig_h=${ZIG_CONFIG_H_OUT}"
-        install
-    )
-
-    # CODE has no effect with Visual Studio build system generator, therefore
-    # when using Visual Studio build system generator we resort to running
-    # `zig build install` during the build phase.
-    if(MSVC)
-        add_custom_target(zig_install_lib_files ALL
-            COMMAND zig ${ZIG_INSTALL_ARGS}
-            DEPENDS zig
-            WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-        )
-    else()
-        get_target_property(zig_BINARY_DIR zig BINARY_DIR)
-        install(CODE "set(zig_EXE \"${ZIG_EXECUTABLE}\")")
-        install(CODE "set(ZIG_INSTALL_ARGS \"${ZIG_INSTALL_ARGS}\")")
-        install(CODE "set(CMAKE_SOURCE_DIR \"${CMAKE_SOURCE_DIR}\")")
-        install(SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/cmake/install.cmake)
-    endif()
-endif()
+add_custom_target(stage3 ALL
+    COMMAND zig2 ${ZIG_INSTALL_ARGS}
+    DEPENDS zig2
+    COMMENT STATUS "Building stage3"
+    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+)
diff --git a/ci/zinc/linux_test_stage3_debug.sh b/ci/zinc/linux_test_stage3_debug.sh
index ba33311a4d094149306b73500a806a6d66c5d763..ccfa698765997f57a6f4de235ca622062ee58e72 100755
--- a/ci/zinc/linux_test_stage3_debug.sh
+++ b/ci/zinc/linux_test_stage3_debug.sh
@@ -20,12 +20,11 @@ export CXX="$OLD_ZIG c++ -target $TARGET -mcpu=$MCPU"
 mkdir build-debug
 cd build-debug
 cmake .. \
-  -DCMAKE_INSTALL_PREFIX="$DEBUG_STAGING" \
+  -DCMAKE_INSTALL_PREFIX="$(pwd)/stage3" \
   -DCMAKE_PREFIX_PATH="$DEPS_LOCAL" \
   -DCMAKE_BUILD_TYPE=Debug \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
   -DZIG_STATIC=ON \
+  -DZIG_USE_LLVM_CONFIG=OFF \
   -GNinja
 
 # Now cmake will use zig as the C/C++ compiler. We reset the environment variables
@@ -35,21 +34,17 @@ unset CXX
 
 ninja install
 
-cd $WORKSPACE
-
-"$DEBUG_STAGING/bin/zig" build -p stage3 -Denable-stage1 -Dstatic-llvm -Dtarget=native-native-musl --search-prefix "$DEPS_LOCAL"
-
-# simultaneously test building self-hosted without LLVM and with 32-bit arm
-stage3/bin/zig build -Dtarget=arm-linux-musleabihf
-
 echo "Looking for non-conforming code formatting..."
-stage3/bin/zig fmt --check . \
-  --exclude test/cases/ \
-  --exclude build-debug \
-  --exclude build-release \
+stage3/bin/zig fmt --check .. \
+  --exclude ../test/cases/ \
+  --exclude ../build-debug \
+  --exclude ../build-release \
   --exclude "$ZIG_LOCAL_CACHE_DIR" \
   --exclude "$ZIG_GLOBAL_CACHE_DIR"
 
+# simultaneously test building self-hosted without LLVM and with 32-bit arm
+stage3/bin/zig build -Dtarget=arm-linux-musleabihf
+
 stage3/bin/zig build test \
   -fqemu \
   -fwasmtime \
diff --git a/ci/zinc/linux_test_stage3_release.sh b/ci/zinc/linux_test_stage3_release.sh
index 3f330cf548f5bd597191a0cc5f5ccff56b8d7a78..2758ea9ca31ff395c5972781b978c35c937df6ec 100755
--- a/ci/zinc/linux_test_stage3_release.sh
+++ b/ci/zinc/linux_test_stage3_release.sh
@@ -13,9 +13,8 @@ export CXX="$OLD_ZIG c++ -target $TARGET -mcpu=$MCPU"
 
 mkdir build-release
 cd build-release
-STAGE2_PREFIX="$(pwd)/stage2"
 cmake .. \
-  -DCMAKE_INSTALL_PREFIX="$STAGE2_PREFIX" \
+  -DCMAKE_INSTALL_PREFIX="$RELEASE_STAGING" \
   -DCMAKE_PREFIX_PATH="$DEPS_LOCAL" \
   -DCMAKE_BUILD_TYPE=Release \
   -DZIG_TARGET_TRIPLE="$TARGET" \
@@ -30,31 +29,7 @@ unset CXX
 
 ninja install
 
-# Here we rebuild zig but this time using the Zig binary we just now produced to
-# build zig1.o rather than relying on the one built with stage0. See
-# https://github.com/ziglang/zig/issues/6830 for more details.
-cmake .. -DZIG_EXECUTABLE="$STAGE2_PREFIX/bin/zig"
-ninja install
-
-# This is the binary we will distribute. We intentionally test this one in this
-# script. If any test failures occur, hopefully they also occur in the debug
-# version of this script for easier troubleshooting. This prevents distribution
-# of a Zig binary that passes tests in debug mode but has a miscompilation in
-# release mode.
-"$STAGE2_PREFIX/bin/zig" build \
-  --prefix "$RELEASE_STAGING" \
-  --search-prefix "$DEPS_LOCAL" \
-  -Dstatic-llvm \
-  -Drelease \
-  -Dstrip \
-  -Dtarget="$TARGET" \
-  -Denable-stage1
-
-cd $WORKSPACE
-
-ZIG="$RELEASE_STAGING/bin/zig"
-
-$ZIG build test docs \
+"$RELEASE_STAGING/bin/zig" build test docs \
   -fqemu \
   -fwasmtime \
   -Dstatic-llvm \
@@ -63,13 +38,13 @@ $ZIG build test docs \
 
 # Produce the experimental std lib documentation.
 mkdir -p "$RELEASE_STAGING/docs/std"
-$ZIG test lib/std/std.zig \
+"$RELEASE_STAGING/bin/zig" test ../lib/std/std.zig \
   --zig-lib-dir lib \
   -femit-docs=$RELEASE_STAGING/docs/std \
   -fno-emit-bin
 
-cp LICENSE $RELEASE_STAGING/
-cp zig-cache/langref.html $RELEASE_STAGING/docs/
+cp ../LICENSE $RELEASE_STAGING/
+cp ../zig-cache/langref.html $RELEASE_STAGING/docs/
 
 # Look for HTML errors.
 tidy --drop-empty-elements no -qe $RELEASE_STAGING/docs/langref.html
diff --git a/cmake/install.cmake b/cmake/install.cmake
deleted file mode 100644
index 386773e30cb67fb6912e8e115cc3d52b5c75e032..0000000000000000000000000000000000000000
--- a/cmake/install.cmake
+++ /dev/null
@@ -1,37 +0,0 @@
-message("-- Installing: ${CMAKE_INSTALL_PREFIX}/lib")
-
-if(NOT EXISTS ${zig_EXE})
-    message("::")
-    message(":: ERROR: Executable not found")
-    message(":: (execute_process)")
-    message("::")
-    message(":: executable: ${zig_EXE}")
-    message("::")
-    message(FATAL_ERROR)
-endif()
-
-execute_process(COMMAND ${zig_EXE} ${ZIG_INSTALL_ARGS}
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-    RESULT_VARIABLE _result
-)
-if(_result)
-    message("::")
-    message(":: ERROR: ${_result}")
-    message(":: (execute_process)")
-
-    string(REPLACE ";" " " s_INSTALL_LIBSTAGE2_ARGS "${ZIG_INSTALL_ARGS}")
-    message("::")
-    message(":: argv: ${zig_EXE} ${s_INSTALL_LIBSTAGE2_ARGS}")
-
-    set(_args ${zig_EXE} ${ZIG_INSTALL_ARGS})
-    list(LENGTH _args _len)
-    math(EXPR _len "${_len} - 1")
-    message("::")
-    foreach(_i RANGE 0 ${_len})
-        list(GET _args ${_i} _arg)
-        message(":: argv[${_i}]: ${_arg}")
-    endforeach()
-
-    message("::")
-    message(FATAL_ERROR)
-endif()
-- 
2.54.0


From 3d9b6cfcc9341cef40a8a525a4acf8be8b81992c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 25 Aug 2022 16:17:00 -0700
Subject: [PATCH 287/290] stage2: add an explicit padding field to avoid
 Valgrind warning

Adds a `unused: u32 = 0` field to `Zir.Header`.

We could leave this as padding, however it triggers a Valgrind warning because
we read and write undefined bytes to the file system. This is harmless, but
it's essentially free to have a zero field here and makes the warning go away,
making it more likely that following Valgrind warnings will be taken seriously.
---
 src/Zir.zig | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/Zir.zig b/src/Zir.zig
index 7a1db54ea28c0c7b4e8416699cd2ff33d7173a2b..ec9ddfcffb2bc75c753051c039f6cb402ad59ca7 100644
--- a/src/Zir.zig
+++ b/src/Zir.zig
@@ -43,7 +43,11 @@ pub const Header = extern struct {
     instructions_len: u32,
     string_bytes_len: u32,
     extra_len: u32,
-
+    /// We could leave this as padding, however it triggers a Valgrind warning because
+    /// we read and write undefined bytes to the file system. This is harmless, but
+    /// it's essentially free to have a zero field here and makes the warning go away,
+    /// making it more likely that following Valgrind warnings will be taken seriously.
+    unused: u32 = 0,
     stat_inode: std.fs.File.INode,
     stat_size: u64,
     stat_mtime: i128,
-- 
2.54.0


From aee53e2ffdd8c68a9b505f8aaad318bfbb459965 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 25 Aug 2022 16:18:16 -0700
Subject: [PATCH 288/290] CMake: add dummy install command

This makes it so that `ninja install` will work as expected.
---
 CMakeLists.txt | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f50d8b48dcc59ec901a133dc39d5ede7512a85f3..35fe217dc8c2c0d55d948cf7a12bb6e736d253b7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1030,6 +1030,12 @@ elseif(MINGW)
   target_link_libraries(zig2 ntdll)
 endif()
 
+# Dummy install command so that the "install" target is not missing.
+# This is redundant from the "stage3" custom target below.
+if(NOT ZIG_SKIP_INSTALL_LIB_FILES)
+  install(FILES "lib/compiler_rt.zig" DESTINATION "lib/zig")
+endif()
+
 set(ZIG_INSTALL_ARGS "build"
     --zig-lib-dir "${CMAKE_SOURCE_DIR}/lib"
     --prefix "${CMAKE_INSTALL_PREFIX}"
-- 
2.54.0


From 532cfb65e018c216972cb50a82c7a0379934c8cc Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 25 Aug 2022 18:12:35 -0700
Subject: [PATCH 289/290] CI: rework to account for new cmake behavior

 * CMakeLists: pass `-Dstrip` for release zig builds
 * pass -target and -mcpu to zig1. works around llvm on freebsd
   incorrectly detecting "freestanding" instead of "freebsd" for the
   native OS.
 * ci.ziglang.org is now responsible for creating aarch64-macos tarballs
   rather than Azure.
---
 CMakeLists.txt                                |  18 ++-
 ci/azure/macos_arm64_script                   | 132 ------------------
 ci/azure/macos_script                         |  10 +-
 ci/azure/pipelines.yml                        |  12 --
 ci/drone/linux_script_base                    |  22 ---
 ci/drone/linux_script_build                   |  29 ++--
 ci/drone/linux_script_finalize                |  24 ++--
 ci/drone/test_linux_behavior                  |  15 +-
 ci/drone/test_linux_cases                     |  11 +-
 ci/drone/test_linux_misc                      |  21 +--
 ci/drone/test_linux_std_Debug                 |   9 +-
 ci/drone/test_linux_std_ReleaseFast           |   9 +-
 ci/drone/test_linux_std_ReleaseSafe           |   9 +-
 ci/drone/test_linux_std_ReleaseSmall          |  13 +-
 ci/srht/freebsd_script                        |  34 ++---
 ci/zinc/build_aarch64_macos                   |  20 +++
 ci/zinc/configure_git                         |  10 ++
 ci/zinc/drone.yml                             |  57 +++++++-
 ci/zinc/linux_base.sh                         |  31 ----
 ci/zinc/{linux_package.sh => linux_package}   |  40 +++---
 ...tage3_debug.sh => linux_test_stage3_debug} |   7 +-
 ...3_release.sh => linux_test_stage3_release} |   9 +-
 ci/zinc/macos_package                         |  49 +++++++
 ci/zinc/notify_lavahut                        |   9 ++
 24 files changed, 286 insertions(+), 314 deletions(-)
 delete mode 100755 ci/azure/macos_arm64_script
 delete mode 100755 ci/drone/linux_script_base
 create mode 100755 ci/zinc/build_aarch64_macos
 create mode 100755 ci/zinc/configure_git
 delete mode 100755 ci/zinc/linux_base.sh
 rename ci/zinc/{linux_package.sh => linux_package} (56%)
 rename ci/zinc/{linux_test_stage3_debug.sh => linux_test_stage3_debug} (94%)
 rename ci/zinc/{linux_test_stage3_release.sh => linux_test_stage3_release} (89%)
 create mode 100755 ci/zinc/macos_package
 create mode 100755 ci/zinc/notify_lavahut

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 35fe217dc8c2c0d55d948cf7a12bb6e736d253b7..835f3c4d62ca1f3ab30d138e306a17f6a495bb04 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -959,9 +959,11 @@ else()
   set(ZIG2_OBJECT "${CMAKE_BINARY_DIR}/zig2.o")
 endif()
 if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-    set(ZIG_RELEASE_ARG "")
+  set(ZIG_RELEASE_ARG "")
+elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo")
+  set(ZIG_RELEASE_ARG -Drelease)
 else()
-    set(ZIG_RELEASE_ARG -Drelease)
+  set(ZIG_RELEASE_ARG -Drelease -Dstrip)
 endif()
 if(ZIG_SKIP_INSTALL_LIB_FILES)
   set(ZIG_SKIP_INSTALL_LIB_FILES_ARG "-Dskip-install-lib-files")
@@ -985,7 +987,9 @@ set(BUILD_ZIG2_ARGS
     --zig-lib-dir "${CMAKE_SOURCE_DIR}/lib"
     "-femit-bin=${ZIG2_OBJECT}"
     -fcompiler-rt
-    "${ZIG_SINGLE_THREADED_ARG}"
+    ${ZIG_SINGLE_THREADED_ARG}
+    -target "${ZIG_TARGET_TRIPLE}"
+    -mcpu "${ZIG_TARGET_MCPU}"
     -lc
     --pkg-begin build_options "${ZIG_CONFIG_ZIG_OUT}"
     --pkg-end
@@ -1042,10 +1046,10 @@ set(ZIG_INSTALL_ARGS "build"
     "-Dconfig_h=${ZIG_CONFIG_H_OUT}"
     "-Denable-llvm"
     "-Denable-stage1"
-    "${ZIG_RELEASE_ARG}"
-    "${ZIG_STATIC_ARG}"
-    "${ZIG_SKIP_INSTALL_LIB_FILES_ARG}"
-    "${ZIG_SINGLE_THREADED_ARG}"
+    ${ZIG_RELEASE_ARG}
+    ${ZIG_STATIC_ARG}
+    ${ZIG_SKIP_INSTALL_LIB_FILES_ARG}
+    ${ZIG_SINGLE_THREADED_ARG}
     "-Dtarget=${ZIG_TARGET_TRIPLE}"
     "-Dcpu=${ZIG_TARGET_MCPU}"
 )
diff --git a/ci/azure/macos_arm64_script b/ci/azure/macos_arm64_script
deleted file mode 100755
index 4df3106f31598dcd818717ca6b77e2113bea9c75..0000000000000000000000000000000000000000
--- a/ci/azure/macos_arm64_script
+++ /dev/null
@@ -1,132 +0,0 @@
-#!/bin/sh
-
-set -x
-set -e
-
-brew update && brew install ncurses s3cmd
-
-ZIGDIR="$(pwd)"
-
-HOST_ARCH="x86_64"
-HOST_TARGET="$HOST_ARCH-macos-none"
-HOST_MCPU="baseline"
-HOST_CACHE_BASENAME="zig+llvm+lld+clang-$HOST_TARGET-0.10.0-dev.2931+bdf3fa12f"
-HOST_PREFIX="$HOME/$HOST_CACHE_BASENAME"
-
-ARCH="aarch64"
-TARGET="$ARCH-macos-none"
-MCPU="apple_a14"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.10.0-dev.2931+bdf3fa12f"
-PREFIX="$HOME/$CACHE_BASENAME"
-
-JOBS="-j2"
-
-rm -rf $HOST_PREFIX $PREFIX
-cd $HOME
-
-wget -nv "https://ziglang.org/deps/$HOST_CACHE_BASENAME.tar.xz"
-wget -nv "https://ziglang.org/deps/$CACHE_BASENAME.tar.xz"
-tar xf "$HOST_CACHE_BASENAME.tar.xz"
-tar xf "$CACHE_BASENAME.tar.xz"
-
-cd $ZIGDIR
-
-# Make the `zig version` number consistent.
-# This will affect the cmake command below.
-git config core.abbrev 9
-git fetch --unshallow || true
-git fetch --tags
-
-# Build host zig compiler in debug so that we can get the
-# current version when packaging
-
-ZIG="$HOST_PREFIX/bin/zig"
-
-export CC="$ZIG cc -target $HOST_TARGET -mcpu=$HOST_MCPU"
-export CXX="$ZIG c++ -target $HOST_TARGET -mcpu=$HOST_MCPU"
-
-mkdir build.host
-cd build.host
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="$(pwd)/release" \
-  -DCMAKE_PREFIX_PATH="$HOST_PREFIX" \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DZIG_TARGET_TRIPLE="$HOST_TARGET" \
-  -DZIG_TARGET_MCPU="$HOST_MCPU" \
-  -DZIG_STATIC=ON \
-  -DZIG_OMIT_STAGE2=ON
-
-unset CC
-unset CXX
-
-make $JOBS install
-
-# Build zig compiler cross-compiled for arm64
-cd $ZIGDIR
-
-ZIG="$ZIGDIR/build.host/release/bin/zig"
-
-export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
-export CXX="$ZIG c++ -target $TARGET -mcpu=$MCPU"
-
-mkdir build
-cd build
-cmake .. \
-  -DCMAKE_INSTALL_PREFIX="$(pwd)/release" \
-  -DCMAKE_PREFIX_PATH="$PREFIX" \
-  -DCMAKE_BUILD_TYPE=Release \
-  -DZIG_TARGET_TRIPLE="$TARGET" \
-  -DZIG_TARGET_MCPU="$MCPU" \
-  -DZIG_EXECUTABLE="$ZIG" \
-  -DZIG_STATIC=ON
-
-unset CC
-unset CXX
-
-make $JOBS install
-
-if [ "${BUILD_REASON}" != "PullRequest" ]; then
-  mv ../LICENSE release/
-
-  # We do not run test suite but still need langref.
-  mkdir -p release/docs
-  $ZIG run ../doc/docgen.zig -- $ZIG ../doc/langref.html.in release/docs/langref.html
-
-  # Produce the experimental std lib documentation.
-  mkdir -p release/docs/std
-  $ZIG test ../lib/std/std.zig \
-    --zig-lib-dir ../lib \
-    -femit-docs=release/docs/std \
-    -fno-emit-bin
-
-  mv release/bin/zig release/
-  rmdir release/bin
-
-  VERSION=$(../build.host/release/bin/zig version)
-  DIRNAME="zig-macos-$ARCH-$VERSION"
-  TARBALL="$DIRNAME.tar.xz"
-  mv release "$DIRNAME"
-  tar cfJ "$TARBALL" "$DIRNAME"
-
-  mv "$DOWNLOADSECUREFILE_SECUREFILEPATH" "$HOME/.s3cfg"
-  s3cmd put -P --add-header="cache-control: public, max-age=31536000, immutable" "$TARBALL" s3://ziglang.org/builds/
-
-  SHASUM=$(shasum -a 256 $TARBALL | cut '-d ' -f1)
-  BYTESIZE=$(wc -c < $TARBALL)
-
-  JSONFILE="macos-$GITBRANCH.json"
-  touch $JSONFILE
-  echo "{\"tarball\": \"$TARBALL\"," >>$JSONFILE
-  echo "\"shasum\": \"$SHASUM\"," >>$JSONFILE
-  echo "\"size\": \"$BYTESIZE\"}" >>$JSONFILE
-
-  s3cmd put -P --add-header="Cache-Control: max-age=0, must-revalidate" "$JSONFILE" "s3://ziglang.org/builds/$JSONFILE"
-  s3cmd put -P "$JSONFILE" "s3://ziglang.org/builds/$ARCH-macos-$VERSION.json"
-
-  # `set -x` causes these variables to be mangled.
-  # See https://developercommunity.visualstudio.com/content/problem/375679/pipeline-variable-incorrectly-inserts-single-quote.html
-  set +x
-  echo "##vso[task.setvariable variable=tarball;isOutput=true]$TARBALL"
-  echo "##vso[task.setvariable variable=shasum;isOutput=true]$SHASUM"
-  echo "##vso[task.setvariable variable=bytesize;isOutput=true]$BYTESIZE"
-fi
diff --git a/ci/azure/macos_script b/ci/azure/macos_script
index 4f3c5697b086fa44e0d152b0b52e120d8ee465b0..4bb083e5e25f1619d74b63215a0057c761913090 100755
--- a/ci/azure/macos_script
+++ b/ci/azure/macos_script
@@ -34,6 +34,7 @@ git fetch --tags
 mkdir build
 cd build
 cmake .. \
+  -DCMAKE_INSTALL_PREFIX="stage3-release" \
   -DCMAKE_PREFIX_PATH="$PREFIX" \
   -DCMAKE_BUILD_TYPE=Release \
   -DZIG_TARGET_TRIPLE="$TARGET" \
@@ -47,15 +48,6 @@ unset CXX
 
 make $JOBS install
 
-stage2/bin/zig build \
-  --prefix stage3-release \
-  --search-prefix "$PREFIX" \
-  -Dstatic-llvm \
-  -Drelease \
-  -Dstrip \
-  -Dtarget="$TARGET" \
-  -Denable-stage1
-
 stage3-release/bin/zig build test docs \
   -Denable-macos-sdk \
   -Dstatic-llvm \
diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index 33747d4d183068b0b60c4cc3738fc9c6e5656b4c..45504c5b6ee91d444f8fc854926eddc4f64b7689 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -10,17 +10,6 @@ jobs:
   - script: ci/azure/macos_script
     name: main
     displayName: 'Build and test'
-- job: BuildMacOS_arm64
-  pool:
-    vmImage: 'macOS-11'
-  timeoutInMinutes: 180
-  steps:
-  - task: DownloadSecureFile@1
-    inputs:
-      secureFile: s3cfg
-  - script: ci/azure/macos_arm64_script
-    name: main
-    displayName: 'Build'
 - job: BuildWindows
   timeoutInMinutes: 360
   pool:
@@ -155,7 +144,6 @@ jobs:
 - job: OnMasterSuccess
   dependsOn:
   - BuildMacOS
-  - BuildMacOS_arm64
   - BuildWindows
   condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/master'))
   strategy:
diff --git a/ci/drone/linux_script_base b/ci/drone/linux_script_base
deleted file mode 100755
index 2788eb2df665a66c06b81a976958b1c0905f7428..0000000000000000000000000000000000000000
--- a/ci/drone/linux_script_base
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/bin/sh
-
-# https://docs.drone.io/pipeline/docker/syntax/workspace/
-#
-# Drone automatically creates a temporary volume, known as your workspace,
-# where it clones your repository. The workspace is the current working
-# directory for each step in your pipeline.
-#
-# Because the workspace is a volume, filesystem changes are persisted between
-# pipeline steps. In other words, individual steps can communicate and share
-# state using the filesystem.
-#
-# Workspace volumes are ephemeral. They are created when the pipeline starts
-# and destroyed after the pipeline completes.
-
-set -x
-set -e
-
-TRIPLEARCH="$(uname -m)"
-DISTDIR="$DRONE_WORKSPACE/dist"
-
-export ZIG_GLOBAL_CACHE_DIR="$DRONE_WORKSPACE/zig-cache"
diff --git a/ci/drone/linux_script_build b/ci/drone/linux_script_build
index 6fe9756b92b2306f216f04c3f8be86b618457578..022de1d21783e5e418bc83a0abc745e5a80b4b1c 100755
--- a/ci/drone/linux_script_build
+++ b/ci/drone/linux_script_build
@@ -1,17 +1,16 @@
 #!/bin/sh
 
-. ./ci/drone/linux_script_base
+set -x
+set -e
 
-# Probe CPU/brand details.
-# TODO: `lscpu` is changing package names in EDGE to `util-linux-misc`
-apk update
-apk add util-linux
-echo "lscpu:"
-lscpu | sed 's,^,  : ,'
+ARCH="$(uname -m)"
+INSTALL_PREFIX="$DRONE_WORKSPACE/stage3-release"
+
+export ZIG_GLOBAL_CACHE_DIR="$DRONE_WORKSPACE/zig-cache"
 
 PREFIX="/deps/local"
 ZIG="$PREFIX/bin/zig"
-TARGET="$TRIPLEARCH-linux-musl"
+TARGET="$ARCH-linux-musl"
 MCPU="baseline"
 
 export CC="$ZIG cc -target $TARGET -mcpu=$MCPU"
@@ -30,8 +29,8 @@ cat <<'ENDFILE' >$PREFIX/bin/ranlib
 /deps/local/bin/zig ranlib $@
 ENDFILE
 
-chmod +x $PREFIX/bin/ar
-chmod +x $PREFIX/bin/ranlib
+chmod +x "$PREFIX/bin/ar"
+chmod +x "$PREFIX/bin/ranlib"
 
 # Make the `zig version` number consistent.
 # This will affect the cmake command below.
@@ -43,6 +42,7 @@ mkdir build
 cd build
 cmake .. \
   -DCMAKE_PREFIX_PATH="$PREFIX" \
+  -DCMAKE_INSTALL_PREFIX="$INSTALL_PREFIX" \
   -DCMAKE_BUILD_TYPE=Release \
   -DCMAKE_AR="$PREFIX/bin/ar" \
   -DCMAKE_RANLIB="$PREFIX/bin/ranlib" \
@@ -56,12 +56,3 @@ cmake .. \
 unset CC
 unset CXX
 samu install
-
-stage2/bin/zig build \
-  --prefix "$DISTDIR" \
-  --search-prefix "$PREFIX" \
-  -Dstatic-llvm \
-  -Drelease \
-  -Dstrip \
-  -Dtarget="$TARGET" \
-  -Denable-stage1
diff --git a/ci/drone/linux_script_finalize b/ci/drone/linux_script_finalize
index 9d70a9b09c532efd6a6ea5dc0611c66d4f4e7394..4219bd19ace00b6ea5b9e2ec5b880dd40301cdfd 100755
--- a/ci/drone/linux_script_finalize
+++ b/ci/drone/linux_script_finalize
@@ -1,6 +1,12 @@
 #!/bin/sh
 
-. ./ci/drone/linux_script_base
+set -x
+set -e
+
+ARCH="$(uname -m)"
+INSTALL_PREFIX="$DRONE_WORKSPACE/stage3-release"
+
+export ZIG_GLOBAL_CACHE_DIR="$DRONE_WORKSPACE/zig-cache"
 
 if [ -n "$DRONE_PULL_REQUEST" ]; then
   exit 0
@@ -12,16 +18,16 @@ pip3 install s3cmd
 
 cd build
 
-mv ../LICENSE "$DISTDIR/"
-mv ../zig-cache/langref.html "$DISTDIR/"
-mv "$DISTDIR/bin/zig" "$DISTDIR/"
-rmdir "$DISTDIR/bin"
+mv ../LICENSE "$INSTALL_PREFIX/"
+mv ../zig-cache/langref.html "$INSTALL_PREFIX/"
+mv "$INSTALL_PREFIX/bin/zig" "$INSTALL_PREFIX/"
+rmdir "$INSTALL_PREFIX/bin"
 
 GITBRANCH="$DRONE_BRANCH"
-VERSION="$("$DISTDIR/zig" version)"
-DIRNAME="zig-linux-$TRIPLEARCH-$VERSION"
+VERSION="$("$INSTALL_PREFIX/zig" version)"
+DIRNAME="zig-linux-$ARCH-$VERSION"
 TARBALL="$DIRNAME.tar.xz"
-mv "$DISTDIR" "$DIRNAME"
+mv "$INSTALL_PREFIX" "$DIRNAME"
 tar cfJ "$TARBALL" "$DIRNAME"
 
 s3cmd put -P --add-header="cache-control: public, max-age=31536000, immutable" "$TARBALL" s3://ziglang.org/builds/
@@ -35,7 +41,7 @@ echo "{\"tarball\": \"$TARBALL\"," >>$JSONFILE
 echo "\"shasum\": \"$SHASUM\"," >>$JSONFILE
 echo "\"size\": \"$BYTESIZE\"}" >>$JSONFILE
 
-s3cmd put -P "$JSONFILE" "s3://ziglang.org/builds/$TRIPLEARCH-linux-$VERSION.json"
+s3cmd put -P "$JSONFILE" "s3://ziglang.org/builds/$ARCH-linux-$VERSION.json"
 if [ "$GITBRANCH" = "master" ]; then
   # avoid leaking oauth token
   set +x
diff --git a/ci/drone/test_linux_behavior b/ci/drone/test_linux_behavior
index a06347c16984a9d7829ccf9e524e4836b36c5823..fb5b1fa9e483f3307ab9f52d22727094ded172bb 100755
--- a/ci/drone/test_linux_behavior
+++ b/ci/drone/test_linux_behavior
@@ -1,8 +1,13 @@
 #!/bin/sh
 
-. ./ci/drone/linux_script_base
+set -x
+set -e
 
-./build/zig build test-behavior    -Dskip-non-native
-./build/zig build test-compiler-rt -Dskip-non-native
-./build/zig build test-fmt
-./build/zig build docs
+INSTALL_PREFIX="$DRONE_WORKSPACE/stage3-release"
+ZIG="$INSTALL_PREFIX/bin/zig"
+export ZIG_GLOBAL_CACHE_DIR="$DRONE_WORKSPACE/zig-cache"
+
+$ZIG build test-behavior    -Dskip-non-native
+$ZIG build test-compiler-rt -Dskip-non-native
+$ZIG build test-fmt
+$ZIG build docs
diff --git a/ci/drone/test_linux_cases b/ci/drone/test_linux_cases
index 702bb45f9148a7bb5576c0b9223b3a83ead5aa7b..383ddf7b37165cee821cb53085d2f9208177f862 100755
--- a/ci/drone/test_linux_cases
+++ b/ci/drone/test_linux_cases
@@ -1,6 +1,11 @@
 #!/bin/sh
 
-. ./ci/drone/linux_script_base
+set -x
+set -e
 
-./build/zig build -Dskip-non-native # test building self-hosted without LLVM
-./build/zig build -Dskip-non-native test-cases
+INSTALL_PREFIX="$DRONE_WORKSPACE/stage3-release"
+ZIG="$INSTALL_PREFIX/bin/zig"
+export ZIG_GLOBAL_CACHE_DIR="$DRONE_WORKSPACE/zig-cache"
+
+$ZIG build -Dskip-non-native # test building self-hosted without LLVM
+$ZIG build -Dskip-non-native test-cases
diff --git a/ci/drone/test_linux_misc b/ci/drone/test_linux_misc
index 6a19ee41f37d67a282cda336837c81a39aafa61b..fc3dfcf4d4ce1e38bcec68a37c0d9616f5ab5c29 100755
--- a/ci/drone/test_linux_misc
+++ b/ci/drone/test_linux_misc
@@ -1,11 +1,16 @@
 #!/bin/sh
 
-. ./ci/drone/linux_script_base
+set -x
+set -e
 
-./build/zig build test-universal-libc -Dskip-non-native
-./build/zig build test-compare-output -Dskip-non-native
-./build/zig build test-standalone     -Dskip-non-native -Dskip-release-safe
-./build/zig build test-stack-traces   -Dskip-non-native
-./build/zig build test-cli            -Dskip-non-native
-./build/zig build test-asm-link       -Dskip-non-native
-./build/zig build test-translate-c    -Dskip-non-native
+INSTALL_PREFIX="$DRONE_WORKSPACE/stage3-release"
+ZIG="$INSTALL_PREFIX/bin/zig"
+export ZIG_GLOBAL_CACHE_DIR="$DRONE_WORKSPACE/zig-cache"
+
+$ZIG build test-universal-libc -Dskip-non-native
+$ZIG build test-compare-output -Dskip-non-native
+$ZIG build test-standalone     -Dskip-non-native -Dskip-release-safe
+$ZIG build test-stack-traces   -Dskip-non-native
+$ZIG build test-cli            -Dskip-non-native
+$ZIG build test-asm-link       -Dskip-non-native
+$ZIG build test-translate-c    -Dskip-non-native
diff --git a/ci/drone/test_linux_std_Debug b/ci/drone/test_linux_std_Debug
index 41fb34f8bc09c9a4f39ce8b77d95b2ac2477c52a..d05554d5a5ca4bd2cbfe61a9eb8c34dfc0ec5b62 100755
--- a/ci/drone/test_linux_std_Debug
+++ b/ci/drone/test_linux_std_Debug
@@ -1,5 +1,10 @@
 #!/bin/sh
 
-. ./ci/drone/linux_script_base
+set -x
+set -e
 
-./build/zig build test-std -Dskip-release-safe -Dskip-release-fast -Dskip-release-small -Dskip-non-native
+INSTALL_PREFIX="$DRONE_WORKSPACE/stage3-release"
+ZIG="$INSTALL_PREFIX/bin/zig"
+export ZIG_GLOBAL_CACHE_DIR="$DRONE_WORKSPACE/zig-cache"
+
+$ZIG build test-std -Dskip-release-safe -Dskip-release-fast -Dskip-release-small -Dskip-non-native
diff --git a/ci/drone/test_linux_std_ReleaseFast b/ci/drone/test_linux_std_ReleaseFast
index 156406ac35a9a63e42cb23b8af142cd2327e1e4c..7e117b313a8511ea6799d705ca255de5f2e0b741 100755
--- a/ci/drone/test_linux_std_ReleaseFast
+++ b/ci/drone/test_linux_std_ReleaseFast
@@ -1,5 +1,10 @@
 #!/bin/sh
 
-. ./ci/drone/linux_script_base
+set -x
+set -e
 
-./build/zig build test-std -Dskip-debug -Dskip-release-safe -Dskip-release-small -Dskip-non-native -Dskip-single-threaded
+INSTALL_PREFIX="$DRONE_WORKSPACE/stage3-release"
+ZIG="$INSTALL_PREFIX/bin/zig"
+export ZIG_GLOBAL_CACHE_DIR="$DRONE_WORKSPACE/zig-cache"
+
+$ZIG build test-std -Dskip-debug -Dskip-release-safe -Dskip-release-small -Dskip-non-native -Dskip-single-threaded
diff --git a/ci/drone/test_linux_std_ReleaseSafe b/ci/drone/test_linux_std_ReleaseSafe
index f972d75f0bc78aabb7c6dd6241c5326e660e51ea..b494ea6e4743efe1335fc44832bcab73d1ccb378 100755
--- a/ci/drone/test_linux_std_ReleaseSafe
+++ b/ci/drone/test_linux_std_ReleaseSafe
@@ -1,5 +1,10 @@
 #!/bin/sh
 
-. ./ci/drone/linux_script_base
+set -x
+set -e
 
-./build/zig build test-std -Dskip-debug -Dskip-release-fast -Dskip-release-small -Dskip-non-native -Dskip-single-threaded
+INSTALL_PREFIX="$DRONE_WORKSPACE/stage3-release"
+ZIG="$INSTALL_PREFIX/bin/zig"
+export ZIG_GLOBAL_CACHE_DIR="$DRONE_WORKSPACE/zig-cache"
+
+$ZIG build test-std -Dskip-debug -Dskip-release-fast -Dskip-release-small -Dskip-non-native -Dskip-single-threaded
diff --git a/ci/drone/test_linux_std_ReleaseSmall b/ci/drone/test_linux_std_ReleaseSmall
index 6271a8b15d5d91d1f0cd39fb46dd1eacacf733a0..ffd366d4542725bc45011347685b94c438b8b4db 100755
--- a/ci/drone/test_linux_std_ReleaseSmall
+++ b/ci/drone/test_linux_std_ReleaseSmall
@@ -1,11 +1,16 @@
 #!/bin/sh
 
-. ./ci/drone/linux_script_base
+set -x
+set -e
+
+INSTALL_PREFIX="$DRONE_WORKSPACE/stage3-release"
+ZIG="$INSTALL_PREFIX/bin/zig"
+export ZIG_GLOBAL_CACHE_DIR="$DRONE_WORKSPACE/zig-cache"
 
 # Empirically, this takes about 55 minutes on the CI, and is the bottleneck
 # causing timeouts. So this is disabled in favor of running a smaller set
 # of ReleaseSmall std lib tests.
-# ./build/zig build test-std -Dskip-debug -Dskip-release-safe -Dskip-release-fast -Dskip-non-native
+# $ZIG build test-std -Dskip-debug -Dskip-release-safe -Dskip-release-fast -Dskip-non-native
 
-./build/zig test lib/std/std.zig -OReleaseSmall
-./build/zig test lib/std/std.zig -OReleaseSmall -lc
+$ZIG test lib/std/std.zig -OReleaseSmall
+$ZIG test lib/std/std.zig -OReleaseSmall -lc
diff --git a/ci/srht/freebsd_script b/ci/srht/freebsd_script
index dc22a02ed590fb86a5fb67823138a3946c5d550b..326e3cadf5542c0e9976bdd0f6b11514f57a694e 100755
--- a/ci/srht/freebsd_script
+++ b/ci/srht/freebsd_script
@@ -31,6 +31,8 @@ export TERM=dumb
 
 mkdir build
 cd build
+
+
 cmake .. \
   -DCMAKE_BUILD_TYPE=Release \
   -DCMAKE_PREFIX_PATH=$PREFIX \
@@ -38,40 +40,38 @@ cmake .. \
   -DZIG_TARGET_MCPU="$MCPU" \
   -DZIG_STATIC=ON \
   -GNinja
-samu install
 
 # TODO: eliminate this workaround. Without this, zig does not end up passing
 # -isystem /usr/include when building libc++, resulting in #include <sys/endian.h>
 # "file not found" errors.
-stage2/bin/zig libc >libc.txt
+echo "include_dir=/usr/include" >>libc.txt
+echo "sys_include_dir=/usr/include" >>libc.txt
+echo "crt_dir=/usr/lib" >>libc.txt
+echo "msvc_lib_dir=" >>libc.txt
+echo "kernel32_lib_dir=" >>libc.txt
+echo "gcc_dir=" >>libc.txt
+ZIG_LIBC_TXT="$(pwd)/libc.txt"
 
-ZIG_LIBC=libc.txt stage2/bin/zig build \
-  --prefix stage3-release \
-  --search-prefix "$PREFIX" \
-  -Dstatic-llvm \
-  -Drelease \
-  -Dstrip \
-  -Dtarget="$TARGET" \
-  -Denable-stage1
+ZIG_LIBC="$ZIG_LIBC_TXT" samu install
 
 # Here we skip some tests to save time.
-stage3-release/bin/zig build test docs \
+stage3/bin/zig build test docs \
   -Dstatic-llvm \
   --search-prefix "$PREFIX" \
   -Dskip-stage1 \
   -Dskip-non-native
 
 if [ -f ~/.s3cfg ]; then
-  mv ../LICENSE stage3-release/
-  mv ../zig-cache/langref.html stage3-release/
-  mv stage3-release/bin/zig stage3-release/
-  rmdir stage3-release/bin
+  mv ../LICENSE stage3/
+  mv ../zig-cache/langref.html stage3/
+  mv stage3/bin/zig stage3/
+  rmdir stage3/bin
 
   GITBRANCH=$(basename $GITHUB_REF)
-  VERSION=$(stage3-release/zig version)
+  VERSION=$(stage3/zig version)
   DIRNAME="zig-freebsd-x86_64-$VERSION"
   TARBALL="$DIRNAME.tar.xz"
-  mv stage3-release "$DIRNAME"
+  mv stage3 "$DIRNAME"
   tar cfJ "$TARBALL" "$DIRNAME"
 
   s3cmd put -P --add-header="cache-control: public, max-age=31536000, immutable" "$TARBALL" s3://ziglang.org/builds/
diff --git a/ci/zinc/build_aarch64_macos b/ci/zinc/build_aarch64_macos
new file mode 100755
index 0000000000000000000000000000000000000000..5e97ccc913b969e1764f825f3054e94b624e472e
--- /dev/null
+++ b/ci/zinc/build_aarch64_macos
@@ -0,0 +1,20 @@
+#!/bin/sh
+
+set -x
+set -e
+
+RELEASE_STAGING="$DRONE_WORKSPACE/_release/staging"
+TARGET="aarch64-macos-none"
+MCPU="apple_a14"
+INSTALL_PREFIX="$DRONE_WORKSPACE/$TARGET"
+SEARCH_PREFIX="/deps/$TARGET"
+
+"$RELEASE_STAGING/bin/zig" build \
+  --prefix "$INSTALL_PREFIX" \
+  --search-prefix "$SEARCH_PREFIX" \
+  -Dstatic-llvm \
+  -Drelease \
+  -Dstrip \
+  -Dtarget="$TARGET" \
+  -Dmcpu="$MCPU" \
+  -Denable-stage1
diff --git a/ci/zinc/configure_git b/ci/zinc/configure_git
new file mode 100755
index 0000000000000000000000000000000000000000..146eafe601ff25fafc0cf8d386db358cbccf8e5d
--- /dev/null
+++ b/ci/zinc/configure_git
@@ -0,0 +1,10 @@
+#!/bin/sh
+
+set -x
+set -e
+
+# Make the `zig version` number consistent.
+# This will affect the cmake commands that follow.
+# This is in its own script because git does not support this command
+# being run concurrently with itself.
+git config core.abbrev 9
diff --git a/ci/zinc/drone.yml b/ci/zinc/drone.yml
index c7d8470268a68abf7652f5f0f9b52026cf51708b..3aa9e9af7b31c17dbbf1e8cfd1c83db1b4b09e2d 100644
--- a/ci/zinc/drone.yml
+++ b/ci/zinc/drone.yml
@@ -9,17 +9,33 @@ workspace:
   path: /workspace
 
 steps:
+- name: configure_git
+  image: ci/debian-amd64:11.1-9
+  commands:
+  - ./ci/zinc/configure_git
+
 - name: test_stage3_debug
-  image: ci/debian-amd64:11.1-8
+  depends_on:
+  - configure_git
+  image: ci/debian-amd64:11.1-9
   commands:
-  - ./ci/zinc/linux_test_stage3_debug.sh
+  - ./ci/zinc/linux_test_stage3_debug
 
 - name: test_stage3_release
-  image: ci/debian-amd64:11.1-8
+  depends_on:
+  - configure_git
+  image: ci/debian-amd64:11.1-9
+  commands:
+  - ./ci/zinc/linux_test_stage3_release
+
+- name: build_aarch64_macos
+  depends_on:
+  - test_stage3_release
+  image: ci/debian-amd64:11.1-9
   commands:
-  - ./ci/zinc/linux_test_stage3_release.sh
+  - ./ci/zinc/build_aarch64_macos
 
-- name: package
+- name: linux_package
   depends_on:
   - test_stage3_debug
   - test_stage3_release
@@ -28,13 +44,40 @@ steps:
       - master
     event:
       - push
-  image: ci/debian-amd64:11.1-8
+  image: ci/debian-amd64:11.1-9
   environment:
     AWS_ACCESS_KEY_ID:
       from_secret: AWS_ACCESS_KEY_ID
     AWS_SECRET_ACCESS_KEY:
       from_secret: AWS_SECRET_ACCESS_KEY
+  commands:
+  - ./ci/zinc/linux_package
+
+- name: macos_package
+  depends_on:
+  - test_stage3_debug
+  - build_aarch64_macos
+  when:
+    branch:
+      - master
+    event:
+      - push
+  image: ci/debian-amd64:11.1-9
+  environment:
+    AWS_ACCESS_KEY_ID:
+      from_secret: AWS_ACCESS_KEY_ID
+    AWS_SECRET_ACCESS_KEY:
+      from_secret: AWS_SECRET_ACCESS_KEY
+  commands:
+  - ./ci/zinc/macos_package
+
+- name: notify_lavahut
+  depends_on:
+  - macos_package
+  - linux_package
+  image: ci/debian-amd64:11.1-9
+  environment:
     SRHT_OAUTH_TOKEN:
       from_secret: SRHT_OAUTH_TOKEN
   commands:
-  - ./ci/zinc/linux_package.sh
+  - ./ci/zinc/notify_lavahut
diff --git a/ci/zinc/linux_base.sh b/ci/zinc/linux_base.sh
deleted file mode 100755
index 9a757c8197f996d46de2154196a842210afdeaa1..0000000000000000000000000000000000000000
--- a/ci/zinc/linux_base.sh
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/sh
-
-# https://docs.drone.io/pipeline/docker/syntax/workspace/
-#
-# Drone automatically creates a temporary volume, known as your workspace,
-# where it clones your repository. The workspace is the current working
-# directory for each step in your pipeline.
-#
-# Because the workspace is a volume, filesystem changes are persisted between
-# pipeline steps. In other words, individual steps can communicate and share
-# state using the filesystem.
-#
-# Workspace volumes are ephemeral. They are created when the pipeline starts
-# and destroyed after the pipeline completes.
-
-set -x
-set -e
-
-ARCH="$(uname -m)"
-
-DEPS_LOCAL="/deps/local"
-WORKSPACE="$DRONE_WORKSPACE"
-
-DEBUG_STAGING="$WORKSPACE/_debug/staging"
-RELEASE_STAGING="$WORKSPACE/_release/staging"
-
-export PATH=$DEPS_LOCAL/bin:$PATH
-
-# Make the `zig version` number consistent.
-# This will affect the cmake commands that follow.
-git config core.abbrev 9
diff --git a/ci/zinc/linux_package.sh b/ci/zinc/linux_package
similarity index 56%
rename from ci/zinc/linux_package.sh
rename to ci/zinc/linux_package
index b89e2d851169d5bec055afcd5e2884f1dfa33e4d..f7a7dccbaecb1560b7975f04cdff5a9185a3c623 100755
--- a/ci/zinc/linux_package.sh
+++ b/ci/zinc/linux_package
@@ -1,22 +1,30 @@
 #!/bin/sh
 
-. ./ci/zinc/linux_base.sh
+set -x
+set -e
+
+ARCH="$(uname -m)"
+OS="linux"
+RELEASE_STAGING="$DRONE_WORKSPACE/_release/staging"
+VERSION=$($RELEASE_STAGING/bin/zig version)
+BASENAME="zig-$OS-$ARCH-$VERSION"
+TARBALL="$BASENAME.tar.xz"
+
+# This runs concurrently with the macos_package script, so it should not make
+# any changes to the filesystem that will cause problems for the other script.
+
+cp -r "$RELEASE_STAGING" "$BASENAME"
 
 # Remove the unnecessary bin dir in $prefix/bin/zig
-mv $RELEASE_STAGING/bin/zig $RELEASE_STAGING/
-rmdir $RELEASE_STAGING/bin
+mv $BASENAME/bin/zig $BASENAME/
+rmdir $BASENAME/bin
 
 # Remove the unnecessary zig dir in $prefix/lib/zig/std/std.zig
-mv $RELEASE_STAGING/lib/zig $RELEASE_STAGING/lib2
-rmdir $RELEASE_STAGING/lib
-mv $RELEASE_STAGING/lib2 $RELEASE_STAGING/lib
+mv $BASENAME/lib/zig $BASENAME/lib2
+rmdir $BASENAME/lib
+mv $BASENAME/lib2 $BASENAME/lib
 
-VERSION=$($RELEASE_STAGING/zig version)
-BASENAME="zig-linux-$ARCH-$VERSION"
-TARBALL="$BASENAME.tar.xz"
-mv "$RELEASE_STAGING" "$BASENAME"
 tar cfJ "$TARBALL" "$BASENAME"
-ls -l "$TARBALL"
 
 SHASUM=$(sha256sum $TARBALL | cut '-d ' -f1)
 BYTESIZE=$(wc -c < $TARBALL)
@@ -31,15 +39,7 @@ echo "\"size\": \"$BYTESIZE\"}" >>$MANIFEST
 s3cmd put -P --add-header="cache-control: public, max-age=31536000, immutable" "$TARBALL" s3://ziglang.org/builds/
 
 # Publish manifest.
-s3cmd put -P --add-header="cache-control: max-age=0, must-revalidate" "$MANIFEST" "s3://ziglang.org/builds/$ARCH-linux-$VERSION.json"
-
-# Avoid leaking oauth token.
-set +x
-
-cd $WORKSPACE
-./ci/srht/on_master_success "$VERSION" "$SRHT_OAUTH_TOKEN"
-
-set -x
+s3cmd put -P --add-header="cache-control: max-age=0, must-revalidate" "$MANIFEST" "s3://ziglang.org/builds/$ARCH-$OS-$VERSION.json"
 
 # Explicit exit helps show last command duration.
 exit
diff --git a/ci/zinc/linux_test_stage3_debug.sh b/ci/zinc/linux_test_stage3_debug
similarity index 94%
rename from ci/zinc/linux_test_stage3_debug.sh
rename to ci/zinc/linux_test_stage3_debug
index ccfa698765997f57a6f4de235ca622062ee58e72..074e80d19bbc92e76b71b60b73f8a892d8e5d17e 100755
--- a/ci/zinc/linux_test_stage3_debug.sh
+++ b/ci/zinc/linux_test_stage3_debug
@@ -1,11 +1,16 @@
 #!/bin/sh
 
-. ./ci/zinc/linux_base.sh
+set -x
+set -e
 
+ARCH="$(uname -m)"
+DEPS_LOCAL="/deps/local"
 OLD_ZIG="$DEPS_LOCAL/bin/zig"
 TARGET="${ARCH}-linux-musl"
 MCPU="baseline"
 
+export PATH=$DEPS_LOCAL/bin:$PATH
+
 echo "building stage3-debug with zig version $($OLD_ZIG version)"
 
 # Override the cache directories so that we don't clobber with the release
diff --git a/ci/zinc/linux_test_stage3_release.sh b/ci/zinc/linux_test_stage3_release
similarity index 89%
rename from ci/zinc/linux_test_stage3_release.sh
rename to ci/zinc/linux_test_stage3_release
index 2758ea9ca31ff395c5972781b978c35c937df6ec..24bdde17d043abf3fe2b5f10222c7062a7aec74a 100755
--- a/ci/zinc/linux_test_stage3_release.sh
+++ b/ci/zinc/linux_test_stage3_release
@@ -1,11 +1,17 @@
 #!/bin/sh
 
-. ./ci/zinc/linux_base.sh
+set -x
+set -e
 
+ARCH="$(uname -m)"
+DEPS_LOCAL="/deps/local"
+RELEASE_STAGING="$DRONE_WORKSPACE/_release/staging"
 OLD_ZIG="$DEPS_LOCAL/bin/zig"
 TARGET="${ARCH}-linux-musl"
 MCPU="baseline"
 
+export PATH=$DEPS_LOCAL/bin:$PATH
+
 echo "building stage3-release with zig version $($OLD_ZIG version)"
 
 export CC="$OLD_ZIG cc -target $TARGET -mcpu=$MCPU"
@@ -39,7 +45,6 @@ ninja install
 # Produce the experimental std lib documentation.
 mkdir -p "$RELEASE_STAGING/docs/std"
 "$RELEASE_STAGING/bin/zig" test ../lib/std/std.zig \
-  --zig-lib-dir lib \
   -femit-docs=$RELEASE_STAGING/docs/std \
   -fno-emit-bin
 
diff --git a/ci/zinc/macos_package b/ci/zinc/macos_package
new file mode 100755
index 0000000000000000000000000000000000000000..1ee4d5f18d460eae205819f0686354657e7f80ff
--- /dev/null
+++ b/ci/zinc/macos_package
@@ -0,0 +1,49 @@
+#!/bin/sh
+
+set -x
+set -e
+
+ARCH="aarch64"
+OS=macos
+ZIG_PREFIX="$DRONE_WORKSPACE/_release/staging"
+VERSION=$($ZIG_PREFIX/bin/zig version)
+TARGET="$ARCH-$OS-none"
+INSTALL_PREFIX="$DRONE_WORKSPACE/$TARGET"
+BASENAME="zig-$OS-$ARCH-$VERSION"
+TARBALL="$BASENAME.tar.xz"
+
+# This runs concurrently with the linux_package script, so it should not make
+# any changes to the filesystem that will cause problems for the other script.
+
+# Remove the unnecessary bin dir in $prefix/bin/zig
+mv $INSTALL_PREFIX/bin/zig $INSTALL_PREFIX/
+rmdir $INSTALL_PREFIX/bin
+
+# Remove the unnecessary zig dir in $prefix/lib/zig/std/std.zig
+mv $INSTALL_PREFIX/lib/zig $INSTALL_PREFIX/lib2
+rmdir $INSTALL_PREFIX/lib
+mv $INSTALL_PREFIX/lib2 $INSTALL_PREFIX/lib
+
+cp -r "$ZIG_PREFIX/docs" "$INSTALL_PREFIX/"
+cp "$ZIG_PREFIX/LICENSE" "$INSTALL_PREFIX/"
+
+mv "$INSTALL_PREFIX" "$BASENAME"
+tar cfJ "$TARBALL" "$BASENAME"
+
+SHASUM=$(sha256sum $TARBALL | cut '-d ' -f1)
+BYTESIZE=$(wc -c < $TARBALL)
+
+MANIFEST="manifest.json"
+touch $MANIFEST
+echo "{\"tarball\": \"$TARBALL\"," >>$MANIFEST
+echo "\"shasum\": \"$SHASUM\"," >>$MANIFEST
+echo "\"size\": \"$BYTESIZE\"}" >>$MANIFEST
+
+# Publish artifact.
+s3cmd put -P --add-header="cache-control: public, max-age=31536000, immutable" "$TARBALL" s3://ziglang.org/builds/
+
+# Publish manifest.
+s3cmd put -P --add-header="cache-control: max-age=0, must-revalidate" "$MANIFEST" "s3://ziglang.org/builds/$ARCH-$OS-$VERSION.json"
+
+# Explicit exit helps show last command duration.
+exit
diff --git a/ci/zinc/notify_lavahut b/ci/zinc/notify_lavahut
new file mode 100755
index 0000000000000000000000000000000000000000..4306e5ae69d4b3eacf3b94c372da3fe7eeb687f6
--- /dev/null
+++ b/ci/zinc/notify_lavahut
@@ -0,0 +1,9 @@
+#!/bin/sh
+
+set +x # Avoid leaking oauth token.
+set -e
+
+ZIG_PREFIX="$DRONE_WORKSPACE/_release/staging"
+VERSION=$($ZIG_PREFIX/bin/zig version)
+cd $DRONE_WORKSPACE
+./ci/srht/on_master_success "$VERSION" "$SRHT_OAUTH_TOKEN"
-- 
2.54.0


From a4b52ccd9fb538bdcd77cf2d45b9310e189cc243 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 29 Aug 2022 00:40:02 +0300
Subject: [PATCH 290/290] Sema: fix access of inactive union field when enum
 and union fields are in different order

Closes #12667
---
 src/Sema.zig                                  | 20 ++++++++--------
 .../access_inactive_union_field_comptime.zig  | 23 +++++++++++++++++++
 2 files changed, 33 insertions(+), 10 deletions(-)
 create mode 100644 test/cases/compile_errors/access_inactive_union_field_comptime.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index ff32dc4b33c2331713961a21530f8c552eee0684..f884684d73794b87424ff3158cf9f34dc07f52c5 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -21892,17 +21892,18 @@ fn unionFieldPtr(
                 if (union_val.isUndef()) {
                     return sema.failWithUseOfUndef(block, src);
                 }
+                const enum_field_index = union_obj.tag_ty.enumFieldIndex(field_name).?;
                 const tag_and_val = union_val.castTag(.@"union").?.data;
                 var field_tag_buf: Value.Payload.U32 = .{
                     .base = .{ .tag = .enum_field_index },
-                    .data = field_index,
+                    .data = @intCast(u32, enum_field_index),
                 };
                 const field_tag = Value.initPayload(&field_tag_buf.base);
                 const tag_matches = tag_and_val.tag.eql(field_tag, union_obj.tag_ty, sema.mod);
                 if (!tag_matches) {
                     const msg = msg: {
                         const active_index = tag_and_val.tag.castTag(.enum_field_index).?.data;
-                        const active_field_name = union_obj.fields.keys()[active_index];
+                        const active_field_name = union_obj.tag_ty.enumFieldName(active_index);
                         const msg = try sema.errMsg(block, src, "access of union field '{s}' while field '{s}' is active", .{ field_name, active_field_name });
                         errdefer msg.destroy(sema.gpa);
                         try sema.addDeclaredHereNote(msg, union_ty);
@@ -21927,12 +21928,11 @@ fn unionFieldPtr(
     if (!initializing and union_obj.layout == .Auto and block.wantSafety() and
         union_ty.unionTagTypeSafety() != null and union_obj.fields.count() > 1)
     {
-        const enum_ty = union_ty.unionTagTypeHypothetical();
         const wanted_tag_val = try Value.Tag.enum_field_index.create(sema.arena, field_index);
-        const wanted_tag = try sema.addConstant(enum_ty, wanted_tag_val);
+        const wanted_tag = try sema.addConstant(union_obj.tag_ty, wanted_tag_val);
         // TODO would it be better if get_union_tag supported pointers to unions?
         const union_val = try block.addTyOp(.load, union_ty, union_ptr);
-        const active_tag = try block.addTyOp(.get_union_tag, enum_ty, union_val);
+        const active_tag = try block.addTyOp(.get_union_tag, union_obj.tag_ty, union_val);
         const ok = try block.addBinOp(.cmp_eq, active_tag, wanted_tag);
         try sema.addSafetyCheck(block, ok, .inactive_union_field);
     }
@@ -21963,9 +21963,10 @@ fn unionFieldVal(
         if (union_val.isUndef()) return sema.addConstUndef(field.ty);
 
         const tag_and_val = union_val.castTag(.@"union").?.data;
+        const enum_field_index = union_obj.tag_ty.enumFieldIndex(field_name).?;
         var field_tag_buf: Value.Payload.U32 = .{
             .base = .{ .tag = .enum_field_index },
-            .data = field_index,
+            .data = @intCast(u32, enum_field_index),
         };
         const field_tag = Value.initPayload(&field_tag_buf.base);
         const tag_matches = tag_and_val.tag.eql(field_tag, union_obj.tag_ty, sema.mod);
@@ -21976,7 +21977,7 @@ fn unionFieldVal(
                 } else {
                     const msg = msg: {
                         const active_index = tag_and_val.tag.castTag(.enum_field_index).?.data;
-                        const active_field_name = union_obj.fields.keys()[active_index];
+                        const active_field_name = union_obj.tag_ty.enumFieldName(active_index);
                         const msg = try sema.errMsg(block, src, "access of union field '{s}' while field '{s}' is active", .{ field_name, active_field_name });
                         errdefer msg.destroy(sema.gpa);
                         try sema.addDeclaredHereNote(msg, union_ty);
@@ -22001,10 +22002,9 @@ fn unionFieldVal(
     if (union_obj.layout == .Auto and block.wantSafety() and
         union_ty.unionTagTypeSafety() != null and union_obj.fields.count() > 1)
     {
-        const enum_ty = union_ty.unionTagTypeHypothetical();
         const wanted_tag_val = try Value.Tag.enum_field_index.create(sema.arena, field_index);
-        const wanted_tag = try sema.addConstant(enum_ty, wanted_tag_val);
-        const active_tag = try block.addTyOp(.get_union_tag, enum_ty, union_byval);
+        const wanted_tag = try sema.addConstant(union_obj.tag_ty, wanted_tag_val);
+        const active_tag = try block.addTyOp(.get_union_tag, union_obj.tag_ty, union_byval);
         const ok = try block.addBinOp(.cmp_eq, active_tag, wanted_tag);
         try sema.addSafetyCheck(block, ok, .inactive_union_field);
     }
diff --git a/test/cases/compile_errors/access_inactive_union_field_comptime.zig b/test/cases/compile_errors/access_inactive_union_field_comptime.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d990a85f9ee169a0ffea5a2894bc2b5c49237cf3
--- /dev/null
+++ b/test/cases/compile_errors/access_inactive_union_field_comptime.zig
@@ -0,0 +1,23 @@
+const Enum = enum(u32) { a, b };
+const TaggedUnion = union(Enum) {
+    b: []const u8,
+    a: []const u8,
+};
+pub export fn entry() void {
+    const result = TaggedUnion{ .b = "b" };
+    _ = result.b;
+    _ = result.a;
+}
+pub export fn entry1() void {
+    const result = TaggedUnion{ .b = "b" };
+    _ = &result.b;
+    _ = &result.a;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :9:15: error: access of union field 'a' while field 'b' is active
+// :2:21: note: union declared here
+// :14:16: error: access of union field 'a' while field 'b' is active
-- 
2.54.0