mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-01-21 06:45:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove workarounds for Windows native CPU features

Browse Source 
bug fixed in LLVM 10

closes #508
This commit is contained in:
Andrew Kelley 2020-02-07 12:41:02 -05:00
parent a1576225ca
commit 9e5b248991
No known key found for this signature in database
GPG Key ID: 7C5F548F728501A9
17 changed files with 1 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/std/fmt/parse_float.zig
View File

@ -382,10 +382,6 @@ pub fn parseFloat(comptime T: type, s: []const u8) !T {
}
test "fmt.parseFloat" {
if (std.Target.current.isWindows()) {
// TODO https://github.com/ziglang/zig/issues/508
return error.SkipZigTest;
}
const testing = std.testing;
const expect = testing.expect;
const expectEqual = testing.expectEqual;

4
lib/std/io/test.zig
View File

@ -547,10 +547,6 @@ fn testSerializerDeserializer(comptime endian: builtin.Endian, comptime packing:
}
test "Serializer/Deserializer generic" {
if (std.Target.current.isWindows()) {
// TODO https://github.com/ziglang/zig/issues/508
return error.SkipZigTest;
}
try testSerializerDeserializer(builtin.Endian.Big, .Byte);
try testSerializerDeserializer(builtin.Endian.Little, .Byte);
try testSerializerDeserializer(builtin.Endian.Big, .Bit);

4
lib/std/math/fabs.zig
View File

@ -95,10 +95,6 @@ test "math.fabs64.special" {
}
test "math.fabs128.special" {
if (std.Target.current.isWindows()) {
// TODO https://github.com/ziglang/zig/issues/508
return error.SkipZigTest;
}
expect(math.isPositiveInf(fabs(math.inf(f128))));
expect(math.isPositiveInf(fabs(-math.inf(f128))));
expect(math.isNan(fabs(math.nan(f128))));

12
lib/std/math/isinf.zig
View File

@ -74,10 +74,6 @@ pub fn isNegativeInf(x: var) bool {
}
test "math.isInf" {
if (std.Target.current.isWindows()) {
// TODO https://github.com/ziglang/zig/issues/508
return error.SkipZigTest;
}
expect(!isInf(@as(f16, 0.0)));
expect(!isInf(@as(f16, -0.0)));
expect(!isInf(@as(f32, 0.0)));
@ -97,10 +93,6 @@ test "math.isInf" {
}
test "math.isPositiveInf" {
if (std.Target.current.isWindows()) {
// TODO https://github.com/ziglang/zig/issues/508
return error.SkipZigTest;
}
expect(!isPositiveInf(@as(f16, 0.0)));
expect(!isPositiveInf(@as(f16, -0.0)));
expect(!isPositiveInf(@as(f32, 0.0)));
@ -120,10 +112,6 @@ test "math.isPositiveInf" {
}
test "math.isNegativeInf" {
if (std.Target.current.isWindows()) {
// TODO https://github.com/ziglang/zig/issues/508
return error.SkipZigTest;
}
expect(!isNegativeInf(@as(f16, 0.0)));
expect(!isNegativeInf(@as(f16, -0.0)));
expect(!isNegativeInf(@as(f32, 0.0)));

4
lib/std/math/isnan.zig
View File

@ -16,10 +16,6 @@ pub fn isSignalNan(x: var) bool {
}
test "math.isNan" {
if (std.Target.current.isWindows()) {
// TODO https://github.com/ziglang/zig/issues/508
return error.SkipZigTest;
}
expect(isNan(math.nan(f16)));
expect(isNan(math.nan(f32)));
expect(isNan(math.nan(f64)));

8
lib/std/special/compiler_rt/addXf3_test.zig
View File

@ -31,10 +31,6 @@ 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
@ -75,10 +71,6 @@ 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);

4
lib/std/special/compiler_rt/fixtfdi_test.zig
View File

@ -11,10 +11,6 @@ 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));

4
lib/std/special/compiler_rt/fixtfsi_test.zig
View File

@ -11,10 +11,6 @@ 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));

4
lib/std/special/compiler_rt/fixtfti_test.zig
View File

@ -11,10 +11,6 @@ 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));

4
lib/std/special/compiler_rt/fixunstfdi_test.zig
View File

@ -7,10 +7,6 @@ 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);

4
lib/std/special/compiler_rt/fixunstfsi_test.zig
View File

@ -9,10 +9,6 @@ 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);

4
lib/std/special/compiler_rt/fixunstfti_test.zig
View File

@ -9,10 +9,6 @@ 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);

4
lib/std/special/compiler_rt/floattitf_test.zig
View File

@ -7,10 +7,6 @@ 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);

4
lib/std/special/compiler_rt/floatuntitf_test.zig
View File

@ -7,10 +7,6 @@ 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);

4
lib/std/special/compiler_rt/mulXf3_test.zig
View File

@ -44,10 +44,6 @@ 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);

8
lib/std/special/compiler_rt/truncXfYf2_test.zig
View File

@ -151,10 +151,6 @@ 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
@ -190,10 +186,6 @@ 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

5
src-self-hosted/compilation.zig
View File

@ -451,14 +451,11 @@ pub const Compilation = struct {
const reloc_mode = if (is_static) llvm.RelocStatic else llvm.RelocPIC;
// LLVM creates invalid binaries on Windows sometimes.
// See https://github.com/ziglang/zig/issues/508
// As a workaround we do not use target native features on Windows.
var target_specific_cpu_args: ?[*:0]u8 = null;
var target_specific_cpu_features: ?[*:0]u8 = null;
defer llvm.DisposeMessage(target_specific_cpu_args);
defer llvm.DisposeMessage(target_specific_cpu_features);
if (target == Target.Native and !target.isWindows()) {
if (target == Target.Native) {
target_specific_cpu_args = llvm.GetHostCPUName() orelse return error.OutOfMemory;
target_specific_cpu_features = llvm.GetNativeFeatures() orelse return error.OutOfMemory;
}