From 79f7481575005f9f63b5b3be8dd89b92b11b9c77 Mon Sep 17 00:00:00 2001 From: Robin Voetter Date: Sat, 26 Aug 2023 11:32:37 +0200 Subject: spirv: disable failing tests --- test/behavior/array.zig | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'test/behavior/array.zig') diff --git a/test/behavior/array.zig b/test/behavior/array.zig index 523855161a..b252265c5b 100644 --- a/test/behavior/array.zig +++ b/test/behavior/array.zig @@ -763,6 +763,8 @@ test "slicing array of zero-sized values" { } test "array init with no result pointer sets field result types" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + const S = struct { // A function parameter has a result type, but no result pointer. fn f(arr: [1]u32) u32 { @@ -777,6 +779,8 @@ test "array init with no result pointer sets field result types" { } test "runtime side-effects in comptime-known array init" { + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; + var side_effects: u4 = 0; const init = [4]u4{ blk: { -- cgit v1.2.3 From 5d844faf7c5c30555664b4161e5f9a903daaf562 Mon Sep 17 00:00:00 2001 From: Robin Voetter Date: Mon, 18 Sep 2023 20:28:31 +0200 Subject: spirv: air array_elem_val using hack SPIR-V doesn't support true element indexing, so we probably need to switch over to isByRef like in llvm for this to work properly. Currently a temporary is used, which at least seems to work. --- src/codegen/spirv.zig | 35 +++++++++++++++++++++++++++++++++++ test/behavior/array.zig | 11 ----------- 2 files changed, 35 insertions(+), 11 deletions(-) (limited to 'test/behavior/array.zig') diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig index e05c8142db..e4ce3e5f3f 100644 --- a/src/codegen/spirv.zig +++ b/src/codegen/spirv.zig @@ -1694,6 +1694,7 @@ pub const DeclGen = struct { .slice_elem_val => try self.airSliceElemVal(inst), .ptr_elem_ptr => try self.airPtrElemPtr(inst), .ptr_elem_val => try self.airPtrElemVal(inst), + .array_elem_val => try self.airArrayElemVal(inst), .set_union_tag => return try self.airSetUnionTag(inst), .get_union_tag => try self.airGetUnionTag(inst), @@ -2567,6 +2568,40 @@ pub const DeclGen = struct { return try self.ptrElemPtr(ptr_ty, ptr_id, index_id); } + fn airArrayElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef { + if (self.liveness.isUnused(inst)) return null; + + const mod = self.module; + const bin_op = self.air.instructions.items(.data)[inst].bin_op; + const array_ty = self.typeOf(bin_op.lhs); + const array_ty_ref = try self.resolveType(array_ty, .direct); + const elem_ty = array_ty.childType(mod); + const elem_ty_ref = try self.resolveType(elem_ty, .indirect); + const array_id = try self.resolve(bin_op.lhs); + const index_id = try self.resolve(bin_op.rhs); + + // SPIR-V doesn't have an array indexing function for some damn reason. + // For now, just generate a temporary and use that. + // TODO: This backend probably also should use isByRef from llvm... + + const array_ptr_ty_ref = try self.spv.ptrType(array_ty_ref, .Function); + const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, .Function); + + const tmp_id = self.spv.allocId(); + try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{ + .id_result_type = self.typeId(array_ptr_ty_ref), + .id_result = tmp_id, + .storage_class = .Function, + }); + try self.func.body.emit(self.spv.gpa, .OpStore, .{ + .pointer = tmp_id, + .object = array_id, + }); + + const elem_ptr_id = try self.accessChainId(elem_ptr_ty_ref, tmp_id, &.{index_id}); + return try self.load(elem_ty, elem_ptr_id, false); + } + fn airPtrElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef { if (self.liveness.isUnused(inst)) return null; diff --git a/test/behavior/array.zig b/test/behavior/array.zig index b252265c5b..7edef09578 100644 --- a/test/behavior/array.zig +++ b/test/behavior/array.zig @@ -21,7 +21,6 @@ test "arrays" { 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_spirv64) return error.SkipZigTest; var array: [5]u32 = undefined; @@ -141,7 +140,6 @@ test "array literal with specified size" { 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_spirv64) return error.SkipZigTest; var array = [2]u8{ 1, 2 }; try expect(array[0] == 1); @@ -201,7 +199,6 @@ test "nested arrays of strings" { 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_spirv64) return error.SkipZigTest; const array_of_strings = [_][]const u8{ "hello", "this", "is", "my", "thing" }; for (array_of_strings, 0..) |s, i| { @@ -288,7 +285,6 @@ test "anonymous list literal syntax" { 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -479,7 +475,6 @@ test "anonymous literal in array" { 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_spirv64) return error.SkipZigTest; const S = struct { const Foo = struct { @@ -504,7 +499,6 @@ test "anonymous literal in array" { test "access the null element of a null terminated array" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -522,7 +516,6 @@ test "type deduction for array subscript expression" { 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -620,7 +613,6 @@ test "type coercion of pointer to anon struct literal to pointer to array" { 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_spirv64) return error.SkipZigTest; const S = struct { const U = union { @@ -703,7 +695,6 @@ test "array of array agregate init" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a = [1]u32{11} ** 10; var b = [1][10]u32{a} ** 2; @@ -763,8 +754,6 @@ test "slicing array of zero-sized values" { } test "array init with no result pointer sets field result types" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const S = struct { // A function parameter has a result type, but no result pointer. fn f(arr: [1]u32) u32 { -- cgit v1.2.3 From b845c9d5326bc83691edcb483ac44793b88afe75 Mon Sep 17 00:00:00 2001 From: Robin Voetter Date: Mon, 18 Sep 2023 22:39:44 +0200 Subject: spirv: generate module initializer --- src/codegen/spirv.zig | 5 +- src/codegen/spirv/Module.zig | 116 +++++++++++++++++++++++++++++++++++-------- test/behavior/array.zig | 7 --- test/behavior/basic.zig | 8 +-- 4 files changed, 97 insertions(+), 39 deletions(-) (limited to 'test/behavior/array.zig') diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig index e4ce3e5f3f..9d44b8eb8f 100644 --- a/src/codegen/spirv.zig +++ b/src/codegen/spirv.zig @@ -1494,7 +1494,6 @@ pub const DeclGen = struct { .id_result = decl_id, .storage_class = actual_storage_class, }); - self.spv.globalPtr(spv_decl_index).?.result_id = decl_id; // Now emit the instructions that initialize the variable. const initializer_id = self.spv.allocId(); @@ -1517,14 +1516,12 @@ pub const DeclGen = struct { }); // TODO: We should be able to get rid of this by now... - self.spv.endGlobal(spv_decl_index, begin); + self.spv.endGlobal(spv_decl_index, begin, decl_id, initializer_id); try self.func.body.emit(self.spv.gpa, .OpReturn, {}); try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {}); try self.spv.addFunction(spv_decl_index, self.func); - try self.spv.initializers.append(self.spv.gpa, initializer_id); - const fqn = ip.stringToSlice(try decl.getFullyQualifiedName(self.module)); try self.spv.sections.debug_names.emit(self.gpa, .OpName, .{ .target = decl_id, diff --git a/src/codegen/spirv/Module.zig b/src/codegen/spirv/Module.zig index cafc2f0662..b6ed381360 100644 --- a/src/codegen/spirv/Module.zig +++ b/src/codegen/spirv/Module.zig @@ -94,6 +94,8 @@ pub const Global = struct { begin_inst: u32, /// The past-end offset into `self.flobals.section`. end_inst: u32, + /// The result-id of the function that initializes this value. + initializer_id: IdRef, }; /// This models a kernel entry point. @@ -174,9 +176,6 @@ globals: struct { section: Section = .{}, } = .{}, -/// The function IDs of global variable initializers -initializers: std.ArrayListUnmanaged(IdRef) = .{}, - pub fn init(gpa: Allocator, arena: Allocator) Module { return .{ .gpa = gpa, @@ -205,8 +204,6 @@ pub fn deinit(self: *Module) void { self.globals.globals.deinit(self.gpa); self.globals.section.deinit(self.gpa); - self.initializers.deinit(self.gpa); - self.* = undefined; } @@ -289,6 +286,10 @@ fn addEntryPointDeps( const decl = self.declPtr(decl_index); const deps = self.decl_deps.items[decl.begin_dep..decl.end_dep]; + if (seen.isSet(@intFromEnum(decl_index))) { + return; + } + seen.set(@intFromEnum(decl_index)); if (self.globalPtr(decl_index)) |global| { @@ -296,9 +297,7 @@ fn addEntryPointDeps( } for (deps) |dep| { - if (!seen.isSet(@intFromEnum(dep))) { - try self.addEntryPointDeps(dep, seen, interface); - } + try self.addEntryPointDeps(dep, seen, interface); } } @@ -330,20 +329,76 @@ fn entryPoints(self: *Module) !Section { return entry_points; } +/// Generate a function that calls all initialization functions, +/// in unspecified order (an order should not be required here). +/// It generated as follows: +/// %init = OpFunction %void None +/// foreach %initializer: +/// OpFunctionCall %initializer +/// OpReturn +/// OpFunctionEnd +fn initializer(self: *Module, entry_points: *Section) !Section { + var section = Section{}; + errdefer section.deinit(self.gpa); + + // const void_ty_ref = try self.resolveType(Type.void, .direct); + const void_ty_ref = try self.resolve(.void_type); + const void_ty_id = self.resultId(void_ty_ref); + const init_proto_ty_ref = try self.resolve(.{ .function_type = .{ + .return_type = void_ty_ref, + .parameters = &.{}, + } }); + + const init_id = self.allocId(); + try section.emit(self.gpa, .OpFunction, .{ + .id_result_type = void_ty_id, + .id_result = init_id, + .function_control = .{}, + .function_type = self.resultId(init_proto_ty_ref), + }); + try section.emit(self.gpa, .OpLabel, .{ + .id_result = self.allocId(), + }); + + var seen = try std.DynamicBitSetUnmanaged.initEmpty(self.gpa, self.decls.items.len); + defer seen.deinit(self.gpa); + + var interface = std.ArrayList(IdRef).init(self.gpa); + defer interface.deinit(); + + for (self.globals.globals.keys(), self.globals.globals.values()) |decl_index, global| { + try self.addEntryPointDeps(decl_index, &seen, &interface); + try section.emit(self.gpa, .OpFunctionCall, .{ + .id_result_type = void_ty_id, + .id_result = self.allocId(), + .function = global.initializer_id, + }); + } + + try section.emit(self.gpa, .OpReturn, {}); + try section.emit(self.gpa, .OpFunctionEnd, {}); + + try entry_points.emit(self.gpa, .OpEntryPoint, .{ + // TODO: Rusticl does not support this because its poorly defined. + // Do we need to generate a workaround here? + .execution_model = .Kernel, + .entry_point = init_id, + .name = "zig global initializer", + .interface = interface.items, + }); + + try self.sections.execution_modes.emit(self.gpa, .OpExecutionMode, .{ + .entry_point = init_id, + .mode = .Initializer, + }); + + return section; +} + /// Emit this module as a spir-v binary. pub fn flush(self: *Module, file: std.fs.File) !void { // See SPIR-V Spec section 2.3, "Physical Layout of a SPIR-V Module and Instruction" - const header = [_]Word{ - spec.magic_number, - // TODO: From cpu features - // Emit SPIR-V 1.4 for now. This is the highest version that Intel's CPU OpenCL supports. - (1 << 16) | (4 << 8), - 0, // TODO: Register Zig compiler magic number. - self.idBound(), - 0, // Schema (currently reserved for future use) - }; - // TODO: Perform topological sort on the globals. var globals = try self.orderGlobals(); defer globals.deinit(self.gpa); @@ -354,6 +409,19 @@ pub fn flush(self: *Module, file: std.fs.File) !void { var types_constants = try self.cache.materialize(self); defer types_constants.deinit(self.gpa); + var init_func = try self.initializer(&entry_points); + defer init_func.deinit(self.gpa); + + const header = [_]Word{ + spec.magic_number, + // TODO: From cpu features + // Emit SPIR-V 1.4 for now. This is the highest version that Intel's CPU OpenCL supports. + (1 << 16) | (4 << 8), + 0, // TODO: Register Zig compiler magic number. + self.idBound(), + 0, // Schema (currently reserved for future use) + }; + // Note: needs to be kept in order according to section 2.3! const buffers = &[_][]const Word{ &header, @@ -368,6 +436,7 @@ pub fn flush(self: *Module, file: std.fs.File) !void { self.sections.types_globals_constants.toWords(), globals.toWords(), self.sections.functions.toWords(), + init_func.toWords(), }; var iovc_buffers: [buffers.len]std.os.iovec_const = undefined; @@ -529,6 +598,7 @@ pub fn allocDecl(self: *Module, kind: DeclKind) !Decl.Index { .result_id = undefined, .begin_inst = undefined, .end_inst = undefined, + .initializer_id = undefined, }), } @@ -558,10 +628,14 @@ pub fn beginGlobal(self: *Module) u32 { return @as(u32, @intCast(self.globals.section.instructions.items.len)); } -pub fn endGlobal(self: *Module, global_index: Decl.Index, begin_inst: u32) void { +pub fn endGlobal(self: *Module, global_index: Decl.Index, begin_inst: u32, result_id: IdRef, initializer_id: IdRef) void { const global = self.globalPtr(global_index).?; - global.begin_inst = begin_inst; - global.end_inst = @as(u32, @intCast(self.globals.section.instructions.items.len)); + global.* = .{ + .result_id = result_id, + .begin_inst = begin_inst, + .end_inst = @intCast(self.globals.section.instructions.items.len), + .initializer_id = initializer_id, + }; } pub fn declareEntryPoint(self: *Module, decl_index: Decl.Index, name: []const u8) !void { diff --git a/test/behavior/array.zig b/test/behavior/array.zig index 7edef09578..6fa93b4657 100644 --- a/test/behavior/array.zig +++ b/test/behavior/array.zig @@ -48,7 +48,6 @@ fn getArrayLen(a: []const u32) usize { test "array concat with undefined" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -88,7 +87,6 @@ test "array concat with tuple" { test "array init with concat" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const a = 'a'; var i: [4]u8 = [2]u8{ a, 'b' } ++ [2]u8{ 'c', 'd' }; @@ -98,7 +96,6 @@ test "array init with concat" { test "array init with mult" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const a = 'a'; var i: [8]u8 = [2]u8{ a, 'b' } ** 4; @@ -241,7 +238,6 @@ fn plusOne(x: u32) u32 { test "single-item pointer to array indexing and slicing" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testSingleItemPtrArrayIndexSlice(); try comptime testSingleItemPtrArrayIndexSlice(); @@ -384,7 +380,6 @@ test "runtime initialize array elem and then implicit cast to slice" { test "array literal as argument to function" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn entry(two: i32) !void { @@ -413,7 +408,6 @@ test "double nested array to const slice cast in array literal" { 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_spirv64) return error.SkipZigTest; const S = struct { fn entry(two: i32) !void { @@ -651,7 +645,6 @@ test "tuple to array handles sentinel" { 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_spirv64) return error.SkipZigTest; const S = struct { const a = .{ 1, 2, 3 }; diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 57a579cfdb..9a75a8495d 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -330,7 +330,6 @@ const FnPtrWrapper = struct { test "const ptr from var variable" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var x: u64 = undefined; var y: u64 = undefined; @@ -581,7 +580,7 @@ test "comptime cast fn to ptr" { } test "equality compare fn ptrs" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // Test passes but should not + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a = &emptyFn; try expect(a == a); @@ -639,7 +638,6 @@ test "global constant is loaded with a runtime-known index" { test "multiline string literal is null terminated" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const s1 = \\one @@ -711,7 +709,6 @@ test "comptime manyptr concatenation" { 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_spirv64) return error.SkipZigTest; const s = "epic"; const actual = manyptrConcat(s); @@ -1027,7 +1024,6 @@ comptime { test "switch inside @as gets correct type" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a: u32 = 0; var b: [2]u32 = undefined; @@ -1136,8 +1132,6 @@ test "orelse coercion as function argument" { } test "runtime-known globals initialized with undefined" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const S = struct { var array: [10]u32 = [_]u32{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; var vp: [*]u32 = undefined; -- cgit v1.2.3 From 075584a4d74276119372994d895bca747b1f861f Mon Sep 17 00:00:00 2001 From: Robin Voetter Date: Sun, 17 Sep 2023 23:41:10 +0200 Subject: spirv: enable passing tests --- src/codegen/spirv.zig | 8 ++++---- test/behavior/alignof.zig | 2 -- test/behavior/array.zig | 5 ----- test/behavior/basic.zig | 1 - test/behavior/bugs/10138.zig | 1 - test/behavior/bugs/10970.zig | 1 - test/behavior/bugs/11100.zig | 2 -- test/behavior/bugs/11165.zig | 2 -- test/behavior/bugs/11816.zig | 1 - test/behavior/bugs/12025.zig | 2 -- test/behavior/bugs/12033.zig | 2 -- test/behavior/bugs/12043.zig | 2 -- test/behavior/bugs/12119.zig | 1 - test/behavior/bugs/12891.zig | 8 -------- test/behavior/bugs/12928.zig | 4 ---- test/behavior/bugs/12984.zig | 1 - test/behavior/bugs/13113.zig | 1 - test/behavior/bugs/13159.zig | 1 - test/behavior/bugs/13285.zig | 1 - test/behavior/bugs/14854.zig | 2 -- test/behavior/bugs/1500.zig | 2 -- test/behavior/bugs/15778.zig | 2 -- test/behavior/bugs/2622.zig | 1 - test/behavior/bugs/3779.zig | 2 -- test/behavior/bugs/4954.zig | 1 - test/behavior/bugs/5398.zig | 1 - test/behavior/bugs/6456.zig | 1 - test/behavior/bugs/656.zig | 1 - test/behavior/bugs/7047.zig | 2 -- test/behavior/bugs/7187.zig | 2 -- test/behavior/bugs/8277.zig | 2 -- test/behavior/bugs/828.zig | 1 - test/behavior/byval_arg_var.zig | 1 - test/behavior/call.zig | 1 - test/behavior/cast.zig | 35 ----------------------------------- test/behavior/cast_int.zig | 1 - test/behavior/defer.zig | 2 -- test/behavior/empty_union.zig | 3 --- test/behavior/enum.zig | 4 ---- test/behavior/error.zig | 1 - test/behavior/eval.zig | 35 ----------------------------------- test/behavior/floatop.zig | 3 --- test/behavior/fn.zig | 12 ------------ test/behavior/for.zig | 4 ---- test/behavior/generics.zig | 14 -------------- test/behavior/inline_switch.zig | 3 --- test/behavior/math.zig | 2 -- test/behavior/maximum_minimum.zig | 2 -- test/behavior/slice.zig | 1 - test/behavior/struct.zig | 14 -------------- test/behavior/switch.zig | 10 ---------- test/behavior/this.zig | 1 - test/behavior/try.zig | 2 -- test/behavior/tuple.zig | 3 --- test/behavior/type_info.zig | 5 ----- test/behavior/undefined.zig | 3 --- test/behavior/underscore.zig | 1 - test/behavior/union.zig | 3 --- test/behavior/vector.zig | 2 -- test/behavior/while.zig | 15 --------------- 60 files changed, 4 insertions(+), 245 deletions(-) (limited to 'test/behavior/array.zig') diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig index 11737943fe..45c081c51d 100644 --- a/src/codegen/spirv.zig +++ b/src/codegen/spirv.zig @@ -801,7 +801,7 @@ pub const DeclGen = struct { } } - fn constantPtr(self: *DeclGen, ptr_ty: Type, ptr_val: Value) !IdRef { + fn constantPtr(self: *DeclGen, ptr_ty: Type, ptr_val: Value) Error!IdRef { const result_ty_ref = try self.resolveType(ptr_ty, .direct); const mod = self.module; switch (mod.intern_pool.indexToKey(ptr_val.toIntern()).ptr.addr) { @@ -1692,9 +1692,9 @@ pub const DeclGen = struct { .bitcast => try self.airBitCast(inst), .intcast, .trunc => try self.airIntCast(inst), - .int_from_ptr => try self.airIntFromPtr(inst), - .float_from_int => try self.airFloatFromInt(inst), - .int_from_float => try self.airIntFromFloat(inst), + .int_from_ptr => try self.airIntFromPtr(inst), + .float_from_int => try self.airFloatFromInt(inst), + .int_from_float => try self.airIntFromFloat(inst), .not => try self.airNot(inst), .array_to_slice => try self.airArrayToSlice(inst), diff --git a/test/behavior/alignof.zig b/test/behavior/alignof.zig index ddc514e4e3..0443b2d6b3 100644 --- a/test/behavior/alignof.zig +++ b/test/behavior/alignof.zig @@ -28,8 +28,6 @@ test "comparison of @alignOf(T) against zero" { } test "correct alignment for elements and slices of aligned array" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var buf: [1024]u8 align(64) = undefined; var start: usize = 1; var end: usize = undefined; diff --git a/test/behavior/array.zig b/test/behavior/array.zig index 6fa93b4657..a291d3a7b7 100644 --- a/test/behavior/array.zig +++ b/test/behavior/array.zig @@ -158,7 +158,6 @@ test "array len field" { test "array with sentinels" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest(is_ct: bool) !void { @@ -225,7 +224,6 @@ test "nested arrays of integers" { test "implicit comptime in array type size" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var arr: [plusOne(10)]bool = undefined; try expect(arr.len == 11); @@ -318,7 +316,6 @@ test "read/write through global variable array of struct fields initialized via 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -358,7 +355,6 @@ fn testArrayByValAtComptime(b: [2]u8) u8 { test "comptime evaluating function that takes array by value" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const arr = [_]u8{ 1, 2 }; const x = comptime testArrayByValAtComptime(arr); @@ -370,7 +366,6 @@ test "comptime evaluating function that takes array by value" { test "runtime initialize array elem and then implicit cast to slice" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var two: i32 = 2; const x: []const i32 = &[_]i32{two}; diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 9a75a8495d..aa4f41a25e 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -606,7 +606,6 @@ test "self reference through fn ptr field" { test "global variable initialized to global variable array element" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(global_ptr == &gdt[0]); } diff --git a/test/behavior/bugs/10138.zig b/test/behavior/bugs/10138.zig index 1c8ff7cf7c..56d8450f33 100644 --- a/test/behavior/bugs/10138.zig +++ b/test/behavior/bugs/10138.zig @@ -5,7 +5,6 @@ test "registers get overwritten when ignoring return" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.cpu.arch != .x86_64 or builtin.os.tag != .linux) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const fd = open(); _ = write(fd, "a", 1); diff --git a/test/behavior/bugs/10970.zig b/test/behavior/bugs/10970.zig index 008242196c..539dfaff71 100644 --- a/test/behavior/bugs/10970.zig +++ b/test/behavior/bugs/10970.zig @@ -7,7 +7,6 @@ test "breaking from a loop in an if statement" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var cond = true; const opt = while (cond) { diff --git a/test/behavior/bugs/11100.zig b/test/behavior/bugs/11100.zig index 1a55b94510..7e4ef7ce67 100644 --- a/test/behavior/bugs/11100.zig +++ b/test/behavior/bugs/11100.zig @@ -9,7 +9,5 @@ pub fn do() bool { } test "bug" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try std.testing.expect(!do()); } diff --git a/test/behavior/bugs/11165.zig b/test/behavior/bugs/11165.zig index 129b605100..e23861ddc1 100644 --- a/test/behavior/bugs/11165.zig +++ b/test/behavior/bugs/11165.zig @@ -2,7 +2,6 @@ const builtin = @import("builtin"); test "bytes" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { a: u32, @@ -24,7 +23,6 @@ test "bytes" { test "aggregate" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { a: u32, diff --git a/test/behavior/bugs/11816.zig b/test/behavior/bugs/11816.zig index 6061d668f3..cb548ef2e9 100644 --- a/test/behavior/bugs/11816.zig +++ b/test/behavior/bugs/11816.zig @@ -4,7 +4,6 @@ const builtin = @import("builtin"); test { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var x: u32 = 3; const val: usize = while (true) switch (x) { diff --git a/test/behavior/bugs/12025.zig b/test/behavior/bugs/12025.zig index aa293aa6b5..92f8aff0aa 100644 --- a/test/behavior/bugs/12025.zig +++ b/test/behavior/bugs/12025.zig @@ -1,8 +1,6 @@ const builtin = @import("builtin"); test { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime var st = .{ .foo = &1, .bar = &2, diff --git a/test/behavior/bugs/12033.zig b/test/behavior/bugs/12033.zig index dfe583f156..b7ff501e35 100644 --- a/test/behavior/bugs/12033.zig +++ b/test/behavior/bugs/12033.zig @@ -2,8 +2,6 @@ const std = @import("std"); const builtin = @import("builtin"); test { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const string = "Hello!\x00World!"; try std.testing.expect(@TypeOf(string) == *const [13:0]u8); diff --git a/test/behavior/bugs/12043.zig b/test/behavior/bugs/12043.zig index 835b2f6b4e..1b04ecab46 100644 --- a/test/behavior/bugs/12043.zig +++ b/test/behavior/bugs/12043.zig @@ -7,8 +7,6 @@ fn foo(x: anytype) void { ok = x; } test { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const x = &foo; x(true); try expect(ok); diff --git a/test/behavior/bugs/12119.zig b/test/behavior/bugs/12119.zig index 6cfb015eb0..e37c90b507 100644 --- a/test/behavior/bugs/12119.zig +++ b/test/behavior/bugs/12119.zig @@ -9,7 +9,6 @@ test { if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO 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_spirv64) return error.SkipZigTest; const zerox32: u8x32 = [_]u8{0} ** 32; const bigsum: u32x8 = @as(u32x8, @bitCast(zerox32)); diff --git a/test/behavior/bugs/12891.zig b/test/behavior/bugs/12891.zig index 9987a494e0..82995eb019 100644 --- a/test/behavior/bugs/12891.zig +++ b/test/behavior/bugs/12891.zig @@ -7,29 +7,21 @@ test "issue12891" { try std.testing.expect(i < f); } test "nan" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const f = comptime std.math.nan(f64); var i: usize = 0; try std.testing.expect(!(f < i)); } test "inf" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const f = comptime std.math.inf(f64); var i: usize = 0; try std.testing.expect(f > i); } test "-inf < 0" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const f = comptime -std.math.inf(f64); var i: usize = 0; try std.testing.expect(f < i); } test "inf >= 1" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const f = comptime std.math.inf(f64); var i: usize = 1; try std.testing.expect(f >= i); diff --git a/test/behavior/bugs/12928.zig b/test/behavior/bugs/12928.zig index dd5a7761d7..1d8afdd7c9 100644 --- a/test/behavior/bugs/12928.zig +++ b/test/behavior/bugs/12928.zig @@ -11,8 +11,6 @@ const B = extern struct { }; test { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var a: *A = undefined; try expect(@TypeOf(&a.value.a) == *volatile u32); try expect(@TypeOf(&a.value.b) == *volatile i32); @@ -26,8 +24,6 @@ const D = extern union { b: i32, }; test { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var c: *C = undefined; try expect(@TypeOf(&c.value.a) == *volatile u32); try expect(@TypeOf(&c.value.b) == *volatile i32); diff --git a/test/behavior/bugs/12984.zig b/test/behavior/bugs/12984.zig index 0b144ed159..75f2747eda 100644 --- a/test/behavior/bugs/12984.zig +++ b/test/behavior/bugs/12984.zig @@ -14,7 +14,6 @@ pub const CustomDraw = DeleagateWithContext(fn (?OnConfirm) void); test "simple test" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var c: CustomDraw = undefined; _ = c; diff --git a/test/behavior/bugs/13113.zig b/test/behavior/bugs/13113.zig index fd3a14f8f6..5a496aa29d 100644 --- a/test/behavior/bugs/13113.zig +++ b/test/behavior/bugs/13113.zig @@ -10,7 +10,6 @@ test { if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO 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_spirv64) return error.SkipZigTest; const foo = Foo{ .a = 1, diff --git a/test/behavior/bugs/13159.zig b/test/behavior/bugs/13159.zig index 6f8ae1842f..eec01658e6 100644 --- a/test/behavior/bugs/13159.zig +++ b/test/behavior/bugs/13159.zig @@ -11,7 +11,6 @@ const Bar = packed struct { test { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var foo = Bar.Baz.fizz; try expect(foo == .fizz); diff --git a/test/behavior/bugs/13285.zig b/test/behavior/bugs/13285.zig index b87020bf46..15ebfa5804 100644 --- a/test/behavior/bugs/13285.zig +++ b/test/behavior/bugs/13285.zig @@ -6,7 +6,6 @@ const Crasher = struct { test { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a: Crasher = undefined; var crasher_ptr = &a; diff --git a/test/behavior/bugs/14854.zig b/test/behavior/bugs/14854.zig index 9c877bc688..8f01ccb3f4 100644 --- a/test/behavior/bugs/14854.zig +++ b/test/behavior/bugs/14854.zig @@ -2,8 +2,6 @@ const testing = @import("std").testing; const builtin = @import("builtin"); test { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try testing.expect(getGeneric(u8, getU8) == 123); } diff --git a/test/behavior/bugs/1500.zig b/test/behavior/bugs/1500.zig index 3a6246b2c9..cc12c5d0be 100644 --- a/test/behavior/bugs/1500.zig +++ b/test/behavior/bugs/1500.zig @@ -6,8 +6,6 @@ const A = struct { const B = *const fn (A) void; test "allow these dependencies" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var a: A = undefined; var b: B = undefined; if (false) { diff --git a/test/behavior/bugs/15778.zig b/test/behavior/bugs/15778.zig index 86b9fce7b6..5754eb6e11 100644 --- a/test/behavior/bugs/15778.zig +++ b/test/behavior/bugs/15778.zig @@ -6,7 +6,6 @@ test { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO const a = @Vector(0, i32){}; const b = @Vector(0, i32){}; _ = a + b; @@ -18,7 +17,6 @@ test { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO const a = @Vector(0, f32){}; const b = @Vector(0, f32){}; _ = a - b; diff --git a/test/behavior/bugs/2622.zig b/test/behavior/bugs/2622.zig index d3d2b078e2..89130a3974 100644 --- a/test/behavior/bugs/2622.zig +++ b/test/behavior/bugs/2622.zig @@ -7,7 +7,6 @@ test "reslice of undefined global var slice" { if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO 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_spirv64) return error.SkipZigTest; var mem: [100]u8 = [_]u8{0} ** 100; buf = &mem; diff --git a/test/behavior/bugs/3779.zig b/test/behavior/bugs/3779.zig index 2b1dad5de0..088443d529 100644 --- a/test/behavior/bugs/3779.zig +++ b/test/behavior/bugs/3779.zig @@ -8,7 +8,6 @@ const ptr_tag_name: [*:0]const u8 = tag_name; test "@tagName() returns a string literal" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name)); try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name)); @@ -22,7 +21,6 @@ const ptr_error_name: [*:0]const u8 = error_name; test "@errorName() returns a string literal" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name)); try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name)); diff --git a/test/behavior/bugs/4954.zig b/test/behavior/bugs/4954.zig index 15c3185fa9..8cae03d314 100644 --- a/test/behavior/bugs/4954.zig +++ b/test/behavior/bugs/4954.zig @@ -8,7 +8,6 @@ test "crash" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var buf: [4096]u8 = undefined; f(&buf); diff --git a/test/behavior/bugs/5398.zig b/test/behavior/bugs/5398.zig index 4dc4ab8d19..6f75bd9436 100644 --- a/test/behavior/bugs/5398.zig +++ b/test/behavior/bugs/5398.zig @@ -22,7 +22,6 @@ test "assignment of field with padding" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; renderable = Renderable{ .mesh = Mesh{ .id = 0 }, diff --git a/test/behavior/bugs/6456.zig b/test/behavior/bugs/6456.zig index 31dea02cf6..c74319a5bf 100644 --- a/test/behavior/bugs/6456.zig +++ b/test/behavior/bugs/6456.zig @@ -13,7 +13,6 @@ const text = test "issue 6456" { 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_spirv64) return error.SkipZigTest; comptime { var fields: []const StructField = &[0]StructField{}; diff --git a/test/behavior/bugs/656.zig b/test/behavior/bugs/656.zig index 161da66964..004f442165 100644 --- a/test/behavior/bugs/656.zig +++ b/test/behavior/bugs/656.zig @@ -14,7 +14,6 @@ test "optional if after an if in a switch prong of a switch with 2 prongs in an 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_spirv64) return error.SkipZigTest; try foo(false, true); } diff --git a/test/behavior/bugs/7047.zig b/test/behavior/bugs/7047.zig index a7a0966935..534624fa72 100644 --- a/test/behavior/bugs/7047.zig +++ b/test/behavior/bugs/7047.zig @@ -15,8 +15,6 @@ fn S(comptime query: U) type { } test "compiler doesn't consider equal unions with different 'type' payload" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const s1 = S(U{ .T = u32 }).tag(); try std.testing.expectEqual(u32, s1); diff --git a/test/behavior/bugs/7187.zig b/test/behavior/bugs/7187.zig index be593d7fad..bb2e82af89 100644 --- a/test/behavior/bugs/7187.zig +++ b/test/behavior/bugs/7187.zig @@ -3,8 +3,6 @@ const builtin = @import("builtin"); const expect = std.testing.expect; test "miscompilation with bool return type" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var x: usize = 1; var y: bool = getFalse(); _ = y; diff --git a/test/behavior/bugs/8277.zig b/test/behavior/bugs/8277.zig index 149962d996..8d64d49223 100644 --- a/test/behavior/bugs/8277.zig +++ b/test/behavior/bugs/8277.zig @@ -2,8 +2,6 @@ const std = @import("std"); const builtin = @import("builtin"); test "@sizeOf reified union zero-size payload fields" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime { try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union {})))); try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union { a: void })))); diff --git a/test/behavior/bugs/828.zig b/test/behavior/bugs/828.zig index a0ac00817d..220d98ce09 100644 --- a/test/behavior/bugs/828.zig +++ b/test/behavior/bugs/828.zig @@ -31,7 +31,6 @@ fn constCount(comptime cb: *const CountBy, comptime unused: u32) void { test "comptime struct return should not return the same instance" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; //the first parameter must be passed by reference to trigger the bug //a second parameter is required to trigger the bug diff --git a/test/behavior/byval_arg_var.zig b/test/behavior/byval_arg_var.zig index 3a82ca86ad..01b5f90ef7 100644 --- a/test/behavior/byval_arg_var.zig +++ b/test/behavior/byval_arg_var.zig @@ -5,7 +5,6 @@ var result: []const u8 = "wrong"; test "pass string literal byvalue to a generic var param" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; start(); blowUpStack(10); diff --git a/test/behavior/call.zig b/test/behavior/call.zig index 6be66da174..beccb059d8 100644 --- a/test/behavior/call.zig +++ b/test/behavior/call.zig @@ -334,7 +334,6 @@ test "inline call preserves tail call" { test "inline call doesn't re-evaluate non generic struct" { 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_spirv64) return error.SkipZigTest; const S = struct { fn foo(f: struct { a: u8, b: u8 }) !void { diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig index bdaece3533..f7ab8695c0 100644 --- a/test/behavior/cast.zig +++ b/test/behavior/cast.zig @@ -403,7 +403,6 @@ test "peer type unsigned int to signed" { test "expected [*c]const u8, found [*:0]const u8" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a: [*:0]const u8 = "hello"; var b: [*c]const u8 = a; @@ -445,7 +444,6 @@ test "implicitly cast from T to anyerror!?T" { 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_spirv64) return error.SkipZigTest; try castToOptionalTypeError(1); try comptime castToOptionalTypeError(1); @@ -521,7 +519,6 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 { test "implicit cast from *const [N]T to []const T" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCastConstArrayRefToConstSlice(); try comptime testCastConstArrayRefToConstSlice(); @@ -547,7 +544,6 @@ fn testCastConstArrayRefToConstSlice() !void { test "peer type resolution: error and [N]T" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); try comptime expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); @@ -709,7 +705,6 @@ test "peer type resolution: error set supersets" { 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_spirv64) return error.SkipZigTest; const a: error{ One, Two } = undefined; const b: error{One} = undefined; @@ -739,7 +734,6 @@ test "peer type resolution: disjoint error sets" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const a: error{ One, Two } = undefined; const b: error{Three} = undefined; @@ -769,7 +763,6 @@ test "peer type resolution: error union and error set" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const a: error{Three} = undefined; const b: error{ One, Two }!u32 = undefined; @@ -803,7 +796,6 @@ test "peer type resolution: error union after non-error" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const a: u32 = undefined; const b: error{ One, Two }!u32 = undefined; @@ -863,7 +855,6 @@ test "peer cast *[0]T to []const T" { test "peer cast *[N]T to [*]T" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var array = [4:99]i32{ 1, 2, 3, 4 }; var dest: [*]i32 = undefined; @@ -930,7 +921,6 @@ test "peer cast [N:x]T to [N]T" { test "peer cast *[N:x]T to *[N]T" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -946,7 +936,6 @@ test "peer cast *[N:x]T to *[N]T" { test "peer cast [*:x]T to [*]T" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -967,7 +956,6 @@ test "peer cast [:x]T to [*:x]T" { 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -988,7 +976,6 @@ test "peer cast [:x]T to [*:x]T" { test "peer type resolution implicit cast to return type" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1009,7 +996,6 @@ test "peer type resolution implicit cast to return type" { test "peer type resolution implicit cast to variable type" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1034,7 +1020,6 @@ test "variable initialization uses result locations properly with regards to the test "cast between C pointer with different but compatible types" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn foo(arg: [*]c_ushort) u16 { @@ -1052,7 +1037,6 @@ test "cast between C pointer with different but compatible types" { test "peer type resolve string lit with sentinel-terminated mutable slice" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var array: [4:0]u8 = undefined; array[4] = 0; // TODO remove this when #4372 is solved @@ -1062,8 +1046,6 @@ test "peer type resolve string lit with sentinel-terminated mutable slice" { } test "peer type resolve array pointers, one of them const" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var array1: [4]u8 = undefined; const array2: [5]u8 = undefined; try comptime expect(@TypeOf(&array1, &array2) == []const u8); @@ -1071,8 +1053,6 @@ test "peer type resolve array pointers, one of them const" { } test "peer type resolve array pointer and unknown pointer" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const const_array: [4]u8 = undefined; var array: [4]u8 = undefined; var const_ptr: [*]const u8 = undefined; @@ -1092,8 +1072,6 @@ test "peer type resolve array pointer and unknown pointer" { } test "comptime float casts" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const a = @as(comptime_float, @floatFromInt(1)); try expect(a == 1); try expect(@TypeOf(a) == comptime_float); @@ -1140,8 +1118,6 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void { } test "compile time int to ptr of function" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try foobar(FUNCTION_CONSTANT); } @@ -1341,8 +1317,6 @@ test "*const [N]null u8 to ?[]const u8" { } test "cast between [*c]T and ?[*:0]T on fn parameter" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const S = struct { const Handler = ?fn ([*c]const u8) callconv(.C) void; fn addCallback(comptime handler: Handler) void { @@ -1382,7 +1356,6 @@ test "cast between *[N]void and []void" { test "peer resolve arrays of different size to const slice" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(mem.eql(u8, boolToStr(true), "true")); try expect(mem.eql(u8, boolToStr(false), "false")); @@ -1486,7 +1459,6 @@ test "cast compatible optional types" { test "coerce undefined single-item pointer of array to error union of slice" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const a = @as([*]u8, undefined)[0..0]; var b: error{a}![]const u8 = a; @@ -1496,7 +1468,6 @@ test "coerce undefined single-item pointer of array to error union of slice" { test "pointer to empty struct literal to mutable slice" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var x: []i32 = &.{}; try expect(x.len == 0); @@ -1585,7 +1556,6 @@ test "bitcast packed struct with u0" { test "optional pointer coerced to optional allowzero pointer" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var p: ?*u32 = undefined; var q: ?*allowzero u32 = undefined; @@ -1595,8 +1565,6 @@ test "optional pointer coerced to optional allowzero pointer" { } test "single item pointer to pointer to array to slice" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var x: i32 = 1234; try expect(@as([]const i32, @as(*[1]i32, &x))[0] == 1234); const z1 = @as([]const i32, @as(*[1]i32, &x)); @@ -1632,8 +1600,6 @@ test "@volatileCast without a result location" { } test "coercion from single-item pointer to @as to slice" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var x: u32 = 1; // Why the following line gets a compile error? @@ -2295,7 +2261,6 @@ test "cast builtins can wrap result in error union" { if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO const S = struct { const MyEnum = enum(u32) { _ }; diff --git a/test/behavior/cast_int.zig b/test/behavior/cast_int.zig index 09733d00a0..989f3d3aa1 100644 --- a/test/behavior/cast_int.zig +++ b/test/behavior/cast_int.zig @@ -19,7 +19,6 @@ test "coerce i8 to i32 and @intCast back" { 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_spirv64) return error.SkipZigTest; var x: i8 = -5; var y: i32 = -5; diff --git a/test/behavior/defer.zig b/test/behavior/defer.zig index dd7ded911d..86a9a40246 100644 --- 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_spirv64) return error.SkipZigTest; - testBreakContInDefer(10); comptime testBreakContInDefer(10); } diff --git a/test/behavior/empty_union.zig b/test/behavior/empty_union.zig index 16606b5785..53408875ae 100644 --- a/test/behavior/empty_union.zig +++ b/test/behavior/empty_union.zig @@ -9,8 +9,6 @@ test "switch on empty enum" { } test "switch on empty enum with a specified tag type" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const E = enum(u8) {}; var e: E = undefined; switch (e) {} @@ -18,7 +16,6 @@ test "switch on empty enum with a specified tag type" { test "switch on empty auto numbered tagged union" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const U = union(enum(u8)) {}; var u: U = undefined; diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig index a472dc87a4..6701381085 100644 --- a/test/behavior/enum.zig +++ b/test/behavior/enum.zig @@ -935,7 +935,6 @@ const Bar = enum { A, B, C, D }; test "enum literal casting to error union with payload enum" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var bar: error{B}!Bar = undefined; bar = .B; // should never cast to the error set @@ -947,7 +946,6 @@ test "constant enum initialization with differing sizes" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try test3_1(test3_foo); try test3_2(test3_bar); @@ -1054,7 +1052,6 @@ test "enum literal casting to optional" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var bar: ?Bar = undefined; bar = .B; @@ -1141,7 +1138,6 @@ test "tag name functions are unique" { test "size of enum with only one tag which has explicit integer tag type" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const E = enum(u8) { nope = 10 }; const S0 = struct { e: E }; diff --git a/test/behavior/error.zig b/test/behavior/error.zig index 038bd94dfa..5a25714d14 100644 --- a/test/behavior/error.zig +++ b/test/behavior/error.zig @@ -822,7 +822,6 @@ test "alignment of wrapping an error union payload" { test "compare error union and error set" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a: anyerror = error.Foo; var b: anyerror!u32 = error.Bar; diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig index 2812457388..c62ddda1aa 100644 --- a/test/behavior/eval.zig +++ b/test/behavior/eval.zig @@ -5,8 +5,6 @@ const expect = std.testing.expect; const expectEqual = std.testing.expectEqual; test "compile time recursion" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try expect(some_data.len == 21); } var some_data: [@as(usize, @intCast(fibonacci(7)))]u8 = undefined; @@ -74,7 +72,6 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 { test "constant expressions" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var array: [array_size]u8 = undefined; try expect(@sizeOf(@TypeOf(array)) == 20); @@ -143,7 +140,6 @@ test "pointer to type" { test "a type constructed in a global expression" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var l: List = undefined; l.array[0] = 10; @@ -202,8 +198,6 @@ test "@setEvalBranchQuota" { } test "constant struct with negation" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try expect(vertices[0].x == @as(f32, -0.6)); } const Vertex = struct { @@ -308,8 +302,6 @@ fn performFn(comptime prefix_char: u8, start_value: i32) i32 { } test "comptime iterate over fn ptr list" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try expect(performFn('t', 1) == 6); try expect(performFn('o', 0) == 1); try expect(performFn('w', 99) == 99); @@ -348,7 +340,6 @@ fn doesAlotT(comptime T: type, value: usize) T { test "@setEvalBranchQuota at same scope as generic function call" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(doesAlotT(u32, 2) == 2); } @@ -385,8 +376,6 @@ test "zero extend from u0 to u1" { } test "return 0 from function that has u0 return type" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const S = struct { fn foo_zero() u0 { return 0; @@ -417,8 +406,6 @@ var st_init_str_foo = StInitStrFoo{ }; test "inline for with same type but different values" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var res: usize = 0; inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) |T| { var a: T = undefined; @@ -544,7 +531,6 @@ test "runtime 128 bit integer division" { test "@tagName of @typeInfo" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const str = @tagName(@typeInfo(u8)); try expect(std.mem.eql(u8, str, "Int")); @@ -554,7 +540,6 @@ test "static eval list init" { 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_spirv64) return error.SkipZigTest; try expect(static_vec3.data[2] == 1.0); try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0); @@ -586,7 +571,6 @@ test "inlined loop has array literal with elided runtime scope on first iteratio test "ptr to local array argument at comptime" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; comptime { var bytes: [10]u8 = undefined; @@ -623,7 +607,6 @@ const hi1 = "hi"; const hi2 = hi1; test "const global shares pointer with other same one" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try assertEqualPtrs(&hi1[0], &hi2[0]); try comptime expect(&hi1[0] == &hi2[0]); @@ -659,8 +642,6 @@ pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type { } test "comptime function with mutable pointer is not memoized" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - comptime { var x: i32 = 1; const ptr = &x; @@ -753,7 +734,6 @@ test "array concatenation of function calls" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a = oneItem(3) ++ oneItem(4); try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 })); @@ -763,7 +743,6 @@ test "array multiplication of function calls" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a = oneItem(3) ** scalar(2); try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 })); @@ -852,7 +831,6 @@ test "array multiplication sets the sentinel - value" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a = [2:7]u3{ 1, 6 }; var b = a ** 2; @@ -869,7 +847,6 @@ test "array multiplication sets the sentinel - pointer" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a = [2:7]u3{ 1, 6 }; var b = &a ** 2; @@ -1004,7 +981,6 @@ test "closure capture type of runtime-known var" { test "comptime break passing through runtime condition converted to runtime break" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1038,7 +1014,6 @@ test "comptime break to outer loop passing through runtime condition converted t 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1110,7 +1085,6 @@ test "comptime break operand passing through runtime switch converted to runtime test "no dependency loop for alignment of self struct" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1148,7 +1122,6 @@ test "no dependency loop for alignment of self struct" { test "no dependency loop for alignment of self bare union" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1186,7 +1159,6 @@ test "no dependency loop for alignment of self bare union" { test "no dependency loop for alignment of self tagged union" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1377,7 +1349,6 @@ test "lazy value is resolved as slice operand" { 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_spirv64) return error.SkipZigTest; const A = struct { a: u32 }; var a: [512]u64 = undefined; @@ -1435,7 +1406,6 @@ test "inline for inside a runtime condition" { test "continue in inline for inside a comptime switch" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const arr = .{ 1, 2, 3 }; var count: u8 = 0; @@ -1501,7 +1471,6 @@ test "continue nested inline for loop in named block expr" { test "x and false is comptime-known false" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const T = struct { var x: u32 = 0; @@ -1529,7 +1498,6 @@ test "x and false is comptime-known false" { test "x or true is comptime-known true" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const T = struct { var x: u32 = 0; @@ -1559,7 +1527,6 @@ test "non-optional and optional array elements concatenated" { 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_spirv64) return error.SkipZigTest; const array = [1]u8{'A'} ++ [1]?u8{null}; var index: usize = 0; @@ -1648,8 +1615,6 @@ test "result of nested switch assigned to variable" { } test "inline for loop of functions returning error unions" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const T1 = struct { fn v() error{}!usize { return 1; diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig index 0e79ba3254..33460b827e 100644 --- a/test/behavior/floatop.zig +++ b/test/behavior/floatop.zig @@ -736,7 +736,6 @@ test "@ceil" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try comptime testCeil(); try testCeil(); @@ -1053,7 +1052,6 @@ test "negation f128" { test "eval @setFloatMode at compile-time" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const result = comptime fnWithFloatMode(); try expect(result == 1234.0); @@ -1089,7 +1087,6 @@ test "comptime fixed-width float non-zero divided by zero produces signed Inf" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; inline for (.{ f16, f32, f64, f80, f128 }) |F| { const pos = @as(F, 1) / @as(F, 0); diff --git a/test/behavior/fn.zig b/test/behavior/fn.zig index 7ccd9d5351..ed69a8d8e9 100644 --- a/test/behavior/fn.zig +++ b/test/behavior/fn.zig @@ -20,8 +20,6 @@ fn testLocVars(b: i32) void { } test "mutable local variables" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var zero: i32 = 0; try expect(zero == 0); @@ -53,8 +51,6 @@ test "weird function name" { } test "assign inline fn to const variable" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const a = inlineFn; a(); } @@ -190,7 +186,6 @@ test "function with complex callconv and return type expressions" { test "pass by non-copying value" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3); } @@ -218,7 +213,6 @@ fn addPointCoordsVar(pt: anytype) !i32 { test "pass by non-copying value as method" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var pt = Point2{ .x = 1, .y = 2 }; try expect(pt.addPointCoords() == 3); @@ -235,7 +229,6 @@ const Point2 = struct { test "pass by non-copying value as method, which is generic" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var pt = Point3{ .x = 1, .y = 2 }; try expect(pt.addPointCoords(i32) == 3); @@ -253,7 +246,6 @@ const Point3 = struct { test "pass by non-copying value as method, at comptime" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; comptime { var pt = Point2{ .x = 1, .y = 2 }; @@ -396,8 +388,6 @@ test "function call with anon list literal - 2D" { } test "ability to give comptime types and non comptime types to same parameter" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const S = struct { fn doTheTest() !void { var x: i32 = 1; @@ -415,8 +405,6 @@ test "ability to give comptime types and non comptime types to same parameter" { } test "function with inferred error set but returning no error" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const S = struct { fn foo() !void {} }; diff --git a/test/behavior/for.zig b/test/behavior/for.zig index 35f51da218..211fba932b 100644 --- a/test/behavior/for.zig +++ b/test/behavior/for.zig @@ -257,7 +257,6 @@ test "for loop with else branch" { test "count over fixed range" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var sum: usize = 0; for (0..6) |i| { @@ -270,7 +269,6 @@ test "count over fixed range" { test "two counters" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var sum: usize = 0; for (0..10, 10..20) |i, j| { @@ -318,7 +316,6 @@ test "slice and two counters, one is offset and one is runtime" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const slice: []const u8 = "blah"; var start: usize = 0; @@ -406,7 +403,6 @@ test "inline for with slice as the comptime-known" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const comptime_slice = "hello"; var runtime_i: usize = 3; diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig index f2b4ebf309..8ecb069956 100644 --- a/test/behavior/generics.zig +++ b/test/behavior/generics.zig @@ -55,7 +55,6 @@ test "fn with comptime args" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(gimmeTheBigOne(1234, 5678) == 5678); try expect(shouldCallSameInstance(34, 12) == 34); @@ -66,7 +65,6 @@ test "anytype params" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try expect(max_i32(12, 34) == 34); try expect(max_f64(1.2, 3.4) == 3.4); @@ -91,7 +89,6 @@ fn max_f64(a: f64, b: f64) f64 { test "type constructed by comptime function call" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var l: SimpleList(10) = undefined; l.array[0] = 10; @@ -115,7 +112,6 @@ test "function with return type type" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var list: List(i32) = undefined; var list2: List(i32) = undefined; @@ -147,8 +143,6 @@ fn GenericDataThing(comptime count: isize) type { } test "use generic param in generic param" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try expect(aGenericFn(i32, 3, 4) == 7); } fn aGenericFn(comptime T: type, comptime a: T, b: T) T { @@ -178,7 +172,6 @@ test "generic fn keeps non-generic parameter types" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const A = 128; @@ -254,7 +247,6 @@ test "generic function instantiation turns into comptime call" { 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -305,7 +297,6 @@ test "generic function with void and comptime parameter" { test "anonymous struct return type referencing comptime parameter" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { pub fn extraData(comptime T: type, index: usize) struct { data: T, end: usize } { @@ -406,8 +397,6 @@ test "generic struct as parameter type" { } test "slice as parameter type" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const S = struct { fn internComptimeString(comptime str: []const u8) *const []const u8 { return &struct { @@ -422,8 +411,6 @@ test "slice as parameter type" { } test "null sentinel pointer passed as generic argument" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const S = struct { fn doTheTest(a: anytype) !void { try std.testing.expect(@intFromPtr(a) == 8); @@ -434,7 +421,6 @@ test "null sentinel pointer passed as generic argument" { test "generic function passed as comptime argument" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doMath(comptime f: fn (type, i32, i32) error{Overflow}!i32, a: i32, b: i32) !void { diff --git a/test/behavior/inline_switch.zig b/test/behavior/inline_switch.zig index fc2eae31be..43a02df01d 100644 --- a/test/behavior/inline_switch.zig +++ b/test/behavior/inline_switch.zig @@ -47,7 +47,6 @@ test "inline switch unions" { 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_spirv64) return error.SkipZigTest; var x: U = .a; switch (x) { @@ -141,8 +140,6 @@ test "inline else int all values" { } test "inline switch capture is set when switch operand is comptime known" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const U2 = union(enum) { a: u32, }; diff --git a/test/behavior/math.zig b/test/behavior/math.zig index afbe0f911d..9e4ec783e7 100644 --- a/test/behavior/math.zig +++ b/test/behavior/math.zig @@ -1145,8 +1145,6 @@ test "overflow arithmetic with u0 values" { } test "allow signed integer division/remainder when values are comptime-known and positive or exact" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try expect(5 / 3 == 1); try expect(-5 / -3 == 1); try expect(-6 / 3 == -2); diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig index ed2679aef4..22514128d0 100644 --- a/test/behavior/maximum_minimum.zig +++ b/test/behavior/maximum_minimum.zig @@ -200,7 +200,6 @@ test "@min/@max on comptime_int" { 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_spirv64) return error.SkipZigTest; // TODO const min = @min(1, 2, -2, -1); const max = @max(1, 2, -2, -1); @@ -257,7 +256,6 @@ test "@min/@max notices bounds from types when comptime-known value is undef" { 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_spirv64) return error.SkipZigTest; var x: u32 = 1_000_000; const y: u16 = undefined; diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig index ce836eb337..9f430a105a 100644 --- a/test/behavior/slice.zig +++ b/test/behavior/slice.zig @@ -754,7 +754,6 @@ test "slice len modification at comptime" { } test "slice field ptr const" { - const const_slice: []const u8 = "string"; const const_ptr_const_slice = &const_slice; diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig index ac57f9176b..1ba9e946d1 100644 --- a/test/behavior/struct.zig +++ b/test/behavior/struct.zig @@ -109,7 +109,6 @@ fn testMutation(foo: *StructFoo) void { test "struct byval assign" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var foo1: StructFoo = undefined; var foo2: StructFoo = undefined; @@ -129,8 +128,6 @@ test "call struct static method" { const should_be_11 = StructWithNoFields.add(5, 6); test "invoke static method in global scope" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try expect(should_be_11 == 11); } @@ -255,7 +252,6 @@ test "usingnamespace within struct scope" { test "struct field init with catch" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -367,8 +363,6 @@ test "self-referencing struct via array member" { } test "empty struct method call" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const es = EmptyStruct{}; try expect(es.method() == 1234); } @@ -553,7 +547,6 @@ test "implicit cast packed struct field to const ptr" { test "zero-bit field in packed struct" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = packed struct { x: u10, @@ -949,8 +942,6 @@ test "tuple assigned to variable" { } test "comptime struct field" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (comptime builtin.cpu.arch.isArmOrThumb()) return error.SkipZigTest; // TODO @@ -988,7 +979,6 @@ test "struct with union field" { 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_spirv64) return error.SkipZigTest; const Value = struct { ref: u32 = 2, @@ -1439,8 +1429,6 @@ test "struct field has a pointer to an aligned version of itself" { } test "struct has only one reference" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const S = struct { fn optionalStructParam(_: ?struct { x: u8 }) void {} fn errorUnionStructParam(_: error{}!struct { x: u8 }) void {} @@ -1510,7 +1498,6 @@ test "discarded struct initialization works as expected" { test "function pointer in struct returns the struct" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const A = struct { const A = @This(); @@ -1560,7 +1547,6 @@ test "optional field init with tuple" { test "if inside struct init inside if" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const MyStruct = struct { x: u32 }; const b: u32 = 5; diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig index 4e6b7ad761..8460798c53 100644 --- a/test/behavior/switch.zig +++ b/test/behavior/switch.zig @@ -232,7 +232,6 @@ test "switch prong with variable" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 }); try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 }); @@ -257,7 +256,6 @@ test "switch on enum using pointer capture" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testSwitchEnumPtrCapture(); try comptime testSwitchEnumPtrCapture(); @@ -318,7 +316,6 @@ test "switch on union with some prongs capturing" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const X = union(enum) { a, @@ -355,7 +352,6 @@ test "switch on const enum with var" { test "anon enum literal used in switch on union enum" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const Foo = union(enum) { a: i32, @@ -394,7 +390,6 @@ fn switchWithUnreachable(x: i32) i32 { test "capture value of switch with all unreachable prongs" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const x = return_a_number() catch |err| switch (err) { else => unreachable, @@ -408,7 +403,6 @@ fn return_a_number() anyerror!i32 { test "switch on integer with else capturing expr" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -498,7 +492,6 @@ test "switch prongs with error set cases make a new error set type for capture v test "return result loc and then switch with range implicit casted to error union" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -539,7 +532,6 @@ test "switch prongs with cases with identical payload types" { 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_spirv64) return error.SkipZigTest; const Union = union(enum) { A: usize, @@ -706,8 +698,6 @@ test "switch item sizeof" { } test "comptime inline switch" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const U = union(enum) { a: type, b: type }; const value = comptime blk: { var u: U = .{ .a = u32 }; diff --git a/test/behavior/this.zig b/test/behavior/this.zig index 0bc765c8a7..a68e44df89 100644 --- a/test/behavior/this.zig +++ b/test/behavior/this.zig @@ -27,7 +27,6 @@ test "this refer to module call private fn" { test "this refer to container" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var pt: Point(i32) = undefined; pt.x = 12; diff --git a/test/behavior/try.zig b/test/behavior/try.zig index c7b0396051..49581977f9 100644 --- a/test/behavior/try.zig +++ b/test/behavior/try.zig @@ -24,8 +24,6 @@ fn returnsTen() anyerror!i32 { } test "try without vars" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - const result1 = if (failIfTrue(true)) 1 else |_| @as(i32, 2); try expect(result1 == 2); diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig index 32ebfe89fd..57c1c920e7 100644 --- a/test/behavior/tuple.zig +++ b/test/behavior/tuple.zig @@ -289,7 +289,6 @@ test "coerce tuple to tuple" { 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_spirv64) return error.SkipZigTest; const T = std.meta.Tuple(&.{u8}); const S = struct { @@ -304,7 +303,6 @@ test "tuple type with void field" { 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_spirv64) return error.SkipZigTest; const T = std.meta.Tuple(&[_]type{void}); const x = T{{}}; @@ -343,7 +341,6 @@ test "zero sized struct in tuple handled correctly" { test "tuple type with void field and a runtime field" { 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_spirv64) return error.SkipZigTest; const T = std.meta.Tuple(&[_]type{ usize, void }); var t: T = .{ 5, {} }; diff --git a/test/behavior/type_info.zig b/test/behavior/type_info.zig index 421800d6fd..30db77e0ea 100644 --- a/test/behavior/type_info.zig +++ b/test/behavior/type_info.zig @@ -160,7 +160,6 @@ test "type info: error set, error union info, anyerror" { 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_spirv64) return error.SkipZigTest; try testErrorSet(); try comptime testErrorSet(); @@ -192,7 +191,6 @@ test "type info: error set single value" { 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_spirv64) return error.SkipZigTest; const TestSet = error.One; @@ -206,7 +204,6 @@ test "type info: error set merged" { 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_spirv64) return error.SkipZigTest; const TestSet = error{ One, Two } || error{Three}; @@ -222,7 +219,6 @@ test "type info: enum info" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testEnum(); try comptime testEnum(); @@ -533,7 +529,6 @@ test "Struct.is_tuple for anon list literal" { test "Struct.is_tuple for anon struct literal" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const info = @typeInfo(@TypeOf(.{ .a = 0 })); try expect(!info.Struct.is_tuple); diff --git a/test/behavior/undefined.zig b/test/behavior/undefined.zig index 04172acfa1..6ae2807b2d 100644 --- a/test/behavior/undefined.zig +++ b/test/behavior/undefined.zig @@ -48,7 +48,6 @@ test "assign undefined to struct" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; comptime { var foo: Foo = undefined; @@ -66,7 +65,6 @@ test "assign undefined to struct with method" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; comptime { var foo: Foo = undefined; @@ -82,7 +80,6 @@ test "assign undefined to struct with method" { test "type name of undefined" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const x = undefined; try expect(mem.eql(u8, @typeName(@TypeOf(x)), "@TypeOf(undefined)")); diff --git a/test/behavior/underscore.zig b/test/behavior/underscore.zig index bb5dd156bc..66b49e52d5 100644 --- a/test/behavior/underscore.zig +++ b/test/behavior/underscore.zig @@ -8,7 +8,6 @@ test "ignore lval with underscore" { test "ignore lval with underscore (while loop)" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; while (optionalReturnError()) |_| { while (optionalReturnError()) |_| { diff --git a/test/behavior/union.zig b/test/behavior/union.zig index a81da9d69e..47e0b2f345 100644 --- a/test/behavior/union.zig +++ b/test/behavior/union.zig @@ -1160,7 +1160,6 @@ test "union with no result loc initiated with a runtime value" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const U = union { a: u32, @@ -1177,7 +1176,6 @@ test "union with a large struct field" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { a: [8]usize, @@ -1329,7 +1327,6 @@ test "@unionInit uses tag value instead of field index" { 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_spirv64) return error.SkipZigTest; const E = enum(u8) { b = 255, diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig index 0b95caa0d3..0ad326d36e 100644 --- a/test/behavior/vector.zig +++ b/test/behavior/vector.zig @@ -240,7 +240,6 @@ test "peer type resolution with coercible element types" { 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_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1469,7 +1468,6 @@ test "boolean vector with 2 or more booleans" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO // TODO: try removing this after : if (!(builtin.os.tag == .linux and builtin.cpu.arch == .x86_64)) return; diff --git a/test/behavior/while.zig b/test/behavior/while.zig index e52b394746..bc051aca32 100644 --- a/test/behavior/while.zig +++ b/test/behavior/while.zig @@ -50,8 +50,6 @@ test "while with continue expression" { } test "while with else" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var sum: i32 = 0; var i: i32 = 0; var got_else: i32 = 0; @@ -79,8 +77,6 @@ fn getNumberOrNull() ?i32 { } test "continue outer while loop" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - testContinueOuter(); comptime testContinueOuter(); } @@ -127,7 +123,6 @@ test "while copies its payload" { test "continue and break" { if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try runContinueAndBreakTest(); try expect(continue_and_break_counter == 8); @@ -149,7 +144,6 @@ fn runContinueAndBreakTest() !void { test "while with optional as condition" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; numbers_left = 10; var sum: i32 = 0; @@ -162,7 +156,6 @@ test "while with optional as condition" { test "while with optional as condition with else" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; numbers_left = 10; var sum: i32 = 0; @@ -223,7 +216,6 @@ test "while on optional with else result follow break prong" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const result = while (returnOptional(10)) |value| { break value; @@ -251,8 +243,6 @@ fn returnTrue() bool { } test "return with implicit cast from while loop" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - returnWithImplicitCastFromWhileLoopTest() catch unreachable; } fn returnWithImplicitCastFromWhileLoopTest() anyerror!void { @@ -263,7 +253,6 @@ fn returnWithImplicitCastFromWhileLoopTest() anyerror!void { test "while on error union with else result follow else prong" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const result = while (returnError()) |value| { break value; @@ -273,7 +262,6 @@ test "while on error union with else result follow else prong" { test "while on error union with else result follow break prong" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const result = while (returnSuccess(10)) |value| { break value; @@ -319,7 +307,6 @@ test "while error 2 break statements and an else" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn entry(opt_t: anyerror!bool, f: bool) !void { @@ -345,8 +332,6 @@ test "continue inline while loop" { } test "else continue outer while" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - var i: usize = 0; while (true) { i += 1; -- cgit v1.2.3