Commit 3ecec50f0c530760653a73194fa3651b16647ef9 | zig

author	Joachim Schmidt <joachim.schmidt557@outlook.com> 2022-10-23 16:53:44+02:00
committer	Joachim Schmidt <joachim.schmidt557@outlook.com> 2022-11-01 20:43:27+01:00
log	3ecec50f0c530760653a73194fa3651b16647ef9
tree	1fff385d90d722b87580b5cc9db1d05d90b6d153
parent	d2a5a36cabad5a9b44538e50e9288c3a968cb9f3
signature	Commit is signed but in an unrecognized format.

stage2 AArch64: implement basic switch statements

2 files changed, 190 insertions(+), 61 deletions(-)

src
- arch
  - aarch64
    CodeGen.zig
test
- behavior
  - switch.zig

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

 @@ -91,7 +91,7 @@ register_manager: RegisterManager = .{},
 /// Maps offset to what is stored there.
 stack: std.AutoHashMapUnmanaged(u32, StackAllocation) = .{},
 /// Tracks the current instruction allocated to the compare flags
-condition_flags_inst: ?Air.Inst.Index = null,
+compare_flags_inst: ?Air.Inst.Index = null,
 /// Offset from the stack base, representing the end of the stack frame.
 max_end_stack: u32 = 0,
 @@ -154,7 +154,7 @@ const MCValue = union(enum) {
     /// The value resides in the N, Z, C, V flags. The value is 1 (if
     /// the type is u1) or true (if the type in bool) iff the
     /// specified condition is true.
-    condition_flags: Condition,
+    compare_flags: Condition,
     /// The value is a function argument passed via the stack.
     stack_argument_offset: u32,
 };
 @@ -201,6 +201,29 @@ const BigTomb = struct {
             log.debug("%{d} => {}", .{ bt.inst, result });
             const branch = &bt.function.branch_stack.items[bt.function.branch_stack.items.len - 1];
             branch.inst_table.putAssumeCapacityNoClobber(bt.inst, result);
+            switch (result) {
+                .register => |reg| {
+                    // In some cases (such as bitcast), an operand
+                    // may be the same MCValue as the result. If
+                    // that operand died and was a register, it
+                    // was freed by processDeath. We have to
+                    // "re-allocate" the register.
+                    if (bt.function.register_manager.isRegFree(reg)) {
+                        bt.function.register_manager.getRegAssumeFree(reg, bt.inst);
+                    }
+                },
+                .register_with_overflow => |rwo| {
+                    if (bt.function.register_manager.isRegFree(rwo.reg)) {
+                        bt.function.register_manager.getRegAssumeFree(rwo.reg, bt.inst);
+                    }
+                    bt.function.compare_flags_inst = bt.inst;
+                },
+                .compare_flags => |_| {
+                    bt.function.compare_flags_inst = bt.inst;
+                },
+                else => {},
+            }
         }
         bt.function.finishAirBookkeeping();
     }
 @@ -764,10 +787,10 @@ fn processDeath(self: *Self, inst: Air.Inst.Index) void {
         },
         .register_with_overflow => |rwo| {
             self.register_manager.freeReg(rwo.reg);
-            self.condition_flags_inst = null;
+            self.compare_flags_inst = null;
         },
-        .condition_flags => {
+        .compare_flags => {
-            self.condition_flags_inst = null;
+            self.compare_flags_inst = null;
         },
         else => {}, // TODO process stack allocation death
     }
 @@ -808,6 +831,15 @@ fn finishAir(self: *Self, inst: Air.Inst.Index, result: MCValue, operands: [Live
                     self.register_manager.getRegAssumeFree(reg, inst);
                 }
             },
+            .register_with_overflow => |rwo| {
+                if (self.register_manager.isRegFree(rwo.reg)) {
+                    self.register_manager.getRegAssumeFree(rwo.reg, inst);
+                }
+                self.compare_flags_inst = inst;
+            },
+            .compare_flags => |_| {
+                self.compare_flags_inst = inst;
+            },
             else => {},
         }
     }
 @@ -931,11 +963,11 @@ pub fn spillInstruction(self: *Self, reg: Register, inst: Air.Inst.Index) !void
 /// Save the current instruction stored in the compare flags if
 /// occupied
 fn spillCompareFlagsIfOccupied(self: *Self) !void {
-    if (self.condition_flags_inst) |inst_to_save| {
+    if (self.compare_flags_inst) |inst_to_save| {
         const ty = self.air.typeOfIndex(inst_to_save);
         const mcv = self.getResolvedInstValue(inst_to_save);
         const new_mcv = switch (mcv) {
-            .condition_flags => try self.allocRegOrMem(ty, true, inst_to_save),
+            .compare_flags => try self.allocRegOrMem(ty, true, inst_to_save),
             .register_with_overflow => try self.allocRegOrMem(ty, false, inst_to_save),
             else => unreachable, // mcv doesn't occupy the compare flags
         };
 @@ -946,7 +978,7 @@ fn spillCompareFlagsIfOccupied(self: *Self) !void {
         const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
         try branch.inst_table.put(self.gpa, inst_to_save, new_mcv);
-        self.condition_flags_inst = null;
+        self.compare_flags_inst = null;
         // TODO consolidate with register manager and spillInstruction
         // this call should really belong in the register manager!
 @@ -1155,7 +1187,7 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void {
         switch (operand) {
             .dead => unreachable,
             .unreach => unreachable,
-            .condition_flags => |cond| break :result MCValue{ .condition_flags = cond.negate() },
+            .compare_flags => |cond| break :result MCValue{ .compare_flags = cond.negate() },
             else => {
                 switch (operand_ty.zigTypeTag()) {
                     .Bool => {
 @@ -1564,9 +1596,9 @@ fn allocRegs(
                 // If the previous MCValue occupied some space we track, we
                 // need to make sure it is marked as free now.
                 switch (mcv) {
-                    .condition_flags => {
+                    .compare_flags => {
-                        assert(self.condition_flags_inst.? == inst);
+                        assert(self.compare_flags_inst.? == inst);
-                        self.condition_flags_inst = null;
+                        self.compare_flags_inst = null;
                     },
                     .register => |prev_reg| {
                         assert(!self.register_manager.isRegFree(prev_reg));
 @@ -2363,7 +2395,7 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
                         const stack_offset = try self.allocMem(tuple_size, tuple_align, inst);
                         try self.spillCompareFlagsIfOccupied();
-                        self.condition_flags_inst = null;
+                        self.compare_flags_inst = null;
                         const base_tag: Air.Inst.Tag = switch (tag) {
                             .add_with_overflow => .add,
 @@ -2395,7 +2427,7 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
                         });
                         try self.genSetStack(lhs_ty, stack_offset, .{ .register = truncated_reg });
-                        try self.genSetStack(Type.initTag(.u1), stack_offset - overflow_bit_offset, .{ .condition_flags = .ne });
+                        try self.genSetStack(Type.initTag(.u1), stack_offset - overflow_bit_offset, .{ .compare_flags = .ne });
                         break :result MCValue{ .stack_offset = stack_offset };
                     },
 @@ -2430,7 +2462,7 @@ fn airOverflow(self: *Self, inst: Air.Inst.Index) !void {
                         };
                         try self.spillCompareFlagsIfOccupied();
-                        self.condition_flags_inst = inst;
+                        self.compare_flags_inst = inst;
                         const dest = blk: {
                             if (rhs_immediate_ok) {
 @@ -2539,7 +2571,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                     }
                     try self.genSetStack(lhs_ty, stack_offset, .{ .register = truncated_reg });
-                    try self.genSetStack(Type.initTag(.u1), stack_offset - overflow_bit_offset, .{ .condition_flags = .ne });
+                    try self.genSetStack(Type.initTag(.u1), stack_offset - overflow_bit_offset, .{ .compare_flags = .ne });
                     break :result MCValue{ .stack_offset = stack_offset };
                 } else if (int_info.bits <= 64) {
 @@ -2679,7 +2711,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                     try self.truncRegister(dest_reg, truncated_reg, int_info.signedness, int_info.bits);
                     try self.genSetStack(lhs_ty, stack_offset, .{ .register = truncated_reg });
-                    try self.genSetStack(Type.initTag(.u1), stack_offset - overflow_bit_offset, .{ .condition_flags = .ne });
+                    try self.genSetStack(Type.initTag(.u1), stack_offset - overflow_bit_offset, .{ .compare_flags = .ne });
                     break :result MCValue{ .stack_offset = stack_offset };
                 } else return self.fail("TODO implement mul_with_overflow for integers > u64/i64", .{});
 @@ -2811,7 +2843,7 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                     });
                     try self.genSetStack(lhs_ty, stack_offset, .{ .register = dest_reg });
-                    try self.genSetStack(Type.initTag(.u1), stack_offset - overflow_bit_offset, .{ .condition_flags = .ne });
+                    try self.genSetStack(Type.initTag(.u1), stack_offset - overflow_bit_offset, .{ .compare_flags = .ne });
                     break :result MCValue{ .stack_offset = stack_offset };
                 } else {
 @@ -3262,7 +3294,7 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
         .undef => unreachable,
         .unreach => unreachable,
         .dead => unreachable,
-        .condition_flags,
+        .compare_flags,
         .register_with_overflow,
         => unreachable, // cannot hold an address
         .immediate => |imm| try self.setRegOrMem(elem_ty, dst_mcv, .{ .memory = imm }),
 @@ -3274,7 +3306,7 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
             switch (dst_mcv) {
                 .dead => unreachable,
                 .undef => unreachable,
-                .condition_flags => unreachable,
+                .compare_flags => unreachable,
                 .register => |dst_reg| {
                     try self.genLdrRegister(dst_reg, addr_reg, elem_ty);
                 },
 @@ -3483,7 +3515,7 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
         .undef => unreachable,
         .unreach => unreachable,
         .dead => unreachable,
-        .condition_flags,
+        .compare_flags,
         .register_with_overflow,
         => unreachable, // cannot hold an address
         .immediate => |imm| {
 @@ -3638,7 +3670,7 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
                     0 => MCValue{ .register = rwo.reg },
                     // get overflow bit: return C or V flag
-                    1 => MCValue{ .condition_flags = rwo.flag },
+                    1 => MCValue{ .compare_flags = rwo.flag },
                     else => unreachable,
                 };
 @@ -4092,8 +4124,8 @@ fn cmp(
         }
         return switch (int_info.signedness) {
-            .signed => MCValue{ .condition_flags = Condition.fromCompareOperatorSigned(op) },
+            .signed => MCValue{ .compare_flags = Condition.fromCompareOperatorSigned(op) },
-            .unsigned => MCValue{ .condition_flags = Condition.fromCompareOperatorUnsigned(op) },
+            .unsigned => MCValue{ .compare_flags = Condition.fromCompareOperatorUnsigned(op) },
         };
     } else {
         return self.fail("TODO AArch64 cmp for ints > 64 bits", .{});
 @@ -4151,7 +4183,7 @@ fn airDbgVar(self: *Self, inst: Air.Inst.Index) !void {
 fn condBr(self: *Self, condition: MCValue) !Mir.Inst.Index {
     switch (condition) {
-        .condition_flags => |cond| return try self.addInst(.{
+        .compare_flags => |cond| return try self.addInst(.{
             .tag = .b_cond,
             .data = .{
                 .inst_cond = .{
 @@ -4207,7 +4239,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
     var parent_stack = try self.stack.clone(self.gpa);
     defer parent_stack.deinit(self.gpa);
     const parent_registers = self.register_manager.registers;
-    const parent_condition_flags_inst = self.condition_flags_inst;
+    const parent_compare_flags_inst = self.compare_flags_inst;
     try self.branch_stack.append(.{});
     errdefer {
 @@ -4226,7 +4258,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
     defer saved_then_branch.deinit(self.gpa);
     self.register_manager.registers = parent_registers;
-    self.condition_flags_inst = parent_condition_flags_inst;
+    self.compare_flags_inst = parent_compare_flags_inst;
     self.stack.deinit(self.gpa);
     self.stack = parent_stack;
 @@ -4354,9 +4386,9 @@ fn isErr(self: *Self, ty: Type, operand: MCValue) !MCValue {
 fn isNonErr(self: *Self, ty: Type, operand: MCValue) !MCValue {
     const is_err_result = try self.isErr(ty, operand);
     switch (is_err_result) {
-        .condition_flags => |cond| {
+        .compare_flags => |cond| {
             assert(cond == .hi);
-            return MCValue{ .condition_flags = cond.negate() };
+            return MCValue{ .compare_flags = cond.negate() };
         },
         .immediate => |imm| {
             assert(imm == 0);
 @@ -4519,10 +4551,132 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
 fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
     const pl_op = self.air.instructions.items(.data)[inst].pl_op;
-    const condition = pl_op.operand;
+    const condition_ty = self.air.typeOf(pl_op.operand);
-    _ = condition;
+    const switch_br = self.air.extraData(Air.SwitchBr, pl_op.payload);
+    const liveness = try self.liveness.getSwitchBr(
+        self.gpa,
+        inst,
+        switch_br.data.cases_len + 1,
+    );
+    defer self.gpa.free(liveness.deaths);
+    var extra_index: usize = switch_br.end;
+    var case_i: u32 = 0;
+    while (case_i < switch_br.data.cases_len) : (case_i += 1) {
+        const case = self.air.extraData(Air.SwitchBr.Case, extra_index);
+        const items = @ptrCast([]const Air.Inst.Ref, self.air.extra[case.end..][0..case.data.items_len]);
+        assert(items.len > 0);
+        const case_body = self.air.extra[case.end + items.len ..][0..case.data.body_len];
+        extra_index = case.end + items.len + case_body.len;
+        // For every item, we compare it to condition and branch into
+        // the prong if they are equal. After we compared to all
+        // items, we branch into the next prong (or if no other prongs
+        // exist out of the switch statement).
+        //
+        //             cmp condition, item1
+        //             beq prong
+        //             cmp condition, item2
+        //             beq prong
+        //             cmp condition, item3
+        //             beq prong
+        //             b out
+        // prong:      ...
+        //             ...
+        // out:        ...
+        const branch_into_prong_relocs = try self.gpa.alloc(u32, items.len);
+        defer self.gpa.free(branch_into_prong_relocs);
+        for (items) |item, idx| {
+            const cmp_result = try self.cmp(.{ .inst = pl_op.operand }, .{ .inst = item }, condition_ty, .neq);
+            branch_into_prong_relocs[idx] = try self.condBr(cmp_result);
+        }
+        const branch_away_from_prong_reloc = try self.addInst(.{
+            .tag = .b,
+            .data = .{ .inst = undefined }, // populated later through performReloc
+        });
+        for (branch_into_prong_relocs) |reloc| {
+            try self.performReloc(reloc);
+        }
+        // Capture the state of register and stack allocation state so that we can revert to it.
+        const parent_next_stack_offset = self.next_stack_offset;
+        const parent_free_registers = self.register_manager.free_registers;
+        const parent_compare_flags_inst = self.compare_flags_inst;
+        var parent_stack = try self.stack.clone(self.gpa);
+        defer parent_stack.deinit(self.gpa);
+        const parent_registers = self.register_manager.registers;
+        try self.branch_stack.append(.{});
+        errdefer {
+            _ = self.branch_stack.pop();
+        }
+        try self.ensureProcessDeathCapacity(liveness.deaths[case_i].len);
+        for (liveness.deaths[case_i]) |operand| {
+            self.processDeath(operand);
+        }
+        try self.genBody(case_body);
+        // Revert to the previous register and stack allocation state.
+        var saved_case_branch = self.branch_stack.pop();
+        defer saved_case_branch.deinit(self.gpa);
+        self.register_manager.registers = parent_registers;
+        self.compare_flags_inst = parent_compare_flags_inst;
+        self.stack.deinit(self.gpa);
+        self.stack = parent_stack;
+        parent_stack = .{};
+        self.next_stack_offset = parent_next_stack_offset;
+        self.register_manager.free_registers = parent_free_registers;
+        try self.performReloc(branch_away_from_prong_reloc);
+    }
+    if (switch_br.data.else_body_len > 0) {
+        const else_body = self.air.extra[extra_index..][0..switch_br.data.else_body_len];
+        // Capture the state of register and stack allocation state so that we can revert to it.
+        const parent_next_stack_offset = self.next_stack_offset;
+        const parent_free_registers = self.register_manager.free_registers;
+        const parent_compare_flags_inst = self.compare_flags_inst;
+        var parent_stack = try self.stack.clone(self.gpa);
+        defer parent_stack.deinit(self.gpa);
+        const parent_registers = self.register_manager.registers;
+        try self.branch_stack.append(.{});
+        errdefer {
+            _ = self.branch_stack.pop();
+        }
+        const else_deaths = liveness.deaths.len - 1;
+        try self.ensureProcessDeathCapacity(liveness.deaths[else_deaths].len);
+        for (liveness.deaths[else_deaths]) |operand| {
+            self.processDeath(operand);
+        }
+        try self.genBody(else_body);
+        // Revert to the previous register and stack allocation state.
+        var saved_case_branch = self.branch_stack.pop();
+        defer saved_case_branch.deinit(self.gpa);
+        self.register_manager.registers = parent_registers;
+        self.compare_flags_inst = parent_compare_flags_inst;
+        self.stack.deinit(self.gpa);
+        self.stack = parent_stack;
+        parent_stack = .{};
+        self.next_stack_offset = parent_next_stack_offset;
+        self.register_manager.free_registers = parent_free_registers;
+        // TODO consolidate returned MCValues between prongs and else branch like we do
+        // in airCondBr.
+    }
-    return self.fail("TODO airSwitch for {}", .{self.target.cpu.arch});
+    return self.finishAir(inst, .unreach, .{ pl_op.operand, .none, .none });
 }
 fn performReloc(self: *Self, inst: Mir.Inst.Index) !void {
 @@ -4551,7 +4705,7 @@ fn br(self: *Self, block: Air.Inst.Index, operand: Air.Inst.Ref) !void {
             block_data.mcv = switch (operand_mcv) {
                 .none, .dead, .unreach => unreachable,
                 .register, .stack_offset, .memory => operand_mcv,
-                .immediate, .stack_argument_offset, .condition_flags => blk: {
+                .immediate, .stack_argument_offset, .compare_flags => blk: {
                     const new_mcv = try self.allocRegOrMem(self.air.typeOfIndex(block), true, block);
                     try self.setRegOrMem(self.air.typeOfIndex(block), new_mcv, operand_mcv);
                     break :blk new_mcv;
 @@ -4734,7 +4888,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
                 else => return self.fail("TODO implement memset", .{}),
             }
         },
-        .condition_flags,
+        .compare_flags,
         .immediate,
         .ptr_stack_offset,
         => {
 @@ -4894,7 +5048,7 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
                 } },
             });
         },
-        .condition_flags => |condition| {
+        .compare_flags => |condition| {
             _ = try self.addInst(.{
                 .tag = .cset,
                 .data = .{ .r_cond = .{
 @@ -5171,7 +5325,7 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
                 try self.genInlineMemcpy(src_reg, dst_reg, len_reg, count_reg, tmp_reg);
             }
         },
-        .condition_flags,
+        .compare_flags,
         .immediate,
         .ptr_stack_offset,
         => {

test/behavior/switch.zig-25

...	@@ -5,8 +5,6 @@ const expectError = std.testing.expectError;	...	@@ -5,8 +5,6 @@ const expectError = std.testing.expectError;
5	const expectEqual = std.testing.expectEqual;	5	const expectEqual = std.testing.expectEqual;
6		6
7	test "switch with numbers" {	7	test "switch with numbers" {
8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9
10	try testSwitchWithNumbers(13);	8	try testSwitchWithNumbers(13);
11	}	9	}
12		10
...	@@ -20,8 +18,6 @@ fn testSwitchWithNumbers(x: u32) !void {	...	@@ -20,8 +18,6 @@ fn testSwitchWithNumbers(x: u32) !void {
20	}	18	}
21		19
22	test "switch with all ranges" {	20	test "switch with all ranges" {
23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
24
25	try expect(testSwitchWithAllRanges(50, 3) == 1);	21	try expect(testSwitchWithAllRanges(50, 3) == 1);
26	try expect(testSwitchWithAllRanges(101, 0) == 2);	22	try expect(testSwitchWithAllRanges(101, 0) == 2);
27	try expect(testSwitchWithAllRanges(300, 5) == 3);	23	try expect(testSwitchWithAllRanges(300, 5) == 3);
...	@@ -53,8 +49,6 @@ test "implicit comptime switch" {	...	@@ -53,8 +49,6 @@ test "implicit comptime switch" {
53	}	49	}
54		50
55	test "switch on enum" {	51	test "switch on enum" {
56	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
57
58	const fruit = Fruit.Orange;	52	const fruit = Fruit.Orange;
59	nonConstSwitchOnEnum(fruit);	53	nonConstSwitchOnEnum(fruit);
60	}	54	}
...	@@ -72,8 +66,6 @@ fn nonConstSwitchOnEnum(fruit: Fruit) void {	...	@@ -72,8 +66,6 @@ fn nonConstSwitchOnEnum(fruit: Fruit) void {
72	}	66	}
73		67
74	test "switch statement" {	68	test "switch statement" {
75	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
76
77	try nonConstSwitch(SwitchStatementFoo.C);	69	try nonConstSwitch(SwitchStatementFoo.C);
78	}	70	}
79	fn nonConstSwitch(foo: SwitchStatementFoo) !void {	71	fn nonConstSwitch(foo: SwitchStatementFoo) !void {
...	@@ -89,7 +81,6 @@ const SwitchStatementFoo = enum { A, B, C, D };	...	@@ -89,7 +81,6 @@ const SwitchStatementFoo = enum { A, B, C, D };
89		81
90	test "switch with multiple expressions" {	82	test "switch with multiple expressions" {
91	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO	83	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
92	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
93		84
94	const x = switch (returnsFive()) {	85	const x = switch (returnsFive()) {
95	1, 2, 3 => 1,	86	1, 2, 3 => 1,
...	@@ -103,8 +94,6 @@ fn returnsFive() i32 {	...	@@ -103,8 +94,6 @@ fn returnsFive() i32 {
103	}	94	}
104		95
105	test "switch on type" {	96	test "switch on type" {
106	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
107
108	try expect(trueIfBoolFalseOtherwise(bool));	97	try expect(trueIfBoolFalseOtherwise(bool));
109	try expect(!trueIfBoolFalseOtherwise(i32));	98	try expect(!trueIfBoolFalseOtherwise(i32));
110	}	99	}
...	@@ -117,8 +106,6 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool {	...	@@ -117,8 +106,6 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool {
117	}	106	}
118		107
119	test "switching on booleans" {	108	test "switching on booleans" {
120	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
121
122	try testSwitchOnBools();	109	try testSwitchOnBools();
123	comptime try testSwitchOnBools();	110	comptime try testSwitchOnBools();
124	}	111	}
...	@@ -170,8 +157,6 @@ test "undefined.u0" {	...	@@ -170,8 +157,6 @@ test "undefined.u0" {
170	}	157	}
171		158
172	test "switch with disjoint range" {	159	test "switch with disjoint range" {
173	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
174
175	var q: u8 = 0;	160	var q: u8 = 0;
176	switch (q) {	161	switch (q) {
177	0...125 => {},	162	0...125 => {},
...	@@ -214,8 +199,6 @@ fn poll() void {	...	@@ -214,8 +199,6 @@ fn poll() void {
214	}	199	}
215		200
216	test "switch on global mutable var isn't constant-folded" {	201	test "switch on global mutable var isn't constant-folded" {
217	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
218
219	while (state < 2) {	202	while (state < 2) {
220	poll();	203	poll();
221	}	204	}
...	@@ -273,7 +256,6 @@ fn testSwitchEnumPtrCapture() !void {	...	@@ -273,7 +256,6 @@ fn testSwitchEnumPtrCapture() !void {
273		256
274	test "switch handles all cases of number" {	257	test "switch handles all cases of number" {
275	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO	258	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
276	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
277		259
278	try testSwitchHandleAllCases();	260	try testSwitchHandleAllCases();
279	comptime try testSwitchHandleAllCases();	261	comptime try testSwitchHandleAllCases();
...	@@ -363,8 +345,6 @@ test "anon enum literal used in switch on union enum" {	...	@@ -363,8 +345,6 @@ test "anon enum literal used in switch on union enum" {
363	}	345	}
364		346
365	test "switch all prongs unreachable" {	347	test "switch all prongs unreachable" {
366	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
367
368	try testAllProngsUnreachable();	348	try testAllProngsUnreachable();
369	comptime try testAllProngsUnreachable();	349	comptime try testAllProngsUnreachable();
370	}	350	}
...	@@ -400,7 +380,6 @@ fn return_a_number() anyerror!i32 {	...	@@ -400,7 +380,6 @@ fn return_a_number() anyerror!i32 {
400		380
401	test "switch on integer with else capturing expr" {	381	test "switch on integer with else capturing expr" {
402	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO	382	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
403	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
404		383
405	const S = struct {	384	const S = struct {
406	fn doTheTest() !void {	385	fn doTheTest() !void {
...	@@ -641,8 +620,6 @@ test "switch capture copies its payload" {	...	@@ -641,8 +620,6 @@ test "switch capture copies its payload" {
641	}	620	}
642		621
643	test "capture of integer forwards the switch condition directly" {	622	test "capture of integer forwards the switch condition directly" {
644	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
645
646	const S = struct {	623	const S = struct {
647	fn foo(x: u8) !void {	624	fn foo(x: u8) !void {
648	switch (x) {	625	switch (x) {
...	@@ -662,8 +639,6 @@ test "capture of integer forwards the switch condition directly" {	...	@@ -662,8 +639,6 @@ test "capture of integer forwards the switch condition directly" {
662	}	639	}
663		640
664	test "enum value without tag name used as switch item" {	641	test "enum value without tag name used as switch item" {
665	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
666
667	const E = enum(u32) {	642	const E = enum(u32) {
668	a = 1,	643	a = 1,
669	b = 2,	644	b = 2,