mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-16 11:13:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

behavior tests: enable all vector tests for the stage2 LLVM backend

Browse Source
This commit is contained in:
William Sengir 2022-03-20 01:11:21 -07:00 committed by Andrew Kelley
parent afdcfb005e
commit c9598c4cd3
2 changed files with 184 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/value.zig
View File

@ -2693,16 +2693,14 @@ pub const Value = extern union {
if (int_ty.zigTypeTag() == .Vector) { if (int_ty.zigTypeTag() == .Vector) {
const result_data = try arena.alloc(Value, int_ty.vectorLen()); const result_data = try arena.alloc(Value, int_ty.vectorLen());
for (result_data) |*scalar, i| { for (result_data) |*scalar, i| {
scalar.* = try intToFloatScalar(val.indexVectorlike(i), arena, int_ty.scalarType(), float_ty.scalarType(), target); scalar.* = try intToFloatScalar(val.indexVectorlike(i), arena, float_ty.scalarType(), target);
} }
return Value.Tag.aggregate.create(arena, result_data); return Value.Tag.aggregate.create(arena, result_data);
} }
return intToFloatScalar(val, arena, int_ty, float_ty, target); return intToFloatScalar(val, arena, float_ty, target);
} }
pub fn intToFloatScalar(val: Value, arena: Allocator, int_ty: Type, float_ty: Type, target: Target) !Value { pub fn intToFloatScalar(val: Value, arena: Allocator, float_ty: Type, target: Target) !Value {
assert(int_ty.isNumeric() and !int_ty.isAnyFloat());
assert(float_ty.isAnyFloat());
switch (val.tag()) { switch (val.tag()) {
.undef, .zero, .one => return val, .undef, .zero, .one => return val,
.the_only_possible_value => return Value.initTag(.zero), // for i0, u0 .the_only_possible_value => return Value.initTag(.zero), // for i0, u0
@ -2754,16 +2752,14 @@ pub const Value = extern union {
if (float_ty.zigTypeTag() == .Vector) { if (float_ty.zigTypeTag() == .Vector) {
const result_data = try arena.alloc(Value, float_ty.vectorLen()); const result_data = try arena.alloc(Value, float_ty.vectorLen());
for (result_data) |*scalar, i| { for (result_data) |*scalar, i| {
scalar.* = try floatToIntScalar(val.indexVectorlike(i), arena, float_ty.scalarType(), int_ty.scalarType(), target); scalar.* = try floatToIntScalar(val.indexVectorlike(i), arena, int_ty.scalarType(), target);
} }
return Value.Tag.aggregate.create(arena, result_data); return Value.Tag.aggregate.create(arena, result_data);
} }
return floatToIntScalar(val, arena, float_ty, int_ty, target); return floatToIntScalar(val, arena, int_ty, target);
} }
pub fn floatToIntScalar(val: Value, arena: Allocator, float_ty: Type, int_ty: Type, target: Target) error{ FloatCannotFit, OutOfMemory }!Value { pub fn floatToIntScalar(val: Value, arena: Allocator, int_ty: Type, target: Target) error{ FloatCannotFit, OutOfMemory }!Value {
assert(float_ty.isAnyFloat());
assert(int_ty.isInt());
const Limb = std.math.big.Limb; const Limb = std.math.big.Limb;
var value = val.toFloat(f64); // TODO: f128 ? var value = val.toFloat(f64); // TODO: f128 ?

209
test/behavior/vector.zig
View File

@ -6,7 +6,12 @@ const expect = std.testing.expect;
const Vector = std.meta.Vector; const Vector = std.meta.Vector;
test "implicit cast vector to array - bool" { test "implicit cast vector to array - bool" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
const a: Vector(4, bool) = [_]bool{ true, false, true, false }; const a: Vector(4, bool) = [_]bool{ true, false, true, false };
@ -19,7 +24,12 @@ test "implicit cast vector to array - bool" {
} }
test "vector wrap operators" { test "vector wrap operators" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 }; var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
@ -36,7 +46,12 @@ test "vector wrap operators" {
} }
test "vector bin compares with mem.eql" { test "vector bin compares with mem.eql" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 }; var v: Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
@ -54,7 +69,12 @@ test "vector bin compares with mem.eql" {
} }
test "vector int operators" { test "vector int operators" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
var v: Vector(4, i32) = [4]i32{ 10, 20, 30, 40 }; var v: Vector(4, i32) = [4]i32{ 10, 20, 30, 40 };
@ -70,7 +90,12 @@ test "vector int operators" {
} }
test "vector float operators" { test "vector float operators" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
var v: Vector(4, f32) = [4]f32{ 10, 20, 30, 40 }; var v: Vector(4, f32) = [4]f32{ 10, 20, 30, 40 };
@ -86,7 +111,12 @@ test "vector float operators" {
} }
test "vector bit operators" { test "vector bit operators" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
var v: Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 }; var v: Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 };
@ -101,7 +131,12 @@ test "vector bit operators" {
} }
test "implicit cast vector to array" { test "implicit cast vector to array" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
var a: Vector(4, i32) = [_]i32{ 1, 2, 3, 4 }; var a: Vector(4, i32) = [_]i32{ 1, 2, 3, 4 };
@ -115,7 +150,12 @@ test "implicit cast vector to array" {
} }
test "array to vector" { test "array to vector" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
var foo: f32 = 3.14; var foo: f32 = 3.14;
@ -129,7 +169,12 @@ test "array to vector" {
} }
test "vector casts of sizes not divisible by 8" { test "vector casts of sizes not divisible by 8" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
{ {
@ -159,7 +204,12 @@ test "vector casts of sizes not divisible by 8" {
} }
test "vector @splat" { test "vector @splat" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn testForT(comptime N: comptime_int, v: anytype) !void { fn testForT(comptime N: comptime_int, v: anytype) !void {
const T = @TypeOf(v); const T = @TypeOf(v);
@ -195,7 +245,12 @@ test "vector @splat" {
} }
test "load vector elements via comptime index" { test "load vector elements via comptime index" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined }; var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
@ -213,7 +268,12 @@ test "load vector elements via comptime index" {
} }
test "store vector elements via comptime index" { test "store vector elements via comptime index" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined }; var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
@ -237,7 +297,12 @@ test "store vector elements via comptime index" {
} }
test "load vector elements via runtime index" { test "load vector elements via runtime index" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined }; var v: Vector(4, i32) = [_]i32{ 1, 2, 3, undefined };
@ -255,7 +320,12 @@ test "load vector elements via runtime index" {
} }
test "store vector elements via runtime index" { test "store vector elements via runtime index" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined }; var v: Vector(4, i32) = [_]i32{ 1, 5, 3, undefined };
@ -274,7 +344,12 @@ test "store vector elements via runtime index" {
} }
test "initialize vector which is a struct field" { test "initialize vector which is a struct field" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const Vec4Obj = struct { const Vec4Obj = struct {
data: Vector(4, f32), data: Vector(4, f32),
}; };
@ -292,7 +367,12 @@ test "initialize vector which is a struct field" {
} }
test "vector comparison operators" { test "vector comparison operators" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
{ {
@ -327,7 +407,12 @@ test "vector comparison operators" {
} }
test "vector division operators" { test "vector division operators" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTestDiv(comptime T: type, x: Vector(4, T), y: Vector(4, T)) !void { fn doTheTestDiv(comptime T: type, x: Vector(4, T), y: Vector(4, T)) !void {
if (!comptime std.meta.trait.isSignedInt(T)) { if (!comptime std.meta.trait.isSignedInt(T)) {
@ -410,7 +495,12 @@ test "vector division operators" {
} }
test "vector bitwise not operator" { test "vector bitwise not operator" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTestNot(comptime T: type, x: Vector(4, T)) !void { fn doTheTestNot(comptime T: type, x: Vector(4, T)) !void {
var y = ~x; var y = ~x;
@ -436,7 +526,12 @@ test "vector bitwise not operator" {
} }
test "vector shift operators" { test "vector shift operators" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTestShift(x: anytype, y: anytype) !void { fn doTheTestShift(x: anytype, y: anytype) !void {
const N = @typeInfo(@TypeOf(x)).Array.len; const N = @typeInfo(@TypeOf(x)).Array.len;
@ -667,7 +762,12 @@ test "vector reduce operation" {
} }
test "mask parameter of @shuffle is comptime scope" { test "mask parameter of @shuffle is comptime scope" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const __v4hi = std.meta.Vector(4, i16); const __v4hi = std.meta.Vector(4, i16);
var v4_a = __v4hi{ 0, 0, 0, 0 }; var v4_a = __v4hi{ 0, 0, 0, 0 };
var v4_b = __v4hi{ 0, 0, 0, 0 }; var v4_b = __v4hi{ 0, 0, 0, 0 };
@ -681,13 +781,30 @@ test "mask parameter of @shuffle is comptime scope" {
} }
test "saturating add" { test "saturating add" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
const u8x3 = std.meta.Vector(3, u8); { // Broken out to avoid https://github.com/ziglang/zig/issues/11251
try expect(mem.eql(u8, &@as([3]u8, u8x3{ 255, 255, 255 }), &@as([3]u8, u8x3{ 255, 254, 1 } +| u8x3{ 1, 2, 255 }))); const u8x3 = std.meta.Vector(3, u8);
const i8x3 = std.meta.Vector(3, i8); const lhs = u8x3{ 255, 254, 1 };
try expect(mem.eql(i8, &@as([3]i8, i8x3{ 127, 127, 127 }), &@as([3]i8, i8x3{ 127, 126, 1 } +| i8x3{ 1, 2, 127 }))); const rhs = u8x3{ 1, 2, 255 };
const result = lhs +| rhs;
const expected = u8x3{ 255, 255, 255 };
try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
}
{ // Broken out to avoid https://github.com/ziglang/zig/issues/11251
const i8x3 = std.meta.Vector(3, i8);
const lhs = i8x3{ 127, 126, 1 };
const rhs = i8x3{ 1, 2, 127 };
const result = lhs +| rhs;
const expected = i8x3{ 127, 127, 127 };
try expect(mem.eql(i8, &@as([3]i8, expected), &@as([3]i8, result)));
}
} }
}; };
try S.doTheTest(); try S.doTheTest();
@ -695,11 +812,21 @@ test "saturating add" {
} }
test "saturating subtraction" { test "saturating subtraction" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
// Broken out to avoid https://github.com/ziglang/zig/issues/11251
const u8x3 = std.meta.Vector(3, u8); const u8x3 = std.meta.Vector(3, u8);
try expect(mem.eql(u8, &@as([3]u8, u8x3{ 0, 0, 0 }), &@as([3]u8, u8x3{ 0, 0, 0 } -| u8x3{ 255, 255, 255 }))); const lhs = u8x3{ 0, 0, 0 };
const rhs = u8x3{ 255, 255, 255 };
const result = lhs -| rhs;
const expected = u8x3{ 0, 0, 0 };
try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
} }
}; };
try S.doTheTest(); try S.doTheTest();
@ -707,14 +834,24 @@ test "saturating subtraction" {
} }
test "saturating multiplication" { test "saturating multiplication" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
// TODO: once #9660 has been solved, remove this line // TODO: once #9660 has been solved, remove this line
if (builtin.target.cpu.arch == .wasm32) return error.SkipZigTest; if (builtin.target.cpu.arch == .wasm32) return error.SkipZigTest;
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
// Broken out to avoid https://github.com/ziglang/zig/issues/11251
const u8x3 = std.meta.Vector(3, u8); const u8x3 = std.meta.Vector(3, u8);
try expect(mem.eql(u8, &@as([3]u8, u8x3{ 255, 255, 255 }), &@as([3]u8, u8x3{ 2, 2, 2 } *| u8x3{ 255, 255, 255 }))); const lhs = u8x3{ 2, 2, 2 };
const rhs = u8x3{ 255, 255, 255 };
const result = lhs *| rhs;
const expected = u8x3{ 255, 255, 255 };
try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
} }
}; };
@ -723,11 +860,21 @@ test "saturating multiplication" {
} }
test "saturating shift-left" { test "saturating shift-left" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
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_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct { const S = struct {
fn doTheTest() !void { fn doTheTest() !void {
// Broken out to avoid https://github.com/ziglang/zig/issues/11251
const u8x3 = std.meta.Vector(3, u8); const u8x3 = std.meta.Vector(3, u8);
try expect(mem.eql(u8, &@as([3]u8, u8x3{ 255, 255, 255 }), &@as([3]u8, u8x3{ 255, 255, 255 } <<| u8x3{ 1, 1, 1 }))); const lhs = u8x3{ 1, 1, 1 };
const rhs = u8x3{ 255, 255, 255 };
const result = lhs <<| rhs;
const expected = u8x3{ 255, 255, 255 };
try expect(mem.eql(u8, &@as([3]u8, expected), &@as([3]u8, result)));
} }
}; };
try S.doTheTest(); try S.doTheTest();