Commit 434537213e406191959818f573b24ca45c1b0e45 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2024-02-13 01:54:57+00:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2024-02-16 11:26:33+00:00
log	434537213e406191959818f573b24ca45c1b0e45
tree	5892fc8f71a48ef1188cee96112a5d7a5706c14f
parent	aba29f9789aff0c1ace2a1d0031818ec2c04070c
signature	Commit is signed but in an unrecognized format.

Sema: eliminate `src` field

`sema.src` is a failed experiment. It introduces complexity, and makes
often unwarranted assumptions about the existence of instructions
providing source locations, requiring an unreasonable amount of caution
in AstGen for correctness. Eliminating it simplifies the whole frontend.

This required adding source locations to a few instructions, but the
cost in ZIR bytes should be counteracted by the other work on this
branch.

5 files changed, 221 insertions(+), 204 deletions(-)

src/AstGen.zig+79-61

 @@ -2122,7 +2122,7 @@ fn restoreErrRetIndex(
             else => .none, // always restore/pop
         },
     };
-    _ = try gz.addRestoreErrRetIndex(bt, .{ .if_non_error = op });
+    _ = try gz.addRestoreErrRetIndex(bt, .{ .if_non_error = op }, node);
 }
 fn breakExpr(parent_gz: *GenZir, parent_scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref {
 @@ -2179,7 +2179,7 @@ fn breakExpr(parent_gz: *GenZir, parent_scope: *Scope, node: Ast.Node.Index) Inn
                     // As our last action before the break, "pop" the error trace if needed
                     if (!block_gz.is_comptime)
-                        _ = try parent_gz.addRestoreErrRetIndex(.{ .block = block_inst }, .always);
+                        _ = try parent_gz.addRestoreErrRetIndex(.{ .block = block_inst }, .always, node);
                     _ = try parent_gz.addBreak(break_tag, block_inst, .void_value);
                     return Zir.Inst.Ref.unreachable_value;
 @@ -2271,7 +2271,7 @@ fn continueExpr(parent_gz: *GenZir, parent_scope: *Scope, node: Ast.Node.Index)
                 // As our last action before the continue, "pop" the error trace if needed
                 if (!gen_zir.is_comptime)
-                    _ = try parent_gz.addRestoreErrRetIndex(.{ .block = continue_block }, .always);
+                    _ = try parent_gz.addRestoreErrRetIndex(.{ .block = continue_block }, .always, node);
                 _ = try parent_gz.addBreak(break_tag, continue_block, .void_value);
                 return Zir.Inst.Ref.unreachable_value;
 @@ -2331,7 +2331,7 @@ fn blockExpr(
         if (!block_scope.endsWithNoReturn()) {
             // As our last action before the break, "pop" the error trace if needed
-            _ = try gz.addRestoreErrRetIndex(.{ .block = block_inst }, .always);
+            _ = try gz.addRestoreErrRetIndex(.{ .block = block_inst }, .always, block_node);
             _ = try block_scope.addBreak(.@"break", block_inst, .void_value);
         }
 @@ -2426,7 +2426,7 @@ fn labeledBlockExpr(
     try blockExprStmts(&block_scope, &block_scope.base, statements);
     if (!block_scope.endsWithNoReturn()) {
         // As our last action before the return, "pop" the error trace if needed
-        _ = try gz.addRestoreErrRetIndex(.{ .block = block_inst }, .always);
+        _ = try gz.addRestoreErrRetIndex(.{ .block = block_inst }, .always, block_node);
         _ = try block_scope.addBreak(.@"break", block_inst, .void_value);
     }
 @@ -2818,7 +2818,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
             .export_value,
             .set_eval_branch_quota,
             .atomic_store,
-            .store,
             .store_node,
             .store_to_inferred_ptr,
             .resolve_inferred_alloc,
 @@ -2829,7 +2828,8 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
             .validate_deref,
             .validate_destructure,
             .save_err_ret_index,
-            .restore_err_ret_index,
+            .restore_err_ret_index_unconditional,
+            .restore_err_ret_index_fn_entry,
             .validate_struct_init_ty,
             .validate_struct_init_result_ty,
             .validate_ptr_struct_init,
 @@ -3692,7 +3692,10 @@ fn assignOp(
         .lhs = lhs,
         .rhs = rhs,
     });
-    _ = try gz.addBin(.store, lhs_ptr, result);
+    _ = try gz.addPlNode(.store_node, infix_node, Zir.Inst.Bin{
+        .lhs = lhs_ptr,
+        .rhs = result,
+    });
 }
 fn assignShift(
 @@ -3715,7 +3718,10 @@ fn assignShift(
         .lhs = lhs,
         .rhs = rhs,
     });
-    _ = try gz.addBin(.store, lhs_ptr, result);
+    _ = try gz.addPlNode(.store_node, infix_node, Zir.Inst.Bin{
+        .lhs = lhs_ptr,
+        .rhs = result,
+    });
 }
 fn assignShiftSat(gz: *GenZir, scope: *Scope, infix_node: Ast.Node.Index) InnerError!void {
 @@ -3733,7 +3739,10 @@ fn assignShiftSat(gz: *GenZir, scope: *Scope, infix_node: Ast.Node.Index) InnerE
         .lhs = lhs,
         .rhs = rhs,
     });
-    _ = try gz.addBin(.store, lhs_ptr, result);
+    _ = try gz.addPlNode(.store_node, infix_node, Zir.Inst.Bin{
+        .lhs = lhs_ptr,
+        .rhs = result,
+    });
 }
 fn ptrType(
 @@ -4294,7 +4303,7 @@ fn fnDecl(
         if (!fn_gz.endsWithNoReturn()) {
             // As our last action before the return, "pop" the error trace if needed
-            _ = try gz.addRestoreErrRetIndex(.ret, .always);
+            _ = try gz.addRestoreErrRetIndex(.ret, .always, decl_node);
             // Add implicit return at end of function.
             _ = try fn_gz.addUnTok(.ret_implicit, .void_value, tree.lastToken(body_node));
 @@ -4742,7 +4751,7 @@ fn testDecl(
     if (fn_block.isEmpty() or !fn_block.refIsNoReturn(block_result)) {
         // As our last action before the return, "pop" the error trace if needed
-        _ = try gz.addRestoreErrRetIndex(.ret, .always);
+        _ = try gz.addRestoreErrRetIndex(.ret, .always, node);
         // Add implicit return at end of function.
         _ = try fn_block.addUnTok(.ret_implicit, .void_value, tree.lastToken(body_node));
 @@ -6149,7 +6158,7 @@ fn boolBinOp(
     const node_datas = tree.nodes.items(.data);
     const lhs = try expr(gz, scope, bool_ri, node_datas[node].lhs);
-    const bool_br = try gz.addBoolBr(zir_tag, lhs);
+    const bool_br = (try gz.addPlNodePayloadIndex(zir_tag, node, undefined)).toIndex().?;
     var rhs_scope = gz.makeSubBlock(scope);
     defer rhs_scope.unstack();
 @@ -6157,7 +6166,7 @@ fn boolBinOp(
     if (!gz.refIsNoReturn(rhs)) {
         _ = try rhs_scope.addBreakWithSrcNode(.break_inline, bool_br, rhs, node_datas[node].rhs);
     }
-    try rhs_scope.setBoolBrBody(bool_br);
+    try rhs_scope.setBoolBrBody(bool_br, lhs);
     const block_ref = bool_br.toRef();
     return rvalue(gz, ri, block_ref, node);
 @@ -6725,7 +6734,10 @@ fn forExpr(
         const alloc_tag: Zir.Inst.Tag = if (is_inline) .alloc_comptime_mut else .alloc;
         const index_ptr = try parent_gz.addUnNode(alloc_tag, .usize_type, node);
         // initialize to zero
-        _ = try parent_gz.addBin(.store, index_ptr, .zero_usize);
+        _ = try parent_gz.addPlNode(.store_node, node, Zir.Inst.Bin{
+            .lhs = index_ptr,
+            .rhs = .zero_usize,
+        });
         break :blk index_ptr;
     };
 @@ -6955,7 +6967,10 @@ fn forExpr(
             .lhs = index,
             .rhs = .one_usize,
         });
-        _ = try loop_scope.addBin(.store, index_ptr, index_plus_one);
+        _ = try loop_scope.addPlNode(.store_node, node, Zir.Inst.Bin{
+            .lhs = index_ptr,
+            .rhs = index_plus_one,
+        });
         const repeat_tag: Zir.Inst.Tag = if (is_inline) .repeat_inline else .repeat;
         _ = try loop_scope.addNode(repeat_tag, node);
 @@ -8008,7 +8023,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
         try genDefers(gz, defer_outer, scope, .normal_only);
         // As our last action before the return, "pop" the error trace if needed
-        _ = try gz.addRestoreErrRetIndex(.ret, .always);
+        _ = try gz.addRestoreErrRetIndex(.ret, .always, node);
         _ = try gz.addUnNode(.ret_node, .void_value, node);
         return Zir.Inst.Ref.unreachable_value;
 @@ -8051,7 +8066,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
             try genDefers(gz, defer_outer, scope, .normal_only);
             // As our last action before the return, "pop" the error trace if needed
-            _ = try gz.addRestoreErrRetIndex(.ret, .always);
+            _ = try gz.addRestoreErrRetIndex(.ret, .always, node);
             try emitDbgStmt(gz, ret_lc);
             try gz.addRet(ri, operand, node);
 @@ -8074,7 +8089,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
                 // As our last action before the return, "pop" the error trace if needed
                 const result = if (ri.rl == .ptr) try gz.addUnNode(.load, ri.rl.ptr.inst, node) else operand;
-                _ = try gz.addRestoreErrRetIndex(.ret, .{ .if_non_error = result });
+                _ = try gz.addRestoreErrRetIndex(.ret, .{ .if_non_error = result }, node);
                 try gz.addRet(ri, operand, node);
                 return Zir.Inst.Ref.unreachable_value;
 @@ -8091,7 +8106,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref
             try genDefers(&then_scope, defer_outer, scope, .normal_only);
             // As our last action before the return, "pop" the error trace if needed
-            _ = try then_scope.addRestoreErrRetIndex(.ret, .always);
+            _ = try then_scope.addRestoreErrRetIndex(.ret, .always, node);
             try emitDbgStmt(&then_scope, ret_lc);
             try then_scope.addRet(ri, operand, node);
 @@ -10979,7 +10994,10 @@ fn rvalueInner(
             return .void_value;
         },
         .inferred_ptr => |alloc| {
-            _ = try gz.addBin(.store_to_inferred_ptr, alloc, result);
+            _ = try gz.addPlNode(.store_to_inferred_ptr, src_node, Zir.Inst.Bin{
+                .lhs = alloc,
+                .rhs = result,
+            });
             return .void_value;
         },
         .destructure => |destructure| {
 @@ -11006,7 +11024,10 @@ fn rvalueInner(
                         });
                     },
                     .inferred_ptr => |ptr_inst| {
-                        _ = try gz.addBin(.store_to_inferred_ptr, ptr_inst, elem_val);
+                        _ = try gz.addPlNode(.store_to_inferred_ptr, src_node, Zir.Inst.Bin{
+                            .lhs = ptr_inst,
+                            .rhs = elem_val,
+                        });
                     },
                     .discard => unreachable,
                 }
 @@ -11828,19 +11849,20 @@ const GenZir = struct {
     }
     /// Assumes nothing stacked on `gz`. Unstacks `gz`.
-    fn setBoolBrBody(gz: *GenZir, inst: Zir.Inst.Index) !void {
+    fn setBoolBrBody(gz: *GenZir, bool_br: Zir.Inst.Index, bool_br_lhs: Zir.Inst.Ref) !void {
         const astgen = gz.astgen;
         const gpa = astgen.gpa;
         const body = gz.instructionsSlice();
         const body_len = astgen.countBodyLenAfterFixups(body);
         try astgen.extra.ensureUnusedCapacity(
             gpa,
-            @typeInfo(Zir.Inst.Block).Struct.fields.len + body_len,
+            @typeInfo(Zir.Inst.BoolBr).Struct.fields.len + body_len,
         );
         const zir_datas = astgen.instructions.items(.data);
-        zir_datas[@intFromEnum(inst)].bool_br.payload_index = astgen.addExtraAssumeCapacity(
+        zir_datas[@intFromEnum(bool_br)].pl_node.payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.BoolBr{
-            Zir.Inst.Block{ .body_len = body_len },
+            .lhs = bool_br_lhs,
-        );
+            .body_len = body_len,
+        });
         astgen.appendBodyWithFixups(body);
         gz.unstack();
     }
 @@ -12225,30 +12247,6 @@ const GenZir = struct {
         return new_index.toRef();
     }
-    /// Note that this returns a `Zir.Inst.Index` not a ref.
-    /// Leaves the `payload_index` field undefined.
-    fn addBoolBr(
-        gz: *GenZir,
-        tag: Zir.Inst.Tag,
-        lhs: Zir.Inst.Ref,
-    ) !Zir.Inst.Index {
-        assert(lhs != .none);
-        const gpa = gz.astgen.gpa;
-        try gz.instructions.ensureUnusedCapacity(gpa, 1);
-        try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1);
-        const new_index: Zir.Inst.Index = @enumFromInt(gz.astgen.instructions.len);
-        gz.astgen.instructions.appendAssumeCapacity(.{
-            .tag = tag,
-            .data = .{ .bool_br = .{
-                .lhs = lhs,
-                .payload_index = undefined,
-            } },
-        });
-        gz.instructions.appendAssumeCapacity(new_index);
-        return new_index;
-    }
     fn addInt(gz: *GenZir, integer: u64) !Zir.Inst.Ref {
         return gz.add(.{
             .tag = .int,
 @@ -12569,17 +12567,37 @@ const GenZir = struct {
             always: void,
             if_non_error: Zir.Inst.Ref,
         },
+        src_node: Ast.Node.Index,
     ) !Zir.Inst.Index {
-        return gz.addAsIndex(.{
+        switch (cond) {
-            .tag = .restore_err_ret_index,
+            .always => return gz.addAsIndex(.{
-            .data = .{ .restore_err_ret_index = .{
+                .tag = .restore_err_ret_index_unconditional,
-                .block = switch (bt) {
+                .data = .{ .un_node = .{
-                    .ret => .none,
+                    .operand = switch (bt) {
-                    .block => |b| b.toRef(),
+                        .ret => .none,
-                },
+                        .block => |b| b.toRef(),
-                .operand = if (cond == .if_non_error) cond.if_non_error else .none,
+                    },
-            } },
+                    .src_node = gz.nodeIndexToRelative(src_node),
-        });
+                } },
+            }),
+            .if_non_error => |operand| switch (bt) {
+                .ret => return gz.addAsIndex(.{
+                    .tag = .restore_err_ret_index_fn_entry,
+                    .data = .{ .un_node = .{
+                        .operand = operand,
+                        .src_node = gz.nodeIndexToRelative(src_node),
+                    } },
+                }),
+                .block => |block| return (try gz.addExtendedPayload(
+                    .restore_err_ret_index,
+                    Zir.Inst.RestoreErrRetIndex{
+                        .src_node = gz.nodeIndexToRelative(src_node),
+                        .block = block.toRef(),
+                        .operand = operand,
+                    },
+                )).toIndex().?,
+            },
+        }
     }
     fn addBreak(

src/Autodoc.zig+3-3

 @@ -1799,7 +1799,8 @@ fn walkInstruction(
             };
         },
         .bool_br_and, .bool_br_or => {
-            const bool_br = data[@intFromEnum(inst)].bool_br;
+            const pl_node = data[@intFromEnum(inst)].pl_node;
+            const extra = file.zir.extraData(Zir.Inst.BoolBr, pl_node.payload_index);
             const bin_index = self.exprs.items.len;
             try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
 @@ -1808,14 +1809,13 @@ fn walkInstruction(
                 file,
                 parent_scope,
                 parent_src,
-                bool_br.lhs,
+                extra.data.lhs,
                 false,
                 call_ctx,
             );
             const lhs_index = self.exprs.items.len;
             try self.exprs.append(self.arena, lhs.expr);
-            const extra = file.zir.extraData(Zir.Inst.Block, bool_br.payload_index);
             const rhs = try self.walkInstruction(
                 file,
                 parent_scope,

src/Sema.zig+71-86

...	@@ -50,11 +50,6 @@ branch_count: u32 = 0,	...	@@ -50,11 +50,6 @@ branch_count: u32 = 0,
50	/// Populated when returning `error.ComptimeBreak`. Used to communicate the	50	/// Populated when returning `error.ComptimeBreak`. Used to communicate the
51	/// break instruction up the stack to find the corresponding Block.	51	/// break instruction up the stack to find the corresponding Block.
52	comptime_break_inst: Zir.Inst.Index = undefined,	52	comptime_break_inst: Zir.Inst.Index = undefined,
53	/// This field is updated when a new source location becomes active, so that
54	/// instructions which do not have explicitly mapped source locations still have
55	/// access to the source location set by the previous instruction which did
56	/// contain a mapped source location.
57	src: LazySrcLoc = .{ .token_offset = 0 },
58	decl_val_table: std.AutoHashMapUnmanaged(InternPool.DeclIndex, Air.Inst.Ref) = .{},	53	decl_val_table: std.AutoHashMapUnmanaged(InternPool.DeclIndex, Air.Inst.Ref) = .{},
59	/// When doing a generic function instantiation, this array collects a value	54	/// When doing a generic function instantiation, this array collects a value
60	/// for each parameter of the generic owner. `none` for non-comptime parameters.	55	/// for each parameter of the generic owner. `none` for non-comptime parameters.
...	@@ -1006,10 +1001,10 @@ fn analyzeBodyInner(	...	@@ -1006,10 +1001,10 @@ fn analyzeBodyInner(
1006	const air_inst: Air.Inst.Ref = switch (tags[@intFromEnum(inst)]) {	1001	const air_inst: Air.Inst.Ref = switch (tags[@intFromEnum(inst)]) {
1007	// zig fmt: off	1002	// zig fmt: off
1008	.alloc => try sema.zirAlloc(block, inst),	1003	.alloc => try sema.zirAlloc(block, inst),
1009	.alloc_inferred => try sema.zirAllocInferred(block, inst, true),	1004	.alloc_inferred => try sema.zirAllocInferred(block, true),
1010	.alloc_inferred_mut => try sema.zirAllocInferred(block, inst, false),	1005	.alloc_inferred_mut => try sema.zirAllocInferred(block, false),
1011	.alloc_inferred_comptime => try sema.zirAllocInferredComptime(inst, true),	1006	.alloc_inferred_comptime => try sema.zirAllocInferredComptime(true),
1012	.alloc_inferred_comptime_mut => try sema.zirAllocInferredComptime(inst, false),	1007	.alloc_inferred_comptime_mut => try sema.zirAllocInferredComptime(false),
1013	.alloc_mut => try sema.zirAllocMut(block, inst),	1008	.alloc_mut => try sema.zirAllocMut(block, inst),
1014	.alloc_comptime_mut => try sema.zirAllocComptime(block, inst),	1009	.alloc_comptime_mut => try sema.zirAllocComptime(block, inst),
1015	.make_ptr_const => try sema.zirMakePtrConst(block, inst),	1010	.make_ptr_const => try sema.zirMakePtrConst(block, inst),
...	@@ -1308,6 +1303,11 @@ fn analyzeBodyInner(	...	@@ -1308,6 +1303,11 @@ fn analyzeBodyInner(
1308	i += 1;	1303	i += 1;
1309	continue;	1304	continue;
1310	},	1305	},
		1306	.restore_err_ret_index => {
		1307	try sema.zirRestoreErrRetIndex(block, extended);
		1308	i += 1;
		1309	continue;
		1310	},
1311	.value_placeholder => unreachable, // never appears in a body	1311	.value_placeholder => unreachable, // never appears in a body
1312	};	1312	};
1313	},	1313	},
...	@@ -1369,11 +1369,6 @@ fn analyzeBodyInner(	...	@@ -1369,11 +1369,6 @@ fn analyzeBodyInner(
1369	i += 1;	1369	i += 1;
1370	continue;	1370	continue;
1371	},	1371	},
1372	.store => {
1373	try sema.zirStore(block, inst);
1374	i += 1;
1375	continue;
1376	},
1377	.store_node => {	1372	.store_node => {
1378	try sema.zirStoreNode(block, inst);	1373	try sema.zirStoreNode(block, inst);
1379	i += 1;	1374	i += 1;
...	@@ -1518,8 +1513,15 @@ fn analyzeBodyInner(	...	@@ -1518,8 +1513,15 @@ fn analyzeBodyInner(
1518	i += 1;	1513	i += 1;
1519	continue;	1514	continue;
1520	},	1515	},
1521	.restore_err_ret_index => {	1516	.restore_err_ret_index_unconditional => {
1522	try sema.zirRestoreErrRetIndex(block, inst);	1517	const un_node = datas[@intFromEnum(inst)].un_node;
		1518	try sema.restoreErrRetIndex(block, un_node.src(), un_node.operand, .none);
		1519	i += 1;
		1520	continue;
		1521	},
		1522	.restore_err_ret_index_fn_entry => {
		1523	const un_node = datas[@intFromEnum(inst)].un_node;
		1524	try sema.restoreErrRetIndex(block, un_node.src(), .none, un_node.operand);
1523	i += 1;	1525	i += 1;
1524	continue;	1526	continue;
1525	},	1527	},
...	@@ -2779,7 +2781,7 @@ fn zirStructDecl(	...	@@ -2779,7 +2781,7 @@ fn zirStructDecl(
2779	const src: LazySrcLoc = if (small.has_src_node) blk: {	2781	const src: LazySrcLoc = if (small.has_src_node) blk: {
2780	const node_offset: i32 = @bitCast(sema.code.extra[extended.operand + @typeInfo(Zir.Inst.StructDecl).Struct.fields.len]);	2782	const node_offset: i32 = @bitCast(sema.code.extra[extended.operand + @typeInfo(Zir.Inst.StructDecl).Struct.fields.len]);
2781	break :blk LazySrcLoc.nodeOffset(node_offset);	2783	break :blk LazySrcLoc.nodeOffset(node_offset);
2782	} else sema.src;	2784	} else unreachable; // MLUGG TODO
2783		2785
2784	// Because these three things each reference each other, `undefined`	2786	// Because these three things each reference each other, `undefined`
2785	// placeholders are used before being set after the struct type gains an	2787	// placeholders are used before being set after the struct type gains an
...	@@ -2945,7 +2947,7 @@ fn zirEnumDecl(	...	@@ -2945,7 +2947,7 @@ fn zirEnumDecl(
2945	const node_offset: i32 = @bitCast(sema.code.extra[extra_index]);	2947	const node_offset: i32 = @bitCast(sema.code.extra[extra_index]);
2946	extra_index += 1;	2948	extra_index += 1;
2947	break :blk LazySrcLoc.nodeOffset(node_offset);	2949	break :blk LazySrcLoc.nodeOffset(node_offset);
2948	} else sema.src;	2950	} else unreachable; // MLUGG TODO
2949	const tag_ty_src: LazySrcLoc = .{ .node_offset_container_tag = src.node_offset.x };	2951	const tag_ty_src: LazySrcLoc = .{ .node_offset_container_tag = src.node_offset.x };
2950		2952
2951	const tag_type_ref = if (small.has_tag_type) blk: {	2953	const tag_type_ref = if (small.has_tag_type) blk: {
...	@@ -3218,7 +3220,7 @@ fn zirUnionDecl(	...	@@ -3218,7 +3220,7 @@ fn zirUnionDecl(
3218	const node_offset: i32 = @bitCast(sema.code.extra[extra_index]);	3220	const node_offset: i32 = @bitCast(sema.code.extra[extra_index]);
3219	extra_index += 1;	3221	extra_index += 1;
3220	break :blk LazySrcLoc.nodeOffset(node_offset);	3222	break :blk LazySrcLoc.nodeOffset(node_offset);
3221	} else sema.src;	3223	} else unreachable; // MLUGG TODO
3222		3224
3223	extra_index += @intFromBool(small.has_tag_type);	3225	extra_index += @intFromBool(small.has_tag_type);
3224	extra_index += @intFromBool(small.has_body_len);	3226	extra_index += @intFromBool(small.has_body_len);
...	@@ -3327,7 +3329,7 @@ fn zirOpaqueDecl(	...	@@ -3327,7 +3329,7 @@ fn zirOpaqueDecl(
3327	const node_offset: i32 = @bitCast(sema.code.extra[extra_index]);	3329	const node_offset: i32 = @bitCast(sema.code.extra[extra_index]);
3328	extra_index += 1;	3330	extra_index += 1;
3329	break :blk LazySrcLoc.nodeOffset(node_offset);	3331	break :blk LazySrcLoc.nodeOffset(node_offset);
3330	} else sema.src;	3332	} else unreachable; // MLUGG TODO
3331		3333
3332	const decls_len = if (small.has_decls_len) blk: {	3334	const decls_len = if (small.has_decls_len) blk: {
3333	const decls_len = sema.code.extra[extra_index];	3335	const decls_len = sema.code.extra[extra_index];
...	@@ -3977,13 +3979,9 @@ fn makePtrConst(sema: Sema, block: Block, alloc: Air.Inst.Ref) CompileError!Ai	...	@@ -3977,13 +3979,9 @@ fn makePtrConst(sema: Sema, block: Block, alloc: Air.Inst.Ref) CompileError!Ai
3977		3979
3978	fn zirAllocInferredComptime(	3980	fn zirAllocInferredComptime(
3979	sema: *Sema,	3981	sema: *Sema,
3980	inst: Zir.Inst.Index,
3981	is_const: bool,	3982	is_const: bool,
3982	) CompileError!Air.Inst.Ref {	3983	) CompileError!Air.Inst.Ref {
3983	const gpa = sema.gpa;	3984	const gpa = sema.gpa;
3984	const src_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].node;
3985	const src = LazySrcLoc.nodeOffset(src_node);
3986	sema.src = src;
3987		3985
3988	try sema.air_instructions.append(gpa, .{	3986	try sema.air_instructions.append(gpa, .{
3989	.tag = .inferred_alloc_comptime,	3987	.tag = .inferred_alloc_comptime,
...	@@ -4042,16 +4040,12 @@ fn zirAllocMut(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -4042,16 +4040,12 @@ fn zirAllocMut(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
4042	fn zirAllocInferred(	4040	fn zirAllocInferred(
4043	sema: *Sema,	4041	sema: *Sema,
4044	block: *Block,	4042	block: *Block,
4045	inst: Zir.Inst.Index,
4046	is_const: bool,	4043	is_const: bool,
4047	) CompileError!Air.Inst.Ref {	4044	) CompileError!Air.Inst.Ref {
4048	const tracy = trace(@src());	4045	const tracy = trace(@src());
4049	defer tracy.end();	4046	defer tracy.end();
4050		4047
4051	const gpa = sema.gpa;	4048	const gpa = sema.gpa;
4052	const src_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].node;
4053	const src = LazySrcLoc.nodeOffset(src_node);
4054	sema.src = src;
4055		4049
4056	if (block.is_comptime) {	4050	if (block.is_comptime) {
4057	try sema.air_instructions.append(gpa, .{	4051	try sema.air_instructions.append(gpa, .{
...	@@ -5428,10 +5422,11 @@ fn zirStoreToInferredPtr(sema: Sema, block: Block, inst: Zir.Inst.Index) Compi	...	@@ -5428,10 +5422,11 @@ fn zirStoreToInferredPtr(sema: Sema, block: Block, inst: Zir.Inst.Index) Compi
5428	const tracy = trace(@src());	5422	const tracy = trace(@src());
5429	defer tracy.end();	5423	defer tracy.end();
5430		5424
5431	const src: LazySrcLoc = sema.src;	5425	const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
5432	const bin_inst = sema.code.instructions.items(.data)[@intFromEnum(inst)].bin;	5426	const src = pl_node.src();
5433	const ptr = try sema.resolveInst(bin_inst.lhs);	5427	const bin = sema.code.extraData(Zir.Inst.Bin, pl_node.payload_index).data;
5434	const operand = try sema.resolveInst(bin_inst.rhs);	5428	const ptr = try sema.resolveInst(bin.lhs);
		5429	const operand = try sema.resolveInst(bin.rhs);
5435	const ptr_inst = ptr.toIndex().?;	5430	const ptr_inst = ptr.toIndex().?;
5436	const air_datas = sema.air_instructions.items(.data);	5431	const air_datas = sema.air_instructions.items(.data);
5437		5432
...	@@ -5496,16 +5491,6 @@ fn zirSetEvalBranchQuota(sema: Sema, block: Block, inst: Zir.Inst.Index) Compi	...	@@ -5496,16 +5491,6 @@ fn zirSetEvalBranchQuota(sema: Sema, block: Block, inst: Zir.Inst.Index) Compi
5496	sema.branch_quota = @max(sema.branch_quota, quota);	5491	sema.branch_quota = @max(sema.branch_quota, quota);
5497	}	5492	}
5498		5493
5499	fn zirStore(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!void {
5500	const tracy = trace(@src());
5501	defer tracy.end();
5502
5503	const bin_inst = sema.code.instructions.items(.data)[@intFromEnum(inst)].bin;
5504	const ptr = try sema.resolveInst(bin_inst.lhs);
5505	const value = try sema.resolveInst(bin_inst.rhs);
5506	return sema.storePtr(block, sema.src, ptr, value);
5507	}
5508
5509	fn zirStoreNode(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!void {	5494	fn zirStoreNode(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!void {
5510	const tracy = trace(@src());	5495	const tracy = trace(@src());
5511	defer tracy.end();	5496	defer tracy.end();
...	@@ -5709,7 +5694,6 @@ fn zirPanic(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Zir.I	...	@@ -5709,7 +5694,6 @@ fn zirPanic(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Zir.I
5709	fn zirTrap(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Zir.Inst.Index {	5694	fn zirTrap(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Zir.Inst.Index {
5710	const src_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].node;	5695	const src_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].node;
5711	const src = LazySrcLoc.nodeOffset(src_node);	5696	const src = LazySrcLoc.nodeOffset(src_node);
5712	sema.src = src;
5713	if (block.is_comptime)	5697	if (block.is_comptime)
5714	return sema.fail(block, src, "encountered @trap at comptime", .{});	5698	return sema.fail(block, src, "encountered @trap at comptime", .{});
5715	_ = try block.addNoOp(.trap);	5699	_ = try block.addNoOp(.trap);
...	@@ -6384,10 +6368,6 @@ fn zirBreak(sema: Sema, start_block: Block, inst: Zir.Inst.Index) CompileError	...	@@ -6384,10 +6368,6 @@ fn zirBreak(sema: Sema, start_block: Block, inst: Zir.Inst.Index) CompileError
6384	}	6368	}
6385		6369
6386	fn zirDbgStmt(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!void {	6370	fn zirDbgStmt(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!void {
6387	// We do not set sema.src here because dbg_stmt instructions are only emitted for
6388	// ZIR code that possibly will need to generate runtime code. So error messages
6389	// and other source locations must not rely on sema.src being set from dbg_stmt
6390	// instructions.
6391	if (block.is_comptime or block.ownerModule().strip) return;	6371	if (block.is_comptime or block.ownerModule().strip) return;
6392		6372
6393	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;	6373	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt;
...	@@ -6632,7 +6612,6 @@ fn funcDeclSrc(sema: Sema, func_inst: Air.Inst.Ref) !?Decl {	...	@@ -6632,7 +6612,6 @@ fn funcDeclSrc(sema: Sema, func_inst: Air.Inst.Ref) !?Decl {
6632	pub fn analyzeSaveErrRetIndex(sema: Sema, block: Block) SemaError!Air.Inst.Ref {	6612	pub fn analyzeSaveErrRetIndex(sema: Sema, block: Block) SemaError!Air.Inst.Ref {
6633	const mod = sema.mod;	6613	const mod = sema.mod;
6634	const gpa = sema.gpa;	6614	const gpa = sema.gpa;
6635	const src = sema.src;
6636		6615
6637	if (block.is_comptime or block.is_typeof) {	6616	if (block.is_comptime or block.is_typeof) {
6638	const index_val = try mod.intValue_u64(Type.usize, sema.comptime_err_ret_trace.items.len);	6617	const index_val = try mod.intValue_u64(Type.usize, sema.comptime_err_ret_trace.items.len);
...	@@ -6650,9 +6629,10 @@ pub fn analyzeSaveErrRetIndex(sema: Sema, block: Block) SemaError!Air.Inst.Ref	...	@@ -6650,9 +6629,10 @@ pub fn analyzeSaveErrRetIndex(sema: Sema, block: Block) SemaError!Air.Inst.Ref
6650	else => \|e\| return e,	6629	else => \|e\| return e,
6651	};	6630	};
6652	const field_name = try mod.intern_pool.getOrPutString(gpa, "index");	6631	const field_name = try mod.intern_pool.getOrPutString(gpa, "index");
6653	const field_index = sema.structFieldIndex(block, stack_trace_ty, field_name, src) catch \|err\| switch (err) {	6632	const field_index = sema.structFieldIndex(block, stack_trace_ty, field_name, .unneeded) catch \|err\| switch (err) {
6654	error.NeededSourceLocation, error.GenericPoison, error.ComptimeReturn, error.ComptimeBreak => unreachable,	6633	error.AnalysisFail, error.NeededSourceLocation => @panic("std.builtin.StackTrace is corrupt"),
6655	else => \|e\| return e,	6634	error.GenericPoison, error.ComptimeReturn, error.ComptimeBreak => unreachable,
		6635	error.OutOfMemory => \|e\| return e,
6656	};	6636	};
6657		6637
6658	return try block.addInst(.{	6638	return try block.addInst(.{
...	@@ -9900,7 +9880,6 @@ fn zirAsNode(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.	...	@@ -9900,7 +9880,6 @@ fn zirAsNode(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.
9900	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	9880	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
9901	const src = inst_data.src();	9881	const src = inst_data.src();
9902	const extra = sema.code.extraData(Zir.Inst.As, inst_data.payload_index).data;	9882	const extra = sema.code.extraData(Zir.Inst.As, inst_data.payload_index).data;
9903	sema.src = src;
9904	return sema.analyzeAs(block, src, extra.dest_type, extra.operand, false);	9883	return sema.analyzeAs(block, src, extra.dest_type, extra.operand, false);
9905	}	9884	}
9906		9885
...	@@ -10855,7 +10834,7 @@ const SwitchProngAnalysis = struct {	...	@@ -10855,7 +10834,7 @@ const SwitchProngAnalysis = struct {
10855	.address_space = operand_ptr_ty.ptrAddressSpace(mod),	10834	.address_space = operand_ptr_ty.ptrAddressSpace(mod),
10856	},	10835	},
10857	});	10836	});
10858	if (try sema.resolveDefinedValue(block, sema.src, spa.operand_ptr)) \|union_ptr\| {	10837	if (try sema.resolveDefinedValue(block, operand_src, spa.operand_ptr)) \|union_ptr\| {
10859	return Air.internedToRef((try mod.intern(.{ .ptr = .{	10838	return Air.internedToRef((try mod.intern(.{ .ptr = .{
10860	.ty = ptr_field_ty.toIntern(),	10839	.ty = ptr_field_ty.toIntern(),
10861	.addr = .{ .field = .{	10840	.addr = .{ .field = .{
...	@@ -10866,7 +10845,7 @@ const SwitchProngAnalysis = struct {	...	@@ -10866,7 +10845,7 @@ const SwitchProngAnalysis = struct {
10866	}	10845	}
10867	return block.addStructFieldPtr(spa.operand_ptr, field_index, ptr_field_ty);	10846	return block.addStructFieldPtr(spa.operand_ptr, field_index, ptr_field_ty);
10868	} else {	10847	} else {
10869	if (try sema.resolveDefinedValue(block, sema.src, spa.operand)) \|union_val\| {	10848	if (try sema.resolveDefinedValue(block, operand_src, spa.operand)) \|union_val\| {
10870	const tag_and_val = ip.indexToKey(union_val.toIntern()).un;	10849	const tag_and_val = ip.indexToKey(union_val.toIntern()).un;
10871	return Air.internedToRef(tag_and_val.val);	10850	return Air.internedToRef(tag_and_val.val);
10872	}	10851	}
...	@@ -13191,6 +13170,7 @@ fn validateErrSetSwitch(	...	@@ -13191,6 +13170,7 @@ fn validateErrSetSwitch(
13191	// else => \|e\| return e,	13170	// else => \|e\| return e,
13192	// even if all the possible errors were already handled.	13171	// even if all the possible errors were already handled.
13193	const tags = sema.code.instructions.items(.tag);	13172	const tags = sema.code.instructions.items(.tag);
		13173	const datas = sema.code.instructions.items(.data);
13194	for (else_case.body) \|else_inst\| switch (tags[@intFromEnum(else_inst)]) {	13174	for (else_case.body) \|else_inst\| switch (tags[@intFromEnum(else_inst)]) {
13195	.dbg_block_begin,	13175	.dbg_block_begin,
13196	.dbg_block_end,	13176	.dbg_block_end,
...	@@ -13205,11 +13185,16 @@ fn validateErrSetSwitch(	...	@@ -13205,11 +13185,16 @@ fn validateErrSetSwitch(
13205	.err_union_code,	13185	.err_union_code,
13206	.ret_err_value_code,	13186	.ret_err_value_code,
13207	.save_err_ret_index,	13187	.save_err_ret_index,
13208	.restore_err_ret_index,	13188	.restore_err_ret_index_unconditional,
		13189	.restore_err_ret_index_fn_entry,
13209	.is_non_err,	13190	.is_non_err,
13210	.ret_is_non_err,	13191	.ret_is_non_err,
13211	.condbr,	13192	.condbr,
13212	=> {},	13193	=> {},
		13194	.extended => switch (datas[@intFromEnum(else_inst)].extended.opcode) {
		13195	.restore_err_ret_index => {},
		13196	else => break,
		13197	},
13213	else => break,	13198	else => break,
13214	} else break :else_validation;	13199	} else break :else_validation;
13215		13200
...	@@ -13707,7 +13692,6 @@ fn zirShl(	...	@@ -13707,7 +13692,6 @@ fn zirShl(
13707	const mod = sema.mod;	13692	const mod = sema.mod;
13708	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	13693	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
13709	const src = inst_data.src();	13694	const src = inst_data.src();
13710	sema.src = src;
13711	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };	13695	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
13712	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };	13696	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
13713	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;	13697	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
...	@@ -13878,7 +13862,6 @@ fn zirShr(	...	@@ -13878,7 +13862,6 @@ fn zirShr(
13878	const mod = sema.mod;	13862	const mod = sema.mod;
13879	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	13863	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
13880	const src = inst_data.src();	13864	const src = inst_data.src();
13881	sema.src = src;
13882	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };	13865	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
13883	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };	13866	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
13884	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;	13867	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
...	@@ -14014,7 +13997,6 @@ fn zirBitwise(	...	@@ -14014,7 +13997,6 @@ fn zirBitwise(
14014	const mod = sema.mod;	13997	const mod = sema.mod;
14015	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	13998	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
14016	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };	13999	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
14017	sema.src = src;
14018	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };	14000	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
14019	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };	14001	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
14020	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;	14002	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
...	@@ -14795,21 +14777,20 @@ fn zirArithmetic(	...	@@ -14795,21 +14777,20 @@ fn zirArithmetic(
14795	defer tracy.end();	14777	defer tracy.end();
14796		14778
14797	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	14779	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
14798	sema.src = .{ .node_offset_bin_op = inst_data.src_node };	14780	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
14799	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };	14781	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
14800	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };	14782	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
14801	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;	14783	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
14802	const lhs = try sema.resolveInst(extra.lhs);	14784	const lhs = try sema.resolveInst(extra.lhs);
14803	const rhs = try sema.resolveInst(extra.rhs);	14785	const rhs = try sema.resolveInst(extra.rhs);
14804		14786
14805	return sema.analyzeArithmetic(block, zir_tag, lhs, rhs, sema.src, lhs_src, rhs_src, safety);	14787	return sema.analyzeArithmetic(block, zir_tag, lhs, rhs, src, lhs_src, rhs_src, safety);
14806	}	14788	}
14807		14789
14808	fn zirDiv(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {	14790	fn zirDiv(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
14809	const mod = sema.mod;	14791	const mod = sema.mod;
14810	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	14792	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
14811	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };	14793	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
14812	sema.src = src;
14813	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };	14794	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
14814	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };	14795	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
14815	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;	14796	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
...	@@ -14975,7 +14956,6 @@ fn zirDivExact(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -14975,7 +14956,6 @@ fn zirDivExact(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
14975	const mod = sema.mod;	14956	const mod = sema.mod;
14976	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	14957	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
14977	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };	14958	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
14978	sema.src = src;
14979	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };	14959	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
14980	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };	14960	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
14981	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;	14961	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
...	@@ -15141,7 +15121,6 @@ fn zirDivFloor(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -15141,7 +15121,6 @@ fn zirDivFloor(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
15141	const mod = sema.mod;	15121	const mod = sema.mod;
15142	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	15122	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
15143	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };	15123	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
15144	sema.src = src;
15145	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };	15124	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
15146	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };	15125	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
15147	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;	15126	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
...	@@ -15252,7 +15231,6 @@ fn zirDivTrunc(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -15252,7 +15231,6 @@ fn zirDivTrunc(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
15252	const mod = sema.mod;	15231	const mod = sema.mod;
15253	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	15232	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
15254	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };	15233	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
15255	sema.src = src;
15256	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };	15234	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
15257	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };	15235	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
15258	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;	15236	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
...	@@ -15494,7 +15472,6 @@ fn zirModRem(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.	...	@@ -15494,7 +15472,6 @@ fn zirModRem(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.
15494	const mod = sema.mod;	15472	const mod = sema.mod;
15495	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	15473	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
15496	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };	15474	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
15497	sema.src = src;
15498	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };	15475	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
15499	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };	15476	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
15500	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;	15477	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
...	@@ -15679,7 +15656,6 @@ fn zirMod(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Ins	...	@@ -15679,7 +15656,6 @@ fn zirMod(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Ins
15679	const mod = sema.mod;	15656	const mod = sema.mod;
15680	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	15657	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
15681	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };	15658	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
15682	sema.src = src;
15683	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };	15659	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
15684	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };	15660	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
15685	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;	15661	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
...	@@ -15775,7 +15751,6 @@ fn zirRem(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Ins	...	@@ -15775,7 +15751,6 @@ fn zirRem(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Air.Ins
15775	const mod = sema.mod;	15751	const mod = sema.mod;
15776	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	15752	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
15777	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };	15753	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
15778	sema.src = src;
15779	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };	15754	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
15780	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };	15755	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
15781	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;	15756	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
...	@@ -18741,13 +18716,16 @@ fn zirBoolBr(	...	@@ -18741,13 +18716,16 @@ fn zirBoolBr(
18741	defer tracy.end();	18716	defer tracy.end();
18742		18717
18743	const mod = sema.mod;	18718	const mod = sema.mod;
		18719	const gpa = sema.gpa;
		18720
18744	const datas = sema.code.instructions.items(.data);	18721	const datas = sema.code.instructions.items(.data);
18745	const inst_data = datas[@intFromEnum(inst)].bool_br;	18722	const inst_data = datas[@intFromEnum(inst)].pl_node;
18746	const lhs = try sema.resolveInst(inst_data.lhs);	18723	const extra = sema.code.extraData(Zir.Inst.BoolBr, inst_data.payload_index);
18747	const lhs_src = sema.src;	18724
18748	const extra = sema.code.extraData(Zir.Inst.Block, inst_data.payload_index);	18725	const lhs = try sema.resolveInst(extra.data.lhs);
18749	const body = sema.code.bodySlice(extra.end, extra.data.body_len);	18726	const body = sema.code.bodySlice(extra.end, extra.data.body_len);
18750	const gpa = sema.gpa;	18727	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
		18728	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
18751		18729
18752	if (try sema.resolveDefinedValue(parent_block, lhs_src, lhs)) \|lhs_val\| {	18730	if (try sema.resolveDefinedValue(parent_block, lhs_src, lhs)) \|lhs_val\| {
18753	if (is_bool_or and lhs_val.toBool()) {	18731	if (is_bool_or and lhs_val.toBool()) {
...	@@ -18795,7 +18773,7 @@ fn zirBoolBr(	...	@@ -18795,7 +18773,7 @@ fn zirBoolBr(
18795		18773
18796	const result = sema.finishCondBr(parent_block, &child_block, &then_block, &else_block, lhs, block_inst);	18774	const result = sema.finishCondBr(parent_block, &child_block, &then_block, &else_block, lhs, block_inst);
18797	if (!sema.typeOf(rhs_result).isNoReturn(mod)) {	18775	if (!sema.typeOf(rhs_result).isNoReturn(mod)) {
18798	if (try sema.resolveDefinedValue(rhs_block, sema.src, rhs_result)) \|rhs_val\| {	18776	if (try sema.resolveDefinedValue(rhs_block, rhs_src, rhs_result)) \|rhs_val\| {
18799	if (is_bool_or and rhs_val.toBool()) {	18777	if (is_bool_or and rhs_val.toBool()) {
18800	return .bool_true;	18778	return .bool_true;
18801	} else if (!is_bool_or and !rhs_val.toBool()) {	18779	} else if (!is_bool_or and !rhs_val.toBool()) {
...	@@ -19375,17 +19353,21 @@ fn zirSaveErrRetIndex(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileE	...	@@ -19375,17 +19353,21 @@ fn zirSaveErrRetIndex(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileE
19375	block.error_return_trace_index = try sema.analyzeSaveErrRetIndex(block);	19353	block.error_return_trace_index = try sema.analyzeSaveErrRetIndex(block);
19376	}	19354	}
19377		19355
19378	fn zirRestoreErrRetIndex(sema: Sema, start_block: Block, inst: Zir.Inst.Index) CompileError!void {	19356	fn zirRestoreErrRetIndex(sema: Sema, start_block: Block, extended: Zir.Inst.Extended.InstData) CompileError!void {
19379	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].restore_err_ret_index;	19357	const extra = sema.code.extraData(Zir.Inst.RestoreErrRetIndex, extended.operand).data;
19380	const src = sema.src; // TODO	19358	return sema.restoreErrRetIndex(start_block, extra.src(), extra.block, extra.operand);
19381		19359	}
19382	const mod = sema.mod;
19383	const ip = &mod.intern_pool;
19384		19360
		19361	/// If `operand` is non-error (or is `none`), restores the error return trace to
		19362	/// its state at the point `block` was reached (or, if `block` is `none`, the
		19363	/// point this function began execution).
		19364	fn restoreErrRetIndex(sema: Sema, start_block: Block, src: LazySrcLoc, target_block: Zir.Inst.Ref, operand_zir: Zir.Inst.Ref) CompileError!void {
19385	const tracy = trace(@src());	19365	const tracy = trace(@src());
19386	defer tracy.end();	19366	defer tracy.end();
19387		19367
19388	const saved_index = if (inst_data.block.toIndexAllowNone()) \|zir_block\| b: {	19368	const mod = sema.mod;
		19369
		19370	const saved_index = if (target_block.toIndexAllowNone()) \|zir_block\| b: {
19389	var block = start_block;	19371	var block = start_block;
19390	while (true) {	19372	while (true) {
19391	if (block.label) \|label\| {	19373	if (block.label) \|label\| {
...	@@ -19409,7 +19391,7 @@ fn zirRestoreErrRetIndex(sema: Sema, start_block: Block, inst: Zir.Inst.Index)	...	@@ -19409,7 +19391,7 @@ fn zirRestoreErrRetIndex(sema: Sema, start_block: Block, inst: Zir.Inst.Index)
19409	return; // No need to restore	19391	return; // No need to restore
19410	};	19392	};
19411		19393
19412	const operand = try sema.resolveInstAllowNone(inst_data.operand);	19394	const operand = try sema.resolveInstAllowNone(operand_zir);
19413		19395
19414	if (start_block.is_comptime or start_block.is_typeof) {	19396	if (start_block.is_comptime or start_block.is_typeof) {
19415	const is_non_error = if (operand != .none) blk: {	19397	const is_non_error = if (operand != .none) blk: {
...	@@ -19427,7 +19409,7 @@ fn zirRestoreErrRetIndex(sema: Sema, start_block: Block, inst: Zir.Inst.Index)	...	@@ -19427,7 +19409,7 @@ fn zirRestoreErrRetIndex(sema: Sema, start_block: Block, inst: Zir.Inst.Index)
19427	return;	19409	return;
19428	}	19410	}
19429		19411
19430	if (!ip.funcAnalysis(sema.owner_func_index).calls_or_awaits_errorable_fn) return;	19412	if (!mod.intern_pool.funcAnalysis(sema.owner_func_index).calls_or_awaits_errorable_fn) return;
19431	if (!start_block.ownerModule().error_tracing) return;	19413	if (!start_block.ownerModule().error_tracing) return;
19432		19414
19433	assert(saved_index != .none); // The .error_return_trace_index field was dropped somewhere	19415	assert(saved_index != .none); // The .error_return_trace_index field was dropped somewhere
...	@@ -23161,7 +23143,6 @@ fn zirOffsetOf(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai	...	@@ -23161,7 +23143,6 @@ fn zirOffsetOf(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!Ai
23161	fn bitOffsetOf(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!u64 {	23143	fn bitOffsetOf(sema: Sema, block: Block, inst: Zir.Inst.Index) CompileError!u64 {
23162	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;	23144	const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
23163	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };	23145	const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node };
23164	sema.src = src;
23165	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };	23146	const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node };
23166	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };	23147	const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node };
23167	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;	23148	const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data;
...	@@ -26416,12 +26397,16 @@ fn preparePanicId(sema: Sema, block: Block, panic_id: Module.PanicId) !InternP	...	@@ -26416,12 +26397,16 @@ fn preparePanicId(sema: Sema, block: Block, panic_id: Module.PanicId) !InternP
26416	try sema.prepareSimplePanic(block);	26397	try sema.prepareSimplePanic(block);
26417		26398
26418	const panic_messages_ty = try sema.getBuiltinType("panic_messages");	26399	const panic_messages_ty = try sema.getBuiltinType("panic_messages");
26419	const msg_decl_index = (try sema.namespaceLookup(	26400	const msg_decl_index = (sema.namespaceLookup(
26420	block,	26401	block,
26421	sema.src,	26402	.unneeded,
26422	panic_messages_ty.getNamespaceIndex(mod).unwrap().?,	26403	panic_messages_ty.getNamespaceIndex(mod).unwrap().?,
26423	try mod.intern_pool.getOrPutString(gpa, @tagName(panic_id)),	26404	try mod.intern_pool.getOrPutString(gpa, @tagName(panic_id)),
26424	)).?;	26405	) catch \|err\| switch (err) {
		26406	error.AnalysisFail, error.NeededSourceLocation => @panic("std.builtin.panic_messages is corrupt"),
		26407	error.GenericPoison, error.ComptimeReturn, error.ComptimeBreak => unreachable,
		26408	error.OutOfMemory => \|e\| return e,
		26409	}).?;
26425	try sema.ensureDeclAnalyzed(msg_decl_index);	26410	try sema.ensureDeclAnalyzed(msg_decl_index);
26426	mod.panic_messages[@intFromEnum(panic_id)] = msg_decl_index.toOptional();	26411	mod.panic_messages[@intFromEnum(panic_id)] = msg_decl_index.toOptional();
26427	return msg_decl_index;	26412	return msg_decl_index;

src/Zir.zig+52-33

 @@ -303,11 +303,11 @@ pub const Inst = struct {
         bool_not,
         /// Short-circuiting boolean `and`. `lhs` is a boolean `Ref` and the other operand
         /// is a block, which is evaluated if `lhs` is `true`.
-        /// Uses the `bool_br` union field.
+        /// Uses the `pl_node` union field. Payload is `BoolBr`.
         bool_br_and,
         /// Short-circuiting boolean `or`. `lhs` is a boolean `Ref` and the other operand
         /// is a block, which is evaluated if `lhs` is `false`.
-        /// Uses the `bool_br` union field.
+        /// Uses the `pl_node` union field. Payload is `BoolBr`.
         bool_br_or,
         /// Return a value from a block.
         /// Uses the `break` union field.
 @@ -592,16 +592,12 @@ pub const Inst = struct {
         /// Returns a pointer to the subslice.
         /// Uses the `pl_node` field. AST node is the slice syntax. Payload is `SliceLength`.
         slice_length,
-        /// Write a value to a pointer. For loading, see `load`.
-        /// Source location is assumed to be same as previous instruction.
-        /// Uses the `bin` union field.
-        store,
         /// Same as `store` except provides a source location.
         /// Uses the `pl_node` union field. Payload is `Bin`.
         store_node,
-        /// Same as `store` but the type of the value being stored will be used to infer
+        /// Same as `store_node` but the type of the value being stored will be
-        /// the pointer type.
+        /// used to infer the pointer type of an `alloc_inferred`.
-        /// Uses the `bin` union field.
+        /// Uses the `pl_node` union field. Payload is `Bin`.
         store_to_inferred_ptr,
         /// String Literal. Makes an anonymous Decl and then takes a pointer to it.
         /// Uses the `str` union field.
 @@ -1036,10 +1032,18 @@ pub const Inst = struct {
         /// block, if the operand is .none or of an error/error-union type.
         /// Uses the `save_err_ret_index` field.
         save_err_ret_index,
-        /// Sets error return trace to zero if no operand is given,
+        /// Specialized form of `Extended.restore_err_ret_index`.
-        /// otherwise sets the value to the given amount.
+        /// Unconditionally restores the error return index to its last saved state
-        /// Uses the `restore_err_ret_index` union field.
+        /// in the block referred to by `operand`. If `operand` is `none`, restores
-        restore_err_ret_index,
+        /// to the point of function entry.
+        /// Uses the `un_node` field.
+        restore_err_ret_index_unconditional,
+        /// Specialized form of `Extended.restore_err_ret_index`.
+        /// Restores the error return index to its state at the entry of
+        /// the current function conditional on `operand` being a non-error.
+        /// If `operand` is `none`, restores unconditionally.
+        /// Uses the `un_node` field.
+        restore_err_ret_index_fn_entry,
         /// The ZIR instruction tag is one of the `Extended` ones.
         /// Uses the `extended` union field.
 @@ -1145,7 +1149,6 @@ pub const Inst = struct {
                 .shl,
                 .shl_sat,
                 .shr,
-                .store,
                 .store_node,
                 .store_to_inferred_ptr,
                 .str,
 @@ -1265,7 +1268,6 @@ pub const Inst = struct {
                 .@"defer",
                 .defer_err_code,
                 .save_err_ret_index,
-                .restore_err_ret_index,
                 .for_len,
                 .opt_eu_base_ptr_init,
                 .coerce_ptr_elem_ty,
 @@ -1290,6 +1292,8 @@ pub const Inst = struct {
                 .array_init_elem_type,
                 .array_init_elem_ptr,
                 .validate_ref_ty,
+                .restore_err_ret_index_unconditional,
+                .restore_err_ret_index_fn_entry,
                 => false,
                 .@"break",
 @@ -1338,7 +1342,6 @@ pub const Inst = struct {
                 .ensure_err_union_payload_void,
                 .set_eval_branch_quota,
                 .atomic_store,
-                .store,
                 .store_node,
                 .store_to_inferred_ptr,
                 .resolve_inferred_alloc,
 @@ -1352,8 +1355,9 @@ pub const Inst = struct {
                 .check_comptime_control_flow,
                 .@"defer",
                 .defer_err_code,
-                .restore_err_ret_index,
                 .save_err_ret_index,
+                .restore_err_ret_index_unconditional,
+                .restore_err_ret_index_fn_entry,
                 .validate_struct_init_ty,
                 .validate_struct_init_result_ty,
                 .validate_ptr_struct_init,
 @@ -1635,8 +1639,8 @@ pub const Inst = struct {
                 .declaration = .pl_node,
                 .suspend_block = .pl_node,
                 .bool_not = .un_node,
-                .bool_br_and = .bool_br,
+                .bool_br_and = .pl_node,
-                .bool_br_or = .bool_br,
+                .bool_br_or = .pl_node,
                 .@"break" = .@"break",
                 .break_inline = .@"break",
                 .check_comptime_control_flow = .un_node,
 @@ -1713,9 +1717,8 @@ pub const Inst = struct {
                 .slice_end = .pl_node,
                 .slice_sentinel = .pl_node,
                 .slice_length = .pl_node,
-                .store = .bin,
                 .store_node = .pl_node,
-                .store_to_inferred_ptr = .bin,
+                .store_to_inferred_ptr = .pl_node,
                 .str = .str,
                 .negate = .un_node,
                 .negate_wrap = .un_node,
 @@ -1845,7 +1848,8 @@ pub const Inst = struct {
                 .defer_err_code = .defer_err_code,
                 .save_err_ret_index = .save_err_ret_index,
-                .restore_err_ret_index = .restore_err_ret_index,
+                .restore_err_ret_index_unconditional = .un_node,
+                .restore_err_ret_index_fn_entry = .un_node,
                 .struct_init_empty = .un_node,
                 .struct_init_empty_result = .un_node,
 @@ -2075,6 +2079,13 @@ pub const Inst = struct {
         /// Implements the `@inComptime` builtin.
         /// `operand` is `src_node: i32`.
         in_comptime,
+        /// Restores the error return index to its last saved state in a given
+        /// block. If the block is `.none`, restores to the state from the point
+        /// of function entry. If the operand is not `.none`, the restore is
+        /// conditional on the operand value not being an error.
+        /// `operand` is payload index to `RestoreErrRetIndex`.
+        /// `small` is undefined.
+        restore_err_ret_index,
         /// Used as a placeholder instruction which is just a dummy index for Sema to replace
         /// with a specific value. For instance, this is used for the capture of an `errdefer`.
         /// This should never appear in a body.
 @@ -2345,11 +2356,6 @@ pub const Inst = struct {
                 return LazySrcLoc.nodeOffset(self.src_node);
             }
         },
-        bool_br: struct {
-            lhs: Ref,
-            /// Points to a `Block`.
-            payload_index: u32,
-        },
         @"unreachable": struct {
             /// Offset from Decl AST node index.
             /// `Tag` determines which kind of AST node this points to.
 @@ -2396,10 +2402,6 @@ pub const Inst = struct {
         save_err_ret_index: struct {
             operand: Ref, // If error type (or .none), save new trace index
         },
-        restore_err_ret_index: struct {
-            block: Ref, // If restored, the index is from this block's entrypoint
-            operand: Ref, // If non-error (or .none), then restore the index
-        },
         elem_val_imm: struct {
             /// The indexable value being accessed.
             operand: Ref,
 @@ -2435,7 +2437,6 @@ pub const Inst = struct {
             float,
             ptr_type,
             int_type,
-            bool_br,
             @"unreachable",
             @"break",
             dbg_stmt,
 @@ -2444,7 +2445,6 @@ pub const Inst = struct {
             @"defer",
             defer_err_code,
             save_err_ret_index,
-            restore_err_ret_index,
             elem_val_imm,
         };
     };
 @@ -2630,6 +2630,13 @@ pub const Inst = struct {
         body_len: u32,
     };
+    /// Trailing:
+    /// * inst: Index // for each `body_len`
+    pub const BoolBr = struct {
+        lhs: Ref,
+        body_len: u32,
+    };
     /// Trailing:
     /// 0. doc_comment: u32          // if `has_doc_comment`; null-terminated string index
     /// 1. align_body_len: u32       // if `has_align_linksection_addrspace`; 0 means no `align`
 @@ -3439,6 +3446,18 @@ pub const Inst = struct {
         /// The RHS of the array multiplication.
         rhs: Ref,
     };
+    pub const RestoreErrRetIndex = struct {
+        src_node: i32,
+        /// If `.none`, restore the trace to its state upon function entry.
+        block: Ref,
+        /// If `.none`, restore unconditionally.
+        operand: Ref,
+        pub fn src(self: RestoreErrRetIndex) LazySrcLoc {
+            return LazySrcLoc.nodeOffset(self.src_node);
+        }
+    };
 };
 pub const SpecialProng = enum { none, @"else", under };

src/print_zir.zig+16-21

 @@ -199,10 +199,6 @@ const Writer = struct {
         const tag = tags[@intFromEnum(inst)];
         try stream.print("= {s}(", .{@tagName(tags[@intFromEnum(inst)])});
         switch (tag) {
-            .store,
-            .store_to_inferred_ptr,
-            => try self.writeBin(stream, inst),
             .alloc,
             .alloc_mut,
             .alloc_comptime_mut,
 @@ -280,6 +276,8 @@ const Writer = struct {
             .validate_deref,
             .check_comptime_control_flow,
             .opt_eu_base_ptr_init,
+            .restore_err_ret_index_unconditional,
+            .restore_err_ret_index_fn_entry,
             => try self.writeUnNode(stream, inst),
             .ref,
 @@ -303,7 +301,6 @@ const Writer = struct {
             .int_type => try self.writeIntType(stream, inst),
             .save_err_ret_index => try self.writeSaveErrRetIndex(stream, inst),
-            .restore_err_ret_index => try self.writeRestoreErrRetIndex(stream, inst),
             .@"break",
             .break_inline,
 @@ -392,6 +389,7 @@ const Writer = struct {
             .shr_exact,
             .xor,
             .store_node,
+            .store_to_inferred_ptr,
             .error_union_type,
             .merge_error_sets,
             .bit_and,
 @@ -615,6 +613,8 @@ const Writer = struct {
             .cmpxchg => try self.writeCmpxchg(stream, extended),
             .ptr_cast_full => try self.writePtrCastFull(stream, extended),
             .ptr_cast_no_dest => try self.writePtrCastNoDest(stream, extended),
+            .restore_err_ret_index => try self.writeRestoreErrRetIndex(stream, extended),
         }
     }
 @@ -624,14 +624,6 @@ const Writer = struct {
         try self.writeSrc(stream, src);
     }
-    fn writeBin(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
-        const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].bin;
-        try self.writeInstRef(stream, inst_data.lhs);
-        try stream.writeAll(", ");
-        try self.writeInstRef(stream, inst_data.rhs);
-        try stream.writeByte(')');
-    }
     fn writeArrayInitElemType(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
         const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].bin;
         try self.writeInstRef(stream, inst_data.lhs);
 @@ -2505,12 +2497,14 @@ const Writer = struct {
     }
     fn writeBoolBr(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
-        const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].bool_br;
+        const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
-        const extra = self.code.extraData(Zir.Inst.Block, inst_data.payload_index);
+        const extra = self.code.extraData(Zir.Inst.BoolBr, inst_data.payload_index);
         const body = self.code.bodySlice(extra.end, extra.data.body_len);
-        try self.writeInstRef(stream, inst_data.lhs);
+        try self.writeInstRef(stream, extra.data.lhs);
         try stream.writeAll(", ");
         try self.writeBracedBody(stream, body);
+        try stream.writeAll(") ");
+        try self.writeSrc(stream, inst_data.src());
     }
     fn writeIntType(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
 @@ -2531,13 +2525,14 @@ const Writer = struct {
         try stream.writeAll(")");
     }
-    fn writeRestoreErrRetIndex(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
+    fn writeRestoreErrRetIndex(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
-        const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].restore_err_ret_index;
+        const extra = self.code.extraData(Zir.Inst.RestoreErrRetIndex, extended.operand).data;
-        try self.writeInstRef(stream, inst_data.block);
+        try self.writeInstRef(stream, extra.block);
-        try self.writeInstRef(stream, inst_data.operand);
+        try self.writeInstRef(stream, extra.operand);
-        try stream.writeAll(")");
+        try stream.writeAll(") ");
+        try self.writeSrc(stream, extra.src());
     }
     fn writeBreak(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {