Commit 85e94fed1e058720460560823ac09d7b64e49b97 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2023-05-27 13:50:50+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2023-06-13 12:55:15+01:00
log	85e94fed1e058720460560823ac09d7b64e49b97
tree	df28ab8360a7cbdf32005532349b72e4713ef097
parent	39510cc7d1f6035e16aaa4f97991abbaddef463c
signature	Commit is signed but in an unrecognized format.

Eliminate switch_cond[_ref] ZIR tags

This finishes the process of consolidating switch expressions in ZIR
into as simple and compact a representation as is possible. There are
now just two ZIR tags dedicated to switch expressions: switch_block and
switch_block_ref, with the latter being for an operand passed by
reference.

5 files changed, 40 insertions(+), 91 deletions(-)

src/AstGen.zig+6-8

 @@ -2610,8 +2610,7 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
             .slice_length,
             .import,
             .switch_block,
-            .switch_cond,
+            .switch_block_ref,
-            .switch_cond_ref,
             .struct_init_empty,
             .struct_init,
             .struct_init_ref,
 @@ -6835,10 +6834,6 @@ fn switchExpr(
     const operand_lc = LineColumn{ astgen.source_line - parent_gz.decl_line, astgen.source_column };
     const raw_operand = try expr(parent_gz, scope, operand_ri, operand_node);
-    const cond_tag: Zir.Inst.Tag = if (any_payload_is_ref) .switch_cond_ref else .switch_cond;
-    const cond = try parent_gz.addUnNode(cond_tag, raw_operand, operand_node);
-    // Sema expects a dbg_stmt immediately after switch_cond(_ref)
-    try emitDbgStmt(parent_gz, operand_lc);
     const item_ri: ResultInfo = .{ .rl = .none };
     // This contains the data that goes into the `extra` array for the SwitchBlock/SwitchBlockMulti,
 @@ -6858,8 +6853,11 @@ fn switchExpr(
     block_scope.instructions_top = GenZir.unstacked_top;
     block_scope.setBreakResultInfo(ri);
+    // Sema expects a dbg_stmt immediately before switch_block(_ref)
+    try emitDbgStmt(parent_gz, operand_lc);
     // This gets added to the parent block later, after the item expressions.
-    const switch_block = try parent_gz.makeBlockInst(.switch_block, switch_node);
+    const switch_tag: Zir.Inst.Tag = if (any_payload_is_ref) .switch_block_ref else .switch_block;
+    const switch_block = try parent_gz.makeBlockInst(switch_tag, switch_node);
     // We re-use this same scope for all cases, including the special prong, if any.
     var case_scope = parent_gz.makeSubBlock(&block_scope.base);
 @@ -7076,7 +7074,7 @@ fn switchExpr(
         payloads.items.len - case_table_end);
     const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.SwitchBlock{
-        .operand = cond,
+        .operand = raw_operand,
         .bits = Zir.Inst.SwitchBlock.Bits{
             .has_multi_cases = multi_cases_len != 0,
             .has_else = special_prong == .@"else",

src/Autodoc.zig-25

...	@@ -1993,31 +1993,6 @@ fn walkInstruction(	...	@@ -1993,31 +1993,6 @@ fn walkInstruction(
1993	.expr = .{ .switchIndex = switch_index },	1993	.expr = .{ .switchIndex = switch_index },
1994	};	1994	};
1995	},	1995	},
1996	.switch_cond => {
1997	const un_node = data[inst_index].un_node;
1998	const operand = try self.walkRef(
1999	file,
2000	parent_scope,
2001	parent_src,
2002	un_node.operand,
2003	need_type,
2004	);
2005	const operand_index = self.exprs.items.len;
2006	try self.exprs.append(self.arena, operand.expr);
2007
2008	// const ast_index = self.ast_nodes.items.len;
2009	// const sep = "=" ** 200;
2010	// log.debug("{s}", .{sep});
2011	// log.debug("SWITCH COND", .{});
2012	// log.debug("ast index = {}", .{ast_index});
2013	// log.debug("ast previous = {}", .{self.ast_nodes.items[ast_index - 1]});
2014	// log.debug("{s}", .{sep});
2015
2016	return DocData.WalkResult{
2017	.typeRef = operand.typeRef,
2018	.expr = .{ .typeOf = operand_index },
2019	};
2020	},
2021		1996
2022	.typeof => {	1997	.typeof => {
2023	const un_node = data[inst_index].un_node;	1998	const un_node = data[inst_index].un_node;

src/Sema.zig+21-33

 @@ -1007,9 +1007,8 @@ fn analyzeBodyInner(
             .slice_start                  => try sema.zirSliceStart(block, inst),
             .slice_length                 => try sema.zirSliceLength(block, inst),
             .str                          => try sema.zirStr(block, inst),
-            .switch_block                 => try sema.zirSwitchBlock(block, inst),
+            .switch_block                 => try sema.zirSwitchBlock(block, inst, false),
-            .switch_cond                  => try sema.zirSwitchCond(block, inst, false),
+            .switch_block_ref             => try sema.zirSwitchBlock(block, inst, true),
-            .switch_cond_ref              => try sema.zirSwitchCond(block, inst, true),
             .type_info                    => try sema.zirTypeInfo(block, inst),
             .size_of                      => try sema.zirSizeOf(block, inst),
             .bit_size_of                  => try sema.zirBitSizeOf(block, inst),
 @@ -10411,23 +10410,14 @@ const SwitchProngAnalysis = struct {
     }
 };
-fn zirSwitchCond(
+fn switchCond(
     sema: *Sema,
     block: *Block,
-    inst: Zir.Inst.Index,
+    src: LazySrcLoc,
-    is_ref: bool,
+    operand: Air.Inst.Ref,
 ) CompileError!Air.Inst.Ref {
     const mod = sema.mod;
-    const inst_data = sema.code.instructions.items(.data)[inst].un_node;
-    const src = inst_data.src();
-    const operand_src: LazySrcLoc = .{ .node_offset_switch_operand = inst_data.src_node };
-    const operand_ptr = try sema.resolveInst(inst_data.operand);
-    const operand = if (is_ref)
-        try sema.analyzeLoad(block, src, operand_ptr, operand_src)
-    else
-        operand_ptr;
     const operand_ty = sema.typeOf(operand);
     switch (operand_ty.zigTypeTag(mod)) {
         .Type,
         .Void,
 @@ -10484,7 +10474,7 @@ fn zirSwitchCond(
 const SwitchErrorSet = std.AutoHashMap(InternPool.NullTerminatedString, Module.SwitchProngSrc);
-fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_ref: bool) CompileError!Air.Inst.Ref {
     const tracy = trace(@src());
     defer tracy.end();
 @@ -10498,10 +10488,21 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const special_prong_src: LazySrcLoc = .{ .node_offset_switch_special_prong = src_node_offset };
     const extra = sema.code.extraData(Zir.Inst.SwitchBlock, inst_data.payload_index);
-    const operand = try sema.resolveInst(extra.data.operand);
+    const raw_operand: struct { val: Air.Inst.Ref, ptr: Air.Inst.Ref } = blk: {
-    // AstGen guarantees that the instruction immediately following
+        const maybe_ptr = try sema.resolveInst(extra.data.operand);
-    // switch_cond(_ref) is a dbg_stmt
+        if (operand_is_ref) {
-    const cond_dbg_node_index = Zir.refToIndex(extra.data.operand).? + 1;
+            const val = try sema.analyzeLoad(block, src, maybe_ptr, operand_src);
+            break :blk .{ .val = val, .ptr = maybe_ptr };
+        } else {
+            break :blk .{ .val = maybe_ptr, .ptr = undefined };
+        }
+    };
+    const operand = try sema.switchCond(block, src, raw_operand.val);
+    // AstGen guarantees that the instruction immediately preceding
+    // switch_block(_ref) is a dbg_stmt
+    const cond_dbg_node_index = inst - 1;
     var header_extra_index: usize = extra.end;
 @@ -10555,19 +10556,6 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         },
     };
-    const raw_operand: struct { val: Air.Inst.Ref, ptr: Air.Inst.Ref } = blk: {
-        const zir_tags = sema.code.instructions.items(.tag);
-        const zir_data = sema.code.instructions.items(.data);
-        const cond_index = Zir.refToIndex(extra.data.operand).?;
-        const raw = sema.resolveInst(zir_data[cond_index].un_node.operand) catch unreachable;
-        if (zir_tags[cond_index] == .switch_cond_ref) {
-            const val = try sema.analyzeLoad(block, src, raw, operand_src);
-            break :blk .{ .val = val, .ptr = raw };
-        } else {
-            break :blk .{ .val = raw, .ptr = undefined };
-        }
-    };
     const maybe_union_ty = sema.typeOf(raw_operand.val);
     const union_originally = maybe_union_ty.zigTypeTag(mod) == .Union;

src/Zir.zig+10-22

 @@ -667,15 +667,9 @@ pub const Inst = struct {
         /// A switch expression. Uses the `pl_node` union field.
         /// AST node is the switch, payload is `SwitchBlock`.
         switch_block,
-        /// Produces the value that will be switched on. For example, for
+        /// A switch expression. Uses the `pl_node` union field.
-        /// integers, it returns the integer with no modifications. For tagged unions, it
+        /// AST node is the switch, payload is `SwitchBlock`. Operand is a pointer.
-        /// returns the active enum tag.
+        switch_block_ref,
-        /// Uses the `un_node` union field.
-        switch_cond,
-        /// Same as `switch_cond`, except the input operand is a pointer to
-        /// what will be switched on.
-        /// Uses the `un_node` union field.
-        switch_cond_ref,
         /// Given a
         ///   *A returns *A
         ///   *E!A returns *A
 @@ -1122,8 +1116,7 @@ pub const Inst = struct {
                 .resolve_inferred_alloc,
                 .set_eval_branch_quota,
                 .switch_block,
-                .switch_cond,
+                .switch_block_ref,
-                .switch_cond_ref,
                 .array_base_ptr,
                 .field_base_ptr,
                 .validate_array_init_ty,
 @@ -1411,8 +1404,7 @@ pub const Inst = struct {
                 .import,
                 .typeof_log2_int_type,
                 .switch_block,
-                .switch_cond,
+                .switch_block_ref,
-                .switch_cond_ref,
                 .array_base_ptr,
                 .field_base_ptr,
                 .struct_init_empty,
 @@ -1663,8 +1655,7 @@ pub const Inst = struct {
                 .err_union_code_ptr = .un_node,
                 .enum_literal = .str_tok,
                 .switch_block = .pl_node,
-                .switch_cond = .un_node,
+                .switch_block_ref = .pl_node,
-                .switch_cond_ref = .un_node,
                 .array_base_ptr = .un_node,
                 .field_base_ptr = .un_node,
                 .validate_array_init_ty = .pl_node,
 @@ -2665,13 +2656,10 @@ pub const Inst = struct {
     /// captured payload. Whether this is captured by reference or by value
     /// depends on whether the `byref` bit is set for the corresponding body.
     pub const SwitchBlock = struct {
-        /// This is always a `switch_cond` or `switch_cond_ref` instruction.
+        /// The operand passed to the `switch` expression. If this is a
-        /// If it is a `switch_cond_ref` instruction, bits.is_ref is always true.
+        /// `switch_block`, this is the operand value; if `switch_block_ref` it
-        /// If it is a `switch_cond` instruction, bits.is_ref is always false.
+        /// is a pointer to the operand. `switch_block_ref` is always used if
-        /// Both `switch_cond` and `switch_cond_ref` return a value, not a pointer,
+        /// any prong has a byref capture.
-        /// that is useful for the case items, but cannot be used for capture values.
-        /// For the capture values, Sema is expected to find the operand of this operand
-        /// and use that.
         operand: Ref,
         bits: Bits,

src/print_zir.zig+3-3

...	@@ -222,8 +222,6 @@ const Writer = struct {	...	@@ -222,8 +222,6 @@ const Writer = struct {
222	.bit_reverse,	222	.bit_reverse,
223	.@"resume",	223	.@"resume",
224	.@"await",	224	.@"await",
225	.switch_cond,
226	.switch_cond_ref,
227	.array_base_ptr,	225	.array_base_ptr,
228	.field_base_ptr,	226	.field_base_ptr,
229	.validate_struct_init_ty,	227	.validate_struct_init_ty,
...	@@ -388,7 +386,9 @@ const Writer = struct {	...	@@ -388,7 +386,9 @@ const Writer = struct {
388	.error_set_decl_anon => try self.writeErrorSetDecl(stream, inst, .anon),	386	.error_set_decl_anon => try self.writeErrorSetDecl(stream, inst, .anon),
389	.error_set_decl_func => try self.writeErrorSetDecl(stream, inst, .func),	387	.error_set_decl_func => try self.writeErrorSetDecl(stream, inst, .func),
390		388
391	.switch_block => try self.writeSwitchBlock(stream, inst),	389	.switch_block,
		390	.switch_block_ref,
		391	=> try self.writeSwitchBlock(stream, inst),
392		392
393	.field_ptr,	393	.field_ptr,
394	.field_ptr_init,	394	.field_ptr_init,