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 4ac2775515..b80e00ad59 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 a0829d6eb7..07e81dc5be 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 ccd677df0b..5af3c0038d 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 93d98c41d3..a603f72d53 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 220fb18699..d09c6278b5 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 2c6a322fca..bc9fc115b2 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 91072d0b4c..dd9cfba548 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 09721c661f..d59a114e51 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 664edb0304..5ea7ffad67 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),

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 b80e00ad59..625af7ca07 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 07e81dc5be..1629b7711a 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,

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 fb0993afe5..6e8cee7b84 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,

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 97e47d84f3..fa23b861e3 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 5a640c5b4b..540c560839 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;
         \\    }
         \\}

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 c6717ad1c0..d5006bf81f 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))

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 31bc367e64..08781767de 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);

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 5decb88ff3..aef0e0eb19 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.

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 a8bafee4f8..b68ae283b5 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}),

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 b68ae283b5..63be9a2220 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 47a0c08893..9320138f65 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 2fef069f7a..6242026b66 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)

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 63be9a2220..f3a6ad84ed 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 9320138f65..1ca198ccd8 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 6242026b66..c4d6af9db4 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

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 f3a6ad84ed..c5b71657aa 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 };
                 }
             }
 

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 c5b71657aa..c30b8d97b3 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;

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 c30b8d97b3..37c3721709 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 1ca198ccd8..ba85730276 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 c4d6af9db4..d1ba38a779 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 a3f5fbac51..ad45661b70 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);
     }

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 37c3721709..4a08a91976 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 ba85730276..8abc083a1e 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 d1ba38a779..00537e0e38 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

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 4a08a91976..ba53c2e757 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 };
                 }

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 ad8879c599..d81d2fa726 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 4e86bcadeb..d218fb6bc6 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 dc7b9b3abf..fd94976763 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 0fadad3c7e..059f0dc042 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

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 d81d2fa726..e964c8f76b 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 f79e2a860c..ec25ec2969 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 3295c20db3..3d08872ca7 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 ecb82c61d4..fbc6fcf428 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 13b331a0f4..b1bca1a11f 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 0000000000..e45f9855a7
--- /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 db8d235c45..1a77d85924 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

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 e964c8f76b..4bfd6ac1c4 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 588801b27e..6fddb63bee 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 ad8010868a..835b084740 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 0000000000..fa2e127107
--- /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 1ca83ea481..3cc8bfb355 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

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 4bfd6ac1c4..e04190973b 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 0254e002ad..e46b84f783 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 e45f9855a7..2767253612 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 1a77d85924..f5041adae7 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

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                                  | 128 ++++++++++++------
 .../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, 102 insertions(+), 50 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index e04190973b..3b672ecd42 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,
-                } },
-            })
-        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);
+    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);
 
-        try sema.addSafetyCheck(block, no_ov, .shl_overflow);
-        return sema.tupleFieldValByIndex(block, src, op_ov, 0, op_ov_tuple_ty);
+            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,
+                    }),
+                } },
+            });
+            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);
+        }
     }
     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 b1159b7d75..e786a739d6 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 2c39011240..a45b8c24ce 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 d59adeb698..8bc5be0d63 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 a46f175487..6d17c284df 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

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 302822fc99..c5734278d3 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 435075a411..748016d584 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 3b672ecd42..56e08d081b 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 a8bafee4f8..369cabecea 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 a603f72d53..be2891ef6f 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 d09c6278b5..a5007928b6 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 bc9fc115b2..bf834a36d9 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 dd9cfba548..ef92361de2 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 d59a114e51..7f7473bc66 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 280b7604bf..b746818142 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 5ea7ffad67..9c3efa18cd 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 ec4a94b420..23107946f6 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 79fcf33bc6..0e5f401f6d 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 507157911e..4081d171c4 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 0c35b5ef3d..eb36fab262 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

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 b746818142..74e4404bce 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);

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 | 6363 +++++++++++++++++++++++-----------------------
 1 file changed, 3246 insertions(+), 3117 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 064099e1ad..41a03322d9 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"));
+(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 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 searchTimer = null;
 
-    
-    let escapeHtmlReplacements = { "&": "&amp;", '"': "&quot;", "<": "&lt;", ">": "&gt;" };
+  let escapeHtmlReplacements = {
+    "&": "&amp;",
+    '"': "&quot;",
+    "<": "&lt;",
+    ">": "&gt;",
+  };
 
-    let typeKinds = (indexTypeKinds());
-    let typeTypeId =  (findTypeTypeId());
-    let pointerSizeEnum = { One: 0, Many: 1, Slice: 2, C: 3 };
+  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 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
 
-    // for each decl, is an array with {declNames, pkgNames} to get to this one
-    
-    let canonDeclPaths = null; // lazy; use getCanonDeclPath
+  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
+  // 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: [],
+  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,
-    };
+    // (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 curNavSearch = "";
+  let curSearchIndex = -1;
+  let imFeelingLucky = false;
 
-    let rootIsStd = detectRootIsStd();
+  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();
+  // 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;
-            }
+  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;
         }
-    }, 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;
+        if (
+          !this.checked &&
+          location.hash.length > 1 &&
+          location.hash[1] == "*"
+        ) {
+          location.hash = "#" + location.hash.substring(2);
+          return;
         }
-    }
-
-    
-    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);
+    },
+    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 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);
+  function isDecl(x) {
+    return "value" in x;
+  }
 
-            let fnName = "@";
+  function isType(x) {
+    return "kind" in x && !("value" in x);
+  }
 
-            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);
+  function isContainerType(x) {
+    return isType(x) && typeKindIsContainer(x.kind);
+  }
 
-            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;
+  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;
           }
-          case "switchIndex": {
-            const switchIndex = zigAnalysis.exprs[expr.switchIndex];
-            return exprName(switchIndex, opts);
+        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 "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;
+          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 {
+              name += lenName + sentinel;
             }
+            name += "]";
+            // name += is_mutable;
+            name += exprName(arrayObj.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";
+          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 "bool_to_int": {
-                payloadHtml += "boolToInt";
+              case pointerSizeEnum.Many:
+                name += "[*";
+                name += sentinel;
+                name += "]";
+                name += is_mutable;
                 break;
-              }
-              case "embed_file": {
-                payloadHtml += "embedFile";
+              case pointerSizeEnum.Slice:
+                if (ptrObj.is_ref) {
+                  name += "*";
+                }
+                name += "[";
+                name += sentinel;
+                name += "]";
+                name += is_mutable;
                 break;
-              }
-              case "error_name": {
-                payloadHtml += "errorName";
+              case pointerSizeEnum.C:
+                name += "[*c";
+                name += sentinel;
+                name += "]";
+                name += is_mutable;
                 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;
+            // @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 ";
             }
-
-            let operator = "";
-
-            switch (expr.binOp.name) {
-              case "add": {
-                operator += "+";
-                break;
+            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 "addwrap": {
-                operator += "+%";
-                break;
+              if (opts.wantHtml) {
+                name += '<span class="tok-number">' + align + "</span>";
+              } else {
+                name += align;
               }
-              case "add_sat": {
-                operator += "+|";
-                break;
+              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;
+                }
               }
-              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;
-
+              name += ") ";
+            }
+            //name += typeValueName(ptrObj.child, wantHtml, wantSubLink, null);
+            name += exprName(ptrObj.child, opts);
+            return name;
           }
-          case "errorSets": {
-            const errUnionObj = zigAnalysis.types[expr.errorSets];
-            let lhs = exprName(errUnionObj.lhs, opts);
-            let rhs = exprName(errUnionObj.rhs, opts);
-            return lhs + " || " + rhs;
+          case typeKinds.Float: {
+            let floatObj = typeObj;
 
+            if (opts.wantHtml) {
+              return '<span class="tok-type">' + floatObj.name + "</span>";
+            } else {
+              return floatObj.name;
+            }
           }
-          case "errorUnion": {
-            const errUnionObj = zigAnalysis.types[expr.errorUnion];
+          case typeKinds.Int: {
+            let intObj = typeObj;
+            let name = intObj.name;
+            if (opts.wantHtml) {
+              return '<span class="tok-type">' + name + "</span>";
+            } else {
+              return name;
+            }
+          }
+          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;
+            }
+          }
+
+          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 += " ";
+          case typeKinds.InferredErrorUnion: {
+            let errUnionObj = typeObj;
+            let payload = exprName(errUnionObj.payload, opts);
+            return "!" + payload;
+          }
+          case typeKinds.Fn: {
+            let fnObj = typeObj;
+            let payloadHtml = "";
+            if (opts.wantHtml) {
+              if (fnObj.is_extern) {
+                payloadHtml += "pub extern ";
               }
-            }
-              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 += ", ";
+              if (fnObj.has_lib_name) {
+                payloadHtml += '"' + fnObj.lib_name + '" ';
               }
-            }
-            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 {
-                      name += lenName + sentinel;
-                    }
-                    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;
-                  }
-                  case typeKinds.Float:
-                  {
-                      let floatObj =  (typeObj);
-
-                      if (opts.wantHtml) {
-                          return '<span class="tok-type">' + floatObj.name + '</span>';
-                      } else {
-                          return floatObj.name;
-                      }
-                  }
-                  case typeKinds.Int:
-                  {
-                      let intObj = (typeObj);
-                      let name = intObj.name;
-                      if (opts.wantHtml) {
-                          return '<span class="tok-type">' + name + '</span>';
-                      } else {
-                          return name;
-                      }
-                  }
-                  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;
-                      }
-                  }
-
-                  case typeKinds.ErrorUnion:
-                  {
-                    let errUnionObj = (typeObj);
-                    let lhs = exprName(errUnionObj.lhs, opts);
-                    let rhs = exprName(errUnionObj.rhs, opts);
-                    return lhs + "!" + rhs;
-                  }
-                  case typeKinds.InferredErrorUnion:
-                  {
-                    let errUnionObj = (typeObj);
-                    let payload = exprName(errUnionObj.payload, opts);
-                    return "!" + payload;
-                  }
-                  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;
-                  }
-                      // if (wantHtml) {
-                      //     return escapeHtml(typeObj.name);
-                      // } else {
-                      //     return typeObj.name;
-                      // }
-              }
-        }
-
-        }
-    }
-
-
-    
-    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;
-                }
-            }
-        }
-        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);
+              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 {
-                    descTdDom.textContent = "";
+                  payloadHtml += escapeHtml(opts.fnDecl.name);
                 }
+                payloadHtml += "</span>";
+              }
+            } else {
+              payloadHtml += "fn ";
             }
-            domTableFnErrors.classList.remove("hidden");
+            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;
+          }
+          // if (wantHtml) {
+          //     return escapeHtml(typeObj.name);
+          // } else {
+          //     return typeObj.name;
+          // }
         }
-        domSectFnErrors.classList.remove("hidden");
+      }
+    }
+  }
+
+  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;
+        }
+      }
+    }
+    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 {
+          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 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;
-//     }
+    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);
 
-    
-    function renderValue(decl) {
-        let resolvedValue = resolveValue(decl.value)
+    let docs = zigAnalysis.astNodes[decl.src].docs;
+    if (docs != null) {
+      domTldDocs.innerHTML = markdown(docs);
+      domTldDocs.classList.remove("hidden");
+    }
 
-      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}) + ";";
+    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;
       }
 
-        let docs = zigAnalysis.astNodes[decl.src].docs;
-        if (docs != null) {
-            domTldDocs.innerHTML = markdown(docs);
-            domTldDocs.classList.remove("hidden");
-        }
+      if (decl.kind === "var") {
+        varsList.push(decl);
+        continue;
+      }
 
-        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
-                        });
-                        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);
-                }
-            }
-        }
-    }
-
-    
-    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");
-            }
-        }
-
-        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");
-        }
-
-        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>');
-
-            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);
-
-                tdFnCode.innerHTML = exprName(declType.expr,{
-                  wantHtml: true,
-                  wantLink: true,
-                  fnDecl: decl,
-                  linkFnNameDecl: navLinkDecl(decl.name),
-                });
-
-                let docs = zigAnalysis.astNodes[decl.src].docs;
-                if (docs != null) {
-                    tdDesc.innerHTML = shortDescMarkdown(docs);
-                } else {
-                    tdDesc.textContent = "";
-                }
-            }
-            domSectFns.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>';
-
-                    }
-                }
-
-                html += ',</pre></div>';
-
-                if (docsNonEmpty) {
-                    html += '<div class="fieldDocs">' + markdown(docs) + '</div>';
-                }
-                divDom.innerHTML = html;
-            }
-            domSectFields.classList.remove("hidden");
-        }
-
-        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");
-        }
-
-        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 (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");
-        }
-    }
-
-
-    
-    function operatorCompare(a, b) {
-        if (a === b) {
-            return 0;
-        } else if (a < b) {
-            return -1;
-        } else {
-            return 1;
-        }
-    }
-
-    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 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;
+      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 {
-                nonSearchPart = query.substring(0, qpos);
-                curNavSearch = decodeURIComponent(query.substring(qpos + 1));
+              fnsList.push(decl);
             }
-
-            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];
-                        }
-                    }
-                }
-            }
-        }
-
-
-        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;
-
-            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,
-                                        });
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return list;
-    }
-
-    
-    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 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 {
+            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 {
-            index += 1; // include the period
+          valsList.push(decl);
         }
-        const slice = trimmed_docs.slice(0, index);
-        return markdown(slice);
+      }
+    }
+  }
+
+  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");
+      }
     }
 
+    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");
+    }
 
-    function markdown(input) {
-        const raw_lines = input.split('\n'); // zig allows no '\r', so we don't need to split on CR
-        
-        const lines = [];
+    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");
+    }
 
-        // PHASE 1:
-        // Dissect lines and determine the type for each line.
-            // Also computes indentation level and removes unnecessary whitespace
+    if (fnsList.length !== 0) {
+      resizeDomList(
+        domListFns,
+        fnsList.length,
+        "<div><dt></dt><dd></dd></div>"
+      );
 
-        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];
+      for (let i = 0; i < fnsList.length; i += 1) {
+        let decl = fnsList[i];
+        let trDom = domListFns.children[i];
 
-            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 tdFnCode = trDom.children[0];
+        let tdDesc = trDom.children[1];
 
-            if (!is_reading_code) {
-                while ((line.indent < line.raw_text.length) && line.raw_text[line.indent] == ' ') {
-                    line.indent += 1;
-                }
+        let declType = resolveValue(decl.value);
+        console.assert("type" in declType.expr);
 
-                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
-                }
-            }
+        tdFnCode.innerHTML = exprName(declType.expr, {
+          wantHtml: true,
+          wantLink: true,
+          fnDecl: decl,
+          linkFnNameDecl: navLinkDecl(decl.name),
+        });
 
-            if (line.type != "skip") {
-                lines.push(line);
-            }
+        let docs = zigAnalysis.astNodes[decl.src].docs;
+        if (docs != null) {
+          tdDesc.innerHTML = shortDescMarkdown(docs);
+        } else {
+          tdDesc.textContent = "";
+        }
+      }
+      domSectFns.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>";
+          }
         }
 
-        // PHASE 2:
-        // Render HTML from markdown lines.
-            // Look at each line and emit fitting HTML code
+        html += ",</pre></div>";
 
-        
-        function markdownInlines(innerText) {
+        if (docsNonEmpty) {
+          html += '<div class="fieldDocs">' + markdown(docs) + "</div>";
+        }
+        divDom.innerHTML = html;
+      }
+      domSectFields.classList.remove("hidden");
+    }
 
-            // 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)
+    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];
 
-            
-            
-            const formats = [
-                {
-                    marker: "**",
-                    tag: "strong",
-                },
-                {
-                    marker: "~~",
-                    tag: "s",
-                },
-                {
-                    marker: "__",
-                    tag: "u",
-                },
-                {
-                    marker: "*",
-                    tag: "em",
-                }
-            ];
+        let tdName = trDom.children[0];
+        let tdNameA = tdName.children[0];
+        let tdType = trDom.children[1];
+        let tdDesc = trDom.children[2];
 
-            
-            const stack = [];
+        tdNameA.setAttribute("href", navLinkDecl(decl.name));
+        tdNameA.textContent = decl.name;
 
-            let innerHTML = "";
-            let currentRun = "";
+        tdType.innerHTML = typeValueName(typeOfDecl(decl), true, true);
 
-            function flushRun() {
-                if (currentRun != "") {
-                    innerHTML += escapeHtml(currentRun);
-                }
-                currentRun = "";
+        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 (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");
+    }
+  }
+
+  function operatorCompare(a, b) {
+    if (a === b) {
+      return 0;
+    } else if (a < b) {
+      return -1;
+    } else {
+      return 1;
+    }
+  }
+
+  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 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 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];
             }
+          }
+        }
+      }
+    }
 
-            let parsing_code = false;
-            let codetag = "";
-            let in_code = false;
+    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;
+  }
 
-            for (let i = 0; i < innerText.length; i++) {
+  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;
 
-                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;
+        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;
+
+      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,
+                    });
+                  }
                 }
+              }
+            }
+          }
+        }
+      }
+    }
+    return list;
+  }
 
-                if (innerText[i] == "`") {
-                    flushRun();
-                    if (!parsing_code) {
-                        innerHTML += "<code>";
-                    }
-                    parsing_code = true;
-                    codetag += "`";
-                    continue;
-                }
+  function getCanonDeclPath(index) {
+    if (canonDeclPaths == null) {
+      canonDeclPaths = computeCanonDeclPaths();
+    }
+    //let cd = (canonDeclPaths);
+    return canonDeclPaths[index];
+  }
 
-                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];
-                    }
-                }
+  function getCanonTypeDecl(index) {
+    getCanonDeclPath(0);
+    //let ct = (canonTypeDecls);
+    return canonTypeDecls[index];
+  }
+
+  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
+
+    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 {
+          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);
+      }
+    }
+
+    // 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();
-
-            while (stack.length > 0) {
-                const fmt = (stack.pop());
-                innerHTML += "</" + fmt.tag + ">";
-            }
-
-            return innerHTML;
+            i += codetag.length - 1;
+            in_code = false;
+            parsing_code = false;
+            innerHTML += "</code>";
+            codetag = "";
+          } else {
+            currentRun += innerText[i];
+          }
+          continue;
         }
 
-        
-        function previousLineIs(type, line_no) {
-            if (line_no > 0) {
-                return (lines[line_no - 1].type == type);
-            } else {
-                return false;
-            }
+        if (innerText[i] == "`") {
+          flushRun();
+          if (!parsing_code) {
+            innerHTML += "<code>";
+          }
+          parsing_code = true;
+          codetag += "`";
+          continue;
         }
 
-        
-        function nextLineIs(type, line_no) {
-            if (line_no < (lines.length - 1)) {
-                return (lines[line_no + 1].type == type);
-            } else {
-                return false;
-            }
-        }
-
-        
-        function getPreviousLineIndent(line_no) {
-            if (line_no > 0) {
-                return lines[line_no - 1].indent;
-            } else {
-                return 0;
-            }
-        }
-
-        
-        function getNextLineIndent(line_no) {
-            if (line_no < (lines.length - 1)) {
-                return lines[line_no + 1].indent;
-            } else {
-                return 0;
-            }
-        }
-
-        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;
-            }
-        }
-
-        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();
-                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;
-        }
-    }
-
-
-    
-    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;
-            }
+        if (parsing_code) {
+          currentRun += innerText[i];
+          in_code = true;
         } else {
-            curSearchIndex += dir;
+          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];
+          }
         }
-        if (curSearchIndex < 0) {
-            curSearchIndex = 0;
-        }
-        if (curSearchIndex >= domListSearchResults.children.length) {
-            curSearchIndex = domListSearchResults.children.length - 1;
-        }
-        renderSearchCursor();
+      }
+      flushRun();
+
+      while (stack.length > 0) {
+        const fmt = stack.pop();
+        innerHTML += "</" + fmt.tag + ">";
+      }
+
+      return innerHTML;
     }
 
-    
-    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 previousLineIs(type, line_no) {
+      if (line_no > 0) {
+        return lines[line_no - 1].type == type;
+      } else {
+        return false;
+      }
     }
 
-    
-    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 nextLineIs(type, line_no) {
+      if (line_no < lines.length - 1) {
+        return lines[line_no + 1].type == type;
+      } else {
+        return false;
+      }
     }
 
-function showHelpModal() {
+    function getPreviousLineIndent(line_no) {
+      if (line_no > 0) {
+        return lines[line_no - 1].indent;
+      } else {
+        return 0;
+      }
+    }
+
+    function getNextLineIndent(line_no) {
+      if (line_no < lines.length - 1) {
+        return lines[line_no + 1].indent;
+      } else {
+        return 0;
+      }
+    }
+
+    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;
+      }
+    }
+
+    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();
+        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;
+    }
+  }
+
+  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 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() {
     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 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];
+
+        // exact, case sensitive match of full decl path
+        if (fullPathSearchText === term) {
+          points += 4;
+          continue;
         }
-        let fullPathSearchTextLower = fullPathSearchText;
-        if (ignoreCase) {
-            fullPathSearchTextLower = fullPathSearchTextLower.toLowerCase();
-            fileAndDocs = fileAndDocs.toLowerCase();
+        // 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;
         }
 
-        let points = 0;
-        for (let termIndex = 0; termIndex < terms.length; termIndex += 1) {
-            let term = terms[termIndex];
+        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);
-}
-
-
-
+  }
 })();

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 41a03322d9..2b6417c015 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");

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 ad8879c599..76c077c103 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 0000000000..435570f2fb
--- /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 0000000000..9d57865a87
--- /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 2edbf4509c..71e295c4dd 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

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 76c077c103..8c2125026d 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 0000000000..8e9358c6f4
--- /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 0000000000..3ce7571026
--- /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 0000000000..a2433adde9
--- /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

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 56e08d081b..4c11894c24 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

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 41a03322d9..2bb796f49b 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();

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 dbcb54288a..5d6f381863 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 2bb796f49b..55546ce056 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;
 

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 5d6f381863..48af4ab585 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 55546ce056..ebbae53714 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) {

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 48af4ab585..7e8022556f 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 ebbae53714..dee8c8a611 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 = {

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 7e8022556f..2328719caf 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>

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 2328719caf..67412bd7ac 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;
       }
 

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 dee8c8a611..77f2e2c550 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);

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 77f2e2c550..bce1a69ff5 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;

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 67412bd7ac..848b130705 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;

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 848b130705..c506eac3dd 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 {

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 dbcb54288a..4d2fda7f1c 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 2b6417c015..ebbe137979 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");

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 ebbe137979..1b15183046 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]+/);

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 f064712d4e..5c007b6986 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

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 d15eae7dc5..f77f73bce0 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 3b1b0dd59d..d53158735a 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,

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 627f946e36..2cd00f5a87 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 {

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 e30913ac76..9c8252da55 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 8c2125026d..bd75e54e87 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(

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 7d0dcd35d0..847298e54b 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")) {

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 99e25709b1..6d052a3573 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 8ea261be2d..e6a7b7991a 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 17ffe356a3..d3816e542c 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 8b88446295..7010e736dc 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 813c410f7b..fee61f5e09 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 377cbb56f4..eb29c9038d 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,

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 ee557cd6c2..0000000000
--- 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

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 dd119fd1f4..0000000000
--- 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 26718738a9..0000000000
--- 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!
-//

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 2c13f1082b..22df0054a2 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 });

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 d4320b1619..76e687c7d6 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 f192137b3c..0c6e4a63a3 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 22df0054a2..d261b5ee33 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",

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 3b5a907536..f171326b2e 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

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 f171326b2e..717aeb4d7f 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 c2b0359c64..5e0848b60f 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(

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 0b0efc55e4..8134beb6e3 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));
 

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 9c8252da55..ffe489a216 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 c2b0359c64..9e3874979d 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 2f3c931e16..c91f4cddb1 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 6427420840..c5618a58c0 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 6e33154bbd..ca2368fe10 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 0000000000..9d6170b9d0
--- /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

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 047c65439c..ef716c6972 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 2f3c931e16..a540a75d60 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);

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 9c8252da55..e53c59817a 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 a540a75d60..13570a509a 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,

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 e53c59817a..5087ea6293 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,

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 5087ea6293..4e08b39777 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 c40413f936..ea27b5beff 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

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 ffe489a216..3a30ab7b9d 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 ab394af0ad..8b195eff2d 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 c91f4cddb1..34d64ff919 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 ca2368fe10..6503e029fd 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 d53158735a..85d77303c9 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 e702246001..1dc8b50464 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 063ee8a8d8..bdd03c8db7 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 e9e63f0d7a..1de0d1c145 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 0000000000..3fff746909
--- /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'

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 ead9517ef0..efa8690b55 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 4995d87866..68409a5d05 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 c5618a58c0..c62e6d02bb 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 6503e029fd..2b70799c36 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 0297582234..eafd2ef4e9 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 0000000000..be9ffaa884
--- /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 0000000000..aaefac58b4
--- /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

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 2a7671863e..7066b1a154 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));
     }
 }
 

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 9e3874979d..3fcc28d742 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;

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 68409a5d05..acdce0e9b0 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 0000000000..54bf585425
--- /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 aaefac58b4..b739be9544 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 401f84e687..0000000000
--- 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 7371223863..0000000000
--- 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 64eb11650a..05d761de18 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 0000000000..da6a7be4fa
--- /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

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 acdce0e9b0..6d95b46c7c 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 3994040ba6..f156651eaa 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 c8d0becbd6..ce476fea04 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;
+    }
+}

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 ef716c6972..2c2bc92c96 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 9bffcb3df2..016cefb255 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 2a7d2623ef..a03764a91c 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 a74d53f21c..bee9375b5a 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 efa8690b55..af77cdacc4 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 3fcc28d742..ef2579a8e4 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 8b195eff2d..7e877a2f4a 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 6d95b46c7c..faf1692653 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 c62e6d02bb..538ef6aaf8 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 9c3efa18cd..6d2922ea3f 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 2b70799c36..4bc96c4259 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 4028c3872d..9f9a6151b8 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 08aa8bbf06..90173f384e 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 e31715030c..a5428945a9 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 fdc0777aff..bd778484cb 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 85d77303c9..1b71f4e9b1 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 fee61f5e09..e9c4ec779b 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 0000000000..165e94fd4e
--- /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 b1012e69c8..968c3e7490 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 0000000000..cd1b4ec11c
--- /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'

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 acdce0e9b0..fc8a182508 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 d2a75e18df..8a872f6378 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);
+    }
+}

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 8a0885ab7b..5c6d732419 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(

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 fc8a182508..4fefff7c26 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 953c5fec50..b2ab45a8e9 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

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 4fefff7c26..fe19de39dd 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 0000000000..d3750c8654
--- /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 0000000000..14edd293de
--- /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

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 996a85ed4b..098917e81f 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 => {},
         }

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 e899def4aa..ac3a4daeab 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,

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 d3816e542c..af39154a3f 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;
         };
 

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 0c6e4a63a3..c103cddcd4 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;

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 9aaa761a03..f9b37f5b49 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 6d2922ea3f..aa846f4247 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 e4357b8060..baf67b15aa 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;
 

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 4aec553527..8cef86b5dd 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;

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 f156651eaa..677a459afe 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 c13db2e262..863a8030c0 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

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 aa846f4247..38f7d285ae 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 baf67b15aa..9daa96eb8f 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 76e46a1b62..2b0667e89c 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", .{});
         }
     }

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 098917e81f..996a85ed4b 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 => {},
         }

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 655bdeaa42..a8c53c3142 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 db207af5f5..3da086a382 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 4871276f3c..dd818ea936 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 996a85ed4b..935183bbc6 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 => {},

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 7e877a2f4a..995fdda7ea 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);

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 5f4107a402..266b4181e0 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,

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 1192c72629..b068a11229 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,

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 ef92361de2..2048a456d7 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 {

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 2048a456d7..cbe4b55861 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);
         }

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 | 125 +++++++++++++++-----------------------
 1 file changed, 50 insertions(+), 75 deletions(-)

diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index cbe4b55861..4e88e04490 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);
-        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.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_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);

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 4e88e04490..c91edca37d 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);

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 c91edca37d..75e989764f 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);
     }
 }
 

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 75e989764f..2ee6a76401 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;

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 | 231 +++++++++++++++++++-------------------
 1 file changed, 117 insertions(+), 114 deletions(-)

diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index 2ee6a76401..728b4af651 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_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);
     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_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 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 lsb = try self.load(operand, Type.u64, 8);
+                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());
 
-                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);
+                try self.emitWValue(result_ptr);
+                const lsb = try self.load(operand, 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);
     }

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 728b4af651..53b7b7fb6b 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);
     }
 }
 

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 e7fd3cde44..0a65fa5242 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 1a60f94a1e..5d7822e8e9 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 dac239094e..6f01886986 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 3de14da7a2..a8287033d7 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 0863cc5a5e..5c259bc41a 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 61e52cfe30..1e726beb75 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 847298e54b..0738b5af0b 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 b068a11229..46b1bed7bd 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 ae9b441b60..539f3612f9 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 44f8b16b9e..a8497586f9 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" {

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 1192c72629..2836ddf9c9 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 3e42ee5f2d..c79ccb5113 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 a69dcc4c6e..14ae142a3f 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 c103cddcd4..971fe19e36 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 {

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 c4060e9182..951c0148d9 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);

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 75e9e7ef8e..27e95c6842 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'

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 27e95c6842..5ff0a5d61b 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: |

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 dcc891f878..0bca9a9d16 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)

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 2b0667e89c..2a7902dfb2 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", .{});
     }

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 1e75620919..01edd07261 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
     });

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 ea27b5beff..e514e0fd88 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 = 

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 c5734278d3..e08993bbed 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 748016d584..5a4bd2265e 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 f9b37f5b49..3e62344a04 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 988317284b..d256f9a558 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 be2891ef6f..60008ec1d1 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 a5007928b6..06adcff6d4 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 bf834a36d9..cd891f0fa3 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 53b7b7fb6b..8eb3e2175b 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 7f7473bc66..8d19768bbb 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 74e4404bce..81a892183f 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 38f7d285ae..5da3e7e327 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 23107946f6..04dec25f5f 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,

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 3e62344a04..55b519d900 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 5da3e7e327..0586c99432 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 1b71f4e9b1..582ea230ef 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 0000000000..3a2edf834a
--- /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

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 f9b37f5b49..d697ab0a99 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 0000000000..7e968ac77e
--- /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 3eebbf2248..0000000000
--- 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

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 2cd00f5a87..73891a81f5 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 3bfe334302..c2aa562db5 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();
 

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 7f7473bc66..e58163875c 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 73891a81f5..3ae151491f 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,
                 );
             }

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 af77cdacc4..1151ed60da 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 e9c4ec779b..40f8ca0fb3 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 0000000000..cbf1658b1c
--- /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);
+}

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 be2891ef6f..0ac1344221 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 47d508b34a..cf749792f0 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,
     }

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 0ac1344221..d78197d2a7 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;

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 d78197d2a7..5b772cc4d0 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", .{}),
             }
         },

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 f9c2954a3a..3d4e663dbc 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 f171326b2e..3072918b32 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";

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 3d4e663dbc..5fe80be91c 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;

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 5fe80be91c..37025c4e72 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>

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 | 45 ++++++++++++++++++++++++++++-----------------
 1 file changed, 28 insertions(+), 17 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 3072918b32..57cdd3c513 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,18 +3256,17 @@ var zigAnalysis;
   function onWindowKeyDown(ev) {
     switch (getKeyString(ev)) {
       case "Esc":
-        if (!domHelpModal.classList.contains("hidden")) {
-          domHelpModal.classList.add("hidden");
-          ev.preventDefault();
-          ev.stopPropagation();
-        }
+        onEscape(ev);
         break;
       case "s":
-        domSearch.focus();
-        domSearch.select();
-        ev.preventDefault();
-        ev.stopPropagation();
-        startAsyncSearch();
+        if (domHelpModal.classList.contains("hidden")) {
+          // TODO: scroll the page to the very top
+          domSearch.focus();
+          domSearch.select();
+          ev.preventDefault();
+          ev.stopPropagation();
+          startAsyncSearch();
+        }
         break;
       case "?":
         ev.preventDefault();
@@ -3273,6 +3283,7 @@ var zigAnalysis;
     domHelpModal.style.top =
       window.innerHeight / 2 - domHelpModal.clientHeight / 2 + "px";
     domHelpModal.focus();
+    domSearch.blur();
   }
 
   function clearAsyncSearch() {

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 57cdd3c513..b6a6e8332b 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();
 

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 b6a6e8332b..44a7c88572 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");

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 44a7c88572..680fc1d962 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();

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 37025c4e72..236923c1d8 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 680fc1d962..e2b5162beb 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();

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 951c0148d9..32f4f4378f 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,

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 0968e16812..b1e88d2e01 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 538ce1bf5e..a7686080c1 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);

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 d697ab0a99..12851cc9ad 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 0000000000..d134e0e2fb
--- /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 0000000000..c09defc56e
--- /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 223db76630..dd23c4bcb3 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

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 ed8204b346..879ecb4e2f 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;

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 5c007b6986..5277da7d2b 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

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 538ef6aaf8..7a1db54ea2 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 => {

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 5c6d732419..178249091e 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});

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 178249091e..8cc221a8dc 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});

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 8cc221a8dc..89d4ee59d9 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;

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 89d4ee59d9..eaa0ddd716 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);
 }

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 879ecb4e2f..d7d6994bcd 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 1a1412420a..4d8b176fbf 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);
+}

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 717aeb4d7f..c08378f5f3 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 +

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 c08378f5f3..a5ddb3b6fb 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) {

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 8134beb6e3..3d74e5e47f 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 0738b5af0b..33b8a98d7f 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 1151ed60da..2fcd8cd994 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 0000000000..cb48cafa45
--- /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

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 01edd07261..a8a39a7018 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 ebf15ca439..7bf3ea1c9e 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

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 d7d6994bcd..ceeb8af23c 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 4e5eb5061c..c13a3b7e4f 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 0000000000..0058cd5e36
--- /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

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 ceeb8af23c..772abf5a84 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 306dad5d9e..84b18a2738 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 0000000000..f8646d9450
--- /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

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 772abf5a84..1aebe8e98e 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 2f6fa78f0c..efca75af30 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 0000000000..90b243c31d
--- /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 c312d6db40..0142f422f4 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 0000000000..66304d6a74
--- /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

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 d7d6994bcd..f1d140520c 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 677a459afe..9909cab5ce 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 cd4e018be3..d930fb7d27 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);
+}

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                                  | 174 +++++++++---------
 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, 156 insertions(+), 178 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 2fcd8cd994..ee1dbeffa4 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 1aebe8e98e..1a0ded4a00 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);
-                        }
-                    }
-
-                    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});
-                    }
-
-                    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 (enum_field_names) |set| {
+                    set.putAssumeCapacity(field_name, {});
                 }
-            } else {
-                return sema.fail(block, src, "unions must have at least one field", .{});
+
+                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);
+                    }
+                }
+
+                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});
+                }
+
+                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 4bc96c4259..579a7970b7 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 582ea230ef..55847b8add 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 40f8ca0fb3..ba8379cd72 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 0000000000..051e464b72
--- /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 f34065b69d..0000000000
--- 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 44876e938a..0000000000
--- 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 0b4f395c81..0000000000
--- 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 2121568dd2..0000000000
--- 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 2121568dd2..0000000000
--- 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 ee6d1b8b7c..0000000000
--- 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 644cba74c1..321de1e3f6 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 {

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 a44296c920..00ce2cc5ba 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 e514e0fd88..06534a2f7e 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 = 

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 f1d140520c..e5700a6fe4 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 c057f7a842..a5eb25d4f5 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));
     }
 
     {

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 e5700a6fe4..29a53ebb2a 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 0000000000..d8fa4e5726
--- /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'

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 29a53ebb2a..5fd1c1ce4c 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 d8fa4e5726..f3e51a1bed 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'

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                             | 97 ++++++++++++-----------
 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, 69 insertions(+), 57 deletions(-)

diff --git a/test/link.zig b/test/link.zig
index a8a39a7018..88b370f343 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,41 +59,11 @@ 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", .{
-        .build_modes = 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", .{
-        .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/search_strategy/build.zig", .{
+    cases.addBuildFile("test/link/macho/entry/build.zig", .{
         .build_modes = true,
     });
 
@@ -107,7 +72,47 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
         .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/needed_library/build.zig", .{
+        .build_modes = true,
+    });
+
+    cases.addBuildFile("test/link/macho/objc/build.zig", .{
+        .build_modes = true,
+        .requires_macos_sdk = true,
+    });
+
+    cases.addBuildFile("test/link/macho/objcpp/build.zig", .{
+        .build_modes = true,
+        .requires_macos_sdk = 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/stack_size/build.zig", .{
+        .build_modes = 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 dea225dd6f..25759f5619 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 9dbc0e6473..5a7044d960 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 39a82bc6a7..e556b5bb23 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 3abf48df7a..91c44baf52 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 7bf3ea1c9e..031a05cedf 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();
 

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 984758565c..c757561b07 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,

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 5ff0a5d61b..5d208b31a2 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

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 e9e7460314..5f52b04ce4 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

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 0a99432c67..a0b8001a9e 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 d90ebc3de8..2364a40f9f 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 0000000000..294ff359f0
--- /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;
+}

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 8eb3e2175b..95a0a8e4aa 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 = {} };
     }
 }

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 30e2192268..1bdd9426a5 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.

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 2364a40f9f..de8a832029 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,
             };
         }
     }

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 294ff359f0..1edb551ed9 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,

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 a0b8001a9e..28f8fb1a70 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 de8a832029..bc1b1beebb 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 1edb551ed9..cafed8d526 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;

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 672f4fa4ba..28935ffa34 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 bee9375b5a..2bb8c848bc 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 ee1dbeffa4..2001e6950a 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 ce476fea04..d3f9676f11 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 868ea8d42a..b90c733dea 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 0000000000..a818a3d75d
--- /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

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 002ad49d64..6dcedd93b8 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);
+        },
     };
 }
 

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 b5defc2e9c..57f0d126d8 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| {

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 236923c1d8..b2a443b253 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);

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 14ae142a3f..a6dafce20e 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 3da086a382..e4370c703e 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 emit = options.emit.?;
     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.

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 7b219a210e..89a0b3ab3e 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 {

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 55847b8add..700f524556 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);

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 f77f73bce0..155c59bdfc 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 995fdda7ea..6d2180e8e7 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 d6ac3d0276..32b95a4c21 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 0586c99432..a9a343439d 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 700f524556..4432ae9cf3 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 26e3d91373..4a824bc9cf 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);
     }
 }
 

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 4432ae9cf3..fb2ca1e3fc 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",

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 a9a343439d..983813d780 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;

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 155c59bdfc..00553bb520 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 b8f75f649e..85835ebf18 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 196afbc835..a4e9b2576d 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 6dcedd93b8..4f8c0025c5 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 af39154a3f..5e0d815c96 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 32b95a4c21..d059ee09a3 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 983813d780..8c84f61a81 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 a6dafce20e..31b54f705a 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 6449be9c56..955044f90d 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 1b5ddbbf8b..92e9dce3ad 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 917e4c18d1..2f67c35205 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 e4370c703e..7a50843023 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 bd86d87201..7bf51c7ad3 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 16f7841c2d..9a8927dcb4 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 e295dceb55..b2f6edddfb 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 1bdd9426a5..6267865888 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 971fe19e36..dfce4d83b8 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 7010e736dc..d4a09f7968 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"
     );
 

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 00553bb520..64f9f97809 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 6d2180e8e7..3ae61c264f 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 fb2ca1e3fc..6a66fb9d70 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 4a824bc9cf..ad857fb9c2 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,

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 6a66fb9d70..f6afa33df1 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,

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 266b4181e0..a8567f2492 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.

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 5e0d815c96..060afba694 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 76e687c7d6..90ba377847 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 8c84f61a81..0898c8fe87 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 4deac5275f..ceb60ff096 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 17d88fa03d..b19834f8c3 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 cbbcd11a8a..16e40c16f8 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 0d030be329..fb4f93af02 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 31b54f705a..a0c0c5c369 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 2f67c35205..9902886bac 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 dfce4d83b8..91d171d237 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 68b524b415..12ff530f8e 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 5202fb15fc..3c8eabe01d 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 d261b5ee33..f1656546f0 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",

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 d059ee09a3..091b88e719 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 f400053b0f..826fdd0f6b 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;

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 3c8eabe01d..405a7fe2bf 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 {

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 fa23b861e3..41b87ade21 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 540c560839..637d491f49 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);
+    });
 }

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 0ff5285201..1c2212c1a4 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 3fec555321..053065b699 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 060afba694..6d778b955a 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 091b88e719..aa02288df7 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 a886b2d28e..336a6c45ed 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 0bca9a9d16..e1836dc1e0 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| {

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 96d10f1e83..d9784090cd 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 1c2212c1a4..6823248431 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 053065b699..00f1cce2bd 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 b244a73869..d0ad9171ee 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 5d208b31a2..16804a0a2b 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 9fd7c0be65..9c77c7d120 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 3a54e82c38..1b280fbae5 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 a101b96be7..0f0e212e3c 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 c61f2d0790..ba817f0a4d 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 2c2bc92c96..69312df838 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 6d778b955a..84dd273947 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 336a6c45ed..12e13815f8 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 a0c0c5c369..a85969d61e 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 92e9dce3ad..a01b9cf7c3 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 9902886bac..ade4f62f91 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 7a50843023..020388cee8 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 6267865888..626f176652 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 91d171d237..dd3a7e797b 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 826fdd0f6b..e3f0daaa44 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 a8567f2492..babded13f9 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 835b084740..d989a33541 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 a30532aee7..ddd9e74cf2 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 fa2e127107..524c69d7b7 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 3cc8bfb355..636235a5b3 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 e1836dc1e0..bd3c1c5dec 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;

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 6bb7d73b41..38185df7e7 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 1b280fbae5..85cfb57b2e 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 0000000000..764c89db8f
--- /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

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 547a2d76b8..b89e2d8511 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 85cfb57b2e..d40ad9da11 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 764c89db8f..dd906f70fb 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

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 ba817f0a4d..9247d3bc43 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;
 }

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 d40ad9da11..2ca2f7bad7 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"
 

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 f1e9924258..9a757c8197 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 2ca2f7bad7..2bacf6d838 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 dd906f70fb..d3532e0976 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"

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 6823248431..bb3db637d6 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 9c77c7d120..45002fda15 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 d3532e0976..3f330cf548 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 \

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 16804a0a2b..730ecbda23 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'
 

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 d0ad9171ee..bf55dda510 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/

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 45002fda15..02ab218756 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/

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 bf55dda510..4f3c5697b0 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 02ab218756..dc22a02ed5 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
 
-# Here we skip some tests to save time.
-release/bin/zig build test docs \
+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.
+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/

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 363d168a21..6a66913a5a 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 58dad5f14c..6fe9756b92 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 b748745da9..0000000000
--- 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 0000000000..a06347c169
--- /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 0000000000..702bb45f91
--- /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 0000000000..6a19ee41f3
--- /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 0000000000..41fb34f8bc
--- /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 0000000000..156406ac35
--- /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 0000000000..f972d75f0b
--- /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 0000000000..9a5975ffe5
--- /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

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 c79ccb5113..b0a0f6d407 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];
     }
 };

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 00f1cce2bd..0000000000
--- 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 730ecbda23..090c133e63 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 -

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 bb3db637d6..c8e757dc4e 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 090c133e63..e6b65233bd 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 bd3c1c5dec..5a58daecaa 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| {

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 e6b65233bd..26befaae79 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 `

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 84dd273947..0914685c77 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 3ae61c264f..3577115ded 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 0898c8fe87..d50b463606 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 9daa96eb8f..38f794cfda 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;
 

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 7c077a9ec8..4371444b96 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,

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 5a58daecaa..a622521182 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 {

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 4cb9dbf5c5..147bf610d8 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,
         };

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 26befaae79..5eab6defff 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: |

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 38185df7e7..fc14ad3ec9 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

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 2bacf6d838..ba33311a4d 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"

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 236923c1d8..616ba54ab3 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;
         }

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 e214d1b124..4a0abb1dfa 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);

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 626f176652..37e25e4360 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 4a0abb1dfa..c80d26d17d 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 a1308ec045..50827ca9fb 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;
 

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 57f0d126d8..1cbf188d2c 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 88b370f343..215a0511fc 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 0000000000..95ce444659
--- /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 0000000000..29be3af0ac
--- /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;
+}

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 020388cee8..7c04972e4c 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,

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 28f8fb1a70..b6131f4bb3 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 bc1b1beebb..f983bdfdf0 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 => {

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 b6131f4bb3..90701b4509 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;

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 aa02288df7..5c66c8d6a1 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 0000000000..7ec539dcd1
--- /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 0000000000..ccd828bd5c
--- /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 180cf74bcb..f8ede21a9d 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",
         });
     }
 

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 5c66c8d6a1..28ff4cc1c2 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 025decdb4b..f5340458a5 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 81a892183f..4a09c09cc9 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 d50b463606..5c537cd5bc 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 f6afa33df1..d2885f537f 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 efca75af30..92f277b946 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);
+}

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 28ff4cc1c2..f3ddf21206 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 8a872f6378..49183227b5 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));
+}

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 1cbf188d2c..b47f962a9d 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 1e22fd10a3..168f5d9d58 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";

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 c757561b07..24b438a53e 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.

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 f3ddf21206..582299bc9e 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 f8ede21a9d..60de07d1e3 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 {

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 9247d3bc43..04d736609a 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 d5583dcc80..9dc3367688 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 40b5eb9204..1ed9604612 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 30e456fcbd..768cc03285 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 8a2086e9ad..348e3a7133 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 a03764a91c..fda6ad98b9 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 3577115ded..45e0779c54 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 582299bc9e..a3207b8539 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 d2885f537f..1592dcf469 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 ac3a4daeab..fa0877258c 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 84b18a2738..b355c85819 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 044e4ff049..d68cd89210 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 eb29c9038d..12c874f8ba 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 0000000000..e4d9eed079
--- /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

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 a3207b8539..24bbdb0b0c 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 49183227b5..bc1c3628d7 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);
+}

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 24bbdb0b0c..2355e8374d 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 c13a3b7e4f..28261daf1f 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));
+}

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 2355e8374d..9538073e5c 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 5c537cd5bc..98458854d1 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 8c34f5741b..540914bd25 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);
+}

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 9538073e5c..42d5e96d3d 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 d68cd89210..47ba63c429 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);
+}

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 9247d3bc43..37631a9678 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 7f2e368121..8edfef9838 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 3f91a0c79b..d619926f99 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 8eb23c1d82..2bb40fc2bd 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 bb5d6a377b..077d510646 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 53205e2ed9..43bc160cda 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 233dfec815..2eb7b5ade8 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 f6949ee3ce..770721cb80 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 d941c242d2..065ea44896 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 0d9ccc8969..58f49c483e 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 35d754ad19..973a312665 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 201e1cc860..46d46cdfa4 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 8006a623b5..2da3f1ac21 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 cb1237c900..1620a8e380 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 cc50bbbe45..68f5bc4a9a 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 f3fac0038e..8f57f9033a 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 d80ae2f6a0..16581b7782 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 fb478ed6ed..e1c147d25a 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 a1269ad252..9133477017 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 724be45181..ff71695303 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 8a535f372e..7c8e42f105 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 adb150446d..44b411bb2c 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 b71cdb7932..e0e8cf51cc 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 b18ca9fab0..8e3a007849 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 40b5eb9204..0b858d061b 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 2a141ac243..ee6ccaacac 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 aef0e0eb19..8ab1b8a6d2 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 539f3612f9..c4dafcd3b8 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 386ad7796a..be975dddbf 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 a07fc13af1..902e3ee19c 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 228c6d62ae..ae403c1d03 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 a121a3f5ba..c562230cca 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 8f2eebccd4..08a2ec78c4 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 4f8c0025c5..824a1a26b6 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 2001e6950a..1924fb444b 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 04cad19354..3a13dde1ab 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 f3ddf21206..579f423e76 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 8abc083a1e..00a2ff380a 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 0081dc4d5d..0f3ee9a2a2 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 935183bbc6..2ec7b3e140 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 37e25e4360..727f329f4b 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 367bed69cf..54d9c969a5 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 d4a09f7968..cc6c0f22a7 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 9909cab5ce..ea423e8488 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 585fe381b0..092f3a1fed 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 b519c71865..221120bb73 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 54826cb0d1..a013688f4e 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 263f2c046e..5313b612b0 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 1fc3f64cda..8fa5fc503e 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 d3f9676f11..8cf0f311af 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 dbfeb64111..e061814692 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 bc30b5cbe6..016dfb1412 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 af1c79f5f4..b218416e39 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 01c36ad72d..11ccce35a2 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 a153d0f2eb..b7c1ae1647 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;
             }

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 6c7dadf1e1..fd6967bb96 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,

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 9247d3bc43..98db21eebf 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#}

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 16acef8e48..6acc004851 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);

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 42d5e96d3d..4f558ccae4 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 b5cb5e472a..ed18f43f48 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'

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 8a3c1f0ca7..46b24deb45 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) {

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 46b24deb45..8a3c1f0ca7 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) {

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 b47f962a9d..4c05586159 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");

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 5eab6defff..e77c759275 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: |

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 98458854d1..cddbdc6822 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 {

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 a622521182..a329233199 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;

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 52c202fded..e03d26d7c4 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) {

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 33b8a98d7f..3ce9f3c1d3 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 d61d198c7e..40dfc8cebb 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 7c04972e4c..8eb29dcfc7 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 935183bbc6..9bcf5243c1 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{},

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 3ce9f3c1d3..5e217890b7 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();
 

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 863a8030c0..829d20057a 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 });
+}

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 28f8fb1a70..01d2443a31 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;
             }
           }

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  | 1242 +++++++++++++++++++++++++++++++++++----------
 lib/std/debug.zig |   40 +-
 src/link/Coff.zig |   29 +-
 3 files changed, 1025 insertions(+), 286 deletions(-)

diff --git a/lib/std/coff.zig b/lib/std/coff.zig
index 4371444b96..a017ae8422 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 pe_magic = "PE\x00\x00";
 
-        const in = self.in_file.reader();
+        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);
 
-        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,
+        // 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;
+            }
         }
 
-        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 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 getCoffHeader(self: Coff) CoffHeader {
+        return @ptrCast(*align(1) CoffHeader, self.data[self.coff_header_offset..][0..@sizeOf(CoffHeader)]).*;
     }
 
-    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 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());
+        }
+
+        const Tag = enum {
+            symbol,
+            func_def,
+            debug_info,
+            weak_ext,
+            file_def,
+            sect_def,
+        };
+
+        const Record = union(Tag) {
+            symbol: Symbol,
+            debug_info: DebugInfoDefinition,
+            func_def: FunctionDefinition,
+            weak_ext: WeakExternalDefinition,
+            file_def: FileDefinition,
+            sect_def: SectionDefinition,
+        };
+
+        /// 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].*,
+            };
+        }
+
+        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 };
+        }
     };
 
-    magic: u16,
-    data_directory: [IMAGE_NUMBEROF_DIRECTORY_ENTRIES]DataDirectory,
-    entry_addr: u32,
-    code_base: u32,
-    image_base: u64,
-};
+    pub const Strtab = struct {
+        buffer: []const u8,
 
-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 Section = struct {
-    header: SectionHeader,
-};
-
-const SectionHeader = struct {
-    const Misc = union {
-        physical_address: u32,
-        virtual_size: u32,
+        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);
+        }
     };
-
-    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,
 };
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 5e217890b7..917354edf7 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 a01b9cf7c3..6536fbd1ac 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);

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         | 504 ++++++++++++++++++++++++++------------
 src/link/MachO.zig        |   4 +-
 src/link/MachO/Object.zig |  15 ++
 test/stack_traces.zig     |   8 +-
 5 files changed, 415 insertions(+), 160 deletions(-)

diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 917354edf7..bfe45569d7 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 40dfc8cebb..5ddc8cb3dc 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);
+        var include_directories = std.ArrayList(FileEntry).init(arena);
+        var file_entries = std.ArrayList(FileEntry).init(arena);
 
-        while (true) {
-            const dir = try in.readUntilDelimiterAlloc(arena, 0, math.maxInt(usize));
-            if (dir.len == 0) break;
-            try include_directories.append(dir);
+        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 file_entries = std.ArrayList(FileEntry).init(arena);
         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 getString(di: DwarfInfo, offset: u64) ![]const u8 {
+        return getStringGeneric(di.debug_str, offset);
     }
 
-    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)
-            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 8eb29dcfc7..91eaedc734 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 9bcf5243c1..22627975f2 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 06534a2f7e..ed0dc9e235 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

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 5277da7d2b..e84fcd910a 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

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  | 152 +++++++++++++++++++++++++++++++++++------------
 2 files changed, 130 insertions(+), 49 deletions(-)

diff --git a/lib/docs/main.js b/lib/docs/main.js
index 5a3572a629..8f6bbcedd2 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 f983bdfdf0..128e09faf2 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,
-                );
 
-                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
-            }
+            // Put inside path the starting index of each decl name that
+            // 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;
+                    }
+
+                    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" };

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 8f6bbcedd2..47bbc9591a 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 128e09faf2..f8560407fe 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
                     {

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 5a3572a629..f33646d258 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;
             }
           }

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 5a3572a629..cd8af7c8e9 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);
   }
 

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 bfe45569d7..39dcfe72a6 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 22627975f2..00fd16054b 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")) {

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 39dcfe72a6..201545c18d 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 };

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 d3f9676f11..804a061da2 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 01ef8c7d29..861b786a56 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();

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 b8d27a6da0..2282c21299 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");
 }

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 24b438a53e..5cc55518ad 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`.

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 201545c18d..a7f0b202cb 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 5ddc8cb3dc..c307cdb733 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 91eaedc734..764e4e71b2 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);

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 0914685c77..1bc9719e1b 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 e03d26d7c4..52c202fded 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) {

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 5cc55518ad..24b438a53e 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`.

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 d5006bf81f..937b1998ff 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();
+}

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 9909cab5ce..4e9ea882e9 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,
         }
     }

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 2001e6950a..db0ed47a04 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 => {

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 0c8f9b0861..2de9db63d1 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#}

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 4f558ccae4..846b6af3bd 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 d930fb7d27..ba4bca0c1a 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 e4d9eed079..008d14f2fc 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

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 846b6af3bd..4e1b885486 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 0000000000..734b026038
--- /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'

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 4e1b885486..22aa26f737 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 14297bd61c..971e52a0b5 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);
+}

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 22aa26f737..4af9c80e02 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 0000000000..747cdf3df6
--- /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

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 1f9bee463c..7d7f2a62a4 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));
 

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 fc14ad3ec9..c7d8470268 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

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 ed0dc9e235..3a8682b5a5 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

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 1bc9719e1b..1b424a4001 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);

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 c33d7b35ab..f01f580083 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;

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 a017ae8422..45d5d3d79e 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 {

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 8ab1b8a6d2..b7f95e6366 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);

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 1b424a4001..d6bf121adb 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|

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 e77c759275..33747d4d18 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: |

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 45e0779c54..34617ed3e2 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.

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 16581b7782..cc43e11a7d 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 34617ed3e2..a92849e127 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 b24a00150a..3e8005269f 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 0f6b6baee3..106d2feec0 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 cddbdc6822..d872057beb 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 1592dcf469..cc6e5706ee 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 ba8379cd72..12edd6f9a3 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 d274befaf3..0000000000
--- 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 709d30af33..9e96163cc0 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 92f277b946..e2078c66df 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 {

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 d6bf121adb..03d7962ccc 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) {

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 3e8005269f..fc2a7f872a 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 e0cb5ba68c..3bc8c58389 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 94c8f6de50..4491a98e9c 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 cac4c7e5e2..de69fa409f 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'

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 ceb60ff096..c02989294b 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,

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 c02989294b..4e33867169 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) {

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 4345625dc1..1687e07f9c 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>

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 03d7962ccc..353a2f1ca3 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 a85969d61e..b46ea51013 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 6536fbd1ac..c30544d3b7 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 ade4f62f91..293771dd2a 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 e99a1af8fc..b50cc4b009 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,

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 9a5975ffe5..6271a8b15d 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

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 d872057beb..d1c68b430c 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 b355c85819..684b01a797 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 28261daf1f..eb693147e6 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);
+}

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 66b969d0bf..4cce1cf71b 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;
+}

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 41b87ade21..b0fae81475 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 2a7902dfb2..bfd683ec4c 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 0000000000..08be1fd471
--- /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;
+}

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 fc2a7f872a..2907999c25 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 12edd6f9a3..8f581f372e 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 0000000000..f0d357efd1
--- /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,
+        },
+    };
+}

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 24b438a53e..59f2a2173f 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 b46ea51013..60c6b24640 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,

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 45d5d3d79e..f9de318e7a 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 1687e07f9c..4345625dc1 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>

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 5c259bc41a..ddcb24ffd3 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 {},
 };

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 540914bd25..9bc1c1f824 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);
+}

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 f01f580083..7b018f62d5 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 cc43e11a7d..4a9b7a498f 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 15262f67a2..e897850b83 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 d71afe5fe5..0be2e7ab08 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 937b1998ff..7e64eff49f 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 48dddf636d..11aec707ab 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 2907999c25..047d3f84c2 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 e2078c66df..5d6b084be5 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 7ec539dcd1..04f64c2303 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 0000000000..758166dd7f
--- /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'

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 7a540a15f1..0d10119cb7 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>

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 703ae84604..6a3f2620f2 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 f8560407fe..db681157ae 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);
     }
 }
 

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 e84fcd910a..89c26952e5 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:

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 c562230cca..c13d2895c9 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 7c2016901f..cae77d6e37 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));
+    }
+}

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 3398478266..943d0aad08 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 0000000000..ad670fe88c
--- /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

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 047d3f84c2..17d3b02da3 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 0000000000..b4644b132c
--- /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'

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 0000000000..6f850e6fe4
--- /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 0000000000..b00c27986f
--- /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

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 17d3b02da3..586f1b2ee8 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 579a7970b7..f315d7f014 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 9e96163cc0..517414780b 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));
+}

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 586f1b2ee8..1030fe0473 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 cc6e5706ee..5ff9da8913 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 971e52a0b5..2b715c3b23 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);
+}

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 1030fe0473..ff32dc4b33 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 9bc1c1f824..bd312e9cda 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();
+}

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 d9784090cd..f50d8b48dc 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 ba33311a4d..ccfa698765 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"
+echo "Looking for non-conforming code formatting..."
+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
 
-echo "Looking for non-conforming code formatting..."
-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 \
   -fwasmtime \
diff --git a/ci/zinc/linux_test_stage3_release.sh b/ci/zinc/linux_test_stage3_release.sh
index 3f330cf548..2758ea9ca3 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 386773e30c..0000000000
--- 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()

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 7a1db54ea2..ec9ddfcffb 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,

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 f50d8b48dc..35fe217dc8 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}"

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                             |  59 ++++++--
 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, 287 insertions(+), 315 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 35fe217dc8..835f3c4d62 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 4df3106f31..0000000000
--- 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 4f3c5697b0..4bb083e5e2 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 33747d4d18..45504c5b6e 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 2788eb2df6..0000000000
--- 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 6fe9756b92..022de1d217 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 9d70a9b09c..4219bd19ac 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 a06347c169..fb5b1fa9e4 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 702bb45f91..383ddf7b37 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 6a19ee41f3..fc3dfcf4d4 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 41fb34f8bc..d05554d5a5 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 156406ac35..7e117b313a 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 f972d75f0b..b494ea6e47 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 6271a8b15d..ffd366d454 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 dc22a02ed5..326e3cadf5 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 0000000000..5e97ccc913
--- /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 0000000000..146eafe601
--- /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 c7d8470268..3aa9e9af7b 100644
--- a/ci/zinc/drone.yml
+++ b/ci/zinc/drone.yml
@@ -9,17 +9,33 @@ workspace:
   path: /workspace
 
 steps:
-- name: test_stage3_debug
-  image: ci/debian-amd64:11.1-8
+- name: configure_git
+  image: ci/debian-amd64:11.1-9
   commands:
-  - ./ci/zinc/linux_test_stage3_debug.sh
+  - ./ci/zinc/configure_git
+
+- name: test_stage3_debug
+  depends_on:
+  - configure_git
+  image: ci/debian-amd64:11.1-9
+  commands:
+  - ./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.sh
+  - ./ci/zinc/linux_test_stage3_release
 
-- name: package
+- name: build_aarch64_macos
+  depends_on:
+  - test_stage3_release
+  image: ci/debian-amd64:11.1-9
+  commands:
+  - ./ci/zinc/build_aarch64_macos
+
+- 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 9a757c8197..0000000000
--- 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 b89e2d8511..f7a7dccbae 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 ccfa698765..074e80d19b 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 2758ea9ca3..24bdde17d0 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 0000000000..1ee4d5f18d
--- /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 0000000000..4306e5ae69
--- /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"

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 ff32dc4b33..f884684d73 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 0000000000..d990a85f9e
--- /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