Commit 6c8985fceeeb6314143691570cf0c7a42521e590 | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-01-24 20:23:37-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-01-31 21:09:22-07:00
log	6c8985fceeeb6314143691570cf0c7a42521e590
tree	a9fb25c5b54b4c2664606d668f247dd863a80bc6
parent	588171c30b34426fbb07645aa2625e989f369eec

astgen: rework labeled blocks

6 files changed, 200 insertions(+), 112 deletions(-)

src/Module.zig+17-6

 @@ -717,7 +717,7 @@ pub const Scope = struct {
         label: ?Label = null,
         break_block: ?*zir.Inst.Block = null,
         continue_block: ?*zir.Inst.Block = null,
-        /// only valid if label != null or (continue_block and break_block) != null
+        /// Only valid when setBlockResultLoc is called.
         break_result_loc: astgen.ResultLoc = undefined,
         /// When a block has a pointer result location, here it is.
         rl_ptr: ?*zir.Inst = null,
 @@ -726,6 +726,17 @@ pub const Scope = struct {
         /// whether to rely on break instructions or writing to the result
         /// pointer for the result instruction.
         rvalue_rl_count: usize = 0,
+        /// Keeps track of how many break instructions there are. When astgen is finished
+        /// with a block, it can check this against rvalue_rl_count to find out whether
+        /// the break instructions should be downgraded to break_void.
+        break_count: usize = 0,
+        /// Tracks `break :foo bar` instructions so they can possibly be elided later if
+        /// the labeled block ends up not needing a result location pointer.
+        labeled_breaks: std.ArrayListUnmanaged(*zir.Inst.Break) = .{},
+        /// Tracks `store_to_block_ptr` instructions that correspond to break instructions
+        /// so they can possibly be elided later if the labeled block ends up not needing
+        /// a result location pointer.
+        labeled_store_to_block_ptr_list: std.ArrayListUnmanaged(*zir.Inst.BinOp) = .{},
         pub const Label = struct {
             token: ast.TokenIndex,
 @@ -3495,18 +3506,18 @@ pub fn addSafetyCheck(mod: *Module, parent_block: *Scope.Block, ok: *Inst, panic
     };
     const ok_body: ir.Body = .{
-        .instructions = try parent_block.arena.alloc(*Inst, 1), // Only need space for the brvoid.
+        .instructions = try parent_block.arena.alloc(*Inst, 1), // Only need space for the br_void.
     };
-    const brvoid = try parent_block.arena.create(Inst.BrVoid);
+    const br_void = try parent_block.arena.create(Inst.BrVoid);
-    brvoid.* = .{
+    br_void.* = .{
         .base = .{
-            .tag = .brvoid,
+            .tag = .br_void,
             .ty = Type.initTag(.noreturn),
             .src = ok.src,
         },
         .block = block_inst,
     };
-    ok_body.instructions[0] = &brvoid.base;
+    ok_body.instructions[0] = &br_void.base;
     var fail_block: Scope.Block = .{
         .parent = parent_block,

src/astgen.zig+160-89

 @@ -38,6 +38,21 @@ pub const ResultLoc = union(enum) {
     /// is inferred based on peer type resolution for a `zir.Inst.Block`.
     /// The result instruction from the expression must be ignored.
     block_ptr: *Module.Scope.GenZIR,
+    pub const Strategy = struct {
+        elide_store_to_block_ptr_instructions: bool,
+        tag: Tag,
+        pub const Tag = enum {
+            /// Both branches will use break_void; result location is used to communicate the
+            /// result instruction.
+            break_void,
+            /// Use break statements to pass the block result value, and call rvalue() at
+            /// the end depending on rl. Also elide the store_to_block_ptr instructions
+            /// depending on rl.
+            break_operand,
+        };
+    };
 };
 pub fn typeExpr(mod: *Module, scope: *Scope, type_node: *ast.Node) InnerError!*zir.Inst {
 @@ -348,10 +363,11 @@ pub fn comptimeExpr(mod: *Module, parent_scope: *Scope, rl: ResultLoc, node: *as
     return &block.base;
 }
-fn breakExpr(mod: *Module, parent_scope: *Scope, node: *ast.Node.ControlFlowExpression) InnerError!*zir.Inst {
+fn breakExpr(
-    if (true) {
+    mod: *Module,
-        @panic("TODO reimplement this");
+    parent_scope: *Scope,
-    }
+    node: *ast.Node.ControlFlowExpression,
+) InnerError!*zir.Inst {
     const tree = parent_scope.tree();
     const src = tree.token_locs[node.ltoken].start;
 @@ -377,25 +393,31 @@ fn breakExpr(mod: *Module, parent_scope: *Scope, node: *ast.Node.ControlFlowExpr
                     continue;
                 };
-                if (node.getRHS()) |rhs| {
+                const rhs = node.getRHS() orelse {
-                    // Most result location types can be forwarded directly; however
+                    return addZirInstTag(mod, parent_scope, src, .break_void, .{
-                    // if we need to write to a pointer which has an inferred type,
-                    // proper type inference requires peer type resolution on the block's
-                    // break operand expressions.
-                    const branch_rl: ResultLoc = switch (gen_zir.break_result_loc) {
-                        .discard, .none, .ty, .ptr, .ref => gen_zir.break_result_loc,
-                        .inferred_ptr, .bitcasted_ptr, .block_ptr => .{ .block_ptr = block_inst },
-                    };
-                    const operand = try expr(mod, parent_scope, branch_rl, rhs);
-                    return try addZIRInst(mod, parent_scope, src, zir.Inst.Break, .{
                         .block = block_inst,
-                        .operand = operand,
+                    });
-                    }, .{});
+                };
-                } else {
+                gen_zir.break_count += 1;
-                    return try addZIRInst(mod, parent_scope, src, zir.Inst.BreakVoid, .{
+                const prev_rvalue_rl_count = gen_zir.rvalue_rl_count;
-                        .block = block_inst,
+                const operand = try expr(mod, parent_scope, gen_zir.break_result_loc, rhs);
-                    }, .{});
+                const have_store_to_block = gen_zir.rvalue_rl_count != prev_rvalue_rl_count;
+                const br = try addZirInstTag(mod, parent_scope, src, .@"break", .{
+                    .block = block_inst,
+                    .operand = operand,
+                });
+                if (gen_zir.break_result_loc == .block_ptr) {
+                    try gen_zir.labeled_breaks.append(mod.gpa, br.castTag(.@"break").?);
+                    if (have_store_to_block) {
+                        const inst_list = parent_scope.cast(Scope.GenZIR).?.instructions.items;
+                        const last_inst = inst_list[inst_list.len - 2];
+                        const store_inst = last_inst.castTag(.store_to_block_ptr).?;
+                        assert(store_inst.positionals.lhs == gen_zir.rl_ptr.?);
+                        try gen_zir.labeled_store_to_block_ptr_list.append(mod.gpa, store_inst);
+                    }
                 }
+                return br;
             },
             .local_val => scope = scope.cast(Scope.LocalVal).?.parent,
             .local_ptr => scope = scope.cast(Scope.LocalPtr).?.parent,
 @@ -538,7 +560,6 @@ fn labeledBlockExpr(
         .decl = parent_scope.ownerDecl().?,
         .arena = gen_zir.arena,
         .instructions = .{},
-        .break_result_loc = rl,
         // TODO @as here is working around a stage1 miscompilation bug :(
         .label = @as(?Scope.GenZIR.Label, Scope.GenZIR.Label{
             .token = block_node.label,
 @@ -546,19 +567,57 @@ fn labeledBlockExpr(
         }),
     };
     defer block_scope.instructions.deinit(mod.gpa);
+    defer block_scope.labeled_breaks.deinit(mod.gpa);
+    defer block_scope.labeled_store_to_block_ptr_list.deinit(mod.gpa);
+    setBlockResultLoc(&block_scope, rl);
     try blockExprStmts(mod, &block_scope.base, &block_node.base, block_node.statements());
     if (!block_scope.label.?.used) {
         return mod.fail(parent_scope, tree.token_locs[block_node.label].start, "unused block label", .{});
     }
-    block_inst.positionals.body.instructions = try block_scope.arena.dupe(*zir.Inst, block_scope.instructions.items);
     try gen_zir.instructions.append(mod.gpa, &block_inst.base);
-    return &block_inst.base;
+    const strat = rlStrategy(rl, &block_scope);
+    switch (strat.tag) {
+        .break_void => {
+            // The code took advantage of the result location as a pointer.
+            // Turn the break instructions into break_void instructions.
+            for (block_scope.labeled_breaks.items) |br| {
+                br.base.tag = .break_void;
+            }
+            // TODO technically not needed since we changed the tag to break_void but
+            // would be better still to elide the ones that are in this list.
+            try copyBodyNoEliding(&block_inst.positionals.body, block_scope);
+            return &block_inst.base;
+        },
+        .break_operand => {
+            // All break operands are values that did not use the result location pointer.
+            if (strat.elide_store_to_block_ptr_instructions) {
+                for (block_scope.labeled_store_to_block_ptr_list.items) |inst| {
+                    inst.base.tag = .void_value;
+                }
+                // TODO technically not needed since we changed the tag to void_value but
+                // would be better still to elide the ones that are in this list.
+            }
+            try copyBodyNoEliding(&block_inst.positionals.body, block_scope);
+            switch (rl) {
+                .ref => return &block_inst.base,
+                else => return rvalue(mod, parent_scope, rl, &block_inst.base),
+            }
+        },
+    }
 }
-fn blockExprStmts(mod: *Module, parent_scope: *Scope, node: *ast.Node, statements: []*ast.Node) !void {
+fn blockExprStmts(
+    mod: *Module,
+    parent_scope: *Scope,
+    node: *ast.Node,
+    statements: []*ast.Node,
+) !void {
     const tree = parent_scope.tree();
     var block_arena = std.heap.ArenaAllocator.init(mod.gpa);
 @@ -1659,7 +1718,6 @@ fn ifExpr(mod: *Module, scope: *Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
             cond_kind = .{ .err_union = null };
         }
     }
-    const block_branch_count = 2; // then and else
     var block_scope: Scope.GenZIR = .{
         .parent = scope,
         .decl = scope.ownerDecl().?,
 @@ -1668,6 +1726,8 @@ fn ifExpr(mod: *Module, scope: *Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
     };
     defer block_scope.instructions.deinit(mod.gpa);
+    setBlockResultLoc(&block_scope, rl);
     const tree = scope.tree();
     const if_src = tree.token_locs[if_node.if_token].start;
     const cond = try cond_kind.cond(mod, &block_scope, if_src, if_node.condition);
 @@ -1682,33 +1742,6 @@ fn ifExpr(mod: *Module, scope: *Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
         .instructions = try block_scope.arena.dupe(*zir.Inst, block_scope.instructions.items),
     });
-    // Depending on whether the result location is a pointer or value, different
-    // ZIR needs to be generated. In the former case we rely on storing to the
-    // pointer to communicate the result, and use breakvoid; in the latter case
-    // the block break instructions will have the result values.
-    // One more complication: when the result location is a pointer, we detect
-    // the scenario where the result location is not consumed. In this case
-    // we emit ZIR for the block break instructions to have the result values,
-    // and then rvalue() on that to pass the value to the result location.
-    const branch_rl: ResultLoc = switch (rl) {
-        .discard, .none, .ty, .ptr, .ref => rl,
-        .inferred_ptr => |ptr| blk: {
-            block_scope.rl_ptr = &ptr.base;
-            break :blk .{ .block_ptr = &block_scope };
-        },
-        .bitcasted_ptr => |ptr| blk: {
-            block_scope.rl_ptr = &ptr.base;
-            break :blk .{ .block_ptr = &block_scope };
-        },
-        .block_ptr => |parent_block_scope| blk: {
-            block_scope.rl_ptr = parent_block_scope.rl_ptr.?;
-            break :blk .{ .block_ptr = &block_scope };
-        },
-    };
     const then_src = tree.token_locs[if_node.body.lastToken()].start;
     var then_scope: Scope.GenZIR = .{
         .parent = scope,
 @@ -1721,7 +1754,8 @@ fn ifExpr(mod: *Module, scope: *Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
     // declare payload to the then_scope
     const then_sub_scope = try cond_kind.thenSubScope(mod, &then_scope, then_src, if_node.payload);
-    const then_result = try expr(mod, then_sub_scope, branch_rl, if_node.body);
+    block_scope.break_count += 1;
+    const then_result = try expr(mod, then_sub_scope, block_scope.break_result_loc, if_node.body);
     // We hold off on the break instructions as well as copying the then/else
     // instructions into place until we know whether to keep store_to_block_ptr
     // instructions or not.
 @@ -1741,47 +1775,18 @@ fn ifExpr(mod: *Module, scope: *Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
         // declare payload to the then_scope
         else_sub_scope = try cond_kind.elseSubScope(mod, &else_scope, else_src, else_node.payload);
-        break :blk try expr(mod, else_sub_scope, branch_rl, else_node.body);
+        block_scope.break_count += 1;
+        break :blk try expr(mod, else_sub_scope, block_scope.break_result_loc, else_node.body);
     } else blk: {
         else_src = tree.token_locs[if_node.lastToken()].start;
         else_sub_scope = &else_scope.base;
-        block_scope.rvalue_rl_count += 1;
         break :blk null;
     };
     // We now have enough information to decide whether the result instruction should
     // be communicated via result location pointer or break instructions.
-    const Strategy = enum {
+    const strat = rlStrategy(rl, &block_scope);
-        /// Both branches will use break_void; result location is used to communicate the
+    switch (strat.tag) {
-        /// result instruction.
-        break_void,
-        /// Use break statements to pass the block result value, and call rvalue() at
-        /// the end depending on rl. Also elide the store_to_block_ptr instructions
-        /// depending on rl.
-        break_operand,
-    };
-    var elide_store_to_block_ptr_instructions = false;
-    const strategy: Strategy = switch (rl) {
-        // In this branch there will not be any store_to_block_ptr instructions.
-        .discard, .none, .ty, .ref => .break_operand,
-        // The pointer got passed through to the sub-expressions, so we will use
-        // break_void here.
-        // In this branch there will not be any store_to_block_ptr instructions.
-        .ptr => .break_void,
-        .inferred_ptr, .bitcasted_ptr, .block_ptr => blk: {
-            if (block_scope.rvalue_rl_count == 2) {
-                // Neither prong of the if consumed the result location, so we can
-                // use break instructions to create an rvalue.
-                elide_store_to_block_ptr_instructions = true;
-                break :blk Strategy.break_operand;
-            } else {
-                // Allow the store_to_block_ptr instructions to remain so that
-                // semantic analysis can turn them into bitcasts.
-                break :blk Strategy.break_void;
-            }
-        },
-    };
-    switch (strategy) {
         .break_void => {
             if (!then_result.tag.isNoReturn()) {
                 _ = try addZirInstTag(mod, then_sub_scope, then_src, .break_void, .{
 @@ -1799,7 +1804,7 @@ fn ifExpr(mod: *Module, scope: *Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
                     .block = block,
                 });
             }
-            assert(!elide_store_to_block_ptr_instructions);
+            assert(!strat.elide_store_to_block_ptr_instructions);
             try copyBodyNoEliding(&condbr.positionals.then_body, then_scope);
             try copyBodyNoEliding(&condbr.positionals.else_body, else_scope);
             return &block.base;
 @@ -1823,7 +1828,7 @@ fn ifExpr(mod: *Module, scope: *Scope, rl: ResultLoc, if_node: *ast.Node.If) Inn
                     .block = block,
                 });
             }
-            if (elide_store_to_block_ptr_instructions) {
+            if (strat.elide_store_to_block_ptr_instructions) {
                 try copyBodyWithElidedStoreBlockPtr(&condbr.positionals.then_body, then_scope);
                 try copyBodyWithElidedStoreBlockPtr(&condbr.positionals.else_body, else_scope);
             } else {
 @@ -3376,6 +3381,72 @@ fn rvalueVoid(mod: *Module, scope: *Scope, rl: ResultLoc, node: *ast.Node, resul
     return rvalue(mod, scope, rl, void_inst);
 }
+fn rlStrategy(rl: ResultLoc, block_scope: *Scope.GenZIR) ResultLoc.Strategy {
+    var elide_store_to_block_ptr_instructions = false;
+    switch (rl) {
+        // In this branch there will not be any store_to_block_ptr instructions.
+        .discard, .none, .ty, .ref => return .{
+            .tag = .break_operand,
+            .elide_store_to_block_ptr_instructions = false,
+        },
+        // The pointer got passed through to the sub-expressions, so we will use
+        // break_void here.
+        // In this branch there will not be any store_to_block_ptr instructions.
+        .ptr => return .{
+            .tag = .break_void,
+            .elide_store_to_block_ptr_instructions = false,
+        },
+        .inferred_ptr, .bitcasted_ptr, .block_ptr => {
+            if (block_scope.rvalue_rl_count == block_scope.break_count) {
+                // Neither prong of the if consumed the result location, so we can
+                // use break instructions to create an rvalue.
+                return .{
+                    .tag = .break_operand,
+                    .elide_store_to_block_ptr_instructions = true,
+                };
+            } else {
+                // Allow the store_to_block_ptr instructions to remain so that
+                // semantic analysis can turn them into bitcasts.
+                return .{
+                    .tag = .break_void,
+                    .elide_store_to_block_ptr_instructions = false,
+                };
+            }
+        },
+    }
+}
+fn setBlockResultLoc(block_scope: *Scope.GenZIR, parent_rl: ResultLoc) void {
+    // Depending on whether the result location is a pointer or value, different
+    // ZIR needs to be generated. In the former case we rely on storing to the
+    // pointer to communicate the result, and use breakvoid; in the latter case
+    // the block break instructions will have the result values.
+    // One more complication: when the result location is a pointer, we detect
+    // the scenario where the result location is not consumed. In this case
+    // we emit ZIR for the block break instructions to have the result values,
+    // and then rvalue() on that to pass the value to the result location.
+    switch (parent_rl) {
+        .discard, .none, .ty, .ptr, .ref => {
+            block_scope.break_result_loc = parent_rl;
+        },
+        .inferred_ptr => |ptr| {
+            block_scope.rl_ptr = &ptr.base;
+            block_scope.break_result_loc = .{ .block_ptr = block_scope };
+        },
+        .bitcasted_ptr => |ptr| {
+            block_scope.rl_ptr = &ptr.base;
+            block_scope.break_result_loc = .{ .block_ptr = block_scope };
+        },
+        .block_ptr => |parent_block_scope| {
+            block_scope.rl_ptr = parent_block_scope.rl_ptr.?;
+            block_scope.break_result_loc = .{ .block_ptr = block_scope };
+        },
+    }
+}
 pub fn addZirInstTag(
     mod: *Module,
     scope: *Scope,

src/codegen.zig+5-5

...	@@ -846,7 +846,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {	...	@@ -846,7 +846,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
846	.br => return self.genBr(inst.castTag(.br).?),	846	.br => return self.genBr(inst.castTag(.br).?),
847	.br_block_flat => return self.genBrBlockFlat(inst.castTag(.br_block_flat).?),	847	.br_block_flat => return self.genBrBlockFlat(inst.castTag(.br_block_flat).?),
848	.breakpoint => return self.genBreakpoint(inst.src),	848	.breakpoint => return self.genBreakpoint(inst.src),
849	.brvoid => return self.genBrVoid(inst.castTag(.brvoid).?),	849	.br_void => return self.genBrVoid(inst.castTag(.br_void).?),
850	.bool_and => return self.genBoolOp(inst.castTag(.bool_and).?),	850	.bool_and => return self.genBoolOp(inst.castTag(.bool_and).?),
851	.bool_or => return self.genBoolOp(inst.castTag(.bool_or).?),	851	.bool_or => return self.genBoolOp(inst.castTag(.bool_or).?),
852	.call => return self.genCall(inst.castTag(.call).?),	852	.call => return self.genCall(inst.castTag(.call).?),
...	@@ -2442,10 +2442,10 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {	...	@@ -2442,10 +2442,10 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
2442	}	2442	}
2443	}	2443	}
2444		2444
2445	fn genBrBlockFlat(self: Self, parent_inst: ir.Inst.BrBlockFlat) !MCValue {	2445	fn genBrBlockFlat(self: Self, inst: ir.Inst.BrBlockFlat) !MCValue {
2446	try self.genBody(parent_inst.body);	2446	try self.genBody(inst.body);
2447	const last = parent_inst.body.instructions[parent_inst.body.instructions.len - 1];	2447	const last = inst.body.instructions[inst.body.instructions.len - 1];
2448	return self.br(parent_inst.base.src, parent_inst.block, last);	2448	return self.br(inst.base.src, inst.block, last);
2449	}	2449	}
2450		2450
2451	fn genBr(self: Self, inst: ir.Inst.Br) !MCValue {	2451	fn genBr(self: Self, inst: ir.Inst.Br) !MCValue {

src/ir.zig+4-4

...	@@ -69,7 +69,7 @@ pub const Inst = struct {	...	@@ -69,7 +69,7 @@ pub const Inst = struct {
69	/// replace one br operand with multiple instructions, without moving anything else around.	69	/// replace one br operand with multiple instructions, without moving anything else around.
70	br_block_flat,	70	br_block_flat,
71	breakpoint,	71	breakpoint,
72	brvoid,	72	br_void,
73	call,	73	call,
74	cmp_lt,	74	cmp_lt,
75	cmp_lte,	75	cmp_lte,
...	@@ -166,7 +166,7 @@ pub const Inst = struct {	...	@@ -166,7 +166,7 @@ pub const Inst = struct {
166	.block => Block,	166	.block => Block,
167	.br => Br,	167	.br => Br,
168	.br_block_flat => BrBlockFlat,	168	.br_block_flat => BrBlockFlat,
169	.brvoid => BrVoid,	169	.br_void => BrVoid,
170	.call => Call,	170	.call => Call,
171	.condbr => CondBr,	171	.condbr => CondBr,
172	.constant => Constant,	172	.constant => Constant,
...	@@ -259,7 +259,7 @@ pub const Inst = struct {	...	@@ -259,7 +259,7 @@ pub const Inst = struct {
259	pub fn breakBlock(base: Inst) ?Block {	259	pub fn breakBlock(base: Inst) ?Block {
260	return switch (base.tag) {	260	return switch (base.tag) {
261	.br => base.castTag(.br).?.block,	261	.br => base.castTag(.br).?.block,
262	.brvoid => base.castTag(.brvoid).?.block,	262	.br_void => base.castTag(.br_void).?.block,
263	.br_block_flat => base.castTag(.br_block_flat).?.block,	263	.br_block_flat => base.castTag(.br_block_flat).?.block,
264	else => null,	264	else => null,
265	};	265	};
...	@@ -403,7 +403,7 @@ pub const Inst = struct {	...	@@ -403,7 +403,7 @@ pub const Inst = struct {
403	};	403	};
404		404
405	pub const BrVoid = struct {	405	pub const BrVoid = struct {
406	pub const base_tag = Tag.brvoid;	406	pub const base_tag = Tag.br_void;
407		407
408	base: Inst,	408	base: Inst,
409	block: *Block,	409	block: *Block,

src/zir.zig+11-8

...	@@ -264,8 +264,7 @@ pub const Inst = struct {	...	@@ -264,8 +264,7 @@ pub const Inst = struct {
264	/// Write a value to a pointer. For loading, see `deref`.	264	/// Write a value to a pointer. For loading, see `deref`.
265	store,	265	store,
266	/// Same as `store` but the type of the value being stored will be used to infer	266	/// Same as `store` but the type of the value being stored will be used to infer
267	/// the block type. The LHS is a block instruction, whose result location is	267	/// the block type. The LHS is the pointer to store to.
268	/// being stored to.
269	store_to_block_ptr,	268	store_to_block_ptr,
270	/// Same as `store` but the type of the value being stored will be used to infer	269	/// Same as `store` but the type of the value being stored will be used to infer
271	/// the pointer type.	270	/// the pointer type.
...	@@ -343,6 +342,8 @@ pub const Inst = struct {	...	@@ -343,6 +342,8 @@ pub const Inst = struct {
343	/// Only checks that `lhs >= rhs` if they are ints, everything else is	342	/// Only checks that `lhs >= rhs` if they are ints, everything else is
344	/// validated by the .switch instruction.	343	/// validated by the .switch instruction.
345	switch_range,	344	switch_range,
		345	/// Does nothing; returns a void value.
		346	void_value,
346		347
347	pub fn Type(tag: Tag) type {	348	pub fn Type(tag: Tag) type {
348	return switch (tag) {	349	return switch (tag) {
...	@@ -355,6 +356,7 @@ pub const Inst = struct {	...	@@ -355,6 +356,7 @@ pub const Inst = struct {
355	.ret_type,	356	.ret_type,
356	.unreachable_unsafe,	357	.unreachable_unsafe,
357	.unreachable_safe,	358	.unreachable_safe,
		359	.void_value,
358	=> NoOp,	360	=> NoOp,
359		361
360	.alloc,	362	.alloc,
...	@@ -611,6 +613,7 @@ pub const Inst = struct {	...	@@ -611,6 +613,7 @@ pub const Inst = struct {
611	.enum_type,	613	.enum_type,
612	.union_type,	614	.union_type,
613	.struct_type,	615	.struct_type,
		616	.void_value,
614	=> false,	617	=> false,
615		618
616	.@"break",	619	.@"break",
...	@@ -1640,9 +1643,9 @@ const DumpTzir = struct {	...	@@ -1640,9 +1643,9 @@ const DumpTzir = struct {
1640	try dtz.fetchInstsAndResolveConsts(br_block_flat.body);	1643	try dtz.fetchInstsAndResolveConsts(br_block_flat.body);
1641	},	1644	},
1642		1645
1643	.brvoid => {	1646	.br_void => {
1644	const brvoid = inst.castTag(.brvoid).?;	1647	const br_void = inst.castTag(.br_void).?;
1645	try dtz.findConst(&brvoid.block.base);	1648	try dtz.findConst(&br_void.block.base);
1646	},	1649	},
1647		1650
1648	.block => {	1651	.block => {
...	@@ -1803,9 +1806,9 @@ const DumpTzir = struct {	...	@@ -1803,9 +1806,9 @@ const DumpTzir = struct {
1803	try writer.writeAll("})\n");	1806	try writer.writeAll("})\n");
1804	},	1807	},
1805		1808
1806	.brvoid => {	1809	.br_void => {
1807	const brvoid = inst.castTag(.brvoid).?;	1810	const br_void = inst.castTag(.br_void).?;
1808	const kinky = try dtz.writeInst(writer, &brvoid.block.base);	1811	const kinky = try dtz.writeInst(writer, &br_void.block.base);
1809	if (kinky) \|_\| {	1812	if (kinky) \|_\| {
1810	try writer.writeAll(") // Instruction does not dominate all uses!\n");	1813	try writer.writeAll(") // Instruction does not dominate all uses!\n");
1811	} else {	1814	} else {

src/zir_sema.zig+3

...	@@ -155,6 +155,7 @@ pub fn analyzeInst(mod: Module, scope: Scope, old_inst: *zir.Inst) InnerError!	...	@@ -155,6 +155,7 @@ pub fn analyzeInst(mod: Module, scope: Scope, old_inst: *zir.Inst) InnerError!
155	.switch_range => return zirSwitchRange(mod, scope, old_inst.castTag(.switch_range).?),	155	.switch_range => return zirSwitchRange(mod, scope, old_inst.castTag(.switch_range).?),
156	.bool_and => return zirBoolOp(mod, scope, old_inst.castTag(.bool_and).?),	156	.bool_and => return zirBoolOp(mod, scope, old_inst.castTag(.bool_and).?),
157	.bool_or => return zirBoolOp(mod, scope, old_inst.castTag(.bool_or).?),	157	.bool_or => return zirBoolOp(mod, scope, old_inst.castTag(.bool_or).?),
		158	.void_value => return mod.constVoid(scope, old_inst.src),
158		159
159	.container_field_named,	160	.container_field_named,
160	.container_field_typed,	161	.container_field_typed,
...	@@ -447,6 +448,8 @@ fn zirStoreToBlockPtr(	...	@@ -447,6 +448,8 @@ fn zirStoreToBlockPtr(
447	const ptr = try resolveInst(mod, scope, inst.positionals.lhs);	448	const ptr = try resolveInst(mod, scope, inst.positionals.lhs);
448	const value = try resolveInst(mod, scope, inst.positionals.rhs);	449	const value = try resolveInst(mod, scope, inst.positionals.rhs);
449	const ptr_ty = try mod.simplePtrType(scope, inst.base.src, value.ty, true, .One);	450	const ptr_ty = try mod.simplePtrType(scope, inst.base.src, value.ty, true, .One);
		451	// TODO detect when this store should be done at compile-time. For example,
		452	// if expressions should force it when the condition is compile-time known.
450	const b = try mod.requireRuntimeBlock(scope, inst.base.src);	453	const b = try mod.requireRuntimeBlock(scope, inst.base.src);
451	const bitcasted_ptr = try mod.addUnOp(b, inst.base.src, ptr_ty, .bitcast, ptr);	454	const bitcasted_ptr = try mod.addUnOp(b, inst.base.src, ptr_ty, .bitcast, ptr);
452	return mod.storePtr(scope, inst.base.src, bitcasted_ptr, value);	455	return mod.storePtr(scope, inst.base.src, bitcasted_ptr, value);