commit 4653794852923e08cceab69620b7d0bb5d11e42d (tree) parent a5fbbb83050f2dad0a9ebc0bd995a5a8f58d0a49 Author: Ali Cheraghi <alichraghi@proton.me> Date: Tue, 16 Jun 2026 16:42:57 +0330 spirv: implement switch with ranges and loop_switch_br switch_dispatch Diffstat:
34 files changed, 679 insertions(+), 544 deletions(-)
diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig @@ -45,104 +45,67 @@ pub fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features { pub const zig_call_abi_ver = 3; -const ControlFlow = union(enum) { - const Structured = struct { - /// This type indicates the way that a block is terminated. The - /// state of a particular block is used to track how a jump from - /// inside the block must reach the outside. - const Block = union(enum) { - const Incoming = struct { - src_label: Id, - /// Instruction that returns an u32 value of the - /// `Air.Inst.Index` that control flow should jump to. - next_block: Id, - }; - - const SelectionMerge = struct { - /// Incoming block from the `then` label. - /// Note that hte incoming block from the `else` label is - /// either given by the next element in the stack. - incoming: Incoming, - /// The label id of the cond_br's merge block. - /// For the top-most element in the stack, this - /// value is undefined. - merge_block: Id, - }; - - /// For a `selection` type block, we cannot use early exits, and we - /// must generate a 'merge ladder' of OpSelection instructions. To that end, - /// we keep a stack of the merges that still must be closed at the end of - /// a block. - /// - /// This entire structure basically just resembles a tree like - /// a x - /// \ / - /// b o merge - /// \ / - /// c o merge - /// \ / - /// o merge - /// / - /// o jump to next block - selection: struct { - /// In order to know which merges we still need to do, we need to keep - /// a stack of those. - merge_stack: std.ArrayList(SelectionMerge) = .empty, - }, - /// For a `loop` type block, we can early-exit the block by - /// jumping to the loop exit node, and we don't need to generate - /// an entire stack of merges. - loop: struct { - /// The next block to jump to can be determined from any number - /// of conditions that jump to the loop exit. - merges: std.ArrayList(Incoming) = .empty, - /// The label id of the loop's merge block. - merge_block: Id, - }, - - fn deinit(block: *Structured.Block, gpa: Allocator) void { - switch (block.*) { - .selection => |*merge| merge.merge_stack.deinit(gpa), - .loop => |*merge| merge.merges.deinit(gpa), - } - block.* = undefined; - } - }; - /// This determines how exits from the current block must be handled. - block_stack: std.ArrayList(*Structured.Block) = .empty, - block_results: std.AutoHashMapUnmanaged(Air.Inst.Index, Id) = .empty, +const LoopSwitch = struct { cond_var: Id, continue_label: Id }; + +/// This type indicates the way that a block is terminated. The +/// state of a particular block is used to track how a jump from +/// inside the block must reach the outside. +const Block = union(enum) { + const Incoming = struct { + src_label: Id, + /// Instruction that returns an u32 value of the + /// `Air.Inst.Index` that control flow should jump to. + next_block: Id, }; - const Unstructured = struct { - const Incoming = struct { - src_label: Id, - break_value_id: Id, - }; - - const Block = struct { - label: ?Id = null, - incoming_blocks: std.ArrayList(Incoming) = .empty, - }; - - /// We need to keep track of result ids for block labels, as well as the 'incoming' - /// blocks for a block. - blocks: std.AutoHashMapUnmanaged(Air.Inst.Index, *Block) = .empty, + const SelectionMerge = struct { + /// Incoming block from the `then` label. + /// Note that the incoming block from the `else` label is + /// either given by the next element in the stack. + incoming: Incoming, + /// The label id of the cond_br's merge block. + /// For the top-most element in the stack, this + /// value is undefined. + merge_block: Id, }; - structured: Structured, - unstructured: Unstructured, + /// For a `selection` type block, we cannot use early exits, and we + /// must generate a 'merge ladder' of OpSelection instructions. To that end, + /// we keep a stack of the merges that still must be closed at the end of + /// a block. + /// + /// This entire structure basically just resembles a tree like + /// a x + /// \ / + /// b o merge + /// \ / + /// c o merge + /// \ / + /// o merge + /// / + /// o jump to next block + selection: struct { + /// In order to know which merges we still need to do, we need to keep + /// a stack of those. + merge_stack: std.ArrayList(SelectionMerge) = .empty, + }, + /// For a `loop` type block, we can early-exit the block by + /// jumping to the loop exit node, and we don't need to generate + /// an entire stack of merges. + loop: struct { + /// The next block to jump to can be determined from any number + /// of conditions that jump to the loop exit. + merges: std.ArrayList(Incoming) = .empty, + /// The label id of the loop's merge block. + merge_block: Id, + }, - pub fn deinit(cg: *ControlFlow, gpa: Allocator) void { - switch (cg.*) { - .structured => |*cf| { - cf.block_stack.deinit(gpa); - cf.block_results.deinit(gpa); - }, - .unstructured => |*cf| { - cf.blocks.deinit(gpa); - }, + fn deinit(block: *Block, gpa: Allocator) void { + switch (block.*) { + .selection => |*merge| merge.merge_stack.deinit(gpa), + .loop => |*merge| merge.merges.deinit(gpa), } - cg.* = undefined; + block.* = undefined; } }; @@ -151,23 +114,27 @@ air: Air, liveness: Air.Liveness, owner_nav: InternPool.Nav.Index, module: *Module, -control_flow: ControlFlow, +block_stack: std.ArrayList(*Block) = .empty, +block_results: std.AutoHashMapUnmanaged(Air.Inst.Index, Id) = .empty, base_line: u32, block_label: Id = .none, next_arg_index: u32 = 0, args: std.ArrayList(Id) = .empty, virtual_allocas: std.AutoHashMapUnmanaged(Id, ?Id) = .empty, inst_results: std.AutoHashMapUnmanaged(Air.Inst.Index, Id) = .empty, +loop_switches: std.AutoHashMapUnmanaged(Air.Inst.Index, LoopSwitch) = .empty, id_scratch: std.ArrayList(Id) = .empty, prologue: Section = .{}, body: Section = .{}, pub fn deinit(cg: *CodeGen) void { const gpa = cg.module.gpa; - cg.control_flow.deinit(gpa); + cg.block_stack.deinit(gpa); + cg.block_results.deinit(gpa); cg.args.deinit(gpa); cg.virtual_allocas.deinit(gpa); cg.inst_results.deinit(gpa); + cg.loop_switches.deinit(gpa); cg.id_scratch.deinit(gpa); cg.prologue.deinit(gpa); cg.body.deinit(gpa); @@ -183,7 +150,6 @@ pub fn generate( const zcu = pt.zcu; const gpa = zcu.gpa; const nav = zcu.funcInfo(func_index).owner_nav; - const structured_cfg = zcu.navFileScope(nav).mod.?.structured_cfg; var arena = std.heap.ArenaAllocator.init(gpa); defer arena.deinit(); @@ -200,10 +166,6 @@ pub fn generate( .liveness = liveness.*.?, .owner_nav = nav, .module = &module, - .control_flow = switch (structured_cfg) { - true => .{ .structured = .{} }, - false => .{ .unstructured = .{} }, - }, .base_line = zcu.navSrcLine(nav), }; defer cg.deinit(); @@ -222,7 +184,6 @@ pub fn generateNav( ) codegen.Error!Mir { const zcu = pt.zcu; const gpa = zcu.gpa; - const structured_cfg = zcu.navFileScope(nav_index).mod.?.structured_cfg; var arena = std.heap.ArenaAllocator.init(gpa); defer arena.deinit(); @@ -239,10 +200,6 @@ pub fn generateNav( .liveness = undefined, .owner_nav = nav_index, .module = &module, - .control_flow = switch (structured_cfg) { - true => .{ .structured = .{} }, - false => .{ .unstructured = .{} }, - }, .base_line = zcu.navSrcLine(nav_index), }; defer cg.deinit(); @@ -433,17 +390,10 @@ pub fn genNav(cg: *CodeGen, do_codegen: bool) Error!void { cg.block_label = root_block_id; const main_body = cg.air.getMainBody(); - switch (cg.control_flow) { - .structured => { - _ = try cg.genStructuredBody(.selection, main_body); - // We always expect paths to here to end, but we still need the block - // to act as a dummy merge block. - try cg.body.emit(gpa, .OpUnreachable, {}); - }, - .unstructured => { - try cg.genBody(main_body); - }, - } + _ = try cg.genStructuredBody(.selection, main_body); + // We always expect paths to here to end, but we still need the block + // to act as a dummy merge block. + try cg.body.emit(gpa, .OpUnreachable, {}); try cg.body.emit(gpa, .OpFunctionEnd, {}); // Append the actual code into the functions section. try cg.module.sections.functions.append(gpa, cg.prologue); @@ -1052,8 +1002,34 @@ fn constIntBig(cg: *CodeGen, ty: Type, val: Value) !Id { return cg.constructComposite(result_ty_id, constituents); } +/// Construct a composite value from its constituents. +/// In logical addressing mode (Vulkan/OpenGL), OpCompositeConstruct cannot accept +/// pointer operands, so for struct types we use alloc, store for each field and load instead. pub fn constructComposite(cg: *CodeGen, result_ty_id: Id, constituents: []const Id) !Id { const gpa = cg.module.gpa; + + if (cg.module.structFields(result_ty_id)) |fields| { + assert(fields.len == constituents.len); + const u32_ty_id = try cg.module.intType(.unsigned, 32); + const var_id = try cg.alloc(result_ty_id, null); + for (fields, constituents, 0..) |field_ty_id, constituent, i| { + const field_ptr_ty_id = try cg.module.ptrType(field_ty_id, .function); + const index_id = try cg.module.constant(u32_ty_id, .{ .uint32 = @intCast(i) }); + const field_ptr = try cg.accessChainId(field_ptr_ty_id, var_id, &.{index_id}); + try cg.body.emit(gpa, .OpStore, .{ + .pointer = field_ptr, + .object = constituent, + }); + } + const result_id = cg.module.allocId(); + try cg.body.emit(gpa, .OpLoad, .{ + .id_result_type = result_ty_id, + .id_result = result_id, + .pointer = var_id, + }); + return result_id; + } + const result_id = cg.module.allocId(); try cg.body.emit(gpa, .OpCompositeConstruct, .{ .id_result_type = result_ty_id, @@ -3896,19 +3872,21 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) Error!void { .load => try cg.airLoad(inst), .store, .store_safe => return cg.airStore(inst), - .br => return cg.airBr(inst), + .br => return cg.airBr(inst), // For now just ignore this instruction. This effectively falls back on the old implementation, // this doesn't change anything for us. - .repeat => return, - .breakpoint => return, - .cond_br => return cg.airCondBr(inst), - .loop => return cg.airLoop(inst), - .ret => return cg.airRet(inst), - .ret_safe => return cg.airRet(inst), // TODO - .ret_load => return cg.airRetLoad(inst), - .@"try" => try cg.airTry(inst), - .switch_br => return cg.airSwitchBr(inst), - .unreach, .trap => return cg.airUnreach(), + .repeat => return, + .breakpoint => return, + .cond_br => return cg.airCondBr(inst), + .loop => return cg.airLoop(inst), + .ret => return cg.airRet(inst), + .ret_safe => return cg.airRet(inst), // TODO + .ret_load => return cg.airRetLoad(inst), + .@"try" => try cg.airTry(inst), + .switch_br => return cg.airSwitchBr(inst), + .loop_switch_br => return cg.airLoopSwitchBr(inst), + .switch_dispatch => return cg.airSwitchDispatch(inst), + .unreach, .trap => return cg.airUnreach(), .dbg_empty_stmt => return, .dbg_stmt => return cg.airDbgStmt(inst), @@ -6426,7 +6404,27 @@ fn structFieldPtr( return cg.accessChain(result_ty_id, object_ptr, &.{field_index}); }, .@"struct" => switch (object_ty.containerLayout(zcu)) { - .@"packed" => return cg.todo("implement field access for packed structs", .{}), + .@"packed" => { + const byte_offset = codegen.fieldOffset(object_ptr_ty, result_ptr_ty, field_index, zcu); + if (byte_offset == 0) return object_ptr; + const usize_ty_id = try cg.resolveType(.usize, .direct); + const base_int = cg.module.allocId(); + try cg.body.emit(cg.module.gpa, .OpConvertPtrToU, .{ + .id_result_type = usize_ty_id, + .id_result = base_int, + .pointer = object_ptr, + }); + const offset_id = try cg.constInt(.usize, byte_offset); + const adjusted = try cg.buildBinary(.OpIAdd, .{ .ty = .usize, .value = .{ .singleton = base_int } }, .{ .ty = .usize, .value = .{ .singleton = offset_id } }); + const adjusted_id = try adjusted.materialize(cg); + const result_id = cg.module.allocId(); + try cg.body.emit(cg.module.gpa, .OpConvertUToPtr, .{ + .id_result_type = result_ty_id, + .id_result = result_id, + .integer_value = adjusted_id, + }); + return result_id; + }, .auto, .@"extern" => { return try cg.accessChain(result_ty_id, object_ptr, &.{field_index}); }, @@ -6532,9 +6530,7 @@ fn airArg(cg: *CodeGen) Id { /// block to jump to. This function emits instructions, so it should be emitted /// inside the merge block of the block. /// This function should only be called with structured control flow generation. -fn structuredNextBlock(cg: *CodeGen, incoming: []const ControlFlow.Structured.Block.Incoming) !Id { - assert(cg.control_flow == .structured); - +fn structuredNextBlock(cg: *CodeGen, incoming: []const Block.Incoming) !Id { const result_id = cg.module.allocId(); const block_id_ty_id = try cg.resolveType(.u32, .direct); try cg.body.emitRaw(cg.module.gpa, .OpPhi, @intCast(2 + incoming.len * 2)); // result type + result + variable/parent... @@ -6552,10 +6548,8 @@ fn structuredNextBlock(cg: *CodeGen, incoming: []const ControlFlow.Structured.Bl /// terminating a body, there should be no instructions after it. /// This function should only be called with structured control flow generation. fn structuredBreak(cg: *CodeGen, target_block: Id) !void { - assert(cg.control_flow == .structured); - const gpa = cg.module.gpa; - const sblock = cg.control_flow.structured.block_stack.getLast().?; + const sblock = cg.block_stack.getLast().?; const merge_block = switch (sblock.*) { .selection => |*merge| blk: { const merge_label = cg.module.allocId(); @@ -6598,11 +6592,9 @@ fn genStructuredBody( }, body: []const Air.Inst.Index, ) !Id { - assert(cg.control_flow == .structured); - const gpa = cg.module.gpa; - var sblock: ControlFlow.Structured.Block = switch (block_merge_type) { + var sblock: Block = switch (block_merge_type) { .loop => |merge| .{ .loop = .{ .merge_block = merge.merge_label, } }, @@ -6611,8 +6603,8 @@ fn genStructuredBody( defer sblock.deinit(gpa); { - try cg.control_flow.structured.block_stack.append(gpa, &sblock); - defer _ = cg.control_flow.structured.block_stack.pop(); + try cg.block_stack.append(gpa, &sblock); + defer _ = cg.block_stack.pop(); try cg.genBody(body); } @@ -6650,7 +6642,7 @@ fn genStructuredBody( try cg.beginSpvBlock(merge_stack[merge_stack.len - 1].merge_block); // Now generate a merge ladder for the remaining merges in the stack. - var incoming: ControlFlow.Structured.Block.Incoming = .{ + var incoming: Block.Incoming = .{ .src_label = cg.block_label, .next_block = merge_stack[merge_stack.len - 1].incoming.next_block, }; @@ -6699,65 +6691,19 @@ fn lowerBlock(cg: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index) const ty = cg.typeOfIndex(inst); const have_block_result = ty.hasRuntimeBits(zcu); - const cf = switch (cg.control_flow) { - .structured => |*cf| cf, - .unstructured => |*cf| { - var block: ControlFlow.Unstructured.Block = .{}; - defer block.incoming_blocks.deinit(gpa); - - // 4 chosen as arbitrary initial capacity. - try block.incoming_blocks.ensureUnusedCapacity(gpa, 4); - - try cf.blocks.putNoClobber(gpa, inst, &block); - defer assert(cf.blocks.remove(inst)); - - try cg.genBody(body); - - // Only begin a new block if there were actually any breaks towards it. - if (block.label) |label| { - try cg.beginSpvBlock(label); - } - - if (!have_block_result) - return null; - - assert(block.label != null); - const result_id = cg.module.allocId(); - const result_type_id = try cg.resolveType(ty, .direct); - - try cg.body.emitRaw( - gpa, - .OpPhi, - // result type + result + variable/parent... - 2 + @as(u16, @intCast(block.incoming_blocks.items.len * 2)), - ); - cg.body.writeOperand(Id, result_type_id); - cg.body.writeOperand(Id, result_id); - - for (block.incoming_blocks.items) |incoming| { - cg.body.writeOperand( - spec.PairIdRefIdRef, - .{ incoming.break_value_id, incoming.src_label }, - ); - } - - return result_id; - }, - }; - const maybe_block_result_var_id = if (have_block_result) blk: { const ty_id = try cg.resolveType(ty, .indirect); const block_result_var_id = try cg.alloc(ty_id, null); - try cf.block_results.putNoClobber(gpa, inst, block_result_var_id); + try cg.block_results.putNoClobber(gpa, inst, block_result_var_id); break :blk block_result_var_id; } else null; - defer if (have_block_result) assert(cf.block_results.remove(inst)); + defer if (have_block_result) assert(cg.block_results.remove(inst)); const next_block = try cg.genStructuredBody(.selection, body); // When encountering a block instruction, we are always at least in the function's scope, // so there always has to be another entry. - assert(cf.block_stack.items.len > 0); + assert(cg.block_stack.items.len > 0); // Check if the target of the branch was this current block. const this_block = try cg.constInt(.u32, @intFromEnum(inst)); @@ -6770,7 +6716,7 @@ fn lowerBlock(cg: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index) .operand_2 = this_block, }); - const sblock = cf.block_stack.getLast().?; + const sblock = cg.block_stack.getLast().?; if (ty.isNoReturn(zcu)) { // If this block is noreturn, this instruction is the last of a block, @@ -6828,41 +6774,18 @@ fn lowerBlock(cg: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index) } fn airBr(cg: *CodeGen, inst: Air.Inst.Index) !void { - const gpa = cg.module.gpa; const zcu = cg.module.zcu; const br = cg.air.instructions.items(.data)[@intFromEnum(inst)].br; const operand_ty = cg.typeOf(br.operand); - switch (cg.control_flow) { - .structured => |*cf| { - if (operand_ty.hasRuntimeBits(zcu)) { - const operand_id = try cg.resolve(br.operand); - const block_result_var_id = cf.block_results.get(br.block_inst).?; - try cg.store(operand_ty, block_result_var_id, operand_id, .{}); - } - - const next_block = try cg.constInt(.u32, @intFromEnum(br.block_inst)); - try cg.structuredBreak(next_block); - }, - .unstructured => |cf| { - const block = cf.blocks.get(br.block_inst).?; - if (operand_ty.hasRuntimeBits(zcu)) { - const operand_id = try cg.resolve(br.operand); - // block_label should not be undefined here, lest there - // is a br or br_void in the function's body. - try block.incoming_blocks.append(gpa, .{ - .src_label = cg.block_label, - .break_value_id = operand_id, - }); - } - - if (block.label == null) { - block.label = cg.module.allocId(); - } - - try cg.body.emit(gpa, .OpBranch, .{ .target_label = block.label.? }); - }, + if (operand_ty.hasRuntimeBits(zcu)) { + const operand_id = try cg.resolve(br.operand); + const block_result_var_id = cg.block_results.get(br.block_inst).?; + try cg.store(operand_ty, block_result_var_id, operand_id, .{}); } + + const next_block = try cg.constInt(.u32, @intFromEnum(br.block_inst)); + try cg.structuredBreak(next_block); } fn airCondBr(cg: *CodeGen, inst: Air.Inst.Index) !void { @@ -6875,56 +6798,40 @@ fn airCondBr(cg: *CodeGen, inst: Air.Inst.Index) !void { const then_label = cg.module.allocId(); const else_label = cg.module.allocId(); - switch (cg.control_flow) { - .structured => { - const merge_label = cg.module.allocId(); - - try cg.body.emit(gpa, .OpSelectionMerge, .{ - .merge_block = merge_label, - .selection_control = .{}, - }); - try cg.body.emit(gpa, .OpBranchConditional, .{ - .condition = condition_id, - .true_label = then_label, - .false_label = else_label, - }); + const merge_label = cg.module.allocId(); - try cg.beginSpvBlock(then_label); - const then_next = try cg.genStructuredBody(.selection, then_body); - const then_incoming: ControlFlow.Structured.Block.Incoming = .{ - .src_label = cg.block_label, - .next_block = then_next, - }; + try cg.body.emit(gpa, .OpSelectionMerge, .{ + .merge_block = merge_label, + .selection_control = .{}, + }); + try cg.body.emit(gpa, .OpBranchConditional, .{ + .condition = condition_id, + .true_label = then_label, + .false_label = else_label, + }); - try cg.body.emit(gpa, .OpBranch, .{ .target_label = merge_label }); + try cg.beginSpvBlock(then_label); + const then_next = try cg.genStructuredBody(.selection, then_body); + const then_incoming: Block.Incoming = .{ + .src_label = cg.block_label, + .next_block = then_next, + }; - try cg.beginSpvBlock(else_label); - const else_next = try cg.genStructuredBody(.selection, else_body); - const else_incoming: ControlFlow.Structured.Block.Incoming = .{ - .src_label = cg.block_label, - .next_block = else_next, - }; + try cg.body.emit(gpa, .OpBranch, .{ .target_label = merge_label }); - try cg.body.emit(gpa, .OpBranch, .{ .target_label = merge_label }); + try cg.beginSpvBlock(else_label); + const else_next = try cg.genStructuredBody(.selection, else_body); + const else_incoming: Block.Incoming = .{ + .src_label = cg.block_label, + .next_block = else_next, + }; - try cg.beginSpvBlock(merge_label); - const next_block = try cg.structuredNextBlock(&.{ then_incoming, else_incoming }); + try cg.body.emit(gpa, .OpBranch, .{ .target_label = merge_label }); - try cg.structuredBreak(next_block); - }, - .unstructured => { - try cg.body.emit(gpa, .OpBranchConditional, .{ - .condition = condition_id, - .true_label = then_label, - .false_label = else_label, - }); + try cg.beginSpvBlock(merge_label); + const next_block = try cg.structuredNextBlock(&.{ then_incoming, else_incoming }); - try cg.beginSpvBlock(then_label); - try cg.genBody(then_body); - try cg.beginSpvBlock(else_label); - try cg.genBody(else_body); - }, - } + try cg.structuredBreak(next_block); } fn airLoop(cg: *CodeGen, inst: Air.Inst.Index) !void { @@ -6933,67 +6840,85 @@ fn airLoop(cg: *CodeGen, inst: Air.Inst.Index) !void { const body_label = cg.module.allocId(); - switch (cg.control_flow) { - .structured => { - const header_label = cg.module.allocId(); - const merge_label = cg.module.allocId(); - const continue_label = cg.module.allocId(); - - // The back-edge must point to the loop header, so generate a separate block for the - // loop header so that we don't accidentally include some instructions from there - // in the loop. + const header_label = cg.module.allocId(); + const merge_label = cg.module.allocId(); + const continue_label = cg.module.allocId(); - try cg.body.emit(gpa, .OpBranch, .{ .target_label = header_label }); - try cg.beginSpvBlock(header_label); + // The back-edge must point to the loop header, so generate a separate block for the + // loop header so that we don't accidentally include some instructions from there + // in the loop. - // Emit loop header and jump to loop body - try cg.body.emit(gpa, .OpLoopMerge, .{ - .merge_block = merge_label, - .continue_target = continue_label, - .loop_control = .{}, - }); + try cg.body.emit(gpa, .OpBranch, .{ .target_label = header_label }); + try cg.beginSpvBlock(header_label); - try cg.body.emit(gpa, .OpBranch, .{ .target_label = body_label }); + // Emit loop header and jump to loop body + try cg.body.emit(gpa, .OpLoopMerge, .{ + .merge_block = merge_label, + .continue_target = continue_label, + .loop_control = .{}, + }); - try cg.beginSpvBlock(body_label); + try cg.body.emit(gpa, .OpBranch, .{ .target_label = body_label }); - const next_block = try cg.genStructuredBody(.{ .loop = .{ - .merge_label = merge_label, - .continue_label = continue_label, - } }, block.body); - try cg.structuredBreak(next_block); + try cg.beginSpvBlock(body_label); - try cg.beginSpvBlock(continue_label); + const next_block = try cg.genStructuredBody(.{ .loop = .{ + .merge_label = merge_label, + .continue_label = continue_label, + } }, block.body); + try cg.structuredBreak(next_block); - try cg.body.emit(gpa, .OpBranch, .{ .target_label = header_label }); - }, - .unstructured => { - try cg.body.emit(gpa, .OpBranch, .{ .target_label = body_label }); - try cg.beginSpvBlock(body_label); - try cg.genBody(block.body); + try cg.beginSpvBlock(continue_label); - try cg.body.emit(gpa, .OpBranch, .{ .target_label = body_label }); - }, - } + try cg.body.emit(gpa, .OpBranch, .{ .target_label = header_label }); } fn airLoad(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.module.zcu; + const pt = cg.pt; const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; const ptr_ty = cg.typeOf(ty_op.operand); + const ptr_info = ptr_ty.ptrInfo(zcu); const elem_ty = cg.typeOfIndex(inst); const operand = try cg.resolve(ty_op.operand); if (!ptr_ty.isVolatilePtr(zcu) and cg.liveness.isUnused(inst)) return null; if (cg.virtual_allocas.get(operand)) |stored| return stored.?; + if (ptr_info.packed_offset.host_size != 0 and + ptr_info.flags.vector_index == .none) + { + const host_bits: u16 = ptr_info.packed_offset.host_size * 8; + const elem_bit_size: u16 = @intCast(elem_ty.bitSize(zcu)); + const host_int_ty = try pt.intType(.unsigned, host_bits); + const host_val = try cg.load(host_int_ty, operand, .{ .is_volatile = ptr_ty.isVolatilePtr(zcu) }); + const signedness: Signedness = if (elem_ty.isInt(zcu)) elem_ty.intInfo(zcu).signedness else .unsigned; + const field_int_ty = try pt.intType(signedness, elem_bit_size); + const narrowed = if (ptr_info.packed_offset.bit_offset > 0) blk: { + const bit_offset_id = try cg.constInt(host_int_ty, ptr_info.packed_offset.bit_offset); + const shifted = try cg.buildBinary(.OpShiftRightLogical, .{ .ty = host_int_ty, .value = .{ .singleton = host_val } }, .{ .ty = host_int_ty, .value = .{ .singleton = bit_offset_id } }); + break :blk try shifted.materialize(cg); + } else host_val; + const result_id = blk: { + if (cg.module.backingIntBits(elem_bit_size).@"0" == cg.module.backingIntBits(host_bits).@"0") + break :blk try cg.bitCast(field_int_ty, host_int_ty, narrowed); + const trunc = try cg.buildConvert(field_int_ty, .{ .ty = host_int_ty, .value = .{ .singleton = narrowed } }); + break :blk try trunc.materialize(cg); + }; + if (elem_ty.ip_index == .bool_type) return try cg.convertToDirect(.bool, result_id); + if (elem_ty.isInt(zcu)) return result_id; + return try cg.bitCast(elem_ty, field_int_ty, result_id); + } + return try cg.load(elem_ty, operand, .{ .is_volatile = ptr_ty.isVolatilePtr(zcu) }); } fn airStore(cg: *CodeGen, inst: Air.Inst.Index) !void { const zcu = cg.module.zcu; + const pt = cg.pt; const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; const ptr_ty = cg.typeOf(bin_op.lhs); + const ptr_info = ptr_ty.ptrInfo(zcu); const elem_ty = ptr_ty.childType(zcu); const ptr = try cg.resolve(bin_op.lhs); const value = try cg.resolve(bin_op.rhs); @@ -7003,6 +6928,48 @@ fn airStore(cg: *CodeGen, inst: Air.Inst.Index) !void { return; } + if (ptr_info.packed_offset.host_size != 0 and + ptr_info.flags.vector_index == .none) + { + const host_bits: u16 = ptr_info.packed_offset.host_size * 8; + const host_int_ty = try pt.intType(.unsigned, host_bits); + const host_val = try cg.load(host_int_ty, ptr, .{ .is_volatile = ptr_ty.isVolatilePtr(zcu) }); + const elem_bit_size: u16 = @intCast(elem_ty.bitSize(zcu)); + const signedness: Signedness = if (elem_ty.isInt(zcu)) elem_ty.intInfo(zcu).signedness else .unsigned; + const field_int_ty = try pt.intType(signedness, elem_bit_size); + + var value_as_int: Id = undefined; + if (elem_ty.ip_index == .bool_type) { + value_as_int = try cg.convertToIndirect(.bool, value); + value_as_int = try cg.bitCast(field_int_ty, .u1, value_as_int); + } else if (elem_ty.isInt(zcu)) { + value_as_int = value; + } else { + value_as_int = try cg.bitCast(field_int_ty, elem_ty, value); + } + + const extended = blk: { + if (cg.module.backingIntBits(elem_bit_size).@"0" == cg.module.backingIntBits(host_bits).@"0") + break :blk try cg.bitCast(host_int_ty, field_int_ty, value_as_int); + const conv = try cg.buildConvert(host_int_ty, .{ .ty = field_int_ty, .value = .{ .singleton = value_as_int } }); + break :blk try conv.materialize(cg); + }; + + const bit_offset = ptr_info.packed_offset.bit_offset; + const field_mask = (@as(u64, 1) << @as(u6, @intCast(elem_bit_size))) - 1; + const host_mask = if (host_bits == 64) @as(u64, std.math.maxInt(u64)) else (@as(u64, 1) << @as(u6, @intCast(host_bits))) - 1; + const clear_mask = ~(field_mask << @as(u6, @intCast(bit_offset))) & host_mask; + const clear_mask_id = try cg.constInt(host_int_ty, clear_mask); + const cleared = try cg.buildBinary(.OpBitwiseAnd, .{ .ty = host_int_ty, .value = .{ .singleton = host_val } }, .{ .ty = host_int_ty, .value = .{ .singleton = clear_mask_id } }); + const bit_offset_id = try cg.constInt(host_int_ty, bit_offset); + const shifted_val = try cg.buildBinary(.OpShiftLeftLogical, .{ .ty = host_int_ty, .value = .{ .singleton = extended } }, .{ .ty = host_int_ty, .value = .{ .singleton = bit_offset_id } }); + const combined = try cg.buildBinary(.OpBitwiseOr, cleared, shifted_val); + const combined_id = try combined.materialize(cg); + + try cg.store(host_int_ty, ptr, combined_id, .{ .is_volatile = ptr_ty.isVolatilePtr(zcu) }); + return; + } + try cg.store(elem_ty, ptr, value, .{ .is_volatile = ptr_ty.isVolatilePtr(zcu) }); } @@ -7091,19 +7058,13 @@ fn airTry(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const err_block = cg.module.allocId(); const ok_block = cg.module.allocId(); - switch (cg.control_flow) { - .structured => { - // According to AIR documentation, this block is guaranteed - // to not break and end in a return instruction. Thus, - // for structured control flow, we can just naively use - // the ok block as the merge block here. - try cg.body.emit(gpa, .OpSelectionMerge, .{ - .merge_block = ok_block, - .selection_control = .{}, - }); - }, - .unstructured => {}, - } + // According to AIR documentation, this block is guaranteed + // to not break and end in a return instruction. Thus, + // we can just naively use the ok block as the merge block here. + try cg.body.emit(gpa, .OpSelectionMerge, .{ + .merge_block = ok_block, + .selection_control = .{}, + }); try cg.body.emit(gpa, .OpBranchConditional, .{ .condition = is_err_id, @@ -7419,45 +7380,44 @@ fn airSwitchBr(cg: *CodeGen, inst: Air.Inst.Index) !void { const num_cases = switch_br.cases_len; - // Compute the total number of arms that we need. - // Zig switches are grouped by condition, so we need to loop through all of them - const num_conditions = blk: { - var num_conditions: u32 = 0; + // compute the total number of scalar arms and find the last range case + var num_conditions: u32 = 0; + var last_range_case: ?u32 = null; + { var it = switch_br.iterateCases(); while (it.next()) |case| { - if (case.ranges.len > 0) return cg.todo("switch with ranges", .{}); - num_conditions += @intCast(case.items.len); + if (case.ranges.len > 0) { + last_range_case = case.idx; + } else { + num_conditions += @intCast(case.items.len); + } } - break :blk num_conditions; - }; + } // First, pre-allocate the labels for the cases. const case_labels = cg.module.allocIds(num_cases); // We always need the default case - if zig has none, we will generate unreachable there. - const default = cg.module.allocId(); + const default_label = cg.module.allocId(); + const switch_default = if (last_range_case != null) cg.module.allocId() else default_label; - const merge_label = switch (cg.control_flow) { - .structured => cg.module.allocId(), - .unstructured => null, - }; + const merge_label = cg.module.allocId(); - if (cg.control_flow == .structured) { - try cg.body.emit(gpa, .OpSelectionMerge, .{ - .merge_block = merge_label.?, - .selection_control = .{}, - }); - } + try cg.body.emit(gpa, .OpSelectionMerge, .{ + .merge_block = merge_label, + .selection_control = .{}, + }); // Emit the instruction before generating the blocks. try cg.body.emitRaw(gpa, .OpSwitch, 2 + (cond_words + 1) * num_conditions); cg.body.writeOperand(Id, cond_indirect); - cg.body.writeOperand(Id, default); + cg.body.writeOperand(Id, switch_default); - // Emit each of the cases + // Emit the non-range cases into the OpSwitch. + // Cases with ranges are handled by the conditional chain below. { var it = switch_br.iterateCases(); while (it.next()) |case| { - // SPIR-V needs a literal here, which' width depends on the case condition. + if (case.ranges.len > 0) continue; const label = case_labels.at(case.idx); for (case.items) |item| { @@ -7480,62 +7440,394 @@ fn airSwitchBr(cg: *CodeGen, inst: Air.Inst.Index) !void { } } - var incoming_structured_blocks: std.ArrayList(ControlFlow.Structured.Block.Incoming) = .empty; + var incoming_structured_blocks: std.ArrayList(Block.Incoming) = .empty; defer incoming_structured_blocks.deinit(gpa); + try incoming_structured_blocks.ensureUnusedCapacity(gpa, num_cases + 1); + + // emit the range-checking chain as nested if-else inside the switch's default branch. + // each range case becomes: + // - check condition, + // - if true emit case body and branch to merge, + // - else continue to next check or default + if (last_range_case != null) { + const cond_tmp: Temporary = .init(cond_ty, cond); + const bool_ty_id = try cg.resolveType(.bool, .direct); + + try cg.beginSpvBlock(switch_default); + + var it_range = switch_br.iterateCases(); + while (it_range.next()) |case| { + if (case.ranges.len == 0) continue; + + var case_cond: ?Id = null; + + for (case.items) |item| { + const item_tmp: Temporary = try cg.temporary(item); + const eq = try (try cg.cmp(.eq, cond_tmp, item_tmp)).materialize(cg); + case_cond = if (case_cond) |prev| blk: { + const combined = cg.module.allocId(); + try cg.body.emitRaw(gpa, .OpLogicalOr, 4); + cg.body.writeOperand(Id, bool_ty_id); + cg.body.writeOperand(Id, combined); + cg.body.writeOperand(Id, prev); + cg.body.writeOperand(Id, eq); + break :blk combined; + } else eq; + } + + for (case.ranges) |range| { + const lo_tmp: Temporary = try cg.temporary(range[0]); + const hi_tmp: Temporary = try cg.temporary(range[1]); + const ge = try (try cg.cmp(.gte, cond_tmp, lo_tmp)).materialize(cg); + const le = try (try cg.cmp(.lte, cond_tmp, hi_tmp)).materialize(cg); + const in_range = cg.module.allocId(); + try cg.body.emitRaw(gpa, .OpLogicalAnd, 4); + cg.body.writeOperand(Id, bool_ty_id); + cg.body.writeOperand(Id, in_range); + cg.body.writeOperand(Id, ge); + cg.body.writeOperand(Id, le); + case_cond = if (case_cond) |prev| blk: { + const combined = cg.module.allocId(); + try cg.body.emitRaw(gpa, .OpLogicalOr, 4); + cg.body.writeOperand(Id, bool_ty_id); + cg.body.writeOperand(Id, combined); + cg.body.writeOperand(Id, prev); + cg.body.writeOperand(Id, in_range); + break :blk combined; + } else in_range; + } - if (cg.control_flow == .structured) { - try incoming_structured_blocks.ensureUnusedCapacity(gpa, num_cases + 1); + const case_label = case_labels.at(case.idx); + const is_last = case.idx == last_range_case.?; + const next_check = if (is_last) default_label else cg.module.allocId(); + + try cg.body.emit(gpa, .OpSelectionMerge, .{ + .merge_block = next_check, + .selection_control = .{}, + }); + + try cg.body.emit(gpa, .OpBranchConditional, .{ + .condition = case_cond.?, + .true_label = case_label, + .false_label = next_check, + }); + + if (!is_last) { + try cg.beginSpvBlock(next_check); + } + } } - // Now, finally, we can start emitting each of the cases. + // emit bodies var it = switch_br.iterateCases(); while (it.next()) |case| { const label = case_labels.at(case.idx); try cg.beginSpvBlock(label); - switch (cg.control_flow) { - .structured => { - const next_block = try cg.genStructuredBody(.selection, case.body); - incoming_structured_blocks.appendAssumeCapacity(.{ - .src_label = cg.block_label, - .next_block = next_block, - }); + const next_block = try cg.genStructuredBody(.selection, case.body); + incoming_structured_blocks.appendAssumeCapacity(.{ + .src_label = cg.block_label, + .next_block = next_block, + }); - try cg.body.emit(gpa, .OpBranch, .{ .target_label = merge_label.? }); - }, - .unstructured => { - try cg.genBody(case.body); - }, - } + try cg.body.emit(gpa, .OpBranch, .{ .target_label = merge_label }); } - const else_body = it.elseBody(); - try cg.beginSpvBlock(default); + const else_body = blk: { + var it_else = switch_br.iterateCases(); + while (it_else.next()) |_| {} + break :blk it_else.elseBody(); + }; + try cg.beginSpvBlock(default_label); if (else_body.len != 0) { - switch (cg.control_flow) { - .structured => { - const next_block = try cg.genStructuredBody(.selection, else_body); - incoming_structured_blocks.appendAssumeCapacity(.{ - .src_label = cg.block_label, - .next_block = next_block, - }); + const next_block = try cg.genStructuredBody(.selection, else_body); + incoming_structured_blocks.appendAssumeCapacity(.{ + .src_label = cg.block_label, + .next_block = next_block, + }); - try cg.body.emit(gpa, .OpBranch, .{ .target_label = merge_label.? }); - }, - .unstructured => { - try cg.genBody(else_body); - }, - } + try cg.body.emit(gpa, .OpBranch, .{ .target_label = merge_label }); } else { try cg.body.emit(gpa, .OpUnreachable, {}); } - if (cg.control_flow == .structured) { - try cg.beginSpvBlock(merge_label.?); - const next_block = try cg.structuredNextBlock(incoming_structured_blocks.items); - try cg.structuredBreak(next_block); + try cg.beginSpvBlock(merge_label); + const next_block = try cg.structuredNextBlock(incoming_structured_blocks.items); + try cg.structuredBreak(next_block); +} + +fn airLoopSwitchBr(cg: *CodeGen, inst: Air.Inst.Index) !void { + const gpa = cg.module.gpa; + const zcu = cg.module.zcu; + const target = cg.module.zcu.getTarget(); + const switch_br = cg.air.unwrapSwitch(inst); + const cond_ty = cg.typeOf(switch_br.operand); + const initial_cond = try cg.resolve(switch_br.operand); + var initial_cond_indirect = try cg.convertToIndirect(cond_ty, initial_cond); + + const cond_words: u32 = switch (cond_ty.zigTypeTag(zcu)) { + .bool, .error_set => 1, + .int => blk: { + const bits = cond_ty.intInfo(zcu).bits; + const backing_bits, const big_int = cg.module.backingIntBits(bits); + if (big_int) return cg.todo("implement composite int loop switch", .{}); + break :blk if (backing_bits <= 32) 1 else 2; + }, + .@"enum" => blk: { + const int_ty = cond_ty.intTagType(zcu); + const int_info = int_ty.intInfo(zcu); + const backing_bits, const big_int = cg.module.backingIntBits(int_info.bits); + if (big_int) return cg.todo("implement composite int loop switch", .{}); + break :blk if (backing_bits <= 32) 1 else 2; + }, + .pointer => blk: { + initial_cond_indirect = try cg.intFromPtr(initial_cond_indirect); + break :blk target.ptrBitWidth() / 32; + }, + else => return cg.todo("implement loop switch for type {s}", .{@tagName(cond_ty.zigTypeTag(zcu))}), + }; + + const cond_ty_id = try cg.resolveType(cond_ty, .indirect); + const cond_var = try cg.alloc(cond_ty_id, null); + try cg.store(cond_ty, cond_var, initial_cond_indirect, .{}); + + const num_cases = switch_br.cases_len; + + var num_conditions: u32 = 0; + var last_range_case: ?u32 = null; + { + var it = switch_br.iterateCases(); + while (it.next()) |case| { + if (case.ranges.len > 0) { + last_range_case = case.idx; + } else { + num_conditions += @intCast(case.items.len); + } + } } + + const case_labels = cg.module.allocIds(num_cases); + const default_label = cg.module.allocId(); + const switch_default = if (last_range_case != null) cg.module.allocId() else default_label; + + const header_label = cg.module.allocId(); + const loop_merge = cg.module.allocId(); + const continue_label = cg.module.allocId(); + const switch_merge = cg.module.allocId(); + const body_label = cg.module.allocId(); + + // switch_dispatch signals "continue the loop" by using this sentinel as the + // next_block in structuredBreak. at switch_merge, a phi + comparison distinguishes + // dispatch (continue) from break (exit) + const dispatch_sentinel = try cg.constInt(.u32, @intFromEnum(inst)); + + try cg.loop_switches.putNoClobber(gpa, inst, .{ + .cond_var = cond_var, + .continue_label = dispatch_sentinel, + }); + defer assert(cg.loop_switches.remove(inst)); + + try cg.body.emit(gpa, .OpBranch, .{ .target_label = header_label }); + try cg.beginSpvBlock(header_label); + + try cg.body.emit(gpa, .OpLoopMerge, .{ + .merge_block = loop_merge, + .continue_target = continue_label, + .loop_control = .{}, + }); + + try cg.body.emit(gpa, .OpBranch, .{ .target_label = body_label }); + try cg.beginSpvBlock(body_label); + + const cond = try cg.load(cond_ty, cond_var, .{}); + const cond_indirect = try cg.convertToIndirect(cond_ty, cond); + + try cg.body.emit(gpa, .OpSelectionMerge, .{ + .merge_block = switch_merge, + .selection_control = .{}, + }); + + try cg.body.emitRaw(gpa, .OpSwitch, 2 + (cond_words + 1) * num_conditions); + cg.body.writeOperand(Id, cond_indirect); + cg.body.writeOperand(Id, switch_default); + + { + var it = switch_br.iterateCases(); + while (it.next()) |case| { + if (case.ranges.len > 0) continue; + const label = case_labels.at(case.idx); + for (case.items) |item| { + const value: Value = .fromInterned(item.toInterned().?); + const int_val: u64 = switch (cond_ty.zigTypeTag(zcu)) { + .bool, .int => if (cond_ty.isSignedInt(zcu)) @bitCast(value.toSignedInt(zcu)) else value.toUnsignedInt(zcu), + .@"enum" => value.intFromEnum(zcu).toUnsignedInt(zcu), + .error_set => value.getErrorInt(zcu), + .pointer => value.toUnsignedInt(zcu), + else => unreachable, + }; + const int_lit: spec.LiteralContextDependentNumber = switch (cond_words) { + 1 => .{ .uint32 = @intCast(int_val) }, + 2 => .{ .uint64 = int_val }, + else => unreachable, + }; + cg.body.writeOperand(spec.LiteralContextDependentNumber, int_lit); + cg.body.writeOperand(Id, label); + } + } + } + + var incoming_structured_blocks: std.ArrayList(Block.Incoming) = .empty; + defer incoming_structured_blocks.deinit(gpa); + try incoming_structured_blocks.ensureUnusedCapacity(gpa, num_cases + 1); + + if (last_range_case != null) { + const cond_tmp: Temporary = .init(cond_ty, cond); + const bool_ty_id = try cg.resolveType(.bool, .direct); + + try cg.beginSpvBlock(switch_default); + + var it_range = switch_br.iterateCases(); + while (it_range.next()) |case| { + if (case.ranges.len == 0) continue; + + var case_cond: ?Id = null; + + for (case.items) |item| { + const item_tmp: Temporary = try cg.temporary(item); + const eq = try (try cg.cmp(.eq, cond_tmp, item_tmp)).materialize(cg); + case_cond = if (case_cond) |prev| blk: { + const combined = cg.module.allocId(); + try cg.body.emitRaw(gpa, .OpLogicalOr, 4); + cg.body.writeOperand(Id, bool_ty_id); + cg.body.writeOperand(Id, combined); + cg.body.writeOperand(Id, prev); + cg.body.writeOperand(Id, eq); + break :blk combined; + } else eq; + } + + for (case.ranges) |range| { + const lo_tmp: Temporary = try cg.temporary(range[0]); + const hi_tmp: Temporary = try cg.temporary(range[1]); + const ge = try (try cg.cmp(.gte, cond_tmp, lo_tmp)).materialize(cg); + const le = try (try cg.cmp(.lte, cond_tmp, hi_tmp)).materialize(cg); + const in_range = cg.module.allocId(); + try cg.body.emitRaw(gpa, .OpLogicalAnd, 4); + cg.body.writeOperand(Id, bool_ty_id); + cg.body.writeOperand(Id, in_range); + cg.body.writeOperand(Id, ge); + cg.body.writeOperand(Id, le); + case_cond = if (case_cond) |prev| blk: { + const combined = cg.module.allocId(); + try cg.body.emitRaw(gpa, .OpLogicalOr, 4); + cg.body.writeOperand(Id, bool_ty_id); + cg.body.writeOperand(Id, combined); + cg.body.writeOperand(Id, prev); + cg.body.writeOperand(Id, in_range); + break :blk combined; + } else in_range; + } + + const case_label = case_labels.at(case.idx); + const is_last = case.idx == last_range_case.?; + const next_check = if (is_last) default_label else cg.module.allocId(); + + try cg.body.emit(gpa, .OpSelectionMerge, .{ + .merge_block = next_check, + .selection_control = .{}, + }); + + try cg.body.emit(gpa, .OpBranchConditional, .{ + .condition = case_cond.?, + .true_label = case_label, + .false_label = next_check, + }); + + if (!is_last) { + try cg.beginSpvBlock(next_check); + } + } + } + + { + var it = switch_br.iterateCases(); + while (it.next()) |case| { + const label = case_labels.at(case.idx); + try cg.beginSpvBlock(label); + + const next_block = try cg.genStructuredBody(.selection, case.body); + incoming_structured_blocks.appendAssumeCapacity(.{ + .src_label = cg.block_label, + .next_block = next_block, + }); + try cg.body.emit(gpa, .OpBranch, .{ .target_label = switch_merge }); + } + } + + const else_body = blk: { + var it_else = switch_br.iterateCases(); + while (it_else.next()) |_| {} + break :blk it_else.elseBody(); + }; + try cg.beginSpvBlock(default_label); + if (else_body.len != 0) { + const next_block = try cg.genStructuredBody(.selection, else_body); + incoming_structured_blocks.appendAssumeCapacity(.{ + .src_label = cg.block_label, + .next_block = next_block, + }); + try cg.body.emit(gpa, .OpBranch, .{ .target_label = switch_merge }); + } else { + try cg.body.emit(gpa, .OpUnreachable, {}); + } + + try cg.beginSpvBlock(switch_merge); + const next_block = try cg.structuredNextBlock(incoming_structured_blocks.items); + + const is_dispatch = cg.module.allocId(); + const bool_ty_id = try cg.resolveType(.bool, .direct); + try cg.body.emit(gpa, .OpIEqual, .{ + .id_result_type = bool_ty_id, + .id_result = is_dispatch, + .operand_1 = next_block, + .operand_2 = dispatch_sentinel, + }); + + const dispatch_check_merge = cg.module.allocId(); + try cg.body.emit(gpa, .OpSelectionMerge, .{ + .merge_block = dispatch_check_merge, + .selection_control = .{}, + }); + const exit_block = cg.module.allocId(); + try cg.body.emit(gpa, .OpBranchConditional, .{ + .condition = is_dispatch, + .true_label = dispatch_check_merge, + .false_label = exit_block, + }); + + try cg.beginSpvBlock(exit_block); + try cg.body.emit(gpa, .OpBranch, .{ .target_label = loop_merge }); + + try cg.beginSpvBlock(dispatch_check_merge); + try cg.body.emit(gpa, .OpBranch, .{ .target_label = continue_label }); + + try cg.beginSpvBlock(continue_label); + try cg.body.emit(gpa, .OpBranch, .{ .target_label = header_label }); + + try cg.beginSpvBlock(loop_merge); + try cg.structuredBreak(next_block); +} + +fn airSwitchDispatch(cg: *CodeGen, inst: Air.Inst.Index) !void { + const br = cg.air.instructions.items(.data)[@intFromEnum(inst)].br; + const loop_switch = cg.loop_switches.get(br.block_inst).?; + const cond_ty = cg.typeOf(br.operand); + const operand = try cg.resolve(br.operand); + const operand_indirect = try cg.convertToIndirect(cond_ty, operand); + + try cg.store(cond_ty, loop_switch.cond_var, operand_indirect, .{}); + try cg.structuredBreak(loop_switch.continue_label); } fn airUnreach(cg: *CodeGen) !void { @@ -7743,9 +8035,19 @@ fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier) // temporary params buffer. const arg_ty = cg.typeOf(arg); if (!arg_ty.hasRuntimeBits(zcu)) continue; - const arg_id = try cg.resolve(arg); - params[n_params] = arg_id; + if (arg_ty.zigTypeTag(zcu) == .pointer and !arg_ty.isSlice(zcu) and + !arg_ty.childType(zcu).hasRuntimeBits(zcu)) + { + // in logical addressing, pointer arguments to function calls + // must be memory object declarations (OpVariable). for pointers to + // zero-sized types, the source value may not be a variable, so just + // allocate a dummy one. + const child_ty_id = try cg.resolveType(arg_ty.childType(zcu), .indirect); + params[n_params] = try cg.alloc(child_ty_id, null); + } else { + params[n_params] = try cg.resolve(arg); + } n_params += 1; } diff --git a/src/codegen/spirv/Module.zig b/src/codegen/spirv/Module.zig @@ -773,6 +773,13 @@ pub fn structType( return result_id; } +pub fn structFields(module: *const Module, struct_ty_id: Id) ?[]const Id { + for (module.cache.struct_types.keys(), module.cache.struct_types.values()) |key, val| { + if (val == struct_ty_id) return key.fields; + } + return null; +} + pub fn functionType(module: *Module, return_ty_id: Id, param_type_ids: []const Id) !Id { if (module.cache.fn_types.get(.{ .return_ty = return_ty_id, diff --git a/test/behavior/align.zig b/test/behavior/align.zig @@ -101,8 +101,6 @@ fn addUnaligned(a: *align(1) const u32, b: *align(1) const u32) u32 { } test "@alignCast pointers" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - var x: u32 align(4) = 1; expectsOnly1(&x); try expect(x == 2); @@ -223,7 +221,6 @@ test "alignment and size of structs with 128-bit fields" { test "implicitly decreasing slice alignment" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const a: u32 align(4) = 3; const b: u32 align(8) = 4; try expect(addUnalignedSlice(@as(*const [1]u32, &a)[0..], @as(*const [1]u32, &b)[0..]) == 7); @@ -265,8 +262,6 @@ test "return error union with 128-bit integer" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - try expect(3 == try give()); } fn give() anyerror!u128 { @@ -278,7 +273,6 @@ test "page aligned array on stack" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - // Large alignment value to make it hard to accidentally pass. var array align(0x1000) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 }; var number1: u8 align(16) = 42; diff --git a/test/behavior/array.zig b/test/behavior/array.zig @@ -22,8 +22,6 @@ test "array to slice" { test "arrays" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - var array: [5]u32 = undefined; var i: u32 = 0; @@ -51,7 +49,6 @@ test "runtime array concat with comptime slice" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - var a: [1]u8 = .{1}; const b = (comptime @as([]const u8, &.{0})) ++ &a; const c = &a ++ (comptime @as([]const u8, &.{0})); @@ -1072,8 +1069,6 @@ test "initialize many-pointer with reference to empty array initializer" { } test "initialize sentinel-terminated slice with reference to empty array initializer" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const a: [:0]const u8 = &.{}; comptime assert(a.len == 0); comptime assert(a[0] == 0); @@ -1081,7 +1076,6 @@ test "initialize sentinel-terminated slice with reference to empty array initial test "initialize sentinel-terminated many-pointer with reference to empty array initializer" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const a: [*:0]const u8 = &.{}; comptime assert(a[0] == 0); } diff --git a/test/behavior/asm.zig b/test/behavior/asm.zig @@ -82,7 +82,6 @@ test "sized integer/float in asm input" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig @@ -302,7 +302,7 @@ test "compile time global reinterpret" { } test "cast undefined" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + // if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO const array: [100]u8 = undefined; diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig @@ -23,8 +23,6 @@ test "@bitCast iX -> uX (8, 16, 128)" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const bit_values = [_]usize{ 8, 16, 128 }; inline for (bit_values) |bits| { @@ -37,9 +35,6 @@ test "@bitCast iX -> uX exotic integers" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 }; inline for (bit_values) |bits| { @@ -82,7 +77,6 @@ test "bitcast uX to bytes" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 }; inline for (bit_values) |bits| { diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig @@ -103,11 +103,6 @@ test "comptime_int @floatFromInt" { } test "@floatFromInt" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - const S = struct { fn doTheTest() !void { try testIntToFloat(-2); @@ -133,13 +128,9 @@ fn testIntFromFloat(comptime F: type, f: F, comptime I: type, i: I) !void { test "@intFromFloat > 128 bits" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; - try testIntFromFloat(f16, 1024, u140, 1024); try testIntFromFloat(f16, -1024, i140, -1024); - try testIntFromFloat(f32, 1 << 24, u140, 1 << 24); try testIntFromFloat(f32, -1 << 24, i140, -1 << 24); @@ -161,13 +152,10 @@ test "@floatFromInt > 128 bits" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; try testFloatFromInt(u140, 1024, f16, 1024); - try testFloatFromInt(i140, -1024, f16, -1024); try testFloatFromInt(u140, 1 << 24, f32, 1 << 24); - try testFloatFromInt(i140, -1 << 24, f32, -1 << 24); try testFloatFromInt(u200, 1 << 53, f64, 1 << 53); try testFloatFromInt(i200, -1 << 53, f64, -1 << 53); @@ -282,8 +270,6 @@ test "type coercion from int to float" { test "@intFromFloat" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - try testIntFromFloats(); try comptime testIntFromFloats(); } @@ -347,7 +333,6 @@ fn expectTruncCast(comptime F: type, f: F, comptime I: type, i: I) !void { test "implicitly cast indirect pointer to maybe-indirect pointer" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { const Self = @This(); x: u8, @@ -431,11 +416,9 @@ test "implicit cast from *[N]T to [*c]T" { var y: [*c]u16 = &x; try expect(std.mem.eql(u16, x[0..4], y[0..4])); - x[0] = 8; y[3] = 6; try expect(std.mem.eql(u16, x[0..4], y[0..4])); } - test "*usize to *void" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -510,7 +493,6 @@ test "array coercion to undefined at runtime" { var array = [4]u8{ 3, 4, 5, 6 }; var undefined_val = [4]u8{ 0xAA, 0xAA, 0xAA, 0xAA }; - try expect(std.mem.eql(u8, &array, &array)); array = undefined; try expect(std.mem.eql(u8, &array, &undefined_val)); diff --git a/test/behavior/cast_int.zig b/test/behavior/cast_int.zig @@ -8,9 +8,6 @@ const minInt = std.math.minInt; test "@intCast i32 to u7" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - var x: u128 = maxInt(u128); var y: i32 = 120; _ = .{ &x, &y }; @@ -145,9 +142,7 @@ fn testIntCast(comptime S: type, a: S, comptime D: type, expected: D) !void { test "@intCast <= 64 bits" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - try testIntCast(i32, minInt(i32), i64, minInt(i32)); - try testIntCast(i32, maxInt(i32), i64, maxInt(i32)); try testIntCast(u32, maxInt(u32), u64, maxInt(u32)); try testIntCast(u32, maxInt(i32), i64, maxInt(i32)); try testIntCast(u32, maxInt(u32), i64, maxInt(u32)); @@ -174,7 +169,6 @@ test "@intCast > 128 bits" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; try testIntCast(u8, 123, u140, 123); - try testIntCast(u64, 1 << 63, u140, 1 << 63); try testIntCast(u127, maxInt(u127), u140, maxInt(u127)); try testIntCast(i8, -42, i140, -42); try testIntCast(i64, minInt(i64), i140, minInt(i64)); diff --git a/test/behavior/comptime_memory.zig b/test/behavior/comptime_memory.zig @@ -431,8 +431,6 @@ test "type pun @ptrFromInt" { } test "type pun null pointer-like optional" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const p: ?*u8 = null; // note that expectEqual hides the bug try testing.expect(@as(*const ?*i8, @ptrCast(&p)).* == null); @@ -518,7 +516,6 @@ fn fieldPtrTest() u32 { } test "pointer in aggregate field can mutate comptime state" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - try comptime std.testing.expect(fieldPtrTest() == 2); } diff --git a/test/behavior/defer.zig b/test/behavior/defer.zig @@ -5,8 +5,6 @@ const expectEqual = std.testing.expectEqual; const expectError = std.testing.expectError; test "break and continue inside loop inside defer expression" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - testBreakContInDefer(10); comptime testBreakContInDefer(10); } @@ -111,7 +109,6 @@ test "mixing normal and error defers" { test "simple else prong doesn't emit an error for unreachable else prong" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { fn foo() error{Foo}!void { return error.Foo; diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig @@ -931,9 +931,7 @@ test "constant enum initialization with differing sizes" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - try test3_1(test3_foo); - try test3_2(test3_bar); } const Test3Foo = union(enum) { One: void, @@ -975,7 +973,6 @@ test "@tagName" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three")); comptime assert(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three")); } @@ -990,9 +987,7 @@ test "@tagName non-exhaustive enum" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B")); comptime assert(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B")); } const NonExhaustive = enum(u8) { A, B, _ }; @@ -1034,7 +1029,6 @@ test "@tagName on enum literals" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; try expect(mem.eql(u8, @tagName(.FooBar), "FooBar")); - comptime assert(mem.eql(u8, @tagName(.FooBar), "FooBar")); } test "tag name with signed enum values" { diff --git a/test/behavior/error.zig b/test/behavior/error.zig @@ -145,19 +145,12 @@ test "implicit cast to optional to error union to return result loc" { } test "fn returning empty error set can be passed as fn returning any error" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - - entry(); - comptime entry(); } test "fn returning empty error set can be passed as fn returning any error - pointer" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - entryPtr(); - comptime entryPtr(); } - fn entry() void { foo2(bar2); } @@ -369,10 +362,8 @@ test "error: Infer error set from literals" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; _ = nullLiteral("n") catch |err| handleErrors(err); - _ = floatLiteral("n") catch |err| handleErrors(err); _ = intLiteral("n") catch |err| handleErrors(err); _ = comptime nullLiteral("n") catch |err| handleErrors(err); - _ = comptime floatLiteral("n") catch |err| handleErrors(err); _ = comptime intLiteral("n") catch |err| handleErrors(err); } @@ -511,7 +502,6 @@ test "function pointer with return type that is error union with payload which i const Foo = struct { fun: *const fn (a: i32) (anyerror!*Foo), }; - const Err = error{UnspecifiedErr}; fn bar(a: i32) anyerror!*Foo { @@ -699,8 +689,6 @@ test "coerce error set to the current inferred error set" { test "error union payload is properly aligned" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const S = struct { a: u128, @@ -758,7 +746,6 @@ test "pointer to error union payload" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; var err_union: anyerror!u8 = 15; diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig @@ -134,9 +134,6 @@ test "cmp f32" { } test "cmp f64" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - try testCmp(f64); try comptime testCmp(f64); } @@ -146,7 +143,6 @@ test "cmp f128" { if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - try testCmp(f128); try comptime testCmp(f128); } @@ -154,10 +150,7 @@ test "cmp f80/c_longdouble" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - try testCmp(f80); - try comptime testCmp(f80); try testCmp(c_longdouble); try comptime testCmp(c_longdouble); } @@ -232,7 +225,6 @@ test "vector cmp f32" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest; diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig @@ -292,9 +292,6 @@ fn voidFun(a: i32, b: void, c: i32, d: void) !void { test "call function with empty string" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - - acceptsString(""); } fn acceptsString(foo: []u8) void { @@ -305,9 +302,7 @@ test "function pointers" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const fns = [_]*const @TypeOf(fn1){ - &fn1, &fn2, &fn3, &fn4, @@ -445,7 +440,6 @@ test "method call with optional and error union first param" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { - x: i32 = 1234, fn opt(s: ?@This()) !void { try expect(s.?.x == 1234); diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig @@ -439,8 +439,6 @@ test "return type of generic function is function pointer" { } test "coerced function body has inequal value with its uncoerced body" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { const A = B(i32, c); fn c() !i32 { @@ -488,8 +486,6 @@ test "union in struct captures argument" { test "function argument tuple used as struct field" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { fn DeleagateWithContext(comptime Function: type) type { const ArgArgs = std.meta.ArgsTuple(Function); diff --git a/test/behavior/inline_switch.zig b/test/behavior/inline_switch.zig @@ -34,8 +34,6 @@ test "inline prong ranges" { const E = enum { a, b, c, d }; test "inline switch enums" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - var x: E = .a; _ = &x; switch (x) { @@ -49,7 +47,6 @@ test "inline switch unions" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - var x: U = .a; _ = &x; switch (x) { @@ -74,8 +71,6 @@ test "inline switch unions" { test "inline else bool" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - var a = true; _ = &a; switch (a) { @@ -87,7 +82,6 @@ test "inline else bool" { test "inline else error" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const Err = error{ a, b, c }; var a = Err.a; _ = &a; diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig @@ -304,8 +304,6 @@ test "@min/@max notices bounds from vector types when element of comptime-known } test "@min/@max of signed and unsigned runtime integers" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - var x: i32 = -1; var y: u31 = 1; _ = .{ &x, &y }; @@ -352,7 +350,6 @@ test "@min/@max with runtime signed and unsigned integers of same size" { test "@min/@max with runtime vectors of signed and unsigned integers of same size" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; diff --git a/test/behavior/memcpy.zig b/test/behavior/memcpy.zig @@ -168,7 +168,6 @@ test "@memcpy with sentinel" { } test "@memcpy no sentinel source into sentinel destination" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { fn doTheTest() void { diff --git a/test/behavior/merge_error_sets.zig b/test/behavior/merge_error_sets.zig @@ -13,7 +13,6 @@ fn foo() C!void { test "merge error sets" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (foo()) { @panic("unexpected"); diff --git a/test/behavior/muladd.zig b/test/behavior/muladd.zig @@ -34,7 +34,6 @@ test "@mulAdd f16" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try comptime testMulAdd16(); - try testMulAdd16(); } fn testMulAdd16() !void { @@ -49,9 +48,7 @@ test "@mulAdd f80" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - try comptime testMulAdd80(); try testMulAdd80(); } diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig @@ -338,8 +338,6 @@ test "coerce an anon struct literal to optional struct" { test "0-bit child type coerced to optional return ptr result location" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { fn doTheTest() !void { var y = Foo{}; @@ -365,7 +363,6 @@ test "0-bit child type coerced to optional" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { fn doTheTest() !void { var it: Foo = .{ @@ -514,8 +511,6 @@ test "mutable optional of noreturn" { } test "orelse on C pointer" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - // TODO https://github.com/ziglang/zig/issues/6597 const foo: [*c]const u8 = "hey"; const d = foo orelse @compileError("bad"); @@ -527,7 +522,6 @@ test "alignment of wrapping an optional payload" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const S = struct { const I = extern struct { x: i128 }; diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig @@ -227,9 +227,6 @@ test "nested packed structs" { test "regular in irregular packed struct" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - const Irregular = packed struct { bar: Regular = Regular{}, _: u24 = 0, @@ -249,9 +246,7 @@ test "nested packed struct unaligned" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S1 = packed struct { - a: u4, b: u4, c: u8, }; @@ -408,7 +403,6 @@ test "nested packed struct field pointers" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // ubsan unaligned pointer access if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO - const S2 = packed struct { base: u8, p0: packed struct { diff --git a/test/behavior/pointers.zig b/test/behavior/pointers.zig @@ -136,8 +136,6 @@ test "implicit cast single item pointer to C pointer and back" { } test "initialize const optional C pointer to null" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const a: ?[*c]i32 = null; try expect(a == null); comptime assert(a == null); @@ -146,7 +144,6 @@ test "initialize const optional C pointer to null" { test "assigning integer to C pointer" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - var x: i32 = 0; var y: i32 = 1; var ptr: [*c]u8 = 0; @@ -645,8 +642,6 @@ test "result type preserved through multiple references" { } test "result type found through optional pointer" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const ptr1: ?*const u32 = &@intCast(123); const ptr2: ?[]const u8 = &.{ @intCast(123), @truncate(0xABCD) }; try expect(ptr1.?.* == 123); @@ -700,7 +695,6 @@ fn constant() !void { test "pointer-to-array constness for zero-size elements, var" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - try mutable(); try comptime mutable(); } diff --git a/test/behavior/shuffle.zig b/test/behavior/shuffle.zig @@ -54,8 +54,6 @@ test "@shuffle int strange sizes" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - try comptime testShuffle(2, 2, 2); try testShuffle(2, 2, 2); try comptime testShuffle(4, 4, 4); @@ -136,7 +134,6 @@ test "@shuffle bool 1" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { fn doTheTest() !void { var x: @Vector(4, bool) = [4]bool{ false, true, false, true }; diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig @@ -211,8 +211,6 @@ test "@sizeOf comparison against zero" { } test "hardcoded address in typeof expression" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { fn func() @TypeOf(@as(*[]u8, @ptrFromInt(0x10)).*[0]) { return 0; @@ -301,7 +299,6 @@ test "lazy abi size used in comparison" { test "peer type resolution with @TypeOf doesn't trigger dependency loop check" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const T = struct { next: @TypeOf(null, @as(*const @This(), undefined)), }; diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig @@ -173,8 +173,6 @@ test "pass a slice of types to a function" { test "generic malloc free" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const a = memAlloc(u8, 10) catch unreachable; memFree(u8, a); } @@ -188,7 +186,6 @@ fn memFree(comptime T: type, memory: []T) void { test "slice of hardcoded address to pointer" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { fn doTheTest() !void { const pointer = @as([*]u8, @ptrFromInt(0x04))[0..2]; @@ -212,8 +209,6 @@ test "comptime slice of pointer preserves comptime var" { } test "comptime pointer cast array and then slice" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 }; const ptrA: [*]const u8 = @as([*]const u8, @ptrCast(&array)); @@ -229,7 +224,6 @@ test "comptime pointer cast array and then slice" { test "slicing zero length array" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const s1 = ""[0..]; const s2 = ([_]u32{})[0..]; try expect(s1.len == 0); diff --git a/test/behavior/string_literals.zig b/test/behavior/string_literals.zig @@ -84,8 +84,6 @@ test "string literal pointer sentinel" { } test "sentinel slice of string literal" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const string = "Hello!\x00World!"; try std.testing.expect(@TypeOf(string) == *const [13:0]u8); @@ -103,7 +101,6 @@ test "Peer type resolution with string literals and unknown length u8 pointers" test "including the sentinel when dereferencing a string literal" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - var var_str = "abc"; const var_derefed = var_str[0 .. var_str.len + 1].*; diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig @@ -342,7 +342,6 @@ test "self-referencing struct via array member" { } test "empty struct method call" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const es = EmptyStruct{}; try expect(es.method() == 1234); } @@ -379,7 +378,6 @@ const APackedStruct = packed struct { test "packed struct" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; var foo = APackedStruct{ @@ -448,8 +446,6 @@ test "runtime struct initialization of bitfield" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const s1 = Nibbles{ .x = x1, @@ -489,7 +485,6 @@ test "packed struct fields are ordered from LSB to MSB" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - var all: u64 = 0x7765443322221111; var bytes: [8]u8 align(@alignOf(Bitfields)) = undefined; @memcpy(bytes[0..8], @as([*]u8, @ptrCast(&all))); @@ -1776,7 +1771,6 @@ test "circular dependency through pointer field of a struct" { } test "field calls do not force struct field init resolution" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { x: u32 = blk: { _ = @TypeOf(make().dummyFn()); // runtime field call - S not fully resolved - dummyFn call should not force field init resolution diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig @@ -9,7 +9,6 @@ const maxInt = std.math.maxInt; test "switch with numbers" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; try testSwitchWithNumbers(13); } @@ -25,7 +24,6 @@ fn testSwitchWithNumbers(x: u32) !void { test "switch with all ranges" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO try expect(testSwitchWithAllRanges(50, 3) == 1); try expect(testSwitchWithAllRanges(101, 0) == 2); @@ -214,8 +212,6 @@ test "undefined.u0" { test "switch with disjoint range" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO - var q: u8 = 0; _ = &q; switch (q) { @@ -226,8 +222,6 @@ test "switch with disjoint range" { } test "switch variable for range and multiple prongs" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO - const S = struct { fn doTheTest() !void { try doTheSwitch(16); diff --git a/test/behavior/switch_loop.zig b/test/behavior/switch_loop.zig @@ -7,7 +7,6 @@ test "simple switch loop" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -31,7 +30,6 @@ test "switch loop with ranges" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO const S = struct { fn doTheTest() !void { @@ -52,7 +50,6 @@ test "switch loop on enum" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO const S = struct { const E = enum { a, b, c }; @@ -76,7 +73,6 @@ test "switch loop with error set" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO const S = struct { const E = error{ Foo, Bar, Baz }; @@ -252,7 +248,6 @@ test "switch loop on non-exhaustive enum" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO const S = struct { const E = enum(u8) { a, b, c, _ }; @@ -275,8 +270,6 @@ test "switch loop on non-exhaustive enum" { test "switch loop with discarded tag capture" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { const U = union(enum) { a: u32, @@ -301,7 +294,6 @@ test "switch loop with discarded tag capture" { test "switch loop with single catch-all prong" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { const E = enum { a, b, c }; const U = union(E) { a: u32, b: u16, c: u8 }; @@ -469,8 +461,6 @@ test "switch loop with tag capture" { } test "switch loop for error handling" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const Error = error{ MyError, MyOtherError }; const S = struct { fn doTheTest() !void { @@ -516,7 +506,6 @@ test "switch loop for error handling" { test "switch loop with packed structs" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const P = packed struct { a: u7, b: u20, diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig @@ -105,8 +105,6 @@ test "tuple initializer for var" { test "array-like initializer for tuple types" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const T = @Tuple(&.{ i32, u8 }); const S = struct { fn doTheTest() !void { @@ -172,7 +170,6 @@ test "fieldParentPtr of tuple" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - var x: u32 = 0; _ = &x; const tuple = .{ x, x }; @@ -217,8 +214,6 @@ test "initializing tuple with mixed comptime-runtime fields" { } test "initializing anon struct with mixed comptime-runtime fields" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - var x: u32 = 15; _ = &x; const T = @TypeOf(.{ .foo = @as(i32, -1234), .bar = x }); @@ -231,7 +226,6 @@ test "tuple in tuple passed to generic function" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { fn pair(x: f32, y: f32) @Tuple(&.{ f32, f32 }) { return .{ x, y }; diff --git a/test/behavior/union.zig b/test/behavior/union.zig @@ -885,8 +885,6 @@ test "union no tag with struct member" { } test "extern union doesn't trigger field check at comptime" { - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const U = extern union { x: u32, y: u8, @@ -901,7 +899,6 @@ test "anonymous union literal syntax" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { const Number = union { int: i32, @@ -1216,8 +1213,6 @@ test "return an extern union from C calling convention" { test "noreturn field in union" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const U = union(enum) { a: u32, b: noreturn, @@ -1269,7 +1264,6 @@ test "@unionInit uses tag value instead of field index" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const E = enum(u8) { b = 255, a = 3, diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig @@ -379,8 +379,6 @@ test "vector @splat" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { fn testForT(comptime N: comptime_int, v: anytype) !void { const T = @TypeOf(v); @@ -417,7 +415,6 @@ test "vector @splat" { test "load vector elements via comptime index" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO const S = struct { @@ -533,8 +530,6 @@ test "vector division operators" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - const S = struct { fn doTheTestDiv(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void { const is_signed_int = switch (@typeInfo(T)) { @@ -622,7 +617,6 @@ test "vector division operators" { test "vector bitwise not operator" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;