authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-05-20 13:54:01-07:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2023-05-20 13:54:01-07:00
log7621e56938ed6d86827c11ee6272db722f350fed
treeaf79c9d211810cd7ea6d3a145fa0e4f08bc85b92
parent413ef3aa38899195d113fc51a5c035a7c15103eb
parentc92cc5798f0ea72ab1c77ae12c6124e5ab090730
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

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

spirv: make more tests pass

44 files changed, 537 insertions(+), 437 deletions(-)

src/codegen/spirv.zig+511-307
......@@ -242,7 +242,7 @@ pub const DeclGen = struct {
242242 return self.spv.declPtr(spv_decl_index).result_id;
243243 }
244244
245 return try self.constant(ty, val);
245 return try self.constant(ty, val, .direct);
246246 }
247247 const index = Air.refToIndex(inst).?;
248248 return self.inst_results.get(index).?; // Assertion means instruction does not dominate usage.
......@@ -369,21 +369,11 @@ pub const DeclGen = struct {
369369 .composite_integer,
370370 };
371371 },
372 .Enum => blk: {
373 var buffer: Type.Payload.Bits = undefined;
374 const int_ty = ty.intTagType(&buffer);
375 const int_info = int_ty.intInfo(target);
376 break :blk ArithmeticTypeInfo{
377 .bits = int_info.bits,
378 .is_vector = false,
379 .signedness = int_info.signedness,
380 .class = .integer,
381 };
382 },
383372 // As of yet, there is no vector support in the self-hosted compiler.
384373 .Vector => self.todo("implement arithmeticTypeInfo for Vector", .{}),
385374 // TODO: For which types is this the case?
386 else => self.todo("implement arithmeticTypeInfo for {}", .{ty.fmt(self.module)}),
375 // else => self.todo("implement arithmeticTypeInfo for {}", .{ty.fmt(self.module)}),
376 else => unreachable,
387377 };
388378 }
389379
......@@ -452,6 +442,37 @@ pub const DeclGen = struct {
452442 }
453443 }
454444
445 /// Construct a struct at runtime.
446 /// result_ty_ref must be a struct type.
447 fn constructStruct(self: *DeclGen, result_ty_ref: SpvType.Ref, constituents: []const IdRef) !IdRef {
448 // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which'
449 // operands are not constant.
450 // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349
451 // For now, just initialize the struct by setting the fields manually...
452 // TODO: Make this OpCompositeConstruct when we can
453 const ptr_composite_id = try self.alloc(result_ty_ref, null);
454 // Note: using 32-bit ints here because usize crashes the translator as well
455 const index_ty_ref = try self.intType(.unsigned, 32);
456 const spv_composite_ty = self.spv.typeRefType(result_ty_ref);
457 const members = spv_composite_ty.payload(.@"struct").members;
458 for (constituents, members, 0..) |constitent_id, member, index| {
459 const index_id = try self.constInt(index_ty_ref, index);
460 const ptr_member_ty_ref = try self.spv.ptrType(member.ty, .Generic, 0);
461 const ptr_id = try self.accessChain(ptr_member_ty_ref, ptr_composite_id, &.{index_id});
462 try self.func.body.emit(self.spv.gpa, .OpStore, .{
463 .pointer = ptr_id,
464 .object = constitent_id,
465 });
466 }
467 const result_id = self.spv.allocId();
468 try self.func.body.emit(self.spv.gpa, .OpLoad, .{
469 .id_result_type = self.typeId(result_ty_ref),
470 .id_result = result_id,
471 .pointer = ptr_composite_id,
472 });
473 return result_id;
474 }
475
455476 const IndirectConstantLowering = struct {
456477 const undef = 0xAA;
457478
......@@ -705,6 +726,10 @@ pub const DeclGen = struct {
705726 try self.lower(ptr_ty, slice.ptr);
706727 try self.addInt(Type.usize, slice.len);
707728 },
729 .null_value, .zero => try self.addNullPtr(try dg.resolveType(ty, .indirect)),
730 .int_u64, .one, .int_big_positive, .lazy_align, .lazy_size => {
731 try self.addInt(Type.usize, val);
732 },
708733 else => |tag| return dg.todo("pointer value of type {s}", .{@tagName(tag)}),
709734 },
710735 .Struct => {
......@@ -996,14 +1021,16 @@ pub const DeclGen = struct {
9961021 /// the constant is more complicated however, it needs to be lowered to an indirect constant, which
9971022 /// is then loaded using OpLoad. Such values are loaded into the UniformConstant storage class by default.
9981023 /// This function should only be called during function code generation.
999 fn constant(self: *DeclGen, ty: Type, val: Value) !IdRef {
1024 fn constant(self: *DeclGen, ty: Type, val: Value, repr: Repr) !IdRef {
10001025 const target = self.getTarget();
10011026 const section = &self.spv.sections.types_globals_constants;
1002 const result_ty_ref = try self.resolveType(ty, .direct);
1027 const result_ty_ref = try self.resolveType(ty, repr);
10031028 const result_ty_id = self.typeId(result_ty_ref);
1004 const result_id = self.spv.allocId();
1029
1030 log.debug("constant: ty = {}, val = {}", .{ ty.fmt(self.module), val.fmtValue(ty, self.module) });
10051031
10061032 if (val.isUndef()) {
1033 const result_id = self.spv.allocId();
10071034 try section.emit(self.spv.gpa, .OpUndef, .{
10081035 .id_result_type = result_ty_id,
10091036 .id_result = result_id,
......@@ -1014,24 +1041,76 @@ pub const DeclGen = struct {
10141041 switch (ty.zigTypeTag()) {
10151042 .Int => {
10161043 if (ty.isSignedInt()) {
1017 try self.genConstInt(result_ty_ref, result_id, val.toSignedInt(target));
1044 return try self.constInt(result_ty_ref, val.toSignedInt(target));
10181045 } else {
1019 try self.genConstInt(result_ty_ref, result_id, val.toUnsignedInt(target));
1046 return try self.constInt(result_ty_ref, val.toUnsignedInt(target));
10201047 }
10211048 },
1022 .Bool => {
1023 const operands = .{ .id_result_type = result_ty_id, .id_result = result_id };
1024 if (val.toBool()) {
1025 try section.emit(self.spv.gpa, .OpConstantTrue, operands);
1049 .Bool => switch (repr) {
1050 .direct => {
1051 const result_id = self.spv.allocId();
1052 const operands = .{ .id_result_type = result_ty_id, .id_result = result_id };
1053 if (val.toBool()) {
1054 try section.emit(self.spv.gpa, .OpConstantTrue, operands);
1055 } else {
1056 try section.emit(self.spv.gpa, .OpConstantFalse, operands);
1057 }
1058 return result_id;
1059 },
1060 .indirect => return try self.constInt(result_ty_ref, @boolToInt(val.toBool())),
1061 },
1062 .Float => {
1063 const result_id = self.spv.allocId();
1064 switch (ty.floatBits(target)) {
1065 16 => try self.spv.emitConstant(result_ty_id, result_id, .{ .float32 = val.toFloat(f16) }),
1066 32 => try self.spv.emitConstant(result_ty_id, result_id, .{ .float32 = val.toFloat(f32) }),
1067 64 => try self.spv.emitConstant(result_ty_id, result_id, .{ .float64 = val.toFloat(f64) }),
1068 80, 128 => unreachable, // TODO
1069 else => unreachable,
1070 }
1071 return result_id;
1072 },
1073 .ErrorSet => {
1074 const value = switch (val.tag()) {
1075 .@"error" => blk: {
1076 const err_name = val.castTag(.@"error").?.data.name;
1077 const kv = try self.module.getErrorValue(err_name);
1078 break :blk @intCast(u16, kv.value);
1079 },
1080 .zero => 0,
1081 else => unreachable,
1082 };
1083
1084 return try self.constInt(result_ty_ref, value);
1085 },
1086 .ErrorUnion => {
1087 const payload_ty = ty.errorUnionPayload();
1088 const is_pl = val.errorUnionIsPayload();
1089 const error_val = if (!is_pl) val else Value.initTag(.zero);
1090
1091 const eu_layout = self.errorUnionLayout(payload_ty);
1092 if (!eu_layout.payload_has_bits) {
1093 return try self.constant(Type.anyerror, error_val, repr);
1094 }
1095
1096 const payload_val = if (val.castTag(.eu_payload)) |pl| pl.data else Value.initTag(.undef);
1097
1098 var members: [2]IdRef = undefined;
1099 if (eu_layout.error_first) {
1100 members[0] = try self.constant(Type.anyerror, error_val, .indirect);
1101 members[1] = try self.constant(payload_ty, payload_val, .indirect);
10261102 } else {
1027 try section.emit(self.spv.gpa, .OpConstantFalse, operands);
1103 members[0] = try self.constant(payload_ty, payload_val, .indirect);
1104 members[1] = try self.constant(Type.anyerror, error_val, .indirect);
10281105 }
1106 return try self.spv.constComposite(result_ty_ref, &members);
10291107 },
10301108 // TODO: We can handle most pointers here (decl refs etc), because now they emit an extra
10311109 // OpVariable that is not really required.
10321110 else => {
10331111 // The value cannot be generated directly, so generate it as an indirect constant,
10341112 // and then perform an OpLoad.
1113 const result_id = self.spv.allocId();
10351114 const alignment = ty.abiAlignment(target);
10361115 const spv_decl_index = try self.spv.allocDecl(.global);
10371116
......@@ -1053,10 +1132,9 @@ pub const DeclGen = struct {
10531132 });
10541133 // TODO: Convert bools? This logic should hook into `load`. It should be a dead
10551134 // path though considering .Bool is handled above.
1135 return result_id;
10561136 },
10571137 }
1058
1059 return result_id;
10601138 }
10611139
10621140 /// Turn a Zig type into a SPIR-V Type, and return its type result-id.
......@@ -1592,10 +1670,23 @@ pub const DeclGen = struct {
15921670 }
15931671 }
15941672
1673 fn boolToInt(self: *DeclGen, result_ty_ref: SpvType.Ref, condition_id: IdRef) !IdRef {
1674 const zero_id = try self.constInt(result_ty_ref, 0);
1675 const one_id = try self.constInt(result_ty_ref, 1);
1676 const result_id = self.spv.allocId();
1677 try self.func.body.emit(self.spv.gpa, .OpSelect, .{
1678 .id_result_type = self.typeId(result_ty_ref),
1679 .id_result = result_id,
1680 .condition = condition_id,
1681 .object_1 = one_id,
1682 .object_2 = zero_id,
1683 });
1684 return result_id;
1685 }
1686
15951687 /// Convert representation from indirect (in memory) to direct (in 'register')
15961688 /// This converts the argument type from resolveType(ty, .indirect) to resolveType(ty, .direct).
15971689 fn convertToDirect(self: *DeclGen, ty: Type, operand_id: IdRef) !IdRef {
1598 // const direct_ty_ref = try self.resolveType(ty, .direct);
15991690 return switch (ty.zigTypeTag()) {
16001691 .Bool => blk: {
16011692 const direct_bool_ty_ref = try self.resolveType(ty, .direct);
......@@ -1620,17 +1711,7 @@ pub const DeclGen = struct {
16201711 return switch (ty.zigTypeTag()) {
16211712 .Bool => blk: {
16221713 const indirect_bool_ty_ref = try self.resolveType(ty, .indirect);
1623 const zero_id = try self.constInt(indirect_bool_ty_ref, 0);
1624 const one_id = try self.constInt(indirect_bool_ty_ref, 1);
1625 const result_id = self.spv.allocId();
1626 try self.func.body.emit(self.spv.gpa, .OpSelect, .{
1627 .id_result_type = self.typeId(indirect_bool_ty_ref),
1628 .id_result = result_id,
1629 .condition = operand_id,
1630 .object_1 = one_id,
1631 .object_2 = zero_id,
1632 });
1633 break :blk result_id;
1714 break :blk self.boolToInt(indirect_bool_ty_ref, operand_id);
16341715 },
16351716 else => operand_id,
16361717 };
......@@ -1714,6 +1795,9 @@ pub const DeclGen = struct {
17141795
17151796 .shuffle => try self.airShuffle(inst),
17161797
1798 .ptr_add => try self.airPtrAdd(inst),
1799 .ptr_sub => try self.airPtrSub(inst),
1800
17171801 .bit_and => try self.airBinOpSimple(inst, .OpBitwiseAnd),
17181802 .bit_or => try self.airBinOpSimple(inst, .OpBitwiseOr),
17191803 .xor => try self.airBinOpSimple(inst, .OpBitwiseXor),
......@@ -1722,8 +1806,8 @@ pub const DeclGen = struct {
17221806
17231807 .shl => try self.airShift(inst, .OpShiftLeftLogical),
17241808
1725 .bitcast => try self.airBitcast(inst),
1726 .intcast, .trunc => try self.airIntcast(inst),
1809 .bitcast => try self.airBitCast(inst),
1810 .intcast, .trunc => try self.airIntCast(inst),
17271811 .ptrtoint => try self.airPtrToInt(inst),
17281812 .int_to_float => try self.airIntToFloat(inst),
17291813 .float_to_int => try self.airFloatToInt(inst),
......@@ -1734,6 +1818,7 @@ pub const DeclGen = struct {
17341818 .slice_elem_ptr => try self.airSliceElemPtr(inst),
17351819 .slice_elem_val => try self.airSliceElemVal(inst),
17361820 .ptr_elem_ptr => try self.airPtrElemPtr(inst),
1821 .ptr_elem_val => try self.airPtrElemVal(inst),
17371822
17381823 .get_union_tag => try self.airGetUnionTag(inst),
17391824 .struct_field_val => try self.airStructFieldVal(inst),
......@@ -1743,12 +1828,12 @@ pub const DeclGen = struct {
17431828 .struct_field_ptr_index_2 => try self.airStructFieldPtrIndex(inst, 2),
17441829 .struct_field_ptr_index_3 => try self.airStructFieldPtrIndex(inst, 3),
17451830
1746 .cmp_eq => try self.airCmp(inst, .OpFOrdEqual, .OpLogicalEqual, .OpIEqual),
1747 .cmp_neq => try self.airCmp(inst, .OpFOrdNotEqual, .OpLogicalNotEqual, .OpINotEqual),
1748 .cmp_gt => try self.airCmp(inst, .OpFOrdGreaterThan, .OpSGreaterThan, .OpUGreaterThan),
1749 .cmp_gte => try self.airCmp(inst, .OpFOrdGreaterThanEqual, .OpSGreaterThanEqual, .OpUGreaterThanEqual),
1750 .cmp_lt => try self.airCmp(inst, .OpFOrdLessThan, .OpSLessThan, .OpULessThan),
1751 .cmp_lte => try self.airCmp(inst, .OpFOrdLessThanEqual, .OpSLessThanEqual, .OpULessThanEqual),
1831 .cmp_eq => try self.airCmp(inst, .eq),
1832 .cmp_neq => try self.airCmp(inst, .neq),
1833 .cmp_gt => try self.airCmp(inst, .gt),
1834 .cmp_gte => try self.airCmp(inst, .gte),
1835 .cmp_lt => try self.airCmp(inst, .lt),
1836 .cmp_lte => try self.airCmp(inst, .lte),
17521837
17531838 .arg => self.airArg(),
17541839 .alloc => try self.airAlloc(inst),
......@@ -1944,64 +2029,83 @@ pub const DeclGen = struct {
19442029 .float, .bool => unreachable,
19452030 }
19462031
1947 // The operand type must be the same as the result type in SPIR-V.
2032 // The operand type must be the same as the result type in SPIR-V, which
2033 // is the same as in Zig.
19482034 const operand_ty_ref = try self.resolveType(operand_ty, .direct);
19492035 const operand_ty_id = self.typeId(operand_ty_ref);
19502036
1951 const op_result_id = blk: {
1952 // Construct the SPIR-V result type.
1953 // It is almost the same as the zig one, except that the fields must be the same type
1954 // and they must be unsigned.
1955 const overflow_result_ty_ref = try self.spv.simpleStructType(&.{
1956 .{ .ty = operand_ty_ref, .name = "res" },
1957 .{ .ty = operand_ty_ref, .name = "ov" },
1958 });
1959 const result_id = self.spv.allocId();
1960 try self.func.body.emit(self.spv.gpa, .OpIAddCarry, .{
1961 .id_result_type = self.typeId(overflow_result_ty_ref),
1962 .id_result = result_id,
1963 .operand_1 = lhs,
1964 .operand_2 = rhs,
1965 });
1966 break :blk result_id;
1967 };
1968
1969 // Now convert the SPIR-V flavor result into a Zig-flavor result.
1970 // First, extract the two fields.
1971 const unsigned_result = try self.extractField(operand_ty, op_result_id, 0);
1972 const overflow = try self.extractField(operand_ty, op_result_id, 1);
1973
1974 // We need to convert the results to the types that Zig expects here.
1975 // The `result` is the same type except unsigned, so we can just bitcast that.
1976 // TODO: This can be removed in Kernels as there are only unsigned ints. Maybe for
1977 // shaders as well?
1978 const result = try self.bitcast(operand_ty_id, unsigned_result);
1979
1980 // The overflow needs to be converted into whatever is used to represent it in Zig.
1981 const casted_overflow = blk: {
1982 const ov_ty = result_ty.tupleFields().types[1];
1983 const ov_ty_id = try self.resolveTypeId(ov_ty);
1984 const result_id = self.spv.allocId();
1985 try self.func.body.emit(self.spv.gpa, .OpUConvert, .{
1986 .id_result_type = ov_ty_id,
1987 .id_result = result_id,
1988 .unsigned_value = overflow,
1989 });
1990 break :blk result_id;
1991 };
2037 const bool_ty_ref = try self.resolveType(Type.bool, .direct);
19922038
1993 // TODO: If copying this function for borrow, make sure to convert -1 to 1 as appropriate.
2039 const ov_ty = result_ty.tupleFields().types[1];
2040 // Note: result is stored in a struct, so indirect representation.
2041 const ov_ty_ref = try self.resolveType(ov_ty, .indirect);
19942042
1995 // Finally, construct the Zig type.
1996 // Layout is result, overflow.
1997 const result_id = self.spv.allocId();
1998 const constituents = [_]IdRef{ result, casted_overflow };
1999 try self.func.body.emit(self.spv.gpa, .OpCompositeConstruct, .{
2043 // TODO: Operations other than addition.
2044 const value_id = self.spv.allocId();
2045 try self.func.body.emit(self.spv.gpa, .OpIAdd, .{
20002046 .id_result_type = operand_ty_id,
2001 .id_result = result_id,
2002 .constituents = &constituents,
2047 .id_result = value_id,
2048 .operand_1 = lhs,
2049 .operand_2 = rhs,
2050 });
2051
2052 const overflowed_id = switch (info.signedness) {
2053 .unsigned => blk: {
2054 // Overflow happened if the result is smaller than either of the operands. It doesn't matter which.
2055 const overflowed_id = self.spv.allocId();
2056 try self.func.body.emit(self.spv.gpa, .OpULessThan, .{
2057 .id_result_type = self.typeId(bool_ty_ref),
2058 .id_result = overflowed_id,
2059 .operand_1 = value_id,
2060 .operand_2 = lhs,
2061 });
2062 break :blk overflowed_id;
2063 },
2064 .signed => blk: {
2065 // Overflow happened if:
2066 // - rhs is negative and value > lhs
2067 // - rhs is positive and value < lhs
2068 // This can be shortened to:
2069 // (rhs < 0 && value > lhs) || (rhs >= 0 && value <= lhs)
2070 // = (rhs < 0) == (value > lhs)
2071 // Note that signed overflow is also wrapping in spir-v.
2072
2073 const rhs_lt_zero_id = self.spv.allocId();
2074 const zero_id = try self.constInt(operand_ty_ref, 0);
2075 try self.func.body.emit(self.spv.gpa, .OpSLessThan, .{
2076 .id_result_type = self.typeId(bool_ty_ref),
2077 .id_result = rhs_lt_zero_id,
2078 .operand_1 = rhs,
2079 .operand_2 = zero_id,
2080 });
2081
2082 const value_gt_lhs_id = self.spv.allocId();
2083 try self.func.body.emit(self.spv.gpa, .OpSGreaterThan, .{
2084 .id_result_type = self.typeId(bool_ty_ref),
2085 .id_result = value_gt_lhs_id,
2086 .operand_1 = value_id,
2087 .operand_2 = lhs,
2088 });
2089
2090 const overflowed_id = self.spv.allocId();
2091 try self.func.body.emit(self.spv.gpa, .OpLogicalEqual, .{
2092 .id_result_type = self.typeId(bool_ty_ref),
2093 .id_result = overflowed_id,
2094 .operand_1 = rhs_lt_zero_id,
2095 .operand_2 = value_gt_lhs_id,
2096 });
2097 break :blk overflowed_id;
2098 },
2099 };
2100
2101 // Construct the struct that Zig wants as result.
2102 // The value should already be the correct type.
2103 const ov_id = try self.boolToInt(ov_ty_ref, overflowed_id);
2104 const result_ty_ref = try self.resolveType(result_ty, .direct);
2105 return try self.constructStruct(result_ty_ref, &.{
2106 value_id,
2107 ov_id,
20032108 });
2004 return result_id;
20052109 }
20062110
20072111 fn airShuffle(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -2040,85 +2144,262 @@ pub const DeclGen = struct {
20402144 return result_id;
20412145 }
20422146
2043 fn airCmp(self: *DeclGen, inst: Air.Inst.Index, comptime fop: Opcode, comptime sop: Opcode, comptime uop: Opcode) !?IdRef {
2044 if (self.liveness.isUnused(inst)) return null;
2045 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
2046 var lhs_id = try self.resolve(bin_op.lhs);
2047 var rhs_id = try self.resolve(bin_op.rhs);
2147 /// AccessChain is essentially PtrAccessChain with 0 as initial argument. The effective
2148 /// difference lies in whether the resulting type of the first dereference will be the
2149 /// same as that of the base pointer, or that of a dereferenced base pointer. AccessChain
2150 /// is the latter and PtrAccessChain is the former.
2151 fn accessChain(
2152 self: *DeclGen,
2153 result_ty_ref: SpvType.Ref,
2154 base: IdRef,
2155 indexes: []const IdRef,
2156 ) !IdRef {
20482157 const result_id = self.spv.allocId();
2049 const result_type_id = try self.resolveTypeId(Type.bool);
2050 const op_ty = self.air.typeOf(bin_op.lhs);
2051 assert(op_ty.eql(self.air.typeOf(bin_op.rhs), self.module));
2158 try self.func.body.emit(self.spv.gpa, .OpInBoundsAccessChain, .{
2159 .id_result_type = self.typeId(result_ty_ref),
2160 .id_result = result_id,
2161 .base = base,
2162 .indexes = indexes,
2163 });
2164 return result_id;
2165 }
20522166
2053 // Comparisons are generally applicable to both scalar and vector operations in SPIR-V,
2054 // but int and float versions of operations require different opcodes.
2055 const info = try self.arithmeticTypeInfo(op_ty);
2167 fn ptrAccessChain(
2168 self: *DeclGen,
2169 result_ty_ref: SpvType.Ref,
2170 base: IdRef,
2171 element: IdRef,
2172 indexes: []const IdRef,
2173 ) !IdRef {
2174 const result_id = self.spv.allocId();
2175 try self.func.body.emit(self.spv.gpa, .OpInBoundsPtrAccessChain, .{
2176 .id_result_type = self.typeId(result_ty_ref),
2177 .id_result = result_id,
2178 .base = base,
2179 .element = element,
2180 .indexes = indexes,
2181 });
2182 return result_id;
2183 }
20562184
2057 const opcode_index: usize = switch (info.class) {
2058 .composite_integer => {
2059 return self.todo("binary operations for composite integers", .{});
2185 fn ptrAdd(self: *DeclGen, result_ty: Type, ptr_ty: Type, ptr_id: IdRef, offset_id: IdRef) !IdRef {
2186 const result_ty_ref = try self.resolveType(result_ty, .direct);
2187
2188 switch (ptr_ty.ptrSize()) {
2189 .One => {
2190 // Pointer to array
2191 // TODO: Is this correct?
2192 return try self.accessChain(result_ty_ref, ptr_id, &.{offset_id});
20602193 },
2061 .float => 0,
2062 .bool => 1,
2063 .strange_integer => blk: {
2064 const op_ty_ref = try self.resolveType(op_ty, .direct);
2065 lhs_id = try self.maskStrangeInt(op_ty_ref, lhs_id, info.bits);
2066 rhs_id = try self.maskStrangeInt(op_ty_ref, rhs_id, info.bits);
2067 break :blk switch (info.signedness) {
2068 .signed => @as(usize, 1),
2069 .unsigned => @as(usize, 2),
2070 };
2194 .C, .Many => {
2195 return try self.ptrAccessChain(result_ty_ref, ptr_id, offset_id, &.{});
20712196 },
2072 .integer => switch (info.signedness) {
2073 .signed => @as(usize, 1),
2074 .unsigned => @as(usize, 2),
2197 .Slice => {
2198 // TODO: This is probably incorrect. A slice should be returned here, though this is what llvm does.
2199 const slice_ptr_id = try self.extractField(result_ty, ptr_id, 0);
2200 return try self.ptrAccessChain(result_ty_ref, slice_ptr_id, offset_id, &.{});
20752201 },
2076 };
2202 }
2203 }
20772204
2078 const operands = .{
2079 .id_result_type = result_type_id,
2080 .id_result = result_id,
2081 .operand_1 = lhs_id,
2082 .operand_2 = rhs_id,
2083 };
2205 fn airPtrAdd(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
2206 if (self.liveness.isUnused(inst)) return null;
2207 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
2208 const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
2209 const ptr_id = try self.resolve(bin_op.lhs);
2210 const offset_id = try self.resolve(bin_op.rhs);
2211 const ptr_ty = self.air.typeOf(bin_op.lhs);
2212 const result_ty = self.air.typeOfIndex(inst);
20842213
2085 switch (opcode_index) {
2086 0 => try self.func.body.emit(self.spv.gpa, fop, operands),
2087 1 => try self.func.body.emit(self.spv.gpa, sop, operands),
2088 2 => try self.func.body.emit(self.spv.gpa, uop, operands),
2089 else => unreachable,
2090 }
2214 return try self.ptrAdd(result_ty, ptr_ty, ptr_id, offset_id);
2215 }
2216
2217 fn airPtrSub(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
2218 if (self.liveness.isUnused(inst)) return null;
2219 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
2220 const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
2221 const ptr_id = try self.resolve(bin_op.lhs);
2222 const ptr_ty = self.air.typeOf(bin_op.lhs);
2223 const offset_id = try self.resolve(bin_op.rhs);
2224 const offset_ty = self.air.typeOf(bin_op.rhs);
2225 const offset_ty_ref = try self.resolveType(offset_ty, .direct);
2226 const result_ty = self.air.typeOfIndex(inst);
2227
2228 const negative_offset_id = self.spv.allocId();
2229 try self.func.body.emit(self.spv.gpa, .OpSNegate, .{
2230 .id_result_type = self.typeId(offset_ty_ref),
2231 .id_result = negative_offset_id,
2232 .operand = offset_id,
2233 });
2234 return try self.ptrAdd(result_ty, ptr_ty, ptr_id, negative_offset_id);
2235 }
2236
2237 fn cmp(
2238 self: *DeclGen,
2239 comptime op: std.math.CompareOperator,
2240 bool_ty_id: IdRef,
2241 ty: Type,
2242 lhs_id: IdRef,
2243 rhs_id: IdRef,
2244 ) !IdRef {
2245 var cmp_lhs_id = lhs_id;
2246 var cmp_rhs_id = rhs_id;
2247 const opcode: Opcode = opcode: {
2248 var int_buffer: Type.Payload.Bits = undefined;
2249 const op_ty = switch (ty.zigTypeTag()) {
2250 .Int, .Bool, .Float => ty,
2251 .Enum => ty.intTagType(&int_buffer),
2252 .ErrorSet => Type.u16,
2253 .Pointer => blk: {
2254 // Note that while SPIR-V offers OpPtrEqual and OpPtrNotEqual, they are
2255 // currently not implemented in the SPIR-V LLVM translator. Thus, we emit these using
2256 // OpConvertPtrToU...
2257 cmp_lhs_id = self.spv.allocId();
2258 cmp_rhs_id = self.spv.allocId();
2259
2260 const usize_ty_id = self.typeId(try self.sizeType());
2261
2262 try self.func.body.emit(self.spv.gpa, .OpConvertPtrToU, .{
2263 .id_result_type = usize_ty_id,
2264 .id_result = cmp_lhs_id,
2265 .pointer = lhs_id,
2266 });
2267
2268 try self.func.body.emit(self.spv.gpa, .OpConvertPtrToU, .{
2269 .id_result_type = usize_ty_id,
2270 .id_result = cmp_rhs_id,
2271 .pointer = rhs_id,
2272 });
20912273
2274 break :blk Type.usize;
2275 },
2276 .Optional => unreachable, // TODO
2277 else => unreachable,
2278 };
2279
2280 const info = try self.arithmeticTypeInfo(op_ty);
2281 const signedness = switch (info.class) {
2282 .composite_integer => {
2283 return self.todo("binary operations for composite integers", .{});
2284 },
2285 .float => break :opcode switch (op) {
2286 .eq => .OpFOrdEqual,
2287 .neq => .OpFOrdNotEqual,
2288 .lt => .OpFOrdLessThan,
2289 .lte => .OpFOrdLessThanEqual,
2290 .gt => .OpFOrdGreaterThan,
2291 .gte => .OpFOrdGreaterThanEqual,
2292 },
2293 .bool => break :opcode switch (op) {
2294 .eq => .OpIEqual,
2295 .neq => .OpINotEqual,
2296 else => unreachable,
2297 },
2298 .strange_integer => sign: {
2299 const op_ty_ref = try self.resolveType(op_ty, .direct);
2300 // Mask operands before performing comparison.
2301 cmp_lhs_id = try self.maskStrangeInt(op_ty_ref, cmp_lhs_id, info.bits);
2302 cmp_rhs_id = try self.maskStrangeInt(op_ty_ref, cmp_rhs_id, info.bits);
2303 break :sign info.signedness;
2304 },
2305 .integer => info.signedness,
2306 };
2307
2308 break :opcode switch (signedness) {
2309 .unsigned => switch (op) {
2310 .eq => .OpIEqual,
2311 .neq => .OpINotEqual,
2312 .lt => .OpULessThan,
2313 .lte => .OpULessThanEqual,
2314 .gt => .OpUGreaterThan,
2315 .gte => .OpUGreaterThanEqual,
2316 },
2317 .signed => switch (op) {
2318 .eq => .OpIEqual,
2319 .neq => .OpINotEqual,
2320 .lt => .OpSLessThan,
2321 .lte => .OpSLessThanEqual,
2322 .gt => .OpSGreaterThan,
2323 .gte => .OpSGreaterThanEqual,
2324 },
2325 };
2326 };
2327
2328 const result_id = self.spv.allocId();
2329 try self.func.body.emitRaw(self.spv.gpa, opcode, 4);
2330 self.func.body.writeOperand(spec.IdResultType, bool_ty_id);
2331 self.func.body.writeOperand(spec.IdResult, result_id);
2332 self.func.body.writeOperand(spec.IdResultType, cmp_lhs_id);
2333 self.func.body.writeOperand(spec.IdResultType, cmp_rhs_id);
20922334 return result_id;
20932335 }
20942336
2095 fn bitcast(self: *DeclGen, target_type_id: IdResultType, value_id: IdRef) !IdRef {
2337 fn airCmp(
2338 self: *DeclGen,
2339 inst: Air.Inst.Index,
2340 comptime op: std.math.CompareOperator,
2341 ) !?IdRef {
2342 if (self.liveness.isUnused(inst)) return null;
2343 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
2344 const lhs_id = try self.resolve(bin_op.lhs);
2345 const rhs_id = try self.resolve(bin_op.rhs);
2346 const bool_ty_id = try self.resolveTypeId(Type.bool);
2347 const ty = self.air.typeOf(bin_op.lhs);
2348 assert(ty.eql(self.air.typeOf(bin_op.rhs), self.module));
2349
2350 return try self.cmp(op, bool_ty_id, ty, lhs_id, rhs_id);
2351 }
2352
2353 fn bitCast(
2354 self: *DeclGen,
2355 dst_ty: Type,
2356 src_ty: Type,
2357 src_id: IdRef,
2358 ) !IdRef {
2359 const dst_ty_ref = try self.resolveType(dst_ty, .direct);
20962360 const result_id = self.spv.allocId();
2097 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
2098 .id_result_type = target_type_id,
2099 .id_result = result_id,
2100 .operand = value_id,
2101 });
2361
2362 // TODO: Some more cases are missing here
2363 // See fn bitCast in llvm.zig
2364
2365 if (src_ty.zigTypeTag() == .Int and dst_ty.isPtrAtRuntime()) {
2366 try self.func.body.emit(self.spv.gpa, .OpConvertUToPtr, .{
2367 .id_result_type = self.typeId(dst_ty_ref),
2368 .id_result = result_id,
2369 .integer_value = src_id,
2370 });
2371 } else {
2372 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
2373 .id_result_type = self.typeId(dst_ty_ref),
2374 .id_result = result_id,
2375 .operand = src_id,
2376 });
2377 }
21022378 return result_id;
21032379 }
21042380
2105 fn airBitcast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
2381 fn airBitCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
21062382 if (self.liveness.isUnused(inst)) return null;
21072383 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
21082384 const operand_id = try self.resolve(ty_op.operand);
2109 const result_type_id = try self.resolveTypeId(self.air.typeOfIndex(inst));
2110 return try self.bitcast(result_type_id, operand_id);
2385 const operand_ty = self.air.typeOf(ty_op.operand);
2386 const result_ty = self.air.typeOfIndex(inst);
2387 return try self.bitCast(result_ty, operand_ty, operand_id);
21112388 }
21122389
2113 fn airIntcast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
2390 fn airIntCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
21142391 if (self.liveness.isUnused(inst)) return null;
21152392
21162393 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
21172394 const operand_id = try self.resolve(ty_op.operand);
21182395 const dest_ty = self.air.typeOfIndex(inst);
2119 const dest_info = try self.arithmeticTypeInfo(dest_ty);
21202396 const dest_ty_id = try self.resolveTypeId(dest_ty);
21212397
2398 const target = self.getTarget();
2399 const dest_info = dest_ty.intInfo(target);
2400
2401 // TODO: Masking?
2402
21222403 const result_id = self.spv.allocId();
21232404 switch (dest_info.signedness) {
21242405 .signed => try self.func.body.emit(self.spv.gpa, .OpSConvert, .{
......@@ -2221,11 +2502,7 @@ pub const DeclGen = struct {
22212502 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
22222503 const field_ty = self.air.typeOfIndex(inst);
22232504 const operand_id = try self.resolve(ty_op.operand);
2224 return try self.extractField(
2225 field_ty,
2226 operand_id,
2227 field,
2228 );
2505 return try self.extractField(field_ty, operand_id, field);
22292506 }
22302507
22312508 fn airSliceElemPtr(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -2233,30 +2510,14 @@ pub const DeclGen = struct {
22332510 const slice_ty = self.air.typeOf(bin_op.lhs);
22342511 if (!slice_ty.isVolatilePtr() and self.liveness.isUnused(inst)) return null;
22352512
2236 const slice = try self.resolve(bin_op.lhs);
2237 const index = try self.resolve(bin_op.rhs);
2238
2239 const spv_ptr_ty = try self.resolveTypeId(self.air.typeOfIndex(inst));
2513 const slice_id = try self.resolve(bin_op.lhs);
2514 const index_id = try self.resolve(bin_op.rhs);
22402515
2241 const slice_ptr = blk: {
2242 const result_id = self.spv.allocId();
2243 try self.func.body.emit(self.spv.gpa, .OpCompositeExtract, .{
2244 .id_result_type = spv_ptr_ty,
2245 .id_result = result_id,
2246 .composite = slice,
2247 .indexes = &.{0},
2248 });
2249 break :blk result_id;
2250 };
2516 const ptr_ty = self.air.typeOfIndex(inst);
2517 const ptr_ty_ref = try self.resolveType(ptr_ty, .direct);
22512518
2252 const result_id = self.spv.allocId();
2253 try self.func.body.emit(self.spv.gpa, .OpInBoundsPtrAccessChain, .{
2254 .id_result_type = spv_ptr_ty,
2255 .id_result = result_id,
2256 .base = slice_ptr,
2257 .element = index,
2258 });
2259 return result_id;
2519 const slice_ptr = try self.extractField(ptr_ty, slice_id, 0);
2520 return try self.ptrAccessChain(ptr_ty_ref, slice_ptr, index_id, &.{});
22602521 }
22612522
22622523 fn airSliceElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -2264,61 +2525,64 @@ pub const DeclGen = struct {
22642525 const slice_ty = self.air.typeOf(bin_op.lhs);
22652526 if (!slice_ty.isVolatilePtr() and self.liveness.isUnused(inst)) return null;
22662527
2267 const slice = try self.resolve(bin_op.lhs);
2268 const index = try self.resolve(bin_op.rhs);
2528 const slice_id = try self.resolve(bin_op.lhs);
2529 const index_id = try self.resolve(bin_op.rhs);
22692530
22702531 var slice_buf: Type.SlicePtrFieldTypeBuffer = undefined;
2271 const ptr_ty_id = try self.resolveTypeId(slice_ty.slicePtrFieldType(&slice_buf));
2272
2273 const slice_ptr = blk: {
2274 const result_id = self.spv.allocId();
2275 try self.func.body.emit(self.spv.gpa, .OpCompositeExtract, .{
2276 .id_result_type = ptr_ty_id,
2277 .id_result = result_id,
2278 .composite = slice,
2279 .indexes = &.{0},
2280 });
2281 break :blk result_id;
2282 };
2283
2284 const elem_ptr = blk: {
2285 const result_id = self.spv.allocId();
2286 try self.func.body.emit(self.spv.gpa, .OpInBoundsPtrAccessChain, .{
2287 .id_result_type = ptr_ty_id,
2288 .id_result = result_id,
2289 .base = slice_ptr,
2290 .element = index,
2291 });
2292 break :blk result_id;
2293 };
2532 const ptr_ty = slice_ty.slicePtrFieldType(&slice_buf);
2533 const ptr_ty_ref = try self.resolveType(ptr_ty, .direct);
22942534
2535 const slice_ptr = try self.extractField(ptr_ty, slice_id, 0);
2536 const elem_ptr = try self.ptrAccessChain(ptr_ty_ref, slice_ptr, index_id, &.{});
22952537 return try self.load(slice_ty, elem_ptr);
22962538 }
22972539
2540 fn ptrElemPtr(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef, index_id: IdRef) !IdRef {
2541 // Construct new pointer type for the resulting pointer
2542 const elem_ty = ptr_ty.elemType2(); // use elemType() so that we get T for *[N]T.
2543 const elem_ty_ref = try self.resolveType(elem_ty, .direct);
2544 const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, spvStorageClass(ptr_ty.ptrAddressSpace()), 0);
2545 if (ptr_ty.isSinglePointer()) {
2546 // Pointer-to-array. In this case, the resulting pointer is not of the same type
2547 // as the ptr_ty (we want a *T, not a *[N]T), and hence we need to use accessChain.
2548 return try self.accessChain(elem_ptr_ty_ref, ptr_id, &.{index_id});
2549 } else {
2550 // Resulting pointer type is the same as the ptr_ty, so use ptrAccessChain
2551 return try self.ptrAccessChain(elem_ptr_ty_ref, ptr_id, index_id, &.{});
2552 }
2553 }
2554
22982555 fn airPtrElemPtr(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
22992556 if (self.liveness.isUnused(inst)) return null;
23002557
23012558 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
23022559 const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
23032560 const ptr_ty = self.air.typeOf(bin_op.lhs);
2304 const result_ty = self.air.typeOfIndex(inst);
23052561 const elem_ty = ptr_ty.childType();
23062562 // TODO: Make this return a null ptr or something
23072563 if (!elem_ty.hasRuntimeBitsIgnoreComptime()) return null;
23082564
2309 const result_type_id = try self.resolveTypeId(result_ty);
2310 const base_ptr = try self.resolve(bin_op.lhs);
2311 const rhs = try self.resolve(bin_op.rhs);
2565 const ptr_id = try self.resolve(bin_op.lhs);
2566 const index_id = try self.resolve(bin_op.rhs);
2567 return try self.ptrElemPtr(ptr_ty, ptr_id, index_id);
2568 }
23122569
2313 const result_id = self.spv.allocId();
2314 const indexes = [_]IdRef{rhs};
2315 try self.func.body.emit(self.spv.gpa, .OpInBoundsAccessChain, .{
2316 .id_result_type = result_type_id,
2317 .id_result = result_id,
2318 .base = base_ptr,
2319 .indexes = &indexes,
2320 });
2321 return result_id;
2570 fn airPtrElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
2571 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
2572 const ptr_ty = self.air.typeOf(bin_op.lhs);
2573 const ptr_id = try self.resolve(bin_op.lhs);
2574 const index_id = try self.resolve(bin_op.rhs);
2575
2576 const elem_ptr_id = try self.ptrElemPtr(ptr_ty, ptr_id, index_id);
2577
2578 // If we have a pointer-to-array, construct an element pointer to use with load()
2579 // If we pass ptr_ty directly, it will attempt to load the entire array rather than
2580 // just an element.
2581 var elem_ptr_info = ptr_ty.ptrInfo();
2582 elem_ptr_info.data.size = .One;
2583 const elem_ptr_ty = Type.initPayload(&elem_ptr_info.base);
2584
2585 return try self.load(elem_ptr_ty, elem_ptr_id);
23222586 }
23232587
23242588 fn airGetUnionTag(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -2344,24 +2608,15 @@ pub const DeclGen = struct {
23442608 const struct_field = self.air.extraData(Air.StructField, ty_pl.payload).data;
23452609
23462610 const struct_ty = self.air.typeOf(struct_field.struct_operand);
2347 const object = try self.resolve(struct_field.struct_operand);
2611 const object_id = try self.resolve(struct_field.struct_operand);
23482612 const field_index = struct_field.field_index;
23492613 const field_ty = struct_ty.structFieldType(field_index);
2350 const field_ty_id = try self.resolveTypeId(field_ty);
23512614
23522615 if (!field_ty.hasRuntimeBitsIgnoreComptime()) return null;
23532616
23542617 assert(struct_ty.zigTypeTag() == .Struct); // Cannot do unions yet.
23552618
2356 const result_id = self.spv.allocId();
2357 const indexes = [_]u32{field_index};
2358 try self.func.body.emit(self.spv.gpa, .OpCompositeExtract, .{
2359 .id_result_type = field_ty_id,
2360 .id_result = result_id,
2361 .composite = object,
2362 .indexes = &indexes,
2363 });
2364 return result_id;
2619 return try self.extractField(field_ty, object_id, field_index);
23652620 }
23662621
23672622 fn structFieldPtr(
......@@ -2379,16 +2634,8 @@ pub const DeclGen = struct {
23792634 const u32_ty_id = self.typeId(try self.intType(.unsigned, 32));
23802635 const field_index_id = self.spv.allocId();
23812636 try self.spv.emitConstant(u32_ty_id, field_index_id, .{ .uint32 = field_index });
2382 const result_id = self.spv.allocId();
2383 const result_type_id = try self.resolveTypeId(result_ptr_ty);
2384 const indexes = [_]IdRef{field_index_id};
2385 try self.func.body.emit(self.spv.gpa, .OpInBoundsAccessChain, .{
2386 .id_result_type = result_type_id,
2387 .id_result = result_id,
2388 .base = object_ptr,
2389 .indexes = &indexes,
2390 });
2391 return result_id;
2637 const result_ty_ref = try self.resolveType(result_ptr_ty, .direct);
2638 return try self.accessChain(result_ty_ref, object_ptr, &.{field_index_id});
23922639 },
23932640 },
23942641 else => unreachable, // TODO
......@@ -2422,76 +2669,45 @@ pub const DeclGen = struct {
24222669 return result_id;
24232670 }
24242671
2425 fn variable(
2672 // Allocate a function-local variable, with possible initializer.
2673 // This function returns a pointer to a variable of type `ty_ref`,
2674 // which is in the Generic address space. The variable is actually
2675 // placed in the Function address space.
2676 fn alloc(
24262677 self: *DeclGen,
2427 comptime context: enum { function, global },
2428 result_id: IdRef,
2429 ptr_ty_ref: SpvType.Ref,
2678 ty_ref: SpvType.Ref,
24302679 initializer: ?IdRef,
2431 ) !void {
2432 const storage_class = self.spv.typeRefType(ptr_ty_ref).payload(.pointer).storage_class;
2433 const actual_storage_class = switch (storage_class) {
2434 .Generic => switch (context) {
2435 .function => .Function,
2436 .global => .CrossWorkgroup,
2437 },
2438 else => storage_class,
2439 };
2440 const actual_ptr_ty_ref = switch (storage_class) {
2441 .Generic => try self.spv.changePtrStorageClass(ptr_ty_ref, actual_storage_class),
2442 else => ptr_ty_ref,
2443 };
2444 const alloc_result_id = switch (storage_class) {
2445 .Generic => self.spv.allocId(),
2446 else => result_id,
2447 };
2680 ) !IdRef {
2681 const fn_ptr_ty_ref = try self.spv.ptrType(ty_ref, .Function, 0);
2682 const general_ptr_ty_ref = try self.spv.ptrType(ty_ref, .Generic, 0);
24482683
2449 const section = switch (actual_storage_class) {
2450 .Generic => unreachable,
2451 // SPIR-V requires that OpVariable declarations for locals go into the first block, so we are just going to
2452 // directly generate them into func.prologue instead of the body.
2453 .Function => &self.func.prologue,
2454 else => &self.spv.sections.types_globals_constants,
2455 };
2456 try section.emit(self.spv.gpa, .OpVariable, .{
2457 .id_result_type = self.typeId(actual_ptr_ty_ref),
2458 .id_result = alloc_result_id,
2459 .storage_class = actual_storage_class,
2684 // SPIR-V requires that OpVariable declarations for locals go into the first block, so we are just going to
2685 // directly generate them into func.prologue instead of the body.
2686 const var_id = self.spv.allocId();
2687 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
2688 .id_result_type = self.typeId(fn_ptr_ty_ref),
2689 .id_result = var_id,
2690 .storage_class = .Function,
24602691 .initializer = initializer,
24612692 });
24622693
2463 if (storage_class != .Generic) {
2464 return;
2465 }
2466
2467 // Now we need to convert the pointer.
2468 // If this is a function local, we need to perform the conversion at runtime. Otherwise, we can do
2469 // it ahead of time using OpSpecConstantOp.
2470 switch (actual_storage_class) {
2471 .Function => try self.func.body.emit(self.spv.gpa, .OpPtrCastToGeneric, .{
2472 .id_result_type = self.typeId(ptr_ty_ref),
2473 .id_result = result_id,
2474 .pointer = alloc_result_id,
2475 }),
2476 // TODO: Can we do without this cast or move it to runtime?
2477 else => {
2478 const const_ptr_id = try self.makePointerConstant(section, actual_ptr_ty_ref, alloc_result_id);
2479 try section.emitSpecConstantOp(self.spv.gpa, .OpPtrCastToGeneric, .{
2480 .id_result_type = self.typeId(ptr_ty_ref),
2481 .id_result = result_id,
2482 .pointer = const_ptr_id,
2483 });
2484 },
2485 }
2694 // Convert to a generic pointer
2695 const result_id = self.spv.allocId();
2696 try self.func.body.emit(self.spv.gpa, .OpPtrCastToGeneric, .{
2697 .id_result_type = self.typeId(general_ptr_ty_ref),
2698 .id_result = result_id,
2699 .pointer = var_id,
2700 });
2701 return result_id;
24862702 }
24872703
24882704 fn airAlloc(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
24892705 if (self.liveness.isUnused(inst)) return null;
2490 const ty = self.air.typeOfIndex(inst);
2491 const result_ty_ref = try self.resolveType(ty, .direct);
2492 const result_id = self.spv.allocId();
2493 try self.variable(.function, result_id, result_ty_ref, null);
2494 return result_id;
2706 const ptr_ty = self.air.typeOfIndex(inst);
2707 assert(ptr_ty.ptrAddressSpace() == .generic);
2708 const child_ty = ptr_ty.childType();
2709 const child_ty_ref = try self.resolveType(child_ty, .indirect);
2710 return try self.alloc(child_ty_ref, null);
24952711 }
24962712
24972713 fn airArg(self: *DeclGen) IdRef {
......@@ -2778,13 +2994,7 @@ pub const DeclGen = struct {
27782994 }
27792995
27802996 const err_union_ty_ref = try self.resolveType(err_union_ty, .direct);
2781 const result_id = self.spv.allocId();
2782 try self.func.body.emit(self.spv.gpa, .OpCompositeConstruct, .{
2783 .id_result_type = self.typeId(err_union_ty_ref),
2784 .id_result = result_id,
2785 .constituents = members.slice(),
2786 });
2787 return result_id;
2997 return try self.constructStruct(err_union_ty_ref, members.slice());
27882998 }
27892999
27903000 fn airIsNull(self: *DeclGen, inst: Air.Inst.Index, pred: enum { is_null, is_non_null }) !?IdRef {
......@@ -2884,14 +3094,8 @@ pub const DeclGen = struct {
28843094 }
28853095
28863096 const optional_ty_ref = try self.resolveType(optional_ty, .direct);
2887 const result_id = self.spv.allocId();
28883097 const members = [_]IdRef{ operand_id, try self.constBool(true, .indirect) };
2889 try self.func.body.emit(self.spv.gpa, .OpCompositeConstruct, .{
2890 .id_result_type = self.typeId(optional_ty_ref),
2891 .id_result = result_id,
2892 .constituents = &members,
2893 });
2894 return result_id;
3098 return try self.constructStruct(optional_ty_ref, &members);
28953099 }
28963100
28973101 fn airSwitchBr(self: *DeclGen, inst: Air.Inst.Index) !void {
src/codegen/spirv/Module.zig+10
......@@ -774,6 +774,16 @@ pub fn changePtrStorageClass(self: *Module, ptr_ty_ref: Type.Ref, new_storage_cl
774774 return try self.resolveType(Type.initPayload(&payload.base));
775775}
776776
777pub fn constComposite(self: *Module, ty_ref: Type.Ref, members: []const IdRef) !IdRef {
778 const result_id = self.allocId();
779 try self.sections.types_globals_constants.emit(self.gpa, .OpSpecConstantComposite, .{
780 .id_result_type = self.typeId(ty_ref),
781 .id_result = result_id,
782 .constituents = members,
783 });
784 return result_id;
785}
786
777787pub fn emitConstant(
778788 self: *Module,
779789 ty_id: IdRef,
test/behavior/align.zig-6
......@@ -33,8 +33,6 @@ test "default alignment allows unspecified in type syntax" {
3333}
3434
3535test "implicitly decreasing pointer alignment" {
36 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
37
3836 const a: u32 align(4) = 3;
3937 const b: u32 align(8) = 4;
4038 try expect(addUnaligned(&a, &b) == 7);
......@@ -45,8 +43,6 @@ fn addUnaligned(a: *align(1) const u32, b: *align(1) const u32) u32 {
4543}
4644
4745test "@alignCast pointers" {
48 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
49
5046 var x: u32 align(4) = 1;
5147 expectsOnly1(&x);
5248 try expect(x == 2);
......@@ -219,8 +215,6 @@ test "alignment and size of structs with 128-bit fields" {
219215}
220216
221217test "@ptrCast preserves alignment of bigger source" {
222 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
223
224218 var x: u32 align(16) = 1234;
225219 const ptr = @ptrCast(*u8, &x);
226220 try expect(@TypeOf(ptr) == *align(16) u8);
test/behavior/array.zig-2
......@@ -347,7 +347,6 @@ test "read/write through global variable array of struct fields initialized via
347347test "implicit cast single-item pointer" {
348348 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
349349 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
350 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
351350
352351 try testImplicitCastSingleItemPtr();
353352 comptime try testImplicitCastSingleItemPtr();
......@@ -542,7 +541,6 @@ test "sentinel element count towards the ABI size calculation" {
542541 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
543542 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
544543 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
545 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
546544
547545 const S = struct {
548546 fn doTheTest() !void {
test/behavior/asm.zig+4-1
......@@ -15,6 +15,10 @@ comptime {
1515 \\.type this_is_my_alias, @function;
1616 \\.set this_is_my_alias, derp;
1717 );
18 } else if (builtin.zig_backend == .stage2_spirv64) {
19 asm (
20 \\%a = OpString "hello there"
21 );
1822 }
1923}
2024
......@@ -24,7 +28,6 @@ test "module level assembly" {
2428 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2529 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2630 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
27 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2831
2932 if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support inline assembly
3033
test/behavior/atomics.zig-2
......@@ -120,7 +120,6 @@ test "128-bit cmpxchg" {
120120 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
121121 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
122122 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
123 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
124123
125124 try test_u128_cmpxchg();
126125 comptime try test_u128_cmpxchg();
......@@ -313,7 +312,6 @@ test "atomicrmw with 128-bit ints" {
313312
314313 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
315314 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
316 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
317315
318316 // TODO "ld.lld: undefined symbol: __sync_lock_test_and_set_16" on -mcpu x86_64
319317 if (builtin.cpu.arch == .x86_64 and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
test/behavior/basic.zig+1-26
......@@ -82,8 +82,6 @@ test "type equality" {
8282}
8383
8484test "pointer dereferencing" {
85 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
86
8785 var x = @as(i32, 3);
8886 const y = &x;
8987
......@@ -134,21 +132,18 @@ fn first4KeysOfHomeRow() []const u8 {
134132
135133test "return string from function" {
136134 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
137 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
138135
139136 try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
140137}
141138
142139test "hex escape" {
143140 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
144 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
145141
146142 try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
147143}
148144
149145test "multiline string" {
150146 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
151 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
152147
153148 const s1 =
154149 \\one
......@@ -161,7 +156,6 @@ test "multiline string" {
161156
162157test "multiline string comments at start" {
163158 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
164 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
165159
166160 const s1 =
167161 //\\one
......@@ -174,7 +168,6 @@ test "multiline string comments at start" {
174168
175169test "multiline string comments at end" {
176170 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
177 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
178171
179172 const s1 =
180173 \\one
......@@ -187,7 +180,6 @@ test "multiline string comments at end" {
187180
188181test "multiline string comments in middle" {
189182 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
190 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
191183
192184 const s1 =
193185 \\one
......@@ -200,7 +192,6 @@ test "multiline string comments in middle" {
200192
201193test "multiline string comments at multiple places" {
202194 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
203 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
204195
205196 const s1 =
206197 \\one
......@@ -214,14 +205,11 @@ test "multiline string comments at multiple places" {
214205}
215206
216207test "string concatenation simple" {
217 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
218
219208 try expect(mem.eql(u8, "OK" ++ " IT " ++ "WORKED", "OK IT WORKED"));
220209}
221210
222211test "array mult operator" {
223212 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
224 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
225213
226214 try expect(mem.eql(u8, "ab" ** 5, "ababababab"));
227215}
......@@ -303,8 +291,6 @@ test "function closes over local const" {
303291}
304292
305293test "volatile load and store" {
306 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
307
308294 var number: i32 = 1234;
309295 const ptr = @as(*volatile i32, &number);
310296 ptr.* += 1;
......@@ -387,7 +373,6 @@ test "take address of parameter" {
387373 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
388374 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
389375 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
390 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
391376
392377 try testTakeAddressOfParameter(12.34);
393378}
......@@ -477,7 +462,6 @@ fn nine() u8 {
477462test "struct inside function" {
478463 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
479464 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
480 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
481465
482466 try testStructInFn();
483467 comptime try testStructInFn();
......@@ -599,7 +583,7 @@ test "comptime cast fn to ptr" {
599583}
600584
601585test "equality compare fn ptrs" {
602 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
586 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // Test passes but should not
603587
604588 var a = &emptyFn;
605589 try expect(a == a);
......@@ -690,8 +674,6 @@ test "explicit cast optional pointers" {
690674}
691675
692676test "pointer comparison" {
693 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
694
695677 const a = @as([]const u8, "a");
696678 const b = &a;
697679 try expect(ptrEql(b, b));
......@@ -704,7 +686,6 @@ test "string concatenation" {
704686 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
705687 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
706688 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
707 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
708689
709690 const a = "OK" ++ " IT " ++ "WORKED";
710691 const b = "OK IT WORKED";
......@@ -770,7 +751,6 @@ fn maybe(x: bool) anyerror!?u32 {
770751test "auto created variables have correct alignment" {
771752 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
772753 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
773 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
774754
775755 const S = struct {
776756 fn foo(str: [*]const u8) u32 {
......@@ -892,8 +872,6 @@ test "catch in block has correct result location" {
892872}
893873
894874test "labeled block with runtime branch forwards its result location type to break statements" {
895 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
896
897875 const E = enum { a, b };
898876 var a = false;
899877 const e: E = blk: {
......@@ -1062,8 +1040,6 @@ test "switch inside @as gets correct type" {
10621040}
10631041
10641042test "inline call of function with a switch inside the return statement" {
1065 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1066
10671043 const S = struct {
10681044 inline fn foo(x: anytype) @TypeOf(x) {
10691045 return switch (x) {
......@@ -1147,7 +1123,6 @@ test "returning an opaque type from a function" {
11471123test "orelse coercion as function argument" {
11481124 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11491125 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1150 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11511126
11521127 const Loc = struct { start: i32 = -1 };
11531128 const Container = struct {
test/behavior/bitcast.zig-1
......@@ -9,7 +9,6 @@ const native_endian = builtin.target.cpu.arch.endian();
99
1010test "@bitCast iX -> uX (32, 64)" {
1111 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
12 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1312
1413 const bit_values = [_]usize{ 32, 64 };
1514
test/behavior/bitreverse.zig-1
......@@ -5,7 +5,6 @@ const minInt = std.math.minInt;
55
66test "@bitReverse large exotic integer" {
77 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
8 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
98
109 try expect(@bitReverse(@as(u95, 0x123456789abcdef111213141)) == 0x4146424447bd9eac8f351624);
1110}
test/behavior/call.zig-5
......@@ -109,7 +109,6 @@ test "result location of function call argument through runtime condition and st
109109
110110test "function call with 40 arguments" {
111111 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
112 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
113112
114113 const S = struct {
115114 fn doTheTest(thirty_nine: i32) !void {
......@@ -374,8 +373,6 @@ test "Enum constructed by @Type passed as generic argument" {
374373}
375374
376375test "generic function with generic function parameter" {
377 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
378
379376 const S = struct {
380377 fn f(comptime a: fn (anytype) anyerror!void, b: anytype) anyerror!void {
381378 try a(b);
......@@ -388,8 +385,6 @@ test "generic function with generic function parameter" {
388385}
389386
390387test "recursive inline call with comptime known argument" {
391 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
392
393388 const S = struct {
394389 inline fn foo(x: i32) i32 {
395390 if (x <= 0) {
test/behavior/cast.zig-3
......@@ -322,7 +322,6 @@ test "peer result null and comptime_int" {
322322test "*const ?[*]const T to [*c]const [*c]const T" {
323323 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
324324 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
325 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
326325
327326 var array = [_]u8{ 'o', 'k' };
328327 const opt_array_ptr: ?[*]const u8 = &array;
......@@ -366,7 +365,6 @@ test "return u8 coercing into ?u32 return type" {
366365 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
367366 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
368367 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
369 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
370368
371369 const S = struct {
372370 fn doTheTest() !void {
......@@ -428,7 +426,6 @@ test "peer resolve array and const slice" {
428426 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
429427 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
430428 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
431 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
432429
433430 try testPeerResolveArrayConstSlice(true);
434431 comptime try testPeerResolveArrayConstSlice(true);
test/behavior/decltest.zig-2
......@@ -5,7 +5,5 @@ pub fn the_add_function(a: u32, b: u32) u32 {
55}
66
77test the_add_function {
8 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9
108 if (the_add_function(1, 2) != 3) unreachable;
119}
test/behavior/defer.zig-3
......@@ -23,8 +23,6 @@ fn testBreakContInDefer(x: usize) void {
2323}
2424
2525test "defer and labeled break" {
26 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
27
2826 var i = @as(usize, 0);
2927
3028 blk: {
......@@ -58,7 +56,6 @@ test "return variable while defer expression in scope to modify it" {
5856 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
5957 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
6058 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
61 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
6259
6360 const S = struct {
6461 fn doTheTest() !void {
test/behavior/duplicated_test_names.zig-2
......@@ -15,7 +15,5 @@ comptime {
1515test "thingy" {}
1616
1717test thingy {
18 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
19
2018 if (thingy(1, 2) != 3) unreachable;
2119}
test/behavior/enum.zig-1
......@@ -1045,7 +1045,6 @@ test "tag name with assigned enum values" {
10451045test "@tagName on enum literals" {
10461046 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10471047 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1048 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10491048
10501049 try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
10511050 comptime try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
test/behavior/error.zig-2
......@@ -16,14 +16,12 @@ fn expectError(expected_err: anyerror, observed_err_union: anytype) !void {
1616}
1717
1818test "error values" {
19 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2019 const a = @errorToInt(error.err1);
2120 const b = @errorToInt(error.err2);
2221 try expect(a != b);
2322}
2423
2524test "redefinition of error values allowed" {
26 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2725 shouldBeNotEqual(error.AnError, error.SecondError);
2826}
2927fn shouldBeNotEqual(a: anyerror, b: anyerror) void {
test/behavior/eval.zig-3
......@@ -23,7 +23,6 @@ test "static add one" {
2323 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2424 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2525 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
26 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2726
2827 try expect(should_be_1235 == 1235);
2928}
......@@ -48,8 +47,6 @@ test "inline variable gets result of const if" {
4847}
4948
5049test "static function evaluation" {
51 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
52
5350 try expect(statically_added_number == 3);
5451}
5552const statically_added_number = staticAdd(1, 2);
test/behavior/floatop.zig-2
......@@ -506,7 +506,6 @@ test "@fabs" {
506506 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
507507 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
508508 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
509 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
510509
511510 comptime try testFabs();
512511 try testFabs();
......@@ -621,7 +620,6 @@ test "@floor" {
621620 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
622621 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
623622 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
624 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
625623
626624 comptime try testFloor();
627625 try testFloor();
test/behavior/fn.zig-4
......@@ -5,8 +5,6 @@ const expect = testing.expect;
55const expectEqual = testing.expectEqual;
66
77test "params" {
8 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9
108 try expect(testParamsAdd(22, 11) == 33);
119}
1210fn testParamsAdd(a: i32, b: i32) i32 {
......@@ -14,8 +12,6 @@ fn testParamsAdd(a: i32, b: i32) i32 {
1412}
1513
1614test "local variables" {
17 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
18
1915 testLocVars(2);
2016}
2117fn testLocVars(b: i32) void {
test/behavior/fn_delegation.zig-1
......@@ -34,7 +34,6 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {
3434test "fn delegation" {
3535 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
3636 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
37 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
3837
3938 const foo = Foo{};
4039 try expect(foo.one() == 11);
test/behavior/fn_in_struct_in_comptime.zig-2
......@@ -13,8 +13,6 @@ fn get_foo() fn (*u8) usize {
1313}
1414
1515test "define a function in an anonymous struct in comptime" {
16 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
17
1816 const foo = get_foo();
1917 try expect(foo(@intToPtr(*u8, 12345)) == 12345);
2018}
test/behavior/for.zig-4
......@@ -22,8 +22,6 @@ test "continue in for loop" {
2222}
2323
2424test "break from outer for loop" {
25 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
26
2725 try testBreakOuter();
2826 comptime try testBreakOuter();
2927}
......@@ -41,8 +39,6 @@ fn testBreakOuter() !void {
4139}
4240
4341test "continue outer for loop" {
44 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
45
4642 try testContinueOuter();
4743 comptime try testContinueOuter();
4844}
test/behavior/generics.zig-3
......@@ -5,8 +5,6 @@ const expect = testing.expect;
55const expectEqual = testing.expectEqual;
66
77test "one param, explicit comptime" {
8 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9
108 var x: usize = 0;
119 x += checkSize(i32);
1210 x += checkSize(bool);
......@@ -21,7 +19,6 @@ fn checkSize(comptime T: type) usize {
2119test "simple generic fn" {
2220 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2321 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
24 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2522
2623 try expect(max(i32, 3, -1) == 3);
2724 try expect(max(u8, 1, 100) == 100);
test/behavior/if.zig-2
......@@ -71,8 +71,6 @@ test "labeled break inside comptime if inside runtime if" {
7171}
7272
7373test "const result loc, runtime if cond, else unreachable" {
74 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
75
7674 const Num = enum { One, Two };
7775
7876 var t = true;
test/behavior/inttoptr.zig-1
......@@ -14,7 +14,6 @@ test "mutate through ptr initialized with constant intToPtr value" {
1414 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1515 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1616 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1817
1918 forceCompilerAnalyzeBranchHardCodedPtrDereference(false);
2019}
test/behavior/math.zig-2
......@@ -208,7 +208,6 @@ test "float equality" {
208208 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
209209 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
210210 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
211 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
212211
213212 const x: f64 = 0.012;
214213 const y: f64 = x + 1.0;
......@@ -684,7 +683,6 @@ test "@addWithOverflow" {
684683 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
685684 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
686685 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
687 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
688686
689687 {
690688 var a: u8 = 250;
test/behavior/maximum_minimum.zig-2
......@@ -129,8 +129,6 @@ test "@min/max for floats" {
129129}
130130
131131test "@min/@max on lazy values" {
132 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
133
134132 const A = extern struct { u8_4: [4]u8 };
135133 const B = extern struct { u8_16: [16]u8 };
136134 const size = @max(@sizeOf(A), @sizeOf(B));
test/behavior/memcpy.zig+11-9
......@@ -67,14 +67,16 @@ fn testMemcpyDestManyPtr() !void {
6767}
6868
6969comptime {
70 const S = struct {
71 buffer: [8]u8 = undefined,
72 fn set(self: *@This(), items: []const u8) void {
73 @memcpy(self.buffer[0..items.len], items);
74 }
75 };
70 if (builtin.zig_backend != .stage2_spirv64) {
71 const S = struct {
72 buffer: [8]u8 = undefined,
73 fn set(self: *@This(), items: []const u8) void {
74 @memcpy(self.buffer[0..items.len], items);
75 }
76 };
7677
77 var s = S{};
78 s.set("hello");
79 if (!std.mem.eql(u8, s.buffer[0..5], "hello")) @compileError("bad");
78 var s = S{};
79 s.set("hello");
80 if (!std.mem.eql(u8, s.buffer[0..5], "hello")) @compileError("bad");
81 }
8082}
test/behavior/optional.zig-2
......@@ -8,7 +8,6 @@ const expectEqualStrings = std.testing.expectEqualStrings;
88test "passing an optional integer as a parameter" {
99 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1010 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1211
1312 const S = struct {
1413 fn entry() bool {
......@@ -422,7 +421,6 @@ test "optional of noreturn used with orelse" {
422421}
423422
424423test "orelse on C pointer" {
425 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
426424
427425 // TODO https://github.com/ziglang/zig/issues/6597
428426 const foo: [*c]const u8 = "hey";
test/behavior/packed-struct.zig-2
......@@ -7,7 +7,6 @@ const native_endian = builtin.cpu.arch.endian();
77
88test "flags in packed structs" {
99 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1110
1211 const Flags1 = packed struct {
1312 // first 8 bits
......@@ -94,7 +93,6 @@ test "flags in packed structs" {
9493
9594test "consistent size of packed structs" {
9695 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
97 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9896
9997 const TxData1 = packed struct { data: u8, _23: u23, full: bool = false };
10098 const TxData2 = packed struct { data: u9, _22: u22, full: bool = false };
test/behavior/pointers.zig-6
......@@ -5,7 +5,6 @@ const expect = testing.expect;
55const expectError = testing.expectError;
66
77test "dereference pointer" {
8 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
98 comptime try testDerefPtr();
109 try testDerefPtr();
1110}
......@@ -20,7 +19,6 @@ fn testDerefPtr() !void {
2019test "pointer arithmetic" {
2120 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2221 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2422
2523 var ptr: [*]const u8 = "abcd";
2624
......@@ -53,7 +51,6 @@ fn PtrOf(comptime T: type) type {
5351
5452test "implicit cast single item pointer to C pointer and back" {
5553 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
56 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
5754
5855 var y: u8 = 11;
5956 var x: [*c]u8 = &y;
......@@ -70,7 +67,6 @@ test "initialize const optional C pointer to null" {
7067
7168test "assigning integer to C pointer" {
7269 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
73 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
7470
7571 var x: i32 = 0;
7672 var y: i32 = 1;
......@@ -87,7 +83,6 @@ test "assigning integer to C pointer" {
8783
8884test "C pointer comparison and arithmetic" {
8985 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
90 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
9186
9287 const S = struct {
9388 fn doTheTest() !void {
......@@ -304,7 +299,6 @@ test "null terminated pointer" {
304299test "allow any sentinel" {
305300 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
306301 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
307 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
308302
309303 const S = struct {
310304 fn doTheTest() !void {
test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig-1
......@@ -8,7 +8,6 @@ test "reference a variable in an if after an if in the 2nd switch prong" {
88 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
99 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1010 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1211
1312 try foo(true, Num.Two, false, "aoeu");
1413 try expect(!ok);
test/behavior/reflection.zig-1
......@@ -28,7 +28,6 @@ fn dummy(a: bool, b: i32, c: f32) i32 {
2828test "reflection: @field" {
2929 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3030 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
31 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
3231
3332 var f = Foo{
3433 .one = 42,
test/behavior/sizeof_and_typeof.zig-3
......@@ -140,8 +140,6 @@ test "@sizeOf(T) == 0 doesn't force resolving struct size" {
140140}
141141
142142test "@TypeOf() has no runtime side effects" {
143 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
144
145143 const S = struct {
146144 fn foo(comptime T: type, ptr: *T) T {
147145 ptr.* += 1;
......@@ -156,7 +154,6 @@ test "@TypeOf() has no runtime side effects" {
156154
157155test "branching logic inside @TypeOf" {
158156 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
159 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
160157
161158 const S = struct {
162159 var data: i32 = 0;
test/behavior/slice.zig-3
......@@ -200,8 +200,6 @@ test "slicing pointer by length" {
200200const x = @intToPtr([*]i32, 0x1000)[0..0x500];
201201const y = x[0x100..];
202202test "compile time slice of pointer to hard coded address" {
203 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
204
205203 try expect(@ptrToInt(x) == 0x1000);
206204 try expect(x.len == 0x500);
207205
......@@ -673,7 +671,6 @@ test "array mult of slice gives ptr to array" {
673671
674672test "slice bounds in comptime concatenation" {
675673 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
676 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
677674
678675 const bs = comptime blk: {
679676 const b = "........1........";
test/behavior/struct.zig-3
......@@ -11,7 +11,6 @@ top_level_field: i32,
1111test "top level fields" {
1212 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1313 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1514
1615 var instance = @This(){
1716 .top_level_field = 1234,
......@@ -122,8 +121,6 @@ test "struct byval assign" {
122121}
123122
124123test "call struct static method" {
125 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
126
127124 const result = StructWithNoFields.add(3, 4);
128125 try expect(result == 7);
129126}
test/behavior/switch.zig-3
......@@ -215,7 +215,6 @@ fn poll() void {
215215
216216test "switch on global mutable var isn't constant-folded" {
217217 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
218 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
219218
220219 while (state < 2) {
221220 poll();
......@@ -349,8 +348,6 @@ fn returnsFalse() bool {
349348 }
350349}
351350test "switch on const enum with var" {
352 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
353
354351 try expect(!returnsFalse());
355352}
356353
test/behavior/this.zig-2
......@@ -21,8 +21,6 @@ fn add(x: i32, y: i32) i32 {
2121}
2222
2323test "this refer to module call private fn" {
24 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
25
2624 try expect(module.add(1, 2) == 3);
2725}
2826
test/behavior/threadlocal.zig-2
......@@ -11,7 +11,6 @@ test "thread local variable" {
1111 else => return error.SkipZigTest,
1212 }; // TODO
1313 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1514
1615 const S = struct {
1716 threadlocal var t: i32 = 1234;
......@@ -47,7 +46,6 @@ test "reference a global threadlocal variable" {
4746 else => return error.SkipZigTest,
4847 }; // TODO
4948 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
50 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
5149
5250 _ = nrfx_uart_rx(&g_uart0);
5351}
test/behavior/type.zig-1
......@@ -491,7 +491,6 @@ test "Type.Fn" {
491491 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
492492 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
493493 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
494 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
495494
496495 const some_opaque = opaque {};
497496 const some_ptr = *some_opaque;
test/behavior/type_info.zig-2
......@@ -285,7 +285,6 @@ fn testUnion() !void {
285285
286286test "type info: struct info" {
287287 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
288 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
289288
290289 try testStruct();
291290 comptime try testStruct();
......@@ -513,7 +512,6 @@ test "type info for async frames" {
513512
514513test "Declarations are returned in declaration order" {
515514 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
516 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
517515
518516 const S = struct {
519517 const a = 1;
test/behavior/undefined.zig-1
......@@ -81,7 +81,6 @@ test "assign undefined to struct with method" {
8181
8282test "type name of undefined" {
8383 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
84 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8584
8685 const x = undefined;
8786 try expect(mem.eql(u8, @typeName(@TypeOf(x)), "@TypeOf(undefined)"));
test/behavior/var_args.zig-3
......@@ -14,8 +14,6 @@ fn add(args: anytype) i32 {
1414}
1515
1616test "add arbitrary args" {
17 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
18
1917 try expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
2018 try expect(add(.{@as(i32, 1234)}) == 1234);
2119 try expect(add(.{}) == 0);
......@@ -32,7 +30,6 @@ test "send void arg to var args" {
3230test "pass args directly" {
3331 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
3432 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
35 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
3633
3734 try expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
3835 try expect(addSomeStuff(.{@as(i32, 1234)}) == 1234);
test/behavior/while.zig-3
......@@ -5,7 +5,6 @@ const assert = std.debug.assert;
55
66test "while loop" {
77 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
98
109 var i: i32 = 0;
1110 while (i < 4) {
......@@ -39,8 +38,6 @@ fn staticWhileLoop2() i32 {
3938}
4039
4140test "while with continue expression" {
42 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
43
4441 var sum: i32 = 0;
4542 {
4643 var i: i32 = 0;