Merge pull request #15753 from Snektron/spirv-more-tests

spirv: make more tests pass
ziglang · May 20, 2023 · 7621e56 · 7621e56
2 parents 413ef3a + c92cc57
commit 7621e56
Show file tree

Hide file tree

Showing 44 changed files with 537 additions and 437 deletions.
diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig
diff --git a/src/codegen/spirv/Module.zig b/src/codegen/spirv/Module.zig
@@ -774,6 +774,16 @@ pub fn changePtrStorageClass(self: *Module, ptr_ty_ref: Type.Ref, new_storage_cl
  return try self.resolveType(Type.initPayload(&payload.base));
 }
 
+pub fn constComposite(self: *Module, ty_ref: Type.Ref, members: []const IdRef) !IdRef {
+ const result_id = self.allocId();
+ try self.sections.types_globals_constants.emit(self.gpa, .OpSpecConstantComposite, .{
+ .id_result_type = self.typeId(ty_ref),
+ .id_result = result_id,
+ .constituents = members,
+ });
+ return result_id;
+}
+
 pub fn emitConstant(
  self: *Module,
  ty_id: IdRef,

diff --git a/test/behavior/align.zig b/test/behavior/align.zig
@@ -33,8 +33,6 @@ test "default alignment allows unspecified in type syntax" {
 }
 
 test "implicitly decreasing pointer alignment" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  const a: u32 align(4) = 3;
  const b: u32 align(8) = 4;
  try expect(addUnaligned(&a, &b) == 7);
@@ -45,8 +43,6 @@ fn addUnaligned(a: *align(1) const u32, b: *align(1) const u32) u32 {
 }
 
 test "@alignCast pointers" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  var x: u32 align(4) = 1;
  expectsOnly1(&x);
  try expect(x == 2);
@@ -219,8 +215,6 @@ test "alignment and size of structs with 128-bit fields" {
 }
 
 test "@ptrCast preserves alignment of bigger source" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  var x: u32 align(16) = 1234;
  const ptr = @ptrCast(*u8, &x);
  try expect(@TypeOf(ptr) == *align(16) u8);

diff --git a/test/behavior/array.zig b/test/behavior/array.zig
@@ -347,7 +347,6 @@ test "read/write through global variable array of struct fields initialized via
 test "implicit cast single-item pointer" {
  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 testImplicitCastSingleItemPtr();
  comptime try testImplicitCastSingleItemPtr();
@@ -542,7 +541,6 @@ test "sentinel element count towards the ABI size calculation" {
  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 {

diff --git a/test/behavior/asm.zig b/test/behavior/asm.zig
@@ -15,6 +15,10 @@ comptime {
  \\.type this_is_my_alias, @function;
  \\.set this_is_my_alias, derp;
  );
+ } else if (builtin.zig_backend == .stage2_spirv64) {
+ asm (
+ \\%a = OpString "hello there"
+ );
  }
 }
 
@@ -24,7 +28,6 @@ test "module level assembly" {
  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;
 
  if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
 

diff --git a/test/behavior/atomics.zig b/test/behavior/atomics.zig
@@ -120,7 +120,6 @@ test "128-bit cmpxchg" {
  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_arm) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
  try test_u128_cmpxchg();
  comptime try test_u128_cmpxchg();
@@ -313,7 +312,6 @@ test "atomicrmw with 128-bit ints" {
 
  if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
  if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
  // TODO "ld.lld: undefined symbol: __sync_lock_test_and_set_16" on -mcpu x86_64
  if (builtin.cpu.arch == .x86_64 and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;

diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
@@ -82,8 +82,6 @@ test "type equality" {
 }
 
 test "pointer dereferencing" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  var x = @as(i32, 3);
  const y = &x;
 
@@ -134,21 +132,18 @@ fn first4KeysOfHomeRow() []const u8 {
 
 test "return string from function" {
  if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
  try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
 }
 
 test "hex escape" {
  if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
  try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
 }
 
 test "multiline string" {
  if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
  const s1 =
  \\one
@@ -161,7 +156,6 @@ test "multiline string" {
 
 test "multiline string comments at start" {
  if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
  const s1 =
  //\\one
@@ -174,7 +168,6 @@ test "multiline string comments at start" {
 
 test "multiline string comments at end" {
  if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
  const s1 =
  \\one
@@ -187,7 +180,6 @@ test "multiline string comments at end" {
 
 test "multiline string comments in middle" {
  if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
  const s1 =
  \\one
@@ -200,7 +192,6 @@ test "multiline string comments in middle" {
 
 test "multiline string comments at multiple places" {
  if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
  const s1 =
  \\one
@@ -214,14 +205,11 @@ test "multiline string comments at multiple places" {
 }
 
 test "string concatenation simple" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));
 }
 
 test "array mult operator" {
  if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
  try expect(mem.eql(u8, "ab" ** 5, "ababababab"));
 }
@@ -303,8 +291,6 @@ test "function closes over local const" {
 }
 
 test "volatile load and store" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  var number: i32 = 1234;
  const ptr = @as(*volatile i32, &number);
  ptr.* += 1;
@@ -387,7 +373,6 @@ test "take address of parameter" {
  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 testTakeAddressOfParameter(12.34);
 }
@@ -477,7 +462,6 @@ fn nine() u8 {
 test "struct inside 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;
 
  try testStructInFn();
  comptime try testStructInFn();
@@ -599,7 +583,7 @@ test "comptime cast fn to ptr" {
 }
 
 test "equality compare fn ptrs" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+ if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // Test passes but should not
 
  var a = &emptyFn;
  try expect(a == a);
@@ -690,8 +674,6 @@ test "explicit cast optional pointers" {
 }
 
 test "pointer comparison" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  const a = @as([]const u8, "a");
  const b = &a;
  try expect(ptrEql(b, b));
@@ -704,7 +686,6 @@ test "string 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 a = "OK" ++ " IT " ++ "WORKED";
  const b = "OK IT WORKED";
@@ -770,7 +751,6 @@ fn maybe(x: bool) anyerror!?u32 {
 test "auto created variables have correct alignment" {
  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(str: [*]const u8) u32 {
@@ -892,8 +872,6 @@ test "catch in block has correct result location" {
 }
 
 test "labeled block with runtime branch forwards its result location type to break statements" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  const E = enum { a, b };
  var a = false;
  const e: E = blk: {
@@ -1062,8 +1040,6 @@ test "switch inside @as gets correct type" {
 }
 
 test "inline call of function with a switch inside the return statement" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  const S = struct {
  inline fn foo(x: anytype) @TypeOf(x) {
  return switch (x) {
@@ -1147,7 +1123,6 @@ test "returning an opaque type from a function" {
 test "orelse coercion as function argument" {
  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 Loc = struct { start: i32 = -1 };
  const Container = struct {

diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig
@@ -9,7 +9,6 @@ const native_endian = builtin.target.cpu.arch.endian();
 
 test "@bitCast iX -> uX (32, 64)" {
  if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
  const bit_values = [_]usize{ 32, 64 };
 

diff --git a/test/behavior/bitreverse.zig b/test/behavior/bitreverse.zig
@@ -5,7 +5,6 @@ const minInt = std.math.minInt;
 
 test "@bitReverse large exotic integer" {
  if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
  try expect(@bitReverse(@as(u95, 0x123456789abcdef111213141)) == 0x4146424447bd9eac8f351624);
 }

diff --git a/test/behavior/call.zig b/test/behavior/call.zig
@@ -109,7 +109,6 @@ test "result location of function call argument through runtime condition and st
 
 test "function call with 40 arguments" {
  if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
 
  const S = struct {
  fn doTheTest(thirty_nine: i32) !void {
@@ -374,8 +373,6 @@ test "Enum constructed by @Type passed as generic argument" {
 }
 
 test "generic function with generic function parameter" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  const S = struct {
  fn f(comptime a: fn (anytype) anyerror!void, b: anytype) anyerror!void {
  try a(b);
@@ -388,8 +385,6 @@ test "generic function with generic function parameter" {
 }
 
 test "recursive inline call with comptime known argument" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  const S = struct {
  inline fn foo(x: i32) i32 {
  if (x <= 0) {

diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
@@ -322,7 +322,6 @@ test "peer result null and comptime_int" {
 test "*const ?[*]const T to [*c]const [*c]const 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;
 
  var array = [_]u8{ 'o', 'k' };
  const opt_array_ptr: ?[*]const u8 = &array;
@@ -366,7 +365,6 @@ test "return u8 coercing into ?u32 return type" {
  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 {
@@ -428,7 +426,6 @@ test "peer resolve array and const slice" {
  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 testPeerResolveArrayConstSlice(true);
  comptime try testPeerResolveArrayConstSlice(true);

diff --git a/test/behavior/decltest.zig b/test/behavior/decltest.zig
@@ -5,7 +5,5 @@ pub fn the_add_function(a: u32, b: u32) u32 {
 }
 
 test the_add_function {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  if (the_add_function(1, 2) != 3) unreachable;
 }
diff --git a/test/behavior/defer.zig b/test/behavior/defer.zig
@@ -23,8 +23,6 @@ fn testBreakContInDefer(x: usize) void {
 }
 
 test "defer and labeled break" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  var i = @as(usize, 0);
 
  blk: {
@@ -58,7 +56,6 @@ test "return variable while defer expression in scope to modify it" {
  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 S = struct {
  fn doTheTest() !void {

diff --git a/test/behavior/duplicated_test_names.zig b/test/behavior/duplicated_test_names.zig
@@ -15,7 +15,5 @@ comptime {
 test "thingy" {}
 
 test thingy {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  if (thingy(1, 2) != 3) unreachable;
 }
diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig
@@ -1045,7 +1045,6 @@ test "tag name with assigned enum values" {
 test "@tagName on enum literals" {
  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, @tagName(.FooBar), "FooBar"));
  comptime try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));

diff --git a/test/behavior/error.zig b/test/behavior/error.zig
@@ -16,14 +16,12 @@ fn expectError(expected_err: anyerror, observed_err_union: anytype) !void {
 }
 
 test "error values" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
  const a = @errorToInt(error.err1);
  const b = @errorToInt(error.err2);
  try expect(a != b);
 }
 
 test "redefinition of error values allowed" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
  shouldBeNotEqual(error.AnError, error.SecondError);
 }
 fn shouldBeNotEqual(a: anyerror, b: anyerror) void {

diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig
@@ -23,7 +23,6 @@ test "static add one" {
  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(should_be_1235 == 1235);
 }
@@ -48,8 +47,6 @@ test "inline variable gets result of const if" {
 }
 
 test "static function evaluation" {
- if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
-
  try expect(statically_added_number == 3);
 }
 const statically_added_number = staticAdd(1, 2);