Commit 9bf715de74a7d5badeae932afb594b7c6b33afa3 | zig

src/Zcu.zig+39-1

...	@@ -4072,15 +4072,53 @@ pub fn navValIsConst(zcu: *const Zcu, val: InternPool.Index) bool {	...	@@ -4072,15 +4072,53 @@ pub fn navValIsConst(zcu: *const Zcu, val: InternPool.Index) bool {
4072	};	4072	};
4073	}	4073	}
4074		4074
		4075	pub const CodegenFailError = error{
		4076	/// Indicates the error message has been already stored at `Zcu.failed_codegen`.
		4077	CodegenFail,
		4078	OutOfMemory,
		4079	};
		4080
4075	pub fn codegenFail(	4081	pub fn codegenFail(
4076	zcu: *Zcu,	4082	zcu: *Zcu,
4077	nav_index: InternPool.Nav.Index,	4083	nav_index: InternPool.Nav.Index,
4078	comptime format: []const u8,	4084	comptime format: []const u8,
4079	args: anytype,	4085	args: anytype,
4080	) error{ CodegenFail, OutOfMemory } {	4086	) CodegenFailError {
4081	const gpa = zcu.gpa;	4087	const gpa = zcu.gpa;
4082	try zcu.failed_codegen.ensureUnusedCapacity(gpa, 1);	4088	try zcu.failed_codegen.ensureUnusedCapacity(gpa, 1);
4083	const msg = try Zcu.ErrorMsg.create(gpa, zcu.navSrcLoc(nav_index), format, args);	4089	const msg = try Zcu.ErrorMsg.create(gpa, zcu.navSrcLoc(nav_index), format, args);
4084	zcu.failed_codegen.putAssumeCapacityNoClobber(nav_index, msg);	4090	zcu.failed_codegen.putAssumeCapacityNoClobber(nav_index, msg);
4085	return error.CodegenFail;	4091	return error.CodegenFail;
4086	}	4092	}
		4093
		4094	pub fn codegenFailMsg(zcu: Zcu, nav_index: InternPool.Nav.Index, msg: ErrorMsg) CodegenFailError {
		4095	const gpa = zcu.gpa;
		4096	{
		4097	errdefer msg.deinit(gpa);
		4098	try zcu.failed_codegen.putNoClobber(gpa, nav_index, msg);
		4099	}
		4100	return error.CodegenFail;
		4101	}
		4102
		4103	pub fn codegenFailType(
		4104	zcu: *Zcu,
		4105	ty_index: InternPool.Index,
		4106	comptime format: []const u8,
		4107	args: anytype,
		4108	) CodegenFailError {
		4109	const gpa = zcu.gpa;
		4110	try zcu.failed_types.ensureUnusedCapacity(gpa, 1);
		4111	const msg = try Zcu.ErrorMsg.create(gpa, zcu.typeSrcLoc(ty_index), format, args);
		4112	zcu.failed_types.putAssumeCapacityNoClobber(ty_index, msg);
		4113	return error.CodegenFail;
		4114	}
		4115
		4116	pub fn codegenFailTypeMsg(zcu: Zcu, ty_index: InternPool.Index, msg: ErrorMsg) CodegenFailError {
		4117	const gpa = zcu.gpa;
		4118	{
		4119	errdefer msg.deinit(gpa);
		4120	try zcu.failed_types.ensureUnusedCapacity(gpa, 1);
		4121	}
		4122	zcu.failed_types.putAssumeCapacityNoClobber(ty_index, msg);
		4123	return error.CodegenFail;
		4124	}

src/Zcu/PerThread.zig+2-9

src/arch/aarch64/CodeGen.zig+16-36

 @@ -24,7 +24,6 @@ const build_options = @import("build_options");
 const Alignment = InternPool.Alignment;
 const CodeGenError = codegen.CodeGenError;
-const Result = codegen.Result;
 const bits = @import("bits.zig");
 const abi = @import("abi.zig");
 @@ -51,7 +50,6 @@ debug_output: link.File.DebugInfoOutput,
 target: *const std.Target,
 func_index: InternPool.Index,
 owner_nav: InternPool.Nav.Index,
-err_msg: ?*ErrorMsg,
 args: []MCValue,
 ret_mcv: MCValue,
 fn_type: Type,
 @@ -167,7 +165,7 @@ const DbgInfoReloc = struct {
     name: [:0]const u8,
     mcv: MCValue,
-    fn genDbgInfo(reloc: DbgInfoReloc, function: Self) CodeGenError!void {
+    fn genDbgInfo(reloc: DbgInfoReloc, function: Self) !void {
         switch (reloc.tag) {
             .arg,
             .dbg_arg_inline,
 @@ -181,7 +179,7 @@ const DbgInfoReloc = struct {
         }
     }
-    fn genArgDbgInfo(reloc: DbgInfoReloc, function: Self) CodeGenError!void {
+    fn genArgDbgInfo(reloc: DbgInfoReloc, function: Self) !void {
         switch (function.debug_output) {
             .dwarf => |dw| {
                 const loc: link.File.Dwarf.Loc = switch (reloc.mcv) {
 @@ -209,7 +207,7 @@ const DbgInfoReloc = struct {
         }
     }
-    fn genVarDbgInfo(reloc: DbgInfoReloc, function: Self) CodeGenError!void {
+    fn genVarDbgInfo(reloc: DbgInfoReloc, function: Self) !void {
         switch (function.debug_output) {
             .dwarf => |dwarf| {
                 const loc: link.File.Dwarf.Loc = switch (reloc.mcv) {
 @@ -327,7 +325,7 @@ pub fn generate(
     liveness: Liveness,
     code: *std.ArrayList(u8),
     debug_output: link.File.DebugInfoOutput,
-) CodeGenError!Result {
+) CodeGenError!void {
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
     const func = zcu.funcInfo(func_index);
 @@ -353,7 +351,6 @@ pub fn generate(
         .bin_file = lf,
         .func_index = func_index,
         .owner_nav = func.owner_nav,
-        .err_msg = null,
         .args = undefined, // populated after `resolveCallingConventionValues`
         .ret_mcv = undefined, // populated after `resolveCallingConventionValues`
         .fn_type = fn_type,
 @@ -370,10 +367,7 @@ pub fn generate(
     defer function.dbg_info_relocs.deinit(gpa);
     var call_info = function.resolveCallingConventionValues(fn_type) catch |err| switch (err) {
-        error.CodegenFail => return Result{ .fail = function.err_msg.? },
+        error.CodegenFail => return error.CodegenFail,
-        error.OutOfRegisters => return Result{
-            .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
-        },
         else => |e| return e,
     };
     defer call_info.deinit(&function);
 @@ -384,15 +378,14 @@ pub fn generate(
     function.max_end_stack = call_info.stack_byte_count;
     function.gen() catch |err| switch (err) {
-        error.CodegenFail => return Result{ .fail = function.err_msg.? },
+        error.CodegenFail => return error.CodegenFail,
-        error.OutOfRegisters => return Result{
+        error.OutOfRegisters => return function.fail("ran out of registers (Zig compiler bug)", .{}),
-            .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
-        },
         else => |e| return e,
     };
     for (function.dbg_info_relocs.items) |reloc| {
-        try reloc.genDbgInfo(function);
+        reloc.genDbgInfo(function) catch |err|
+            return function.fail("failed to generate debug info: {s}", .{@errorName(err)});
     }
     var mir: Mir = .{
 @@ -417,15 +410,9 @@ pub fn generate(
     defer emit.deinit();
     emit.emitMir() catch |err| switch (err) {
-        error.EmitFail => return Result{ .fail = emit.err_msg.? },
+        error.EmitFail => return function.failMsg(emit.err_msg.?),
         else => |e| return e,
     };
-    if (function.err_msg) |em| {
-        return Result{ .fail = em };
-    } else {
-        return Result.ok;
-    }
 }
 fn addInst(self: *Self, inst: Mir.Inst) error{OutOfMemory}!Mir.Inst.Index {
 @@ -567,7 +554,7 @@ fn gen(self: *Self) !void {
                 .data = .{ .rr_imm12_sh = .{ .rd = .sp, .rn = .sp, .imm12 = size } },
             });
         } else {
-            return self.failSymbol("TODO AArch64: allow larger stacks", .{});
+            @panic("TODO AArch64: allow larger stacks");
         }
         _ = try self.addInst(.{
 @@ -6191,10 +6178,7 @@ fn genTypedValue(self: *Self, val: Value) InnerError!MCValue {
             .load_direct => |sym_index| .{ .linker_load = .{ .type = .direct, .sym_index = sym_index } },
             .load_symbol, .load_tlv, .lea_symbol, .lea_direct => unreachable, // TODO
         },
-        .fail => |msg| {
+        .fail => |msg| return self.failMsg(msg),
-            self.err_msg = msg;
-            return error.CodegenFail;
-        },
     };
     return mcv;
 }
 @@ -6355,18 +6339,14 @@ fn wantSafety(self: *Self) bool {
     };
 }
-fn fail(self: *Self, comptime format: []const u8, args: anytype) InnerError {
+fn fail(self: *Self, comptime format: []const u8, args: anytype) error{ OutOfMemory, CodegenFail } {
     @branchHint(.cold);
-    assert(self.err_msg == null);
+    return self.pt.zcu.codegenFail(self.owner_nav, format, args);
-    self.err_msg = try ErrorMsg.create(self.gpa, self.src_loc, format, args);
-    return error.CodegenFail;
 }
-fn failSymbol(self: *Self, comptime format: []const u8, args: anytype) InnerError {
+fn failMsg(self: *Self, msg: *ErrorMsg) error{ OutOfMemory, CodegenFail } {
     @branchHint(.cold);
-    assert(self.err_msg == null);
+    return self.pt.zcu.codegenFailMsg(self.owner_nav, msg);
-    self.err_msg = try ErrorMsg.create(self.gpa, self.src_loc, format, args);
-    return error.CodegenFail;
 }
 fn parseRegName(name: []const u8) ?Register {

src/arch/arm/CodeGen.zig+19-31

 @@ -23,7 +23,6 @@ const log = std.log.scoped(.codegen);
 const build_options = @import("build_options");
 const Alignment = InternPool.Alignment;
-const Result = codegen.Result;
 const CodeGenError = codegen.CodeGenError;
 const bits = @import("bits.zig");
 @@ -245,7 +244,7 @@ const DbgInfoReloc = struct {
     name: [:0]const u8,
     mcv: MCValue,
-    fn genDbgInfo(reloc: DbgInfoReloc, function: Self) CodeGenError!void {
+    fn genDbgInfo(reloc: DbgInfoReloc, function: Self) !void {
         switch (reloc.tag) {
             .arg,
             .dbg_arg_inline,
 @@ -259,7 +258,7 @@ const DbgInfoReloc = struct {
         }
     }
-    fn genArgDbgInfo(reloc: DbgInfoReloc, function: Self) CodeGenError!void {
+    fn genArgDbgInfo(reloc: DbgInfoReloc, function: Self) !void {
         switch (function.debug_output) {
             .dwarf => |dw| {
                 const loc: link.File.Dwarf.Loc = switch (reloc.mcv) {
 @@ -287,7 +286,7 @@ const DbgInfoReloc = struct {
         }
     }
-    fn genVarDbgInfo(reloc: DbgInfoReloc, function: Self) CodeGenError!void {
+    fn genVarDbgInfo(reloc: DbgInfoReloc, function: Self) !void {
         switch (function.debug_output) {
             .dwarf => |dw| {
                 const loc: link.File.Dwarf.Loc = switch (reloc.mcv) {
 @@ -335,7 +334,7 @@ pub fn generate(
     liveness: Liveness,
     code: *std.ArrayList(u8),
     debug_output: link.File.DebugInfoOutput,
-) CodeGenError!Result {
+) CodeGenError!void {
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
     const func = zcu.funcInfo(func_index);
 @@ -377,10 +376,7 @@ pub fn generate(
     defer function.dbg_info_relocs.deinit(gpa);
     var call_info = function.resolveCallingConventionValues(func_ty) catch |err| switch (err) {
-        error.CodegenFail => return Result{ .fail = function.err_msg.? },
+        error.CodegenFail => return error.CodegenFail,
-        error.OutOfRegisters => return Result{
-            .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
-        },
         else => |e| return e,
     };
     defer call_info.deinit(&function);
 @@ -391,15 +387,14 @@ pub fn generate(
     function.max_end_stack = call_info.stack_byte_count;
     function.gen() catch |err| switch (err) {
-        error.CodegenFail => return Result{ .fail = function.err_msg.? },
+        error.CodegenFail => return error.CodegenFail,
-        error.OutOfRegisters => return Result{
+        error.OutOfRegisters => return function.fail("ran out of registers (Zig compiler bug)", .{}),
-            .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
-        },
         else => |e| return e,
     };
     for (function.dbg_info_relocs.items) |reloc| {
-        try reloc.genDbgInfo(function);
+        reloc.genDbgInfo(function) catch |err|
+            return function.fail("failed to generate debug info: {s}", .{@errorName(err)});
     }
     var mir = Mir{
 @@ -424,15 +419,9 @@ pub fn generate(
     defer emit.deinit();
     emit.emitMir() catch |err| switch (err) {
-        error.EmitFail => return Result{ .fail = emit.err_msg.? },
+        error.EmitFail => return function.failMsg(emit.err_msg.?),
         else => |e| return e,
     };
-    if (function.err_msg) |em| {
-        return Result{ .fail = em };
-    } else {
-        return Result.ok;
-    }
 }
 fn addInst(self: *Self, inst: Mir.Inst) error{OutOfMemory}!Mir.Inst.Index {
 @@ -6310,20 +6299,19 @@ fn wantSafety(self: *Self) bool {
     };
 }
-fn fail(self: *Self, comptime format: []const u8, args: anytype) InnerError {
+fn fail(self: *Self, comptime format: []const u8, args: anytype) error{ OutOfMemory, CodegenFail } {
     @branchHint(.cold);
-    assert(self.err_msg == null);
+    const zcu = self.pt.zcu;
-    const gpa = self.gpa;
+    const func = zcu.funcInfo(self.func_index);
-    self.err_msg = try ErrorMsg.create(gpa, self.src_loc, format, args);
+    const msg = try ErrorMsg.create(zcu.gpa, self.src_loc, format, args);
-    return error.CodegenFail;
+    return zcu.codegenFailMsg(func.owner_nav, msg);
 }
-fn failSymbol(self: *Self, comptime format: []const u8, args: anytype) InnerError {
+fn failMsg(self: *Self, msg: *ErrorMsg) error{ OutOfMemory, CodegenFail } {
     @branchHint(.cold);
-    assert(self.err_msg == null);
+    const zcu = self.pt.zcu;
-    const gpa = self.gpa;
+    const func = zcu.funcInfo(self.func_index);
-    self.err_msg = try ErrorMsg.create(gpa, self.src_loc, format, args);
+    return zcu.codegenFailMsg(func.owner_nav, msg);
-    return error.CodegenFail;
 }
 fn parseRegName(name: []const u8) ?Register {

src/arch/riscv64/CodeGen.zig+31-74

 @@ -32,7 +32,6 @@ const wip_mir_log = std.log.scoped(.wip_mir);
 const Alignment = InternPool.Alignment;
 const CodeGenError = codegen.CodeGenError;
-const Result = codegen.Result;
 const bits = @import("bits.zig");
 const abi = @import("abi.zig");
 @@ -62,7 +61,6 @@ gpa: Allocator,
 mod: *Package.Module,
 target: *const std.Target,
 debug_output: link.File.DebugInfoOutput,
-err_msg: ?*ErrorMsg,
 args: []MCValue,
 ret_mcv: InstTracking,
 fn_type: Type,
 @@ -761,7 +759,7 @@ pub fn generate(
     liveness: Liveness,
     code: *std.ArrayList(u8),
     debug_output: link.File.DebugInfoOutput,
-) CodeGenError!Result {
+) CodeGenError!void {
     const zcu = pt.zcu;
     const comp = zcu.comp;
     const gpa = zcu.gpa;
 @@ -788,7 +786,6 @@ pub fn generate(
         .target = &mod.resolved_target.result,
         .debug_output = debug_output,
         .owner = .{ .nav_index = func.owner_nav },
-        .err_msg = null,
         .args = undefined, // populated after `resolveCallingConventionValues`
         .ret_mcv = undefined, // populated after `resolveCallingConventionValues`
         .fn_type = fn_type,
 @@ -829,10 +826,7 @@ pub fn generate(
     const fn_info = zcu.typeToFunc(fn_type).?;
     var call_info = function.resolveCallingConventionValues(fn_info, &.{}) catch |err| switch (err) {
-        error.CodegenFail => return Result{ .fail = function.err_msg.? },
+        error.CodegenFail => return error.CodegenFail,
-        error.OutOfRegisters => return Result{
-            .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
-        },
         else => |e| return e,
     };
 @@ -861,10 +855,8 @@ pub fn generate(
     }));
     function.gen() catch |err| switch (err) {
-        error.CodegenFail => return Result{ .fail = function.err_msg.? },
+        error.CodegenFail => return error.CodegenFail,
-        error.OutOfRegisters => return Result{
+        error.OutOfRegisters => return function.fail("ran out of registers (Zig compiler bug)", .{}),
-            .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
-        },
         else => |e| return e,
     };
 @@ -895,28 +887,10 @@ pub fn generate(
     defer emit.deinit();
     emit.emitMir() catch |err| switch (err) {
-        error.LowerFail, error.EmitFail => return Result{ .fail = emit.lower.err_msg.? },
+        error.LowerFail, error.EmitFail => return function.failMsg(emit.lower.err_msg.?),
-        error.InvalidInstruction => |e| {
+        error.InvalidInstruction => |e| return function.fail("emit MIR failed: {s} (Zig compiler bug)", .{@errorName(e)}),
-            const msg = switch (e) {
-                error.InvalidInstruction => "CodeGen failed to find a viable instruction.",
-            };
-            return Result{
-                .fail = try ErrorMsg.create(
-                    gpa,
-                    src_loc,
-                    "{s} This is a bug in the Zig compiler.",
-                    .{msg},
-                ),
-            };
-        },
         else => |e| return e,
     };
-    if (function.err_msg) |em| {
-        return Result{ .fail = em };
-    } else {
-        return Result.ok;
-    }
 }
 pub fn generateLazy(
 @@ -926,7 +900,7 @@ pub fn generateLazy(
     lazy_sym: link.File.LazySymbol,
     code: *std.ArrayList(u8),
     debug_output: link.File.DebugInfoOutput,
-) CodeGenError!Result {
+) CodeGenError!void {
     const comp = bin_file.comp;
     const gpa = comp.gpa;
     const mod = comp.root_mod;
 @@ -941,7 +915,6 @@ pub fn generateLazy(
         .target = &mod.resolved_target.result,
         .debug_output = debug_output,
         .owner = .{ .lazy_sym = lazy_sym },
-        .err_msg = null,
         .args = undefined, // populated after `resolveCallingConventionValues`
         .ret_mcv = undefined, // populated after `resolveCallingConventionValues`
         .fn_type = undefined,
 @@ -957,10 +930,8 @@ pub fn generateLazy(
     defer function.mir_instructions.deinit(gpa);
     function.genLazy(lazy_sym) catch |err| switch (err) {
-        error.CodegenFail => return Result{ .fail = function.err_msg.? },
+        error.CodegenFail => return error.CodegenFail,
-        error.OutOfRegisters => return Result{
+        error.OutOfRegisters => return function.fail("ran out of registers (Zig compiler bug)", .{}),
-            .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
-        },
         else => |e| return e,
     };
 @@ -991,28 +962,10 @@ pub fn generateLazy(
     defer emit.deinit();
     emit.emitMir() catch |err| switch (err) {
-        error.LowerFail, error.EmitFail => return Result{ .fail = emit.lower.err_msg.? },
+        error.LowerFail, error.EmitFail => return function.failMsg(emit.lower.err_msg.?),
-        error.InvalidInstruction => |e| {
+        error.InvalidInstruction => |e| return function.fail("emit MIR failed: {s} (Zig compiler bug)", .{@errorName(e)}),
-            const msg = switch (e) {
-                error.InvalidInstruction => "CodeGen failed to find a viable instruction.",
-            };
-            return Result{
-                .fail = try ErrorMsg.create(
-                    gpa,
-                    src_loc,
-                    "{s} This is a bug in the Zig compiler.",
-                    .{msg},
-                ),
-            };
-        },
         else => |e| return e,
     };
-    if (function.err_msg) |em| {
-        return Result{ .fail = em };
-    } else {
-        return Result.ok;
-    }
 }
 const FormatWipMirData = struct {
 @@ -4758,19 +4711,19 @@ fn airFieldParentPtr(func: *Func, inst: Air.Inst.Index) !void {
     return func.fail("TODO implement codegen airFieldParentPtr", .{});
 }
-fn genArgDbgInfo(func: Func, inst: Air.Inst.Index, mcv: MCValue) !void {
+fn genArgDbgInfo(func: *const Func, inst: Air.Inst.Index, mcv: MCValue) InnerError!void {
     const arg = func.air.instructions.items(.data)[@intFromEnum(inst)].arg;
     const ty = arg.ty.toType();
     if (arg.name == .none) return;
     switch (func.debug_output) {
         .dwarf => |dw| switch (mcv) {
-            .register => |reg| try dw.genLocalDebugInfo(
+            .register => |reg| dw.genLocalDebugInfo(
                 .local_arg,
                 arg.name.toSlice(func.air),
                 ty,
                 .{ .reg = reg.dwarfNum() },
-            ),
+            ) catch |err| return func.fail("failed to generate debug info: {s}", .{@errorName(err)}),
             .load_frame => {},
             else => {},
         },
 @@ -4779,7 +4732,7 @@ fn genArgDbgInfo(func: Func, inst: Air.Inst.Index, mcv: MCValue) !void {
     }
 }
-fn airArg(func: *Func, inst: Air.Inst.Index) !void {
+fn airArg(func: *Func, inst: Air.Inst.Index) InnerError!void {
     var arg_index = func.arg_index;
     // we skip over args that have no bits
 @@ -5255,7 +5208,7 @@ fn airDbgInlineBlock(func: *Func, inst: Air.Inst.Index) !void {
     try func.lowerBlock(inst, @ptrCast(func.air.extra[extra.end..][0..extra.data.body_len]));
 }
-fn airDbgVar(func: *Func, inst: Air.Inst.Index) !void {
+fn airDbgVar(func: *Func, inst: Air.Inst.Index) InnerError!void {
     const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op;
     const operand = pl_op.operand;
     const ty = func.typeOf(operand);
 @@ -5263,7 +5216,8 @@ fn airDbgVar(func: *Func, inst: Air.Inst.Index) !void {
     const name: Air.NullTerminatedString = @enumFromInt(pl_op.payload);
     const tag = func.air.instructions.items(.tag)[@intFromEnum(inst)];
-    try func.genVarDbgInfo(tag, ty, mcv, name.toSlice(func.air));
+    func.genVarDbgInfo(tag, ty, mcv, name.toSlice(func.air)) catch |err|
+        return func.fail("failed to generate variable debug info: {s}", .{@errorName(err)});
     return func.finishAir(inst, .unreach, .{ operand, .none, .none });
 }
 @@ -8236,10 +8190,7 @@ fn genTypedValue(func: *Func, val: Value) InnerError!MCValue {
                 return func.fail("TODO: genTypedValue {s}", .{@tagName(mcv)});
             },
         },
-        .fail => |msg| {
+        .fail => |msg| return func.failMsg(msg),
-            func.err_msg = msg;
-            return error.CodegenFail;
-        },
     };
     return mcv;
 }
 @@ -8427,17 +8378,23 @@ fn wantSafety(func: *Func) bool {
     };
 }
-fn fail(func: *Func, comptime format: []const u8, args: anytype) InnerError {
+fn fail(func: *const Func, comptime format: []const u8, args: anytype) error{ OutOfMemory, CodegenFail } {
     @branchHint(.cold);
-    assert(func.err_msg == null);
+    const zcu = func.pt.zcu;
-    func.err_msg = try ErrorMsg.create(func.gpa, func.src_loc, format, args);
+    switch (func.owner) {
+        .nav_index => |i| return zcu.codegenFail(i, format, args),
+        .lazy_sym => |s| return zcu.codegenFailType(s.ty, format, args),
+    }
     return error.CodegenFail;
 }
-fn failSymbol(func: *Func, comptime format: []const u8, args: anytype) InnerError {
+fn failMsg(func: *const Func, msg: *ErrorMsg) error{ OutOfMemory, CodegenFail } {
     @branchHint(.cold);
-    assert(func.err_msg == null);
+    const zcu = func.pt.zcu;
-    func.err_msg = try ErrorMsg.create(func.gpa, func.src_loc, format, args);
+    switch (func.owner) {
+        .nav_index => |i| return zcu.codegenFailMsg(i, msg),
+        .lazy_sym => |s| return zcu.codegenFailTypeMsg(s.ty, msg),
+    }
     return error.CodegenFail;
 }

src/arch/sparc64/CodeGen.zig+20-24

 @@ -21,7 +21,6 @@ const Emit = @import("Emit.zig");
 const Liveness = @import("../../Liveness.zig");
 const Type = @import("../../Type.zig");
 const CodeGenError = codegen.CodeGenError;
-const Result = @import("../../codegen.zig").Result;
 const Endian = std.builtin.Endian;
 const Alignment = InternPool.Alignment;
 @@ -268,7 +267,7 @@ pub fn generate(
     liveness: Liveness,
     code: *std.ArrayList(u8),
     debug_output: link.File.DebugInfoOutput,
-) CodeGenError!Result {
+) CodeGenError!void {
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
     const func = zcu.funcInfo(func_index);
 @@ -310,10 +309,7 @@ pub fn generate(
     defer function.exitlude_jump_relocs.deinit(gpa);
     var call_info = function.resolveCallingConventionValues(func_ty, .callee) catch |err| switch (err) {
-        error.CodegenFail => return Result{ .fail = function.err_msg.? },
+        error.CodegenFail => return error.CodegenFail,
-        error.OutOfRegisters => return Result{
-            .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
-        },
         else => |e| return e,
     };
     defer call_info.deinit(&function);
 @@ -324,10 +320,8 @@ pub fn generate(
     function.max_end_stack = call_info.stack_byte_count;
     function.gen() catch |err| switch (err) {
-        error.CodegenFail => return Result{ .fail = function.err_msg.? },
+        error.CodegenFail => return error.CodegenFail,
-        error.OutOfRegisters => return Result{
+        error.OutOfRegisters => return function.fail("ran out of registers (Zig compiler bug)", .{}),
-            .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
-        },
         else => |e| return e,
     };
 @@ -351,15 +345,9 @@ pub fn generate(
     defer emit.deinit();
     emit.emitMir() catch |err| switch (err) {
-        error.EmitFail => return Result{ .fail = emit.err_msg.? },
+        error.EmitFail => return function.failMsg(emit.err_msg.?),
         else => |e| return e,
     };
-    if (function.err_msg) |em| {
-        return Result{ .fail = em };
-    } else {
-        return Result.ok;
-    }
 }
 fn gen(self: *Self) !void {
 @@ -1014,7 +1002,7 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
     return bt.finishAir(result);
 }
-fn airArg(self: *Self, inst: Air.Inst.Index) !void {
+fn airArg(self: *Self, inst: Air.Inst.Index) InnerError!void {
     const pt = self.pt;
     const zcu = pt.zcu;
     const arg_index = self.arg_index;
 @@ -1036,7 +1024,8 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
         }
     };
-    try self.genArgDbgInfo(inst, mcv);
+    self.genArgDbgInfo(inst, mcv) catch |err|
+        return self.fail("failed to generate debug info for parameter: {s}", .{@errorName(err)});
     if (self.liveness.isUnused(inst))
         return self.finishAirBookkeeping();
 @@ -3511,12 +3500,19 @@ fn errUnionPayload(self: *Self, error_union_mcv: MCValue, error_union_ty: Type)
     }
 }
-fn fail(self: *Self, comptime format: []const u8, args: anytype) InnerError {
+fn fail(self: *Self, comptime format: []const u8, args: anytype) error{ OutOfMemory, CodegenFail } {
     @branchHint(.cold);
-    assert(self.err_msg == null);
+    const zcu = self.pt.zcu;
-    const gpa = self.gpa;
+    const func = zcu.funcInfo(self.func_index);
-    self.err_msg = try ErrorMsg.create(gpa, self.src_loc, format, args);
+    const msg = try ErrorMsg.create(zcu.gpa, self.src_loc, format, args);
-    return error.CodegenFail;
+    return zcu.codegenFailMsg(func.owner_nav, msg);
+}
+fn failMsg(self: *Self, msg: *ErrorMsg) error{ OutOfMemory, CodegenFail } {
+    @branchHint(.cold);
+    const zcu = self.pt.zcu;
+    const func = zcu.funcInfo(self.func_index);
+    return zcu.codegenFailMsg(func.owner_nav, msg);
 }
 /// Called when there are no operands, and the instruction is always unreferenced.

src/arch/x86_64/CodeGen.zig+34-83

 @@ -19,7 +19,6 @@ const Allocator = mem.Allocator;
 const CodeGenError = codegen.CodeGenError;
 const Compilation = @import("../../Compilation.zig");
 const ErrorMsg = Zcu.ErrorMsg;
-const Result = codegen.Result;
 const Emit = @import("Emit.zig");
 const Liveness = @import("../../Liveness.zig");
 const Lower = @import("Lower.zig");
 @@ -59,7 +58,6 @@ target: *const std.Target,
 owner: Owner,
 inline_func: InternPool.Index,
 mod: *Package.Module,
-err_msg: ?*ErrorMsg,
 arg_index: u32,
 args: []MCValue,
 va_info: union {
 @@ -821,7 +819,7 @@ pub fn generate(
     liveness: Liveness,
     code: *std.ArrayList(u8),
     debug_output: link.File.DebugInfoOutput,
-) CodeGenError!Result {
+) CodeGenError!void {
     const zcu = pt.zcu;
     const comp = zcu.comp;
     const gpa = zcu.gpa;
 @@ -841,7 +839,6 @@ pub fn generate(
         .debug_output = debug_output,
         .owner = .{ .nav_index = func.owner_nav },
         .inline_func = func_index,
-        .err_msg = null,
         .arg_index = undefined,
         .args = undefined, // populated after `resolveCallingConventionValues`
         .va_info = undefined, // populated after `resolveCallingConventionValues`
 @@ -881,15 +878,7 @@ pub fn generate(
     const fn_info = zcu.typeToFunc(fn_type).?;
     const cc = abi.resolveCallingConvention(fn_info.cc, function.target.*);
     var call_info = function.resolveCallingConventionValues(fn_info, &.{}, .args_frame) catch |err| switch (err) {
-        error.CodegenFail => return Result{ .fail = function.err_msg.? },
+        error.CodegenFail => return error.CodegenFail,
-        error.OutOfRegisters => return Result{
-            .fail = try ErrorMsg.create(
-                gpa,
-                src_loc,
-                "CodeGen ran out of registers. This is a bug in the Zig compiler.",
-                .{},
-            ),
-        },
         else => |e| return e,
     };
     defer call_info.deinit(&function);
 @@ -926,10 +915,8 @@ pub fn generate(
     };
     function.gen() catch |err| switch (err) {
-        error.CodegenFail => return Result{ .fail = function.err_msg.? },
+        error.CodegenFail => return error.CodegenFail,
-        error.OutOfRegisters => return Result{
+        error.OutOfRegisters => return function.fail("ran out of registers (Zig compiler bug)", .{}),
-            .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
-        },
         else => |e| return e,
     };
 @@ -953,10 +940,7 @@ pub fn generate(
             .pic = mod.pic,
         },
         .atom_index = function.owner.getSymbolIndex(&function) catch |err| switch (err) {
-            error.CodegenFail => return Result{ .fail = function.err_msg.? },
+            error.CodegenFail => return error.CodegenFail,
-            error.OutOfRegisters => return Result{
-                .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
-            },
             else => |e| return e,
         },
         .debug_output = debug_output,
 @@ -974,29 +958,11 @@ pub fn generate(
     };
     defer emit.deinit();
     emit.emitMir() catch |err| switch (err) {
-        error.LowerFail, error.EmitFail => return Result{ .fail = emit.lower.err_msg.? },
+        error.LowerFail, error.EmitFail => return function.failMsg(emit.lower.err_msg.?),
-        error.InvalidInstruction, error.CannotEncode => |e| {
-            const msg = switch (e) {
-                error.InvalidInstruction => "CodeGen failed to find a viable instruction.",
-                error.CannotEncode => "CodeGen failed to encode the instruction.",
-            };
-            return Result{
-                .fail = try ErrorMsg.create(
-                    gpa,
-                    src_loc,
-                    "{s} This is a bug in the Zig compiler.",
-                    .{msg},
-                ),
-            };
-        },
-        else => |e| return e,
-    };
-    if (function.err_msg) |em| {
+        error.InvalidInstruction, error.CannotEncode => |e| return function.fail("emit MIR failed: {s} (Zig compiler bug)", .{@errorName(e)}),
-        return Result{ .fail = em };
+        else => |e| return function.fail("emit MIR failed: {s}", .{@errorName(e)}),
-    } else {
+    };
-        return Result.ok;
-    }
 }
 pub fn generateLazy(
 @@ -1006,7 +972,7 @@ pub fn generateLazy(
     lazy_sym: link.File.LazySymbol,
     code: *std.ArrayList(u8),
     debug_output: link.File.DebugInfoOutput,
-) CodeGenError!Result {
+) CodeGenError!void {
     const comp = bin_file.comp;
     const gpa = comp.gpa;
     // This function is for generating global code, so we use the root module.
 @@ -1022,7 +988,6 @@ pub fn generateLazy(
         .debug_output = debug_output,
         .owner = .{ .lazy_sym = lazy_sym },
         .inline_func = undefined,
-        .err_msg = null,
         .arg_index = undefined,
         .args = undefined,
         .va_info = undefined,
 @@ -1038,10 +1003,8 @@ pub fn generateLazy(
     }
     function.genLazy(lazy_sym) catch |err| switch (err) {
-        error.CodegenFail => return Result{ .fail = function.err_msg.? },
+        error.CodegenFail => return error.CodegenFail,
-        error.OutOfRegisters => return Result{
+        error.OutOfRegisters => return function.fail("ran out of registers (Zig compiler bug)", .{}),
-            .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
-        },
         else => |e| return e,
     };
 @@ -1065,10 +1028,7 @@ pub fn generateLazy(
             .pic = mod.pic,
         },
         .atom_index = function.owner.getSymbolIndex(&function) catch |err| switch (err) {
-            error.CodegenFail => return Result{ .fail = function.err_msg.? },
+            error.CodegenFail => return error.CodegenFail,
-            error.OutOfRegisters => return Result{
-                .fail = try ErrorMsg.create(gpa, src_loc, "CodeGen ran out of registers. This is a bug in the Zig compiler.", .{}),
-            },
             else => |e| return e,
         },
         .debug_output = debug_output,
 @@ -1078,29 +1038,11 @@ pub fn generateLazy(
     };
     defer emit.deinit();
     emit.emitMir() catch |err| switch (err) {
-        error.LowerFail, error.EmitFail => return Result{ .fail = emit.lower.err_msg.? },
+        error.LowerFail, error.EmitFail => return function.failMsg(emit.lower.err_msg.?),
-        error.InvalidInstruction, error.CannotEncode => |e| {
+        error.InvalidInstruction => return function.fail("failed to find a viable x86 instruction (Zig compiler bug)", .{}),
-            const msg = switch (e) {
+        error.CannotEncode => return function.fail("failed to find encode x86 instruction (Zig compiler bug)", .{}),
-                error.InvalidInstruction => "CodeGen failed to find a viable instruction.",
+        else => |e| return function.fail("failed to emit MIR: {s}", .{@errorName(e)}),
-                error.CannotEncode => "CodeGen failed to encode the instruction.",
-            };
-            return Result{
-                .fail = try ErrorMsg.create(
-                    gpa,
-                    src_loc,
-                    "{s} This is a bug in the Zig compiler.",
-                    .{msg},
-                ),
-            };
-        },
-        else => |e| return e,
     };
-    if (function.err_msg) |em| {
-        return Result{ .fail = em };
-    } else {
-        return Result.ok;
-    }
 }
 const FormatNavData = struct {
 @@ -19276,10 +19218,7 @@ fn genTypedValue(self: *Self, val: Value) InnerError!MCValue {
             .load_got => |sym_index| .{ .lea_got = sym_index },
             .load_tlv => |sym_index| .{ .lea_tlv = sym_index },
         },
-        .fail => |msg| {
+        .fail => |msg| return self.failMsg(msg),
-            self.err_msg = msg;
-            return error.CodegenFail;
-        },
     };
 }
 @@ -19592,11 +19531,23 @@ fn resolveCallingConventionValues(
     return result;
 }
-fn fail(self: *Self, comptime format: []const u8, args: anytype) InnerError {
+fn fail(self: *Self, comptime format: []const u8, args: anytype) error{ OutOfMemory, CodegenFail } {
     @branchHint(.cold);
-    assert(self.err_msg == null);
+    const zcu = self.pt.zcu;
-    const gpa = self.gpa;
+    switch (self.owner) {
-    self.err_msg = try ErrorMsg.create(gpa, self.src_loc, format, args);
+        .nav_index => |i| return zcu.codegenFail(i, format, args),
+        .lazy_sym => |s| return zcu.codegenFailType(s.ty, format, args),
+    }
+    return error.CodegenFail;
+}
+fn failMsg(self: *Self, msg: *ErrorMsg) error{ OutOfMemory, CodegenFail } {
+    @branchHint(.cold);
+    const zcu = self.pt.zcu;
+    switch (self.owner) {
+        .nav_index => |i| return zcu.codegenFailMsg(i, msg),
+        .lazy_sym => |s| return zcu.codegenFailTypeMsg(s.ty, msg),
+    }
     return error.CodegenFail;
 }

src/codegen.zig+56-113

 @@ -24,13 +24,6 @@ const Zir = std.zig.Zir;
 const Alignment = InternPool.Alignment;
 const dev = @import("dev.zig");
-pub const Result = union(enum) {
-    /// The `code` parameter passed to `generateSymbol` has the value.
-    ok,
-    /// There was a codegen error.
-    fail: *ErrorMsg,
-};
 pub const CodeGenError = error{
     OutOfMemory,
     /// Compiler was asked to operate on a number larger than supported.
 @@ -64,7 +57,7 @@ pub fn generateFunction(
     liveness: Liveness,
     code: *std.ArrayList(u8),
     debug_output: link.File.DebugInfoOutput,
-) CodeGenError!Result {
+) CodeGenError!void {
     const zcu = pt.zcu;
     const func = zcu.funcInfo(func_index);
     const target = zcu.navFileScope(func.owner_nav).mod.resolved_target.result;
 @@ -89,7 +82,7 @@ pub fn generateLazyFunction(
     lazy_sym: link.File.LazySymbol,
     code: *std.ArrayList(u8),
     debug_output: link.File.DebugInfoOutput,
-) CodeGenError!Result {
+) CodeGenError!void {
     const zcu = pt.zcu;
     const file = Type.fromInterned(lazy_sym.ty).typeDeclInstAllowGeneratedTag(zcu).?.resolveFile(&zcu.intern_pool);
     const target = zcu.fileByIndex(file).mod.resolved_target.result;
 @@ -120,17 +113,17 @@ pub fn generateLazySymbol(
     code: *std.ArrayList(u8),
     debug_output: link.File.DebugInfoOutput,
     reloc_parent: link.File.RelocInfo.Parent,
-) CodeGenError!Result {
+) CodeGenError!void {
     _ = reloc_parent;
     const tracy = trace(@src());
     defer tracy.end();
     const comp = bin_file.comp;
-    const ip = &pt.zcu.intern_pool;
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
     const target = comp.root_mod.resolved_target.result;
     const endian = target.cpu.arch.endian();
-    const gpa = comp.gpa;
     log.debug("generateLazySymbol: kind = {s}, ty = {}", .{
         @tagName(lazy_sym.kind),
 @@ -161,26 +154,29 @@ pub fn generateLazySymbol(
             string_index += @intCast(err_name.len + 1);
         }
         mem.writeInt(u32, code.items[offset_index..][0..4], string_index, endian);
-        return .ok;
+    } else if (Type.fromInterned(lazy_sym.ty).zigTypeTag(zcu) == .@"enum") {
-    } else if (Type.fromInterned(lazy_sym.ty).zigTypeTag(pt.zcu) == .@"enum") {
         alignment.* = .@"1";
         const enum_ty = Type.fromInterned(lazy_sym.ty);
-        const tag_names = enum_ty.enumFields(pt.zcu);
+        const tag_names = enum_ty.enumFields(zcu);
         for (0..tag_names.len) |tag_index| {
             const tag_name = tag_names.get(ip)[tag_index].toSlice(ip);
             try code.ensureUnusedCapacity(tag_name.len + 1);
             code.appendSliceAssumeCapacity(tag_name);
             code.appendAssumeCapacity(0);
         }
-        return .ok;
+    } else {
-    } else return .{ .fail = try .create(
+        return zcu.codegenFailType(lazy_sym.ty, "TODO implement generateLazySymbol for {s} {}", .{
-        gpa,
+            @tagName(lazy_sym.kind), Type.fromInterned(lazy_sym.ty).fmt(pt),
-        src_loc,
+        });
-        "TODO implement generateLazySymbol for {s} {}",
+    }
-        .{ @tagName(lazy_sym.kind), Type.fromInterned(lazy_sym.ty).fmt(pt) },
-    ) };
 }
+pub const GenerateSymbolError = error{
+    OutOfMemory,
+    /// Compiler was asked to operate on a number larger than supported.
+    Overflow,
+};
 pub fn generateSymbol(
     bin_file: *link.File,
     pt: Zcu.PerThread,
 @@ -188,7 +184,7 @@ pub fn generateSymbol(
     val: Value,
     code: *std.ArrayList(u8),
     reloc_parent: link.File.RelocInfo.Parent,
-) CodeGenError!Result {
+) GenerateSymbolError!void {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -204,7 +200,7 @@ pub fn generateSymbol(
     if (val.isUndefDeep(zcu)) {
         const abi_size = math.cast(usize, ty.abiSize(zcu)) orelse return error.Overflow;
         try code.appendNTimes(0xaa, abi_size);
-        return .ok;
+        return;
     }
     switch (ip.indexToKey(val.toIntern())) {
 @@ -266,7 +262,7 @@ pub fn generateSymbol(
             if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                 try code.writer().writeInt(u16, err_val, endian);
-                return .ok;
+                return;
             }
             const payload_align = payload_ty.abiAlignment(zcu);
 @@ -281,13 +277,10 @@ pub fn generateSymbol(
             // emit payload part of the error union
             {
                 const begin = code.items.len;
-                switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(switch (error_union.val) {
+                try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(switch (error_union.val) {
                     .err_name => try pt.intern(.{ .undef = payload_ty.toIntern() }),
                     .payload => |payload| payload,
-                }), code, reloc_parent)) {
+                }), code, reloc_parent);
-                    .ok => {},
-                    .fail => |em| return .{ .fail = em },
-                }
                 const unpadded_end = code.items.len - begin;
                 const padded_end = abi_align.forward(unpadded_end);
                 const padding = math.cast(usize, padded_end - unpadded_end) orelse return error.Overflow;
 @@ -312,10 +305,7 @@ pub fn generateSymbol(
         },
         .enum_tag => |enum_tag| {
             const int_tag_ty = ty.intTagType(zcu);
-            switch (try generateSymbol(bin_file, pt, src_loc, try pt.getCoerced(Value.fromInterned(enum_tag.int), int_tag_ty), code, reloc_parent)) {
+            try generateSymbol(bin_file, pt, src_loc, try pt.getCoerced(Value.fromInterned(enum_tag.int), int_tag_ty), code, reloc_parent);
-                .ok => {},
-                .fail => |em| return .{ .fail = em },
-            }
         },
         .float => |float| switch (float.storage) {
             .f16 => |f16_val| writeFloat(f16, f16_val, target, endian, try code.addManyAsArray(2)),
 @@ -328,19 +318,10 @@ pub fn generateSymbol(
             },
             .f128 => |f128_val| writeFloat(f128, f128_val, target, endian, try code.addManyAsArray(16)),
         },
-        .ptr => switch (try lowerPtr(bin_file, pt, src_loc, val.toIntern(), code, reloc_parent, 0)) {
+        .ptr => try lowerPtr(bin_file, pt, src_loc, val.toIntern(), code, reloc_parent, 0),
-            .ok => {},
-            .fail => |em| return .{ .fail = em },
-        },
         .slice => |slice| {
-            switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(slice.ptr), code, reloc_parent)) {
+            try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(slice.ptr), code, reloc_parent);
-                .ok => {},
+            try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(slice.len), code, reloc_parent);
-                .fail => |em| return .{ .fail = em },
-            }
-            switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(slice.len), code, reloc_parent)) {
-                .ok => {},
-                .fail => |em| return .{ .fail = em },
-            }
         },
         .opt => {
             const payload_type = ty.optionalChild(zcu);
 @@ -349,10 +330,7 @@ pub fn generateSymbol(
             if (ty.optionalReprIsPayload(zcu)) {
                 if (payload_val) |value| {
-                    switch (try generateSymbol(bin_file, pt, src_loc, value, code, reloc_parent)) {
+                    try generateSymbol(bin_file, pt, src_loc, value, code, reloc_parent);
-                        .ok => {},
-                        .fail => |em| return Result{ .fail = em },
-                    }
                 } else {
                     try code.appendNTimes(0, abi_size);
                 }
 @@ -362,10 +340,7 @@ pub fn generateSymbol(
                     const value = payload_val orelse Value.fromInterned(try pt.intern(.{
                         .undef = payload_type.toIntern(),
                     }));
-                    switch (try generateSymbol(bin_file, pt, src_loc, value, code, reloc_parent)) {
+                    try generateSymbol(bin_file, pt, src_loc, value, code, reloc_parent);
-                        .ok => {},
-                        .fail => |em| return Result{ .fail = em },
-                    }
                 }
                 try code.writer().writeByte(@intFromBool(payload_val != null));
                 try code.appendNTimes(0, padding);
 @@ -377,17 +352,14 @@ pub fn generateSymbol(
                 .elems, .repeated_elem => {
                     var index: u64 = 0;
                     while (index < array_type.lenIncludingSentinel()) : (index += 1) {
-                        switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(switch (aggregate.storage) {
+                        try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(switch (aggregate.storage) {
                             .bytes => unreachable,
                             .elems => |elems| elems[@intCast(index)],
                             .repeated_elem => |elem| if (index < array_type.len)
                                 elem
                             else
                                 array_type.sentinel,
-                        }), code, reloc_parent)) {
+                        }), code, reloc_parent);
-                            .ok => {},
-                            .fail => |em| return .{ .fail = em },
-                        }
                     }
                 },
             },
 @@ -437,16 +409,13 @@ pub fn generateSymbol(
                         .elems, .repeated_elem => {
                             var index: u64 = 0;
                             while (index < vector_type.len) : (index += 1) {
-                                switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(switch (aggregate.storage) {
+                                try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(switch (aggregate.storage) {
                                     .bytes => unreachable,
                                     .elems => |elems| elems[
                                         math.cast(usize, index) orelse return error.Overflow
                                     ],
                                     .repeated_elem => |elem| elem,
-                                }), code, reloc_parent)) {
+                                }), code, reloc_parent);
-                                    .ok => {},
-                                    .fail => |em| return .{ .fail = em },
-                                }
                             }
                         },
                     }
 @@ -476,10 +445,7 @@ pub fn generateSymbol(
                         .repeated_elem => |elem| elem,
                     };
-                    switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), code, reloc_parent)) {
+                    try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), code, reloc_parent);
-                        .ok => {},
-                        .fail => |em| return Result{ .fail = em },
-                    }
                     const unpadded_field_end = code.items.len - struct_begin;
                     // Pad struct members if required
 @@ -518,10 +484,8 @@ pub fn generateSymbol(
                                     return error.Overflow;
                                 var tmp_list = try std.ArrayList(u8).initCapacity(code.allocator, field_size);
                                 defer tmp_list.deinit();
-                                switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), &tmp_list, reloc_parent)) {
+                                try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), &tmp_list, reloc_parent);
-                                    .ok => @memcpy(code.items[current_pos..][0..tmp_list.items.len], tmp_list.items),
+                                @memcpy(code.items[current_pos..][0..tmp_list.items.len], tmp_list.items);
-                                    .fail => |em| return Result{ .fail = em },
-                                }
                             } else {
                                 Value.fromInterned(field_val).writeToPackedMemory(Type.fromInterned(field_ty), pt, code.items[current_pos..], bits) catch unreachable;
                             }
 @@ -553,10 +517,7 @@ pub fn generateSymbol(
                             ) orelse return error.Overflow;
                             if (padding > 0) try code.appendNTimes(0, padding);
-                            switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), code, reloc_parent)) {
+                            try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(field_val), code, reloc_parent);
-                                .ok => {},
-                                .fail => |em| return Result{ .fail = em },
-                            }
                         }
                         const size = struct_type.sizeUnordered(ip);
 @@ -582,10 +543,7 @@ pub fn generateSymbol(
             // Check if we should store the tag first.
             if (layout.tag_size > 0 and layout.tag_align.compare(.gte, layout.payload_align)) {
-                switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.tag), code, reloc_parent)) {
+                try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.tag), code, reloc_parent);
-                    .ok => {},
-                    .fail => |em| return Result{ .fail = em },
-                }
             }
             const union_obj = zcu.typeToUnion(ty).?;
 @@ -595,10 +553,7 @@ pub fn generateSymbol(
                 if (!field_ty.hasRuntimeBits(zcu)) {
                     try code.appendNTimes(0xaa, math.cast(usize, layout.payload_size) orelse return error.Overflow);
                 } else {
-                    switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.val), code, reloc_parent)) {
+                    try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.val), code, reloc_parent);
-                        .ok => {},
-                        .fail => |em| return Result{ .fail = em },
-                    }
                     const padding = math.cast(usize, layout.payload_size - field_ty.abiSize(zcu)) orelse return error.Overflow;
                     if (padding > 0) {
 @@ -606,17 +561,11 @@ pub fn generateSymbol(
                     }
                 }
             } else {
-                switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.val), code, reloc_parent)) {
+                try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.val), code, reloc_parent);
-                    .ok => {},
-                    .fail => |em| return Result{ .fail = em },
-                }
             }
             if (layout.tag_size > 0 and layout.tag_align.compare(.lt, layout.payload_align)) {
-                switch (try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.tag), code, reloc_parent)) {
+                try generateSymbol(bin_file, pt, src_loc, Value.fromInterned(un.tag), code, reloc_parent);
-                    .ok => {},
-                    .fail => |em| return Result{ .fail = em },
-                }
                 if (layout.padding > 0) {
                     try code.appendNTimes(0, layout.padding);
 @@ -625,7 +574,6 @@ pub fn generateSymbol(
         },
         .memoized_call => unreachable,
     }
-    return .ok;
 }
 fn lowerPtr(
 @@ -636,7 +584,7 @@ fn lowerPtr(
     code: *std.ArrayList(u8),
     reloc_parent: link.File.RelocInfo.Parent,
     prev_offset: u64,
-) CodeGenError!Result {
+) GenerateSymbolError!void {
     const zcu = pt.zcu;
     const ptr = zcu.intern_pool.indexToKey(ptr_val).ptr;
     const offset: u64 = prev_offset + ptr.byte_offset;
 @@ -689,7 +637,7 @@ fn lowerUavRef(
     code: *std.ArrayList(u8),
     reloc_parent: link.File.RelocInfo.Parent,
     offset: u64,
-) CodeGenError!Result {
+) GenerateSymbolError!void {
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
     const ip = &zcu.intern_pool;
 @@ -702,14 +650,7 @@ fn lowerUavRef(
     const is_fn_body = uav_ty.zigTypeTag(zcu) == .@"fn";
     if (!is_fn_body and !uav_ty.hasRuntimeBits(zcu)) {
         try code.appendNTimes(0xaa, ptr_width_bytes);
-        return .ok;
+        return;
-    }
-    const uav_align = ip.indexToKey(uav.orig_ty).ptr_type.flags.alignment;
-    const res = try lf.lowerUav(pt, uav_val, uav_align, src_loc);
-    switch (res) {
-        .mcv => {},
-        .fail => |em| return .{ .fail = em },
     }
     switch (lf.tag) {
 @@ -727,11 +668,17 @@ fn lowerUavRef(
                 .pointee = .{ .uav_index = uav.val },
             });
             try code.appendNTimes(0, ptr_width_bytes);
-            return .ok;
+            return;
         },
         else => {},
     }
+    const uav_align = ip.indexToKey(uav.orig_ty).ptr_type.flags.alignment;
+    switch (try lf.lowerUav(pt, uav_val, uav_align, src_loc)) {
+        .mcv => {},
+        .fail => |em| std.debug.panic("TODO rework lowerUav. internal error: {s}", .{em.msg}),
+    }
     const vaddr = try lf.getUavVAddr(uav_val, .{
         .parent = reloc_parent,
         .offset = code.items.len,
 @@ -744,8 +691,6 @@ fn lowerUavRef(
         8 => mem.writeInt(u64, try code.addManyAsArray(8), vaddr, endian),
         else => unreachable,
     }
-    return Result.ok;
 }
 fn lowerNavRef(
 @@ -756,7 +701,7 @@ fn lowerNavRef(
     code: *std.ArrayList(u8),
     reloc_parent: link.File.RelocInfo.Parent,
     offset: u64,
-) CodeGenError!Result {
+) GenerateSymbolError!void {
     _ = src_loc;
     const zcu = pt.zcu;
     const gpa = zcu.gpa;
 @@ -768,7 +713,7 @@ fn lowerNavRef(
     const is_fn_body = nav_ty.zigTypeTag(zcu) == .@"fn";
     if (!is_fn_body and !nav_ty.hasRuntimeBits(zcu)) {
         try code.appendNTimes(0xaa, ptr_width_bytes);
-        return Result.ok;
+        return;
     }
     switch (lf.tag) {
 @@ -786,16 +731,16 @@ fn lowerNavRef(
                 .pointee = .{ .nav_index = nav_index },
             });
             try code.appendNTimes(0, ptr_width_bytes);
-            return .ok;
+            return;
         },
         else => {},
     }
-    const vaddr = try lf.getNavVAddr(pt, nav_index, .{
+    const vaddr = lf.getNavVAddr(pt, nav_index, .{
         .parent = reloc_parent,
         .offset = code.items.len,
         .addend = @intCast(offset),
-    });
+    }) catch @panic("TODO rework getNavVAddr");
     const endian = target.cpu.arch.endian();
     switch (ptr_width_bytes) {
         2 => mem.writeInt(u16, try code.addManyAsArray(2), @intCast(vaddr), endian),
 @@ -803,8 +748,6 @@ fn lowerNavRef(
         8 => mem.writeInt(u64, try code.addManyAsArray(8), vaddr, endian),
         else => unreachable,
     }
-    return .ok;
 }
 /// Helper struct to denote that the value is in memory but requires a linker relocation fixup:

src/link.zig+7-1

 @@ -673,7 +673,13 @@ pub const File = struct {
         }
     }
-    pub fn updateContainerType(base: *File, pt: Zcu.PerThread, ty: InternPool.Index) UpdateNavError!void {
+    pub const UpdateContainerTypeError = error{
+        OutOfMemory,
+        /// `Zcu.failed_types` is already populated with the error message.
+        TypeFailureReported,
+    };
+    pub fn updateContainerType(base: *File, pt: Zcu.PerThread, ty: InternPool.Index) UpdateContainerTypeError!void {
         switch (base.tag) {
             else => {},
             inline .elf => |tag| {

src/link/Coff.zig+57-48

 @@ -754,7 +754,7 @@ fn allocateGlobal(coff: *Coff) !u32 {
     return index;
 }
-fn addGotEntry(coff: *Coff, target: SymbolWithLoc) error{ OutOfMemory, LinkFailure }!void {
+fn addGotEntry(coff: *Coff, target: SymbolWithLoc) !void {
     const gpa = coff.base.comp.gpa;
     if (coff.got_table.lookup.contains(target)) return;
     const got_index = try coff.got_table.allocateEntry(gpa, target);
 @@ -780,7 +780,7 @@ pub fn createAtom(coff: *Coff) !Atom.Index {
     return atom_index;
 }
-fn growAtom(coff: *Coff, atom_index: Atom.Index, new_atom_size: u32, alignment: u32) link.File.UpdateNavError!u32 {
+fn growAtom(coff: *Coff, atom_index: Atom.Index, new_atom_size: u32, alignment: u32) !u32 {
     const atom = coff.getAtom(atom_index);
     const sym = atom.getSymbol(coff);
     const align_ok = mem.alignBackward(u32, sym.value, alignment) == sym.value;
 @@ -909,12 +909,12 @@ fn writeOffsetTableEntry(coff: *Coff, index: usize) !void {
         .p32 => {
             var buf: [4]u8 = undefined;
             mem.writeInt(u32, &buf, @intCast(entry_value + coff.image_base), .little);
-            try coff.pwriteAll(&buf, file_offset);
+            try coff.base.file.?.pwriteAll(&buf, file_offset);
         },
         .p64 => {
             var buf: [8]u8 = undefined;
             mem.writeInt(u64, &buf, entry_value + coff.image_base, .little);
-            try coff.pwriteAll(&buf, file_offset);
+            try coff.base.file.?.pwriteAll(&buf, file_offset);
         },
     }
 @@ -1122,7 +1122,7 @@ pub fn updateFunc(
     var code_buffer = std.ArrayList(u8).init(gpa);
     defer code_buffer.deinit();
-    const res = codegen.generateFunction(
+    codegen.generateFunction(
         &coff.base,
         pt,
         zcu.navSrcLoc(nav_index),
 @@ -1134,7 +1134,7 @@ pub fn updateFunc(
     ) catch |err| switch (err) {
         error.CodegenFail => return error.CodegenFail,
         error.OutOfMemory => return error.OutOfMemory,
-        else => |e| {
+        error.Overflow => |e| {
             try zcu.failed_codegen.putNoClobber(gpa, nav_index, try Zcu.ErrorMsg.create(
                 gpa,
                 zcu.navSrcLoc(nav_index),
 @@ -1145,15 +1145,8 @@ pub fn updateFunc(
             return error.CodegenFail;
         },
     };
-    const code = switch (res) {
-        .ok => code_buffer.items,
-        .fail => |em| {
-            try zcu.failed_codegen.put(zcu.gpa, nav_index, em);
-            return;
-        },
-    };
-    try coff.updateNavCode(pt, nav_index, code, .FUNCTION);
+    try coff.updateNavCode(pt, nav_index, code_buffer.items, .FUNCTION);
     // Exports will be updated by `Zcu.processExports` after the update.
 }
 @@ -1182,16 +1175,13 @@ fn lowerConst(
     try coff.setSymbolName(sym, name);
     sym.section_number = @as(coff_util.SectionNumber, @enumFromInt(sect_id + 1));
-    const res = try codegen.generateSymbol(&coff.base, pt, src_loc, val, &code_buffer, .{
+    try codegen.generateSymbol(&coff.base, pt, src_loc, val, &code_buffer, .{
         .atom_index = coff.getAtom(atom_index).getSymbolIndex().?,
     });
-    const code = switch (res) {
+    const code = code_buffer.items;
-        .ok => code_buffer.items,
-        .fail => |em| return .{ .fail = em },
-    };
     const atom = coff.getAtomPtr(atom_index);
-    atom.size = @as(u32, @intCast(code.len));
+    atom.size = @intCast(code.len);
     atom.getSymbolPtr(coff).value = try coff.allocateAtom(
         atom_index,
         atom.size,
 @@ -1250,7 +1240,7 @@ pub fn updateNav(
         var code_buffer = std.ArrayList(u8).init(gpa);
         defer code_buffer.deinit();
-        const res = try codegen.generateSymbol(
+        try codegen.generateSymbol(
             &coff.base,
             pt,
             zcu.navSrcLoc(nav_index),
 @@ -1258,15 +1248,8 @@ pub fn updateNav(
             &code_buffer,
             .{ .atom_index = atom.getSymbolIndex().? },
         );
-        const code = switch (res) {
-            .ok => code_buffer.items,
-            .fail => |em| {
-                try zcu.failed_codegen.put(gpa, nav_index, em);
-                return;
-            },
-        };
-        try coff.updateNavCode(pt, nav_index, code, .NULL);
+        try coff.updateNavCode(pt, nav_index, code_buffer.items, .NULL);
     }
     // Exports will be updated by `Zcu.processExports` after the update.
 @@ -1278,11 +1261,10 @@ fn updateLazySymbolAtom(
     sym: link.File.LazySymbol,
     atom_index: Atom.Index,
     section_index: u16,
-) link.File.FlushError!void {
+) !void {
     const zcu = pt.zcu;
     const comp = coff.base.comp;
     const gpa = comp.gpa;
-    const diags = &comp.link_diags;
     var required_alignment: InternPool.Alignment = .none;
     var code_buffer = std.ArrayList(u8).init(gpa);
 @@ -1298,7 +1280,7 @@ fn updateLazySymbolAtom(
     const local_sym_index = atom.getSymbolIndex().?;
     const src = Type.fromInterned(sym.ty).srcLocOrNull(zcu) orelse Zcu.LazySrcLoc.unneeded;
-    const res = codegen.generateLazySymbol(
+    try codegen.generateLazySymbol(
         &coff.base,
         pt,
         src,
 @@ -1307,14 +1289,8 @@ fn updateLazySymbolAtom(
         &code_buffer,
         .none,
         .{ .atom_index = local_sym_index },
-    ) catch |err| switch (err) {
+    );
-        error.CodegenFail => return error.LinkFailure,
+    const code = code_buffer.items;
-        else => |e| return diags.fail("failed to generate lazy symbol: {s}", .{@errorName(e)}),
-    };
-    const code = switch (res) {
-        .ok => code_buffer.items,
-        .fail => |em| return diags.fail("failed to generate code: {s}", .{em.msg}),
-    };
     const code_len: u32 = @intCast(code.len);
     const symbol = atom.getSymbolPtr(coff);
 @@ -1438,7 +1414,10 @@ fn updateNavCode(
         const capacity = atom.capacity(coff);
         const need_realloc = code.len > capacity or !required_alignment.check(sym.value);
         if (need_realloc) {
-            const vaddr = try coff.growAtom(atom_index, code_len, @intCast(required_alignment.toByteUnits() orelse 0));
+            const vaddr = coff.growAtom(atom_index, code_len, @intCast(required_alignment.toByteUnits() orelse 0)) catch |err| switch (err) {
+                error.OutOfMemory => return error.OutOfMemory,
+                else => |e| return coff.base.cgFail(nav_index, "failed to grow atom: {s}", .{@errorName(e)}),
+            };
             log.debug("growing {} from 0x{x} to 0x{x}", .{ nav.fqn.fmt(ip), sym.value, vaddr });
             log.debug("  (required alignment 0x{x}", .{required_alignment});
 @@ -1446,7 +1425,10 @@ fn updateNavCode(
                 sym.value = vaddr;
                 log.debug("  (updating GOT entry)", .{});
                 const got_entry_index = coff.got_table.lookup.get(.{ .sym_index = sym_index }).?;
-                try coff.writeOffsetTableEntry(got_entry_index);
+                coff.writeOffsetTableEntry(got_entry_index) catch |err| switch (err) {
+                    error.OutOfMemory => return error.OutOfMemory,
+                    else => |e| return coff.base.cgFail(nav_index, "failed to write offset table entry: {s}", .{@errorName(e)}),
+                };
                 coff.markRelocsDirtyByTarget(.{ .sym_index = sym_index });
             }
         } else if (code_len < atom.size) {
 @@ -1459,16 +1441,25 @@ fn updateNavCode(
         sym.section_number = @enumFromInt(sect_index + 1);
         sym.type = .{ .complex_type = complex_type, .base_type = .NULL };
-        const vaddr = try coff.allocateAtom(atom_index, code_len, @intCast(required_alignment.toByteUnits() orelse 0));
+        const vaddr = coff.allocateAtom(atom_index, code_len, @intCast(required_alignment.toByteUnits() orelse 0)) catch |err| switch (err) {
+            error.OutOfMemory => return error.OutOfMemory,
+            else => |e| return coff.base.cgFail(nav_index, "failed to allocate atom: {s}", .{@errorName(e)}),
+        };
         errdefer coff.freeAtom(atom_index);
         log.debug("allocated atom for {} at 0x{x}", .{ nav.fqn.fmt(ip), vaddr });
         coff.getAtomPtr(atom_index).size = code_len;
         sym.value = vaddr;
-        try coff.addGotEntry(.{ .sym_index = sym_index });
+        coff.addGotEntry(.{ .sym_index = sym_index }) catch |err| switch (err) {
+            error.OutOfMemory => return error.OutOfMemory,
+            else => |e| return coff.base.cgFail(nav_index, "failed to add GOT entry: {s}", .{@errorName(e)}),
+        };
     }
-    try coff.writeAtom(atom_index, code);
+    coff.writeAtom(atom_index, code) catch |err| switch (err) {
+        error.OutOfMemory => return error.OutOfMemory,
+        else => |e| return coff.base.cgFail(nav_index, "failed to write atom: {s}", .{@errorName(e)}),
+    };
 }
 pub fn freeNav(coff: *Coff, nav_index: InternPool.NavIndex) void {
 @@ -2229,12 +2220,16 @@ fn findLib(arena: Allocator, name: []const u8, lib_directories: []const Director
     return null;
 }
-pub fn flushModule(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) link.File.FlushError!void {
+pub fn flushModule(
+    coff: *Coff,
+    arena: Allocator,
+    tid: Zcu.PerThread.Id,
+    prog_node: std.Progress.Node,
+) link.File.FlushError!void {
     const tracy = trace(@src());
     defer tracy.end();
     const comp = coff.base.comp;
-    const gpa = comp.gpa;
     const diags = &comp.link_diags;
     if (coff.llvm_object) |llvm_object| {
 @@ -2245,6 +2240,20 @@ pub fn flushModule(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
     const sub_prog_node = prog_node.start("COFF Flush", 0);
     defer sub_prog_node.end();
+    return flushModuleInner(coff, arena, tid) catch |err| switch (err) {
+        error.OutOfMemory => return error.OutOfMemory,
+        error.LinkFailure => return error.LinkFailure,
+        else => |e| return diags.fail("COFF flush failed: {s}", .{@errorName(e)}),
+    };
+}
+fn flushModuleInner(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id) !void {
+    _ = arena;
+    const comp = coff.base.comp;
+    const gpa = comp.gpa;
+    const diags = &comp.link_diags;
     const pt: Zcu.PerThread = .activate(
         comp.zcu orelse return diags.fail("linking without zig source is not yet implemented", .{}),
         tid,
 @@ -2757,7 +2766,7 @@ fn writeImportTables(coff: *Coff) !void {
     coff.imports_count_dirty = false;
 }
-fn writeStrtab(coff: *Coff) link.File.FlushError!void {
+fn writeStrtab(coff: *Coff) !void {
     if (coff.strtab_offset == null) return;
     const comp = coff.base.comp;

src/link/Dwarf.zig+3-9

 @@ -21,7 +21,6 @@ debug_rnglists: DebugRngLists,
 debug_str: StringSection,
 pub const UpdateError = error{
-    CodegenFail,
     ReinterpretDeclRef,
     Unimplemented,
     OutOfMemory,
 @@ -1893,17 +1892,15 @@ pub const WipNav = struct {
         if (bytes == 0) return;
         var dim = wip_nav.debug_info.toManaged(wip_nav.dwarf.gpa);
         defer wip_nav.debug_info = dim.moveToUnmanaged();
-        switch (try codegen.generateSymbol(
+        try codegen.generateSymbol(
             wip_nav.dwarf.bin_file,
             wip_nav.pt,
             src_loc,
             val,
             &dim,
             .{ .debug_output = .{ .dwarf = wip_nav } },
-        )) {
+        );
-            .ok => assert(dim.items.len == wip_nav.debug_info.items.len + bytes),
+        assert(dim.items.len == wip_nav.debug_info.items.len + bytes);
-            .fail => unreachable,
-        }
     }
     const AbbrevCodeForForm = struct {
 @@ -2346,7 +2343,6 @@ pub fn initWipNav(
 ) error{ OutOfMemory, CodegenFail }!?WipNav {
     return initWipNavInner(dwarf, pt, nav_index, sym_index) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
-        error.CodegenFail => return error.CodegenFail,
         else => |e| return pt.zcu.codegenFail(nav_index, "failed to init dwarf: {s}", .{@errorName(e)}),
     };
 }
 @@ -2669,7 +2665,6 @@ pub fn finishWipNav(
 ) error{ OutOfMemory, CodegenFail }!void {
     return finishWipNavInner(dwarf, pt, nav_index, wip_nav) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
-        error.CodegenFail => return error.CodegenFail,
         else => |e| return pt.zcu.codegenFail(nav_index, "failed to finish dwarf: {s}", .{@errorName(e)}),
     };
 }
 @@ -2701,7 +2696,6 @@ fn finishWipNavInner(
 pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) error{ OutOfMemory, CodegenFail }!void {
     return updateComptimeNavInner(dwarf, pt, nav_index) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
-        error.CodegenFail => return error.CodegenFail,
         else => |e| return pt.zcu.codegenFail(nav_index, "failed to update dwarf: {s}", .{@errorName(e)}),
     };
 }

src/link/Elf.zig+15-2

...	@@ -2368,12 +2368,25 @@ pub fn updateContainerType(	...	@@ -2368,12 +2368,25 @@ pub fn updateContainerType(
2368	self: *Elf,	2368	self: *Elf,
2369	pt: Zcu.PerThread,	2369	pt: Zcu.PerThread,
2370	ty: InternPool.Index,	2370	ty: InternPool.Index,
2371	) link.File.UpdateNavError!void {	2371	) link.File.UpdateContainerTypeError!void {
2372	if (build_options.skip_non_native and builtin.object_format != .elf) {	2372	if (build_options.skip_non_native and builtin.object_format != .elf) {
2373	@panic("Attempted to compile for object format that was disabled by build configuration");	2373	@panic("Attempted to compile for object format that was disabled by build configuration");
2374	}	2374	}
2375	if (self.llvm_object) \|_\| return;	2375	if (self.llvm_object) \|_\| return;
2376	return self.zigObjectPtr().?.updateContainerType(pt, ty);	2376	const zcu = pt.zcu;
		2377	const gpa = zcu.gpa;
		2378	return self.zigObjectPtr().?.updateContainerType(pt, ty) catch \|err\| switch (err) {
		2379	error.OutOfMemory => return error.OutOfMemory,
		2380	else => \|e\| {
		2381	try zcu.failed_types.putNoClobber(gpa, ty, try Zcu.ErrorMsg.create(
		2382	gpa,
		2383	zcu.typeSrcLoc(ty),
		2384	"failed to update container type: {s}",
		2385	.{@errorName(e)},
		2386	));
		2387	return error.TypeFailureReported;
		2388	},
		2389	};
2377	}	2390	}
2378		2391
2379	pub fn updateExports(	2392	pub fn updateExports(

src/link/Elf/ZigObject.zig+9-32

...	@@ -1437,7 +1437,7 @@ pub fn updateFunc(	...	@@ -1437,7 +1437,7 @@ pub fn updateFunc(
1437	var debug_wip_nav = if (self.dwarf) \|*dwarf\| try dwarf.initWipNav(pt, func.owner_nav, sym_index) else null;	1437	var debug_wip_nav = if (self.dwarf) \|*dwarf\| try dwarf.initWipNav(pt, func.owner_nav, sym_index) else null;
1438	defer if (debug_wip_nav) \|*wip_nav\| wip_nav.deinit();	1438	defer if (debug_wip_nav) \|*wip_nav\| wip_nav.deinit();
1439		1439
1440	const res = try codegen.generateFunction(	1440	try codegen.generateFunction(
1441	&elf_file.base,	1441	&elf_file.base,
1442	pt,	1442	pt,
1443	zcu.navSrcLoc(func.owner_nav),	1443	zcu.navSrcLoc(func.owner_nav),
...	@@ -1447,14 +1447,7 @@ pub fn updateFunc(	...	@@ -1447,14 +1447,7 @@ pub fn updateFunc(
1447	&code_buffer,	1447	&code_buffer,
1448	if (debug_wip_nav) \|*dn\| .{ .dwarf = dn } else .none,	1448	if (debug_wip_nav) \|*dn\| .{ .dwarf = dn } else .none,
1449	);	1449	);
1450		1450	const code = code_buffer.items;
1451	const code = switch (res) {
1452	.ok => code_buffer.items,
1453	.fail => \|em\| {
1454	try zcu.failed_codegen.put(gpa, func.owner_nav, em);
1455	return;
1456	},
1457	};
1458		1451
1459	const shndx = try self.getNavShdrIndex(elf_file, zcu, func.owner_nav, sym_index, code);	1452	const shndx = try self.getNavShdrIndex(elf_file, zcu, func.owner_nav, sym_index, code);
1460	log.debug("setting shdr({x},{s}) for {}", .{	1453	log.debug("setting shdr({x},{s}) for {}", .{
...	@@ -1574,7 +1567,7 @@ pub fn updateNav(	...	@@ -1574,7 +1567,7 @@ pub fn updateNav(
1574	var debug_wip_nav = if (self.dwarf) \|*dwarf\| try dwarf.initWipNav(pt, nav_index, sym_index) else null;	1567	var debug_wip_nav = if (self.dwarf) \|*dwarf\| try dwarf.initWipNav(pt, nav_index, sym_index) else null;
1575	defer if (debug_wip_nav) \|*wip_nav\| wip_nav.deinit();	1568	defer if (debug_wip_nav) \|*wip_nav\| wip_nav.deinit();
1576		1569
1577	const res = try codegen.generateSymbol(	1570	try codegen.generateSymbol(
1578	&elf_file.base,	1571	&elf_file.base,
1579	pt,	1572	pt,
1580	zcu.navSrcLoc(nav_index),	1573	zcu.navSrcLoc(nav_index),
...	@@ -1582,14 +1575,7 @@ pub fn updateNav(	...	@@ -1582,14 +1575,7 @@ pub fn updateNav(
1582	&code_buffer,	1575	&code_buffer,
1583	.{ .atom_index = sym_index },	1576	.{ .atom_index = sym_index },
1584	);	1577	);
1585		1578	const code = code_buffer.items;
1586	const code = switch (res) {
1587	.ok => code_buffer.items,
1588	.fail => \|em\| {
1589	try zcu.failed_codegen.put(zcu.gpa, nav_index, em);
1590	return;
1591	},
1592	};
1593		1579
1594	const shndx = try self.getNavShdrIndex(elf_file, zcu, nav_index, sym_index, code);	1580	const shndx = try self.getNavShdrIndex(elf_file, zcu, nav_index, sym_index, code);
1595	log.debug("setting shdr({x},{s}) for {}", .{	1581	log.debug("setting shdr({x},{s}) for {}", .{
...	@@ -1612,7 +1598,7 @@ pub fn updateContainerType(	...	@@ -1612,7 +1598,7 @@ pub fn updateContainerType(
1612	self: *ZigObject,	1598	self: *ZigObject,
1613	pt: Zcu.PerThread,	1599	pt: Zcu.PerThread,
1614	ty: InternPool.Index,	1600	ty: InternPool.Index,
1615	) link.File.UpdateNavError!void {	1601	) !void {
1616	const tracy = trace(@src());	1602	const tracy = trace(@src());
1617	defer tracy.end();	1603	defer tracy.end();
1618		1604
...	@@ -1643,7 +1629,7 @@ fn updateLazySymbol(	...	@@ -1643,7 +1629,7 @@ fn updateLazySymbol(
1643	};	1629	};
1644		1630
1645	const src = Type.fromInterned(sym.ty).srcLocOrNull(zcu) orelse Zcu.LazySrcLoc.unneeded;	1631	const src = Type.fromInterned(sym.ty).srcLocOrNull(zcu) orelse Zcu.LazySrcLoc.unneeded;
1646	const res = try codegen.generateLazySymbol(	1632	try codegen.generateLazySymbol(
1647	&elf_file.base,	1633	&elf_file.base,
1648	pt,	1634	pt,
1649	src,	1635	src,
...	@@ -1653,13 +1639,7 @@ fn updateLazySymbol(	...	@@ -1653,13 +1639,7 @@ fn updateLazySymbol(
1653	.none,	1639	.none,
1654	.{ .atom_index = symbol_index },	1640	.{ .atom_index = symbol_index },
1655	);	1641	);
1656	const code = switch (res) {	1642	const code = code_buffer.items;
1657	.ok => code_buffer.items,
1658	.fail => \|em\| {
1659	log.err("{s}", .{em.msg});
1660	return error.CodegenFail;
1661	},
1662	};
1663		1643
1664	const output_section_index = switch (sym.kind) {	1644	const output_section_index = switch (sym.kind) {
1665	.code => if (self.text_index) \|sym_index\|	1645	.code => if (self.text_index) \|sym_index\|
...	@@ -1732,7 +1712,7 @@ fn lowerConst(	...	@@ -1732,7 +1712,7 @@ fn lowerConst(
1732	const name_off = try self.addString(gpa, name);	1712	const name_off = try self.addString(gpa, name);
1733	const sym_index = try self.newSymbolWithAtom(gpa, name_off);	1713	const sym_index = try self.newSymbolWithAtom(gpa, name_off);
1734		1714
1735	const res = try codegen.generateSymbol(	1715	try codegen.generateSymbol(
1736	&elf_file.base,	1716	&elf_file.base,
1737	pt,	1717	pt,
1738	src_loc,	1718	src_loc,
...	@@ -1740,10 +1720,7 @@ fn lowerConst(	...	@@ -1740,10 +1720,7 @@ fn lowerConst(
1740	&code_buffer,	1720	&code_buffer,
1741	.{ .atom_index = sym_index },	1721	.{ .atom_index = sym_index },
1742	);	1722	);
1743	const code = switch (res) {	1723	const code = code_buffer.items;
1744	.ok => code_buffer.items,
1745	.fail => \|em\| return .{ .fail = em },
1746	};
1747		1724
1748	const local_sym = self.symbol(sym_index);	1725	const local_sym = self.symbol(sym_index);
1749	const local_esym = &self.symtab.items(.elf_sym)[local_sym.esym_index];	1726	const local_esym = &self.symtab.items(.elf_sym)[local_sym.esym_index];

src/link/MachO/ZigObject.zig+9-34

...	@@ -590,7 +590,6 @@ pub fn flushModule(self: ZigObject, macho_file: MachO, tid: Zcu.PerThread.Id)	...	@@ -590,7 +590,6 @@ pub fn flushModule(self: ZigObject, macho_file: MachO, tid: Zcu.PerThread.Id)
590	defer pt.deactivate();	590	defer pt.deactivate();
591	dwarf.flushModule(pt) catch \|err\| switch (err) {	591	dwarf.flushModule(pt) catch \|err\| switch (err) {
592	error.OutOfMemory => return error.OutOfMemory,	592	error.OutOfMemory => return error.OutOfMemory,
593	error.CodegenFail => return error.LinkFailure,
594	else => \|e\| return diags.fail("failed to flush dwarf module: {s}", .{@errorName(e)}),	593	else => \|e\| return diags.fail("failed to flush dwarf module: {s}", .{@errorName(e)}),
595	};	594	};
596		595
...	@@ -796,7 +795,7 @@ pub fn updateFunc(	...	@@ -796,7 +795,7 @@ pub fn updateFunc(
796	var debug_wip_nav = if (self.dwarf) \|*dwarf\| try dwarf.initWipNav(pt, func.owner_nav, sym_index) else null;	795	var debug_wip_nav = if (self.dwarf) \|*dwarf\| try dwarf.initWipNav(pt, func.owner_nav, sym_index) else null;
797	defer if (debug_wip_nav) \|*wip_nav\| wip_nav.deinit();	796	defer if (debug_wip_nav) \|*wip_nav\| wip_nav.deinit();
798		797
799	const res = try codegen.generateFunction(	798	try codegen.generateFunction(
800	&macho_file.base,	799	&macho_file.base,
801	pt,	800	pt,
802	zcu.navSrcLoc(func.owner_nav),	801	zcu.navSrcLoc(func.owner_nav),
...	@@ -806,14 +805,7 @@ pub fn updateFunc(	...	@@ -806,14 +805,7 @@ pub fn updateFunc(
806	&code_buffer,	805	&code_buffer,
807	if (debug_wip_nav) \|*wip_nav\| .{ .dwarf = wip_nav } else .none,	806	if (debug_wip_nav) \|*wip_nav\| .{ .dwarf = wip_nav } else .none,
808	);	807	);
809		808	const code = code_buffer.items;
810	const code = switch (res) {
811	.ok => code_buffer.items,
812	.fail => \|em\| {
813	try zcu.failed_codegen.put(gpa, func.owner_nav, em);
814	return error.CodegenFail;
815	},
816	};
817		809
818	const sect_index = try self.getNavOutputSection(macho_file, zcu, func.owner_nav, code);	810	const sect_index = try self.getNavOutputSection(macho_file, zcu, func.owner_nav, code);
819	const old_rva, const old_alignment = blk: {	811	const old_rva, const old_alignment = blk: {
...	@@ -914,7 +906,7 @@ pub fn updateNav(	...	@@ -914,7 +906,7 @@ pub fn updateNav(
914	var debug_wip_nav = if (self.dwarf) \|*dwarf\| try dwarf.initWipNav(pt, nav_index, sym_index) else null;	906	var debug_wip_nav = if (self.dwarf) \|*dwarf\| try dwarf.initWipNav(pt, nav_index, sym_index) else null;
915	defer if (debug_wip_nav) \|*wip_nav\| wip_nav.deinit();	907	defer if (debug_wip_nav) \|*wip_nav\| wip_nav.deinit();
916		908
917	const res = try codegen.generateSymbol(	909	try codegen.generateSymbol(
918	&macho_file.base,	910	&macho_file.base,
919	pt,	911	pt,
920	zcu.navSrcLoc(nav_index),	912	zcu.navSrcLoc(nav_index),
...	@@ -922,14 +914,8 @@ pub fn updateNav(	...	@@ -922,14 +914,8 @@ pub fn updateNav(
922	&code_buffer,	914	&code_buffer,
923	.{ .atom_index = sym_index },	915	.{ .atom_index = sym_index },
924	);	916	);
		917	const code = code_buffer.items;
925		918
926	const code = switch (res) {
927	.ok => code_buffer.items,
928	.fail => \|em\| {
929	try zcu.failed_codegen.put(zcu.gpa, nav_index, em);
930	return;
931	},
932	};
933	const sect_index = try self.getNavOutputSection(macho_file, zcu, nav_index, code);	919	const sect_index = try self.getNavOutputSection(macho_file, zcu, nav_index, code);
934	if (isThreadlocal(macho_file, nav_index))	920	if (isThreadlocal(macho_file, nav_index))
935	try self.updateTlv(macho_file, pt, nav_index, sym_index, sect_index, code)	921	try self.updateTlv(macho_file, pt, nav_index, sym_index, sect_index, code)
...	@@ -1221,7 +1207,7 @@ fn lowerConst(	...	@@ -1221,7 +1207,7 @@ fn lowerConst(
1221	const name_str = try self.addString(gpa, name);	1207	const name_str = try self.addString(gpa, name);
1222	const sym_index = try self.newSymbolWithAtom(gpa, name_str, macho_file);	1208	const sym_index = try self.newSymbolWithAtom(gpa, name_str, macho_file);
1223		1209
1224	const res = try codegen.generateSymbol(	1210	try codegen.generateSymbol(
1225	&macho_file.base,	1211	&macho_file.base,
1226	pt,	1212	pt,
1227	src_loc,	1213	src_loc,
...	@@ -1229,10 +1215,7 @@ fn lowerConst(	...	@@ -1229,10 +1215,7 @@ fn lowerConst(
1229	&code_buffer,	1215	&code_buffer,
1230	.{ .atom_index = sym_index },	1216	.{ .atom_index = sym_index },
1231	);	1217	);
1232	const code = switch (res) {	1218	const code = code_buffer.items;
1233	.ok => code_buffer.items,
1234	.fail => \|em\| return .{ .fail = em },
1235	};
1236		1219
1237	const sym = &self.symbols.items[sym_index];	1220	const sym = &self.symbols.items[sym_index];
1238	sym.out_n_sect = output_section_index;	1221	sym.out_n_sect = output_section_index;
...	@@ -1367,7 +1350,6 @@ fn updateLazySymbol(	...	@@ -1367,7 +1350,6 @@ fn updateLazySymbol(
1367	) !void {	1350	) !void {
1368	const zcu = pt.zcu;	1351	const zcu = pt.zcu;
1369	const gpa = zcu.gpa;	1352	const gpa = zcu.gpa;
1370	const diags = &macho_file.base.comp.link_diags;
1371		1353
1372	var required_alignment: Atom.Alignment = .none;	1354	var required_alignment: Atom.Alignment = .none;
1373	var code_buffer = std.ArrayList(u8).init(gpa);	1355	var code_buffer = std.ArrayList(u8).init(gpa);
...	@@ -1383,7 +1365,7 @@ fn updateLazySymbol(	...	@@ -1383,7 +1365,7 @@ fn updateLazySymbol(
1383	};	1365	};
1384		1366
1385	const src = Type.fromInterned(lazy_sym.ty).srcLocOrNull(zcu) orelse Zcu.LazySrcLoc.unneeded;	1367	const src = Type.fromInterned(lazy_sym.ty).srcLocOrNull(zcu) orelse Zcu.LazySrcLoc.unneeded;
1386	const res = codegen.generateLazySymbol(	1368	try codegen.generateLazySymbol(
1387	&macho_file.base,	1369	&macho_file.base,
1388	pt,	1370	pt,
1389	src,	1371	src,
...	@@ -1392,15 +1374,8 @@ fn updateLazySymbol(	...	@@ -1392,15 +1374,8 @@ fn updateLazySymbol(
1392	&code_buffer,	1374	&code_buffer,
1393	.none,	1375	.none,
1394	.{ .atom_index = symbol_index },	1376	.{ .atom_index = symbol_index },
1395	) catch \|err\| switch (err) {	1377	);
1396	error.CodegenFail => return error.LinkFailure,	1378	const code = code_buffer.items;
1397	error.OutOfMemory => return error.OutOfMemory,
1398	else => \|e\| return diags.fail("failed to codegen symbol: {s}", .{@errorName(e)}),
1399	};
1400	const code = switch (res) {
1401	.ok => code_buffer.items,
1402	.fail => \|em\| return diags.fail("codegen failure: {s}", .{em.msg}),
1403	};
1404		1379
1405	const output_section_index = switch (lazy_sym.kind) {	1380	const output_section_index = switch (lazy_sym.kind) {
1406	.code => macho_file.zig_text_sect_index.?,	1381	.code => macho_file.zig_text_sect_index.?,

src/link/Plan9.zig+6-15

 @@ -465,7 +465,7 @@ pub fn updateNav(self: *Plan9, pt: Zcu.PerThread, nav_index: InternPool.Nav.Inde
         var code_buffer = std.ArrayList(u8).init(gpa);
         defer code_buffer.deinit();
         // TODO we need the symbol index for symbol in the table of locals for the containing atom
-        const res = try codegen.generateSymbol(
+        try codegen.generateSymbol(
             &self.base,
             pt,
             zcu.navSrcLoc(nav_index),
 @@ -473,10 +473,7 @@ pub fn updateNav(self: *Plan9, pt: Zcu.PerThread, nav_index: InternPool.Nav.Inde
             &code_buffer,
             .{ .atom_index = @intCast(atom_idx) },
         );
-        const code = switch (res) {
+        const code = code_buffer.items;
-            .ok => code_buffer.items,
-            .fail => |em| return zcu.failed_codegen.put(gpa, nav_index, em),
-        };
         try self.data_nav_table.ensureUnusedCapacity(gpa, 1);
         const duped_code = try gpa.dupe(u8, code);
         self.getAtomPtr(self.navs.get(nav_index).?.index).code = .{ .code_ptr = null, .other = .{ .nav_index = nav_index } };
 @@ -1081,7 +1078,7 @@ fn updateLazySymbolAtom(
     // generate the code
     const src = Type.fromInterned(sym.ty).srcLocOrNull(pt.zcu) orelse Zcu.LazySrcLoc.unneeded;
-    const res = codegen.generateLazySymbol(
+    codegen.generateLazySymbol(
         &self.base,
         pt,
         src,
 @@ -1095,10 +1092,7 @@ fn updateLazySymbolAtom(
         error.CodegenFail => return error.LinkFailure,
         error.Overflow => return diags.fail("codegen failure: encountered number too big for compiler", .{}),
     };
-    const code = switch (res) {
+    const code = code_buffer.items;
-        .ok => code_buffer.items,
-        .fail => |em| return diags.fail("codegen failure: {s}", .{em.msg}),
-    };
     // duped_code is freed when the atom is freed
     const duped_code = try gpa.dupe(u8, code);
     errdefer gpa.free(duped_code);
 @@ -1408,11 +1402,8 @@ pub fn lowerUav(
     gop.value_ptr.* = index;
     // we need to free name latex
     var code_buffer = std.ArrayList(u8).init(gpa);
-    const res = try codegen.generateSymbol(&self.base, pt, src_loc, val, &code_buffer, .{ .atom_index = index });
+    try codegen.generateSymbol(&self.base, pt, src_loc, val, &code_buffer, .{ .atom_index = index });
-    const code = switch (res) {
+    const code = code_buffer.items;
-        .ok => code_buffer.items,
-        .fail => |em| return .{ .fail = em },
-    };
     const atom_ptr = self.getAtomPtr(index);
     atom_ptr.* = .{
         .type = .d,

author	Andrew Kelley <andrew@ziglang.org> 2024-12-03 20:35:23-08:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-01-15 15:11:35-08:00
log	9bf715de74a7d5badeae932afb594b7c6b33afa3
tree	302e2c5a42d30e379c5bb2e86c24360ea49ab3fb
parent	77accf597d845245847b143e42ec4109c9468480

...	@@ -1726,7 +1726,6 @@ pub fn linkerUpdateFunc(pt: Zcu.PerThread, func_index: InternPool.Index, air: Ai	...	@@ -1726,7 +1726,6 @@ pub fn linkerUpdateFunc(pt: Zcu.PerThread, func_index: InternPool.Index, air: Ai
1726	lf.updateFunc(pt, func_index, air, liveness) catch \|err\| switch (err) {	1726	lf.updateFunc(pt, func_index, air, liveness) catch \|err\| switch (err) {
1727	error.OutOfMemory => return error.OutOfMemory,	1727	error.OutOfMemory => return error.OutOfMemory,
1728	error.CodegenFail => assert(zcu.failed_codegen.contains(nav_index)),	1728	error.CodegenFail => assert(zcu.failed_codegen.contains(nav_index)),
1729	error.LinkFailure => assert(comp.link_diags.hasErrors()),
1730	error.Overflow => {	1729	error.Overflow => {
1731	try zcu.failed_codegen.putNoClobber(gpa, nav_index, try Zcu.ErrorMsg.create(	1730	try zcu.failed_codegen.putNoClobber(gpa, nav_index, try Zcu.ErrorMsg.create(
1732	gpa,	1731	gpa,
...	@@ -3112,7 +3111,6 @@ pub fn linkerUpdateNav(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) error	...	@@ -3112,7 +3111,6 @@ pub fn linkerUpdateNav(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) error
3112	lf.updateNav(pt, nav_index) catch \|err\| switch (err) {	3111	lf.updateNav(pt, nav_index) catch \|err\| switch (err) {
3113	error.OutOfMemory => return error.OutOfMemory,	3112	error.OutOfMemory => return error.OutOfMemory,
3114	error.CodegenFail => assert(zcu.failed_codegen.contains(nav_index)),	3113	error.CodegenFail => assert(zcu.failed_codegen.contains(nav_index)),
3115	error.LinkFailure => assert(comp.link_diags.hasErrors()),
3116	error.Overflow => {	3114	error.Overflow => {
3117	try zcu.failed_codegen.putNoClobber(gpa, nav_index, try Zcu.ErrorMsg.create(	3115	try zcu.failed_codegen.putNoClobber(gpa, nav_index, try Zcu.ErrorMsg.create(
3118	gpa,	3116	gpa,
...	@@ -3139,7 +3137,7 @@ pub fn linkerUpdateContainerType(pt: Zcu.PerThread, ty: InternPool.Index) error{	...	@@ -3139,7 +3137,7 @@ pub fn linkerUpdateContainerType(pt: Zcu.PerThread, ty: InternPool.Index) error{
3139	const codegen_prog_node = zcu.codegen_prog_node.start(Type.fromInterned(ty).containerTypeName(ip).toSlice(ip), 0);	3137	const codegen_prog_node = zcu.codegen_prog_node.start(Type.fromInterned(ty).containerTypeName(ip).toSlice(ip), 0);
3140	defer codegen_prog_node.end();	3138	defer codegen_prog_node.end();
3141		3139
3142	if (zcu.failed_types.fetchSwapRemove(ty)) \|entry\| entry.deinit();	3140	if (zcu.failed_types.fetchSwapRemove(ty)) \|*entry\| entry.value.deinit(gpa);
3143		3141
3144	if (!Air.typeFullyResolved(Type.fromInterned(ty), zcu)) {	3142	if (!Air.typeFullyResolved(Type.fromInterned(ty), zcu)) {
3145	// This type failed to resolve. This is a transitive failure.	3143	// This type failed to resolve. This is a transitive failure.
...	@@ -3148,12 +3146,7 @@ pub fn linkerUpdateContainerType(pt: Zcu.PerThread, ty: InternPool.Index) error{	...	@@ -3148,12 +3146,7 @@ pub fn linkerUpdateContainerType(pt: Zcu.PerThread, ty: InternPool.Index) error{
3148		3146
3149	if (comp.bin_file) \|lf\| lf.updateContainerType(pt, ty) catch \|err\| switch (err) {	3147	if (comp.bin_file) \|lf\| lf.updateContainerType(pt, ty) catch \|err\| switch (err) {
3150	error.OutOfMemory => return error.OutOfMemory,	3148	error.OutOfMemory => return error.OutOfMemory,
3151	else => \|e\| try zcu.failed_types.putNoClobber(gpa, ty, try Zcu.ErrorMsg.create(	3149	error.TypeFailureReported => assert(zcu.failed_types.contains(ty)),
3152	gpa,
3153	zcu.typeSrcLoc(ty),
3154	"failed to update container type: {s}",
3155	.{@errorName(e)},
3156	)),
3157	};	3150	};
3158	}	3151	}
3159		3152

rework error handling in the backends