Commit c86589a738e5053a26b2be7d156bcfee1565f00b | zig

author	Andrew Kelley <andrew@ziglang.org> 2020-01-23 02:05:24-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-01-23 02:05:24-05:00
log	c86589a738e5053a26b2be7d156bcfee1565f00b
tree	71b186ca97808438a0a236d2b3f2f1730d80a9f0
parent	ead7d15772587cecff69d8b8fac3b5122ff2b98c

disable f128 compiler_rt tests failing on windows

These were never working with native CPU features. In this branch,
we fix native CPU features not being enabled on Windows, and regress
f128 language features. In the llvm10 branch, all this is fixed,
and the tests are re-enabled.

11 files changed, 52 insertions(+), 0 deletions(-)

lib
- std
  - special
    compiler_rt
    addXf3_test.zig
    fixtfdi_test.zig
    fixtfsi_test.zig
    fixtfti_test.zig
    fixunstfdi_test.zig
    fixunstfsi_test.zig
    fixunstfti_test.zig
    floattitf_test.zig
    floatuntitf_test.zig
    mulXf3_test.zig
    truncXfYf2_test.zig

lib/std/special/compiler_rt/addXf3_test.zig+8

 @@ -31,6 +31,10 @@ fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
 }
 test "addtf3" {
+    if (@import("std").Target.current.isWindows()) {
+        // TODO https://github.com/ziglang/zig/issues/508
+        return error.SkipZigTest;
+    }
     test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
     // NaN + any = NaN
 @@ -71,6 +75,10 @@ fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
 }
 test "subtf3" {
+    if (@import("std").Target.current.isWindows()) {
+        // TODO https://github.com/ziglang/zig/issues/508
+        return error.SkipZigTest;
+    }
     // qNaN - any = qNaN
     test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);

lib/std/special/compiler_rt/fixtfdi_test.zig+4

 @@ -11,6 +11,10 @@ fn test__fixtfdi(a: f128, expected: i64) void {
 }
 test "fixtfdi" {
+    if (@import("std").Target.current.isWindows()) {
+        // TODO https://github.com/ziglang/zig/issues/508
+        return error.SkipZigTest;
+    }
     //warn("\n", .{});
     test__fixtfdi(-math.f128_max, math.minInt(i64));

lib/std/special/compiler_rt/fixtfsi_test.zig+4

 @@ -11,6 +11,10 @@ fn test__fixtfsi(a: f128, expected: i32) void {
 }
 test "fixtfsi" {
+    if (@import("std").Target.current.isWindows()) {
+        // TODO https://github.com/ziglang/zig/issues/508
+        return error.SkipZigTest;
+    }
     //warn("\n", .{});
     test__fixtfsi(-math.f128_max, math.minInt(i32));

lib/std/special/compiler_rt/fixtfti_test.zig+4

 @@ -11,6 +11,10 @@ fn test__fixtfti(a: f128, expected: i128) void {
 }
 test "fixtfti" {
+    if (@import("std").Target.current.isWindows()) {
+        // TODO https://github.com/ziglang/zig/issues/508
+        return error.SkipZigTest;
+    }
     //warn("\n", .{});
     test__fixtfti(-math.f128_max, math.minInt(i128));

lib/std/special/compiler_rt/fixunstfdi_test.zig+4

 @@ -7,6 +7,10 @@ fn test__fixunstfdi(a: f128, expected: u64) void {
 }
 test "fixunstfdi" {
+    if (@import("std").Target.current.isWindows()) {
+        // TODO https://github.com/ziglang/zig/issues/508
+        return error.SkipZigTest;
+    }
     test__fixunstfdi(0.0, 0);
     test__fixunstfdi(0.5, 0);

lib/std/special/compiler_rt/fixunstfsi_test.zig+4

 @@ -9,6 +9,10 @@ fn test__fixunstfsi(a: f128, expected: u32) void {
 const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000));
 test "fixunstfsi" {
+    if (@import("std").Target.current.isWindows()) {
+        // TODO https://github.com/ziglang/zig/issues/508
+        return error.SkipZigTest;
+    }
     test__fixunstfsi(inf128, 0xffffffff);
     test__fixunstfsi(0, 0x0);
     test__fixunstfsi(0x1.23456789abcdefp+5, 0x24);

lib/std/special/compiler_rt/fixunstfti_test.zig+4

 @@ -9,6 +9,10 @@ fn test__fixunstfti(a: f128, expected: u128) void {
 const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000));
 test "fixunstfti" {
+    if (@import("std").Target.current.isWindows()) {
+        // TODO https://github.com/ziglang/zig/issues/508
+        return error.SkipZigTest;
+    }
     test__fixunstfti(inf128, 0xffffffffffffffffffffffffffffffff);
     test__fixunstfti(0.0, 0);

lib/std/special/compiler_rt/floattitf_test.zig+4

 @@ -7,6 +7,10 @@ fn test__floattitf(a: i128, expected: f128) void {
 }
 test "floattitf" {
+    if (@import("std").Target.current.isWindows()) {
+        // TODO https://github.com/ziglang/zig/issues/508
+        return error.SkipZigTest;
+    }
     test__floattitf(0, 0.0);
     test__floattitf(1, 1.0);

lib/std/special/compiler_rt/floatuntitf_test.zig+4

 @@ -7,6 +7,10 @@ fn test__floatuntitf(a: u128, expected: f128) void {
 }
 test "floatuntitf" {
+    if (@import("std").Target.current.isWindows()) {
+        // TODO https://github.com/ziglang/zig/issues/508
+        return error.SkipZigTest;
+    }
     test__floatuntitf(0, 0.0);
     test__floatuntitf(1, 1.0);

lib/std/special/compiler_rt/mulXf3_test.zig+4

 @@ -44,6 +44,10 @@ fn makeNaN128(rand: u64) f128 {
     return float_result;
 }
 test "multf3" {
+    if (@import("std").Target.current.isWindows()) {
+        // TODO https://github.com/ziglang/zig/issues/508
+        return error.SkipZigTest;
+    }
     // qNaN * any = qNaN
     test__multf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);

lib/std/special/compiler_rt/truncXfYf2_test.zig+8

 @@ -151,6 +151,10 @@ fn test__trunctfsf2(a: f128, expected: u32) void {
 }
 test "trunctfsf2" {
+    if (@import("std").Target.current.isWindows()) {
+        // TODO https://github.com/ziglang/zig/issues/508
+        return error.SkipZigTest;
+    }
     // qnan
     test__trunctfsf2(@bitCast(f128, @as(u128, 0x7fff800000000000 << 64)), 0x7fc00000);
     // nan
 @@ -186,6 +190,10 @@ fn test__trunctfdf2(a: f128, expected: u64) void {
 }
 test "trunctfdf2" {
+    if (@import("std").Target.current.isWindows()) {
+        // TODO https://github.com/ziglang/zig/issues/508
+        return error.SkipZigTest;
+    }
     // qnan
     test__trunctfdf2(@bitCast(f128, @as(u128, 0x7fff800000000000 << 64)), 0x7ff8000000000000);
     // nan