authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2021-05-06 09:32:29+03:00
committergravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2021-05-08 15:15:30+03:00
log7fe39c4e9680870f0bf30368c9f5b345b262b0eb
tree5349a75c27a0242f643764ec3bdbaf8ac77f2e77
parent42a95197f32b46ee7b504282ab345209cb43c247

update usage of std.testing in compiler_rt

60 files changed, 2259 insertions(+), 2259 deletions(-)

lib/std/special/c.zig+20-20
...@@ -66,7 +66,7 @@ test "strcpy" {...@@ -66,7 +66,7 @@ test "strcpy" {
6666
67 s1[0] = 0;67 s1[0] = 0;
68 _ = strcpy(&s1, "foobarbaz");68 _ = strcpy(&s1, "foobarbaz");
69 std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));69 try std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));
70}70}
7171
72fn strncpy(dest: [*:0]u8, src: [*:0]const u8, n: usize) callconv(.C) [*:0]u8 {72fn strncpy(dest: [*:0]u8, src: [*:0]const u8, n: usize) callconv(.C) [*:0]u8 {
...@@ -86,7 +86,7 @@ test "strncpy" {...@@ -86,7 +86,7 @@ test "strncpy" {
8686
87 s1[0] = 0;87 s1[0] = 0;
88 _ = strncpy(&s1, "foobarbaz", @sizeOf(@TypeOf(s1)));88 _ = strncpy(&s1, "foobarbaz", @sizeOf(@TypeOf(s1)));
89 std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));89 try std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));
90}90}
9191
92fn strcat(dest: [*:0]u8, src: [*:0]const u8) callconv(.C) [*:0]u8 {92fn strcat(dest: [*:0]u8, src: [*:0]const u8) callconv(.C) [*:0]u8 {
...@@ -109,7 +109,7 @@ test "strcat" {...@@ -109,7 +109,7 @@ test "strcat" {
109 _ = strcat(&s1, "foo");109 _ = strcat(&s1, "foo");
110 _ = strcat(&s1, "bar");110 _ = strcat(&s1, "bar");
111 _ = strcat(&s1, "baz");111 _ = strcat(&s1, "baz");
112 std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));112 try std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));
113}113}
114114
115fn strncat(dest: [*:0]u8, src: [*:0]const u8, avail: usize) callconv(.C) [*:0]u8 {115fn strncat(dest: [*:0]u8, src: [*:0]const u8, avail: usize) callconv(.C) [*:0]u8 {
...@@ -132,7 +132,7 @@ test "strncat" {...@@ -132,7 +132,7 @@ test "strncat" {
132 _ = strncat(&s1, "foo1111", 3);132 _ = strncat(&s1, "foo1111", 3);
133 _ = strncat(&s1, "bar1111", 3);133 _ = strncat(&s1, "bar1111", 3);
134 _ = strncat(&s1, "baz1111", 3);134 _ = strncat(&s1, "baz1111", 3);
135 std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));135 try std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));
136}136}
137137
138fn strcmp(s1: [*:0]const u8, s2: [*:0]const u8) callconv(.C) c_int {138fn strcmp(s1: [*:0]const u8, s2: [*:0]const u8) callconv(.C) c_int {
...@@ -871,13 +871,13 @@ test "fmod, fmodf" {...@@ -871,13 +871,13 @@ test "fmod, fmodf" {
871 try std.testing.expect(isNan(generic_fmod(T, 0.0, 0.0)));871 try std.testing.expect(isNan(generic_fmod(T, 0.0, 0.0)));
872 try std.testing.expect(isNan(generic_fmod(T, 1.0, 0.0)));872 try std.testing.expect(isNan(generic_fmod(T, 1.0, 0.0)));
873873
874 std.testing.expectEqual(@as(T, 0.0), generic_fmod(T, 0.0, 2.0));874 try std.testing.expectEqual(@as(T, 0.0), generic_fmod(T, 0.0, 2.0));
875 std.testing.expectEqual(@as(T, -0.0), generic_fmod(T, -0.0, 2.0));875 try std.testing.expectEqual(@as(T, -0.0), generic_fmod(T, -0.0, 2.0));
876876
877 std.testing.expectEqual(@as(T, -2.0), generic_fmod(T, -32.0, 10.0));877 try std.testing.expectEqual(@as(T, -2.0), generic_fmod(T, -32.0, 10.0));
878 std.testing.expectEqual(@as(T, -2.0), generic_fmod(T, -32.0, -10.0));878 try std.testing.expectEqual(@as(T, -2.0), generic_fmod(T, -32.0, -10.0));
879 std.testing.expectEqual(@as(T, 2.0), generic_fmod(T, 32.0, 10.0));879 try std.testing.expectEqual(@as(T, 2.0), generic_fmod(T, 32.0, 10.0));
880 std.testing.expectEqual(@as(T, 2.0), generic_fmod(T, 32.0, -10.0));880 try std.testing.expectEqual(@as(T, 2.0), generic_fmod(T, 32.0, -10.0));
881 }881 }
882}882}
883883
...@@ -902,11 +902,11 @@ test "fmin, fminf" {...@@ -902,11 +902,11 @@ test "fmin, fminf" {
902 const nan_val = math.nan(T);902 const nan_val = math.nan(T);
903903
904 try std.testing.expect(isNan(generic_fmin(T, nan_val, nan_val)));904 try std.testing.expect(isNan(generic_fmin(T, nan_val, nan_val)));
905 std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, nan_val, 1.0));905 try std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, nan_val, 1.0));
906 std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, 1.0, nan_val));906 try std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, 1.0, nan_val));
907907
908 std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, 1.0, 10.0));908 try std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, 1.0, 10.0));
909 std.testing.expectEqual(@as(T, -1.0), generic_fmin(T, 1.0, -1.0));909 try std.testing.expectEqual(@as(T, -1.0), generic_fmin(T, 1.0, -1.0));
910 }910 }
911}911}
912912
...@@ -931,11 +931,11 @@ test "fmax, fmaxf" {...@@ -931,11 +931,11 @@ test "fmax, fmaxf" {
931 const nan_val = math.nan(T);931 const nan_val = math.nan(T);
932932
933 try std.testing.expect(isNan(generic_fmax(T, nan_val, nan_val)));933 try std.testing.expect(isNan(generic_fmax(T, nan_val, nan_val)));
934 std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, nan_val, 1.0));934 try std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, nan_val, 1.0));
935 std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, 1.0, nan_val));935 try std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, 1.0, nan_val));
936936
937 std.testing.expectEqual(@as(T, 10.0), generic_fmax(T, 1.0, 10.0));937 try std.testing.expectEqual(@as(T, 10.0), generic_fmax(T, 1.0, 10.0));
938 std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, 1.0, -1.0));938 try std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, 1.0, -1.0));
939 }939 }
940}940}
941941
...@@ -1090,7 +1090,7 @@ test "sqrt" {...@@ -1090,7 +1090,7 @@ test "sqrt" {
1090 // Note that @sqrt will either generate the sqrt opcode (if supported by the1090 // Note that @sqrt will either generate the sqrt opcode (if supported by the
1091 // target ISA) or a call to `sqrtf` otherwise.1091 // target ISA) or a call to `sqrtf` otherwise.
1092 for (V) |val|1092 for (V) |val|
1093 std.testing.expectEqual(@sqrt(val), sqrt(val));1093 try std.testing.expectEqual(@sqrt(val), sqrt(val));
1094}1094}
10951095
1096test "sqrt special" {1096test "sqrt special" {
...@@ -1195,7 +1195,7 @@ test "sqrtf" {...@@ -1195,7 +1195,7 @@ test "sqrtf" {
1195 // Note that @sqrt will either generate the sqrt opcode (if supported by the1195 // Note that @sqrt will either generate the sqrt opcode (if supported by the
1196 // target ISA) or a call to `sqrtf` otherwise.1196 // target ISA) or a call to `sqrtf` otherwise.
1197 for (V) |val|1197 for (V) |val|
1198 std.testing.expectEqual(@sqrt(val), sqrtf(val));1198 try std.testing.expectEqual(@sqrt(val), sqrtf(val));
1199}1199}
12001200
1201test "sqrtf special" {1201test "sqrtf special" {
lib/std/special/compiler_rt/addXf3_test.zig+13-13
...@@ -13,7 +13,7 @@ const inf128 = @bitCast(f128, @as(u128, 0x7fff000000000000) << 64);...@@ -13,7 +13,7 @@ const inf128 = @bitCast(f128, @as(u128, 0x7fff000000000000) << 64);
1313
14const __addtf3 = @import("addXf3.zig").__addtf3;14const __addtf3 = @import("addXf3.zig").__addtf3;
1515
16fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {16fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
17 const x = __addtf3(a, b);17 const x = __addtf3(a, b);
1818
19 const rep = @bitCast(u128, x);19 const rep = @bitCast(u128, x);
...@@ -32,28 +32,28 @@ fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {...@@ -32,28 +32,28 @@ fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
32 }32 }
33 }33 }
3434
35 @panic("__addtf3 test failure");35 return error.TestFailed;
36}36}
3737
38test "addtf3" {38test "addtf3" {
39 test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);39 try test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
4040
41 // NaN + any = NaN41 // NaN + any = NaN
42 test__addtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);42 try test__addtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
4343
44 // inf + inf = inf44 // inf + inf = inf
45 test__addtf3(inf128, inf128, 0x7fff000000000000, 0x0);45 try test__addtf3(inf128, inf128, 0x7fff000000000000, 0x0);
4646
47 // inf + any = inf47 // inf + any = inf
48 test__addtf3(inf128, 0x1.2335653452436234723489432abcdefp+5, 0x7fff000000000000, 0x0);48 try test__addtf3(inf128, 0x1.2335653452436234723489432abcdefp+5, 0x7fff000000000000, 0x0);
4949
50 // any + any50 // any + any
51 test__addtf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);51 try test__addtf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);
52}52}
5353
54const __subtf3 = @import("addXf3.zig").__subtf3;54const __subtf3 = @import("addXf3.zig").__subtf3;
5555
56fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {56fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
57 const x = __subtf3(a, b);57 const x = __subtf3(a, b);
5858
59 const rep = @bitCast(u128, x);59 const rep = @bitCast(u128, x);
...@@ -72,19 +72,19 @@ fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {...@@ -72,19 +72,19 @@ fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
72 }72 }
73 }73 }
7474
75 @panic("__subtf3 test failure");75 return error.TestFailed;
76}76}
7777
78test "subtf3" {78test "subtf3" {
79 // qNaN - any = qNaN79 // qNaN - any = qNaN
80 test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);80 try test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
8181
82 // NaN + any = NaN82 // NaN + any = NaN
83 test__subtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);83 try test__subtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
8484
85 // inf - any = inf85 // inf - any = inf
86 test__subtf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);86 try test__subtf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
8787
88 // any + any88 // any + any
89 test__subtf3(0x1.234567829a3bcdef5678ade36734p+5, 0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x40041b8af1915166, 0xa44a7bca780a166c);89 try test__subtf3(0x1.234567829a3bcdef5678ade36734p+5, 0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x40041b8af1915166, 0xa44a7bca780a166c);
90}90}
lib/std/special/compiler_rt/ashldi3_test.zig+20-20
...@@ -6,32 +6,32 @@...@@ -6,32 +6,32 @@
6const __ashldi3 = @import("shift.zig").__ashldi3;6const __ashldi3 = @import("shift.zig").__ashldi3;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__ashldi3(a: i64, b: i32, expected: u64) void {9fn test__ashldi3(a: i64, b: i32, expected: u64) !void {
10 const x = __ashldi3(a, b);10 const x = __ashldi3(a, b);
11 testing.expectEqual(@bitCast(i64, expected), x);11 try testing.expectEqual(@bitCast(i64, expected), x);
12}12}
1313
14test "ashldi3" {14test "ashldi3" {
15 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF);15 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF);
16 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x2468ACF13579BDE);16 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x2468ACF13579BDE);
17 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37BC);17 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37BC);
18 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x91A2B3C4D5E6F78);18 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x91A2B3C4D5E6F78);
19 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDEF0);19 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDEF0);
2020
21 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x789ABCDEF0000000);21 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x789ABCDEF0000000);
22 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0xF13579BDE0000000);22 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0xF13579BDE0000000);
23 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0xE26AF37BC0000000);23 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0xE26AF37BC0000000);
24 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0xC4D5E6F780000000);24 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0xC4D5E6F780000000);
2525
26 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x89ABCDEF00000000);26 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x89ABCDEF00000000);
2727
28 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x13579BDE00000000);28 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x13579BDE00000000);
29 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x26AF37BC00000000);29 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x26AF37BC00000000);
30 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x4D5E6F7800000000);30 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x4D5E6F7800000000);
31 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x9ABCDEF000000000);31 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x9ABCDEF000000000);
3232
33 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0xF000000000000000);33 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0xF000000000000000);
34 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0xE000000000000000);34 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0xE000000000000000);
35 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0xC000000000000000);35 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0xC000000000000000);
36 test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0x8000000000000000);36 try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0x8000000000000000);
37}37}
lib/std/special/compiler_rt/ashlti3_test.zig+38-38
...@@ -6,46 +6,46 @@...@@ -6,46 +6,46 @@
6const __ashlti3 = @import("shift.zig").__ashlti3;6const __ashlti3 = @import("shift.zig").__ashlti3;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__ashlti3(a: i128, b: i32, expected: i128) void {9fn test__ashlti3(a: i128, b: i32, expected: i128) !void {
10 const x = __ashlti3(a, b);10 const x = __ashlti3(a, b);
11 testing.expectEqual(expected, x);11 try testing.expectEqual(expected, x);
12}12}
1313
14test "ashlti3" {14test "ashlti3" {
15 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)));15 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)));
16 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0xFDB97530ECA8642BFDB97530ECA8642A)));16 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0xFDB97530ECA8642BFDB97530ECA8642A)));
17 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0xFB72EA61D950C857FB72EA61D950C854)));17 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0xFB72EA61D950C857FB72EA61D950C854)));
18 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0xF6E5D4C3B2A190AFF6E5D4C3B2A190A8)));18 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0xF6E5D4C3B2A190AFF6E5D4C3B2A190A8)));
19 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0xEDCBA9876543215FEDCBA98765432150)));19 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0xEDCBA9876543215FEDCBA98765432150)));
20 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0x876543215FEDCBA98765432150000000)));20 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0x876543215FEDCBA98765432150000000)));
21 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0x0ECA8642BFDB97530ECA8642A0000000)));21 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0x0ECA8642BFDB97530ECA8642A0000000)));
22 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0x1D950C857FB72EA61D950C8540000000)));22 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0x1D950C857FB72EA61D950C8540000000)));
23 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0x3B2A190AFF6E5D4C3B2A190A80000000)));23 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0x3B2A190AFF6E5D4C3B2A190A80000000)));
24 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0x76543215FEDCBA987654321500000000)));24 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0x76543215FEDCBA987654321500000000)));
25 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0xECA8642BFDB97530ECA8642A00000000)));25 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0xECA8642BFDB97530ECA8642A00000000)));
26 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0xD950C857FB72EA61D950C85400000000)));26 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0xD950C857FB72EA61D950C85400000000)));
27 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0xB2A190AFF6E5D4C3B2A190A800000000)));27 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0xB2A190AFF6E5D4C3B2A190A800000000)));
28 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0x6543215FEDCBA9876543215000000000)));28 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0x6543215FEDCBA9876543215000000000)));
29 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0x5FEDCBA9876543215000000000000000)));29 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0x5FEDCBA9876543215000000000000000)));
30 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0xBFDB97530ECA8642A000000000000000)));30 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0xBFDB97530ECA8642A000000000000000)));
31 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0x7FB72EA61D950C854000000000000000)));31 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0x7FB72EA61D950C854000000000000000)));
32 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0xFF6E5D4C3B2A190A8000000000000000)));32 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0xFF6E5D4C3B2A190A8000000000000000)));
33 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0xFEDCBA98765432150000000000000000)));33 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0xFEDCBA98765432150000000000000000)));
34 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0xFDB97530ECA8642A0000000000000000)));34 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0xFDB97530ECA8642A0000000000000000)));
35 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0xFB72EA61D950C8540000000000000000)));35 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0xFB72EA61D950C8540000000000000000)));
36 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0xF6E5D4C3B2A190A80000000000000000)));36 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0xF6E5D4C3B2A190A80000000000000000)));
37 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0xEDCBA987654321500000000000000000)));37 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0xEDCBA987654321500000000000000000)));
38 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0x87654321500000000000000000000000)));38 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0x87654321500000000000000000000000)));
39 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0x0ECA8642A00000000000000000000000)));39 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0x0ECA8642A00000000000000000000000)));
40 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0x1D950C85400000000000000000000000)));40 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0x1D950C85400000000000000000000000)));
41 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0x3B2A190A800000000000000000000000)));41 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0x3B2A190A800000000000000000000000)));
42 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0x76543215000000000000000000000000)));42 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0x76543215000000000000000000000000)));
43 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0xECA8642A000000000000000000000000)));43 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0xECA8642A000000000000000000000000)));
44 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0xD950C854000000000000000000000000)));44 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0xD950C854000000000000000000000000)));
45 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0xB2A190A8000000000000000000000000)));45 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0xB2A190A8000000000000000000000000)));
46 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0x65432150000000000000000000000000)));46 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0x65432150000000000000000000000000)));
47 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0x50000000000000000000000000000000)));47 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0x50000000000000000000000000000000)));
48 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0xA0000000000000000000000000000000)));48 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0xA0000000000000000000000000000000)));
49 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0x40000000000000000000000000000000)));49 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0x40000000000000000000000000000000)));
50 test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0x80000000000000000000000000000000)));50 try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0x80000000000000000000000000000000)));
51}51}
lib/std/special/compiler_rt/ashrdi3_test.zig+47-47
...@@ -6,55 +6,55 @@...@@ -6,55 +6,55 @@
6const __ashrdi3 = @import("shift.zig").__ashrdi3;6const __ashrdi3 = @import("shift.zig").__ashrdi3;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__ashrdi3(a: i64, b: i32, expected: u64) void {9fn test__ashrdi3(a: i64, b: i32, expected: u64) !void {
10 const x = __ashrdi3(a, b);10 const x = __ashrdi3(a, b);
11 testing.expectEqual(@bitCast(i64, expected), x);11 try testing.expectEqual(@bitCast(i64, expected), x);
12}12}
1313
14test "ashrdi3" {14test "ashrdi3" {
15 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF);15 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF);
16 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x91A2B3C4D5E6F7);16 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x91A2B3C4D5E6F7);
17 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37B);17 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37B);
18 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x2468ACF13579BD);18 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x2468ACF13579BD);
19 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDE);19 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDE);
2020
21 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x12345678);21 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x12345678);
22 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0x91A2B3C);22 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0x91A2B3C);
23 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0x48D159E);23 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0x48D159E);
24 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0x2468ACF);24 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0x2468ACF);
2525
26 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x1234567);26 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x1234567);
2727
28 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x91A2B3);28 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x91A2B3);
29 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x48D159);29 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x48D159);
30 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x2468AC);30 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x2468AC);
31 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x123456);31 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x123456);
3232
33 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0);33 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0);
34 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0);34 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0);
35 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0);35 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0);
36 test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0);36 try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0);
3737
38 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 0, 0xFEDCBA9876543210);38 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 0, 0xFEDCBA9876543210);
39 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 1, 0xFF6E5D4C3B2A1908);39 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 1, 0xFF6E5D4C3B2A1908);
40 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 2, 0xFFB72EA61D950C84);40 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 2, 0xFFB72EA61D950C84);
41 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 3, 0xFFDB97530ECA8642);41 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 3, 0xFFDB97530ECA8642);
42 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 4, 0xFFEDCBA987654321);42 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 4, 0xFFEDCBA987654321);
4343
44 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 28, 0xFFFFFFFFEDCBA987);44 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 28, 0xFFFFFFFFEDCBA987);
45 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 29, 0xFFFFFFFFF6E5D4C3);45 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 29, 0xFFFFFFFFF6E5D4C3);
46 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 30, 0xFFFFFFFFFB72EA61);46 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 30, 0xFFFFFFFFFB72EA61);
47 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 31, 0xFFFFFFFFFDB97530);47 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 31, 0xFFFFFFFFFDB97530);
4848
49 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 32, 0xFFFFFFFFFEDCBA98);49 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 32, 0xFFFFFFFFFEDCBA98);
5050
51 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 33, 0xFFFFFFFFFF6E5D4C);51 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 33, 0xFFFFFFFFFF6E5D4C);
52 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 34, 0xFFFFFFFFFFB72EA6);52 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 34, 0xFFFFFFFFFFB72EA6);
53 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 35, 0xFFFFFFFFFFDB9753);53 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 35, 0xFFFFFFFFFFDB9753);
54 test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 36, 0xFFFFFFFFFFEDCBA9);54 try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 36, 0xFFFFFFFFFFEDCBA9);
5555
56 test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 60, 0xFFFFFFFFFFFFFFFA);56 try test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 60, 0xFFFFFFFFFFFFFFFA);
57 test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 61, 0xFFFFFFFFFFFFFFFD);57 try test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 61, 0xFFFFFFFFFFFFFFFD);
58 test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 62, 0xFFFFFFFFFFFFFFFE);58 try test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 62, 0xFFFFFFFFFFFFFFFE);
59 test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 63, 0xFFFFFFFFFFFFFFFF);59 try test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 63, 0xFFFFFFFFFFFFFFFF);
60}60}
lib/std/special/compiler_rt/ashrti3_test.zig+48-48
...@@ -6,56 +6,56 @@...@@ -6,56 +6,56 @@
6const __ashrti3 = @import("shift.zig").__ashrti3;6const __ashrti3 = @import("shift.zig").__ashrti3;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__ashrti3(a: i128, b: i32, expected: i128) void {9fn test__ashrti3(a: i128, b: i32, expected: i128) !void {
10 const x = __ashrti3(a, b);10 const x = __ashrti3(a, b);
11 testing.expectEqual(expected, x);11 try testing.expectEqual(expected, x);
12}12}
1313
14test "ashrti3" {14test "ashrti3" {
15 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)));15 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)));
16 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0xFF6E5D4C3B2A190AFF6E5D4C3B2A190A)));16 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0xFF6E5D4C3B2A190AFF6E5D4C3B2A190A)));
17 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0xFFB72EA61D950C857FB72EA61D950C85)));17 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0xFFB72EA61D950C857FB72EA61D950C85)));
18 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0xFFDB97530ECA8642BFDB97530ECA8642)));18 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0xFFDB97530ECA8642BFDB97530ECA8642)));
19 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0xFFEDCBA9876543215FEDCBA987654321)));19 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0xFFEDCBA9876543215FEDCBA987654321)));
2020
21 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0xFFFFFFFFEDCBA9876543215FEDCBA987)));21 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0xFFFFFFFFEDCBA9876543215FEDCBA987)));
22 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0xFFFFFFFFF6E5D4C3B2A190AFF6E5D4C3)));22 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0xFFFFFFFFF6E5D4C3B2A190AFF6E5D4C3)));
23 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFB72EA61D950C857FB72EA61)));23 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFB72EA61D950C857FB72EA61)));
24 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFDB97530ECA8642BFDB97530)));24 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFDB97530ECA8642BFDB97530)));
2525
26 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFEDCBA9876543215FEDCBA98)));26 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFEDCBA9876543215FEDCBA98)));
2727
28 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFF6E5D4C3B2A190AFF6E5D4C)));28 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFF6E5D4C3B2A190AFF6E5D4C)));
29 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFB72EA61D950C857FB72EA6)));29 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFB72EA61D950C857FB72EA6)));
30 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFDB97530ECA8642BFDB9753)));30 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFDB97530ECA8642BFDB9753)));
31 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFEDCBA9876543215FEDCBA9)));31 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFEDCBA9876543215FEDCBA9)));
3232
33 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFEDCBA9876543215F)));33 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFEDCBA9876543215F)));
34 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFF6E5D4C3B2A190AF)));34 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFF6E5D4C3B2A190AF)));
35 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFB72EA61D950C857)));35 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFB72EA61D950C857)));
36 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFDB97530ECA8642B)));36 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFDB97530ECA8642B)));
3737
38 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFEDCBA9876543215)));38 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFEDCBA9876543215)));
3939
40 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFF6E5D4C3B2A190A)));40 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFF6E5D4C3B2A190A)));
41 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFB72EA61D950C85)));41 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFB72EA61D950C85)));
42 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFDB97530ECA8642)));42 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFDB97530ECA8642)));
43 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFEDCBA987654321)));43 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFEDCBA987654321)));
4444
45 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFEDCBA987)));45 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFEDCBA987)));
46 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFF6E5D4C3)));46 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFF6E5D4C3)));
47 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFB72EA61)));47 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFB72EA61)));
48 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFDB97530)));48 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFDB97530)));
4949
50 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA98)));50 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA98)));
5151
52 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFF6E5D4C)));52 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFF6E5D4C)));
53 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFB72EA6)));53 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFB72EA6)));
54 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFDB9753)));54 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFDB9753)));
55 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA9)));55 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA9)));
5656
57 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));57 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));
58 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));58 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));
59 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));59 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));
60 test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));60 try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));
61}61}
lib/std/special/compiler_rt/clzsi2_test.zig+281-281
...@@ -6,294 +6,294 @@...@@ -6,294 +6,294 @@
6const clzsi2 = @import("clzsi2.zig");6const clzsi2 = @import("clzsi2.zig");
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__clzsi2(a: u32, expected: i32) void {9fn test__clzsi2(a: u32, expected: i32) !void {
10 // XXX At high optimization levels this test may be horribly miscompiled if10 // XXX At high optimization levels this test may be horribly miscompiled if
11 // one of the naked implementations is selected.11 // one of the naked implementations is selected.
12 var nakedClzsi2 = clzsi2.__clzsi2;12 var nakedClzsi2 = clzsi2.__clzsi2;
13 var actualClzsi2 = @ptrCast(fn (a: i32) callconv(.C) i32, nakedClzsi2);13 var actualClzsi2 = @ptrCast(fn (a: i32) callconv(.C) i32, nakedClzsi2);
14 var x = @bitCast(i32, a);14 var x = @bitCast(i32, a);
15 var result = actualClzsi2(x);15 var result = actualClzsi2(x);
16 testing.expectEqual(expected, result);16 try testing.expectEqual(expected, result);
17}17}
1818
19test "clzsi2" {19test "clzsi2" {
20 test__clzsi2(0x00800000, 8);20 try test__clzsi2(0x00800000, 8);
21 test__clzsi2(0x01000000, 7);21 try test__clzsi2(0x01000000, 7);
22 test__clzsi2(0x02000000, 6);22 try test__clzsi2(0x02000000, 6);
23 test__clzsi2(0x03000000, 6);23 try test__clzsi2(0x03000000, 6);
24 test__clzsi2(0x04000000, 5);24 try test__clzsi2(0x04000000, 5);
25 test__clzsi2(0x05000000, 5);25 try test__clzsi2(0x05000000, 5);
26 test__clzsi2(0x06000000, 5);26 try test__clzsi2(0x06000000, 5);
27 test__clzsi2(0x07000000, 5);27 try test__clzsi2(0x07000000, 5);
28 test__clzsi2(0x08000000, 4);28 try test__clzsi2(0x08000000, 4);
29 test__clzsi2(0x09000000, 4);29 try test__clzsi2(0x09000000, 4);
30 test__clzsi2(0x0A000000, 4);30 try test__clzsi2(0x0A000000, 4);
31 test__clzsi2(0x0B000000, 4);31 try test__clzsi2(0x0B000000, 4);
32 test__clzsi2(0x0C000000, 4);32 try test__clzsi2(0x0C000000, 4);
33 test__clzsi2(0x0D000000, 4);33 try test__clzsi2(0x0D000000, 4);
34 test__clzsi2(0x0E000000, 4);34 try test__clzsi2(0x0E000000, 4);
35 test__clzsi2(0x0F000000, 4);35 try test__clzsi2(0x0F000000, 4);
36 test__clzsi2(0x10000000, 3);36 try test__clzsi2(0x10000000, 3);
37 test__clzsi2(0x11000000, 3);37 try test__clzsi2(0x11000000, 3);
38 test__clzsi2(0x12000000, 3);38 try test__clzsi2(0x12000000, 3);
39 test__clzsi2(0x13000000, 3);39 try test__clzsi2(0x13000000, 3);
40 test__clzsi2(0x14000000, 3);40 try test__clzsi2(0x14000000, 3);
41 test__clzsi2(0x15000000, 3);41 try test__clzsi2(0x15000000, 3);
42 test__clzsi2(0x16000000, 3);42 try test__clzsi2(0x16000000, 3);
43 test__clzsi2(0x17000000, 3);43 try test__clzsi2(0x17000000, 3);
44 test__clzsi2(0x18000000, 3);44 try test__clzsi2(0x18000000, 3);
45 test__clzsi2(0x19000000, 3);45 try test__clzsi2(0x19000000, 3);
46 test__clzsi2(0x1A000000, 3);46 try test__clzsi2(0x1A000000, 3);
47 test__clzsi2(0x1B000000, 3);47 try test__clzsi2(0x1B000000, 3);
48 test__clzsi2(0x1C000000, 3);48 try test__clzsi2(0x1C000000, 3);
49 test__clzsi2(0x1D000000, 3);49 try test__clzsi2(0x1D000000, 3);
50 test__clzsi2(0x1E000000, 3);50 try test__clzsi2(0x1E000000, 3);
51 test__clzsi2(0x1F000000, 3);51 try test__clzsi2(0x1F000000, 3);
52 test__clzsi2(0x20000000, 2);52 try test__clzsi2(0x20000000, 2);
53 test__clzsi2(0x21000000, 2);53 try test__clzsi2(0x21000000, 2);
54 test__clzsi2(0x22000000, 2);54 try test__clzsi2(0x22000000, 2);
55 test__clzsi2(0x23000000, 2);55 try test__clzsi2(0x23000000, 2);
56 test__clzsi2(0x24000000, 2);56 try test__clzsi2(0x24000000, 2);
57 test__clzsi2(0x25000000, 2);57 try test__clzsi2(0x25000000, 2);
58 test__clzsi2(0x26000000, 2);58 try test__clzsi2(0x26000000, 2);
59 test__clzsi2(0x27000000, 2);59 try test__clzsi2(0x27000000, 2);
60 test__clzsi2(0x28000000, 2);60 try test__clzsi2(0x28000000, 2);
61 test__clzsi2(0x29000000, 2);61 try test__clzsi2(0x29000000, 2);
62 test__clzsi2(0x2A000000, 2);62 try test__clzsi2(0x2A000000, 2);
63 test__clzsi2(0x2B000000, 2);63 try test__clzsi2(0x2B000000, 2);
64 test__clzsi2(0x2C000000, 2);64 try test__clzsi2(0x2C000000, 2);
65 test__clzsi2(0x2D000000, 2);65 try test__clzsi2(0x2D000000, 2);
66 test__clzsi2(0x2E000000, 2);66 try test__clzsi2(0x2E000000, 2);
67 test__clzsi2(0x2F000000, 2);67 try test__clzsi2(0x2F000000, 2);
68 test__clzsi2(0x30000000, 2);68 try test__clzsi2(0x30000000, 2);
69 test__clzsi2(0x31000000, 2);69 try test__clzsi2(0x31000000, 2);
70 test__clzsi2(0x32000000, 2);70 try test__clzsi2(0x32000000, 2);
71 test__clzsi2(0x33000000, 2);71 try test__clzsi2(0x33000000, 2);
72 test__clzsi2(0x34000000, 2);72 try test__clzsi2(0x34000000, 2);
73 test__clzsi2(0x35000000, 2);73 try test__clzsi2(0x35000000, 2);
74 test__clzsi2(0x36000000, 2);74 try test__clzsi2(0x36000000, 2);
75 test__clzsi2(0x37000000, 2);75 try test__clzsi2(0x37000000, 2);
76 test__clzsi2(0x38000000, 2);76 try test__clzsi2(0x38000000, 2);
77 test__clzsi2(0x39000000, 2);77 try test__clzsi2(0x39000000, 2);
78 test__clzsi2(0x3A000000, 2);78 try test__clzsi2(0x3A000000, 2);
79 test__clzsi2(0x3B000000, 2);79 try test__clzsi2(0x3B000000, 2);
80 test__clzsi2(0x3C000000, 2);80 try test__clzsi2(0x3C000000, 2);
81 test__clzsi2(0x3D000000, 2);81 try test__clzsi2(0x3D000000, 2);
82 test__clzsi2(0x3E000000, 2);82 try test__clzsi2(0x3E000000, 2);
83 test__clzsi2(0x3F000000, 2);83 try test__clzsi2(0x3F000000, 2);
84 test__clzsi2(0x40000000, 1);84 try test__clzsi2(0x40000000, 1);
85 test__clzsi2(0x41000000, 1);85 try test__clzsi2(0x41000000, 1);
86 test__clzsi2(0x42000000, 1);86 try test__clzsi2(0x42000000, 1);
87 test__clzsi2(0x43000000, 1);87 try test__clzsi2(0x43000000, 1);
88 test__clzsi2(0x44000000, 1);88 try test__clzsi2(0x44000000, 1);
89 test__clzsi2(0x45000000, 1);89 try test__clzsi2(0x45000000, 1);
90 test__clzsi2(0x46000000, 1);90 try test__clzsi2(0x46000000, 1);
91 test__clzsi2(0x47000000, 1);91 try test__clzsi2(0x47000000, 1);
92 test__clzsi2(0x48000000, 1);92 try test__clzsi2(0x48000000, 1);
93 test__clzsi2(0x49000000, 1);93 try test__clzsi2(0x49000000, 1);
94 test__clzsi2(0x4A000000, 1);94 try test__clzsi2(0x4A000000, 1);
95 test__clzsi2(0x4B000000, 1);95 try test__clzsi2(0x4B000000, 1);
96 test__clzsi2(0x4C000000, 1);96 try test__clzsi2(0x4C000000, 1);
97 test__clzsi2(0x4D000000, 1);97 try test__clzsi2(0x4D000000, 1);
98 test__clzsi2(0x4E000000, 1);98 try test__clzsi2(0x4E000000, 1);
99 test__clzsi2(0x4F000000, 1);99 try test__clzsi2(0x4F000000, 1);
100 test__clzsi2(0x50000000, 1);100 try test__clzsi2(0x50000000, 1);
101 test__clzsi2(0x51000000, 1);101 try test__clzsi2(0x51000000, 1);
102 test__clzsi2(0x52000000, 1);102 try test__clzsi2(0x52000000, 1);
103 test__clzsi2(0x53000000, 1);103 try test__clzsi2(0x53000000, 1);
104 test__clzsi2(0x54000000, 1);104 try test__clzsi2(0x54000000, 1);
105 test__clzsi2(0x55000000, 1);105 try test__clzsi2(0x55000000, 1);
106 test__clzsi2(0x56000000, 1);106 try test__clzsi2(0x56000000, 1);
107 test__clzsi2(0x57000000, 1);107 try test__clzsi2(0x57000000, 1);
108 test__clzsi2(0x58000000, 1);108 try test__clzsi2(0x58000000, 1);
109 test__clzsi2(0x59000000, 1);109 try test__clzsi2(0x59000000, 1);
110 test__clzsi2(0x5A000000, 1);110 try test__clzsi2(0x5A000000, 1);
111 test__clzsi2(0x5B000000, 1);111 try test__clzsi2(0x5B000000, 1);
112 test__clzsi2(0x5C000000, 1);112 try test__clzsi2(0x5C000000, 1);
113 test__clzsi2(0x5D000000, 1);113 try test__clzsi2(0x5D000000, 1);
114 test__clzsi2(0x5E000000, 1);114 try test__clzsi2(0x5E000000, 1);
115 test__clzsi2(0x5F000000, 1);115 try test__clzsi2(0x5F000000, 1);
116 test__clzsi2(0x60000000, 1);116 try test__clzsi2(0x60000000, 1);
117 test__clzsi2(0x61000000, 1);117 try test__clzsi2(0x61000000, 1);
118 test__clzsi2(0x62000000, 1);118 try test__clzsi2(0x62000000, 1);
119 test__clzsi2(0x63000000, 1);119 try test__clzsi2(0x63000000, 1);
120 test__clzsi2(0x64000000, 1);120 try test__clzsi2(0x64000000, 1);
121 test__clzsi2(0x65000000, 1);121 try test__clzsi2(0x65000000, 1);
122 test__clzsi2(0x66000000, 1);122 try test__clzsi2(0x66000000, 1);
123 test__clzsi2(0x67000000, 1);123 try test__clzsi2(0x67000000, 1);
124 test__clzsi2(0x68000000, 1);124 try test__clzsi2(0x68000000, 1);
125 test__clzsi2(0x69000000, 1);125 try test__clzsi2(0x69000000, 1);
126 test__clzsi2(0x6A000000, 1);126 try test__clzsi2(0x6A000000, 1);
127 test__clzsi2(0x6B000000, 1);127 try test__clzsi2(0x6B000000, 1);
128 test__clzsi2(0x6C000000, 1);128 try test__clzsi2(0x6C000000, 1);
129 test__clzsi2(0x6D000000, 1);129 try test__clzsi2(0x6D000000, 1);
130 test__clzsi2(0x6E000000, 1);130 try test__clzsi2(0x6E000000, 1);
131 test__clzsi2(0x6F000000, 1);131 try test__clzsi2(0x6F000000, 1);
132 test__clzsi2(0x70000000, 1);132 try test__clzsi2(0x70000000, 1);
133 test__clzsi2(0x71000000, 1);133 try test__clzsi2(0x71000000, 1);
134 test__clzsi2(0x72000000, 1);134 try test__clzsi2(0x72000000, 1);
135 test__clzsi2(0x73000000, 1);135 try test__clzsi2(0x73000000, 1);
136 test__clzsi2(0x74000000, 1);136 try test__clzsi2(0x74000000, 1);
137 test__clzsi2(0x75000000, 1);137 try test__clzsi2(0x75000000, 1);
138 test__clzsi2(0x76000000, 1);138 try test__clzsi2(0x76000000, 1);
139 test__clzsi2(0x77000000, 1);139 try test__clzsi2(0x77000000, 1);
140 test__clzsi2(0x78000000, 1);140 try test__clzsi2(0x78000000, 1);
141 test__clzsi2(0x79000000, 1);141 try test__clzsi2(0x79000000, 1);
142 test__clzsi2(0x7A000000, 1);142 try test__clzsi2(0x7A000000, 1);
143 test__clzsi2(0x7B000000, 1);143 try test__clzsi2(0x7B000000, 1);
144 test__clzsi2(0x7C000000, 1);144 try test__clzsi2(0x7C000000, 1);
145 test__clzsi2(0x7D000000, 1);145 try test__clzsi2(0x7D000000, 1);
146 test__clzsi2(0x7E000000, 1);146 try test__clzsi2(0x7E000000, 1);
147 test__clzsi2(0x7F000000, 1);147 try test__clzsi2(0x7F000000, 1);
148 test__clzsi2(0x80000000, 0);148 try test__clzsi2(0x80000000, 0);
149 test__clzsi2(0x81000000, 0);149 try test__clzsi2(0x81000000, 0);
150 test__clzsi2(0x82000000, 0);150 try test__clzsi2(0x82000000, 0);
151 test__clzsi2(0x83000000, 0);151 try test__clzsi2(0x83000000, 0);
152 test__clzsi2(0x84000000, 0);152 try test__clzsi2(0x84000000, 0);
153 test__clzsi2(0x85000000, 0);153 try test__clzsi2(0x85000000, 0);
154 test__clzsi2(0x86000000, 0);154 try test__clzsi2(0x86000000, 0);
155 test__clzsi2(0x87000000, 0);155 try test__clzsi2(0x87000000, 0);
156 test__clzsi2(0x88000000, 0);156 try test__clzsi2(0x88000000, 0);
157 test__clzsi2(0x89000000, 0);157 try test__clzsi2(0x89000000, 0);
158 test__clzsi2(0x8A000000, 0);158 try test__clzsi2(0x8A000000, 0);
159 test__clzsi2(0x8B000000, 0);159 try test__clzsi2(0x8B000000, 0);
160 test__clzsi2(0x8C000000, 0);160 try test__clzsi2(0x8C000000, 0);
161 test__clzsi2(0x8D000000, 0);161 try test__clzsi2(0x8D000000, 0);
162 test__clzsi2(0x8E000000, 0);162 try test__clzsi2(0x8E000000, 0);
163 test__clzsi2(0x8F000000, 0);163 try test__clzsi2(0x8F000000, 0);
164 test__clzsi2(0x90000000, 0);164 try test__clzsi2(0x90000000, 0);
165 test__clzsi2(0x91000000, 0);165 try test__clzsi2(0x91000000, 0);
166 test__clzsi2(0x92000000, 0);166 try test__clzsi2(0x92000000, 0);
167 test__clzsi2(0x93000000, 0);167 try test__clzsi2(0x93000000, 0);
168 test__clzsi2(0x94000000, 0);168 try test__clzsi2(0x94000000, 0);
169 test__clzsi2(0x95000000, 0);169 try test__clzsi2(0x95000000, 0);
170 test__clzsi2(0x96000000, 0);170 try test__clzsi2(0x96000000, 0);
171 test__clzsi2(0x97000000, 0);171 try test__clzsi2(0x97000000, 0);
172 test__clzsi2(0x98000000, 0);172 try test__clzsi2(0x98000000, 0);
173 test__clzsi2(0x99000000, 0);173 try test__clzsi2(0x99000000, 0);
174 test__clzsi2(0x9A000000, 0);174 try test__clzsi2(0x9A000000, 0);
175 test__clzsi2(0x9B000000, 0);175 try test__clzsi2(0x9B000000, 0);
176 test__clzsi2(0x9C000000, 0);176 try test__clzsi2(0x9C000000, 0);
177 test__clzsi2(0x9D000000, 0);177 try test__clzsi2(0x9D000000, 0);
178 test__clzsi2(0x9E000000, 0);178 try test__clzsi2(0x9E000000, 0);
179 test__clzsi2(0x9F000000, 0);179 try test__clzsi2(0x9F000000, 0);
180 test__clzsi2(0xA0000000, 0);180 try test__clzsi2(0xA0000000, 0);
181 test__clzsi2(0xA1000000, 0);181 try test__clzsi2(0xA1000000, 0);
182 test__clzsi2(0xA2000000, 0);182 try test__clzsi2(0xA2000000, 0);
183 test__clzsi2(0xA3000000, 0);183 try test__clzsi2(0xA3000000, 0);
184 test__clzsi2(0xA4000000, 0);184 try test__clzsi2(0xA4000000, 0);
185 test__clzsi2(0xA5000000, 0);185 try test__clzsi2(0xA5000000, 0);
186 test__clzsi2(0xA6000000, 0);186 try test__clzsi2(0xA6000000, 0);
187 test__clzsi2(0xA7000000, 0);187 try test__clzsi2(0xA7000000, 0);
188 test__clzsi2(0xA8000000, 0);188 try test__clzsi2(0xA8000000, 0);
189 test__clzsi2(0xA9000000, 0);189 try test__clzsi2(0xA9000000, 0);
190 test__clzsi2(0xAA000000, 0);190 try test__clzsi2(0xAA000000, 0);
191 test__clzsi2(0xAB000000, 0);191 try test__clzsi2(0xAB000000, 0);
192 test__clzsi2(0xAC000000, 0);192 try test__clzsi2(0xAC000000, 0);
193 test__clzsi2(0xAD000000, 0);193 try test__clzsi2(0xAD000000, 0);
194 test__clzsi2(0xAE000000, 0);194 try test__clzsi2(0xAE000000, 0);
195 test__clzsi2(0xAF000000, 0);195 try test__clzsi2(0xAF000000, 0);
196 test__clzsi2(0xB0000000, 0);196 try test__clzsi2(0xB0000000, 0);
197 test__clzsi2(0xB1000000, 0);197 try test__clzsi2(0xB1000000, 0);
198 test__clzsi2(0xB2000000, 0);198 try test__clzsi2(0xB2000000, 0);
199 test__clzsi2(0xB3000000, 0);199 try test__clzsi2(0xB3000000, 0);
200 test__clzsi2(0xB4000000, 0);200 try test__clzsi2(0xB4000000, 0);
201 test__clzsi2(0xB5000000, 0);201 try test__clzsi2(0xB5000000, 0);
202 test__clzsi2(0xB6000000, 0);202 try test__clzsi2(0xB6000000, 0);
203 test__clzsi2(0xB7000000, 0);203 try test__clzsi2(0xB7000000, 0);
204 test__clzsi2(0xB8000000, 0);204 try test__clzsi2(0xB8000000, 0);
205 test__clzsi2(0xB9000000, 0);205 try test__clzsi2(0xB9000000, 0);
206 test__clzsi2(0xBA000000, 0);206 try test__clzsi2(0xBA000000, 0);
207 test__clzsi2(0xBB000000, 0);207 try test__clzsi2(0xBB000000, 0);
208 test__clzsi2(0xBC000000, 0);208 try test__clzsi2(0xBC000000, 0);
209 test__clzsi2(0xBD000000, 0);209 try test__clzsi2(0xBD000000, 0);
210 test__clzsi2(0xBE000000, 0);210 try test__clzsi2(0xBE000000, 0);
211 test__clzsi2(0xBF000000, 0);211 try test__clzsi2(0xBF000000, 0);
212 test__clzsi2(0xC0000000, 0);212 try test__clzsi2(0xC0000000, 0);
213 test__clzsi2(0xC1000000, 0);213 try test__clzsi2(0xC1000000, 0);
214 test__clzsi2(0xC2000000, 0);214 try test__clzsi2(0xC2000000, 0);
215 test__clzsi2(0xC3000000, 0);215 try test__clzsi2(0xC3000000, 0);
216 test__clzsi2(0xC4000000, 0);216 try test__clzsi2(0xC4000000, 0);
217 test__clzsi2(0xC5000000, 0);217 try test__clzsi2(0xC5000000, 0);
218 test__clzsi2(0xC6000000, 0);218 try test__clzsi2(0xC6000000, 0);
219 test__clzsi2(0xC7000000, 0);219 try test__clzsi2(0xC7000000, 0);
220 test__clzsi2(0xC8000000, 0);220 try test__clzsi2(0xC8000000, 0);
221 test__clzsi2(0xC9000000, 0);221 try test__clzsi2(0xC9000000, 0);
222 test__clzsi2(0xCA000000, 0);222 try test__clzsi2(0xCA000000, 0);
223 test__clzsi2(0xCB000000, 0);223 try test__clzsi2(0xCB000000, 0);
224 test__clzsi2(0xCC000000, 0);224 try test__clzsi2(0xCC000000, 0);
225 test__clzsi2(0xCD000000, 0);225 try test__clzsi2(0xCD000000, 0);
226 test__clzsi2(0xCE000000, 0);226 try test__clzsi2(0xCE000000, 0);
227 test__clzsi2(0xCF000000, 0);227 try test__clzsi2(0xCF000000, 0);
228 test__clzsi2(0xD0000000, 0);228 try test__clzsi2(0xD0000000, 0);
229 test__clzsi2(0xD1000000, 0);229 try test__clzsi2(0xD1000000, 0);
230 test__clzsi2(0xD2000000, 0);230 try test__clzsi2(0xD2000000, 0);
231 test__clzsi2(0xD3000000, 0);231 try test__clzsi2(0xD3000000, 0);
232 test__clzsi2(0xD4000000, 0);232 try test__clzsi2(0xD4000000, 0);
233 test__clzsi2(0xD5000000, 0);233 try test__clzsi2(0xD5000000, 0);
234 test__clzsi2(0xD6000000, 0);234 try test__clzsi2(0xD6000000, 0);
235 test__clzsi2(0xD7000000, 0);235 try test__clzsi2(0xD7000000, 0);
236 test__clzsi2(0xD8000000, 0);236 try test__clzsi2(0xD8000000, 0);
237 test__clzsi2(0xD9000000, 0);237 try test__clzsi2(0xD9000000, 0);
238 test__clzsi2(0xDA000000, 0);238 try test__clzsi2(0xDA000000, 0);
239 test__clzsi2(0xDB000000, 0);239 try test__clzsi2(0xDB000000, 0);
240 test__clzsi2(0xDC000000, 0);240 try test__clzsi2(0xDC000000, 0);
241 test__clzsi2(0xDD000000, 0);241 try test__clzsi2(0xDD000000, 0);
242 test__clzsi2(0xDE000000, 0);242 try test__clzsi2(0xDE000000, 0);
243 test__clzsi2(0xDF000000, 0);243 try test__clzsi2(0xDF000000, 0);
244 test__clzsi2(0xE0000000, 0);244 try test__clzsi2(0xE0000000, 0);
245 test__clzsi2(0xE1000000, 0);245 try test__clzsi2(0xE1000000, 0);
246 test__clzsi2(0xE2000000, 0);246 try test__clzsi2(0xE2000000, 0);
247 test__clzsi2(0xE3000000, 0);247 try test__clzsi2(0xE3000000, 0);
248 test__clzsi2(0xE4000000, 0);248 try test__clzsi2(0xE4000000, 0);
249 test__clzsi2(0xE5000000, 0);249 try test__clzsi2(0xE5000000, 0);
250 test__clzsi2(0xE6000000, 0);250 try test__clzsi2(0xE6000000, 0);
251 test__clzsi2(0xE7000000, 0);251 try test__clzsi2(0xE7000000, 0);
252 test__clzsi2(0xE8000000, 0);252 try test__clzsi2(0xE8000000, 0);
253 test__clzsi2(0xE9000000, 0);253 try test__clzsi2(0xE9000000, 0);
254 test__clzsi2(0xEA000000, 0);254 try test__clzsi2(0xEA000000, 0);
255 test__clzsi2(0xEB000000, 0);255 try test__clzsi2(0xEB000000, 0);
256 test__clzsi2(0xEC000000, 0);256 try test__clzsi2(0xEC000000, 0);
257 test__clzsi2(0xED000000, 0);257 try test__clzsi2(0xED000000, 0);
258 test__clzsi2(0xEE000000, 0);258 try test__clzsi2(0xEE000000, 0);
259 test__clzsi2(0xEF000000, 0);259 try test__clzsi2(0xEF000000, 0);
260 test__clzsi2(0xF0000000, 0);260 try test__clzsi2(0xF0000000, 0);
261 test__clzsi2(0xF1000000, 0);261 try test__clzsi2(0xF1000000, 0);
262 test__clzsi2(0xF2000000, 0);262 try test__clzsi2(0xF2000000, 0);
263 test__clzsi2(0xF3000000, 0);263 try test__clzsi2(0xF3000000, 0);
264 test__clzsi2(0xF4000000, 0);264 try test__clzsi2(0xF4000000, 0);
265 test__clzsi2(0xF5000000, 0);265 try test__clzsi2(0xF5000000, 0);
266 test__clzsi2(0xF6000000, 0);266 try test__clzsi2(0xF6000000, 0);
267 test__clzsi2(0xF7000000, 0);267 try test__clzsi2(0xF7000000, 0);
268 test__clzsi2(0xF8000000, 0);268 try test__clzsi2(0xF8000000, 0);
269 test__clzsi2(0xF9000000, 0);269 try test__clzsi2(0xF9000000, 0);
270 test__clzsi2(0xFA000000, 0);270 try test__clzsi2(0xFA000000, 0);
271 test__clzsi2(0xFB000000, 0);271 try test__clzsi2(0xFB000000, 0);
272 test__clzsi2(0xFC000000, 0);272 try test__clzsi2(0xFC000000, 0);
273 test__clzsi2(0xFD000000, 0);273 try test__clzsi2(0xFD000000, 0);
274 test__clzsi2(0xFE000000, 0);274 try test__clzsi2(0xFE000000, 0);
275 test__clzsi2(0xFF000000, 0);275 try test__clzsi2(0xFF000000, 0);
276 test__clzsi2(0x00000001, 31);276 try test__clzsi2(0x00000001, 31);
277 test__clzsi2(0x00000002, 30);277 try test__clzsi2(0x00000002, 30);
278 test__clzsi2(0x00000004, 29);278 try test__clzsi2(0x00000004, 29);
279 test__clzsi2(0x00000008, 28);279 try test__clzsi2(0x00000008, 28);
280 test__clzsi2(0x00000010, 27);280 try test__clzsi2(0x00000010, 27);
281 test__clzsi2(0x00000020, 26);281 try test__clzsi2(0x00000020, 26);
282 test__clzsi2(0x00000040, 25);282 try test__clzsi2(0x00000040, 25);
283 test__clzsi2(0x00000080, 24);283 try test__clzsi2(0x00000080, 24);
284 test__clzsi2(0x00000100, 23);284 try test__clzsi2(0x00000100, 23);
285 test__clzsi2(0x00000200, 22);285 try test__clzsi2(0x00000200, 22);
286 test__clzsi2(0x00000400, 21);286 try test__clzsi2(0x00000400, 21);
287 test__clzsi2(0x00000800, 20);287 try test__clzsi2(0x00000800, 20);
288 test__clzsi2(0x00001000, 19);288 try test__clzsi2(0x00001000, 19);
289 test__clzsi2(0x00002000, 18);289 try test__clzsi2(0x00002000, 18);
290 test__clzsi2(0x00004000, 17);290 try test__clzsi2(0x00004000, 17);
291 test__clzsi2(0x00008000, 16);291 try test__clzsi2(0x00008000, 16);
292 test__clzsi2(0x00010000, 15);292 try test__clzsi2(0x00010000, 15);
293 test__clzsi2(0x00020000, 14);293 try test__clzsi2(0x00020000, 14);
294 test__clzsi2(0x00040000, 13);294 try test__clzsi2(0x00040000, 13);
295 test__clzsi2(0x00080000, 12);295 try test__clzsi2(0x00080000, 12);
296 test__clzsi2(0x00100000, 11);296 try test__clzsi2(0x00100000, 11);
297 test__clzsi2(0x00200000, 10);297 try test__clzsi2(0x00200000, 10);
298 test__clzsi2(0x00400000, 9);298 try test__clzsi2(0x00400000, 9);
299}299}
lib/std/special/compiler_rt/divdf3_test.zig+3-3
...@@ -27,13 +27,13 @@ fn compareResultD(result: f64, expected: u64) bool {...@@ -27,13 +27,13 @@ fn compareResultD(result: f64, expected: u64) bool {
27 return false;27 return false;
28}28}
2929
30fn test__divdf3(a: f64, b: f64, expected: u64) void {30fn test__divdf3(a: f64, b: f64, expected: u64) !void {
31 const x = __divdf3(a, b);31 const x = __divdf3(a, b);
32 const ret = compareResultD(x, expected);32 const ret = compareResultD(x, expected);
33 try testing.expect(ret == true);33 try testing.expect(ret == true);
34}34}
3535
36test "divdf3" {36test "divdf3" {
37 test__divdf3(1.0, 3.0, 0x3fd5555555555555);37 try test__divdf3(1.0, 3.0, 0x3fd5555555555555);
38 test__divdf3(4.450147717014403e-308, 2.0, 0x10000000000000);38 try test__divdf3(4.450147717014403e-308, 2.0, 0x10000000000000);
39}39}
lib/std/special/compiler_rt/divsf3_test.zig+3-3
...@@ -27,13 +27,13 @@ fn compareResultF(result: f32, expected: u32) bool {...@@ -27,13 +27,13 @@ fn compareResultF(result: f32, expected: u32) bool {
27 return false;27 return false;
28}28}
2929
30fn test__divsf3(a: f32, b: f32, expected: u32) void {30fn test__divsf3(a: f32, b: f32, expected: u32) !void {
31 const x = __divsf3(a, b);31 const x = __divsf3(a, b);
32 const ret = compareResultF(x, expected);32 const ret = compareResultF(x, expected);
33 try testing.expect(ret == true);33 try testing.expect(ret == true);
34}34}
3535
36test "divsf3" {36test "divsf3" {
37 test__divsf3(1.0, 3.0, 0x3EAAAAAB);37 try test__divsf3(1.0, 3.0, 0x3EAAAAAB);
38 test__divsf3(2.3509887e-38, 2.0, 0x00800000);38 try test__divsf3(2.3509887e-38, 2.0, 0x00800000);
39}39}
lib/std/special/compiler_rt/divtf3_test.zig+10-10
...@@ -28,7 +28,7 @@ fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool {...@@ -28,7 +28,7 @@ fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool {
28 return false;28 return false;
29}29}
3030
31fn test__divtf3(a: f128, b: f128, expectedHi: u64, expectedLo: u64) void {31fn test__divtf3(a: f128, b: f128, expectedHi: u64, expectedLo: u64) !void {
32 const x = __divtf3(a, b);32 const x = __divtf3(a, b);
33 const ret = compareResultLD(x, expectedHi, expectedLo);33 const ret = compareResultLD(x, expectedHi, expectedLo);
34 try testing.expect(ret == true);34 try testing.expect(ret == true);
...@@ -36,16 +36,16 @@ fn test__divtf3(a: f128, b: f128, expectedHi: u64, expectedLo: u64) void {...@@ -36,16 +36,16 @@ fn test__divtf3(a: f128, b: f128, expectedHi: u64, expectedLo: u64) void {
3636
37test "divtf3" {37test "divtf3" {
38 // qNaN / any = qNaN38 // qNaN / any = qNaN
39 test__divtf3(math.qnan_f128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0);39 try test__divtf3(math.qnan_f128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0);
40 // NaN / any = NaN40 // NaN / any = NaN
41 test__divtf3(math.nan_f128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0);41 try test__divtf3(math.nan_f128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0);
42 // inf / any = inf42 // inf / any = inf
43 test__divtf3(math.inf_f128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0);43 try test__divtf3(math.inf_f128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0);
4444
45 test__divtf3(0x1.a23b45362464523375893ab4cdefp+5, 0x1.eedcbaba3a94546558237654321fp-1, 0x4004b0b72924d407, 0x0717e84356c6eba2);45 try test__divtf3(0x1.a23b45362464523375893ab4cdefp+5, 0x1.eedcbaba3a94546558237654321fp-1, 0x4004b0b72924d407, 0x0717e84356c6eba2);
46 test__divtf3(0x1.a2b34c56d745382f9abf2c3dfeffp-50, 0x1.ed2c3ba15935332532287654321fp-9, 0x3fd5b2af3f828c9b, 0x40e51f64cde8b1f2);46 try test__divtf3(0x1.a2b34c56d745382f9abf2c3dfeffp-50, 0x1.ed2c3ba15935332532287654321fp-9, 0x3fd5b2af3f828c9b, 0x40e51f64cde8b1f2);
47 test__divtf3(0x1.2345f6aaaa786555f42432abcdefp+456, 0x1.edacbba9874f765463544dd3621fp+6400, 0x28c62e15dc464466, 0xb5a07586348557ac);47 try test__divtf3(0x1.2345f6aaaa786555f42432abcdefp+456, 0x1.edacbba9874f765463544dd3621fp+6400, 0x28c62e15dc464466, 0xb5a07586348557ac);
48 test__divtf3(0x1.2d3456f789ba6322bc665544edefp-234, 0x1.eddcdba39f3c8b7a36564354321fp-4455, 0x507b38442b539266, 0x22ce0f1d024e1252);48 try test__divtf3(0x1.2d3456f789ba6322bc665544edefp-234, 0x1.eddcdba39f3c8b7a36564354321fp-4455, 0x507b38442b539266, 0x22ce0f1d024e1252);
49 test__divtf3(0x1.2345f6b77b7a8953365433abcdefp+234, 0x1.edcba987d6bb3aa467754354321fp-4055, 0x50bf2e02f0798d36, 0x5e6fcb6b60044078);49 try test__divtf3(0x1.2345f6b77b7a8953365433abcdefp+234, 0x1.edcba987d6bb3aa467754354321fp-4055, 0x50bf2e02f0798d36, 0x5e6fcb6b60044078);
50 test__divtf3(6.72420628622418701252535563464350521E-4932, 2.0, 0x0001000000000000, 0);50 try test__divtf3(6.72420628622418701252535563464350521E-4932, 2.0, 0x0001000000000000, 0);
51}51}
lib/std/special/compiler_rt/divti3_test.zig+11-11
...@@ -6,21 +6,21 @@...@@ -6,21 +6,21 @@
6const __divti3 = @import("divti3.zig").__divti3;6const __divti3 = @import("divti3.zig").__divti3;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__divti3(a: i128, b: i128, expected: i128) void {9fn test__divti3(a: i128, b: i128, expected: i128) !void {
10 const x = __divti3(a, b);10 const x = __divti3(a, b);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "divti3" {14test "divti3" {
15 test__divti3(0, 1, 0);15 try test__divti3(0, 1, 0);
16 test__divti3(0, -1, 0);16 try test__divti3(0, -1, 0);
17 test__divti3(2, 1, 2);17 try test__divti3(2, 1, 2);
18 test__divti3(2, -1, -2);18 try test__divti3(2, -1, -2);
19 test__divti3(-2, 1, -2);19 try test__divti3(-2, 1, -2);
20 test__divti3(-2, -1, 2);20 try test__divti3(-2, -1, 2);
2121
22 test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 1, @bitCast(i128, @as(u128, 0x8 << 124)));22 try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 1, @bitCast(i128, @as(u128, 0x8 << 124)));
23 test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -1, @bitCast(i128, @as(u128, 0x8 << 124)));23 try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -1, @bitCast(i128, @as(u128, 0x8 << 124)));
24 test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -2, @bitCast(i128, @as(u128, 0x4 << 124)));24 try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -2, @bitCast(i128, @as(u128, 0x4 << 124)));
25 test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 2, @bitCast(i128, @as(u128, 0xc << 124)));25 try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 2, @bitCast(i128, @as(u128, 0xc << 124)));
26}26}
lib/std/special/compiler_rt/extendXfYf2_test.zig+55-55
...@@ -9,7 +9,7 @@ const __extendhftf2 = @import("extendXfYf2.zig").__extendhftf2;...@@ -9,7 +9,7 @@ const __extendhftf2 = @import("extendXfYf2.zig").__extendhftf2;
9const __extendsftf2 = @import("extendXfYf2.zig").__extendsftf2;9const __extendsftf2 = @import("extendXfYf2.zig").__extendsftf2;
10const __extenddftf2 = @import("extendXfYf2.zig").__extenddftf2;10const __extenddftf2 = @import("extendXfYf2.zig").__extenddftf2;
1111
12fn test__extenddftf2(a: f64, expectedHi: u64, expectedLo: u64) void {12fn test__extenddftf2(a: f64, expectedHi: u64, expectedLo: u64) !void {
13 const x = __extenddftf2(a);13 const x = __extenddftf2(a);
1414
15 const rep = @bitCast(u128, x);15 const rep = @bitCast(u128, x);
...@@ -31,7 +31,7 @@ fn test__extenddftf2(a: f64, expectedHi: u64, expectedLo: u64) void {...@@ -31,7 +31,7 @@ fn test__extenddftf2(a: f64, expectedHi: u64, expectedLo: u64) void {
31 @panic("__extenddftf2 test failure");31 @panic("__extenddftf2 test failure");
32}32}
3333
34fn test__extendhfsf2(a: u16, expected: u32) void {34fn test__extendhfsf2(a: u16, expected: u32) !void {
35 const x = __extendhfsf2(a);35 const x = __extendhfsf2(a);
36 const rep = @bitCast(u32, x);36 const rep = @bitCast(u32, x);
3737
...@@ -44,10 +44,10 @@ fn test__extendhfsf2(a: u16, expected: u32) void {...@@ -44,10 +44,10 @@ fn test__extendhfsf2(a: u16, expected: u32) void {
44 }44 }
45 }45 }
4646
47 @panic("__extendhfsf2 test failure");47 return error.TestFailure;
48}48}
4949
50fn test__extendsftf2(a: f32, expectedHi: u64, expectedLo: u64) void {50fn test__extendsftf2(a: f32, expectedHi: u64, expectedLo: u64) !void {
51 const x = __extendsftf2(a);51 const x = __extendsftf2(a);
5252
53 const rep = @bitCast(u128, x);53 const rep = @bitCast(u128, x);
...@@ -66,77 +66,77 @@ fn test__extendsftf2(a: f32, expectedHi: u64, expectedLo: u64) void {...@@ -66,77 +66,77 @@ fn test__extendsftf2(a: f32, expectedHi: u64, expectedLo: u64) void {
66 }66 }
67 }67 }
6868
69 @panic("__extendsftf2 test failure");69 return error.TestFailure;
70}70}
7171
72test "extenddftf2" {72test "extenddftf2" {
73 // qNaN73 // qNaN
74 test__extenddftf2(makeQNaN64(), 0x7fff800000000000, 0x0);74 try test__extenddftf2(makeQNaN64(), 0x7fff800000000000, 0x0);
7575
76 // NaN76 // NaN
77 test__extenddftf2(makeNaN64(0x7100000000000), 0x7fff710000000000, 0x0);77 try test__extenddftf2(makeNaN64(0x7100000000000), 0x7fff710000000000, 0x0);
7878
79 // inf79 // inf
80 test__extenddftf2(makeInf64(), 0x7fff000000000000, 0x0);80 try test__extenddftf2(makeInf64(), 0x7fff000000000000, 0x0);
8181
82 // zero82 // zero
83 test__extenddftf2(0.0, 0x0, 0x0);83 try test__extenddftf2(0.0, 0x0, 0x0);
8484
85 test__extenddftf2(0x1.23456789abcdefp+5, 0x400423456789abcd, 0xf000000000000000);85 try test__extenddftf2(0x1.23456789abcdefp+5, 0x400423456789abcd, 0xf000000000000000);
8686
87 test__extenddftf2(0x1.edcba987654321fp-9, 0x3ff6edcba9876543, 0x2000000000000000);87 try test__extenddftf2(0x1.edcba987654321fp-9, 0x3ff6edcba9876543, 0x2000000000000000);
8888
89 test__extenddftf2(0x1.23456789abcdefp+45, 0x402c23456789abcd, 0xf000000000000000);89 try test__extenddftf2(0x1.23456789abcdefp+45, 0x402c23456789abcd, 0xf000000000000000);
9090
91 test__extenddftf2(0x1.edcba987654321fp-45, 0x3fd2edcba9876543, 0x2000000000000000);91 try test__extenddftf2(0x1.edcba987654321fp-45, 0x3fd2edcba9876543, 0x2000000000000000);
92}92}
9393
94test "extendhfsf2" {94test "extendhfsf2" {
95 test__extendhfsf2(0x7e00, 0x7fc00000); // qNaN95 try test__extendhfsf2(0x7e00, 0x7fc00000); // qNaN
96 test__extendhfsf2(0x7f00, 0x7fe00000); // sNaN96 try test__extendhfsf2(0x7f00, 0x7fe00000); // sNaN
97 // On x86 the NaN becomes quiet because the return is pushed on the x8797 // On x86 the NaN becomes quiet because the return is pushed on the x87
98 // stack due to ABI requirements98 // stack due to ABI requirements
99 if (builtin.arch != .i386 and builtin.os.tag == .windows)99 if (builtin.arch != .i386 and builtin.os.tag == .windows)
100 test__extendhfsf2(0x7c01, 0x7f802000); // sNaN100 try test__extendhfsf2(0x7c01, 0x7f802000); // sNaN
101101
102 test__extendhfsf2(0, 0); // 0102 try test__extendhfsf2(0, 0); // 0
103 test__extendhfsf2(0x8000, 0x80000000); // -0103 try test__extendhfsf2(0x8000, 0x80000000); // -0
104104
105 test__extendhfsf2(0x7c00, 0x7f800000); // inf105 try test__extendhfsf2(0x7c00, 0x7f800000); // inf
106 test__extendhfsf2(0xfc00, 0xff800000); // -inf106 try test__extendhfsf2(0xfc00, 0xff800000); // -inf
107107
108 test__extendhfsf2(0x0001, 0x33800000); // denormal (min), 2**-24108 try test__extendhfsf2(0x0001, 0x33800000); // denormal (min), 2**-24
109 test__extendhfsf2(0x8001, 0xb3800000); // denormal (min), -2**-24109 try test__extendhfsf2(0x8001, 0xb3800000); // denormal (min), -2**-24
110110
111 test__extendhfsf2(0x03ff, 0x387fc000); // denormal (max), 2**-14 - 2**-24111 try test__extendhfsf2(0x03ff, 0x387fc000); // denormal (max), 2**-14 - 2**-24
112 test__extendhfsf2(0x83ff, 0xb87fc000); // denormal (max), -2**-14 + 2**-24112 try test__extendhfsf2(0x83ff, 0xb87fc000); // denormal (max), -2**-14 + 2**-24
113113
114 test__extendhfsf2(0x0400, 0x38800000); // normal (min), 2**-14114 try test__extendhfsf2(0x0400, 0x38800000); // normal (min), 2**-14
115 test__extendhfsf2(0x8400, 0xb8800000); // normal (min), -2**-14115 try test__extendhfsf2(0x8400, 0xb8800000); // normal (min), -2**-14
116116
117 test__extendhfsf2(0x7bff, 0x477fe000); // normal (max), 65504117 try test__extendhfsf2(0x7bff, 0x477fe000); // normal (max), 65504
118 test__extendhfsf2(0xfbff, 0xc77fe000); // normal (max), -65504118 try test__extendhfsf2(0xfbff, 0xc77fe000); // normal (max), -65504
119119
120 test__extendhfsf2(0x3c01, 0x3f802000); // normal, 1 + 2**-10120 try test__extendhfsf2(0x3c01, 0x3f802000); // normal, 1 + 2**-10
121 test__extendhfsf2(0xbc01, 0xbf802000); // normal, -1 - 2**-10121 try test__extendhfsf2(0xbc01, 0xbf802000); // normal, -1 - 2**-10
122122
123 test__extendhfsf2(0x3555, 0x3eaaa000); // normal, approx. 1/3123 try test__extendhfsf2(0x3555, 0x3eaaa000); // normal, approx. 1/3
124 test__extendhfsf2(0xb555, 0xbeaaa000); // normal, approx. -1/3124 try test__extendhfsf2(0xb555, 0xbeaaa000); // normal, approx. -1/3
125}125}
126126
127test "extendsftf2" {127test "extendsftf2" {
128 // qNaN128 // qNaN
129 test__extendsftf2(makeQNaN32(), 0x7fff800000000000, 0x0);129 try test__extendsftf2(makeQNaN32(), 0x7fff800000000000, 0x0);
130 // NaN130 // NaN
131 test__extendsftf2(makeNaN32(0x410000), 0x7fff820000000000, 0x0);131 try test__extendsftf2(makeNaN32(0x410000), 0x7fff820000000000, 0x0);
132 // inf132 // inf
133 test__extendsftf2(makeInf32(), 0x7fff000000000000, 0x0);133 try test__extendsftf2(makeInf32(), 0x7fff000000000000, 0x0);
134 // zero134 // zero
135 test__extendsftf2(0.0, 0x0, 0x0);135 try test__extendsftf2(0.0, 0x0, 0x0);
136 test__extendsftf2(0x1.23456p+5, 0x4004234560000000, 0x0);136 try test__extendsftf2(0x1.23456p+5, 0x4004234560000000, 0x0);
137 test__extendsftf2(0x1.edcbap-9, 0x3ff6edcba0000000, 0x0);137 try test__extendsftf2(0x1.edcbap-9, 0x3ff6edcba0000000, 0x0);
138 test__extendsftf2(0x1.23456p+45, 0x402c234560000000, 0x0);138 try test__extendsftf2(0x1.23456p+45, 0x402c234560000000, 0x0);
139 test__extendsftf2(0x1.edcbap-45, 0x3fd2edcba0000000, 0x0);139 try test__extendsftf2(0x1.edcbap-45, 0x3fd2edcba0000000, 0x0);
140}140}
141141
142fn makeQNaN64() f64 {142fn makeQNaN64() f64 {
...@@ -163,7 +163,7 @@ fn makeInf32() f32 {...@@ -163,7 +163,7 @@ fn makeInf32() f32 {
163 return @bitCast(f32, @as(u32, 0x7f800000));163 return @bitCast(f32, @as(u32, 0x7f800000));
164}164}
165165
166fn test__extendhftf2(a: u16, expectedHi: u64, expectedLo: u64) void {166fn test__extendhftf2(a: u16, expectedHi: u64, expectedLo: u64) !void {
167 const x = __extendhftf2(a);167 const x = __extendhftf2(a);
168168
169 const rep = @bitCast(u128, x);169 const rep = @bitCast(u128, x);
...@@ -182,29 +182,29 @@ fn test__extendhftf2(a: u16, expectedHi: u64, expectedLo: u64) void {...@@ -182,29 +182,29 @@ fn test__extendhftf2(a: u16, expectedHi: u64, expectedLo: u64) void {
182 }182 }
183 }183 }
184184
185 @panic("__extendhftf2 test failure");185 return error.TestFailure;
186}186}
187187
188test "extendhftf2" {188test "extendhftf2" {
189 // qNaN189 // qNaN
190 test__extendhftf2(0x7e00, 0x7fff800000000000, 0x0);190 try test__extendhftf2(0x7e00, 0x7fff800000000000, 0x0);
191 // NaN191 // NaN
192 test__extendhftf2(0x7d00, 0x7fff400000000000, 0x0);192 try test__extendhftf2(0x7d00, 0x7fff400000000000, 0x0);
193 // inf193 // inf
194 test__extendhftf2(0x7c00, 0x7fff000000000000, 0x0);194 try test__extendhftf2(0x7c00, 0x7fff000000000000, 0x0);
195 test__extendhftf2(0xfc00, 0xffff000000000000, 0x0);195 try test__extendhftf2(0xfc00, 0xffff000000000000, 0x0);
196 // zero196 // zero
197 test__extendhftf2(0x0000, 0x0000000000000000, 0x0);197 try test__extendhftf2(0x0000, 0x0000000000000000, 0x0);
198 test__extendhftf2(0x8000, 0x8000000000000000, 0x0);198 try test__extendhftf2(0x8000, 0x8000000000000000, 0x0);
199 // denormal199 // denormal
200 test__extendhftf2(0x0010, 0x3feb000000000000, 0x0);200 try test__extendhftf2(0x0010, 0x3feb000000000000, 0x0);
201 test__extendhftf2(0x0001, 0x3fe7000000000000, 0x0);201 try test__extendhftf2(0x0001, 0x3fe7000000000000, 0x0);
202 test__extendhftf2(0x8001, 0xbfe7000000000000, 0x0);202 try test__extendhftf2(0x8001, 0xbfe7000000000000, 0x0);
203203
204 // pi204 // pi
205 test__extendhftf2(0x4248, 0x4000920000000000, 0x0);205 try test__extendhftf2(0x4248, 0x4000920000000000, 0x0);
206 test__extendhftf2(0xc248, 0xc000920000000000, 0x0);206 try test__extendhftf2(0xc248, 0xc000920000000000, 0x0);
207207
208 test__extendhftf2(0x508c, 0x4004230000000000, 0x0);208 try test__extendhftf2(0x508c, 0x4004230000000000, 0x0);
209 test__extendhftf2(0x1bb7, 0x3ff6edc000000000, 0x0);209 try test__extendhftf2(0x1bb7, 0x3ff6edc000000000, 0x0);
210}210}
lib/std/special/compiler_rt/fixdfdi_test.zig+41-41
...@@ -9,7 +9,7 @@ const math = std.math;...@@ -9,7 +9,7 @@ const math = std.math;
9const testing = std.testing;9const testing = std.testing;
10const warn = std.debug.warn;10const warn = std.debug.warn;
1111
12fn test__fixdfdi(a: f64, expected: i64) void {12fn test__fixdfdi(a: f64, expected: i64) !void {
13 const x = __fixdfdi(a);13 const x = __fixdfdi(a);
14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u64, expected)});14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u64, expected)});
15 try testing.expect(x == expected);15 try testing.expect(x == expected);
...@@ -17,54 +17,54 @@ fn test__fixdfdi(a: f64, expected: i64) void {...@@ -17,54 +17,54 @@ fn test__fixdfdi(a: f64, expected: i64) void {
1717
18test "fixdfdi" {18test "fixdfdi" {
19 //warn("\n", .{});19 //warn("\n", .{});
20 test__fixdfdi(-math.f64_max, math.minInt(i64));20 try test__fixdfdi(-math.f64_max, math.minInt(i64));
2121
22 test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));22 try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
23 test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);23 try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
2424
25 test__fixdfdi(-0x1.0000000000000p+127, -0x8000000000000000);25 try test__fixdfdi(-0x1.0000000000000p+127, -0x8000000000000000);
26 test__fixdfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);26 try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
27 test__fixdfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);27 try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
2828
29 test__fixdfdi(-0x1.0000000000001p+63, -0x8000000000000000);29 try test__fixdfdi(-0x1.0000000000001p+63, -0x8000000000000000);
30 test__fixdfdi(-0x1.0000000000000p+63, -0x8000000000000000);30 try test__fixdfdi(-0x1.0000000000000p+63, -0x8000000000000000);
31 test__fixdfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);31 try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
32 test__fixdfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);32 try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
3333
34 test__fixdfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);34 try test__fixdfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
35 test__fixdfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);35 try test__fixdfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
3636
37 test__fixdfdi(-2.01, -2);37 try test__fixdfdi(-2.01, -2);
38 test__fixdfdi(-2.0, -2);38 try test__fixdfdi(-2.0, -2);
39 test__fixdfdi(-1.99, -1);39 try test__fixdfdi(-1.99, -1);
40 test__fixdfdi(-1.0, -1);40 try test__fixdfdi(-1.0, -1);
41 test__fixdfdi(-0.99, 0);41 try test__fixdfdi(-0.99, 0);
42 test__fixdfdi(-0.5, 0);42 try test__fixdfdi(-0.5, 0);
43 test__fixdfdi(-math.f64_min, 0);43 try test__fixdfdi(-math.f64_min, 0);
44 test__fixdfdi(0.0, 0);44 try test__fixdfdi(0.0, 0);
45 test__fixdfdi(math.f64_min, 0);45 try test__fixdfdi(math.f64_min, 0);
46 test__fixdfdi(0.5, 0);46 try test__fixdfdi(0.5, 0);
47 test__fixdfdi(0.99, 0);47 try test__fixdfdi(0.99, 0);
48 test__fixdfdi(1.0, 1);48 try test__fixdfdi(1.0, 1);
49 test__fixdfdi(1.5, 1);49 try test__fixdfdi(1.5, 1);
50 test__fixdfdi(1.99, 1);50 try test__fixdfdi(1.99, 1);
51 test__fixdfdi(2.0, 2);51 try test__fixdfdi(2.0, 2);
52 test__fixdfdi(2.01, 2);52 try test__fixdfdi(2.01, 2);
5353
54 test__fixdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);54 try test__fixdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
55 test__fixdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);55 try test__fixdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
5656
57 test__fixdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);57 try test__fixdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
58 test__fixdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);58 try test__fixdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
59 test__fixdfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);59 try test__fixdfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
60 test__fixdfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);60 try test__fixdfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
6161
62 test__fixdfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);62 try test__fixdfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
63 test__fixdfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);63 try test__fixdfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
64 test__fixdfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);64 try test__fixdfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
6565
66 test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);66 try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
67 test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));67 try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
6868
69 test__fixdfdi(math.f64_max, math.maxInt(i64));69 try test__fixdfdi(math.f64_max, math.maxInt(i64));
70}70}
lib/std/special/compiler_rt/fixdfsi_test.zig+47-47
...@@ -9,7 +9,7 @@ const math = std.math;...@@ -9,7 +9,7 @@ const math = std.math;
9const testing = std.testing;9const testing = std.testing;
10const warn = std.debug.warn;10const warn = std.debug.warn;
1111
12fn test__fixdfsi(a: f64, expected: i32) void {12fn test__fixdfsi(a: f64, expected: i32) !void {
13 const x = __fixdfsi(a);13 const x = __fixdfsi(a);
14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u32, expected)});14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u32, expected)});
15 try testing.expect(x == expected);15 try testing.expect(x == expected);
...@@ -17,62 +17,62 @@ fn test__fixdfsi(a: f64, expected: i32) void {...@@ -17,62 +17,62 @@ fn test__fixdfsi(a: f64, expected: i32) void {
1717
18test "fixdfsi" {18test "fixdfsi" {
19 //warn("\n", .{});19 //warn("\n", .{});
20 test__fixdfsi(-math.f64_max, math.minInt(i32));20 try test__fixdfsi(-math.f64_max, math.minInt(i32));
2121
22 test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));22 try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
23 test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);23 try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
2424
25 test__fixdfsi(-0x1.0000000000000p+127, -0x80000000);25 try test__fixdfsi(-0x1.0000000000000p+127, -0x80000000);
26 test__fixdfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);26 try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
27 test__fixdfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);27 try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
2828
29 test__fixdfsi(-0x1.0000000000001p+63, -0x80000000);29 try test__fixdfsi(-0x1.0000000000001p+63, -0x80000000);
30 test__fixdfsi(-0x1.0000000000000p+63, -0x80000000);30 try test__fixdfsi(-0x1.0000000000000p+63, -0x80000000);
31 test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);31 try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
32 test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);32 try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
3333
34 test__fixdfsi(-0x1.FFFFFEp+62, -0x80000000);34 try test__fixdfsi(-0x1.FFFFFEp+62, -0x80000000);
35 test__fixdfsi(-0x1.FFFFFCp+62, -0x80000000);35 try test__fixdfsi(-0x1.FFFFFCp+62, -0x80000000);
3636
37 test__fixdfsi(-0x1.000000p+31, -0x80000000);37 try test__fixdfsi(-0x1.000000p+31, -0x80000000);
38 test__fixdfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);38 try test__fixdfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
39 test__fixdfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);39 try test__fixdfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
4040
41 test__fixdfsi(-2.01, -2);41 try test__fixdfsi(-2.01, -2);
42 test__fixdfsi(-2.0, -2);42 try test__fixdfsi(-2.0, -2);
43 test__fixdfsi(-1.99, -1);43 try test__fixdfsi(-1.99, -1);
44 test__fixdfsi(-1.0, -1);44 try test__fixdfsi(-1.0, -1);
45 test__fixdfsi(-0.99, 0);45 try test__fixdfsi(-0.99, 0);
46 test__fixdfsi(-0.5, 0);46 try test__fixdfsi(-0.5, 0);
47 test__fixdfsi(-math.f64_min, 0);47 try test__fixdfsi(-math.f64_min, 0);
48 test__fixdfsi(0.0, 0);48 try test__fixdfsi(0.0, 0);
49 test__fixdfsi(math.f64_min, 0);49 try test__fixdfsi(math.f64_min, 0);
50 test__fixdfsi(0.5, 0);50 try test__fixdfsi(0.5, 0);
51 test__fixdfsi(0.99, 0);51 try test__fixdfsi(0.99, 0);
52 test__fixdfsi(1.0, 1);52 try test__fixdfsi(1.0, 1);
53 test__fixdfsi(1.5, 1);53 try test__fixdfsi(1.5, 1);
54 test__fixdfsi(1.99, 1);54 try test__fixdfsi(1.99, 1);
55 test__fixdfsi(2.0, 2);55 try test__fixdfsi(2.0, 2);
56 test__fixdfsi(2.01, 2);56 try test__fixdfsi(2.01, 2);
5757
58 test__fixdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);58 try test__fixdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
59 test__fixdfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);59 try test__fixdfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
60 test__fixdfsi(0x1.000000p+31, 0x7FFFFFFF);60 try test__fixdfsi(0x1.000000p+31, 0x7FFFFFFF);
6161
62 test__fixdfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);62 try test__fixdfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
63 test__fixdfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);63 try test__fixdfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
6464
65 test__fixdfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);65 try test__fixdfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
66 test__fixdfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);66 try test__fixdfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
67 test__fixdfsi(0x1.0000000000000p+63, 0x7FFFFFFF);67 try test__fixdfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
68 test__fixdfsi(0x1.0000000000001p+63, 0x7FFFFFFF);68 try test__fixdfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
6969
70 test__fixdfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);70 try test__fixdfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
71 test__fixdfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);71 try test__fixdfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
72 test__fixdfsi(0x1.0000000000000p+127, 0x7FFFFFFF);72 try test__fixdfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
7373
74 test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);74 try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
75 test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));75 try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
7676
77 test__fixdfsi(math.f64_max, math.maxInt(i32));77 try test__fixdfsi(math.f64_max, math.maxInt(i32));
78}78}
lib/std/special/compiler_rt/fixdfti_test.zig+41-41
...@@ -9,7 +9,7 @@ const math = std.math;...@@ -9,7 +9,7 @@ const math = std.math;
9const testing = std.testing;9const testing = std.testing;
10const warn = std.debug.warn;10const warn = std.debug.warn;
1111
12fn test__fixdfti(a: f64, expected: i128) void {12fn test__fixdfti(a: f64, expected: i128) !void {
13 const x = __fixdfti(a);13 const x = __fixdfti(a);
14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u128, expected)});14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u128, expected)});
15 try testing.expect(x == expected);15 try testing.expect(x == expected);
...@@ -17,54 +17,54 @@ fn test__fixdfti(a: f64, expected: i128) void {...@@ -17,54 +17,54 @@ fn test__fixdfti(a: f64, expected: i128) void {
1717
18test "fixdfti" {18test "fixdfti" {
19 //warn("\n", .{});19 //warn("\n", .{});
20 test__fixdfti(-math.f64_max, math.minInt(i128));20 try test__fixdfti(-math.f64_max, math.minInt(i128));
2121
22 test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));22 try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
23 test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);23 try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
2424
25 test__fixdfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);25 try test__fixdfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
26 test__fixdfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);26 try test__fixdfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
27 test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);27 try test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
2828
29 test__fixdfti(-0x1.0000000000001p+63, -0x8000000000000800);29 try test__fixdfti(-0x1.0000000000001p+63, -0x8000000000000800);
30 test__fixdfti(-0x1.0000000000000p+63, -0x8000000000000000);30 try test__fixdfti(-0x1.0000000000000p+63, -0x8000000000000000);
31 test__fixdfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);31 try test__fixdfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
32 test__fixdfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);32 try test__fixdfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
3333
34 test__fixdfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);34 try test__fixdfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
35 test__fixdfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);35 try test__fixdfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
3636
37 test__fixdfti(-2.01, -2);37 try test__fixdfti(-2.01, -2);
38 test__fixdfti(-2.0, -2);38 try test__fixdfti(-2.0, -2);
39 test__fixdfti(-1.99, -1);39 try test__fixdfti(-1.99, -1);
40 test__fixdfti(-1.0, -1);40 try test__fixdfti(-1.0, -1);
41 test__fixdfti(-0.99, 0);41 try test__fixdfti(-0.99, 0);
42 test__fixdfti(-0.5, 0);42 try test__fixdfti(-0.5, 0);
43 test__fixdfti(-math.f64_min, 0);43 try test__fixdfti(-math.f64_min, 0);
44 test__fixdfti(0.0, 0);44 try test__fixdfti(0.0, 0);
45 test__fixdfti(math.f64_min, 0);45 try test__fixdfti(math.f64_min, 0);
46 test__fixdfti(0.5, 0);46 try test__fixdfti(0.5, 0);
47 test__fixdfti(0.99, 0);47 try test__fixdfti(0.99, 0);
48 test__fixdfti(1.0, 1);48 try test__fixdfti(1.0, 1);
49 test__fixdfti(1.5, 1);49 try test__fixdfti(1.5, 1);
50 test__fixdfti(1.99, 1);50 try test__fixdfti(1.99, 1);
51 test__fixdfti(2.0, 2);51 try test__fixdfti(2.0, 2);
52 test__fixdfti(2.01, 2);52 try test__fixdfti(2.01, 2);
5353
54 test__fixdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);54 try test__fixdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
55 test__fixdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);55 try test__fixdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
5656
57 test__fixdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);57 try test__fixdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
58 test__fixdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);58 try test__fixdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
59 test__fixdfti(0x1.0000000000000p+63, 0x8000000000000000);59 try test__fixdfti(0x1.0000000000000p+63, 0x8000000000000000);
60 test__fixdfti(0x1.0000000000001p+63, 0x8000000000000800);60 try test__fixdfti(0x1.0000000000001p+63, 0x8000000000000800);
6161
62 test__fixdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);62 try test__fixdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
63 test__fixdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);63 try test__fixdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
64 test__fixdfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);64 try test__fixdfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
6565
66 test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);66 try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
67 test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));67 try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
6868
69 test__fixdfti(math.f64_max, math.maxInt(i128));69 try test__fixdfti(math.f64_max, math.maxInt(i128));
70}70}
lib/std/special/compiler_rt/fixint_test.zig+122-122
...@@ -11,147 +11,147 @@ const warn = std.debug.warn;...@@ -11,147 +11,147 @@ const warn = std.debug.warn;
1111
12const fixint = @import("fixint.zig").fixint;12const fixint = @import("fixint.zig").fixint;
1313
14fn test__fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t, expected: fixint_t) void {14fn test__fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t, expected: fixint_t) !void {
15 const x = fixint(fp_t, fixint_t, a);15 const x = fixint(fp_t, fixint_t, a);
16 //warn("a={} x={}:{x} expected={}:{x})\n", .{a, x, x, expected, expected});16 //warn("a={} x={}:{x} expected={}:{x})\n", .{a, x, x, expected, expected});
17 try testing.expect(x == expected);17 try testing.expect(x == expected);
18}18}
1919
20test "fixint.i1" {20test "fixint.i1" {
21 test__fixint(f32, i1, -math.inf_f32, -1);21 try test__fixint(f32, i1, -math.inf_f32, -1);
22 test__fixint(f32, i1, -math.f32_max, -1);22 try test__fixint(f32, i1, -math.f32_max, -1);
23 test__fixint(f32, i1, -2.0, -1);23 try test__fixint(f32, i1, -2.0, -1);
24 test__fixint(f32, i1, -1.1, -1);24 try test__fixint(f32, i1, -1.1, -1);
25 test__fixint(f32, i1, -1.0, -1);25 try test__fixint(f32, i1, -1.0, -1);
26 test__fixint(f32, i1, -0.9, 0);26 try test__fixint(f32, i1, -0.9, 0);
27 test__fixint(f32, i1, -0.1, 0);27 try test__fixint(f32, i1, -0.1, 0);
28 test__fixint(f32, i1, -math.f32_min, 0);28 try test__fixint(f32, i1, -math.f32_min, 0);
29 test__fixint(f32, i1, -0.0, 0);29 try test__fixint(f32, i1, -0.0, 0);
30 test__fixint(f32, i1, 0.0, 0);30 try test__fixint(f32, i1, 0.0, 0);
31 test__fixint(f32, i1, math.f32_min, 0);31 try test__fixint(f32, i1, math.f32_min, 0);
32 test__fixint(f32, i1, 0.1, 0);32 try test__fixint(f32, i1, 0.1, 0);
33 test__fixint(f32, i1, 0.9, 0);33 try test__fixint(f32, i1, 0.9, 0);
34 test__fixint(f32, i1, 1.0, 0);34 try test__fixint(f32, i1, 1.0, 0);
35 test__fixint(f32, i1, 2.0, 0);35 try test__fixint(f32, i1, 2.0, 0);
36 test__fixint(f32, i1, math.f32_max, 0);36 try test__fixint(f32, i1, math.f32_max, 0);
37 test__fixint(f32, i1, math.inf_f32, 0);37 try test__fixint(f32, i1, math.inf_f32, 0);
38}38}
3939
40test "fixint.i2" {40test "fixint.i2" {
41 test__fixint(f32, i2, -math.inf_f32, -2);41 try test__fixint(f32, i2, -math.inf_f32, -2);
42 test__fixint(f32, i2, -math.f32_max, -2);42 try test__fixint(f32, i2, -math.f32_max, -2);
43 test__fixint(f32, i2, -2.0, -2);43 try test__fixint(f32, i2, -2.0, -2);
44 test__fixint(f32, i2, -1.9, -1);44 try test__fixint(f32, i2, -1.9, -1);
45 test__fixint(f32, i2, -1.1, -1);45 try test__fixint(f32, i2, -1.1, -1);
46 test__fixint(f32, i2, -1.0, -1);46 try test__fixint(f32, i2, -1.0, -1);
47 test__fixint(f32, i2, -0.9, 0);47 try test__fixint(f32, i2, -0.9, 0);
48 test__fixint(f32, i2, -0.1, 0);48 try test__fixint(f32, i2, -0.1, 0);
49 test__fixint(f32, i2, -math.f32_min, 0);49 try test__fixint(f32, i2, -math.f32_min, 0);
50 test__fixint(f32, i2, -0.0, 0);50 try test__fixint(f32, i2, -0.0, 0);
51 test__fixint(f32, i2, 0.0, 0);51 try test__fixint(f32, i2, 0.0, 0);
52 test__fixint(f32, i2, math.f32_min, 0);52 try test__fixint(f32, i2, math.f32_min, 0);
53 test__fixint(f32, i2, 0.1, 0);53 try test__fixint(f32, i2, 0.1, 0);
54 test__fixint(f32, i2, 0.9, 0);54 try test__fixint(f32, i2, 0.9, 0);
55 test__fixint(f32, i2, 1.0, 1);55 try test__fixint(f32, i2, 1.0, 1);
56 test__fixint(f32, i2, 2.0, 1);56 try test__fixint(f32, i2, 2.0, 1);
57 test__fixint(f32, i2, math.f32_max, 1);57 try test__fixint(f32, i2, math.f32_max, 1);
58 test__fixint(f32, i2, math.inf_f32, 1);58 try test__fixint(f32, i2, math.inf_f32, 1);
59}59}
6060
61test "fixint.i3" {61test "fixint.i3" {
62 test__fixint(f32, i3, -math.inf_f32, -4);62 try test__fixint(f32, i3, -math.inf_f32, -4);
63 test__fixint(f32, i3, -math.f32_max, -4);63 try test__fixint(f32, i3, -math.f32_max, -4);
64 test__fixint(f32, i3, -4.0, -4);64 try test__fixint(f32, i3, -4.0, -4);
65 test__fixint(f32, i3, -3.0, -3);65 try test__fixint(f32, i3, -3.0, -3);
66 test__fixint(f32, i3, -2.0, -2);66 try test__fixint(f32, i3, -2.0, -2);
67 test__fixint(f32, i3, -1.9, -1);67 try test__fixint(f32, i3, -1.9, -1);
68 test__fixint(f32, i3, -1.1, -1);68 try test__fixint(f32, i3, -1.1, -1);
69 test__fixint(f32, i3, -1.0, -1);69 try test__fixint(f32, i3, -1.0, -1);
70 test__fixint(f32, i3, -0.9, 0);70 try test__fixint(f32, i3, -0.9, 0);
71 test__fixint(f32, i3, -0.1, 0);71 try test__fixint(f32, i3, -0.1, 0);
72 test__fixint(f32, i3, -math.f32_min, 0);72 try test__fixint(f32, i3, -math.f32_min, 0);
73 test__fixint(f32, i3, -0.0, 0);73 try test__fixint(f32, i3, -0.0, 0);
74 test__fixint(f32, i3, 0.0, 0);74 try test__fixint(f32, i3, 0.0, 0);
75 test__fixint(f32, i3, math.f32_min, 0);75 try test__fixint(f32, i3, math.f32_min, 0);
76 test__fixint(f32, i3, 0.1, 0);76 try test__fixint(f32, i3, 0.1, 0);
77 test__fixint(f32, i3, 0.9, 0);77 try test__fixint(f32, i3, 0.9, 0);
78 test__fixint(f32, i3, 1.0, 1);78 try test__fixint(f32, i3, 1.0, 1);
79 test__fixint(f32, i3, 2.0, 2);79 try test__fixint(f32, i3, 2.0, 2);
80 test__fixint(f32, i3, 3.0, 3);80 try test__fixint(f32, i3, 3.0, 3);
81 test__fixint(f32, i3, 4.0, 3);81 try test__fixint(f32, i3, 4.0, 3);
82 test__fixint(f32, i3, math.f32_max, 3);82 try test__fixint(f32, i3, math.f32_max, 3);
83 test__fixint(f32, i3, math.inf_f32, 3);83 try test__fixint(f32, i3, math.inf_f32, 3);
84}84}
8585
86test "fixint.i32" {86test "fixint.i32" {
87 test__fixint(f64, i32, -math.inf_f64, math.minInt(i32));87 try test__fixint(f64, i32, -math.inf_f64, math.minInt(i32));
88 test__fixint(f64, i32, -math.f64_max, math.minInt(i32));88 try test__fixint(f64, i32, -math.f64_max, math.minInt(i32));
89 test__fixint(f64, i32, @as(f64, math.minInt(i32)), math.minInt(i32));89 try test__fixint(f64, i32, @as(f64, math.minInt(i32)), math.minInt(i32));
90 test__fixint(f64, i32, @as(f64, math.minInt(i32)) + 1, math.minInt(i32) + 1);90 try test__fixint(f64, i32, @as(f64, math.minInt(i32)) + 1, math.minInt(i32) + 1);
91 test__fixint(f64, i32, -2.0, -2);91 try test__fixint(f64, i32, -2.0, -2);
92 test__fixint(f64, i32, -1.9, -1);92 try test__fixint(f64, i32, -1.9, -1);
93 test__fixint(f64, i32, -1.1, -1);93 try test__fixint(f64, i32, -1.1, -1);
94 test__fixint(f64, i32, -1.0, -1);94 try test__fixint(f64, i32, -1.0, -1);
95 test__fixint(f64, i32, -0.9, 0);95 try test__fixint(f64, i32, -0.9, 0);
96 test__fixint(f64, i32, -0.1, 0);96 try test__fixint(f64, i32, -0.1, 0);
97 test__fixint(f64, i32, -math.f32_min, 0);97 try test__fixint(f64, i32, -math.f32_min, 0);
98 test__fixint(f64, i32, -0.0, 0);98 try test__fixint(f64, i32, -0.0, 0);
99 test__fixint(f64, i32, 0.0, 0);99 try test__fixint(f64, i32, 0.0, 0);
100 test__fixint(f64, i32, math.f32_min, 0);100 try test__fixint(f64, i32, math.f32_min, 0);
101 test__fixint(f64, i32, 0.1, 0);101 try test__fixint(f64, i32, 0.1, 0);
102 test__fixint(f64, i32, 0.9, 0);102 try test__fixint(f64, i32, 0.9, 0);
103 test__fixint(f64, i32, 1.0, 1);103 try test__fixint(f64, i32, 1.0, 1);
104 test__fixint(f64, i32, @as(f64, math.maxInt(i32)) - 1, math.maxInt(i32) - 1);104 try test__fixint(f64, i32, @as(f64, math.maxInt(i32)) - 1, math.maxInt(i32) - 1);
105 test__fixint(f64, i32, @as(f64, math.maxInt(i32)), math.maxInt(i32));105 try test__fixint(f64, i32, @as(f64, math.maxInt(i32)), math.maxInt(i32));
106 test__fixint(f64, i32, math.f64_max, math.maxInt(i32));106 try test__fixint(f64, i32, math.f64_max, math.maxInt(i32));
107 test__fixint(f64, i32, math.inf_f64, math.maxInt(i32));107 try test__fixint(f64, i32, math.inf_f64, math.maxInt(i32));
108}108}
109109
110test "fixint.i64" {110test "fixint.i64" {
111 test__fixint(f64, i64, -math.inf_f64, math.minInt(i64));111 try test__fixint(f64, i64, -math.inf_f64, math.minInt(i64));
112 test__fixint(f64, i64, -math.f64_max, math.minInt(i64));112 try test__fixint(f64, i64, -math.f64_max, math.minInt(i64));
113 test__fixint(f64, i64, @as(f64, math.minInt(i64)), math.minInt(i64));113 try test__fixint(f64, i64, @as(f64, math.minInt(i64)), math.minInt(i64));
114 test__fixint(f64, i64, @as(f64, math.minInt(i64)) + 1, math.minInt(i64));114 try test__fixint(f64, i64, @as(f64, math.minInt(i64)) + 1, math.minInt(i64));
115 test__fixint(f64, i64, @as(f64, math.minInt(i64) / 2), math.minInt(i64) / 2);115 try test__fixint(f64, i64, @as(f64, math.minInt(i64) / 2), math.minInt(i64) / 2);
116 test__fixint(f64, i64, -2.0, -2);116 try test__fixint(f64, i64, -2.0, -2);
117 test__fixint(f64, i64, -1.9, -1);117 try test__fixint(f64, i64, -1.9, -1);
118 test__fixint(f64, i64, -1.1, -1);118 try test__fixint(f64, i64, -1.1, -1);
119 test__fixint(f64, i64, -1.0, -1);119 try test__fixint(f64, i64, -1.0, -1);
120 test__fixint(f64, i64, -0.9, 0);120 try test__fixint(f64, i64, -0.9, 0);
121 test__fixint(f64, i64, -0.1, 0);121 try test__fixint(f64, i64, -0.1, 0);
122 test__fixint(f64, i64, -math.f32_min, 0);122 try test__fixint(f64, i64, -math.f32_min, 0);
123 test__fixint(f64, i64, -0.0, 0);123 try test__fixint(f64, i64, -0.0, 0);
124 test__fixint(f64, i64, 0.0, 0);124 try test__fixint(f64, i64, 0.0, 0);
125 test__fixint(f64, i64, math.f32_min, 0);125 try test__fixint(f64, i64, math.f32_min, 0);
126 test__fixint(f64, i64, 0.1, 0);126 try test__fixint(f64, i64, 0.1, 0);
127 test__fixint(f64, i64, 0.9, 0);127 try test__fixint(f64, i64, 0.9, 0);
128 test__fixint(f64, i64, 1.0, 1);128 try test__fixint(f64, i64, 1.0, 1);
129 test__fixint(f64, i64, @as(f64, math.maxInt(i64)) - 1, math.maxInt(i64));129 try test__fixint(f64, i64, @as(f64, math.maxInt(i64)) - 1, math.maxInt(i64));
130 test__fixint(f64, i64, @as(f64, math.maxInt(i64)), math.maxInt(i64));130 try test__fixint(f64, i64, @as(f64, math.maxInt(i64)), math.maxInt(i64));
131 test__fixint(f64, i64, math.f64_max, math.maxInt(i64));131 try test__fixint(f64, i64, math.f64_max, math.maxInt(i64));
132 test__fixint(f64, i64, math.inf_f64, math.maxInt(i64));132 try test__fixint(f64, i64, math.inf_f64, math.maxInt(i64));
133}133}
134134
135test "fixint.i128" {135test "fixint.i128" {
136 test__fixint(f64, i128, -math.inf_f64, math.minInt(i128));136 try test__fixint(f64, i128, -math.inf_f64, math.minInt(i128));
137 test__fixint(f64, i128, -math.f64_max, math.minInt(i128));137 try test__fixint(f64, i128, -math.f64_max, math.minInt(i128));
138 test__fixint(f64, i128, @as(f64, math.minInt(i128)), math.minInt(i128));138 try test__fixint(f64, i128, @as(f64, math.minInt(i128)), math.minInt(i128));
139 test__fixint(f64, i128, @as(f64, math.minInt(i128)) + 1, math.minInt(i128));139 try test__fixint(f64, i128, @as(f64, math.minInt(i128)) + 1, math.minInt(i128));
140 test__fixint(f64, i128, -2.0, -2);140 try test__fixint(f64, i128, -2.0, -2);
141 test__fixint(f64, i128, -1.9, -1);141 try test__fixint(f64, i128, -1.9, -1);
142 test__fixint(f64, i128, -1.1, -1);142 try test__fixint(f64, i128, -1.1, -1);
143 test__fixint(f64, i128, -1.0, -1);143 try test__fixint(f64, i128, -1.0, -1);
144 test__fixint(f64, i128, -0.9, 0);144 try test__fixint(f64, i128, -0.9, 0);
145 test__fixint(f64, i128, -0.1, 0);145 try test__fixint(f64, i128, -0.1, 0);
146 test__fixint(f64, i128, -math.f32_min, 0);146 try test__fixint(f64, i128, -math.f32_min, 0);
147 test__fixint(f64, i128, -0.0, 0);147 try test__fixint(f64, i128, -0.0, 0);
148 test__fixint(f64, i128, 0.0, 0);148 try test__fixint(f64, i128, 0.0, 0);
149 test__fixint(f64, i128, math.f32_min, 0);149 try test__fixint(f64, i128, math.f32_min, 0);
150 test__fixint(f64, i128, 0.1, 0);150 try test__fixint(f64, i128, 0.1, 0);
151 test__fixint(f64, i128, 0.9, 0);151 try test__fixint(f64, i128, 0.9, 0);
152 test__fixint(f64, i128, 1.0, 1);152 try test__fixint(f64, i128, 1.0, 1);
153 test__fixint(f64, i128, @as(f64, math.maxInt(i128)) - 1, math.maxInt(i128));153 try test__fixint(f64, i128, @as(f64, math.maxInt(i128)) - 1, math.maxInt(i128));
154 test__fixint(f64, i128, @as(f64, math.maxInt(i128)), math.maxInt(i128));154 try test__fixint(f64, i128, @as(f64, math.maxInt(i128)), math.maxInt(i128));
155 test__fixint(f64, i128, math.f64_max, math.maxInt(i128));155 try test__fixint(f64, i128, math.f64_max, math.maxInt(i128));
156 test__fixint(f64, i128, math.inf_f64, math.maxInt(i128));156 try test__fixint(f64, i128, math.inf_f64, math.maxInt(i128));
157}157}
lib/std/special/compiler_rt/fixsfdi_test.zig+43-43
...@@ -9,7 +9,7 @@ const math = std.math;...@@ -9,7 +9,7 @@ const math = std.math;
9const testing = std.testing;9const testing = std.testing;
10const warn = std.debug.warn;10const warn = std.debug.warn;
1111
12fn test__fixsfdi(a: f32, expected: i64) void {12fn test__fixsfdi(a: f32, expected: i64) !void {
13 const x = __fixsfdi(a);13 const x = __fixsfdi(a);
14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u64, expected)});14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u64, expected)});
15 try testing.expect(x == expected);15 try testing.expect(x == expected);
...@@ -17,56 +17,56 @@ fn test__fixsfdi(a: f32, expected: i64) void {...@@ -17,56 +17,56 @@ fn test__fixsfdi(a: f32, expected: i64) void {
1717
18test "fixsfdi" {18test "fixsfdi" {
19 //warn("\n", .{});19 //warn("\n", .{});
20 test__fixsfdi(-math.f32_max, math.minInt(i64));20 try test__fixsfdi(-math.f32_max, math.minInt(i64));
2121
22 test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));22 try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
23 test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);23 try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
2424
25 test__fixsfdi(-0x1.0000000000000p+127, -0x8000000000000000);25 try test__fixsfdi(-0x1.0000000000000p+127, -0x8000000000000000);
26 test__fixsfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);26 try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
27 test__fixsfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);27 try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
2828
29 test__fixsfdi(-0x1.0000000000001p+63, -0x8000000000000000);29 try test__fixsfdi(-0x1.0000000000001p+63, -0x8000000000000000);
30 test__fixsfdi(-0x1.0000000000000p+63, -0x8000000000000000);30 try test__fixsfdi(-0x1.0000000000000p+63, -0x8000000000000000);
31 test__fixsfdi(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);31 try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
32 test__fixsfdi(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);32 try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
3333
34 test__fixsfdi(-0x1.FFFFFFp+62, -0x8000000000000000);34 try test__fixsfdi(-0x1.FFFFFFp+62, -0x8000000000000000);
35 test__fixsfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);35 try test__fixsfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
36 test__fixsfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);36 try test__fixsfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
3737
38 test__fixsfdi(-2.01, -2);38 try test__fixsfdi(-2.01, -2);
39 test__fixsfdi(-2.0, -2);39 try test__fixsfdi(-2.0, -2);
40 test__fixsfdi(-1.99, -1);40 try test__fixsfdi(-1.99, -1);
41 test__fixsfdi(-1.0, -1);41 try test__fixsfdi(-1.0, -1);
42 test__fixsfdi(-0.99, 0);42 try test__fixsfdi(-0.99, 0);
43 test__fixsfdi(-0.5, 0);43 try test__fixsfdi(-0.5, 0);
44 test__fixsfdi(-math.f32_min, 0);44 try test__fixsfdi(-math.f32_min, 0);
45 test__fixsfdi(0.0, 0);45 try test__fixsfdi(0.0, 0);
46 test__fixsfdi(math.f32_min, 0);46 try test__fixsfdi(math.f32_min, 0);
47 test__fixsfdi(0.5, 0);47 try test__fixsfdi(0.5, 0);
48 test__fixsfdi(0.99, 0);48 try test__fixsfdi(0.99, 0);
49 test__fixsfdi(1.0, 1);49 try test__fixsfdi(1.0, 1);
50 test__fixsfdi(1.5, 1);50 try test__fixsfdi(1.5, 1);
51 test__fixsfdi(1.99, 1);51 try test__fixsfdi(1.99, 1);
52 test__fixsfdi(2.0, 2);52 try test__fixsfdi(2.0, 2);
53 test__fixsfdi(2.01, 2);53 try test__fixsfdi(2.01, 2);
5454
55 test__fixsfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);55 try test__fixsfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
56 test__fixsfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);56 try test__fixsfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
57 test__fixsfdi(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF);57 try test__fixsfdi(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
5858
59 test__fixsfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF);59 try test__fixsfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF);
60 test__fixsfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF);60 try test__fixsfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
61 test__fixsfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);61 try test__fixsfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
62 test__fixsfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);62 try test__fixsfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
6363
64 test__fixsfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);64 try test__fixsfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
65 test__fixsfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);65 try test__fixsfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
66 test__fixsfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);66 try test__fixsfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
6767
68 test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);68 try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
69 test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));69 try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
7070
71 test__fixsfdi(math.f64_max, math.maxInt(i64));71 try test__fixsfdi(math.f64_max, math.maxInt(i64));
72}72}
lib/std/special/compiler_rt/fixsfsi_test.zig+49-49
...@@ -9,7 +9,7 @@ const math = std.math;...@@ -9,7 +9,7 @@ const math = std.math;
9const testing = std.testing;9const testing = std.testing;
10const warn = std.debug.warn;10const warn = std.debug.warn;
1111
12fn test__fixsfsi(a: f32, expected: i32) void {12fn test__fixsfsi(a: f32, expected: i32) !void {
13 const x = __fixsfsi(a);13 const x = __fixsfsi(a);
14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u32, expected)});14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u32, expected)});
15 try testing.expect(x == expected);15 try testing.expect(x == expected);
...@@ -17,64 +17,64 @@ fn test__fixsfsi(a: f32, expected: i32) void {...@@ -17,64 +17,64 @@ fn test__fixsfsi(a: f32, expected: i32) void {
1717
18test "fixsfsi" {18test "fixsfsi" {
19 //warn("\n", .{});19 //warn("\n", .{});
20 test__fixsfsi(-math.f32_max, math.minInt(i32));20 try test__fixsfsi(-math.f32_max, math.minInt(i32));
2121
22 test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));22 try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
23 test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);23 try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
2424
25 test__fixsfsi(-0x1.0000000000000p+127, -0x80000000);25 try test__fixsfsi(-0x1.0000000000000p+127, -0x80000000);
26 test__fixsfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);26 try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
27 test__fixsfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);27 try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
2828
29 test__fixsfsi(-0x1.0000000000001p+63, -0x80000000);29 try test__fixsfsi(-0x1.0000000000001p+63, -0x80000000);
30 test__fixsfsi(-0x1.0000000000000p+63, -0x80000000);30 try test__fixsfsi(-0x1.0000000000000p+63, -0x80000000);
31 test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);31 try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
32 test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);32 try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
3333
34 test__fixsfsi(-0x1.FFFFFEp+62, -0x80000000);34 try test__fixsfsi(-0x1.FFFFFEp+62, -0x80000000);
35 test__fixsfsi(-0x1.FFFFFCp+62, -0x80000000);35 try test__fixsfsi(-0x1.FFFFFCp+62, -0x80000000);
3636
37 test__fixsfsi(-0x1.000000p+31, -0x80000000);37 try test__fixsfsi(-0x1.000000p+31, -0x80000000);
38 test__fixsfsi(-0x1.FFFFFFp+30, -0x80000000);38 try test__fixsfsi(-0x1.FFFFFFp+30, -0x80000000);
39 test__fixsfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);39 try test__fixsfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
40 test__fixsfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);40 try test__fixsfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
4141
42 test__fixsfsi(-2.01, -2);42 try test__fixsfsi(-2.01, -2);
43 test__fixsfsi(-2.0, -2);43 try test__fixsfsi(-2.0, -2);
44 test__fixsfsi(-1.99, -1);44 try test__fixsfsi(-1.99, -1);
45 test__fixsfsi(-1.0, -1);45 try test__fixsfsi(-1.0, -1);
46 test__fixsfsi(-0.99, 0);46 try test__fixsfsi(-0.99, 0);
47 test__fixsfsi(-0.5, 0);47 try test__fixsfsi(-0.5, 0);
48 test__fixsfsi(-math.f32_min, 0);48 try test__fixsfsi(-math.f32_min, 0);
49 test__fixsfsi(0.0, 0);49 try test__fixsfsi(0.0, 0);
50 test__fixsfsi(math.f32_min, 0);50 try test__fixsfsi(math.f32_min, 0);
51 test__fixsfsi(0.5, 0);51 try test__fixsfsi(0.5, 0);
52 test__fixsfsi(0.99, 0);52 try test__fixsfsi(0.99, 0);
53 test__fixsfsi(1.0, 1);53 try test__fixsfsi(1.0, 1);
54 test__fixsfsi(1.5, 1);54 try test__fixsfsi(1.5, 1);
55 test__fixsfsi(1.99, 1);55 try test__fixsfsi(1.99, 1);
56 test__fixsfsi(2.0, 2);56 try test__fixsfsi(2.0, 2);
57 test__fixsfsi(2.01, 2);57 try test__fixsfsi(2.01, 2);
5858
59 test__fixsfsi(0x1.FFFFFCp+30, 0x7FFFFF00);59 try test__fixsfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
60 test__fixsfsi(0x1.FFFFFEp+30, 0x7FFFFF80);60 try test__fixsfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
61 test__fixsfsi(0x1.FFFFFFp+30, 0x7FFFFFFF);61 try test__fixsfsi(0x1.FFFFFFp+30, 0x7FFFFFFF);
62 test__fixsfsi(0x1.000000p+31, 0x7FFFFFFF);62 try test__fixsfsi(0x1.000000p+31, 0x7FFFFFFF);
6363
64 test__fixsfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);64 try test__fixsfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
65 test__fixsfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);65 try test__fixsfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
6666
67 test__fixsfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);67 try test__fixsfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
68 test__fixsfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);68 try test__fixsfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
69 test__fixsfsi(0x1.0000000000000p+63, 0x7FFFFFFF);69 try test__fixsfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
70 test__fixsfsi(0x1.0000000000001p+63, 0x7FFFFFFF);70 try test__fixsfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
7171
72 test__fixsfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);72 try test__fixsfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
73 test__fixsfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);73 try test__fixsfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
74 test__fixsfsi(0x1.0000000000000p+127, 0x7FFFFFFF);74 try test__fixsfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
7575
76 test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);76 try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
77 test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));77 try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
7878
79 test__fixsfsi(math.f32_max, math.maxInt(i32));79 try test__fixsfsi(math.f32_max, math.maxInt(i32));
80}80}
lib/std/special/compiler_rt/fixsfti_test.zig+57-57
...@@ -9,7 +9,7 @@ const math = std.math;...@@ -9,7 +9,7 @@ const math = std.math;
9const testing = std.testing;9const testing = std.testing;
10const warn = std.debug.warn;10const warn = std.debug.warn;
1111
12fn test__fixsfti(a: f32, expected: i128) void {12fn test__fixsfti(a: f32, expected: i128) !void {
13 const x = __fixsfti(a);13 const x = __fixsfti(a);
14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u128, expected)});14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u128, expected)});
15 try testing.expect(x == expected);15 try testing.expect(x == expected);
...@@ -17,72 +17,72 @@ fn test__fixsfti(a: f32, expected: i128) void {...@@ -17,72 +17,72 @@ fn test__fixsfti(a: f32, expected: i128) void {
1717
18test "fixsfti" {18test "fixsfti" {
19 //warn("\n", .{});19 //warn("\n", .{});
20 test__fixsfti(-math.f32_max, math.minInt(i128));20 try test__fixsfti(-math.f32_max, math.minInt(i128));
2121
22 test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));22 try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
23 test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);23 try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
2424
25 test__fixsfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);25 try test__fixsfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
26 test__fixsfti(-0x1.FFFFFFFFFFFFFp+126, -0x80000000000000000000000000000000);26 try test__fixsfti(-0x1.FFFFFFFFFFFFFp+126, -0x80000000000000000000000000000000);
27 test__fixsfti(-0x1.FFFFFFFFFFFFEp+126, -0x80000000000000000000000000000000);27 try test__fixsfti(-0x1.FFFFFFFFFFFFEp+126, -0x80000000000000000000000000000000);
28 test__fixsfti(-0x1.FFFFFF0000000p+126, -0x80000000000000000000000000000000);28 try test__fixsfti(-0x1.FFFFFF0000000p+126, -0x80000000000000000000000000000000);
29 test__fixsfti(-0x1.FFFFFE0000000p+126, -0x7FFFFF80000000000000000000000000);29 try test__fixsfti(-0x1.FFFFFE0000000p+126, -0x7FFFFF80000000000000000000000000);
30 test__fixsfti(-0x1.FFFFFC0000000p+126, -0x7FFFFF00000000000000000000000000);30 try test__fixsfti(-0x1.FFFFFC0000000p+126, -0x7FFFFF00000000000000000000000000);
3131
32 test__fixsfti(-0x1.0000000000001p+63, -0x8000000000000000);32 try test__fixsfti(-0x1.0000000000001p+63, -0x8000000000000000);
33 test__fixsfti(-0x1.0000000000000p+63, -0x8000000000000000);33 try test__fixsfti(-0x1.0000000000000p+63, -0x8000000000000000);
34 test__fixsfti(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);34 try test__fixsfti(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
35 test__fixsfti(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);35 try test__fixsfti(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
3636
37 test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000);37 try test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000);
38 test__fixsfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);38 try test__fixsfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
39 test__fixsfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);39 try test__fixsfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
4040
41 test__fixsfti(-0x1.000000p+31, -0x80000000);41 try test__fixsfti(-0x1.000000p+31, -0x80000000);
42 test__fixsfti(-0x1.FFFFFFp+30, -0x80000000);42 try test__fixsfti(-0x1.FFFFFFp+30, -0x80000000);
43 test__fixsfti(-0x1.FFFFFEp+30, -0x7FFFFF80);43 try test__fixsfti(-0x1.FFFFFEp+30, -0x7FFFFF80);
44 test__fixsfti(-0x1.FFFFFCp+30, -0x7FFFFF00);44 try test__fixsfti(-0x1.FFFFFCp+30, -0x7FFFFF00);
4545
46 test__fixsfti(-2.01, -2);46 try test__fixsfti(-2.01, -2);
47 test__fixsfti(-2.0, -2);47 try test__fixsfti(-2.0, -2);
48 test__fixsfti(-1.99, -1);48 try test__fixsfti(-1.99, -1);
49 test__fixsfti(-1.0, -1);49 try test__fixsfti(-1.0, -1);
50 test__fixsfti(-0.99, 0);50 try test__fixsfti(-0.99, 0);
51 test__fixsfti(-0.5, 0);51 try test__fixsfti(-0.5, 0);
52 test__fixsfti(-math.f32_min, 0);52 try test__fixsfti(-math.f32_min, 0);
53 test__fixsfti(0.0, 0);53 try test__fixsfti(0.0, 0);
54 test__fixsfti(math.f32_min, 0);54 try test__fixsfti(math.f32_min, 0);
55 test__fixsfti(0.5, 0);55 try test__fixsfti(0.5, 0);
56 test__fixsfti(0.99, 0);56 try test__fixsfti(0.99, 0);
57 test__fixsfti(1.0, 1);57 try test__fixsfti(1.0, 1);
58 test__fixsfti(1.5, 1);58 try test__fixsfti(1.5, 1);
59 test__fixsfti(1.99, 1);59 try test__fixsfti(1.99, 1);
60 test__fixsfti(2.0, 2);60 try test__fixsfti(2.0, 2);
61 test__fixsfti(2.01, 2);61 try test__fixsfti(2.01, 2);
6262
63 test__fixsfti(0x1.FFFFFCp+30, 0x7FFFFF00);63 try test__fixsfti(0x1.FFFFFCp+30, 0x7FFFFF00);
64 test__fixsfti(0x1.FFFFFEp+30, 0x7FFFFF80);64 try test__fixsfti(0x1.FFFFFEp+30, 0x7FFFFF80);
65 test__fixsfti(0x1.FFFFFFp+30, 0x80000000);65 try test__fixsfti(0x1.FFFFFFp+30, 0x80000000);
66 test__fixsfti(0x1.000000p+31, 0x80000000);66 try test__fixsfti(0x1.000000p+31, 0x80000000);
6767
68 test__fixsfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);68 try test__fixsfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
69 test__fixsfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);69 try test__fixsfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
70 test__fixsfti(0x1.FFFFFFp+62, 0x8000000000000000);70 try test__fixsfti(0x1.FFFFFFp+62, 0x8000000000000000);
7171
72 test__fixsfti(0x1.FFFFFFFFFFFFEp+62, 0x8000000000000000);72 try test__fixsfti(0x1.FFFFFFFFFFFFEp+62, 0x8000000000000000);
73 test__fixsfti(0x1.FFFFFFFFFFFFFp+62, 0x8000000000000000);73 try test__fixsfti(0x1.FFFFFFFFFFFFFp+62, 0x8000000000000000);
74 test__fixsfti(0x1.0000000000000p+63, 0x8000000000000000);74 try test__fixsfti(0x1.0000000000000p+63, 0x8000000000000000);
75 test__fixsfti(0x1.0000000000001p+63, 0x8000000000000000);75 try test__fixsfti(0x1.0000000000001p+63, 0x8000000000000000);
7676
77 test__fixsfti(0x1.FFFFFC0000000p+126, 0x7FFFFF00000000000000000000000000);77 try test__fixsfti(0x1.FFFFFC0000000p+126, 0x7FFFFF00000000000000000000000000);
78 test__fixsfti(0x1.FFFFFE0000000p+126, 0x7FFFFF80000000000000000000000000);78 try test__fixsfti(0x1.FFFFFE0000000p+126, 0x7FFFFF80000000000000000000000000);
79 test__fixsfti(0x1.FFFFFF0000000p+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);79 try test__fixsfti(0x1.FFFFFF0000000p+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
80 test__fixsfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);80 try test__fixsfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
81 test__fixsfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);81 try test__fixsfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
82 test__fixsfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);82 try test__fixsfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
8383
84 test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);84 try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
85 test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));85 try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
8686
87 test__fixsfti(math.f32_max, math.maxInt(i128));87 try test__fixsfti(math.f32_max, math.maxInt(i128));
88}88}
lib/std/special/compiler_rt/fixtfdi_test.zig+49-49
...@@ -9,7 +9,7 @@ const math = std.math;...@@ -9,7 +9,7 @@ const math = std.math;
9const testing = std.testing;9const testing = std.testing;
10const warn = std.debug.warn;10const warn = std.debug.warn;
1111
12fn test__fixtfdi(a: f128, expected: i64) void {12fn test__fixtfdi(a: f128, expected: i64) !void {
13 const x = __fixtfdi(a);13 const x = __fixtfdi(a);
14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u64, expected)});14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u64, expected)});
15 try testing.expect(x == expected);15 try testing.expect(x == expected);
...@@ -17,64 +17,64 @@ fn test__fixtfdi(a: f128, expected: i64) void {...@@ -17,64 +17,64 @@ fn test__fixtfdi(a: f128, expected: i64) void {
1717
18test "fixtfdi" {18test "fixtfdi" {
19 //warn("\n", .{});19 //warn("\n", .{});
20 test__fixtfdi(-math.f128_max, math.minInt(i64));20 try test__fixtfdi(-math.f128_max, math.minInt(i64));
2121
22 test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));22 try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
23 test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);23 try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
2424
25 test__fixtfdi(-0x1.0000000000000p+127, -0x8000000000000000);25 try test__fixtfdi(-0x1.0000000000000p+127, -0x8000000000000000);
26 test__fixtfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);26 try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
27 test__fixtfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);27 try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
2828
29 test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000);29 try test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000);
30 test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000);30 try test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000);
31 test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);31 try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
32 test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);32 try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
3333
34 test__fixtfdi(-0x1.FFFFFEp+62, -0x7FFFFF8000000000);34 try test__fixtfdi(-0x1.FFFFFEp+62, -0x7FFFFF8000000000);
35 test__fixtfdi(-0x1.FFFFFCp+62, -0x7FFFFF0000000000);35 try test__fixtfdi(-0x1.FFFFFCp+62, -0x7FFFFF0000000000);
3636
37 test__fixtfdi(-0x1.000000p+31, -0x80000000);37 try test__fixtfdi(-0x1.000000p+31, -0x80000000);
38 test__fixtfdi(-0x1.FFFFFFp+30, -0x7FFFFFC0);38 try test__fixtfdi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
39 test__fixtfdi(-0x1.FFFFFEp+30, -0x7FFFFF80);39 try test__fixtfdi(-0x1.FFFFFEp+30, -0x7FFFFF80);
40 test__fixtfdi(-0x1.FFFFFCp+30, -0x7FFFFF00);40 try test__fixtfdi(-0x1.FFFFFCp+30, -0x7FFFFF00);
4141
42 test__fixtfdi(-2.01, -2);42 try test__fixtfdi(-2.01, -2);
43 test__fixtfdi(-2.0, -2);43 try test__fixtfdi(-2.0, -2);
44 test__fixtfdi(-1.99, -1);44 try test__fixtfdi(-1.99, -1);
45 test__fixtfdi(-1.0, -1);45 try test__fixtfdi(-1.0, -1);
46 test__fixtfdi(-0.99, 0);46 try test__fixtfdi(-0.99, 0);
47 test__fixtfdi(-0.5, 0);47 try test__fixtfdi(-0.5, 0);
48 test__fixtfdi(-math.f64_min, 0);48 try test__fixtfdi(-math.f64_min, 0);
49 test__fixtfdi(0.0, 0);49 try test__fixtfdi(0.0, 0);
50 test__fixtfdi(math.f64_min, 0);50 try test__fixtfdi(math.f64_min, 0);
51 test__fixtfdi(0.5, 0);51 try test__fixtfdi(0.5, 0);
52 test__fixtfdi(0.99, 0);52 try test__fixtfdi(0.99, 0);
53 test__fixtfdi(1.0, 1);53 try test__fixtfdi(1.0, 1);
54 test__fixtfdi(1.5, 1);54 try test__fixtfdi(1.5, 1);
55 test__fixtfdi(1.99, 1);55 try test__fixtfdi(1.99, 1);
56 test__fixtfdi(2.0, 2);56 try test__fixtfdi(2.0, 2);
57 test__fixtfdi(2.01, 2);57 try test__fixtfdi(2.01, 2);
5858
59 test__fixtfdi(0x1.FFFFFCp+30, 0x7FFFFF00);59 try test__fixtfdi(0x1.FFFFFCp+30, 0x7FFFFF00);
60 test__fixtfdi(0x1.FFFFFEp+30, 0x7FFFFF80);60 try test__fixtfdi(0x1.FFFFFEp+30, 0x7FFFFF80);
61 test__fixtfdi(0x1.FFFFFFp+30, 0x7FFFFFC0);61 try test__fixtfdi(0x1.FFFFFFp+30, 0x7FFFFFC0);
62 test__fixtfdi(0x1.000000p+31, 0x80000000);62 try test__fixtfdi(0x1.000000p+31, 0x80000000);
6363
64 test__fixtfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);64 try test__fixtfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
65 test__fixtfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);65 try test__fixtfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
6666
67 test__fixtfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);67 try test__fixtfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
68 test__fixtfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);68 try test__fixtfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
69 test__fixtfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);69 try test__fixtfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
70 test__fixtfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);70 try test__fixtfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
7171
72 test__fixtfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);72 try test__fixtfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
73 test__fixtfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);73 try test__fixtfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
74 test__fixtfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);74 try test__fixtfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
7575
76 test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);76 try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
77 test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));77 try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
7878
79 test__fixtfdi(math.f128_max, math.maxInt(i64));79 try test__fixtfdi(math.f128_max, math.maxInt(i64));
80}80}
lib/std/special/compiler_rt/fixtfsi_test.zig+49-49
...@@ -9,7 +9,7 @@ const math = std.math;...@@ -9,7 +9,7 @@ const math = std.math;
9const testing = std.testing;9const testing = std.testing;
10const warn = std.debug.warn;10const warn = std.debug.warn;
1111
12fn test__fixtfsi(a: f128, expected: i32) void {12fn test__fixtfsi(a: f128, expected: i32) !void {
13 const x = __fixtfsi(a);13 const x = __fixtfsi(a);
14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u32, expected)});14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u32, expected)});
15 try testing.expect(x == expected);15 try testing.expect(x == expected);
...@@ -17,64 +17,64 @@ fn test__fixtfsi(a: f128, expected: i32) void {...@@ -17,64 +17,64 @@ fn test__fixtfsi(a: f128, expected: i32) void {
1717
18test "fixtfsi" {18test "fixtfsi" {
19 //warn("\n", .{});19 //warn("\n", .{});
20 test__fixtfsi(-math.f128_max, math.minInt(i32));20 try test__fixtfsi(-math.f128_max, math.minInt(i32));
2121
22 test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));22 try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
23 test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);23 try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
2424
25 test__fixtfsi(-0x1.0000000000000p+127, -0x80000000);25 try test__fixtfsi(-0x1.0000000000000p+127, -0x80000000);
26 test__fixtfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);26 try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
27 test__fixtfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);27 try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
2828
29 test__fixtfsi(-0x1.0000000000001p+63, -0x80000000);29 try test__fixtfsi(-0x1.0000000000001p+63, -0x80000000);
30 test__fixtfsi(-0x1.0000000000000p+63, -0x80000000);30 try test__fixtfsi(-0x1.0000000000000p+63, -0x80000000);
31 test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);31 try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
32 test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);32 try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
3333
34 test__fixtfsi(-0x1.FFFFFEp+62, -0x80000000);34 try test__fixtfsi(-0x1.FFFFFEp+62, -0x80000000);
35 test__fixtfsi(-0x1.FFFFFCp+62, -0x80000000);35 try test__fixtfsi(-0x1.FFFFFCp+62, -0x80000000);
3636
37 test__fixtfsi(-0x1.000000p+31, -0x80000000);37 try test__fixtfsi(-0x1.000000p+31, -0x80000000);
38 test__fixtfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);38 try test__fixtfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
39 test__fixtfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);39 try test__fixtfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
40 test__fixtfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);40 try test__fixtfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
4141
42 test__fixtfsi(-2.01, -2);42 try test__fixtfsi(-2.01, -2);
43 test__fixtfsi(-2.0, -2);43 try test__fixtfsi(-2.0, -2);
44 test__fixtfsi(-1.99, -1);44 try test__fixtfsi(-1.99, -1);
45 test__fixtfsi(-1.0, -1);45 try test__fixtfsi(-1.0, -1);
46 test__fixtfsi(-0.99, 0);46 try test__fixtfsi(-0.99, 0);
47 test__fixtfsi(-0.5, 0);47 try test__fixtfsi(-0.5, 0);
48 test__fixtfsi(-math.f32_min, 0);48 try test__fixtfsi(-math.f32_min, 0);
49 test__fixtfsi(0.0, 0);49 try test__fixtfsi(0.0, 0);
50 test__fixtfsi(math.f32_min, 0);50 try test__fixtfsi(math.f32_min, 0);
51 test__fixtfsi(0.5, 0);51 try test__fixtfsi(0.5, 0);
52 test__fixtfsi(0.99, 0);52 try test__fixtfsi(0.99, 0);
53 test__fixtfsi(1.0, 1);53 try test__fixtfsi(1.0, 1);
54 test__fixtfsi(1.5, 1);54 try test__fixtfsi(1.5, 1);
55 test__fixtfsi(1.99, 1);55 try test__fixtfsi(1.99, 1);
56 test__fixtfsi(2.0, 2);56 try test__fixtfsi(2.0, 2);
57 test__fixtfsi(2.01, 2);57 try test__fixtfsi(2.01, 2);
5858
59 test__fixtfsi(0x1.FFFFFCp+30, 0x7FFFFF00);59 try test__fixtfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
60 test__fixtfsi(0x1.FFFFFEp+30, 0x7FFFFF80);60 try test__fixtfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
61 test__fixtfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);61 try test__fixtfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
62 test__fixtfsi(0x1.000000p+31, 0x7FFFFFFF);62 try test__fixtfsi(0x1.000000p+31, 0x7FFFFFFF);
6363
64 test__fixtfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);64 try test__fixtfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
65 test__fixtfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);65 try test__fixtfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
6666
67 test__fixtfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);67 try test__fixtfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
68 test__fixtfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);68 try test__fixtfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
69 test__fixtfsi(0x1.0000000000000p+63, 0x7FFFFFFF);69 try test__fixtfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
70 test__fixtfsi(0x1.0000000000001p+63, 0x7FFFFFFF);70 try test__fixtfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
7171
72 test__fixtfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);72 try test__fixtfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
73 test__fixtfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);73 try test__fixtfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
74 test__fixtfsi(0x1.0000000000000p+127, 0x7FFFFFFF);74 try test__fixtfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
7575
76 test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);76 try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
77 test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));77 try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
7878
79 test__fixtfsi(math.f128_max, math.maxInt(i32));79 try test__fixtfsi(math.f128_max, math.maxInt(i32));
80}80}
lib/std/special/compiler_rt/fixtfti_test.zig+41-41
...@@ -9,7 +9,7 @@ const math = std.math;...@@ -9,7 +9,7 @@ const math = std.math;
9const testing = std.testing;9const testing = std.testing;
10const warn = std.debug.warn;10const warn = std.debug.warn;
1111
12fn test__fixtfti(a: f128, expected: i128) void {12fn test__fixtfti(a: f128, expected: i128) !void {
13 const x = __fixtfti(a);13 const x = __fixtfti(a);
14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u128, expected)});14 //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u128, expected)});
15 try testing.expect(x == expected);15 try testing.expect(x == expected);
...@@ -17,54 +17,54 @@ fn test__fixtfti(a: f128, expected: i128) void {...@@ -17,54 +17,54 @@ fn test__fixtfti(a: f128, expected: i128) void {
1717
18test "fixtfti" {18test "fixtfti" {
19 //warn("\n", .{});19 //warn("\n", .{});
20 test__fixtfti(-math.f128_max, math.minInt(i128));20 try test__fixtfti(-math.f128_max, math.minInt(i128));
2121
22 test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));22 try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
23 test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);23 try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
2424
25 test__fixtfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);25 try test__fixtfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
26 test__fixtfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);26 try test__fixtfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
27 test__fixtfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);27 try test__fixtfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
2828
29 test__fixtfti(-0x1.0000000000001p+63, -0x8000000000000800);29 try test__fixtfti(-0x1.0000000000001p+63, -0x8000000000000800);
30 test__fixtfti(-0x1.0000000000000p+63, -0x8000000000000000);30 try test__fixtfti(-0x1.0000000000000p+63, -0x8000000000000000);
31 test__fixtfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);31 try test__fixtfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
32 test__fixtfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);32 try test__fixtfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
3333
34 test__fixtfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);34 try test__fixtfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
35 test__fixtfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);35 try test__fixtfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
3636
37 test__fixtfti(-2.01, -2);37 try test__fixtfti(-2.01, -2);
38 test__fixtfti(-2.0, -2);38 try test__fixtfti(-2.0, -2);
39 test__fixtfti(-1.99, -1);39 try test__fixtfti(-1.99, -1);
40 test__fixtfti(-1.0, -1);40 try test__fixtfti(-1.0, -1);
41 test__fixtfti(-0.99, 0);41 try test__fixtfti(-0.99, 0);
42 test__fixtfti(-0.5, 0);42 try test__fixtfti(-0.5, 0);
43 test__fixtfti(-math.f128_min, 0);43 try test__fixtfti(-math.f128_min, 0);
44 test__fixtfti(0.0, 0);44 try test__fixtfti(0.0, 0);
45 test__fixtfti(math.f128_min, 0);45 try test__fixtfti(math.f128_min, 0);
46 test__fixtfti(0.5, 0);46 try test__fixtfti(0.5, 0);
47 test__fixtfti(0.99, 0);47 try test__fixtfti(0.99, 0);
48 test__fixtfti(1.0, 1);48 try test__fixtfti(1.0, 1);
49 test__fixtfti(1.5, 1);49 try test__fixtfti(1.5, 1);
50 test__fixtfti(1.99, 1);50 try test__fixtfti(1.99, 1);
51 test__fixtfti(2.0, 2);51 try test__fixtfti(2.0, 2);
52 test__fixtfti(2.01, 2);52 try test__fixtfti(2.01, 2);
5353
54 test__fixtfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);54 try test__fixtfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
55 test__fixtfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);55 try test__fixtfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
5656
57 test__fixtfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);57 try test__fixtfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
58 test__fixtfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);58 try test__fixtfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
59 test__fixtfti(0x1.0000000000000p+63, 0x8000000000000000);59 try test__fixtfti(0x1.0000000000000p+63, 0x8000000000000000);
60 test__fixtfti(0x1.0000000000001p+63, 0x8000000000000800);60 try test__fixtfti(0x1.0000000000001p+63, 0x8000000000000800);
6161
62 test__fixtfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);62 try test__fixtfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
63 test__fixtfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);63 try test__fixtfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
64 test__fixtfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);64 try test__fixtfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
6565
66 test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);66 try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
67 test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));67 try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
6868
69 test__fixtfti(math.f128_max, math.maxInt(i128));69 try test__fixtfti(math.f128_max, math.maxInt(i128));
70}70}
lib/std/special/compiler_rt/fixunsdfdi_test.zig+23-23
...@@ -6,7 +6,7 @@...@@ -6,7 +6,7 @@
6const __fixunsdfdi = @import("fixunsdfdi.zig").__fixunsdfdi;6const __fixunsdfdi = @import("fixunsdfdi.zig").__fixunsdfdi;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__fixunsdfdi(a: f64, expected: u64) void {9fn test__fixunsdfdi(a: f64, expected: u64) !void {
10 const x = __fixunsdfdi(a);10 const x = __fixunsdfdi(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
...@@ -15,30 +15,30 @@ test "fixunsdfdi" {...@@ -15,30 +15,30 @@ test "fixunsdfdi" {
15 //test__fixunsdfdi(0.0, 0);15 //test__fixunsdfdi(0.0, 0);
16 //test__fixunsdfdi(0.5, 0);16 //test__fixunsdfdi(0.5, 0);
17 //test__fixunsdfdi(0.99, 0);17 //test__fixunsdfdi(0.99, 0);
18 test__fixunsdfdi(1.0, 1);18 try test__fixunsdfdi(1.0, 1);
19 test__fixunsdfdi(1.5, 1);19 try test__fixunsdfdi(1.5, 1);
20 test__fixunsdfdi(1.99, 1);20 try test__fixunsdfdi(1.99, 1);
21 test__fixunsdfdi(2.0, 2);21 try test__fixunsdfdi(2.0, 2);
22 test__fixunsdfdi(2.01, 2);22 try test__fixunsdfdi(2.01, 2);
23 test__fixunsdfdi(-0.5, 0);23 try test__fixunsdfdi(-0.5, 0);
24 test__fixunsdfdi(-0.99, 0);24 try test__fixunsdfdi(-0.99, 0);
25 test__fixunsdfdi(-1.0, 0);25 try test__fixunsdfdi(-1.0, 0);
26 test__fixunsdfdi(-1.5, 0);26 try test__fixunsdfdi(-1.5, 0);
27 test__fixunsdfdi(-1.99, 0);27 try test__fixunsdfdi(-1.99, 0);
28 test__fixunsdfdi(-2.0, 0);28 try test__fixunsdfdi(-2.0, 0);
29 test__fixunsdfdi(-2.01, 0);29 try test__fixunsdfdi(-2.01, 0);
3030
31 test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);31 try test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
32 test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);32 try test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
3333
34 test__fixunsdfdi(-0x1.FFFFFEp+62, 0);34 try test__fixunsdfdi(-0x1.FFFFFEp+62, 0);
35 test__fixunsdfdi(-0x1.FFFFFCp+62, 0);35 try test__fixunsdfdi(-0x1.FFFFFCp+62, 0);
3636
37 test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);37 try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
38 test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000);38 try test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000);
39 test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);39 try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
40 test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);40 try test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
4141
42 test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0);42 try test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
43 test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0);43 try test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
44}44}
lib/std/special/compiler_rt/fixunsdfsi_test.zig+26-26
...@@ -6,39 +6,39 @@...@@ -6,39 +6,39 @@
6const __fixunsdfsi = @import("fixunsdfsi.zig").__fixunsdfsi;6const __fixunsdfsi = @import("fixunsdfsi.zig").__fixunsdfsi;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__fixunsdfsi(a: f64, expected: u32) void {9fn test__fixunsdfsi(a: f64, expected: u32) !void {
10 const x = __fixunsdfsi(a);10 const x = __fixunsdfsi(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "fixunsdfsi" {14test "fixunsdfsi" {
15 test__fixunsdfsi(0.0, 0);15 try test__fixunsdfsi(0.0, 0);
1616
17 test__fixunsdfsi(0.5, 0);17 try test__fixunsdfsi(0.5, 0);
18 test__fixunsdfsi(0.99, 0);18 try test__fixunsdfsi(0.99, 0);
19 test__fixunsdfsi(1.0, 1);19 try test__fixunsdfsi(1.0, 1);
20 test__fixunsdfsi(1.5, 1);20 try test__fixunsdfsi(1.5, 1);
21 test__fixunsdfsi(1.99, 1);21 try test__fixunsdfsi(1.99, 1);
22 test__fixunsdfsi(2.0, 2);22 try test__fixunsdfsi(2.0, 2);
23 test__fixunsdfsi(2.01, 2);23 try test__fixunsdfsi(2.01, 2);
24 test__fixunsdfsi(-0.5, 0);24 try test__fixunsdfsi(-0.5, 0);
25 test__fixunsdfsi(-0.99, 0);25 try test__fixunsdfsi(-0.99, 0);
26 test__fixunsdfsi(-1.0, 0);26 try test__fixunsdfsi(-1.0, 0);
27 test__fixunsdfsi(-1.5, 0);27 try test__fixunsdfsi(-1.5, 0);
28 test__fixunsdfsi(-1.99, 0);28 try test__fixunsdfsi(-1.99, 0);
29 test__fixunsdfsi(-2.0, 0);29 try test__fixunsdfsi(-2.0, 0);
30 test__fixunsdfsi(-2.01, 0);30 try test__fixunsdfsi(-2.01, 0);
3131
32 test__fixunsdfsi(0x1.000000p+31, 0x80000000);32 try test__fixunsdfsi(0x1.000000p+31, 0x80000000);
33 test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF);33 try test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF);
34 test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00);34 try test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
35 test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);35 try test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
36 test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00);36 try test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
3737
38 test__fixunsdfsi(-0x1.FFFFFEp+30, 0);38 try test__fixunsdfsi(-0x1.FFFFFEp+30, 0);
39 test__fixunsdfsi(-0x1.FFFFFCp+30, 0);39 try test__fixunsdfsi(-0x1.FFFFFCp+30, 0);
4040
41 test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF);41 try test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF);
42 test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF);42 try test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF);
43 test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE);43 try test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE);
44}44}
lib/std/special/compiler_rt/fixunsdfti_test.zig+37-37
...@@ -6,46 +6,46 @@...@@ -6,46 +6,46 @@
6const __fixunsdfti = @import("fixunsdfti.zig").__fixunsdfti;6const __fixunsdfti = @import("fixunsdfti.zig").__fixunsdfti;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__fixunsdfti(a: f64, expected: u128) void {9fn test__fixunsdfti(a: f64, expected: u128) !void {
10 const x = __fixunsdfti(a);10 const x = __fixunsdfti(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "fixunsdfti" {14test "fixunsdfti" {
15 test__fixunsdfti(0.0, 0);15 try test__fixunsdfti(0.0, 0);
1616
17 test__fixunsdfti(0.5, 0);17 try test__fixunsdfti(0.5, 0);
18 test__fixunsdfti(0.99, 0);18 try test__fixunsdfti(0.99, 0);
19 test__fixunsdfti(1.0, 1);19 try test__fixunsdfti(1.0, 1);
20 test__fixunsdfti(1.5, 1);20 try test__fixunsdfti(1.5, 1);
21 test__fixunsdfti(1.99, 1);21 try test__fixunsdfti(1.99, 1);
22 test__fixunsdfti(2.0, 2);22 try test__fixunsdfti(2.0, 2);
23 test__fixunsdfti(2.01, 2);23 try test__fixunsdfti(2.01, 2);
24 test__fixunsdfti(-0.5, 0);24 try test__fixunsdfti(-0.5, 0);
25 test__fixunsdfti(-0.99, 0);25 try test__fixunsdfti(-0.99, 0);
26 test__fixunsdfti(-1.0, 0);26 try test__fixunsdfti(-1.0, 0);
27 test__fixunsdfti(-1.5, 0);27 try test__fixunsdfti(-1.5, 0);
28 test__fixunsdfti(-1.99, 0);28 try test__fixunsdfti(-1.99, 0);
29 test__fixunsdfti(-2.0, 0);29 try test__fixunsdfti(-2.0, 0);
30 test__fixunsdfti(-2.01, 0);30 try test__fixunsdfti(-2.01, 0);
3131
32 test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);32 try test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
33 test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);33 try test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
3434
35 test__fixunsdfti(-0x1.FFFFFEp+62, 0);35 try test__fixunsdfti(-0x1.FFFFFEp+62, 0);
36 test__fixunsdfti(-0x1.FFFFFCp+62, 0);36 try test__fixunsdfti(-0x1.FFFFFCp+62, 0);
3737
38 test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);38 try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
39 test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000);39 try test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000);
40 test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);40 try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
41 test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);41 try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
4242
43 test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000);43 try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000);
44 test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000);44 try test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000);
45 test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);45 try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
46 test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);46 try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
47 test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);47 try test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
4848
49 test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0);49 try test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0);
50 test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0);50 try test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0);
51}51}
lib/std/special/compiler_rt/fixunssfdi_test.zig+22-22
...@@ -6,35 +6,35 @@...@@ -6,35 +6,35 @@
6const __fixunssfdi = @import("fixunssfdi.zig").__fixunssfdi;6const __fixunssfdi = @import("fixunssfdi.zig").__fixunssfdi;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__fixunssfdi(a: f32, expected: u64) void {9fn test__fixunssfdi(a: f32, expected: u64) !void {
10 const x = __fixunssfdi(a);10 const x = __fixunssfdi(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "fixunssfdi" {14test "fixunssfdi" {
15 test__fixunssfdi(0.0, 0);15 try test__fixunssfdi(0.0, 0);
1616
17 test__fixunssfdi(0.5, 0);17 try test__fixunssfdi(0.5, 0);
18 test__fixunssfdi(0.99, 0);18 try test__fixunssfdi(0.99, 0);
19 test__fixunssfdi(1.0, 1);19 try test__fixunssfdi(1.0, 1);
20 test__fixunssfdi(1.5, 1);20 try test__fixunssfdi(1.5, 1);
21 test__fixunssfdi(1.99, 1);21 try test__fixunssfdi(1.99, 1);
22 test__fixunssfdi(2.0, 2);22 try test__fixunssfdi(2.0, 2);
23 test__fixunssfdi(2.01, 2);23 try test__fixunssfdi(2.01, 2);
24 test__fixunssfdi(-0.5, 0);24 try test__fixunssfdi(-0.5, 0);
25 test__fixunssfdi(-0.99, 0);25 try test__fixunssfdi(-0.99, 0);
2626
27 test__fixunssfdi(-1.0, 0);27 try test__fixunssfdi(-1.0, 0);
28 test__fixunssfdi(-1.5, 0);28 try test__fixunssfdi(-1.5, 0);
29 test__fixunssfdi(-1.99, 0);29 try test__fixunssfdi(-1.99, 0);
30 test__fixunssfdi(-2.0, 0);30 try test__fixunssfdi(-2.0, 0);
31 test__fixunssfdi(-2.01, 0);31 try test__fixunssfdi(-2.01, 0);
3232
33 test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000);33 try test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
34 test__fixunssfdi(0x1.000000p+63, 0x8000000000000000);34 try test__fixunssfdi(0x1.000000p+63, 0x8000000000000000);
35 test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);35 try test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
36 test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);36 try test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
3737
38 test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000);38 try test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000);
39 test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000);39 try test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000);
40}40}
lib/std/special/compiler_rt/fixunssfsi_test.zig+23-23
...@@ -6,36 +6,36 @@...@@ -6,36 +6,36 @@
6const __fixunssfsi = @import("fixunssfsi.zig").__fixunssfsi;6const __fixunssfsi = @import("fixunssfsi.zig").__fixunssfsi;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__fixunssfsi(a: f32, expected: u32) void {9fn test__fixunssfsi(a: f32, expected: u32) !void {
10 const x = __fixunssfsi(a);10 const x = __fixunssfsi(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "fixunssfsi" {14test "fixunssfsi" {
15 test__fixunssfsi(0.0, 0);15 try test__fixunssfsi(0.0, 0);
1616
17 test__fixunssfsi(0.5, 0);17 try test__fixunssfsi(0.5, 0);
18 test__fixunssfsi(0.99, 0);18 try test__fixunssfsi(0.99, 0);
19 test__fixunssfsi(1.0, 1);19 try test__fixunssfsi(1.0, 1);
20 test__fixunssfsi(1.5, 1);20 try test__fixunssfsi(1.5, 1);
21 test__fixunssfsi(1.99, 1);21 try test__fixunssfsi(1.99, 1);
22 test__fixunssfsi(2.0, 2);22 try test__fixunssfsi(2.0, 2);
23 test__fixunssfsi(2.01, 2);23 try test__fixunssfsi(2.01, 2);
24 test__fixunssfsi(-0.5, 0);24 try test__fixunssfsi(-0.5, 0);
25 test__fixunssfsi(-0.99, 0);25 try test__fixunssfsi(-0.99, 0);
2626
27 test__fixunssfsi(-1.0, 0);27 try test__fixunssfsi(-1.0, 0);
28 test__fixunssfsi(-1.5, 0);28 try test__fixunssfsi(-1.5, 0);
29 test__fixunssfsi(-1.99, 0);29 try test__fixunssfsi(-1.99, 0);
30 test__fixunssfsi(-2.0, 0);30 try test__fixunssfsi(-2.0, 0);
31 test__fixunssfsi(-2.01, 0);31 try test__fixunssfsi(-2.01, 0);
3232
33 test__fixunssfsi(0x1.000000p+31, 0x80000000);33 try test__fixunssfsi(0x1.000000p+31, 0x80000000);
34 test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF);34 try test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF);
35 test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00);35 try test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
36 test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80);36 try test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
37 test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00);37 try test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
3838
39 test__fixunssfsi(-0x1.FFFFFEp+30, 0);39 try test__fixunssfsi(-0x1.FFFFFEp+30, 0);
40 test__fixunssfsi(-0x1.FFFFFCp+30, 0);40 try test__fixunssfsi(-0x1.FFFFFCp+30, 0);
41}41}
lib/std/special/compiler_rt/fixunssfti_test.zig+28-28
...@@ -6,41 +6,41 @@...@@ -6,41 +6,41 @@
6const __fixunssfti = @import("fixunssfti.zig").__fixunssfti;6const __fixunssfti = @import("fixunssfti.zig").__fixunssfti;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__fixunssfti(a: f32, expected: u128) void {9fn test__fixunssfti(a: f32, expected: u128) !void {
10 const x = __fixunssfti(a);10 const x = __fixunssfti(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "fixunssfti" {14test "fixunssfti" {
15 test__fixunssfti(0.0, 0);15 try test__fixunssfti(0.0, 0);
1616
17 test__fixunssfti(0.5, 0);17 try test__fixunssfti(0.5, 0);
18 test__fixunssfti(0.99, 0);18 try test__fixunssfti(0.99, 0);
19 test__fixunssfti(1.0, 1);19 try test__fixunssfti(1.0, 1);
20 test__fixunssfti(1.5, 1);20 try test__fixunssfti(1.5, 1);
21 test__fixunssfti(1.99, 1);21 try test__fixunssfti(1.99, 1);
22 test__fixunssfti(2.0, 2);22 try test__fixunssfti(2.0, 2);
23 test__fixunssfti(2.01, 2);23 try test__fixunssfti(2.01, 2);
24 test__fixunssfti(-0.5, 0);24 try test__fixunssfti(-0.5, 0);
25 test__fixunssfti(-0.99, 0);25 try test__fixunssfti(-0.99, 0);
2626
27 test__fixunssfti(-1.0, 0);27 try test__fixunssfti(-1.0, 0);
28 test__fixunssfti(-1.5, 0);28 try test__fixunssfti(-1.5, 0);
29 test__fixunssfti(-1.99, 0);29 try test__fixunssfti(-1.99, 0);
30 test__fixunssfti(-2.0, 0);30 try test__fixunssfti(-2.0, 0);
31 test__fixunssfti(-2.01, 0);31 try test__fixunssfti(-2.01, 0);
3232
33 test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000);33 try test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
34 test__fixunssfti(0x1.000000p+63, 0x8000000000000000);34 try test__fixunssfti(0x1.000000p+63, 0x8000000000000000);
35 test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);35 try test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
36 test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);36 try test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
37 test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000);37 try test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000);
38 test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000);38 try test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000);
39 test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000);39 try test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000);
40 test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000);40 try test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000);
4141
42 test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000);42 try test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000);
43 test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000);43 try test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000);
44 test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000);44 try test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000);
45 test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000);45 try test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000);
46}46}
lib/std/special/compiler_rt/fixunstfdi_test.zig+40-40
...@@ -6,49 +6,49 @@...@@ -6,49 +6,49 @@
6const __fixunstfdi = @import("fixunstfdi.zig").__fixunstfdi;6const __fixunstfdi = @import("fixunstfdi.zig").__fixunstfdi;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__fixunstfdi(a: f128, expected: u64) void {9fn test__fixunstfdi(a: f128, expected: u64) !void {
10 const x = __fixunstfdi(a);10 const x = __fixunstfdi(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "fixunstfdi" {14test "fixunstfdi" {
15 test__fixunstfdi(0.0, 0);15 try test__fixunstfdi(0.0, 0);
1616
17 test__fixunstfdi(0.5, 0);17 try test__fixunstfdi(0.5, 0);
18 test__fixunstfdi(0.99, 0);18 try test__fixunstfdi(0.99, 0);
19 test__fixunstfdi(1.0, 1);19 try test__fixunstfdi(1.0, 1);
20 test__fixunstfdi(1.5, 1);20 try test__fixunstfdi(1.5, 1);
21 test__fixunstfdi(1.99, 1);21 try test__fixunstfdi(1.99, 1);
22 test__fixunstfdi(2.0, 2);22 try test__fixunstfdi(2.0, 2);
23 test__fixunstfdi(2.01, 2);23 try test__fixunstfdi(2.01, 2);
24 test__fixunstfdi(-0.5, 0);24 try test__fixunstfdi(-0.5, 0);
25 test__fixunstfdi(-0.99, 0);25 try test__fixunstfdi(-0.99, 0);
26 test__fixunstfdi(-1.0, 0);26 try test__fixunstfdi(-1.0, 0);
27 test__fixunstfdi(-1.5, 0);27 try test__fixunstfdi(-1.5, 0);
28 test__fixunstfdi(-1.99, 0);28 try test__fixunstfdi(-1.99, 0);
29 test__fixunstfdi(-2.0, 0);29 try test__fixunstfdi(-2.0, 0);
30 test__fixunstfdi(-2.01, 0);30 try test__fixunstfdi(-2.01, 0);
3131
32 test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);32 try test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
33 test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);33 try test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
3434
35 test__fixunstfdi(-0x1.FFFFFEp+62, 0);35 try test__fixunstfdi(-0x1.FFFFFEp+62, 0);
36 test__fixunstfdi(-0x1.FFFFFCp+62, 0);36 try test__fixunstfdi(-0x1.FFFFFCp+62, 0);
3737
38 test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);38 try test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
39 test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);39 try test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
4040
41 test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0);41 try test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
42 test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0);42 try test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
4343
44 test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF);44 try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF);
45 test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001);45 try test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001);
46 test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000);46 try test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000);
47 test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF);47 try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF);
48 test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE);48 try test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE);
49 test__fixunstfdi(0x1.p+64, 0xFFFFFFFFFFFFFFFF);49 try test__fixunstfdi(0x1.p+64, 0xFFFFFFFFFFFFFFFF);
5050
51 test__fixunstfdi(-0x1.0000000000000000p+63, 0);51 try test__fixunstfdi(-0x1.0000000000000000p+63, 0);
52 test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0);52 try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0);
53 test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0);53 try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0);
54}54}
lib/std/special/compiler_rt/fixunstfsi_test.zig+10-10
...@@ -6,7 +6,7 @@...@@ -6,7 +6,7 @@
6const __fixunstfsi = @import("fixunstfsi.zig").__fixunstfsi;6const __fixunstfsi = @import("fixunstfsi.zig").__fixunstfsi;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__fixunstfsi(a: f128, expected: u32) void {9fn test__fixunstfsi(a: f128, expected: u32) !void {
10 const x = __fixunstfsi(a);10 const x = __fixunstfsi(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
...@@ -14,14 +14,14 @@ fn test__fixunstfsi(a: f128, expected: u32) void {...@@ -14,14 +14,14 @@ fn test__fixunstfsi(a: f128, expected: u32) void {
14const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000));14const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000));
1515
16test "fixunstfsi" {16test "fixunstfsi" {
17 test__fixunstfsi(inf128, 0xffffffff);17 try test__fixunstfsi(inf128, 0xffffffff);
18 test__fixunstfsi(0, 0x0);18 try test__fixunstfsi(0, 0x0);
19 test__fixunstfsi(0x1.23456789abcdefp+5, 0x24);19 try test__fixunstfsi(0x1.23456789abcdefp+5, 0x24);
20 test__fixunstfsi(0x1.23456789abcdefp-3, 0x0);20 try test__fixunstfsi(0x1.23456789abcdefp-3, 0x0);
21 test__fixunstfsi(0x1.23456789abcdefp+20, 0x123456);21 try test__fixunstfsi(0x1.23456789abcdefp+20, 0x123456);
22 test__fixunstfsi(0x1.23456789abcdefp+40, 0xffffffff);22 try test__fixunstfsi(0x1.23456789abcdefp+40, 0xffffffff);
23 test__fixunstfsi(0x1.23456789abcdefp+256, 0xffffffff);23 try test__fixunstfsi(0x1.23456789abcdefp+256, 0xffffffff);
24 test__fixunstfsi(-0x1.23456789abcdefp+3, 0x0);24 try test__fixunstfsi(-0x1.23456789abcdefp+3, 0x0);
2525
26 test__fixunstfsi(0x1.p+32, 0xFFFFFFFF);26 try test__fixunstfsi(0x1.p+32, 0xFFFFFFFF);
27}27}
lib/std/special/compiler_rt/fixunstfti_test.zig+17-17
...@@ -6,7 +6,7 @@...@@ -6,7 +6,7 @@
6const __fixunstfti = @import("fixunstfti.zig").__fixunstfti;6const __fixunstfti = @import("fixunstfti.zig").__fixunstfti;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__fixunstfti(a: f128, expected: u128) void {9fn test__fixunstfti(a: f128, expected: u128) !void {
10 const x = __fixunstfti(a);10 const x = __fixunstfti(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
...@@ -14,24 +14,24 @@ fn test__fixunstfti(a: f128, expected: u128) void {...@@ -14,24 +14,24 @@ fn test__fixunstfti(a: f128, expected: u128) void {
14const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000));14const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000));
1515
16test "fixunstfti" {16test "fixunstfti" {
17 test__fixunstfti(inf128, 0xffffffffffffffffffffffffffffffff);17 try test__fixunstfti(inf128, 0xffffffffffffffffffffffffffffffff);
1818
19 test__fixunstfti(0.0, 0);19 try test__fixunstfti(0.0, 0);
2020
21 test__fixunstfti(0.5, 0);21 try test__fixunstfti(0.5, 0);
22 test__fixunstfti(0.99, 0);22 try test__fixunstfti(0.99, 0);
23 test__fixunstfti(1.0, 1);23 try test__fixunstfti(1.0, 1);
24 test__fixunstfti(1.5, 1);24 try test__fixunstfti(1.5, 1);
25 test__fixunstfti(1.99, 1);25 try test__fixunstfti(1.99, 1);
26 test__fixunstfti(2.0, 2);26 try test__fixunstfti(2.0, 2);
27 test__fixunstfti(2.01, 2);27 try test__fixunstfti(2.01, 2);
28 test__fixunstfti(-0.01, 0);28 try test__fixunstfti(-0.01, 0);
29 test__fixunstfti(-0.99, 0);29 try test__fixunstfti(-0.99, 0);
3030
31 test__fixunstfti(0x1.p+128, 0xffffffffffffffffffffffffffffffff);31 try test__fixunstfti(0x1.p+128, 0xffffffffffffffffffffffffffffffff);
3232
33 test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000);33 try test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000);
34 test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000);34 try test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000);
35 test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff);35 try test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff);
36 test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff);36 try test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff);
37}37}
lib/std/special/compiler_rt/floatdidf_test.zig+44-44
...@@ -6,53 +6,53 @@...@@ -6,53 +6,53 @@
6const __floatdidf = @import("floatdidf.zig").__floatdidf;6const __floatdidf = @import("floatdidf.zig").__floatdidf;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__floatdidf(a: i64, expected: f64) void {9fn test__floatdidf(a: i64, expected: f64) !void {
10 const r = __floatdidf(a);10 const r = __floatdidf(a);
11 try testing.expect(r == expected);11 try testing.expect(r == expected);
12}12}
1313
14test "floatdidf" {14test "floatdidf" {
15 test__floatdidf(0, 0.0);15 try test__floatdidf(0, 0.0);
16 test__floatdidf(1, 1.0);16 try test__floatdidf(1, 1.0);
17 test__floatdidf(2, 2.0);17 try test__floatdidf(2, 2.0);
18 test__floatdidf(20, 20.0);18 try test__floatdidf(20, 20.0);
19 test__floatdidf(-1, -1.0);19 try test__floatdidf(-1, -1.0);
20 test__floatdidf(-2, -2.0);20 try test__floatdidf(-2, -2.0);
21 test__floatdidf(-20, -20.0);21 try test__floatdidf(-20, -20.0);
22 test__floatdidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);22 try test__floatdidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
23 test__floatdidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);23 try test__floatdidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
24 test__floatdidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);24 try test__floatdidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
25 test__floatdidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);25 try test__floatdidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
26 test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000008000000000)), -0x1.FFFFFEp+62);26 try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000008000000000)), -0x1.FFFFFEp+62);
27 test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000800)), -0x1.FFFFFFFFFFFFEp+62);27 try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000800)), -0x1.FFFFFFFFFFFFEp+62);
28 test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000010000000000)), -0x1.FFFFFCp+62);28 try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000010000000000)), -0x1.FFFFFCp+62);
29 test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000001000)), -0x1.FFFFFFFFFFFFCp+62);29 try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000001000)), -0x1.FFFFFFFFFFFFCp+62);
30 test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000000)), -0x1.000000p+63);30 try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000000)), -0x1.000000p+63);
31 test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000001)), -0x1.000000p+63);31 try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000001)), -0x1.000000p+63);
32 test__floatdidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);32 try test__floatdidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
33 test__floatdidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);33 try test__floatdidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
34 test__floatdidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);34 try test__floatdidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
35 test__floatdidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);35 try test__floatdidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
36 test__floatdidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);36 try test__floatdidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
37 test__floatdidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);37 try test__floatdidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
38 test__floatdidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);38 try test__floatdidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
39 test__floatdidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);39 try test__floatdidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
40 test__floatdidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);40 try test__floatdidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
41 test__floatdidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);41 try test__floatdidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
42 test__floatdidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);42 try test__floatdidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
43 test__floatdidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);43 try test__floatdidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
44 test__floatdidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);44 try test__floatdidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
45 test__floatdidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);45 try test__floatdidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
46 test__floatdidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);46 try test__floatdidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
47 test__floatdidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);47 try test__floatdidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
48 test__floatdidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);48 try test__floatdidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
49 test__floatdidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);49 try test__floatdidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
50 test__floatdidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);50 try test__floatdidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
51 test__floatdidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);51 try test__floatdidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
52 test__floatdidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);52 try test__floatdidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
53 test__floatdidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);53 try test__floatdidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
54 test__floatdidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);54 try test__floatdidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
55 test__floatdidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);55 try test__floatdidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
56 test__floatdidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);56 try test__floatdidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
57 test__floatdidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);57 try test__floatdidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
58}58}
lib/std/special/compiler_rt/floatdisf_test.zig+23-23
...@@ -6,32 +6,32 @@...@@ -6,32 +6,32 @@
6const __floatdisf = @import("floatXisf.zig").__floatdisf;6const __floatdisf = @import("floatXisf.zig").__floatdisf;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__floatdisf(a: i64, expected: f32) void {9fn test__floatdisf(a: i64, expected: f32) !void {
10 const x = __floatdisf(a);10 const x = __floatdisf(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "floatdisf" {14test "floatdisf" {
15 test__floatdisf(0, 0.0);15 try test__floatdisf(0, 0.0);
16 test__floatdisf(1, 1.0);16 try test__floatdisf(1, 1.0);
17 test__floatdisf(2, 2.0);17 try test__floatdisf(2, 2.0);
18 test__floatdisf(-1, -1.0);18 try test__floatdisf(-1, -1.0);
19 test__floatdisf(-2, -2.0);19 try test__floatdisf(-2, -2.0);
20 test__floatdisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);20 try test__floatdisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
21 test__floatdisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);21 try test__floatdisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
22 test__floatdisf(0x8000008000000000, -0x1.FFFFFEp+62);22 try test__floatdisf(0x8000008000000000, -0x1.FFFFFEp+62);
23 test__floatdisf(0x8000010000000000, -0x1.FFFFFCp+62);23 try test__floatdisf(0x8000010000000000, -0x1.FFFFFCp+62);
24 test__floatdisf(0x8000000000000000, -0x1.000000p+63);24 try test__floatdisf(0x8000000000000000, -0x1.000000p+63);
25 test__floatdisf(0x8000000000000001, -0x1.000000p+63);25 try test__floatdisf(0x8000000000000001, -0x1.000000p+63);
26 test__floatdisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);26 try test__floatdisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
27 test__floatdisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);27 try test__floatdisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
28 test__floatdisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);28 try test__floatdisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
29 test__floatdisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);29 try test__floatdisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
30 test__floatdisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);30 try test__floatdisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
31 test__floatdisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);31 try test__floatdisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
32 test__floatdisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);32 try test__floatdisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
33 test__floatdisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);33 try test__floatdisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
34 test__floatdisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);34 try test__floatdisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
35 test__floatdisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);35 try test__floatdisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
36 test__floatdisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);36 try test__floatdisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
37}37}
lib/std/special/compiler_rt/floatditf_test.zig+10-10
...@@ -6,21 +6,21 @@...@@ -6,21 +6,21 @@
6const __floatditf = @import("floatditf.zig").__floatditf;6const __floatditf = @import("floatditf.zig").__floatditf;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__floatditf(a: i64, expected: f128) void {9fn test__floatditf(a: i64, expected: f128) !void {
10 const x = __floatditf(a);10 const x = __floatditf(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "floatditf" {14test "floatditf" {
15 test__floatditf(0x7fffffffffffffff, make_ti(0x403dffffffffffff, 0xfffc000000000000));15 try test__floatditf(0x7fffffffffffffff, make_ti(0x403dffffffffffff, 0xfffc000000000000));
16 test__floatditf(0x123456789abcdef1, make_ti(0x403b23456789abcd, 0xef10000000000000));16 try test__floatditf(0x123456789abcdef1, make_ti(0x403b23456789abcd, 0xef10000000000000));
17 test__floatditf(0x2, make_ti(0x4000000000000000, 0x0));17 try test__floatditf(0x2, make_ti(0x4000000000000000, 0x0));
18 test__floatditf(0x1, make_ti(0x3fff000000000000, 0x0));18 try test__floatditf(0x1, make_ti(0x3fff000000000000, 0x0));
19 test__floatditf(0x0, make_ti(0x0, 0x0));19 try test__floatditf(0x0, make_ti(0x0, 0x0));
20 test__floatditf(@bitCast(i64, @as(u64, 0xffffffffffffffff)), make_ti(0xbfff000000000000, 0x0));20 try test__floatditf(@bitCast(i64, @as(u64, 0xffffffffffffffff)), make_ti(0xbfff000000000000, 0x0));
21 test__floatditf(@bitCast(i64, @as(u64, 0xfffffffffffffffe)), make_ti(0xc000000000000000, 0x0));21 try test__floatditf(@bitCast(i64, @as(u64, 0xfffffffffffffffe)), make_ti(0xc000000000000000, 0x0));
22 test__floatditf(-0x123456789abcdef1, make_ti(0xc03b23456789abcd, 0xef10000000000000));22 try test__floatditf(-0x123456789abcdef1, make_ti(0xc03b23456789abcd, 0xef10000000000000));
23 test__floatditf(@bitCast(i64, @as(u64, 0x8000000000000000)), make_ti(0xc03e000000000000, 0x0));23 try test__floatditf(@bitCast(i64, @as(u64, 0x8000000000000000)), make_ti(0xc03e000000000000, 0x0));
24}24}
2525
26fn make_ti(high: u64, low: u64) f128 {26fn make_ti(high: u64, low: u64) f128 {
lib/std/special/compiler_rt/floatsiXf.zig+19-19
...@@ -84,42 +84,42 @@ pub fn __aeabi_i2f(arg: i32) callconv(.AAPCS) f32 {...@@ -84,42 +84,42 @@ pub fn __aeabi_i2f(arg: i32) callconv(.AAPCS) f32 {
84 return @call(.{ .modifier = .always_inline }, __floatsisf, .{arg});84 return @call(.{ .modifier = .always_inline }, __floatsisf, .{arg});
85}85}
8686
87fn test_one_floatsitf(a: i32, expected: u128) void {87fn test_one_floatsitf(a: i32, expected: u128) !void {
88 const r = __floatsitf(a);88 const r = __floatsitf(a);
89 try std.testing.expect(@bitCast(u128, r) == expected);89 try std.testing.expect(@bitCast(u128, r) == expected);
90}90}
9191
92fn test_one_floatsidf(a: i32, expected: u64) void {92fn test_one_floatsidf(a: i32, expected: u64) !void {
93 const r = __floatsidf(a);93 const r = __floatsidf(a);
94 try std.testing.expect(@bitCast(u64, r) == expected);94 try std.testing.expect(@bitCast(u64, r) == expected);
95}95}
9696
97fn test_one_floatsisf(a: i32, expected: u32) void {97fn test_one_floatsisf(a: i32, expected: u32) !void {
98 const r = __floatsisf(a);98 const r = __floatsisf(a);
99 try std.testing.expect(@bitCast(u32, r) == expected);99 try std.testing.expect(@bitCast(u32, r) == expected);
100}100}
101101
102test "floatsidf" {102test "floatsidf" {
103 test_one_floatsidf(0, 0x0000000000000000);103 try test_one_floatsidf(0, 0x0000000000000000);
104 test_one_floatsidf(1, 0x3ff0000000000000);104 try test_one_floatsidf(1, 0x3ff0000000000000);
105 test_one_floatsidf(-1, 0xbff0000000000000);105 try test_one_floatsidf(-1, 0xbff0000000000000);
106 test_one_floatsidf(0x7FFFFFFF, 0x41dfffffffc00000);106 try test_one_floatsidf(0x7FFFFFFF, 0x41dfffffffc00000);
107 test_one_floatsidf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc1e0000000000000);107 try test_one_floatsidf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc1e0000000000000);
108}108}
109109
110test "floatsisf" {110test "floatsisf" {
111 test_one_floatsisf(0, 0x00000000);111 try test_one_floatsisf(0, 0x00000000);
112 test_one_floatsisf(1, 0x3f800000);112 try test_one_floatsisf(1, 0x3f800000);
113 test_one_floatsisf(-1, 0xbf800000);113 try test_one_floatsisf(-1, 0xbf800000);
114 test_one_floatsisf(0x7FFFFFFF, 0x4f000000);114 try test_one_floatsisf(0x7FFFFFFF, 0x4f000000);
115 test_one_floatsisf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xcf000000);115 try test_one_floatsisf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xcf000000);
116}116}
117117
118test "floatsitf" {118test "floatsitf" {
119 test_one_floatsitf(0, 0);119 try test_one_floatsitf(0, 0);
120 test_one_floatsitf(0x7FFFFFFF, 0x401dfffffffc00000000000000000000);120 try test_one_floatsitf(0x7FFFFFFF, 0x401dfffffffc00000000000000000000);
121 test_one_floatsitf(0x12345678, 0x401b2345678000000000000000000000);121 try test_one_floatsitf(0x12345678, 0x401b2345678000000000000000000000);
122 test_one_floatsitf(-0x12345678, 0xc01b2345678000000000000000000000);122 try test_one_floatsitf(-0x12345678, 0xc01b2345678000000000000000000000);
123 test_one_floatsitf(@bitCast(i32, @intCast(u32, 0xffffffff)), 0xbfff0000000000000000000000000000);123 try test_one_floatsitf(@bitCast(i32, @intCast(u32, 0xffffffff)), 0xbfff0000000000000000000000000000);
124 test_one_floatsitf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc01e0000000000000000000000000000);124 try test_one_floatsitf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc01e0000000000000000000000000000);
125}125}
lib/std/special/compiler_rt/floattidf_test.zig+59-59
...@@ -6,79 +6,79 @@...@@ -6,79 +6,79 @@
6const __floattidf = @import("floattidf.zig").__floattidf;6const __floattidf = @import("floattidf.zig").__floattidf;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__floattidf(a: i128, expected: f64) void {9fn test__floattidf(a: i128, expected: f64) !void {
10 const x = __floattidf(a);10 const x = __floattidf(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "floattidf" {14test "floattidf" {
15 test__floattidf(0, 0.0);15 try test__floattidf(0, 0.0);
1616
17 test__floattidf(1, 1.0);17 try test__floattidf(1, 1.0);
18 test__floattidf(2, 2.0);18 try test__floattidf(2, 2.0);
19 test__floattidf(20, 20.0);19 try test__floattidf(20, 20.0);
20 test__floattidf(-1, -1.0);20 try test__floattidf(-1, -1.0);
21 test__floattidf(-2, -2.0);21 try test__floattidf(-2, -2.0);
22 test__floattidf(-20, -20.0);22 try test__floattidf(-20, -20.0);
2323
24 test__floattidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);24 try test__floattidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
25 test__floattidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);25 try test__floattidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
26 test__floattidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);26 try test__floattidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
27 test__floattidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);27 try test__floattidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
2828
29 test__floattidf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);29 try test__floattidf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);
30 test__floattidf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);30 try test__floattidf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);
31 test__floattidf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);31 try test__floattidf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);
32 test__floattidf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);32 try test__floattidf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);
3333
34 test__floattidf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);34 try test__floattidf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);
35 test__floattidf(make_ti(0x8000000000000001, 0), -0x1.000000p+127);35 try test__floattidf(make_ti(0x8000000000000001, 0), -0x1.000000p+127);
3636
37 test__floattidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);37 try test__floattidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
3838
39 test__floattidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);39 try test__floattidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
40 test__floattidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);40 try test__floattidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
41 test__floattidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);41 try test__floattidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
42 test__floattidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);42 try test__floattidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
43 test__floattidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);43 try test__floattidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
4444
45 test__floattidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);45 try test__floattidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
46 test__floattidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);46 try test__floattidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
47 test__floattidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);47 try test__floattidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
48 test__floattidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);48 try test__floattidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
49 test__floattidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);49 try test__floattidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
5050
51 test__floattidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);51 try test__floattidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
52 test__floattidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);52 try test__floattidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
53 test__floattidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);53 try test__floattidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
54 test__floattidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);54 try test__floattidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
55 test__floattidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);55 try test__floattidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
56 test__floattidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);56 try test__floattidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
57 test__floattidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);57 try test__floattidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
58 test__floattidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);58 try test__floattidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
59 test__floattidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);59 try test__floattidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
60 test__floattidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);60 try test__floattidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
61 test__floattidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);61 try test__floattidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
62 test__floattidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);62 try test__floattidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
63 test__floattidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);63 try test__floattidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
64 test__floattidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);64 try test__floattidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
65 test__floattidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);65 try test__floattidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
6666
67 test__floattidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);67 try test__floattidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
68 test__floattidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121);68 try test__floattidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121);
69 test__floattidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121);69 try test__floattidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121);
70 test__floattidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121);70 try test__floattidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121);
71 test__floattidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121);71 try test__floattidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121);
72 test__floattidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121);72 try test__floattidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121);
73 test__floattidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121);73 try test__floattidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121);
74 test__floattidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121);74 try test__floattidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121);
75 test__floattidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121);75 try test__floattidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121);
76 test__floattidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121);76 try test__floattidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121);
77 test__floattidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121);77 try test__floattidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121);
78 test__floattidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121);78 try test__floattidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121);
79 test__floattidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121);79 try test__floattidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121);
80 test__floattidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121);80 try test__floattidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121);
81 test__floattidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);81 try test__floattidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
82}82}
8383
84fn make_ti(high: u64, low: u64) i128 {84fn make_ti(high: u64, low: u64) i128 {
lib/std/special/compiler_rt/floattisf_test.zig+34-34
...@@ -6,55 +6,55 @@...@@ -6,55 +6,55 @@
6const __floattisf = @import("floatXisf.zig").__floattisf;6const __floattisf = @import("floatXisf.zig").__floattisf;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__floattisf(a: i128, expected: f32) void {9fn test__floattisf(a: i128, expected: f32) !void {
10 const x = __floattisf(a);10 const x = __floattisf(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "floattisf" {14test "floattisf" {
15 test__floattisf(0, 0.0);15 try test__floattisf(0, 0.0);
1616
17 test__floattisf(1, 1.0);17 try test__floattisf(1, 1.0);
18 test__floattisf(2, 2.0);18 try test__floattisf(2, 2.0);
19 test__floattisf(-1, -1.0);19 try test__floattisf(-1, -1.0);
20 test__floattisf(-2, -2.0);20 try test__floattisf(-2, -2.0);
2121
22 test__floattisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);22 try test__floattisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
23 test__floattisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);23 try test__floattisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
2424
25 test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000008000000000), -0x1.FFFFFEp+62);25 try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000008000000000), -0x1.FFFFFEp+62);
26 test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000010000000000), -0x1.FFFFFCp+62);26 try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000010000000000), -0x1.FFFFFCp+62);
2727
28 test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000000), -0x1.000000p+63);28 try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000000), -0x1.000000p+63);
29 test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000001), -0x1.000000p+63);29 try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000001), -0x1.000000p+63);
3030
31 test__floattisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);31 try test__floattisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
3232
33 test__floattisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);33 try test__floattisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
34 test__floattisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);34 try test__floattisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
35 test__floattisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);35 try test__floattisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
36 test__floattisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);36 try test__floattisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
37 test__floattisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);37 try test__floattisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
3838
39 test__floattisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);39 try test__floattisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
40 test__floattisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);40 try test__floattisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
41 test__floattisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);41 try test__floattisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
42 test__floattisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);42 try test__floattisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
43 test__floattisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);43 try test__floattisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
4444
45 test__floattisf(make_ti(0x0007FB72E8000000, 0), 0x1.FEDCBAp+114);45 try test__floattisf(make_ti(0x0007FB72E8000000, 0), 0x1.FEDCBAp+114);
4646
47 test__floattisf(make_ti(0x0007FB72EA000000, 0), 0x1.FEDCBAp+114);47 try test__floattisf(make_ti(0x0007FB72EA000000, 0), 0x1.FEDCBAp+114);
48 test__floattisf(make_ti(0x0007FB72EB000000, 0), 0x1.FEDCBAp+114);48 try test__floattisf(make_ti(0x0007FB72EB000000, 0), 0x1.FEDCBAp+114);
49 test__floattisf(make_ti(0x0007FB72EBFFFFFF, 0), 0x1.FEDCBAp+114);49 try test__floattisf(make_ti(0x0007FB72EBFFFFFF, 0), 0x1.FEDCBAp+114);
50 test__floattisf(make_ti(0x0007FB72EC000000, 0), 0x1.FEDCBCp+114);50 try test__floattisf(make_ti(0x0007FB72EC000000, 0), 0x1.FEDCBCp+114);
51 test__floattisf(make_ti(0x0007FB72E8000001, 0), 0x1.FEDCBAp+114);51 try test__floattisf(make_ti(0x0007FB72E8000001, 0), 0x1.FEDCBAp+114);
5252
53 test__floattisf(make_ti(0x0007FB72E6000000, 0), 0x1.FEDCBAp+114);53 try test__floattisf(make_ti(0x0007FB72E6000000, 0), 0x1.FEDCBAp+114);
54 test__floattisf(make_ti(0x0007FB72E7000000, 0), 0x1.FEDCBAp+114);54 try test__floattisf(make_ti(0x0007FB72E7000000, 0), 0x1.FEDCBAp+114);
55 test__floattisf(make_ti(0x0007FB72E7FFFFFF, 0), 0x1.FEDCBAp+114);55 try test__floattisf(make_ti(0x0007FB72E7FFFFFF, 0), 0x1.FEDCBAp+114);
56 test__floattisf(make_ti(0x0007FB72E4000001, 0), 0x1.FEDCBAp+114);56 try test__floattisf(make_ti(0x0007FB72E4000001, 0), 0x1.FEDCBAp+114);
57 test__floattisf(make_ti(0x0007FB72E4000000, 0), 0x1.FEDCB8p+114);57 try test__floattisf(make_ti(0x0007FB72E4000000, 0), 0x1.FEDCB8p+114);
58}58}
5959
60fn make_ti(high: u64, low: u64) i128 {60fn make_ti(high: u64, low: u64) i128 {
lib/std/special/compiler_rt/floattitf_test.zig+69-69
...@@ -6,91 +6,91 @@...@@ -6,91 +6,91 @@
6const __floattitf = @import("floattitf.zig").__floattitf;6const __floattitf = @import("floattitf.zig").__floattitf;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__floattitf(a: i128, expected: f128) void {9fn test__floattitf(a: i128, expected: f128) !void {
10 const x = __floattitf(a);10 const x = __floattitf(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "floattitf" {14test "floattitf" {
15 test__floattitf(0, 0.0);15 try test__floattitf(0, 0.0);
1616
17 test__floattitf(1, 1.0);17 try test__floattitf(1, 1.0);
18 test__floattitf(2, 2.0);18 try test__floattitf(2, 2.0);
19 test__floattitf(20, 20.0);19 try test__floattitf(20, 20.0);
20 test__floattitf(-1, -1.0);20 try test__floattitf(-1, -1.0);
21 test__floattitf(-2, -2.0);21 try test__floattitf(-2, -2.0);
22 test__floattitf(-20, -20.0);22 try test__floattitf(-20, -20.0);
2323
24 test__floattitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);24 try test__floattitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
25 test__floattitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);25 try test__floattitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
26 test__floattitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);26 try test__floattitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
27 test__floattitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);27 try test__floattitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
2828
29 test__floattitf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);29 try test__floattitf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);
30 test__floattitf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);30 try test__floattitf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);
31 test__floattitf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);31 try test__floattitf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);
32 test__floattitf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);32 try test__floattitf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);
3333
34 test__floattitf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);34 try test__floattitf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);
35 test__floattitf(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126);35 try test__floattitf(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126);
3636
37 test__floattitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);37 try test__floattitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
3838
39 test__floattitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);39 try test__floattitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
40 test__floattitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);40 try test__floattitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
41 test__floattitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);41 try test__floattitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
42 test__floattitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);42 try test__floattitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
43 test__floattitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);43 try test__floattitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
4444
45 test__floattitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);45 try test__floattitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
46 test__floattitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);46 try test__floattitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
47 test__floattitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);47 try test__floattitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
48 test__floattitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);48 try test__floattitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
49 test__floattitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);49 try test__floattitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
5050
51 test__floattitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);51 try test__floattitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
52 test__floattitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);52 try test__floattitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);
53 test__floattitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);53 try test__floattitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);
54 test__floattitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);54 try test__floattitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);
55 test__floattitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);55 try test__floattitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);
56 test__floattitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);56 try test__floattitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);
57 test__floattitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);57 try test__floattitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);
58 test__floattitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);58 try test__floattitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);
59 test__floattitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);59 try test__floattitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);
60 test__floattitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);60 try test__floattitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);
61 test__floattitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);61 try test__floattitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);
62 test__floattitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);62 try test__floattitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);
63 test__floattitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);63 try test__floattitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);
64 test__floattitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);64 try test__floattitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);
65 test__floattitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);65 try test__floattitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
6666
67 test__floattitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);67 try test__floattitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
68 test__floattitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);68 try test__floattitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);
69 test__floattitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);69 try test__floattitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);
70 test__floattitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);70 try test__floattitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);
71 test__floattitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);71 try test__floattitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);
72 test__floattitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);72 try test__floattitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);
73 test__floattitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);73 try test__floattitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);
74 test__floattitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);74 try test__floattitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);
75 test__floattitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);75 try test__floattitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);
76 test__floattitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);76 try test__floattitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);
77 test__floattitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);77 try test__floattitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);
78 test__floattitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);78 try test__floattitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);
79 test__floattitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);79 try test__floattitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);
80 test__floattitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);80 try test__floattitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);
81 test__floattitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);81 try test__floattitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
8282
83 test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);83 try test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);
8484
85 test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);85 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);
86 test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);86 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);
87 test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);87 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);
88 test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);88 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);
89 test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);89 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);
90 test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);90 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);
91 test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);91 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);
92 test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);92 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);
93 test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);93 try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);
94}94}
9595
96fn make_ti(high: u64, low: u64) i128 {96fn make_ti(high: u64, low: u64) i128 {
lib/std/special/compiler_rt/floatundidf_test.zig+41-41
...@@ -6,50 +6,50 @@...@@ -6,50 +6,50 @@
6const __floatundidf = @import("floatundidf.zig").__floatundidf;6const __floatundidf = @import("floatundidf.zig").__floatundidf;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__floatundidf(a: u64, expected: f64) void {9fn test__floatundidf(a: u64, expected: f64) !void {
10 const r = __floatundidf(a);10 const r = __floatundidf(a);
11 try testing.expect(r == expected);11 try testing.expect(r == expected);
12}12}
1313
14test "floatundidf" {14test "floatundidf" {
15 test__floatundidf(0, 0.0);15 try test__floatundidf(0, 0.0);
16 test__floatundidf(1, 1.0);16 try test__floatundidf(1, 1.0);
17 test__floatundidf(2, 2.0);17 try test__floatundidf(2, 2.0);
18 test__floatundidf(20, 20.0);18 try test__floatundidf(20, 20.0);
19 test__floatundidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);19 try test__floatundidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
20 test__floatundidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);20 try test__floatundidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
21 test__floatundidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);21 try test__floatundidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
22 test__floatundidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);22 try test__floatundidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
23 test__floatundidf(0x8000008000000000, 0x1.000001p+63);23 try test__floatundidf(0x8000008000000000, 0x1.000001p+63);
24 test__floatundidf(0x8000000000000800, 0x1.0000000000001p+63);24 try test__floatundidf(0x8000000000000800, 0x1.0000000000001p+63);
25 test__floatundidf(0x8000010000000000, 0x1.000002p+63);25 try test__floatundidf(0x8000010000000000, 0x1.000002p+63);
26 test__floatundidf(0x8000000000001000, 0x1.0000000000002p+63);26 try test__floatundidf(0x8000000000001000, 0x1.0000000000002p+63);
27 test__floatundidf(0x8000000000000000, 0x1p+63);27 try test__floatundidf(0x8000000000000000, 0x1p+63);
28 test__floatundidf(0x8000000000000001, 0x1p+63);28 try test__floatundidf(0x8000000000000001, 0x1p+63);
29 test__floatundidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);29 try test__floatundidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
30 test__floatundidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);30 try test__floatundidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
31 test__floatundidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);31 try test__floatundidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
32 test__floatundidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);32 try test__floatundidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
33 test__floatundidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);33 try test__floatundidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
34 test__floatundidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);34 try test__floatundidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
35 test__floatundidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);35 try test__floatundidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
36 test__floatundidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);36 try test__floatundidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
37 test__floatundidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);37 try test__floatundidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
38 test__floatundidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);38 try test__floatundidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
39 test__floatundidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);39 try test__floatundidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
40 test__floatundidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);40 try test__floatundidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
41 test__floatundidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);41 try test__floatundidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
42 test__floatundidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);42 try test__floatundidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
43 test__floatundidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);43 try test__floatundidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
44 test__floatundidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);44 try test__floatundidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
45 test__floatundidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);45 try test__floatundidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
46 test__floatundidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);46 try test__floatundidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
47 test__floatundidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);47 try test__floatundidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
48 test__floatundidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);48 try test__floatundidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
49 test__floatundidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);49 try test__floatundidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
50 test__floatundidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);50 try test__floatundidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
51 test__floatundidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);51 try test__floatundidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
52 test__floatundidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);52 try test__floatundidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
53 test__floatundidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);53 try test__floatundidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
54 test__floatundidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);54 try test__floatundidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
55}55}
lib/std/special/compiler_rt/floatundisf.zig+24-24
...@@ -66,31 +66,31 @@ pub fn __aeabi_ul2f(arg: u64) callconv(.AAPCS) f32 {...@@ -66,31 +66,31 @@ pub fn __aeabi_ul2f(arg: u64) callconv(.AAPCS) f32 {
66 return @call(.{ .modifier = .always_inline }, __floatundisf, .{arg});66 return @call(.{ .modifier = .always_inline }, __floatundisf, .{arg});
67}67}
6868
69fn test__floatundisf(a: u64, expected: f32) void {69fn test__floatundisf(a: u64, expected: f32) !void {
70 std.testing.expectEqual(expected, __floatundisf(a));70 try std.testing.expectEqual(expected, __floatundisf(a));
71}71}
7272
73test "floatundisf" {73test "floatundisf" {
74 test__floatundisf(0, 0.0);74 try test__floatundisf(0, 0.0);
75 test__floatundisf(1, 1.0);75 try test__floatundisf(1, 1.0);
76 test__floatundisf(2, 2.0);76 try test__floatundisf(2, 2.0);
77 test__floatundisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);77 try test__floatundisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
78 test__floatundisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);78 try test__floatundisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
79 test__floatundisf(0x8000008000000000, 0x1p+63);79 try test__floatundisf(0x8000008000000000, 0x1p+63);
80 test__floatundisf(0x8000010000000000, 0x1.000002p+63);80 try test__floatundisf(0x8000010000000000, 0x1.000002p+63);
81 test__floatundisf(0x8000000000000000, 0x1p+63);81 try test__floatundisf(0x8000000000000000, 0x1p+63);
82 test__floatundisf(0x8000000000000001, 0x1p+63);82 try test__floatundisf(0x8000000000000001, 0x1p+63);
83 test__floatundisf(0xFFFFFFFFFFFFFFFE, 0x1p+64);83 try test__floatundisf(0xFFFFFFFFFFFFFFFE, 0x1p+64);
84 test__floatundisf(0xFFFFFFFFFFFFFFFF, 0x1p+64);84 try test__floatundisf(0xFFFFFFFFFFFFFFFF, 0x1p+64);
85 test__floatundisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);85 try test__floatundisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
86 test__floatundisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);86 try test__floatundisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
87 test__floatundisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);87 try test__floatundisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
88 test__floatundisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);88 try test__floatundisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
89 test__floatundisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);89 try test__floatundisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
90 test__floatundisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);90 try test__floatundisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
91 test__floatundisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);91 try test__floatundisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
92 test__floatundisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);92 try test__floatundisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
93 test__floatundisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);93 try test__floatundisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
94 test__floatundisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);94 try test__floatundisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
95 test__floatundisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);95 try test__floatundisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
96}96}
lib/std/special/compiler_rt/floatunditf_test.zig+9-9
...@@ -5,7 +5,7 @@...@@ -5,7 +5,7 @@
5// and substantial portions of the software.5// and substantial portions of the software.
6const __floatunditf = @import("floatunditf.zig").__floatunditf;6const __floatunditf = @import("floatunditf.zig").__floatunditf;
77
8fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) void {8fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) !void {
9 const x = __floatunditf(a);9 const x = __floatunditf(a);
1010
11 const x_repr = @bitCast(u128, x);11 const x_repr = @bitCast(u128, x);
...@@ -26,12 +26,12 @@ fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) void {...@@ -26,12 +26,12 @@ fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) void {
26}26}
2727
28test "floatunditf" {28test "floatunditf" {
29 test__floatunditf(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000);29 try test__floatunditf(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000);
30 test__floatunditf(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000);30 try test__floatunditf(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000);
31 test__floatunditf(0x8000000000000000, 0x403e000000000000, 0x0);31 try test__floatunditf(0x8000000000000000, 0x403e000000000000, 0x0);
32 test__floatunditf(0x7fffffffffffffff, 0x403dffffffffffff, 0xfffc000000000000);32 try test__floatunditf(0x7fffffffffffffff, 0x403dffffffffffff, 0xfffc000000000000);
33 test__floatunditf(0x123456789abcdef1, 0x403b23456789abcd, 0xef10000000000000);33 try test__floatunditf(0x123456789abcdef1, 0x403b23456789abcd, 0xef10000000000000);
34 test__floatunditf(0x2, 0x4000000000000000, 0x0);34 try test__floatunditf(0x2, 0x4000000000000000, 0x0);
35 test__floatunditf(0x1, 0x3fff000000000000, 0x0);35 try test__floatunditf(0x1, 0x3fff000000000000, 0x0);
36 test__floatunditf(0x0, 0x0, 0x0);36 try test__floatunditf(0x0, 0x0, 0x0);
37}37}
lib/std/special/compiler_rt/floatunsidf.zig+6-6
...@@ -28,16 +28,16 @@ pub fn __aeabi_ui2d(arg: u32) callconv(.AAPCS) f64 {...@@ -28,16 +28,16 @@ pub fn __aeabi_ui2d(arg: u32) callconv(.AAPCS) f64 {
28 return @call(.{ .modifier = .always_inline }, __floatunsidf, .{arg});28 return @call(.{ .modifier = .always_inline }, __floatunsidf, .{arg});
29}29}
3030
31fn test_one_floatunsidf(a: u32, expected: u64) void {31fn test_one_floatunsidf(a: u32, expected: u64) !void {
32 const r = __floatunsidf(a);32 const r = __floatunsidf(a);
33 try std.testing.expect(@bitCast(u64, r) == expected);33 try std.testing.expect(@bitCast(u64, r) == expected);
34}34}
3535
36test "floatsidf" {36test "floatsidf" {
37 // Test the produced bit pattern37 // Test the produced bit pattern
38 test_one_floatunsidf(0, 0x0000000000000000);38 try test_one_floatunsidf(0, 0x0000000000000000);
39 test_one_floatunsidf(1, 0x3ff0000000000000);39 try test_one_floatunsidf(1, 0x3ff0000000000000);
40 test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000);40 try test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000);
41 test_one_floatunsidf(@intCast(u32, 0x80000000), 0x41e0000000000000);41 try test_one_floatunsidf(@intCast(u32, 0x80000000), 0x41e0000000000000);
42 test_one_floatunsidf(@intCast(u32, 0xFFFFFFFF), 0x41efffffffe00000);42 try test_one_floatunsidf(@intCast(u32, 0xFFFFFFFF), 0x41efffffffe00000);
43}43}
lib/std/special/compiler_rt/floatunsisf.zig+6-6
...@@ -48,16 +48,16 @@ pub fn __aeabi_ui2f(arg: u32) callconv(.AAPCS) f32 {...@@ -48,16 +48,16 @@ pub fn __aeabi_ui2f(arg: u32) callconv(.AAPCS) f32 {
48 return @call(.{ .modifier = .always_inline }, __floatunsisf, .{arg});48 return @call(.{ .modifier = .always_inline }, __floatunsisf, .{arg});
49}49}
5050
51fn test_one_floatunsisf(a: u32, expected: u32) void {51fn test_one_floatunsisf(a: u32, expected: u32) !void {
52 const r = __floatunsisf(a);52 const r = __floatunsisf(a);
53 try std.testing.expect(@bitCast(u32, r) == expected);53 try std.testing.expect(@bitCast(u32, r) == expected);
54}54}
5555
56test "floatunsisf" {56test "floatunsisf" {
57 // Test the produced bit pattern57 // Test the produced bit pattern
58 test_one_floatunsisf(0, 0);58 try test_one_floatunsisf(0, 0);
59 test_one_floatunsisf(1, 0x3f800000);59 try test_one_floatunsisf(1, 0x3f800000);
60 test_one_floatunsisf(0x7FFFFFFF, 0x4f000000);60 try test_one_floatunsisf(0x7FFFFFFF, 0x4f000000);
61 test_one_floatunsisf(0x80000000, 0x4f000000);61 try test_one_floatunsisf(0x80000000, 0x4f000000);
62 test_one_floatunsisf(0xFFFFFFFF, 0x4f800000);62 try test_one_floatunsisf(0xFFFFFFFF, 0x4f800000);
63}63}
lib/std/special/compiler_rt/floatunsitf_test.zig+5-5
...@@ -5,7 +5,7 @@...@@ -5,7 +5,7 @@
5// and substantial portions of the software.5// and substantial portions of the software.
6const __floatunsitf = @import("floatunsitf.zig").__floatunsitf;6const __floatunsitf = @import("floatunsitf.zig").__floatunsitf;
77
8fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) void {8fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) !void {
9 const x = __floatunsitf(a);9 const x = __floatunsitf(a);
1010
11 const x_repr = @bitCast(u128, x);11 const x_repr = @bitCast(u128, x);
...@@ -26,8 +26,8 @@ fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) void {...@@ -26,8 +26,8 @@ fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) void {
26}26}
2727
28test "floatunsitf" {28test "floatunsitf" {
29 test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0);29 try test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0);
30 test__floatunsitf(0, 0x0, 0x0);30 try test__floatunsitf(0, 0x0, 0x0);
31 test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0);31 try test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0);
32 test__floatunsitf(0x12345678, 0x401b234567800000, 0x0);32 try test__floatunsitf(0x12345678, 0x401b234567800000, 0x0);
33}33}
lib/std/special/compiler_rt/floatuntidf_test.zig+56-56
...@@ -6,76 +6,76 @@...@@ -6,76 +6,76 @@
6const __floatuntidf = @import("floatuntidf.zig").__floatuntidf;6const __floatuntidf = @import("floatuntidf.zig").__floatuntidf;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__floatuntidf(a: u128, expected: f64) void {9fn test__floatuntidf(a: u128, expected: f64) !void {
10 const x = __floatuntidf(a);10 const x = __floatuntidf(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "floatuntidf" {14test "floatuntidf" {
15 test__floatuntidf(0, 0.0);15 try test__floatuntidf(0, 0.0);
1616
17 test__floatuntidf(1, 1.0);17 try test__floatuntidf(1, 1.0);
18 test__floatuntidf(2, 2.0);18 try test__floatuntidf(2, 2.0);
19 test__floatuntidf(20, 20.0);19 try test__floatuntidf(20, 20.0);
2020
21 test__floatuntidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);21 try test__floatuntidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
22 test__floatuntidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);22 try test__floatuntidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
23 test__floatuntidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);23 try test__floatuntidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
24 test__floatuntidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);24 try test__floatuntidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
2525
26 test__floatuntidf(make_ti(0x8000008000000000, 0), 0x1.000001p+127);26 try test__floatuntidf(make_ti(0x8000008000000000, 0), 0x1.000001p+127);
27 test__floatuntidf(make_ti(0x8000000000000800, 0), 0x1.0000000000001p+127);27 try test__floatuntidf(make_ti(0x8000000000000800, 0), 0x1.0000000000001p+127);
28 test__floatuntidf(make_ti(0x8000010000000000, 0), 0x1.000002p+127);28 try test__floatuntidf(make_ti(0x8000010000000000, 0), 0x1.000002p+127);
29 test__floatuntidf(make_ti(0x8000000000001000, 0), 0x1.0000000000002p+127);29 try test__floatuntidf(make_ti(0x8000000000001000, 0), 0x1.0000000000002p+127);
3030
31 test__floatuntidf(make_ti(0x8000000000000000, 0), 0x1.000000p+127);31 try test__floatuntidf(make_ti(0x8000000000000000, 0), 0x1.000000p+127);
32 test__floatuntidf(make_ti(0x8000000000000001, 0), 0x1.0000000000000002p+127);32 try test__floatuntidf(make_ti(0x8000000000000001, 0), 0x1.0000000000000002p+127);
3333
34 test__floatuntidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);34 try test__floatuntidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
3535
36 test__floatuntidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);36 try test__floatuntidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
37 test__floatuntidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);37 try test__floatuntidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
38 test__floatuntidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);38 try test__floatuntidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
39 test__floatuntidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);39 try test__floatuntidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
40 test__floatuntidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);40 try test__floatuntidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
4141
42 test__floatuntidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);42 try test__floatuntidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
43 test__floatuntidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);43 try test__floatuntidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
44 test__floatuntidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);44 try test__floatuntidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
45 test__floatuntidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);45 try test__floatuntidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
46 test__floatuntidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);46 try test__floatuntidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
4747
48 test__floatuntidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);48 try test__floatuntidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
49 test__floatuntidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);49 try test__floatuntidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
50 test__floatuntidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);50 try test__floatuntidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
51 test__floatuntidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);51 try test__floatuntidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
52 test__floatuntidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);52 try test__floatuntidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
53 test__floatuntidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);53 try test__floatuntidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
54 test__floatuntidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);54 try test__floatuntidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
55 test__floatuntidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);55 try test__floatuntidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
56 test__floatuntidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);56 try test__floatuntidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
57 test__floatuntidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);57 try test__floatuntidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
58 test__floatuntidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);58 try test__floatuntidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
59 test__floatuntidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);59 try test__floatuntidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
60 test__floatuntidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);60 try test__floatuntidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
61 test__floatuntidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);61 try test__floatuntidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
62 test__floatuntidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);62 try test__floatuntidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
6363
64 test__floatuntidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);64 try test__floatuntidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
65 test__floatuntidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121);65 try test__floatuntidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121);
66 test__floatuntidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121);66 try test__floatuntidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121);
67 test__floatuntidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121);67 try test__floatuntidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121);
68 test__floatuntidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121);68 try test__floatuntidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121);
69 test__floatuntidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121);69 try test__floatuntidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121);
70 test__floatuntidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121);70 try test__floatuntidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121);
71 test__floatuntidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121);71 try test__floatuntidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121);
72 test__floatuntidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121);72 try test__floatuntidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121);
73 test__floatuntidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121);73 try test__floatuntidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121);
74 test__floatuntidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121);74 try test__floatuntidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121);
75 test__floatuntidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121);75 try test__floatuntidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121);
76 test__floatuntidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121);76 try test__floatuntidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121);
77 test__floatuntidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121);77 try test__floatuntidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121);
78 test__floatuntidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);78 try test__floatuntidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
79}79}
8080
81fn make_ti(high: u64, low: u64) u128 {81fn make_ti(high: u64, low: u64) u128 {
lib/std/special/compiler_rt/floatuntisf_test.zig+43-43
...@@ -6,67 +6,67 @@...@@ -6,67 +6,67 @@
6const __floatuntisf = @import("floatuntisf.zig").__floatuntisf;6const __floatuntisf = @import("floatuntisf.zig").__floatuntisf;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__floatuntisf(a: u128, expected: f32) void {9fn test__floatuntisf(a: u128, expected: f32) !void {
10 const x = __floatuntisf(a);10 const x = __floatuntisf(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "floatuntisf" {14test "floatuntisf" {
15 test__floatuntisf(0, 0.0);15 try test__floatuntisf(0, 0.0);
1616
17 test__floatuntisf(1, 1.0);17 try test__floatuntisf(1, 1.0);
18 test__floatuntisf(2, 2.0);18 try test__floatuntisf(2, 2.0);
19 test__floatuntisf(20, 20.0);19 try test__floatuntisf(20, 20.0);
2020
21 test__floatuntisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);21 try test__floatuntisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
22 test__floatuntisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);22 try test__floatuntisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
2323
24 test__floatuntisf(make_ti(0x8000008000000000, 0), 0x1.000001p+127);24 try test__floatuntisf(make_ti(0x8000008000000000, 0), 0x1.000001p+127);
25 test__floatuntisf(make_ti(0x8000000000000800, 0), 0x1.0p+127);25 try test__floatuntisf(make_ti(0x8000000000000800, 0), 0x1.0p+127);
26 test__floatuntisf(make_ti(0x8000010000000000, 0), 0x1.000002p+127);26 try test__floatuntisf(make_ti(0x8000010000000000, 0), 0x1.000002p+127);
2727
28 test__floatuntisf(make_ti(0x8000000000000000, 0), 0x1.000000p+127);28 try test__floatuntisf(make_ti(0x8000000000000000, 0), 0x1.000000p+127);
2929
30 test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);30 try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
3131
32 test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);32 try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
33 test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBACp+50);33 try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
3434
35 test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBBp+50);35 try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
3636
37 test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCB98p+50);37 try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
38 test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);38 try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
39 test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB9p+50);39 try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
4040
41 test__floatuntisf(0xFFFFFFFFFFFFFFFE, 0x1p+64);41 try test__floatuntisf(0xFFFFFFFFFFFFFFFE, 0x1p+64);
42 test__floatuntisf(0xFFFFFFFFFFFFFFFF, 0x1p+64);42 try test__floatuntisf(0xFFFFFFFFFFFFFFFF, 0x1p+64);
4343
44 test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);44 try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
4545
46 test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);46 try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
47 test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);47 try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
48 test__floatuntisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);48 try test__floatuntisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
49 test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);49 try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
50 test__floatuntisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);50 try test__floatuntisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
5151
52 test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);52 try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
53 test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);53 try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
54 test__floatuntisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);54 try test__floatuntisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
55 test__floatuntisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);55 try test__floatuntisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
56 test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);56 try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
5757
58 test__floatuntisf(make_ti(0x0000000000001FED, 0xCB90000000000001), 0x1.FEDCBAp+76);58 try test__floatuntisf(make_ti(0x0000000000001FED, 0xCB90000000000001), 0x1.FEDCBAp+76);
59 test__floatuntisf(make_ti(0x0000000000001FED, 0xCBA0000000000000), 0x1.FEDCBAp+76);59 try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBA0000000000000), 0x1.FEDCBAp+76);
60 test__floatuntisf(make_ti(0x0000000000001FED, 0xCBAFFFFFFFFFFFFF), 0x1.FEDCBAp+76);60 try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBAFFFFFFFFFFFFF), 0x1.FEDCBAp+76);
61 test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000000), 0x1.FEDCBCp+76);61 try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000000), 0x1.FEDCBCp+76);
62 test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000001), 0x1.FEDCBCp+76);62 try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000001), 0x1.FEDCBCp+76);
63 test__floatuntisf(make_ti(0x0000000000001FED, 0xCBBFFFFFFFFFFFFF), 0x1.FEDCBCp+76);63 try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBBFFFFFFFFFFFFF), 0x1.FEDCBCp+76);
64 test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000000), 0x1.FEDCBCp+76);64 try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000000), 0x1.FEDCBCp+76);
65 test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000001), 0x1.FEDCBCp+76);65 try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000001), 0x1.FEDCBCp+76);
66 test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000000), 0x1.FEDCBCp+76);66 try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000000), 0x1.FEDCBCp+76);
67 test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000001), 0x1.FEDCBEp+76);67 try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000001), 0x1.FEDCBEp+76);
68 test__floatuntisf(make_ti(0x0000000000001FED, 0xCBDFFFFFFFFFFFFF), 0x1.FEDCBEp+76);68 try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBDFFFFFFFFFFFFF), 0x1.FEDCBEp+76);
69 test__floatuntisf(make_ti(0x0000000000001FED, 0xCBE0000000000000), 0x1.FEDCBEp+76);69 try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBE0000000000000), 0x1.FEDCBEp+76);
70}70}
7171
72fn make_ti(high: u64, low: u64) u128 {72fn make_ti(high: u64, low: u64) u128 {
lib/std/special/compiler_rt/floatuntitf_test.zig+71-71
...@@ -6,94 +6,94 @@...@@ -6,94 +6,94 @@
6const __floatuntitf = @import("floatuntitf.zig").__floatuntitf;6const __floatuntitf = @import("floatuntitf.zig").__floatuntitf;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__floatuntitf(a: u128, expected: f128) void {9fn test__floatuntitf(a: u128, expected: f128) !void {
10 const x = __floatuntitf(a);10 const x = __floatuntitf(a);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "floatuntitf" {14test "floatuntitf" {
15 test__floatuntitf(0, 0.0);15 try test__floatuntitf(0, 0.0);
1616
17 test__floatuntitf(1, 1.0);17 try test__floatuntitf(1, 1.0);
18 test__floatuntitf(2, 2.0);18 try test__floatuntitf(2, 2.0);
19 test__floatuntitf(20, 20.0);19 try test__floatuntitf(20, 20.0);
2020
21 test__floatuntitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);21 try test__floatuntitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
22 test__floatuntitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);22 try test__floatuntitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
23 test__floatuntitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);23 try test__floatuntitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
24 test__floatuntitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);24 try test__floatuntitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
25 test__floatuntitf(0x7FFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFEp+59);25 try test__floatuntitf(0x7FFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFEp+59);
26 test__floatuntitf(0xFFFFFFFFFFFFFFFE, 0xF.FFFFFFFFFFFFFFEp+60);26 try test__floatuntitf(0xFFFFFFFFFFFFFFFE, 0xF.FFFFFFFFFFFFFFEp+60);
27 test__floatuntitf(0xFFFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFFp+60);27 try test__floatuntitf(0xFFFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFFp+60);
2828
29 test__floatuntitf(0x8000008000000000, 0x8.000008p+60);29 try test__floatuntitf(0x8000008000000000, 0x8.000008p+60);
30 test__floatuntitf(0x8000000000000800, 0x8.0000000000008p+60);30 try test__floatuntitf(0x8000000000000800, 0x8.0000000000008p+60);
31 test__floatuntitf(0x8000010000000000, 0x8.00001p+60);31 try test__floatuntitf(0x8000010000000000, 0x8.00001p+60);
32 test__floatuntitf(0x8000000000001000, 0x8.000000000001p+60);32 try test__floatuntitf(0x8000000000001000, 0x8.000000000001p+60);
3333
34 test__floatuntitf(0x8000000000000000, 0x8p+60);34 try test__floatuntitf(0x8000000000000000, 0x8p+60);
35 test__floatuntitf(0x8000000000000001, 0x8.000000000000001p+60);35 try test__floatuntitf(0x8000000000000001, 0x8.000000000000001p+60);
3636
37 test__floatuntitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);37 try test__floatuntitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
3838
39 test__floatuntitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);39 try test__floatuntitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
40 test__floatuntitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);40 try test__floatuntitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
41 test__floatuntitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);41 try test__floatuntitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
42 test__floatuntitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);42 try test__floatuntitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
43 test__floatuntitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);43 try test__floatuntitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
4444
45 test__floatuntitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);45 try test__floatuntitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
46 test__floatuntitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);46 try test__floatuntitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
47 test__floatuntitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);47 try test__floatuntitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
48 test__floatuntitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);48 try test__floatuntitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
49 test__floatuntitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);49 try test__floatuntitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
5050
51 test__floatuntitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);51 try test__floatuntitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
52 test__floatuntitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);52 try test__floatuntitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);
53 test__floatuntitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);53 try test__floatuntitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);
54 test__floatuntitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);54 try test__floatuntitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);
55 test__floatuntitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);55 try test__floatuntitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);
56 test__floatuntitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);56 try test__floatuntitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);
57 test__floatuntitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);57 try test__floatuntitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);
58 test__floatuntitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);58 try test__floatuntitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);
59 test__floatuntitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);59 try test__floatuntitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);
60 test__floatuntitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);60 try test__floatuntitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);
61 test__floatuntitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);61 try test__floatuntitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);
62 test__floatuntitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);62 try test__floatuntitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);
63 test__floatuntitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);63 try test__floatuntitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);
64 test__floatuntitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);64 try test__floatuntitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);
65 test__floatuntitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);65 try test__floatuntitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
6666
67 test__floatuntitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);67 try test__floatuntitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
68 test__floatuntitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);68 try test__floatuntitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);
69 test__floatuntitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);69 try test__floatuntitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);
70 test__floatuntitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);70 try test__floatuntitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);
71 test__floatuntitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);71 try test__floatuntitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);
72 test__floatuntitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);72 try test__floatuntitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);
73 test__floatuntitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);73 try test__floatuntitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);
74 test__floatuntitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);74 try test__floatuntitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);
75 test__floatuntitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);75 try test__floatuntitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);
76 test__floatuntitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);76 try test__floatuntitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);
77 test__floatuntitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);77 try test__floatuntitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);
78 test__floatuntitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);78 try test__floatuntitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);
79 test__floatuntitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);79 try test__floatuntitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);
80 test__floatuntitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);80 try test__floatuntitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);
81 test__floatuntitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);81 try test__floatuntitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
8282
83 test__floatuntitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);83 try test__floatuntitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);
8484
85 test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0x0000000000000000), 0x1.FFFFFFFFFFFFFFFEp+127);85 try test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0x0000000000000000), 0x1.FFFFFFFFFFFFFFFEp+127);
86 test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x1.0000000000000000p+128);86 try test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x1.0000000000000000p+128);
8787
88 test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);88 try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);
89 test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);89 try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);
90 test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);90 try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);
91 test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);91 try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);
92 test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);92 try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);
93 test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);93 try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);
94 test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);94 try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);
95 test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);95 try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);
96 test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);96 try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);
97}97}
9898
99fn make_ti(high: u64, low: u64) u128 {99fn make_ti(high: u64, low: u64) u128 {
lib/std/special/compiler_rt/int.zig+57-57
...@@ -58,11 +58,11 @@ test "test_divdi3" {...@@ -58,11 +58,11 @@ test "test_divdi3" {
58 };58 };
5959
60 for (cases) |case| {60 for (cases) |case| {
61 test_one_divdi3(case[0], case[1], case[2]);61 try test_one_divdi3(case[0], case[1], case[2]);
62 }62 }
63}63}
6464
65fn test_one_divdi3(a: i64, b: i64, expected_q: i64) void {65fn test_one_divdi3(a: i64, b: i64, expected_q: i64) !void {
66 const q: i64 = __divdi3(a, b);66 const q: i64 = __divdi3(a, b);
67 try testing.expect(q == expected_q);67 try testing.expect(q == expected_q);
68}68}
...@@ -98,11 +98,11 @@ test "test_moddi3" {...@@ -98,11 +98,11 @@ test "test_moddi3" {
98 };98 };
9999
100 for (cases) |case| {100 for (cases) |case| {
101 test_one_moddi3(case[0], case[1], case[2]);101 try test_one_moddi3(case[0], case[1], case[2]);
102 }102 }
103}103}
104104
105fn test_one_moddi3(a: i64, b: i64, expected_r: i64) void {105fn test_one_moddi3(a: i64, b: i64, expected_r: i64) !void {
106 const r: i64 = __moddi3(a, b);106 const r: i64 = __moddi3(a, b);
107 try testing.expect(r == expected_r);107 try testing.expect(r == expected_r);
108}108}
...@@ -121,14 +121,14 @@ pub fn __umoddi3(a: u64, b: u64) callconv(.C) u64 {...@@ -121,14 +121,14 @@ pub fn __umoddi3(a: u64, b: u64) callconv(.C) u64 {
121}121}
122122
123test "test_umoddi3" {123test "test_umoddi3" {
124 test_one_umoddi3(0, 1, 0);124 try test_one_umoddi3(0, 1, 0);
125 test_one_umoddi3(2, 1, 0);125 try test_one_umoddi3(2, 1, 0);
126 test_one_umoddi3(0x8000000000000000, 1, 0x0);126 try test_one_umoddi3(0x8000000000000000, 1, 0x0);
127 test_one_umoddi3(0x8000000000000000, 2, 0x0);127 try test_one_umoddi3(0x8000000000000000, 2, 0x0);
128 test_one_umoddi3(0xFFFFFFFFFFFFFFFF, 2, 0x1);128 try test_one_umoddi3(0xFFFFFFFFFFFFFFFF, 2, 0x1);
129}129}
130130
131fn test_one_umoddi3(a: u64, b: u64, expected_r: u64) void {131fn test_one_umoddi3(a: u64, b: u64, expected_r: u64) !void {
132 const r = __umoddi3(a, b);132 const r = __umoddi3(a, b);
133 try testing.expect(r == expected_r);133 try testing.expect(r == expected_r);
134}134}
...@@ -159,11 +159,11 @@ test "test_divmodsi4" {...@@ -159,11 +159,11 @@ test "test_divmodsi4" {
159 };159 };
160160
161 for (cases) |case| {161 for (cases) |case| {
162 test_one_divmodsi4(case[0], case[1], case[2], case[3]);162 try test_one_divmodsi4(case[0], case[1], case[2], case[3]);
163 }163 }
164}164}
165165
166fn test_one_divmodsi4(a: i32, b: i32, expected_q: i32, expected_r: i32) void {166fn test_one_divmodsi4(a: i32, b: i32, expected_q: i32, expected_r: i32) !void {
167 var r: i32 = undefined;167 var r: i32 = undefined;
168 const q: i32 = __divmodsi4(a, b, &r);168 const q: i32 = __divmodsi4(a, b, &r);
169 try testing.expect(q == expected_q and r == expected_r);169 try testing.expect(q == expected_q and r == expected_r);
...@@ -207,11 +207,11 @@ test "test_divsi3" {...@@ -207,11 +207,11 @@ test "test_divsi3" {
207 };207 };
208208
209 for (cases) |case| {209 for (cases) |case| {
210 test_one_divsi3(case[0], case[1], case[2]);210 try test_one_divsi3(case[0], case[1], case[2]);
211 }211 }
212}212}
213213
214fn test_one_divsi3(a: i32, b: i32, expected_q: i32) void {214fn test_one_divsi3(a: i32, b: i32, expected_q: i32) !void {
215 const q: i32 = __divsi3(a, b);215 const q: i32 = __divsi3(a, b);
216 try testing.expect(q == expected_q);216 try testing.expect(q == expected_q);
217}217}
...@@ -394,11 +394,11 @@ test "test_udivsi3" {...@@ -394,11 +394,11 @@ test "test_udivsi3" {
394 };394 };
395395
396 for (cases) |case| {396 for (cases) |case| {
397 test_one_udivsi3(case[0], case[1], case[2]);397 try test_one_udivsi3(case[0], case[1], case[2]);
398 }398 }
399}399}
400400
401fn test_one_udivsi3(a: u32, b: u32, expected_q: u32) void {401fn test_one_udivsi3(a: u32, b: u32, expected_q: u32) !void {
402 const q: u32 = __udivsi3(a, b);402 const q: u32 = __udivsi3(a, b);
403 try testing.expect(q == expected_q);403 try testing.expect(q == expected_q);
404}404}
...@@ -425,11 +425,11 @@ test "test_modsi3" {...@@ -425,11 +425,11 @@ test "test_modsi3" {
425 };425 };
426426
427 for (cases) |case| {427 for (cases) |case| {
428 test_one_modsi3(case[0], case[1], case[2]);428 try test_one_modsi3(case[0], case[1], case[2]);
429 }429 }
430}430}
431431
432fn test_one_modsi3(a: i32, b: i32, expected_r: i32) void {432fn test_one_modsi3(a: i32, b: i32, expected_r: i32) !void {
433 const r: i32 = __modsi3(a, b);433 const r: i32 = __modsi3(a, b);
434 try testing.expect(r == expected_r);434 try testing.expect(r == expected_r);
435}435}
...@@ -577,11 +577,11 @@ test "test_umodsi3" {...@@ -577,11 +577,11 @@ test "test_umodsi3" {
577 };577 };
578578
579 for (cases) |case| {579 for (cases) |case| {
580 test_one_umodsi3(case[0], case[1], case[2]);580 try test_one_umodsi3(case[0], case[1], case[2]);
581 }581 }
582}582}
583583
584fn test_one_umodsi3(a: u32, b: u32, expected_r: u32) void {584fn test_one_umodsi3(a: u32, b: u32, expected_r: u32) !void {
585 const r: u32 = __umodsi3(a, b);585 const r: u32 = __umodsi3(a, b);
586 try testing.expect(r == expected_r);586 try testing.expect(r == expected_r);
587}587}
...@@ -602,44 +602,44 @@ pub fn __mulsi3(a: i32, b: i32) callconv(.C) i32 {...@@ -602,44 +602,44 @@ pub fn __mulsi3(a: i32, b: i32) callconv(.C) i32 {
602 return @bitCast(i32, r);602 return @bitCast(i32, r);
603}603}
604604
605fn test_one_mulsi3(a: i32, b: i32, result: i32) void {605fn test_one_mulsi3(a: i32, b: i32, result: i32) !void {
606 testing.expectEqual(result, __mulsi3(a, b));606 try testing.expectEqual(result, __mulsi3(a, b));
607}607}
608608
609test "mulsi3" {609test "mulsi3" {
610 test_one_mulsi3(0, 0, 0);610 try test_one_mulsi3(0, 0, 0);
611 test_one_mulsi3(0, 1, 0);611 try test_one_mulsi3(0, 1, 0);
612 test_one_mulsi3(1, 0, 0);612 try test_one_mulsi3(1, 0, 0);
613 test_one_mulsi3(0, 10, 0);613 try test_one_mulsi3(0, 10, 0);
614 test_one_mulsi3(10, 0, 0);614 try test_one_mulsi3(10, 0, 0);
615 test_one_mulsi3(0, maxInt(i32), 0);615 try test_one_mulsi3(0, maxInt(i32), 0);
616 test_one_mulsi3(maxInt(i32), 0, 0);616 try test_one_mulsi3(maxInt(i32), 0, 0);
617 test_one_mulsi3(0, -1, 0);617 try test_one_mulsi3(0, -1, 0);
618 test_one_mulsi3(-1, 0, 0);618 try test_one_mulsi3(-1, 0, 0);
619 test_one_mulsi3(0, -10, 0);619 try test_one_mulsi3(0, -10, 0);
620 test_one_mulsi3(-10, 0, 0);620 try test_one_mulsi3(-10, 0, 0);
621 test_one_mulsi3(0, minInt(i32), 0);621 try test_one_mulsi3(0, minInt(i32), 0);
622 test_one_mulsi3(minInt(i32), 0, 0);622 try test_one_mulsi3(minInt(i32), 0, 0);
623 test_one_mulsi3(1, 1, 1);623 try test_one_mulsi3(1, 1, 1);
624 test_one_mulsi3(1, 10, 10);624 try test_one_mulsi3(1, 10, 10);
625 test_one_mulsi3(10, 1, 10);625 try test_one_mulsi3(10, 1, 10);
626 test_one_mulsi3(1, maxInt(i32), maxInt(i32));626 try test_one_mulsi3(1, maxInt(i32), maxInt(i32));
627 test_one_mulsi3(maxInt(i32), 1, maxInt(i32));627 try test_one_mulsi3(maxInt(i32), 1, maxInt(i32));
628 test_one_mulsi3(1, -1, -1);628 try test_one_mulsi3(1, -1, -1);
629 test_one_mulsi3(1, -10, -10);629 try test_one_mulsi3(1, -10, -10);
630 test_one_mulsi3(-10, 1, -10);630 try test_one_mulsi3(-10, 1, -10);
631 test_one_mulsi3(1, minInt(i32), minInt(i32));631 try test_one_mulsi3(1, minInt(i32), minInt(i32));
632 test_one_mulsi3(minInt(i32), 1, minInt(i32));632 try test_one_mulsi3(minInt(i32), 1, minInt(i32));
633 test_one_mulsi3(46340, 46340, 2147395600);633 try test_one_mulsi3(46340, 46340, 2147395600);
634 test_one_mulsi3(-46340, 46340, -2147395600);634 try test_one_mulsi3(-46340, 46340, -2147395600);
635 test_one_mulsi3(46340, -46340, -2147395600);635 try test_one_mulsi3(46340, -46340, -2147395600);
636 test_one_mulsi3(-46340, -46340, 2147395600);636 try test_one_mulsi3(-46340, -46340, 2147395600);
637 test_one_mulsi3(4194303, 8192, @truncate(i32, 34359730176));637 try test_one_mulsi3(4194303, 8192, @truncate(i32, 34359730176));
638 test_one_mulsi3(-4194303, 8192, @truncate(i32, -34359730176));638 try test_one_mulsi3(-4194303, 8192, @truncate(i32, -34359730176));
639 test_one_mulsi3(4194303, -8192, @truncate(i32, -34359730176));639 try test_one_mulsi3(4194303, -8192, @truncate(i32, -34359730176));
640 test_one_mulsi3(-4194303, -8192, @truncate(i32, 34359730176));640 try test_one_mulsi3(-4194303, -8192, @truncate(i32, 34359730176));
641 test_one_mulsi3(8192, 4194303, @truncate(i32, 34359730176));641 try test_one_mulsi3(8192, 4194303, @truncate(i32, 34359730176));
642 test_one_mulsi3(-8192, 4194303, @truncate(i32, -34359730176));642 try test_one_mulsi3(-8192, 4194303, @truncate(i32, -34359730176));
643 test_one_mulsi3(8192, -4194303, @truncate(i32, -34359730176));643 try test_one_mulsi3(8192, -4194303, @truncate(i32, -34359730176));
644 test_one_mulsi3(-8192, -4194303, @truncate(i32, 34359730176));644 try test_one_mulsi3(-8192, -4194303, @truncate(i32, 34359730176));
645}645}
lib/std/special/compiler_rt/lshrdi3_test.zig+47-47
...@@ -6,55 +6,55 @@...@@ -6,55 +6,55 @@
6const __lshrdi3 = @import("shift.zig").__lshrdi3;6const __lshrdi3 = @import("shift.zig").__lshrdi3;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__lshrdi3(a: i64, b: i32, expected: u64) void {9fn test__lshrdi3(a: i64, b: i32, expected: u64) !void {
10 const x = __lshrdi3(a, b);10 const x = __lshrdi3(a, b);
11 testing.expectEqual(@bitCast(i64, expected), x);11 try testing.expectEqual(@bitCast(i64, expected), x);
12}12}
1313
14test "lshrdi3" {14test "lshrdi3" {
15 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF);15 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF);
16 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x91A2B3C4D5E6F7);16 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x91A2B3C4D5E6F7);
17 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37B);17 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37B);
18 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x2468ACF13579BD);18 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x2468ACF13579BD);
19 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDE);19 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDE);
2020
21 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x12345678);21 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x12345678);
22 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0x91A2B3C);22 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0x91A2B3C);
23 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0x48D159E);23 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0x48D159E);
24 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0x2468ACF);24 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0x2468ACF);
2525
26 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x1234567);26 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x1234567);
2727
28 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x91A2B3);28 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x91A2B3);
29 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x48D159);29 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x48D159);
30 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x2468AC);30 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x2468AC);
31 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x123456);31 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x123456);
3232
33 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0);33 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0);
34 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0);34 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0);
35 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0);35 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0);
36 test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0);36 try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0);
3737
38 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 0, 0xFEDCBA9876543210);38 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 0, 0xFEDCBA9876543210);
39 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 1, 0x7F6E5D4C3B2A1908);39 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 1, 0x7F6E5D4C3B2A1908);
40 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 2, 0x3FB72EA61D950C84);40 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 2, 0x3FB72EA61D950C84);
41 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 3, 0x1FDB97530ECA8642);41 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 3, 0x1FDB97530ECA8642);
42 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 4, 0xFEDCBA987654321);42 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 4, 0xFEDCBA987654321);
4343
44 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 28, 0xFEDCBA987);44 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 28, 0xFEDCBA987);
45 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 29, 0x7F6E5D4C3);45 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 29, 0x7F6E5D4C3);
46 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 30, 0x3FB72EA61);46 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 30, 0x3FB72EA61);
47 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 31, 0x1FDB97530);47 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 31, 0x1FDB97530);
4848
49 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 32, 0xFEDCBA98);49 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 32, 0xFEDCBA98);
5050
51 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 33, 0x7F6E5D4C);51 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 33, 0x7F6E5D4C);
52 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 34, 0x3FB72EA6);52 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 34, 0x3FB72EA6);
53 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 35, 0x1FDB9753);53 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 35, 0x1FDB9753);
54 test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 36, 0xFEDCBA9);54 try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 36, 0xFEDCBA9);
5555
56 test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 60, 0xA);56 try test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 60, 0xA);
57 test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 61, 0x5);57 try test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 61, 0x5);
58 test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 62, 0x2);58 try test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 62, 0x2);
59 test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 63, 0x1);59 try test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 63, 0x1);
60}60}
lib/std/special/compiler_rt/lshrti3_test.zig+38-38
...@@ -6,46 +6,46 @@...@@ -6,46 +6,46 @@
6const __lshrti3 = @import("shift.zig").__lshrti3;6const __lshrti3 = @import("shift.zig").__lshrti3;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__lshrti3(a: i128, b: i32, expected: i128) void {9fn test__lshrti3(a: i128, b: i32, expected: i128) !void {
10 const x = __lshrti3(a, b);10 const x = __lshrti3(a, b);
11 testing.expectEqual(expected, x);11 try testing.expectEqual(expected, x);
12}12}
1313
14test "lshrti3" {14test "lshrti3" {
15 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)));15 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)));
16 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0x7F6E5D4C3B2A190AFF6E5D4C3B2A190A)));16 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0x7F6E5D4C3B2A190AFF6E5D4C3B2A190A)));
17 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0x3FB72EA61D950C857FB72EA61D950C85)));17 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0x3FB72EA61D950C857FB72EA61D950C85)));
18 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0x1FDB97530ECA8642BFDB97530ECA8642)));18 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0x1FDB97530ECA8642BFDB97530ECA8642)));
19 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0x0FEDCBA9876543215FEDCBA987654321)));19 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0x0FEDCBA9876543215FEDCBA987654321)));
20 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0x0000000FEDCBA9876543215FEDCBA987)));20 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0x0000000FEDCBA9876543215FEDCBA987)));
21 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0x00000007F6E5D4C3B2A190AFF6E5D4C3)));21 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0x00000007F6E5D4C3B2A190AFF6E5D4C3)));
22 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0x00000003FB72EA61D950C857FB72EA61)));22 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0x00000003FB72EA61D950C857FB72EA61)));
23 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0x00000001FDB97530ECA8642BFDB97530)));23 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0x00000001FDB97530ECA8642BFDB97530)));
24 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0x00000000FEDCBA9876543215FEDCBA98)));24 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0x00000000FEDCBA9876543215FEDCBA98)));
25 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0x000000007F6E5D4C3B2A190AFF6E5D4C)));25 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0x000000007F6E5D4C3B2A190AFF6E5D4C)));
26 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0x000000003FB72EA61D950C857FB72EA6)));26 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0x000000003FB72EA61D950C857FB72EA6)));
27 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0x000000001FDB97530ECA8642BFDB9753)));27 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0x000000001FDB97530ECA8642BFDB9753)));
28 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0x000000000FEDCBA9876543215FEDCBA9)));28 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0x000000000FEDCBA9876543215FEDCBA9)));
29 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0x000000000000000FEDCBA9876543215F)));29 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0x000000000000000FEDCBA9876543215F)));
30 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0x0000000000000007F6E5D4C3B2A190AF)));30 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0x0000000000000007F6E5D4C3B2A190AF)));
31 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0x0000000000000003FB72EA61D950C857)));31 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0x0000000000000003FB72EA61D950C857)));
32 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0x0000000000000001FDB97530ECA8642B)));32 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0x0000000000000001FDB97530ECA8642B)));
33 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0x0000000000000000FEDCBA9876543215)));33 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0x0000000000000000FEDCBA9876543215)));
34 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0x00000000000000007F6E5D4C3B2A190A)));34 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0x00000000000000007F6E5D4C3B2A190A)));
35 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0x00000000000000003FB72EA61D950C85)));35 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0x00000000000000003FB72EA61D950C85)));
36 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0x00000000000000001FDB97530ECA8642)));36 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0x00000000000000001FDB97530ECA8642)));
37 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0x00000000000000000FEDCBA987654321)));37 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0x00000000000000000FEDCBA987654321)));
38 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0x00000000000000000000000FEDCBA987)));38 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0x00000000000000000000000FEDCBA987)));
39 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0x000000000000000000000007F6E5D4C3)));39 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0x000000000000000000000007F6E5D4C3)));
40 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0x000000000000000000000003FB72EA61)));40 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0x000000000000000000000003FB72EA61)));
41 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0x000000000000000000000001FDB97530)));41 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0x000000000000000000000001FDB97530)));
42 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0x000000000000000000000000FEDCBA98)));42 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0x000000000000000000000000FEDCBA98)));
43 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0x0000000000000000000000007F6E5D4C)));43 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0x0000000000000000000000007F6E5D4C)));
44 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0x0000000000000000000000003FB72EA6)));44 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0x0000000000000000000000003FB72EA6)));
45 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0x0000000000000000000000001FDB9753)));45 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0x0000000000000000000000001FDB9753)));
46 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0x0000000000000000000000000FEDCBA9)));46 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0x0000000000000000000000000FEDCBA9)));
47 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0x0000000000000000000000000000000F)));47 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0x0000000000000000000000000000000F)));
48 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000007)));48 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000007)));
49 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000003)));49 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000003)));
50 test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000001)));50 try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000001)));
51}51}
lib/std/special/compiler_rt/modti3_test.zig+19-19
...@@ -6,32 +6,32 @@...@@ -6,32 +6,32 @@
6const __modti3 = @import("modti3.zig").__modti3;6const __modti3 = @import("modti3.zig").__modti3;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__modti3(a: i128, b: i128, expected: i128) void {9fn test__modti3(a: i128, b: i128, expected: i128) !void {
10 const x = __modti3(a, b);10 const x = __modti3(a, b);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "modti3" {14test "modti3" {
15 test__modti3(0, 1, 0);15 try test__modti3(0, 1, 0);
16 test__modti3(0, -1, 0);16 try test__modti3(0, -1, 0);
17 test__modti3(5, 3, 2);17 try test__modti3(5, 3, 2);
18 test__modti3(5, -3, 2);18 try test__modti3(5, -3, 2);
19 test__modti3(-5, 3, -2);19 try test__modti3(-5, 3, -2);
20 test__modti3(-5, -3, -2);20 try test__modti3(-5, -3, -2);
2121
22 test__modti3(0x8000000000000000, 1, 0x0);22 try test__modti3(0x8000000000000000, 1, 0x0);
23 test__modti3(0x8000000000000000, -1, 0x0);23 try test__modti3(0x8000000000000000, -1, 0x0);
24 test__modti3(0x8000000000000000, 2, 0x0);24 try test__modti3(0x8000000000000000, 2, 0x0);
25 test__modti3(0x8000000000000000, -2, 0x0);25 try test__modti3(0x8000000000000000, -2, 0x0);
26 test__modti3(0x8000000000000000, 3, 2);26 try test__modti3(0x8000000000000000, 3, 2);
27 test__modti3(0x8000000000000000, -3, 2);27 try test__modti3(0x8000000000000000, -3, 2);
2828
29 test__modti3(make_ti(0x8000000000000000, 0), 1, 0x0);29 try test__modti3(make_ti(0x8000000000000000, 0), 1, 0x0);
30 test__modti3(make_ti(0x8000000000000000, 0), -1, 0x0);30 try test__modti3(make_ti(0x8000000000000000, 0), -1, 0x0);
31 test__modti3(make_ti(0x8000000000000000, 0), 2, 0x0);31 try test__modti3(make_ti(0x8000000000000000, 0), 2, 0x0);
32 test__modti3(make_ti(0x8000000000000000, 0), -2, 0x0);32 try test__modti3(make_ti(0x8000000000000000, 0), -2, 0x0);
33 test__modti3(make_ti(0x8000000000000000, 0), 3, -2);33 try test__modti3(make_ti(0x8000000000000000, 0), 3, -2);
34 test__modti3(make_ti(0x8000000000000000, 0), -3, -2);34 try test__modti3(make_ti(0x8000000000000000, 0), -3, -2);
35}35}
3636
37fn make_ti(high: u64, low: u64) i128 {37fn make_ti(high: u64, low: u64) i128 {
lib/std/special/compiler_rt/mulXf3_test.zig+9-9
...@@ -34,7 +34,7 @@ fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool {...@@ -34,7 +34,7 @@ fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool {
34 return false;34 return false;
35}35}
3636
37fn test__multf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {37fn test__multf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
38 const x = __multf3(a, b);38 const x = __multf3(a, b);
3939
40 if (compareResultLD(x, expected_hi, expected_lo))40 if (compareResultLD(x, expected_hi, expected_lo))
...@@ -50,42 +50,42 @@ fn makeNaN128(rand: u64) f128 {...@@ -50,42 +50,42 @@ fn makeNaN128(rand: u64) f128 {
50}50}
51test "multf3" {51test "multf3" {
52 // qNaN * any = qNaN52 // qNaN * any = qNaN
53 test__multf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);53 try test__multf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
5454
55 // NaN * any = NaN55 // NaN * any = NaN
56 const a = makeNaN128(0x800030000000);56 const a = makeNaN128(0x800030000000);
57 test__multf3(a, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);57 try test__multf3(a, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
58 // inf * any = inf58 // inf * any = inf
59 test__multf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);59 try test__multf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
6060
61 // any * any61 // any * any
62 test__multf3(62 try test__multf3(
63 @bitCast(f128, @as(u128, 0x40042eab345678439abcdefea5678234)),63 @bitCast(f128, @as(u128, 0x40042eab345678439abcdefea5678234)),
64 @bitCast(f128, @as(u128, 0x3ffeedcb34a235253948765432134675)),64 @bitCast(f128, @as(u128, 0x3ffeedcb34a235253948765432134675)),
65 0x400423e7f9e3c9fc,65 0x400423e7f9e3c9fc,
66 0xd906c2c2a85777c4,66 0xd906c2c2a85777c4,
67 );67 );
6868
69 test__multf3(69 try test__multf3(
70 @bitCast(f128, @as(u128, 0x3fcd353e45674d89abacc3a2ebf3ff50)),70 @bitCast(f128, @as(u128, 0x3fcd353e45674d89abacc3a2ebf3ff50)),
71 @bitCast(f128, @as(u128, 0x3ff6ed8764648369535adf4be3214568)),71 @bitCast(f128, @as(u128, 0x3ff6ed8764648369535adf4be3214568)),
72 0x3fc52a163c6223fc,72 0x3fc52a163c6223fc,
73 0xc94c4bf0430768b4,73 0xc94c4bf0430768b4,
74 );74 );
7575
76 test__multf3(76 try test__multf3(
77 0x1.234425696abcad34a35eeffefdcbap+456,77 0x1.234425696abcad34a35eeffefdcbap+456,
78 0x451.ed98d76e5d46e5f24323dff21ffp+600,78 0x451.ed98d76e5d46e5f24323dff21ffp+600,
79 0x44293a91de5e0e94,79 0x44293a91de5e0e94,
80 0xe8ed17cc2cdf64ac,80 0xe8ed17cc2cdf64ac,
81 );81 );
8282
83 test__multf3(83 try test__multf3(
84 @bitCast(f128, @as(u128, 0x3f154356473c82a9fabf2d22ace345df)),84 @bitCast(f128, @as(u128, 0x3f154356473c82a9fabf2d22ace345df)),
85 @bitCast(f128, @as(u128, 0x3e38eda98765476743ab21da23d45679)),85 @bitCast(f128, @as(u128, 0x3e38eda98765476743ab21da23d45679)),
86 0x3d4f37c1a3137cae,86 0x3d4f37c1a3137cae,
87 0xfc6807048bc2836a,87 0xfc6807048bc2836a,
88 );88 );
8989
90 test__multf3(0x1.23456734245345p-10000, 0x1.edcba524498724p-6497, 0x0, 0x0);90 try test__multf3(0x1.23456734245345p-10000, 0x1.edcba524498724p-6497, 0x0, 0x0);
91}91}
lib/std/special/compiler_rt/muldi3_test.zig+42-42
...@@ -6,51 +6,51 @@...@@ -6,51 +6,51 @@
6const __muldi3 = @import("muldi3.zig").__muldi3;6const __muldi3 = @import("muldi3.zig").__muldi3;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__muldi3(a: i64, b: i64, expected: i64) void {9fn test__muldi3(a: i64, b: i64, expected: i64) !void {
10 const x = __muldi3(a, b);10 const x = __muldi3(a, b);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "muldi3" {14test "muldi3" {
15 test__muldi3(0, 0, 0);15 try test__muldi3(0, 0, 0);
16 test__muldi3(0, 1, 0);16 try test__muldi3(0, 1, 0);
17 test__muldi3(1, 0, 0);17 try test__muldi3(1, 0, 0);
18 test__muldi3(0, 10, 0);18 try test__muldi3(0, 10, 0);
19 test__muldi3(10, 0, 0);19 try test__muldi3(10, 0, 0);
20 test__muldi3(0, 81985529216486895, 0);20 try test__muldi3(0, 81985529216486895, 0);
21 test__muldi3(81985529216486895, 0, 0);21 try test__muldi3(81985529216486895, 0, 0);
2222
23 test__muldi3(0, -1, 0);23 try test__muldi3(0, -1, 0);
24 test__muldi3(-1, 0, 0);24 try test__muldi3(-1, 0, 0);
25 test__muldi3(0, -10, 0);25 try test__muldi3(0, -10, 0);
26 test__muldi3(-10, 0, 0);26 try test__muldi3(-10, 0, 0);
27 test__muldi3(0, -81985529216486895, 0);27 try test__muldi3(0, -81985529216486895, 0);
28 test__muldi3(-81985529216486895, 0, 0);28 try test__muldi3(-81985529216486895, 0, 0);
2929
30 test__muldi3(1, 1, 1);30 try test__muldi3(1, 1, 1);
31 test__muldi3(1, 10, 10);31 try test__muldi3(1, 10, 10);
32 test__muldi3(10, 1, 10);32 try test__muldi3(10, 1, 10);
33 test__muldi3(1, 81985529216486895, 81985529216486895);33 try test__muldi3(1, 81985529216486895, 81985529216486895);
34 test__muldi3(81985529216486895, 1, 81985529216486895);34 try test__muldi3(81985529216486895, 1, 81985529216486895);
3535
36 test__muldi3(1, -1, -1);36 try test__muldi3(1, -1, -1);
37 test__muldi3(1, -10, -10);37 try test__muldi3(1, -10, -10);
38 test__muldi3(-10, 1, -10);38 try test__muldi3(-10, 1, -10);
39 test__muldi3(1, -81985529216486895, -81985529216486895);39 try test__muldi3(1, -81985529216486895, -81985529216486895);
40 test__muldi3(-81985529216486895, 1, -81985529216486895);40 try test__muldi3(-81985529216486895, 1, -81985529216486895);
4141
42 test__muldi3(3037000499, 3037000499, 9223372030926249001);42 try test__muldi3(3037000499, 3037000499, 9223372030926249001);
43 test__muldi3(-3037000499, 3037000499, -9223372030926249001);43 try test__muldi3(-3037000499, 3037000499, -9223372030926249001);
44 test__muldi3(3037000499, -3037000499, -9223372030926249001);44 try test__muldi3(3037000499, -3037000499, -9223372030926249001);
45 test__muldi3(-3037000499, -3037000499, 9223372030926249001);45 try test__muldi3(-3037000499, -3037000499, 9223372030926249001);
4646
47 test__muldi3(4398046511103, 2097152, 9223372036852678656);47 try test__muldi3(4398046511103, 2097152, 9223372036852678656);
48 test__muldi3(-4398046511103, 2097152, -9223372036852678656);48 try test__muldi3(-4398046511103, 2097152, -9223372036852678656);
49 test__muldi3(4398046511103, -2097152, -9223372036852678656);49 try test__muldi3(4398046511103, -2097152, -9223372036852678656);
50 test__muldi3(-4398046511103, -2097152, 9223372036852678656);50 try test__muldi3(-4398046511103, -2097152, 9223372036852678656);
5151
52 test__muldi3(2097152, 4398046511103, 9223372036852678656);52 try test__muldi3(2097152, 4398046511103, 9223372036852678656);
53 test__muldi3(-2097152, 4398046511103, -9223372036852678656);53 try test__muldi3(-2097152, 4398046511103, -9223372036852678656);
54 test__muldi3(2097152, -4398046511103, -9223372036852678656);54 try test__muldi3(2097152, -4398046511103, -9223372036852678656);
55 test__muldi3(-2097152, -4398046511103, 9223372036852678656);55 try test__muldi3(-2097152, -4398046511103, 9223372036852678656);
56}56}
lib/std/special/compiler_rt/mulodi4_test.zig+66-66
...@@ -6,85 +6,85 @@...@@ -6,85 +6,85 @@
6const __mulodi4 = @import("mulodi4.zig").__mulodi4;6const __mulodi4 = @import("mulodi4.zig").__mulodi4;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__mulodi4(a: i64, b: i64, expected: i64, expected_overflow: c_int) void {9fn test__mulodi4(a: i64, b: i64, expected: i64, expected_overflow: c_int) !void {
10 var overflow: c_int = undefined;10 var overflow: c_int = undefined;
11 const x = __mulodi4(a, b, &overflow);11 const x = __mulodi4(a, b, &overflow);
12 try testing.expect(overflow == expected_overflow and (expected_overflow != 0 or x == expected));12 try testing.expect(overflow == expected_overflow and (expected_overflow != 0 or x == expected));
13}13}
1414
15test "mulodi4" {15test "mulodi4" {
16 test__mulodi4(0, 0, 0, 0);16 try test__mulodi4(0, 0, 0, 0);
17 test__mulodi4(0, 1, 0, 0);17 try test__mulodi4(0, 1, 0, 0);
18 test__mulodi4(1, 0, 0, 0);18 try test__mulodi4(1, 0, 0, 0);
19 test__mulodi4(0, 10, 0, 0);19 try test__mulodi4(0, 10, 0, 0);
20 test__mulodi4(10, 0, 0, 0);20 try test__mulodi4(10, 0, 0, 0);
21 test__mulodi4(0, 81985529216486895, 0, 0);21 try test__mulodi4(0, 81985529216486895, 0, 0);
22 test__mulodi4(81985529216486895, 0, 0, 0);22 try test__mulodi4(81985529216486895, 0, 0, 0);
2323
24 test__mulodi4(0, -1, 0, 0);24 try test__mulodi4(0, -1, 0, 0);
25 test__mulodi4(-1, 0, 0, 0);25 try test__mulodi4(-1, 0, 0, 0);
26 test__mulodi4(0, -10, 0, 0);26 try test__mulodi4(0, -10, 0, 0);
27 test__mulodi4(-10, 0, 0, 0);27 try test__mulodi4(-10, 0, 0, 0);
28 test__mulodi4(0, -81985529216486895, 0, 0);28 try test__mulodi4(0, -81985529216486895, 0, 0);
29 test__mulodi4(-81985529216486895, 0, 0, 0);29 try test__mulodi4(-81985529216486895, 0, 0, 0);
3030
31 test__mulodi4(1, 1, 1, 0);31 try test__mulodi4(1, 1, 1, 0);
32 test__mulodi4(1, 10, 10, 0);32 try test__mulodi4(1, 10, 10, 0);
33 test__mulodi4(10, 1, 10, 0);33 try test__mulodi4(10, 1, 10, 0);
34 test__mulodi4(1, 81985529216486895, 81985529216486895, 0);34 try test__mulodi4(1, 81985529216486895, 81985529216486895, 0);
35 test__mulodi4(81985529216486895, 1, 81985529216486895, 0);35 try test__mulodi4(81985529216486895, 1, 81985529216486895, 0);
3636
37 test__mulodi4(1, -1, -1, 0);37 try test__mulodi4(1, -1, -1, 0);
38 test__mulodi4(1, -10, -10, 0);38 try test__mulodi4(1, -10, -10, 0);
39 test__mulodi4(-10, 1, -10, 0);39 try test__mulodi4(-10, 1, -10, 0);
40 test__mulodi4(1, -81985529216486895, -81985529216486895, 0);40 try test__mulodi4(1, -81985529216486895, -81985529216486895, 0);
41 test__mulodi4(-81985529216486895, 1, -81985529216486895, 0);41 try test__mulodi4(-81985529216486895, 1, -81985529216486895, 0);
4242
43 test__mulodi4(3037000499, 3037000499, 9223372030926249001, 0);43 try test__mulodi4(3037000499, 3037000499, 9223372030926249001, 0);
44 test__mulodi4(-3037000499, 3037000499, -9223372030926249001, 0);44 try test__mulodi4(-3037000499, 3037000499, -9223372030926249001, 0);
45 test__mulodi4(3037000499, -3037000499, -9223372030926249001, 0);45 try test__mulodi4(3037000499, -3037000499, -9223372030926249001, 0);
46 test__mulodi4(-3037000499, -3037000499, 9223372030926249001, 0);46 try test__mulodi4(-3037000499, -3037000499, 9223372030926249001, 0);
4747
48 test__mulodi4(4398046511103, 2097152, 9223372036852678656, 0);48 try test__mulodi4(4398046511103, 2097152, 9223372036852678656, 0);
49 test__mulodi4(-4398046511103, 2097152, -9223372036852678656, 0);49 try test__mulodi4(-4398046511103, 2097152, -9223372036852678656, 0);
50 test__mulodi4(4398046511103, -2097152, -9223372036852678656, 0);50 try test__mulodi4(4398046511103, -2097152, -9223372036852678656, 0);
51 test__mulodi4(-4398046511103, -2097152, 9223372036852678656, 0);51 try test__mulodi4(-4398046511103, -2097152, 9223372036852678656, 0);
5252
53 test__mulodi4(2097152, 4398046511103, 9223372036852678656, 0);53 try test__mulodi4(2097152, 4398046511103, 9223372036852678656, 0);
54 test__mulodi4(-2097152, 4398046511103, -9223372036852678656, 0);54 try test__mulodi4(-2097152, 4398046511103, -9223372036852678656, 0);
55 test__mulodi4(2097152, -4398046511103, -9223372036852678656, 0);55 try test__mulodi4(2097152, -4398046511103, -9223372036852678656, 0);
56 test__mulodi4(-2097152, -4398046511103, 9223372036852678656, 0);56 try test__mulodi4(-2097152, -4398046511103, 9223372036852678656, 0);
5757
58 test__mulodi4(0x7FFFFFFFFFFFFFFF, -2, 2, 1);58 try test__mulodi4(0x7FFFFFFFFFFFFFFF, -2, 2, 1);
59 test__mulodi4(-2, 0x7FFFFFFFFFFFFFFF, 2, 1);59 try test__mulodi4(-2, 0x7FFFFFFFFFFFFFFF, 2, 1);
60 test__mulodi4(0x7FFFFFFFFFFFFFFF, -1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);60 try test__mulodi4(0x7FFFFFFFFFFFFFFF, -1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
61 test__mulodi4(-1, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);61 try test__mulodi4(-1, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
62 test__mulodi4(0x7FFFFFFFFFFFFFFF, 0, 0, 0);62 try test__mulodi4(0x7FFFFFFFFFFFFFFF, 0, 0, 0);
63 test__mulodi4(0, 0x7FFFFFFFFFFFFFFF, 0, 0);63 try test__mulodi4(0, 0x7FFFFFFFFFFFFFFF, 0, 0);
64 test__mulodi4(0x7FFFFFFFFFFFFFFF, 1, 0x7FFFFFFFFFFFFFFF, 0);64 try test__mulodi4(0x7FFFFFFFFFFFFFFF, 1, 0x7FFFFFFFFFFFFFFF, 0);
65 test__mulodi4(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF, 0);65 try test__mulodi4(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF, 0);
66 test__mulodi4(0x7FFFFFFFFFFFFFFF, 2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);66 try test__mulodi4(0x7FFFFFFFFFFFFFFF, 2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
67 test__mulodi4(2, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);67 try test__mulodi4(2, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
6868
69 test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);69 try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
70 test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);70 try test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
71 test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -1, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);71 try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -1, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
72 test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);72 try test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
73 test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0, 0);73 try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0, 0);
74 test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0);74 try test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0);
75 test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 1, @bitCast(i64, @as(u64, 0x8000000000000000)), 0);75 try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 1, @bitCast(i64, @as(u64, 0x8000000000000000)), 0);
76 test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 0);76 try test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 0);
77 test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);77 try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
78 test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);78 try test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
7979
80 test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);80 try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
81 test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 1);81 try test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
82 test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -1, 0x7FFFFFFFFFFFFFFF, 0);82 try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -1, 0x7FFFFFFFFFFFFFFF, 0);
83 test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0x7FFFFFFFFFFFFFFF, 0);83 try test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0x7FFFFFFFFFFFFFFF, 0);
84 test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0, 0);84 try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0, 0);
85 test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0);85 try test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0);
86 test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);86 try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
87 test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 0);87 try test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
88 test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);88 try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
89 test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);89 try test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
90}90}
lib/std/special/compiler_rt/muloti4_test.zig+57-57
...@@ -6,76 +6,76 @@...@@ -6,76 +6,76 @@
6const __muloti4 = @import("muloti4.zig").__muloti4;6const __muloti4 = @import("muloti4.zig").__muloti4;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__muloti4(a: i128, b: i128, expected: i128, expected_overflow: c_int) void {9fn test__muloti4(a: i128, b: i128, expected: i128, expected_overflow: c_int) !void {
10 var overflow: c_int = undefined;10 var overflow: c_int = undefined;
11 const x = __muloti4(a, b, &overflow);11 const x = __muloti4(a, b, &overflow);
12 try testing.expect(overflow == expected_overflow and (expected_overflow != 0 or x == expected));12 try testing.expect(overflow == expected_overflow and (expected_overflow != 0 or x == expected));
13}13}
1414
15test "muloti4" {15test "muloti4" {
16 test__muloti4(0, 0, 0, 0);16 try test__muloti4(0, 0, 0, 0);
17 test__muloti4(0, 1, 0, 0);17 try test__muloti4(0, 1, 0, 0);
18 test__muloti4(1, 0, 0, 0);18 try test__muloti4(1, 0, 0, 0);
19 test__muloti4(0, 10, 0, 0);19 try test__muloti4(0, 10, 0, 0);
20 test__muloti4(10, 0, 0, 0);20 try test__muloti4(10, 0, 0, 0);
2121
22 test__muloti4(0, 81985529216486895, 0, 0);22 try test__muloti4(0, 81985529216486895, 0, 0);
23 test__muloti4(81985529216486895, 0, 0, 0);23 try test__muloti4(81985529216486895, 0, 0, 0);
2424
25 test__muloti4(0, -1, 0, 0);25 try test__muloti4(0, -1, 0, 0);
26 test__muloti4(-1, 0, 0, 0);26 try test__muloti4(-1, 0, 0, 0);
27 test__muloti4(0, -10, 0, 0);27 try test__muloti4(0, -10, 0, 0);
28 test__muloti4(-10, 0, 0, 0);28 try test__muloti4(-10, 0, 0, 0);
29 test__muloti4(0, -81985529216486895, 0, 0);29 try test__muloti4(0, -81985529216486895, 0, 0);
30 test__muloti4(-81985529216486895, 0, 0, 0);30 try test__muloti4(-81985529216486895, 0, 0, 0);
3131
32 test__muloti4(3037000499, 3037000499, 9223372030926249001, 0);32 try test__muloti4(3037000499, 3037000499, 9223372030926249001, 0);
33 test__muloti4(-3037000499, 3037000499, -9223372030926249001, 0);33 try test__muloti4(-3037000499, 3037000499, -9223372030926249001, 0);
34 test__muloti4(3037000499, -3037000499, -9223372030926249001, 0);34 try test__muloti4(3037000499, -3037000499, -9223372030926249001, 0);
35 test__muloti4(-3037000499, -3037000499, 9223372030926249001, 0);35 try test__muloti4(-3037000499, -3037000499, 9223372030926249001, 0);
3636
37 test__muloti4(4398046511103, 2097152, 9223372036852678656, 0);37 try test__muloti4(4398046511103, 2097152, 9223372036852678656, 0);
38 test__muloti4(-4398046511103, 2097152, -9223372036852678656, 0);38 try test__muloti4(-4398046511103, 2097152, -9223372036852678656, 0);
39 test__muloti4(4398046511103, -2097152, -9223372036852678656, 0);39 try test__muloti4(4398046511103, -2097152, -9223372036852678656, 0);
40 test__muloti4(-4398046511103, -2097152, 9223372036852678656, 0);40 try test__muloti4(-4398046511103, -2097152, 9223372036852678656, 0);
4141
42 test__muloti4(2097152, 4398046511103, 9223372036852678656, 0);42 try test__muloti4(2097152, 4398046511103, 9223372036852678656, 0);
43 test__muloti4(-2097152, 4398046511103, -9223372036852678656, 0);43 try test__muloti4(-2097152, 4398046511103, -9223372036852678656, 0);
44 test__muloti4(2097152, -4398046511103, -9223372036852678656, 0);44 try test__muloti4(2097152, -4398046511103, -9223372036852678656, 0);
45 test__muloti4(-2097152, -4398046511103, 9223372036852678656, 0);45 try test__muloti4(-2097152, -4398046511103, 9223372036852678656, 0);
4646
47 test__muloti4(@bitCast(i128, @as(u128, 0x00000000000000B504F333F9DE5BE000)), @bitCast(i128, @as(u128, 0x000000000000000000B504F333F9DE5B)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFF328DF915DA296E8A000)), 0);47 try test__muloti4(@bitCast(i128, @as(u128, 0x00000000000000B504F333F9DE5BE000)), @bitCast(i128, @as(u128, 0x000000000000000000B504F333F9DE5B)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFF328DF915DA296E8A000)), 0);
48 test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);48 try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
49 test__muloti4(-2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);49 try test__muloti4(-2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
5050
51 test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);51 try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
52 test__muloti4(-1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);52 try test__muloti4(-1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
53 test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0, 0);53 try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0, 0);
54 test__muloti4(0, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0);54 try test__muloti4(0, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0);
55 test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);55 try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
56 test__muloti4(1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);56 try test__muloti4(1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
57 test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);57 try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
58 test__muloti4(2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);58 try test__muloti4(2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
5959
60 test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);60 try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
61 test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);61 try test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
62 test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);62 try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
63 test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);63 try test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
64 test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0, 0);64 try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0, 0);
65 test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0);65 try test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0);
66 test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0);66 try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0);
67 test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0);67 try test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0);
68 test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);68 try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
69 test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);69 try test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
7070
71 test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);71 try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
72 test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);72 try test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
73 test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);73 try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
74 test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);74 try test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
75 test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0, 0);75 try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0, 0);
76 test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0);76 try test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0);
77 test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);77 try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
78 test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);78 try test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
79 test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);79 try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
80 test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);80 try test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
81}81}
lib/std/special/compiler_rt/multi3_test.zig+44-44
...@@ -6,53 +6,53 @@...@@ -6,53 +6,53 @@
6const __multi3 = @import("multi3.zig").__multi3;6const __multi3 = @import("multi3.zig").__multi3;
7const testing = @import("std").testing;7const testing = @import("std").testing;
88
9fn test__multi3(a: i128, b: i128, expected: i128) void {9fn test__multi3(a: i128, b: i128, expected: i128) !void {
10 const x = __multi3(a, b);10 const x = __multi3(a, b);
11 try testing.expect(x == expected);11 try testing.expect(x == expected);
12}12}
1313
14test "multi3" {14test "multi3" {
15 test__multi3(0, 0, 0);15 try test__multi3(0, 0, 0);
16 test__multi3(0, 1, 0);16 try test__multi3(0, 1, 0);
17 test__multi3(1, 0, 0);17 try test__multi3(1, 0, 0);
18 test__multi3(0, 10, 0);18 try test__multi3(0, 10, 0);
19 test__multi3(10, 0, 0);19 try test__multi3(10, 0, 0);
20 test__multi3(0, 81985529216486895, 0);20 try test__multi3(0, 81985529216486895, 0);
21 test__multi3(81985529216486895, 0, 0);21 try test__multi3(81985529216486895, 0, 0);
2222
23 test__multi3(0, -1, 0);23 try test__multi3(0, -1, 0);
24 test__multi3(-1, 0, 0);24 try test__multi3(-1, 0, 0);
25 test__multi3(0, -10, 0);25 try test__multi3(0, -10, 0);
26 test__multi3(-10, 0, 0);26 try test__multi3(-10, 0, 0);
27 test__multi3(0, -81985529216486895, 0);27 try test__multi3(0, -81985529216486895, 0);
28 test__multi3(-81985529216486895, 0, 0);28 try test__multi3(-81985529216486895, 0, 0);
2929
30 test__multi3(1, 1, 1);30 try test__multi3(1, 1, 1);
31 test__multi3(1, 10, 10);31 try test__multi3(1, 10, 10);
32 test__multi3(10, 1, 10);32 try test__multi3(10, 1, 10);
33 test__multi3(1, 81985529216486895, 81985529216486895);33 try test__multi3(1, 81985529216486895, 81985529216486895);
34 test__multi3(81985529216486895, 1, 81985529216486895);34 try test__multi3(81985529216486895, 1, 81985529216486895);
3535
36 test__multi3(1, -1, -1);36 try test__multi3(1, -1, -1);
37 test__multi3(1, -10, -10);37 try test__multi3(1, -10, -10);
38 test__multi3(-10, 1, -10);38 try test__multi3(-10, 1, -10);
39 test__multi3(1, -81985529216486895, -81985529216486895);39 try test__multi3(1, -81985529216486895, -81985529216486895);
40 test__multi3(-81985529216486895, 1, -81985529216486895);40 try test__multi3(-81985529216486895, 1, -81985529216486895);
4141
42 test__multi3(3037000499, 3037000499, 9223372030926249001);42 try test__multi3(3037000499, 3037000499, 9223372030926249001);
43 test__multi3(-3037000499, 3037000499, -9223372030926249001);43 try test__multi3(-3037000499, 3037000499, -9223372030926249001);
44 test__multi3(3037000499, -3037000499, -9223372030926249001);44 try test__multi3(3037000499, -3037000499, -9223372030926249001);
45 test__multi3(-3037000499, -3037000499, 9223372030926249001);45 try test__multi3(-3037000499, -3037000499, 9223372030926249001);
4646
47 test__multi3(4398046511103, 2097152, 9223372036852678656);47 try test__multi3(4398046511103, 2097152, 9223372036852678656);
48 test__multi3(-4398046511103, 2097152, -9223372036852678656);48 try test__multi3(-4398046511103, 2097152, -9223372036852678656);
49 test__multi3(4398046511103, -2097152, -9223372036852678656);49 try test__multi3(4398046511103, -2097152, -9223372036852678656);
50 test__multi3(-4398046511103, -2097152, 9223372036852678656);50 try test__multi3(-4398046511103, -2097152, 9223372036852678656);
5151
52 test__multi3(2097152, 4398046511103, 9223372036852678656);52 try test__multi3(2097152, 4398046511103, 9223372036852678656);
53 test__multi3(-2097152, 4398046511103, -9223372036852678656);53 try test__multi3(-2097152, 4398046511103, -9223372036852678656);
54 test__multi3(2097152, -4398046511103, -9223372036852678656);54 try test__multi3(2097152, -4398046511103, -9223372036852678656);
55 test__multi3(-2097152, -4398046511103, 9223372036852678656);55 try test__multi3(-2097152, -4398046511103, 9223372036852678656);
5656
57 test__multi3(0x00000000000000B504F333F9DE5BE000, 0x000000000000000000B504F333F9DE5B, 0x7FFFFFFFFFFFF328DF915DA296E8A000);57 try test__multi3(0x00000000000000B504F333F9DE5BE000, 0x000000000000000000B504F333F9DE5B, 0x7FFFFFFFFFFFF328DF915DA296E8A000);
58}58}
lib/std/special/compiler_rt/popcountdi2_test.zig+7-7
...@@ -15,18 +15,18 @@ fn naive_popcount(a_param: i64) i32 {...@@ -15,18 +15,18 @@ fn naive_popcount(a_param: i64) i32 {
15 return r;15 return r;
16}16}
1717
18fn test__popcountdi2(a: i64) void {18fn test__popcountdi2(a: i64) !void {
19 const x = __popcountdi2(a);19 const x = __popcountdi2(a);
20 const expected = naive_popcount(a);20 const expected = naive_popcount(a);
21 try testing.expect(expected == x);21 try testing.expect(expected == x);
22}22}
2323
24test "popcountdi2" {24test "popcountdi2" {
25 test__popcountdi2(0);25 try test__popcountdi2(0);
26 test__popcountdi2(1);26 try test__popcountdi2(1);
27 test__popcountdi2(2);27 try test__popcountdi2(2);
28 test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFD)));28 try test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFD)));
29 test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFE)));29 try test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFE)));
30 test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFF)));30 try test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFF)));
31 // TODO some fuzz testing31 // TODO some fuzz testing
32}32}
lib/std/special/compiler_rt/truncXfYf2_test.zig+36-36
...@@ -5,67 +5,67 @@...@@ -5,67 +5,67 @@
5// and substantial portions of the software.5// and substantial portions of the software.
6const __truncsfhf2 = @import("truncXfYf2.zig").__truncsfhf2;6const __truncsfhf2 = @import("truncXfYf2.zig").__truncsfhf2;
77
8fn test__truncsfhf2(a: u32, expected: u16) void {8fn test__truncsfhf2(a: u32, expected: u16) !void {
9 const actual = __truncsfhf2(@bitCast(f32, a));9 const actual = __truncsfhf2(@bitCast(f32, a));
1010
11 if (actual == expected) {11 if (actual == expected) {
12 return;12 return;
13 }13 }
1414
15 @panic("__truncsfhf2 test failure");15 return error.TestFailure;
16}16}
1717
18test "truncsfhf2" {18test "truncsfhf2" {
19 test__truncsfhf2(0x7fc00000, 0x7e00); // qNaN19 try test__truncsfhf2(0x7fc00000, 0x7e00); // qNaN
20 test__truncsfhf2(0x7fe00000, 0x7f00); // sNaN20 try test__truncsfhf2(0x7fe00000, 0x7f00); // sNaN
2121
22 test__truncsfhf2(0, 0); // 022 try test__truncsfhf2(0, 0); // 0
23 test__truncsfhf2(0x80000000, 0x8000); // -023 try test__truncsfhf2(0x80000000, 0x8000); // -0
2424
25 test__truncsfhf2(0x7f800000, 0x7c00); // inf25 try test__truncsfhf2(0x7f800000, 0x7c00); // inf
26 test__truncsfhf2(0xff800000, 0xfc00); // -inf26 try test__truncsfhf2(0xff800000, 0xfc00); // -inf
2727
28 test__truncsfhf2(0x477ff000, 0x7c00); // 65520 -> inf28 try test__truncsfhf2(0x477ff000, 0x7c00); // 65520 -> inf
29 test__truncsfhf2(0xc77ff000, 0xfc00); // -65520 -> -inf29 try test__truncsfhf2(0xc77ff000, 0xfc00); // -65520 -> -inf
3030
31 test__truncsfhf2(0x71cc3892, 0x7c00); // 0x1.987124876876324p+100 -> inf31 try test__truncsfhf2(0x71cc3892, 0x7c00); // 0x1.987124876876324p+100 -> inf
32 test__truncsfhf2(0xf1cc3892, 0xfc00); // -0x1.987124876876324p+100 -> -inf32 try test__truncsfhf2(0xf1cc3892, 0xfc00); // -0x1.987124876876324p+100 -> -inf
3333
34 test__truncsfhf2(0x38800000, 0x0400); // normal (min), 2**-1434 try test__truncsfhf2(0x38800000, 0x0400); // normal (min), 2**-14
35 test__truncsfhf2(0xb8800000, 0x8400); // normal (min), -2**-1435 try test__truncsfhf2(0xb8800000, 0x8400); // normal (min), -2**-14
3636
37 test__truncsfhf2(0x477fe000, 0x7bff); // normal (max), 6550437 try test__truncsfhf2(0x477fe000, 0x7bff); // normal (max), 65504
38 test__truncsfhf2(0xc77fe000, 0xfbff); // normal (max), -6550438 try test__truncsfhf2(0xc77fe000, 0xfbff); // normal (max), -65504
3939
40 test__truncsfhf2(0x477fe100, 0x7bff); // normal, 65505 -> 6550440 try test__truncsfhf2(0x477fe100, 0x7bff); // normal, 65505 -> 65504
41 test__truncsfhf2(0xc77fe100, 0xfbff); // normal, -65505 -> -6550441 try test__truncsfhf2(0xc77fe100, 0xfbff); // normal, -65505 -> -65504
4242
43 test__truncsfhf2(0x477fef00, 0x7bff); // normal, 65519 -> 6550443 try test__truncsfhf2(0x477fef00, 0x7bff); // normal, 65519 -> 65504
44 test__truncsfhf2(0xc77fef00, 0xfbff); // normal, -65519 -> -6550444 try test__truncsfhf2(0xc77fef00, 0xfbff); // normal, -65519 -> -65504
4545
46 test__truncsfhf2(0x3f802000, 0x3c01); // normal, 1 + 2**-1046 try test__truncsfhf2(0x3f802000, 0x3c01); // normal, 1 + 2**-10
47 test__truncsfhf2(0xbf802000, 0xbc01); // normal, -1 - 2**-1047 try test__truncsfhf2(0xbf802000, 0xbc01); // normal, -1 - 2**-10
4848
49 test__truncsfhf2(0x3eaaa000, 0x3555); // normal, approx. 1/349 try test__truncsfhf2(0x3eaaa000, 0x3555); // normal, approx. 1/3
50 test__truncsfhf2(0xbeaaa000, 0xb555); // normal, approx. -1/350 try test__truncsfhf2(0xbeaaa000, 0xb555); // normal, approx. -1/3
5151
52 test__truncsfhf2(0x40490fdb, 0x4248); // normal, 3.141592653552 try test__truncsfhf2(0x40490fdb, 0x4248); // normal, 3.1415926535
53 test__truncsfhf2(0xc0490fdb, 0xc248); // normal, -3.141592653553 try test__truncsfhf2(0xc0490fdb, 0xc248); // normal, -3.1415926535
5454
55 test__truncsfhf2(0x45cc3892, 0x6e62); // normal, 0x1.987124876876324p+1255 try test__truncsfhf2(0x45cc3892, 0x6e62); // normal, 0x1.987124876876324p+12
5656
57 test__truncsfhf2(0x3f800000, 0x3c00); // normal, 157 try test__truncsfhf2(0x3f800000, 0x3c00); // normal, 1
58 test__truncsfhf2(0x38800000, 0x0400); // normal, 0x1.0p-1458 try test__truncsfhf2(0x38800000, 0x0400); // normal, 0x1.0p-14
5959
60 test__truncsfhf2(0x33800000, 0x0001); // denormal (min), 2**-2460 try test__truncsfhf2(0x33800000, 0x0001); // denormal (min), 2**-24
61 test__truncsfhf2(0xb3800000, 0x8001); // denormal (min), -2**-2461 try test__truncsfhf2(0xb3800000, 0x8001); // denormal (min), -2**-24
6262
63 test__truncsfhf2(0x387fc000, 0x03ff); // denormal (max), 2**-14 - 2**-2463 try test__truncsfhf2(0x387fc000, 0x03ff); // denormal (max), 2**-14 - 2**-24
64 test__truncsfhf2(0xb87fc000, 0x83ff); // denormal (max), -2**-14 + 2**-2464 try test__truncsfhf2(0xb87fc000, 0x83ff); // denormal (max), -2**-14 + 2**-24
6565
66 test__truncsfhf2(0x35800000, 0x0010); // denormal, 0x1.0p-2066 try test__truncsfhf2(0x35800000, 0x0010); // denormal, 0x1.0p-20
67 test__truncsfhf2(0x33280000, 0x0001); // denormal, 0x1.5p-25 -> 0x1.0p-2467 try test__truncsfhf2(0x33280000, 0x0001); // denormal, 0x1.5p-25 -> 0x1.0p-24
68 test__truncsfhf2(0x33000000, 0x0000); // 0x1.0p-25 -> zero68 try test__truncsfhf2(0x33000000, 0x0000); // 0x1.0p-25 -> zero
69}69}
7070
71const __truncdfhf2 = @import("truncXfYf2.zig").__truncdfhf2;71const __truncdfhf2 = @import("truncXfYf2.zig").__truncdfhf2;
lib/std/special/compiler_rt/udivmoddi4_test.zig+2-2
...@@ -8,7 +8,7 @@...@@ -8,7 +8,7 @@
8const __udivmoddi4 = @import("int.zig").__udivmoddi4;8const __udivmoddi4 = @import("int.zig").__udivmoddi4;
9const testing = @import("std").testing;9const testing = @import("std").testing;
1010
11fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) void {11fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) !void {
12 var r: u64 = undefined;12 var r: u64 = undefined;
13 const q = __udivmoddi4(a, b, &r);13 const q = __udivmoddi4(a, b, &r);
14 try testing.expect(q == expected_q);14 try testing.expect(q == expected_q);
...@@ -17,7 +17,7 @@ fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) void {...@@ -17,7 +17,7 @@ fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) void {
1717
18test "udivmoddi4" {18test "udivmoddi4" {
19 for (cases) |case| {19 for (cases) |case| {
20 test__udivmoddi4(case[0], case[1], case[2], case[3]);20 try test__udivmoddi4(case[0], case[1], case[2], case[3]);
21 }21 }
22}22}
2323
lib/std/special/compiler_rt/udivmodti4_test.zig+2-2
...@@ -8,7 +8,7 @@...@@ -8,7 +8,7 @@
8const __udivmodti4 = @import("udivmodti4.zig").__udivmodti4;8const __udivmodti4 = @import("udivmodti4.zig").__udivmodti4;
9const testing = @import("std").testing;9const testing = @import("std").testing;
1010
11fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) void {11fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) !void {
12 var r: u128 = undefined;12 var r: u128 = undefined;
13 const q = __udivmodti4(a, b, &r);13 const q = __udivmodti4(a, b, &r);
14 try testing.expect(q == expected_q);14 try testing.expect(q == expected_q);
...@@ -17,7 +17,7 @@ fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) void {...@@ -17,7 +17,7 @@ fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) void {
1717
18test "udivmodti4" {18test "udivmodti4" {
19 for (cases) |case| {19 for (cases) |case| {
20 test__udivmodti4(case[0], case[1], case[2], case[3]);20 try test__udivmodti4(case[0], case[1], case[2], case[3]);
21 }21 }
22}22}
2323