motiejus/zig
1
Fork 0
Code Releases Activity

Merge pull request #15240 from Snektron/spirv-basic

Browse Source 
spirv: attempting to get the 'basic' behavior tests running
This commit is contained in:
Andrew Kelley
2023-05-12 14:46:20 -07:00
committed by GitHub
parent 6547d23312 d61dc3a5a2
commit 88d275199c
181 changed files with 1720 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
lib/std/builtin.zig
View File

@@ -836,6 +836,9 @@ pub const CompilerBackend = enum(u64) {
/// The reference implementation self-hosted compiler of Zig, using the
/// sparc64 backend.
stage2_sparc64 = 10,
/// The reference implementation self-hosted compiler of Zig, using the
/// spirv backend.
stage2_spirv64 = 11,
_,
};

12
lib/std/target.zig
View File

@@ -2220,6 +2220,17 @@ pub const Target = struct {
.longdouble => return 128,
},
.opencl => switch (c_type) {
.char => return 8,
.short, .ushort => return 16,
.int, .uint, .float => return 32,
.long, .ulong, .double => return 64,
.longlong, .ulonglong => return 128,
// Note: The OpenCL specification does not guarantee a particular size for long double,
// but clang uses 128 bits.
.longdouble => return 128,
},
.cloudabi,
.kfreebsd,
.lv2,
@@ -2234,7 +2245,6 @@ pub const Target = struct {
.contiki,
.hermit,
.hurd,
.opencl,
.glsl450,
.vulkan,
.driverkit,

1
src/Compilation.zig
View File

@@ -5076,6 +5076,7 @@ pub fn getZigBackend(comp: Compilation) std.builtin.CompilerBackend {
.aarch64, .aarch64_be, .aarch64_32 => .stage2_aarch64,
.riscv64 => .stage2_riscv64,
.sparc64 => .stage2_sparc64,
.spirv64 => .stage2_spirv64,
else => .other,
};
}

602
src/codegen/spirv.zig
View File

@@ -238,6 +238,7 @@ pub const DeclGen = struct {
else => unreachable,
};
const spv_decl_index = try self.resolveDecl(fn_decl_index);
try self.func.decl_deps.put(self.spv.gpa, spv_decl_index, {});
return self.spv.declPtr(spv_decl_index).result_id;
}
@@ -402,12 +403,44 @@ pub const DeclGen = struct {
return result_id;
}
fn genUndef(self: *DeclGen, ty_ref: SpvType.Ref) Error!IdRef {
fn constUndef(self: *DeclGen, ty_ref: SpvType.Ref) !IdRef {
const result_id = self.spv.allocId();
try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpUndef, .{ .id_result_type = self.typeId(ty_ref), .id_result = result_id });
try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpUndef, .{
.id_result_type = self.typeId(ty_ref),
.id_result = result_id,
});
return result_id;
}
fn constNull(self: *DeclGen, ty_ref: SpvType.Ref) !IdRef {
const result_id = self.spv.allocId();
try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpConstantNull, .{
.id_result_type = self.typeId(ty_ref),
.id_result = result_id,
});
return result_id;
}
fn constBool(self: *DeclGen, value: bool, repr: Repr) !IdRef {
switch (repr) {
.indirect => {
const int_ty_ref = try self.intType(.unsigned, 1);
return self.constInt(int_ty_ref, @boolToInt(value));
},
.direct => {
const bool_ty_ref = try self.resolveType(Type.bool, .direct);
const result_id = self.spv.allocId();
const operands = .{ .id_result_type = self.typeId(bool_ty_ref), .id_result = result_id };
if (value) {
try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpConstantTrue, operands);
} else {
try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpConstantFalse, operands);
}
return result_id;
},
}
}
const IndirectConstantLowering = struct {
const undef = 0xAA;
@@ -427,7 +460,7 @@ pub const DeclGen = struct {
/// If full, its flushed.
partial_word: std.BoundedArray(u8, @sizeOf(Word)) = .{},
/// The declaration dependencies of the constant we are lowering.
decl_deps: std.ArrayList(SpvModule.Decl.Index),
decl_deps: std.AutoArrayHashMap(SpvModule.Decl.Index, void),
/// Utility function to get the section that instructions should be lowered to.
fn section(self: *@This()) *SpvSection {
@@ -550,14 +583,15 @@ pub const DeclGen = struct {
// just generate an empty pointer. Function pointers are represented by usize for now,
// though.
try self.addInt(Type.usize, Value.initTag(.zero));
// TODO: Add dependency
return;
},
.extern_fn => unreachable, // TODO
else => {
const result_id = dg.spv.allocId();
log.debug("addDeclRef {s} = {}", .{ decl.name, result_id.id });
log.debug("addDeclRef: id = {}, index = {}, name = {s}", .{ result_id.id, @enumToInt(spv_decl_index), decl.name });
try self.decl_deps.append(spv_decl_index);
try self.decl_deps.put(spv_decl_index, {});
const decl_id = dg.spv.declPtr(spv_decl_index).result_id;
// TODO: Do we need a storage class cast here?
@@ -674,7 +708,7 @@ pub const DeclGen = struct {
try self.addConstBool(has_payload);
return;
} else if (ty.optionalReprIsPayload()) {
// Optional representation is a nullable pointer.
// Optional representation is a nullable pointer or slice.
if (val.castTag(.opt_payload)) |payload| {
try self.lower(payload_ty, payload.data);
} else if (has_payload) {
@@ -765,21 +799,18 @@ pub const DeclGen = struct {
const is_pl = val.errorUnionIsPayload();
const error_val = if (!is_pl) val else Value.initTag(.zero);
if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
const eu_layout = dg.errorUnionLayout(payload_ty);
if (!eu_layout.payload_has_bits) {
return try self.lower(Type.anyerror, error_val);
}
const payload_align = payload_ty.abiAlignment(target);
const error_align = Type.anyerror.abiAlignment(target);
const payload_size = payload_ty.abiSize(target);
const error_size = Type.anyerror.abiAlignment(target);
const ty_size = ty.abiSize(target);
const padding = ty_size - payload_size - error_size;
const payload_val = if (val.castTag(.eu_payload)) |pl| pl.data else Value.initTag(.undef);
if (error_align > payload_align) {
if (eu_layout.error_first) {
try self.lower(Type.anyerror, error_val);
try self.lower(payload_ty, payload_val);
} else {
@@ -832,7 +863,8 @@ pub const DeclGen = struct {
assert(storage_class != .Generic and storage_class != .Function);
log.debug("lowerIndirectConstant: ty = {}, val = {}", .{ ty.fmt(self.module), val.fmtDebug() });
const var_id = self.spv.allocId();
log.debug("lowerIndirectConstant: id = {}, index = {}, ty = {}, val = {}", .{ var_id.id, @enumToInt(spv_decl_index), ty.fmt(self.module), val.fmtDebug() });
const section = &self.spv.globals.section;
@@ -868,7 +900,7 @@ pub const DeclGen = struct {
.u32_ty_id = self.typeId(u32_ty_ref),
.members = std.ArrayList(SpvType.Payload.Struct.Member).init(self.gpa),
.initializers = std.ArrayList(IdRef).init(self.gpa),
.decl_deps = std.ArrayList(SpvModule.Decl.Index).init(self.gpa),
.decl_deps = std.AutoArrayHashMap(SpvModule.Decl.Index, void).init(self.gpa),
};
defer icl.members.deinit();
@@ -888,7 +920,6 @@ pub const DeclGen = struct {
.constituents = icl.initializers.items,
});
const var_id = self.spv.allocId();
self.spv.globalPtr(spv_decl_index).?.result_id = var_id;
try section.emit(self.spv.gpa, .OpVariable, .{
.id_result_type = self.typeId(ptr_constant_struct_ty_ref),
@@ -922,7 +953,7 @@ pub const DeclGen = struct {
});
}
try self.spv.declareDeclDeps(spv_decl_index, icl.decl_deps.items);
try self.spv.declareDeclDeps(spv_decl_index, icl.decl_deps.keys());
self.spv.endGlobal(spv_decl_index, begin_inst);
}
@@ -948,11 +979,11 @@ pub const DeclGen = struct {
switch (ty.zigTypeTag()) {
.Int => {
const int_bits = if (ty.isSignedInt())
@bitCast(u64, val.toSignedInt(target))
else
val.toUnsignedInt(target);
try self.genConstInt(result_ty_ref, result_id, int_bits);
if (ty.isSignedInt()) {
try self.genConstInt(result_ty_ref, result_id, val.toSignedInt(target));
} else {
try self.genConstInt(result_ty_ref, result_id, val.toUnsignedInt(target));
}
},
.Bool => {
const operands = .{ .id_result_type = result_ty_id, .id_result = result_id };
@@ -978,7 +1009,8 @@ pub const DeclGen = struct {
false,
alignment,
);
try self.func.decl_deps.append(self.spv.gpa, spv_decl_index);
log.debug("indirect constant: index = {}", .{@enumToInt(spv_decl_index)});
try self.func.decl_deps.put(self.spv.gpa, spv_decl_index, {});
try self.func.body.emit(self.spv.gpa, .OpLoad, .{
.id_result_type = result_ty_id,
@@ -1260,7 +1292,7 @@ pub const DeclGen = struct {
const payload_ty_ref = try self.resolveType(payload_ty, .indirect);
if (ty.optionalReprIsPayload()) {
// Optional is actually a pointer.
// Optional is actually a pointer or a slice.
return payload_ty_ref;
}
@@ -1277,18 +1309,16 @@ pub const DeclGen = struct {
.ErrorUnion => {
const payload_ty = ty.errorUnionPayload();
const error_ty_ref = try self.resolveType(Type.anyerror, .indirect);
if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
const eu_layout = self.errorUnionLayout(payload_ty);
if (!eu_layout.payload_has_bits) {
return error_ty_ref;
}
const payload_ty_ref = try self.resolveType(payload_ty, .indirect);
const payload_align = payload_ty.abiAlignment(target);
const error_align = Type.anyerror.abiAlignment(target);
var members = std.BoundedArray(SpvType.Payload.Struct.Member, 2){};
// Similar to unions, we're going to put the most aligned member first.
if (error_align > payload_align) {
if (eu_layout.error_first) {
// Put the error first
members.appendAssumeCapacity(.{ .ty = error_ty_ref, .name = "error" });
members.appendAssumeCapacity(.{ .ty = payload_ty_ref, .name = "payload" });
@@ -1336,6 +1366,34 @@ pub const DeclGen = struct {
};
}
const ErrorUnionLayout = struct {
payload_has_bits: bool,
error_first: bool,
fn errorFieldIndex(self: @This()) u32 {
assert(self.payload_has_bits);
return if (self.error_first) 0 else 1;
}
fn payloadFieldIndex(self: @This()) u32 {
assert(self.payload_has_bits);
return if (self.error_first) 1 else 0;
}
};
fn errorUnionLayout(self: *DeclGen, payload_ty: Type) ErrorUnionLayout {
const target = self.getTarget();
const error_align = Type.anyerror.abiAlignment(target);
const payload_align = payload_ty.abiAlignment(target);
const error_first = error_align > payload_align;
return .{
.payload_has_bits = payload_ty.hasRuntimeBitsIgnoreComptime(),
.error_first = error_first,
};
}
/// The SPIR-V backend is not yet advanced enough to support the std testing infrastructure.
/// In order to be able to run tests, we "temporarily" lower test kernels into separate entry-
/// points. The test executor will then be able to invoke these to run the tests.
@@ -1416,7 +1474,7 @@ pub const DeclGen = struct {
const spv_decl_index = try self.resolveDecl(self.decl_index);
const decl_id = self.spv.declPtr(spv_decl_index).result_id;
log.debug("genDecl {s} = {}", .{ decl.name, decl_id });
log.debug("genDecl: id = {}, index = {}, name = {s}", .{ decl_id.id, @enumToInt(spv_decl_index), decl.name });
if (decl.val.castTag(.function)) |_| {
assert(decl.ty.zigTypeTag() == .Fn);
@@ -1500,6 +1558,93 @@ pub const DeclGen = struct {
}
}
/// Convert representation from indirect (in memory) to direct (in 'register')
/// This converts the argument type from resolveType(ty, .indirect) to resolveType(ty, .direct).
fn convertToDirect(self: *DeclGen, ty: Type, operand_id: IdRef) !IdRef {
// const direct_ty_ref = try self.resolveType(ty, .direct);
return switch (ty.zigTypeTag()) {
.Bool => blk: {
const direct_bool_ty_ref = try self.resolveType(ty, .direct);
const indirect_bool_ty_ref = try self.resolveType(ty, .indirect);
const zero_id = try self.constInt(indirect_bool_ty_ref, 0);
const result_id = self.spv.allocId();
try self.func.body.emit(self.spv.gpa, .OpINotEqual, .{
.id_result_type = self.typeId(direct_bool_ty_ref),
.id_result = result_id,
.operand_1 = operand_id,
.operand_2 = zero_id,
});
break :blk result_id;
},
else => operand_id,
};
}
/// Convert representation from direct (in 'register) to direct (in memory)
/// This converts the argument type from resolveType(ty, .direct) to resolveType(ty, .indirect).
fn convertToIndirect(self: *DeclGen, ty: Type, operand_id: IdRef) !IdRef {
return switch (ty.zigTypeTag()) {
.Bool => blk: {
const indirect_bool_ty_ref = try self.resolveType(ty, .indirect);
const zero_id = try self.constInt(indirect_bool_ty_ref, 0);
const one_id = try self.constInt(indirect_bool_ty_ref, 1);
const result_id = self.spv.allocId();
try self.func.body.emit(self.spv.gpa, .OpSelect, .{
.id_result_type = self.typeId(indirect_bool_ty_ref),
.id_result = result_id,
.condition = operand_id,
.object_1 = one_id,
.object_2 = zero_id,
});
break :blk result_id;
},
else => operand_id,
};
}
fn extractField(self: *DeclGen, result_ty: Type, object: IdRef, field: u32) !IdRef {
const result_ty_ref = try self.resolveType(result_ty, .indirect);
const result_id = self.spv.allocId();
const indexes = [_]u32{field};
try self.func.body.emit(self.spv.gpa, .OpCompositeExtract, .{
.id_result_type = self.typeId(result_ty_ref),
.id_result = result_id,
.composite = object,
.indexes = &indexes,
});
// Convert bools; direct structs have their field types as indirect values.
return try self.convertToDirect(result_ty, result_id);
}
fn load(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef) !IdRef {
const value_ty = ptr_ty.childType();
const indirect_value_ty_ref = try self.resolveType(value_ty, .indirect);
const result_id = self.spv.allocId();
const access = spec.MemoryAccess.Extended{
.Volatile = ptr_ty.isVolatilePtr(),
};
try self.func.body.emit(self.spv.gpa, .OpLoad, .{
.id_result_type = self.typeId(indirect_value_ty_ref),
.id_result = result_id,
.pointer = ptr_id,
.memory_access = access,
});
return try self.convertToDirect(value_ty, result_id);
}
fn store(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef, value_id: IdRef) !void {
const value_ty = ptr_ty.childType();
const indirect_value_id = try self.convertToIndirect(value_ty, value_id);
const access = spec.MemoryAccess.Extended{
.Volatile = ptr_ty.isVolatilePtr(),
};
try self.func.body.emit(self.spv.gpa, .OpStore, .{
.pointer = ptr_id,
.object = indirect_value_id,
.memory_access = access,
});
}
fn genBody(self: *DeclGen, body: []const Air.Inst.Index) Error!void {
for (body) |inst| {
try self.genInst(inst);
@@ -1543,9 +1688,9 @@ pub const DeclGen = struct {
.shl => try self.airShift(inst, .OpShiftLeftLogical),
.bitcast => try self.airBitcast(inst),
.intcast => try self.airIntcast(inst),
.not => try self.airNot(inst),
.bitcast => try self.airBitcast(inst),
.intcast, .trunc => try self.airIntcast(inst),
.not => try self.airNot(inst),
.slice_ptr => try self.airSliceField(inst, 0),
.slice_len => try self.airSliceField(inst, 1),
@@ -1573,20 +1718,30 @@ pub const DeclGen = struct {
.ret_ptr => try self.airAlloc(inst),
.block => try self.airBlock(inst),
.load => try self.airLoad(inst),
.store => return self.airStore(inst),
.load => try self.airLoad(inst),
.store, .store_safe => return self.airStore(inst),
.br => return self.airBr(inst),
.breakpoint => return,
.cond_br => return self.airCondBr(inst),
.constant => unreachable,
.const_ty => unreachable,
.dbg_stmt => return self.airDbgStmt(inst),
.loop => return self.airLoop(inst),
.ret => return self.airRet(inst),
.ret_load => return self.airRetLoad(inst),
.switch_br => return self.airSwitchBr(inst),
.unreach => return self.airUnreach(),
.br => return self.airBr(inst),
.breakpoint => return,
.cond_br => return self.airCondBr(inst),
.constant => unreachable,
.const_ty => unreachable,
.dbg_stmt => return self.airDbgStmt(inst),
.loop => return self.airLoop(inst),
.ret => return self.airRet(inst),
.ret_load => return self.airRetLoad(inst),
.@"try" => try self.airTry(inst),
.switch_br => return self.airSwitchBr(inst),
.unreach, .trap => return self.airUnreach(),
.unwrap_errunion_err => try self.airErrUnionErr(inst),
.wrap_errunion_err => try self.airWrapErrUnionErr(inst),
.is_null => try self.airIsNull(inst, .is_null),
.is_non_null => try self.airIsNull(inst, .is_non_null),
.optional_payload => try self.airUnwrapOptional(inst),
.wrap_optional => try self.airWrapOptional(inst),
.assembly => try self.airAssembly(inst),
@@ -1749,19 +1904,17 @@ pub const DeclGen = struct {
.float, .bool => unreachable,
}
const operand_ty_id = try self.resolveTypeId(operand_ty);
const result_type_id = try self.resolveTypeId(result_ty);
const overflow_member_ty = try self.intType(.unsigned, info.bits);
const overflow_member_ty_id = self.typeId(overflow_member_ty);
// The operand type must be the same as the result type in SPIR-V.
const operand_ty_ref = try self.resolveType(operand_ty, .direct);
const operand_ty_id = self.typeId(operand_ty_ref);
const op_result_id = blk: {
// Construct the SPIR-V result type.
// It is almost the same as the zig one, except that the fields must be the same type
// and they must be unsigned.
const overflow_result_ty_ref = try self.spv.simpleStructType(&.{
.{ .ty = overflow_member_ty, .name = "res" },
.{ .ty = overflow_member_ty, .name = "ov" },
.{ .ty = operand_ty_ref, .name = "res" },
.{ .ty = operand_ty_ref, .name = "ov" },
});
const result_id = self.spv.allocId();
try self.func.body.emit(self.spv.gpa, .OpIAddCarry, .{
@@ -1775,11 +1928,13 @@ pub const DeclGen = struct {
// Now convert the SPIR-V flavor result into a Zig-flavor result.
// First, extract the two fields.
const unsigned_result = try self.extractField(overflow_member_ty_id, op_result_id, 0);
const overflow = try self.extractField(overflow_member_ty_id, op_result_id, 1);
const unsigned_result = try self.extractField(operand_ty, op_result_id, 0);
const overflow = try self.extractField(operand_ty, op_result_id, 1);
// We need to convert the results to the types that Zig expects here.
// The `result` is the same type except unsigned, so we can just bitcast that.
// TODO: This can be removed in Kernels as there are only unsigned ints. Maybe for
// shaders as well?
const result = try self.bitcast(operand_ty_id, unsigned_result);
// The overflow needs to be converted into whatever is used to represent it in Zig.
@@ -1802,7 +1957,7 @@ pub const DeclGen = struct {
const result_id = self.spv.allocId();
const constituents = [_]IdRef{ result, casted_overflow };
try self.func.body.emit(self.spv.gpa, .OpCompositeConstruct, .{
.id_result_type = result_type_id,
.id_result_type = operand_ty_id,
.id_result = result_id,
.constituents = &constituents,
});
@@ -1954,24 +2109,14 @@ pub const DeclGen = struct {
return result_id;
}
fn extractField(self: *DeclGen, result_ty: IdResultType, object: IdRef, field: u32) !IdRef {
const result_id = self.spv.allocId();
const indexes = [_]u32{field};
try self.func.body.emit(self.spv.gpa, .OpCompositeExtract, .{
.id_result_type = result_ty,
.id_result = result_id,
.composite = object,
.indexes = &indexes,
});
return result_id;
}
fn airSliceField(self: *DeclGen, inst: Air.Inst.Index, field: u32) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const field_ty = self.air.typeOfIndex(inst);
const operand_id = try self.resolve(ty_op.operand);
return try self.extractField(
try self.resolveTypeId(self.air.typeOfIndex(inst)),
try self.resolve(ty_op.operand),
field_ty,
operand_id,
field,
);
}
@@ -2264,15 +2409,15 @@ pub const DeclGen = struct {
return null;
// Combine the result from the blocks using the Phi instruction.
const result_id = self.spv.allocId();
// TODO: OpPhi is limited in the types that it may produce, such as pointers. Figure out which other types
// are not allowed to be created from a phi node, and throw an error for those.
const result_type_id = try self.resolveTypeId(ty);
_ = result_type_id;
try self.func.body.emitRaw(self.spv.gpa, .OpPhi, 2 + @intCast(u16, incoming_blocks.items.len * 2)); // result type + result + variable/parent...
self.func.body.writeOperand(spec.IdResultType, result_type_id);
self.func.body.writeOperand(spec.IdRef, result_id);
for (incoming_blocks.items) |incoming| {
self.func.body.writeOperand(spec.PairIdRefIdRef, .{ incoming.break_value_id, incoming.src_label_id });
@@ -2340,71 +2485,20 @@ pub const DeclGen = struct {
return try self.load(ptr_ty, operand);
}
fn load(self: *DeclGen, ptr_ty: Type, ptr: IdRef) !IdRef {
const value_ty = ptr_ty.childType();
const direct_result_ty_ref = try self.resolveType(value_ty, .direct);
const indirect_result_ty_ref = try self.resolveType(value_ty, .indirect);
const result_id = self.spv.allocId();
const access = spec.MemoryAccess.Extended{
.Volatile = ptr_ty.isVolatilePtr(),
};
try self.func.body.emit(self.spv.gpa, .OpLoad, .{
.id_result_type = self.typeId(indirect_result_ty_ref),
.id_result = result_id,
.pointer = ptr,
.memory_access = access,
});
if (value_ty.zigTypeTag() == .Bool) {
// Convert indirect bool to direct bool
const zero_id = try self.constInt(indirect_result_ty_ref, 0);
const casted_result_id = self.spv.allocId();
try self.func.body.emit(self.spv.gpa, .OpINotEqual, .{
.id_result_type = self.typeId(direct_result_ty_ref),
.id_result = casted_result_id,
.operand_1 = result_id,
.operand_2 = zero_id,
});
return casted_result_id;
}
return result_id;
}
fn airStore(self: *DeclGen, inst: Air.Inst.Index) !void {
const bin_op = self.air.instructions.items(.data)[inst].bin_op;
const ptr_ty = self.air.typeOf(bin_op.lhs);
const ptr = try self.resolve(bin_op.lhs);
const value = try self.resolve(bin_op.rhs);
const ptr_ty_ref = try self.resolveType(ptr_ty, .direct);
try self.store(ptr_ty, ptr, value);
}
fn store(self: *DeclGen, ptr_ty: Type, ptr: IdRef, value: IdRef) !void {
const value_ty = ptr_ty.childType();
const converted_value = switch (value_ty.zigTypeTag()) {
.Bool => blk: {
const indirect_bool_ty_ref = try self.resolveType(value_ty, .indirect);
const result_id = self.spv.allocId();
const zero = try self.constInt(indirect_bool_ty_ref, 0);
const one = try self.constInt(indirect_bool_ty_ref, 1);
try self.func.body.emit(self.spv.gpa, .OpSelect, .{
.id_result_type = self.typeId(indirect_bool_ty_ref),
.id_result = result_id,
.condition = value,
.object_1 = one,
.object_2 = zero,
});
break :blk result_id;
},
else => value,
};
const access = spec.MemoryAccess.Extended{
.Volatile = ptr_ty.isVolatilePtr(),
};
try self.func.body.emit(self.spv.gpa, .OpStore, .{
.pointer = ptr,
.object = converted_value,
.memory_access = access,
});
const val_is_undef = if (self.air.value(bin_op.rhs)) |val| val.isUndefDeep() else false;
if (val_is_undef) {
const undef = try self.constUndef(ptr_ty_ref);
try self.store(ptr_ty, ptr, undef);
} else {
try self.store(ptr_ty, ptr, value);
}
}
fn airLoop(self: *DeclGen, inst: Air.Inst.Index) !void {
@@ -2451,6 +2545,232 @@ pub const DeclGen = struct {
});
}
fn airTry(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
const err_union_id = try self.resolve(pl_op.operand);
const extra = self.air.extraData(Air.Try, pl_op.payload);
const body = self.air.extra[extra.end..][0..extra.data.body_len];
const err_union_ty = self.air.typeOf(pl_op.operand);
const payload_ty = self.air.typeOfIndex(inst);
const err_ty_ref = try self.resolveType(Type.anyerror, .direct);
const bool_ty_ref = try self.resolveType(Type.bool, .direct);
const eu_layout = self.errorUnionLayout(payload_ty);
if (!err_union_ty.errorUnionSet().errorSetIsEmpty()) {
const err_id = if (eu_layout.payload_has_bits)
try self.extractField(Type.anyerror, err_union_id, eu_layout.errorFieldIndex())
else
err_union_id;
const zero_id = try self.constInt(err_ty_ref, 0);
const is_err_id = self.spv.allocId();
try self.func.body.emit(self.spv.gpa, .OpINotEqual, .{
.id_result_type = self.typeId(bool_ty_ref),
.id_result = is_err_id,
.operand_1 = err_id,
.operand_2 = zero_id,
});
// When there is an error, we must evaluate `body`. Otherwise we must continue
// with the current body.
// Just generate a new block here, then generate a new block inline for the remainder of the body.
const err_block = self.spv.allocId();
const ok_block = self.spv.allocId();
// TODO: Merge block
try self.func.body.emit(self.spv.gpa, .OpBranchConditional, .{
.condition = is_err_id,
.true_label = err_block,
.false_label = ok_block,
});
try self.beginSpvBlock(err_block);
try self.genBody(body);
try self.beginSpvBlock(ok_block);
// Now just extract the payload, if required.
}
if (self.liveness.isUnused(inst)) {
return null;
}
if (!eu_layout.payload_has_bits) {
return null;
}
return try self.extractField(payload_ty, err_union_id, eu_layout.payloadFieldIndex());
}
fn airErrUnionErr(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const operand_id = try self.resolve(ty_op.operand);
const err_union_ty = self.air.typeOf(ty_op.operand);
const err_ty_ref = try self.resolveType(Type.anyerror, .direct);
if (err_union_ty.errorUnionSet().errorSetIsEmpty()) {
// No error possible, so just return undefined.
return try self.constUndef(err_ty_ref);
}
const payload_ty = err_union_ty.errorUnionPayload();
const eu_layout = self.errorUnionLayout(payload_ty);
if (!eu_layout.payload_has_bits) {
// If no payload, error union is represented by error set.
return operand_id;
}
return try self.extractField(Type.anyerror, operand_id, eu_layout.errorFieldIndex());
}
fn airWrapErrUnionErr(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const err_union_ty = self.air.typeOfIndex(inst);
const payload_ty = err_union_ty.errorUnionPayload();
const operand_id = try self.resolve(ty_op.operand);
const eu_layout = self.errorUnionLayout(payload_ty);
if (!eu_layout.payload_has_bits) {
return operand_id;
}
const payload_ty_ref = try self.resolveType(payload_ty, .indirect);
var members = std.BoundedArray(IdRef, 2){};
const payload_id = try self.constUndef(payload_ty_ref);
if (eu_layout.error_first) {
members.appendAssumeCapacity(operand_id);
members.appendAssumeCapacity(payload_id);
// TODO: ABI padding?
} else {
members.appendAssumeCapacity(payload_id);
members.appendAssumeCapacity(operand_id);
// TODO: ABI padding?
}
const err_union_ty_ref = try self.resolveType(err_union_ty, .direct);
const result_id = self.spv.allocId();
try self.func.body.emit(self.spv.gpa, .OpCompositeConstruct, .{
.id_result_type = self.typeId(err_union_ty_ref),
.id_result = result_id,
.constituents = members.slice(),
});
return result_id;
}
fn airIsNull(self: *DeclGen, inst: Air.Inst.Index, pred: enum { is_null, is_non_null }) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
const un_op = self.air.instructions.items(.data)[inst].un_op;
const operand_id = try self.resolve(un_op);
const optional_ty = self.air.typeOf(un_op);
var buf: Type.Payload.ElemType = undefined;
const payload_ty = optional_ty.optionalChild(&buf);
const bool_ty_ref = try self.resolveType(Type.bool, .direct);
if (optional_ty.optionalReprIsPayload()) {
// Pointer payload represents nullability: pointer or slice.
var ptr_buf: Type.SlicePtrFieldTypeBuffer = undefined;
const ptr_ty = if (payload_ty.isSlice())
payload_ty.slicePtrFieldType(&ptr_buf)
else
payload_ty;
const ptr_id = if (payload_ty.isSlice())
try self.extractField(Type.bool, operand_id, 0)
else
operand_id;
const payload_ty_ref = try self.resolveType(ptr_ty, .direct);
const null_id = try self.constNull(payload_ty_ref);
const result_id = self.spv.allocId();
const operands = .{
.id_result_type = self.typeId(bool_ty_ref),
.id_result = result_id,
.operand_1 = ptr_id,
.operand_2 = null_id,
};
switch (pred) {
.is_null => try self.func.body.emit(self.spv.gpa, .OpPtrEqual, operands),
.is_non_null => try self.func.body.emit(self.spv.gpa, .OpPtrNotEqual, operands),
}
return result_id;
}
const is_non_null_id = if (optional_ty.hasRuntimeBitsIgnoreComptime())
try self.extractField(Type.bool, operand_id, 1)
else
// Optional representation is bool indicating whether the optional is set
operand_id;
return switch (pred) {
.is_null => blk: {
// Invert condition
const result_id = self.spv.allocId();
try self.func.body.emit(self.spv.gpa, .OpLogicalNot, .{
.id_result_type = self.typeId(bool_ty_ref),
.id_result = result_id,
.operand = is_non_null_id,
});
break :blk result_id;
},
.is_non_null => is_non_null_id,
};
}
fn airUnwrapOptional(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const operand_id = try self.resolve(ty_op.operand);
const optional_ty = self.air.typeOf(ty_op.operand);
const payload_ty = self.air.typeOfIndex(inst);
if (!payload_ty.hasRuntimeBitsIgnoreComptime()) return null;
if (optional_ty.optionalReprIsPayload()) {
return operand_id;
}
return try self.extractField(payload_ty, operand_id, 0);
}
fn airWrapOptional(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
if (self.liveness.isUnused(inst)) return null;
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const payload_ty = self.air.typeOf(ty_op.operand);
if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
return try self.constBool(true, .direct);
}
const operand_id = try self.resolve(ty_op.operand);
const optional_ty = self.air.typeOfIndex(inst);
if (optional_ty.optionalReprIsPayload()) {
return operand_id;
}
const optional_ty_ref = try self.resolveType(optional_ty, .direct);
const result_id = self.spv.allocId();
const members = [_]IdRef{ operand_id, try self.constBool(true, .indirect) };
try self.func.body.emit(self.spv.gpa, .OpCompositeConstruct, .{
.id_result_type = self.typeId(optional_ty_ref),
.id_result = result_id,
.constituents = &members,
});
return result_id;
}
fn airSwitchBr(self: *DeclGen, inst: Air.Inst.Index) !void {
const target = self.getTarget();
const pl_op = self.air.instructions.items(.data)[inst].pl_op;
@@ -2717,19 +3037,29 @@ pub const DeclGen = struct {
const result_id = self.spv.allocId();
const callee_id = try self.resolve(pl_op.operand);
try self.func.body.emitRaw(self.spv.gpa, .OpFunctionCall, 3 + args.len);
self.func.body.writeOperand(spec.IdResultType, result_type_id);
self.func.body.writeOperand(spec.IdResult, result_id);
self.func.body.writeOperand(spec.IdRef, callee_id);
const params = try self.gpa.alloc(spec.IdRef, args.len);
defer self.gpa.free(params);
var n_params: usize = 0;
for (args) |arg| {
// Note: resolve() might emit instructions, so we need to call it
// before starting to emit OpFunctionCall instructions. Hence the
// temporary params buffer.
const arg_id = try self.resolve(arg);
const arg_ty = self.air.typeOf(arg);
if (!arg_ty.hasRuntimeBitsIgnoreComptime()) continue;
self.func.body.writeOperand(spec.IdRef, arg_id);
params[n_params] = arg_id;
n_params += 1;
}
try self.func.body.emit(self.spv.gpa, .OpFunctionCall, .{
.id_result_type = result_type_id,
.id_result = result_id,
.function = callee_id,
.id_ref_3 = params[0..n_params],
});
if (return_type.isNoReturn()) {
try self.func.body.emit(self.spv.gpa, .OpUnreachable, {});
}

13
src/codegen/spirv/Module.zig
View File

@@ -40,14 +40,14 @@ pub const Fn = struct {
/// the end of this function definition.
body: Section = .{},
/// The decl dependencies that this function depends on.
decl_deps: std.ArrayListUnmanaged(Decl.Index) = .{},
decl_deps: std.AutoArrayHashMapUnmanaged(Decl.Index, void) = .{},
/// Reset this function without deallocating resources, so that
/// it may be used to emit code for another function.
pub fn reset(self: *Fn) void {
self.prologue.reset();
self.body.reset();
self.decl_deps.items.len = 0;
self.decl_deps.clearRetainingCapacity();
}
/// Free the resources owned by this function.
@@ -358,7 +358,7 @@ pub fn flush(self: *Module, file: std.fs.File) !void {
pub fn addFunction(self: *Module, decl_index: Decl.Index, func: Fn) !void {
try self.sections.functions.append(self.gpa, func.prologue);
try self.sections.functions.append(self.gpa, func.body);
try self.declareDeclDeps(decl_index, func.decl_deps.items);
try self.declareDeclDeps(decl_index, func.decl_deps.keys());
}
/// Fetch the result-id of an OpString instruction that encodes the path of the source
@@ -393,11 +393,14 @@ pub fn resolveSourceFileName(self: *Module, decl: *ZigDecl) !IdRef {
/// be emitted at this point.
pub fn resolveType(self: *Module, ty: Type) !Type.Ref {
const result = try self.type_cache.getOrPut(self.gpa, ty);
const index = @intToEnum(Type.Ref, result.index);
if (!result.found_existing) {
result.value_ptr.* = try self.emitType(ty);
const ref = try self.emitType(ty);
self.type_cache.values()[result.index] = ref;
}
return @intToEnum(Type.Ref, result.index);
return index;
}
pub fn resolveTypeId(self: *Module, ty: Type) !IdResultType {

3
test/behavior.zig
View File

@@ -241,7 +241,8 @@ test {
builtin.zig_backend != .stage2_x86_64 and
builtin.zig_backend != .stage2_aarch64 and
builtin.zig_backend != .stage2_wasm and
builtin.zig_backend != .stage2_c)
builtin.zig_backend != .stage2_c and
builtin.zig_backend != .stage2_spirv64)
{
_ = @import("behavior/bugs/13063.zig");
_ = @import("behavior/bugs/11227.zig");

23
test/behavior/align.zig
View File

@@ -19,6 +19,7 @@ test "slicing array of length 1 can not assume runtime index is always zero" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var runtime_index: usize = 1;
const slice = @as(*align(4) [1]u8, &foo)[runtime_index..];
@@ -32,6 +33,8 @@ 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);
@@ -42,6 +45,8 @@ 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);
@@ -214,6 +219,8 @@ 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);
@@ -231,6 +238,7 @@ fn fnWithAlignedStack() i32 {
test "implicitly decreasing slice alignment" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a: u32 align(4) = 3;
const b: u32 align(8) = 4;
@@ -256,6 +264,7 @@ test "@alignCast slices" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var array align(4) = [_]u32{ 1, 1 };
const slice = array[0..];
@@ -273,6 +282,7 @@ test "return error union with 128-bit integer" {
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 expect(3 == try give());
}
@@ -284,6 +294,7 @@ test "page aligned array on stack" {
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;
if (builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) {
// https://github.com/ziglang/zig/issues/13679
@@ -329,6 +340,7 @@ test "implicitly decreasing fn alignment" {
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;
// function alignment is a compile error on wasm32/wasm64
if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
@@ -352,6 +364,7 @@ test "@alignCast functions" {
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;
// function alignment is a compile error on wasm32/wasm64
if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
@@ -395,6 +408,7 @@ test "function align expression depends on generic parameter" {
test "function callconv expression depends on generic parameter" {
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 {
@@ -412,6 +426,7 @@ test "function callconv expression depends on generic parameter" {
test "runtime-known array index has best alignment possible" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
// take full advantage of over-alignment
var array align(4) = [_]u8{ 1, 2, 3, 4 };
@@ -451,6 +466,8 @@ fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) !void {
}
test "alignment of function with c calling convention" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var runtime_nothing = &nothing;
const casted1 = @ptrCast(*const u8, runtime_nothing);
const casted2 = @ptrCast(*const fn () callconv(.C) void, casted1);
@@ -468,6 +485,7 @@ test "read 128-bit field from default aligned struct in stack memory" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var default_aligned = DefaultAligned{
.nevermind = 1,
@@ -485,6 +503,7 @@ test "read 128-bit field from default aligned struct in global memory" {
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 expect(12 == default_aligned_global.badguy);
}
@@ -493,6 +512,7 @@ test "struct field explicit alignment" {
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 {
const Node = struct {
@@ -537,6 +557,7 @@ test "align(N) on functions" {
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_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
// This is not supported on MSVC
if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) {
@@ -558,6 +579,7 @@ test "comptime alloc alignment" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime var bytes1 = [_]u8{0};
_ = bytes1;
@@ -570,6 +592,7 @@ test "comptime alloc alignment" {
test "@alignCast null" {
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 ptr: ?*anyopaque = null;
const aligned: ?*anyopaque = @alignCast(@alignOf(?*anyopaque), ptr);

30
test/behavior/array.zig
View File

@@ -21,6 +21,7 @@ test "arrays" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var array: [5]u32 = undefined;
@@ -48,6 +49,7 @@ fn getArrayLen(a: []const u32) usize {
test "array concat with undefined" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@@ -72,6 +74,7 @@ test "array concat with tuple" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const array: [2]u8 = .{ 1, 2 };
{
@@ -86,6 +89,8 @@ test "array concat with tuple" {
test "array init with concat" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a = 'a';
var i: [4]u8 = [2]u8{ a, 'b' } ++ [2]u8{ 'c', 'd' };
try expect(std.mem.eql(u8, &i, "abcd"));
@@ -94,6 +99,7 @@ test "array init with concat" {
test "array init with mult" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a = 'a';
var i: [8]u8 = [2]u8{ a, 'b' } ** 4;
@@ -135,6 +141,7 @@ test "array literal with specified size" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var array = [2]u8{ 1, 2 };
try expect(array[0] == 1);
@@ -156,6 +163,7 @@ test "array len field" {
test "array with sentinels" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest(is_ct: bool) !void {
@@ -193,6 +201,7 @@ test "nested arrays of strings" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const array_of_strings = [_][]const u8{ "hello", "this", "is", "my", "thing" };
for (array_of_strings, 0..) |s, i| {
@@ -222,6 +231,7 @@ test "nested arrays of integers" {
test "implicit comptime in array type size" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var arr: [plusOne(10)]bool = undefined;
try expect(arr.len == 11);
@@ -234,6 +244,7 @@ fn plusOne(x: u32) u32 {
test "single-item pointer to array indexing and slicing" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testSingleItemPtrArrayIndexSlice();
comptime try testSingleItemPtrArrayIndexSlice();
@@ -259,6 +270,7 @@ fn doSomeMangling(array: *[4]u8) void {
test "implicit cast zero sized array ptr to slice" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
{
var b = "".*;
@@ -276,6 +288,7 @@ test "anonymous list literal syntax" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@@ -296,6 +309,7 @@ const Str = struct { a: []Sub };
test "set global var array via slice embedded in struct" {
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 s = Str{ .a = s_array[0..] };
@@ -312,6 +326,7 @@ test "read/write through global variable array of struct fields initialized via
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@@ -332,6 +347,7 @@ 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();
@@ -351,6 +367,7 @@ fn testArrayByValAtComptime(b: [2]u8) u8 {
test "comptime evaluating function that takes array by value" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const arr = [_]u8{ 1, 2 };
const x = comptime testArrayByValAtComptime(arr);
@@ -362,6 +379,7 @@ test "comptime evaluating function that takes array by value" {
test "runtime initialize array elem and then implicit cast to slice" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var two: i32 = 2;
const x: []const i32 = &[_]i32{two};
@@ -371,6 +389,7 @@ test "runtime initialize array elem and then implicit cast to slice" {
test "array literal as argument to function" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn entry(two: i32) !void {
@@ -399,6 +418,7 @@ test "double nested array to const slice cast in array literal" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn entry(two: i32) !void {
@@ -460,6 +480,7 @@ test "anonymous literal in array" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const Foo = struct {
@@ -484,6 +505,7 @@ test "anonymous literal in array" {
test "access the null element of a null terminated array" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@@ -501,6 +523,7 @@ test "type deduction for array subscript expression" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@@ -519,6 +542,7 @@ 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 {
@@ -542,6 +566,7 @@ test "sentinel element count towards the ABI size calculation" {
test "zero-sized array with recursive type definition" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const U = struct {
fn foo(comptime T: type, comptime n: usize) type {
@@ -564,6 +589,7 @@ test "type coercion of anon struct literal to array" {
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;
const S = struct {
const U = union {
@@ -596,6 +622,7 @@ test "type coercion of pointer to anon struct literal to pointer to array" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const U = union {
@@ -634,6 +661,7 @@ test "tuple to array handles sentinel" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const a = .{ 1, 2, 3 };
@@ -646,6 +674,7 @@ test "array init of container level array variable" {
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 {
var pair: [2]usize = .{ 1, 2 };
@@ -676,6 +705,7 @@ test "array of array agregate init" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a = [1]u32{11} ** 10;
var b = [1][10]u32{a} ** 2;

4
test/behavior/asm.zig
View File

@@ -24,6 +24,7 @@ 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
@@ -38,6 +39,7 @@ test "output constraint modifiers" {
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
@@ -61,6 +63,7 @@ test "alternative constraints" {
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
@@ -79,6 +82,7 @@ test "sized integer/float in asm input" {
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

15
test/behavior/atomics.zig
View File

@@ -14,6 +14,7 @@ test "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 testCmpxchg();
comptime try testCmpxchg();
@@ -39,6 +40,7 @@ fn testCmpxchg() !void {
test "fence" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: i32 = 1234;
@fence(.SeqCst);
@@ -49,6 +51,7 @@ test "atomicrmw and atomicload" {
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;
var data: u8 = 200;
try testAtomicRmw(&data);
@@ -76,6 +79,7 @@ test "cmpxchg with ptr" {
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;
var data1: i32 = 1234;
var data2: i32 = 5678;
@@ -100,6 +104,7 @@ test "cmpxchg with ignored result" {
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;
var x: i32 = 1234;
@@ -115,6 +120,7 @@ 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();
@@ -143,6 +149,7 @@ test "cmpxchg on a global variable" {
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;
if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
// https://github.com/ziglang/zig/issues/10627
@@ -157,6 +164,7 @@ test "atomic load and rmw with enum" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const Value = enum(u8) { a, b, c };
var x = Value.a;
@@ -173,6 +181,7 @@ test "atomic store" {
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;
var x: u32 = 0;
@atomicStore(u32, &x, 1, .SeqCst);
@@ -185,6 +194,7 @@ test "atomic store comptime" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime try testAtomicStore();
try testAtomicStore();
@@ -203,6 +213,7 @@ test "atomicrmw with floats" {
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;
if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
// https://github.com/ziglang/zig/issues/10627
@@ -231,6 +242,7 @@ test "atomicrmw with ints" {
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 testAtomicRmwInts();
comptime try testAtomicRmwInts();
@@ -301,6 +313,7 @@ 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;
@@ -376,6 +389,7 @@ test "atomics with different types" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testAtomicsWithType(bool, true, false);
@@ -404,6 +418,7 @@ test "return @atomicStore, using it as a void value" {
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;
const S = struct {
const A = struct {

55
test/behavior/basic.zig
View File

@@ -42,6 +42,7 @@ test "truncate to non-power-of-two integers from 128-bit" {
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 testTrunc(u128, u1, 0xffffffff_ffffffff_ffffffff_01010101, 0x01);
try testTrunc(u128, u1, 0xffffffff_ffffffff_ffffffff_01010110, 0x00);
@@ -81,6 +82,8 @@ test "type equality" {
}
test "pointer dereferencing" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x = @as(i32, 3);
const y = &x;
@@ -131,18 +134,21 @@ 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
@@ -155,6 +161,7 @@ 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
@@ -167,6 +174,7 @@ 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
@@ -179,6 +187,7 @@ 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
@@ -191,6 +200,7 @@ 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
@@ -204,11 +214,14 @@ 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"));
}
@@ -218,6 +231,7 @@ const OpaqueB = opaque {};
test "opaque types" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(*OpaqueA != *OpaqueB);
@@ -289,6 +303,8 @@ 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;
@@ -304,6 +320,7 @@ fn fB() []const u8 {
test "call function pointer in struct" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(mem.eql(u8, f3(true), "a"));
try expect(mem.eql(u8, f3(false), "b"));
@@ -327,6 +344,7 @@ const FnPtrWrapper = struct {
test "const ptr from var variable" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: u64 = undefined;
var y: u64 = undefined;
@@ -345,6 +363,7 @@ test "call result of if else expression" {
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 expect(mem.eql(u8, f2(true), "a"));
try expect(mem.eql(u8, f2(false), "b"));
@@ -354,6 +373,8 @@ fn f2(x: bool) []const u8 {
}
test "variable is allowed to be a pointer to an opaque type" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: i32 = 1234;
_ = hereIsAnOpaqueType(@ptrCast(*OpaqueA, &x));
}
@@ -366,6 +387,7 @@ 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);
}
@@ -375,6 +397,8 @@ fn testTakeAddressOfParameter(f: f32) !void {
}
test "pointer to void return type" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testPointerToVoidReturnType();
}
fn testPointerToVoidReturnType() anyerror!void {
@@ -391,6 +415,7 @@ test "array 2D const double ptr" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const rect_2d_vertexes = [_][1]f32{
[_]f32{1.0},
@@ -404,6 +429,7 @@ test "array 2D const double ptr with offset" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const rect_2d_vertexes = [_][2]f32{
[_]f32{ 3.0, 4.239 },
@@ -417,6 +443,7 @@ test "array 3D const double ptr with offset" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const rect_3d_vertexes = [_][2][2]f32{
[_][2]f32{
@@ -450,6 +477,7 @@ 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();
@@ -471,6 +499,7 @@ fn testStructInFn() !void {
test "fn call returning scalar optional in equality expression" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(getNull() == null);
}
@@ -481,6 +510,7 @@ fn getNull() ?*i32 {
test "global variable assignment with optional unwrapping with var initialized to undefined" {
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 {
var data: i32 = 1234;
@@ -569,11 +599,15 @@ test "comptime cast fn to ptr" {
}
test "equality compare fn ptrs" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a = &emptyFn;
try expect(a == a);
}
test "self reference through fn ptr field" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
const A = struct {
f: *const fn (A) u8,
@@ -591,6 +625,7 @@ test "self reference through fn ptr field" {
test "global variable initialized to global variable array element" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try expect(global_ptr == &gdt[0]);
}
@@ -622,6 +657,7 @@ test "global constant is loaded with a runtime-known index" {
test "multiline string literal is null terminated" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const s1 =
\\one
@@ -636,6 +672,7 @@ test "string escapes" {
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 expectEqualStrings("\"", "\x22");
try expectEqualStrings("\'", "\x27");
@@ -653,6 +690,8 @@ 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));
@@ -665,6 +704,7 @@ 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";
@@ -692,6 +732,7 @@ test "comptime manyptr concatenation" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const s = "epic";
const actual = manyptrConcat(s);
@@ -713,6 +754,7 @@ test "result location is optional inside error union" {
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 x = maybe(true) catch unreachable;
try expect(x.? == 42);
@@ -728,6 +770,7 @@ 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 {
@@ -748,6 +791,7 @@ test "extern variable with non-pointer opaque type" {
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_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
@export(var_to_export, .{ .name = "opaque_extern_var" });
try expect(@ptrCast(*align(1) u32, &opaque_extern_var).* == 42);
@@ -830,6 +874,7 @@ test "labeled block implicitly ends in a break" {
test "catch in block has correct result location" {
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 open() error{A}!@This() {
@@ -847,6 +892,8 @@ 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: {
@@ -1004,6 +1051,7 @@ comptime {
test "switch inside @as gets correct type" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: u32 = 0;
var b: [2]u32 = undefined;
@@ -1014,6 +1062,8 @@ 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) {
@@ -1029,6 +1079,7 @@ test "namespace lookup ignores decl causing the lookup" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_llvm) {
// regressed with LLVM 15
@@ -1096,6 +1147,7 @@ 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 {
@@ -1112,6 +1164,8 @@ test "orelse coercion as function argument" {
}
test "runtime-known globals initialized with undefined" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
var array: [10]u32 = [_]u32{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var vp: [*]u32 = undefined;
@@ -1131,6 +1185,7 @@ test "arrays and vectors with big integers" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
// TODO: only aarch64-windows didn't pass in the PR that added this code.
// figure out why if you can run this target.

1
test/behavior/bit_shifting.zig
View File

@@ -64,6 +64,7 @@ test "sharded table" {
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;
// realistic 16-way sharding
try testShardedTable(u32, 4, 8);

15
test/behavior/bitcast.zig
View File

@@ -9,6 +9,7 @@ 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 };
@@ -22,6 +23,7 @@ test "@bitCast iX -> uX (8, 16, 128)" {
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 bit_values = [_]usize{ 8, 16, 128 };
@@ -37,6 +39,7 @@ test "@bitCast iX -> uX exotic integers" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 };
@@ -83,6 +86,7 @@ test "bitcast uX to bytes" {
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 bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 };
inline for (bit_values) |bits| {
@@ -150,6 +154,8 @@ test "bitcast literal [4]u8 param to u32" {
}
test "bitcast generates a temporary value" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var y = @as(u16, 0x55AA);
const x = @bitCast(u16, @bitCast([2]u8, y));
try expect(y == x);
@@ -159,6 +165,7 @@ test "@bitCast packed structs at runtime and comptime" {
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 Full = packed struct {
number: u16,
@@ -184,6 +191,7 @@ test "@bitCast packed structs at runtime and comptime" {
test "@bitCast extern structs at runtime and comptime" {
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 Full = extern struct {
number: u16,
@@ -216,6 +224,7 @@ test "bitcast packed struct to integer and back" {
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 LevelUpMove = packed struct {
move_id: u9,
@@ -237,6 +246,7 @@ test "bitcast packed struct to integer and back" {
test "implicit cast to error union by returning" {
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 entry() !void {
@@ -292,6 +302,7 @@ test "@bitCast packed struct of floats" {
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 Foo = packed struct {
a: f16 = 0,
@@ -328,6 +339,7 @@ test "comptime @bitCast packed struct to int and back" {
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;
if (builtin.zig_backend == .stage2_llvm and native_endian == .Big) {
// https://github.com/ziglang/zig/issues/13782
@@ -368,6 +380,7 @@ test "comptime bitcast with fields following f80" {
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 FloatT = extern struct { f: f80, x: u128 align(16) };
const x: FloatT = .{ .f = 0.5, .x = 123 };
@@ -383,6 +396,7 @@ test "bitcast vector to integer and back" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const arr: [16]bool = [_]bool{ true, false } ++ [_]bool{true} ** 14;
var x = @splat(16, true);
@@ -408,6 +422,7 @@ test "bitcast nan float does modify signaling bit" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
// TODO: https://github.com/ziglang/zig/issues/14366
if (builtin.cpu.arch == .arm and builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;

5
test/behavior/bitreverse.zig
View File

@@ -5,6 +5,7 @@ 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);
}
@@ -15,6 +16,7 @@ test "@bitReverse" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime try testBitReverse();
try testBitReverse();
@@ -100,6 +102,7 @@ test "bitReverse vectors u8" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime try vector8();
try vector8();
@@ -118,6 +121,7 @@ test "bitReverse vectors u16" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime try vector16();
try vector16();
@@ -136,6 +140,7 @@ test "bitReverse vectors u24" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime try vector24();
try vector24();

3
test/behavior/bool.zig
View File

@@ -1,4 +1,5 @@
const std = @import("std");
const builtin = @import("builtin");
const expect = std.testing.expect;
test "bool literals" {
@@ -7,6 +8,8 @@ test "bool literals" {
}
test "cast bool to int" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const t = true;
const f = false;
try expect(@boolToInt(t) == @as(u32, 1));

1
test/behavior/bugs/10138.zig
View File

@@ -5,6 +5,7 @@ test "registers get overwritten when ignoring return" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.cpu.arch != .x86_64 or builtin.os.tag != .linux) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const fd = open();
_ = write(fd, "a", 1);

1
test/behavior/bugs/10147.zig
View File

@@ -7,6 +7,7 @@ test "test calling @clz on both vector and scalar inputs" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: u32 = 0x1;
var y: @Vector(4, u32) = [_]u32{ 0x1, 0x1, 0x1, 0x1 };

1
test/behavior/bugs/10684.zig
View File

@@ -7,6 +7,7 @@ test "slicing slices" {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const foo = "1234";
const bar = foo[0..4];

1
test/behavior/bugs/1076.zig
View File

@@ -6,6 +6,7 @@ const expect = std.testing.expect;
test "comptime code should not modify constant data" {
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 testCastPtrOfArrayToSliceAndPtr();
comptime try testCastPtrOfArrayToSliceAndPtr();

1
test/behavior/bugs/10970.zig
View File

@@ -7,6 +7,7 @@ test "breaking from a loop in an if statement" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var cond = true;
const opt = while (cond) {

1
test/behavior/bugs/11046.zig
View File

@@ -13,6 +13,7 @@ test "fixed" {
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;
bar() catch |err| switch (err) {
error.Foo => {}, // error: expected (inferred error set of bar), found error{Foo}

4
test/behavior/bugs/11100.zig
View File

@@ -1,4 +1,6 @@
const std = @import("std");
const builtin = @import("builtin");
pub fn do() bool {
inline for (.{"a"}) |_| {
if (true) return false;
@@ -7,5 +9,7 @@ pub fn do() bool {
}
test "bug" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try std.testing.expect(!do());
}

1
test/behavior/bugs/11139.zig
View File

@@ -6,6 +6,7 @@ test "store array of array of structs at comptime" {
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(storeArrayOfArrayOfStructs() == 15);
comptime try expect(storeArrayOfArrayOfStructs() == 15);

2
test/behavior/bugs/11165.zig
View File

@@ -2,6 +2,7 @@ const builtin = @import("builtin");
test "bytes" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
a: u32,
@@ -23,6 +24,7 @@ test "bytes" {
test "aggregate" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
a: u32,

1
test/behavior/bugs/11179.zig
View File

@@ -1,4 +1,5 @@
const std = @import("std");
const builtin = @import("builtin");
const Type = std.builtin.Type;
test "Tuple" {

2
test/behavior/bugs/11213.zig
View File

@@ -3,6 +3,8 @@ const builtin = @import("builtin");
const testing = std.testing;
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const g: error{Test}!void = error.Test;
var v: u32 = 0;

1
test/behavior/bugs/11787.zig
View File

@@ -7,6 +7,7 @@ test "slicing zero length array field of struct" {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const S = struct {
a: [0]usize,

1
test/behavior/bugs/11816.zig
View File

@@ -4,6 +4,7 @@ const builtin = @import("builtin");
test {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: u32 = 3;
const val: usize = while (true) switch (x) {

2
test/behavior/bugs/11995.zig
View File

@@ -22,6 +22,8 @@ test {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var string: [5]u8 = "hello".*;
const arg_data = wuffs_base__slice_u8{ .ptr = @ptrCast([*c]u8, &string), .len = string.len };
var arg_meta = wuffs_base__io_buffer_meta{ .wi = 1, .ri = 2, .pos = 3, .closed = true };

2
test/behavior/bugs/12000.zig
View File

@@ -10,6 +10,8 @@ test {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var t: T = .{ .next = null };
try std.testing.expect(t.next == null);
}

4
test/behavior/bugs/12025.zig
View File

@@ -1,4 +1,8 @@
const builtin = @import("builtin");
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime var st = .{
.foo = &1,
.bar = &2,

3
test/behavior/bugs/12033.zig
View File

@@ -1,6 +1,9 @@
const std = @import("std");
const builtin = @import("builtin");
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const string = "Hello!\x00World!";
try std.testing.expect(@TypeOf(string) == *const [13:0]u8);

3
test/behavior/bugs/12043.zig
View File

@@ -1,4 +1,5 @@
const std = @import("std");
const builtin = @import("builtin");
const expect = std.testing.expect;
var ok = false;
@@ -6,6 +7,8 @@ fn foo(x: anytype) void {
ok = x;
}
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const x = &foo;
x(true);
try expect(ok);

2
test/behavior/bugs/12051.zig
View File

@@ -7,6 +7,8 @@ test {
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 x = X{};
try std.testing.expectEqual(@as(u16, 0), x.y.a);
try std.testing.expectEqual(false, x.y.b);

2
test/behavior/bugs/12092.zig
View File

@@ -18,6 +18,8 @@ test {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var baz: u32 = 24;
try takeFoo(&.{
.a = .{

2
test/behavior/bugs/12119.zig
View File

@@ -9,6 +9,8 @@ test {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const zerox32: u8x32 = [_]u8{0} ** 32;
const bigsum: u32x8 = @bitCast(u32x8, zerox32);
try std.testing.expectEqual(0, @reduce(.Add, bigsum));

2
test/behavior/bugs/12142.zig
View File

@@ -23,6 +23,8 @@ test {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const test_struct = Test{
.holders = &.{
Holder{

2
test/behavior/bugs/12450.zig
View File

@@ -14,6 +14,8 @@ test {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var f1: *align(16) Foo = @alignCast(16, @ptrCast(*align(1) Foo, &buffer[0]));
try expect(@typeInfo(@TypeOf(f1)).Pointer.alignment == 16);
try expect(@ptrToInt(f1) == @ptrToInt(&f1.a));

1
test/behavior/bugs/12551.zig
View File

@@ -4,6 +4,7 @@ const builtin = @import("builtin");
test {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try std.testing.expect(for ([1]u8{0}) |x| {
if (x == 0) break true;

1
test/behavior/bugs/12571.zig
View File

@@ -14,6 +14,7 @@ const Entry = packed struct {
test {
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 frame = Frame{ .num = 0x7FDE };
var entry = Entry{ .other = 0, .frame = .{ .num = 0xFFFFF } };

3
test/behavior/bugs/12644.zig
View File

@@ -1,4 +1,5 @@
const std = @import("std");
const builtin = @import("builtin");
inline fn foo(comptime T: type) !T {
return error.AnError;
@@ -9,6 +10,8 @@ fn main0() !void {
}
test "issue12644" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
main0() catch |e| {
try std.testing.expect(e == error.AnError);
};

1
test/behavior/bugs/12680.zig
View File

@@ -11,6 +11,7 @@ test "export a function twice" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.os.tag == .macos and builtin.zig_backend == .stage2_c) {
// TODO: test.c: error: aliases are not supported on darwin
return error.SkipZigTest;

1
test/behavior/bugs/1277.zig
View File

@@ -16,6 +16,7 @@ test "don't emit an LLVM global for a const function when it's in an optional in
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try std.testing.expect(s.f.?() == 1234);
}

1
test/behavior/bugs/12776.zig
View File

@@ -32,6 +32,7 @@ test {
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;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) {
// Careful enabling this test, fails randomly.
return error.SkipZigTest;

1
test/behavior/bugs/12801-2.zig
View File

@@ -18,6 +18,7 @@ test {
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_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const a: Auto = .{ .offset = 16, .capacity = Auto.capacity };
try std.testing.expect(a.capacity() == 32);

1
test/behavior/bugs/12890.zig
View File

@@ -11,6 +11,7 @@ fn a(b: []u3, c: u3) void {
test {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var arr: [8]u3 = undefined;
a(&arr, 5);

14
test/behavior/bugs/12891.zig
View File

@@ -7,21 +7,29 @@ test "issue12891" {
try std.testing.expect(i < f);
}
test "nan" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const f = comptime std.math.nan(f64);
var i: usize = 0;
try std.testing.expect(!(f < i));
}
test "inf" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const f = comptime std.math.inf(f64);
var i: usize = 0;
try std.testing.expect(f > i);
}
test "-inf < 0" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const f = comptime -std.math.inf(f64);
var i: usize = 0;
try std.testing.expect(f < i);
}
test "inf >= 1" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const f = comptime std.math.inf(f64);
var i: usize = 1;
try std.testing.expect(f >= i);
@@ -29,6 +37,7 @@ test "inf >= 1" {
test "isNan(nan * 1)" {
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 nan_times_one = comptime std.math.nan(f64) * 1;
try std.testing.expect(std.math.isNan(nan_times_one));
@@ -36,6 +45,7 @@ test "isNan(nan * 1)" {
test "runtime isNan(nan * 1)" {
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 nan_times_one = std.math.nan(f64) * 1;
try std.testing.expect(std.math.isNan(nan_times_one));
@@ -43,6 +53,7 @@ test "runtime isNan(nan * 1)" {
test "isNan(nan * 0)" {
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 nan_times_zero = comptime std.math.nan(f64) * 0;
try std.testing.expect(std.math.isNan(nan_times_zero));
@@ -52,6 +63,7 @@ test "isNan(nan * 0)" {
test "isNan(inf * 0)" {
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 inf_times_zero = comptime std.math.inf(f64) * 0;
try std.testing.expect(std.math.isNan(inf_times_zero));
@@ -61,6 +73,7 @@ test "isNan(inf * 0)" {
test "runtime isNan(nan * 0)" {
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 nan_times_zero = std.math.nan(f64) * 0;
try std.testing.expect(std.math.isNan(nan_times_zero));
@@ -70,6 +83,7 @@ test "runtime isNan(nan * 0)" {
test "runtime isNan(inf * 0)" {
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 inf_times_zero = std.math.inf(f64) * 0;
try std.testing.expect(std.math.isNan(inf_times_zero));

8
test/behavior/bugs/12928.zig
View File

@@ -1,5 +1,7 @@
const std = @import("std");
const builtin = @import("builtin");
const expect = std.testing.expect;
const A = extern struct {
value: *volatile B,
};
@@ -7,11 +9,15 @@ const B = extern struct {
a: u32,
b: i32,
};
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: *A = undefined;
try expect(@TypeOf(&a.value.a) == *volatile u32);
try expect(@TypeOf(&a.value.b) == *volatile i32);
}
const C = extern struct {
value: *volatile D,
};
@@ -20,6 +26,8 @@ const D = extern union {
b: i32,
};
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var c: *C = undefined;
try expect(@TypeOf(&c.value.a) == *volatile u32);
try expect(@TypeOf(&c.value.b) == *volatile i32);

1
test/behavior/bugs/12972.zig
View File

@@ -6,6 +6,7 @@ test {
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 c: u8 = 42;
f(&[_:null]?u8{c});

1
test/behavior/bugs/12984.zig
View File

@@ -14,6 +14,7 @@ pub const CustomDraw = DeleagateWithContext(fn (?OnConfirm) void);
test "simple test" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var c: CustomDraw = undefined;
_ = c;

1
test/behavior/bugs/13064.zig
View File

@@ -6,6 +6,7 @@ test {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: [10][10]u32 = undefined;

1
test/behavior/bugs/13065.zig
View File

@@ -11,6 +11,7 @@ test {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x = U{ .array = undefined };

1
test/behavior/bugs/13068.zig
View File

@@ -9,6 +9,7 @@ test {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
list.items.len = 0;
}

1
test/behavior/bugs/13069.zig
View File

@@ -6,6 +6,7 @@ test {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var opt_x: ?[3]f32 = [_]f32{0.0} ** 3;

2
test/behavior/bugs/13113.zig
View File

@@ -11,6 +11,8 @@ test {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const foo = Foo{
.a = 1,
.b = 2,

1
test/behavior/bugs/13128.zig
View File

@@ -17,6 +17,7 @@ test "runtime union init, most-aligned field != largest" {
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: u8 = 1;
try foo(.{ .x = x });

2
test/behavior/bugs/13159.zig
View File

@@ -11,6 +11,8 @@ const Bar = packed struct {
test {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var foo = Bar.Baz.fizz;
try expect(foo == .fizz);
}

1
test/behavior/bugs/13285.zig
View File

@@ -6,6 +6,7 @@ const Crasher = struct {
test {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: Crasher = undefined;
var crasher_ptr = &a;

1
test/behavior/bugs/13366.zig
View File

@@ -18,6 +18,7 @@ test {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: u32 = 16;
var reason = .{ .c_import = .{ .a = a } };

1
test/behavior/bugs/13664.zig
View File

@@ -18,6 +18,7 @@ test {
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 timestamp: i64 = value();
const id = ID{ .fields = Fields{

1
test/behavior/bugs/13785.zig
View File

@@ -6,6 +6,7 @@ test {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: u8 = 0;
try std.io.null_writer.print("\n{} {}\n", .{ a, S{} });

1
test/behavior/bugs/1381.zig
View File

@@ -17,6 +17,7 @@ test "union that needs padding bytes inside an array" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var as = [_]A{
A{ .B = B{ .D = 1 } },

2
test/behavior/bugs/1442.zig
View File

@@ -10,6 +10,8 @@ test "const error union field alignment" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var union_or_err: anyerror!Union = Union{ .Color = 1234 };
try std.testing.expect((union_or_err catch unreachable).Color == 1234);
}

3
test/behavior/bugs/14854.zig
View File

@@ -1,6 +1,9 @@
const testing = @import("std").testing;
const builtin = @import("builtin");
test {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try testing.expect(getGeneric(u8, getU8) == 123);
}

2
test/behavior/bugs/1500.zig
View File

@@ -6,6 +6,8 @@ const A = struct {
const B = *const fn (A) void;
test "allow these dependencies" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: A = undefined;
var b: B = undefined;
if (false) {

2
test/behavior/bugs/1607.zig
View File

@@ -14,6 +14,8 @@ test "slices pointing at the same address as global array." {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try checkAddress(&a);
comptime try checkAddress(&a);
}

2
test/behavior/bugs/1735.zig
View File

@@ -44,6 +44,8 @@ const a = struct {
test "initialization" {
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 t = a.init();
try std.testing.expect(t.foo.len == 0);
}

1
test/behavior/bugs/1741.zig
View File

@@ -5,6 +5,7 @@ test "fixed" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const x: f32 align(128) = 12.34;
try std.testing.expect(@ptrToInt(&x) % 128 == 0);

1
test/behavior/bugs/1851.zig
View File

@@ -7,6 +7,7 @@ test "allocation and looping over 3-byte integer" {
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_llvm and builtin.os.tag == .macos) {
return error.SkipZigTest; // TODO

4
test/behavior/bugs/1914.zig
View File

@@ -12,6 +12,8 @@ const b_list: []B = &[_]B{};
const a = A{ .b_list_pointer = &b_list };
test "segfault bug" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const assert = std.debug.assert;
const obj = B{ .a_pointer = &a };
assert(obj.a_pointer == &a); // this makes zig crash
@@ -28,5 +30,7 @@ pub const B2 = struct {
var b_value = B2{ .pointer_array = &[_]*A2{} };
test "basic stuff" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
std.debug.assert(&b_value == &b_value);
}

1
test/behavior/bugs/2006.zig
View File

@@ -7,6 +7,7 @@ const S = struct {
};
test "bug 2006" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var a: S = undefined;
a = S{ .p = undefined };

1
test/behavior/bugs/2114.zig
View File

@@ -14,6 +14,7 @@ test "fixed" {
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 testCtz();
comptime try testCtz();

1
test/behavior/bugs/2578.zig
View File

@@ -15,6 +15,7 @@ test "fixed" {
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;
bar(t);
}

1
test/behavior/bugs/2622.zig
View File

@@ -7,6 +7,7 @@ test "reslice of undefined global var slice" {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var mem: [100]u8 = [_]u8{0} ** 100;
buf = &mem;

1
test/behavior/bugs/2692.zig
View File

@@ -7,6 +7,7 @@ fn foo(a: []u8) void {
test "address of 0 length array" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var pt: [0]u8 = undefined;
foo(&pt);

1
test/behavior/bugs/3007.zig
View File

@@ -22,6 +22,7 @@ test "fixed" {
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;
default_foo = get_foo() catch null; // This Line
try std.testing.expect(!default_foo.?.free);

1
test/behavior/bugs/3046.zig
View File

@@ -16,6 +16,7 @@ test "fixed" {
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;
some_struct = SomeStruct{
.field = couldFail() catch @as(i32, 0),

2
test/behavior/bugs/3112.zig
View File

@@ -15,6 +15,8 @@ test "zig test crash" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var global: State = undefined;
global.enter = prev;
global.enter(null);

2
test/behavior/bugs/3367.zig
View File

@@ -10,6 +10,8 @@ const Mixin = struct {
};
test "container member access usingnamespace decls" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var foo = Foo{};
foo.two();
}

2
test/behavior/bugs/3742.zig
View File

@@ -40,5 +40,7 @@ test "fixed" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_llvm and
builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
ArgSerializer.serializeCommand(GET.init("banana"));
}

5
test/behavior/bugs/3779.zig
View File

@@ -8,6 +8,7 @@ const ptr_tag_name: [*:0]const u8 = tag_name;
test "@tagName() returns a string literal" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name));
try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name));
@@ -21,6 +22,7 @@ const ptr_error_name: [*:0]const u8 = error_name;
test "@errorName() returns a string literal" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name));
try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name));
@@ -34,6 +36,7 @@ const ptr_type_name: [*:0]const u8 = type_name;
test "@typeName() returns a string literal" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try std.testing.expect(*const [type_name.len:0]u8 == @TypeOf(type_name));
try std.testing.expect(std.mem.eql(u8, "behavior.bugs.3779.TestType", type_name));
@@ -47,6 +50,7 @@ const expected_contents = "hello zig\n";
test "@embedFile() returns a string literal" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try std.testing.expect(*const [expected_contents.len:0]u8 == @TypeOf(actual_contents));
try std.testing.expect(std.mem.eql(u8, expected_contents, actual_contents));
@@ -61,6 +65,7 @@ fn testFnForSrc() std.builtin.SourceLocation {
test "@src() returns a struct containing 0-terminated string slices" {
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 src = testFnForSrc();
try std.testing.expect([:0]const u8 == @TypeOf(src.file));

1
test/behavior/bugs/421.zig
View File

@@ -5,6 +5,7 @@ test "bitCast to array" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime try testBitCastArray();
try testBitCastArray();

5
test/behavior/bugs/4328.zig
View File

@@ -17,6 +17,8 @@ const S = extern struct {
};
test "Extern function calls in @TypeOf" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const Test = struct {
fn test_fn_1(a: anytype, b: anytype) @TypeOf(c_printf("%d %s\n", a, b)) {
return 0;
@@ -37,6 +39,8 @@ test "Extern function calls in @TypeOf" {
}
test "Peer resolution of extern function calls in @TypeOf" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const Test = struct {
fn test_fn() @TypeOf(c_ftell(null), c_fputs(null, null)) {
return 0;
@@ -54,6 +58,7 @@ test "Peer resolution of extern function calls in @TypeOf" {
test "Extern function calls, dereferences and field access in @TypeOf" {
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 Test = struct {
fn test_fn_1(a: c_long) @TypeOf(c_fopen("test", "r").*) {

1
test/behavior/bugs/4954.zig
View File

@@ -8,6 +8,7 @@ test "crash" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var buf: [4096]u8 = undefined;
f(&buf);

1
test/behavior/bugs/529.zig
View File

@@ -16,6 +16,7 @@ test "issue 529 fixed" {
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;
@import("529_other_file.zig").issue529(null);
issue529(null);

1
test/behavior/bugs/5398.zig
View File

@@ -22,6 +22,7 @@ test "assignment of field with padding" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
renderable = Renderable{
.mesh = Mesh{ .id = 0 },

1
test/behavior/bugs/6047.zig
View File

@@ -14,6 +14,7 @@ test "`try`ing an if/else expression" {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try @import("std").testing.expectError(error.Test, getError2());
}

1
test/behavior/bugs/6456.zig
View File

@@ -13,6 +13,7 @@ const text =
test "issue 6456" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime {
var fields: []const StructField = &[0]StructField{};

2
test/behavior/bugs/656.zig
View File

@@ -14,6 +14,8 @@ test "optional if after an if in a switch prong of a switch with 2 prongs in an
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try foo(false, true);
}

1
test/behavior/bugs/6781.zig
View File

@@ -68,6 +68,7 @@ test "fixed" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var buffer align(@alignOf(JournalHeader)) = [_]u8{0} ** 65536;
var entry = std.mem.bytesAsValue(JournalHeader, buffer[0..@sizeOf(JournalHeader)]);

1
test/behavior/bugs/6905.zig
View File

@@ -6,6 +6,7 @@ test "sentinel-terminated 0-length slices" {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var u32s: [4]u32 = [_]u32{ 0, 1, 2, 3 };

1
test/behavior/bugs/6947.zig
View File

@@ -9,6 +9,7 @@ test {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var slice: []void = undefined;
destroy(&slice[0]);

3
test/behavior/bugs/7047.zig
View File

@@ -1,4 +1,5 @@
const std = @import("std");
const builtin = @import("builtin");
const U = union(enum) {
T: type,
@@ -14,6 +15,8 @@ fn S(comptime query: U) type {
}
test "compiler doesn't consider equal unions with different 'type' payload" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
const s1 = S(U{ .T = u32 }).tag();
try std.testing.expectEqual(u32, s1);

1
test/behavior/bugs/718.zig
View File

@@ -13,6 +13,7 @@ test "zero keys with @memset" {
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;
@memset(@ptrCast([*]u8, &keys)[0..@sizeOf(@TypeOf(keys))], 0);
try expect(!keys.up);

2
test/behavior/bugs/7187.zig
View File

@@ -3,6 +3,8 @@ const builtin = @import("builtin");
const expect = std.testing.expect;
test "miscompilation with bool return type" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var x: usize = 1;
var y: bool = getFalse();
_ = y;

2
test/behavior/bugs/726.zig
View File

@@ -5,6 +5,7 @@ test "@ptrCast from const to nullable" {
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 c: u8 = 4;
var x: ?*const u8 = @ptrCast(?*const u8, &c);
@@ -15,6 +16,7 @@ test "@ptrCast from var in empty struct to nullable" {
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 container = struct {
var c: u8 = 4;

1
test/behavior/bugs/7325.zig
View File

@@ -82,6 +82,7 @@ test {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
var param: ParamType = .{
.one_of = .{ .name = "name" },

2
test/behavior/bugs/8277.zig
View File

@@ -2,6 +2,8 @@ const std = @import("std");
const builtin = @import("builtin");
test "@sizeOf reified union zero-size payload fields" {
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
comptime {
try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union {}))));
try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union { a: void }))));

1
test/behavior/bugs/828.zig
View File

@@ -31,6 +31,7 @@ fn constCount(comptime cb: *const CountBy, comptime unused: u32) void {
test "comptime struct return should not return the same instance" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
//the first parameter must be passed by reference to trigger the bug
//a second parameter is required to trigger the bug

1
test/behavior/bugs/8646.zig
View File

@@ -11,6 +11,7 @@ test {
if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
try std.testing.expect(array[0].len == 1);
try std.testing.expectEqualStrings("hello", array[0][0]);

Some files were not shown because too many files have changed in this diff Show More