Commit bbc610339814908e68d221748dffdbd8d8ec4f09 | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-06-16 15:14:12-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-06-17 16:38:59-07:00
log	bbc610339814908e68d221748dffdbd8d8ec4f09
tree	64ee6d459cd783d7f76bdf66b10843346485b02d
parent	453243d9e02a5d893828694e7090515de7777bb8

compiler-rt: fix tests

81 files changed, 1203 insertions(+), 1185 deletions(-)

lib
- compiler_rt

lib/compiler_rt/absvdi2.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__absvdi2, .{ .name = "__absvdi2", .linkage = common.linkage });	7	@export(__absvdi2, .{ .name = "__absvdi2", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __absvdi2(a: i64) callconv(.C) i64 {	10	pub fn __absvdi2(a: i64) callconv(.C) i64 {
11	return absv(i64, a);	11	return absv(i64, a);
12	}	12	}

lib/compiler_rt/absvdi2_test.zig+3-2

 @@ -1,8 +1,9 @@
-const absv = @import("absv.zig");
 const testing = @import("std").testing;
+const __absvdi2 = @import("absvdi2.zig").__absvdi2;
 fn test__absvdi2(a: i64, expected: i64) !void {
-    var result = absv.__absvdi2(a);
+    var result = __absvdi2(a);
     try testing.expectEqual(expected, result);
 }

lib/compiler_rt/absvsi2.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__absvsi2, .{ .name = "__absvsi2", .linkage = common.linkage });	7	@export(__absvsi2, .{ .name = "__absvsi2", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __absvsi2(a: i32) callconv(.C) i32 {	10	pub fn __absvsi2(a: i32) callconv(.C) i32 {
11	return absv(i32, a);	11	return absv(i32, a);
12	}	12	}

lib/compiler_rt/absvsi2_test.zig+3-2

 @@ -1,8 +1,9 @@
-const absv = @import("absv.zig");
 const testing = @import("std").testing;
+const __absvsi2 = @import("absvsi2.zig").__absvsi2;
 fn test__absvsi2(a: i32, expected: i32) !void {
-    var result = absv.__absvsi2(a);
+    var result = __absvsi2(a);
     try testing.expectEqual(expected, result);
 }

lib/compiler_rt/absvti2.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__absvti2, .{ .name = "__absvti2", .linkage = common.linkage });	7	@export(__absvti2, .{ .name = "__absvti2", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __absvti2(a: i128) callconv(.C) i128 {	10	pub fn __absvti2(a: i128) callconv(.C) i128 {
11	return absv(i128, a);	11	return absv(i128, a);
12	}	12	}

lib/compiler_rt/absvti2_test.zig+3-2

 @@ -1,8 +1,9 @@
-const absv = @import("absv.zig");
 const testing = @import("std").testing;
+const __absvti2 = @import("absvti2.zig").__absvti2;
 fn test__absvti2(a: i128, expected: i128) !void {
-    var result = absv.__absvti2(a);
+    var result = __absvti2(a);
     try testing.expectEqual(expected, result);
 }

lib/compiler_rt/addf3_test.zig+3-4

...	@@ -7,7 +7,9 @@ const std = @import("std");	...	@@ -7,7 +7,9 @@ const std = @import("std");
7	const math = std.math;	7	const math = std.math;
8	const qnan128 = @bitCast(f128, @as(u128, 0x7fff800000000000) << 64);	8	const qnan128 = @bitCast(f128, @as(u128, 0x7fff800000000000) << 64);
9		9
10	const __addtf3 = @import("addf3.zig").__addtf3;	10	const __addtf3 = @import("addtf3.zig").__addtf3;
		11	const __addxf3 = @import("addxf3.zig").__addxf3;
		12	const __subtf3 = @import("subtf3.zig").__subtf3;
11		13
12	fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {	14	fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
13	const x = __addtf3(a, b);	15	const x = __addtf3(a, b);
...	@@ -48,8 +50,6 @@ test "addtf3" {	...	@@ -48,8 +50,6 @@ test "addtf3" {
48	try test__addtf3(0x1.edcba52449872455634654321fp-1, 0x1.23456734245345543849abcdefp+5, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);	50	try test__addtf3(0x1.edcba52449872455634654321fp-1, 0x1.23456734245345543849abcdefp+5, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);
49	}	51	}
50		52
51	const __subtf3 = @import("addf3.zig").__subtf3;
52
53	fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {	53	fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
54	const x = __subtf3(a, b);	54	const x = __subtf3(a, b);
55		55
...	@@ -87,7 +87,6 @@ test "subtf3" {	...	@@ -87,7 +87,6 @@ test "subtf3" {
87	try test__subtf3(0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x1.234567829a3bcdef5678ade36734p+5, 0xc0041b8af1915166, 0xa44a7bca780a166c);	87	try test__subtf3(0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x1.234567829a3bcdef5678ade36734p+5, 0xc0041b8af1915166, 0xa44a7bca780a166c);
88	}	88	}
89		89
90	const __addxf3 = @import("addf3.zig").__addxf3;
91	const qnan80 = @bitCast(f80, @bitCast(u80, math.nan(f80)) \| (1 << (math.floatFractionalBits(f80) - 1)));	90	const qnan80 = @bitCast(f80, @bitCast(u80, math.nan(f80)) \| (1 << (math.floatFractionalBits(f80) - 1)));
92		91
93	fn test__addxf3(a: f80, b: f80, expected: u80) !void {	92	fn test__addxf3(a: f80, b: f80, expected: u80) !void {

lib/compiler_rt/addtf3.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __addtf3(a: f128, b: f128) callconv(.C) f128 {	16	pub fn __addtf3(a: f128, b: f128) callconv(.C) f128 {
17	return addf3(f128, a, b);	17	return addf3(f128, a, b);
18	}	18	}
19		19

lib/compiler_rt/addxf3.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__addxf3, .{ .name = "__addxf3", .linkage = common.linkage });	7	@export(__addxf3, .{ .name = "__addxf3", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __addxf3(a: f80, b: f80) callconv(.C) f80 {	10	pub fn __addxf3(a: f80, b: f80) callconv(.C) f80 {
11	return addf3(f80, a, b);	11	return addf3(f80, a, b);
12	}	12	}

lib/compiler_rt/cmpdf2.zig+4-4

lib/compiler_rt/cmpsf2.zig+4-4

lib/compiler_rt/comparedf2_test.zig+16-8

 @@ -6,7 +6,15 @@ const std = @import("std");
 const builtin = @import("builtin");
 const is_test = builtin.is_test;
-const comparedf2 = @import("compareXf2.zig");
+const __eqdf2 = @import("./cmpdf2.zig").__eqdf2;
+const __ledf2 = @import("./cmpdf2.zig").__ledf2;
+const __ltdf2 = @import("./cmpdf2.zig").__ltdf2;
+const __nedf2 = @import("./cmpdf2.zig").__nedf2;
+const __gedf2 = @import("./gedf2.zig").__gedf2;
+const __gtdf2 = @import("./gedf2.zig").__gtdf2;
+const __unorddf2 = @import("./unorddf2.zig").__unorddf2;
 const TestVector = struct {
     a: f64,
 @@ -21,25 +29,25 @@ const TestVector = struct {
 };
 fn test__cmpdf2(vector: TestVector) bool {
-    if (comparedf2.__eqdf2(vector.a, vector.b) != vector.eqReference) {
+    if (__eqdf2(vector.a, vector.b) != vector.eqReference) {
         return false;
     }
-    if (comparedf2.__gedf2(vector.a, vector.b) != vector.geReference) {
+    if (__gedf2(vector.a, vector.b) != vector.geReference) {
         return false;
     }
-    if (comparedf2.__gtdf2(vector.a, vector.b) != vector.gtReference) {
+    if (__gtdf2(vector.a, vector.b) != vector.gtReference) {
         return false;
     }
-    if (comparedf2.__ledf2(vector.a, vector.b) != vector.leReference) {
+    if (__ledf2(vector.a, vector.b) != vector.leReference) {
         return false;
     }
-    if (comparedf2.__ltdf2(vector.a, vector.b) != vector.ltReference) {
+    if (__ltdf2(vector.a, vector.b) != vector.ltReference) {
         return false;
     }
-    if (comparedf2.__nedf2(vector.a, vector.b) != vector.neReference) {
+    if (__nedf2(vector.a, vector.b) != vector.neReference) {
         return false;
     }
-    if (comparedf2.__unorddf2(vector.a, vector.b) != vector.unReference) {
+    if (__unorddf2(vector.a, vector.b) != vector.unReference) {
         return false;
     }
     return true;

lib/compiler_rt/comparesf2_test.zig+16-8

 @@ -6,7 +6,15 @@ const std = @import("std");
 const builtin = @import("builtin");
 const is_test = builtin.is_test;
-const comparesf2 = @import("compareXf2.zig");
+const __eqsf2 = @import("./cmpsf2.zig").__eqsf2;
+const __lesf2 = @import("./cmpsf2.zig").__lesf2;
+const __ltsf2 = @import("./cmpsf2.zig").__ltsf2;
+const __nesf2 = @import("./cmpsf2.zig").__nesf2;
+const __gesf2 = @import("./gesf2.zig").__gesf2;
+const __gtsf2 = @import("./gesf2.zig").__gtsf2;
+const __unordsf2 = @import("./unordsf2.zig").__unordsf2;
 const TestVector = struct {
     a: f32,
 @@ -21,25 +29,25 @@ const TestVector = struct {
 };
 fn test__cmpsf2(vector: TestVector) bool {
-    if (comparesf2.__eqsf2(vector.a, vector.b) != vector.eqReference) {
+    if (__eqsf2(vector.a, vector.b) != vector.eqReference) {
         return false;
     }
-    if (comparesf2.__gesf2(vector.a, vector.b) != vector.geReference) {
+    if (__gesf2(vector.a, vector.b) != vector.geReference) {
         return false;
     }
-    if (comparesf2.__gtsf2(vector.a, vector.b) != vector.gtReference) {
+    if (__gtsf2(vector.a, vector.b) != vector.gtReference) {
         return false;
     }
-    if (comparesf2.__lesf2(vector.a, vector.b) != vector.leReference) {
+    if (__lesf2(vector.a, vector.b) != vector.leReference) {
         return false;
     }
-    if (comparesf2.__ltsf2(vector.a, vector.b) != vector.ltReference) {
+    if (__ltsf2(vector.a, vector.b) != vector.ltReference) {
         return false;
     }
-    if (comparesf2.__nesf2(vector.a, vector.b) != vector.neReference) {
+    if (__nesf2(vector.a, vector.b) != vector.neReference) {
         return false;
     }
-    if (comparesf2.__unordsf2(vector.a, vector.b) != vector.unReference) {
+    if (__unordsf2(vector.a, vector.b) != vector.unReference) {
         return false;
     }
     return true;

lib/compiler_rt/divtf3.zig+4-4

 @@ -17,6 +17,10 @@ comptime {
     }
 }
+pub fn __divtf3(a: f128, b: f128) callconv(.C) f128 {
+    return div(a, b);
+}
 fn __divkf3(a: f128, b: f128) callconv(.C) f128 {
     return div(a, b);
 }
 @@ -25,10 +29,6 @@ fn _Qp_div(c: *f128, a: *const f128, b: *const f128) callconv(.C) void {
     c.* = div(a.*, b.*);
 }
-fn __divtf3(a: f128, b: f128) callconv(.C) f128 {
-    return div(a, b);
-}
 inline fn div(a: f128, b: f128) f128 {
     const Z = std.meta.Int(.unsigned, 128);

lib/compiler_rt/extendXfYf2_test.zig deleted-206

...	@@ -1,206 +0,0 @@
1	const builtin = @import("builtin");
2	const __extendhfsf2 = @import("extendXfYf2.zig").__extendhfsf2;
3	const __extendhftf2 = @import("extendXfYf2.zig").__extendhftf2;
4	const __extendsftf2 = @import("extendXfYf2.zig").__extendsftf2;
5	const __extenddftf2 = @import("extendXfYf2.zig").__extenddftf2;
6	const F16T = @import("extendXfYf2.zig").F16T;
7
8	fn test__extenddftf2(a: f64, expectedHi: u64, expectedLo: u64) !void {
9	const x = __extenddftf2(a);
10
11	const rep = @bitCast(u128, x);
12	const hi = @intCast(u64, rep >> 64);
13	const lo = @truncate(u64, rep);
14
15	if (hi == expectedHi and lo == expectedLo)
16	return;
17
18	// test other possible NaN representation(signal NaN)
19	if (expectedHi == 0x7fff800000000000 and expectedLo == 0x0) {
20	if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
21	((hi & 0xffffffffffff) > 0 or lo > 0))
22	{
23	return;
24	}
25	}
26
27	@panic("__extenddftf2 test failure");
28	}
29
30	fn test__extendhfsf2(a: u16, expected: u32) !void {
31	const x = __extendhfsf2(@bitCast(F16T, a));
32	const rep = @bitCast(u32, x);
33
34	if (rep == expected) {
35	if (rep & 0x7fffffff > 0x7f800000) {
36	return; // NaN is always unequal.
37	}
38	if (x == @bitCast(f32, expected)) {
39	return;
40	}
41	}
42
43	return error.TestFailure;
44	}
45
46	fn test__extendsftf2(a: f32, expectedHi: u64, expectedLo: u64) !void {
47	const x = __extendsftf2(a);
48
49	const rep = @bitCast(u128, x);
50	const hi = @intCast(u64, rep >> 64);
51	const lo = @truncate(u64, rep);
52
53	if (hi == expectedHi and lo == expectedLo)
54	return;
55
56	// test other possible NaN representation(signal NaN)
57	if (expectedHi == 0x7fff800000000000 and expectedLo == 0x0) {
58	if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
59	((hi & 0xffffffffffff) > 0 or lo > 0))
60	{
61	return;
62	}
63	}
64
65	return error.TestFailure;
66	}
67
68	test "extenddftf2" {
69	// qNaN
70	try test__extenddftf2(makeQNaN64(), 0x7fff800000000000, 0x0);
71
72	// NaN
73	try test__extenddftf2(makeNaN64(0x7100000000000), 0x7fff710000000000, 0x0);
74
75	// inf
76	try test__extenddftf2(makeInf64(), 0x7fff000000000000, 0x0);
77
78	// zero
79	try test__extenddftf2(0.0, 0x0, 0x0);
80
81	try test__extenddftf2(0x1.23456789abcdefp+5, 0x400423456789abcd, 0xf000000000000000);
82
83	try test__extenddftf2(0x1.edcba987654321fp-9, 0x3ff6edcba9876543, 0x2000000000000000);
84
85	try test__extenddftf2(0x1.23456789abcdefp+45, 0x402c23456789abcd, 0xf000000000000000);
86
87	try test__extenddftf2(0x1.edcba987654321fp-45, 0x3fd2edcba9876543, 0x2000000000000000);
88	}
89
90	test "extendhfsf2" {
91	try test__extendhfsf2(0x7e00, 0x7fc00000); // qNaN
92	try test__extendhfsf2(0x7f00, 0x7fe00000); // sNaN
93	// On x86 the NaN becomes quiet because the return is pushed on the x87
94	// stack due to ABI requirements
95	if (builtin.target.cpu.arch != .i386 and builtin.target.os.tag == .windows)
96	try test__extendhfsf2(0x7c01, 0x7f802000); // sNaN
97
98	try test__extendhfsf2(0, 0); // 0
99	try test__extendhfsf2(0x8000, 0x80000000); // -0
100
101	try test__extendhfsf2(0x7c00, 0x7f800000); // inf
102	try test__extendhfsf2(0xfc00, 0xff800000); // -inf
103
104	try test__extendhfsf2(0x0001, 0x33800000); // denormal (min), 2**-24
105	try test__extendhfsf2(0x8001, 0xb3800000); // denormal (min), -2**-24
106
107	try test__extendhfsf2(0x03ff, 0x387fc000); // denormal (max), 2-14 - 2-24
108	try test__extendhfsf2(0x83ff, 0xb87fc000); // denormal (max), -2-14 + 2-24
109
110	try test__extendhfsf2(0x0400, 0x38800000); // normal (min), 2**-14
111	try test__extendhfsf2(0x8400, 0xb8800000); // normal (min), -2**-14
112
113	try test__extendhfsf2(0x7bff, 0x477fe000); // normal (max), 65504
114	try test__extendhfsf2(0xfbff, 0xc77fe000); // normal (max), -65504
115
116	try test__extendhfsf2(0x3c01, 0x3f802000); // normal, 1 + 2**-10
117	try test__extendhfsf2(0xbc01, 0xbf802000); // normal, -1 - 2**-10
118
119	try test__extendhfsf2(0x3555, 0x3eaaa000); // normal, approx. 1/3
120	try test__extendhfsf2(0xb555, 0xbeaaa000); // normal, approx. -1/3
121	}
122
123	test "extendsftf2" {
124	// qNaN
125	try test__extendsftf2(makeQNaN32(), 0x7fff800000000000, 0x0);
126	// NaN
127	try test__extendsftf2(makeNaN32(0x410000), 0x7fff820000000000, 0x0);
128	// inf
129	try test__extendsftf2(makeInf32(), 0x7fff000000000000, 0x0);
130	// zero
131	try test__extendsftf2(0.0, 0x0, 0x0);
132	try test__extendsftf2(0x1.23456p+5, 0x4004234560000000, 0x0);
133	try test__extendsftf2(0x1.edcbap-9, 0x3ff6edcba0000000, 0x0);
134	try test__extendsftf2(0x1.23456p+45, 0x402c234560000000, 0x0);
135	try test__extendsftf2(0x1.edcbap-45, 0x3fd2edcba0000000, 0x0);
136	}
137
138	fn makeQNaN64() f64 {
139	return @bitCast(f64, @as(u64, 0x7ff8000000000000));
140	}
141
142	fn makeInf64() f64 {
143	return @bitCast(f64, @as(u64, 0x7ff0000000000000));
144	}
145
146	fn makeNaN64(rand: u64) f64 {
147	return @bitCast(f64, 0x7ff0000000000000 \| (rand & 0xfffffffffffff));
148	}
149
150	fn makeQNaN32() f32 {
151	return @bitCast(f32, @as(u32, 0x7fc00000));
152	}
153
154	fn makeNaN32(rand: u32) f32 {
155	return @bitCast(f32, 0x7f800000 \| (rand & 0x7fffff));
156	}
157
158	fn makeInf32() f32 {
159	return @bitCast(f32, @as(u32, 0x7f800000));
160	}
161
162	fn test__extendhftf2(a: u16, expectedHi: u64, expectedLo: u64) !void {
163	const x = __extendhftf2(@bitCast(F16T, a));
164
165	const rep = @bitCast(u128, x);
166	const hi = @intCast(u64, rep >> 64);
167	const lo = @truncate(u64, rep);
168
169	if (hi == expectedHi and lo == expectedLo)
170	return;
171
172	// test other possible NaN representation(signal NaN)
173	if (expectedHi == 0x7fff800000000000 and expectedLo == 0x0) {
174	if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
175	((hi & 0xffffffffffff) > 0 or lo > 0))
176	{
177	return;
178	}
179	}
180
181	return error.TestFailure;
182	}
183
184	test "extendhftf2" {
185	// qNaN
186	try test__extendhftf2(0x7e00, 0x7fff800000000000, 0x0);
187	// NaN
188	try test__extendhftf2(0x7d00, 0x7fff400000000000, 0x0);
189	// inf
190	try test__extendhftf2(0x7c00, 0x7fff000000000000, 0x0);
191	try test__extendhftf2(0xfc00, 0xffff000000000000, 0x0);
192	// zero
193	try test__extendhftf2(0x0000, 0x0000000000000000, 0x0);
194	try test__extendhftf2(0x8000, 0x8000000000000000, 0x0);
195	// denormal
196	try test__extendhftf2(0x0010, 0x3feb000000000000, 0x0);
197	try test__extendhftf2(0x0001, 0x3fe7000000000000, 0x0);
198	try test__extendhftf2(0x8001, 0xbfe7000000000000, 0x0);
199
200	// pi
201	try test__extendhftf2(0x4248, 0x4000920000000000, 0x0);
202	try test__extendhftf2(0xc248, 0xc000920000000000, 0x0);
203
204	try test__extendhftf2(0x508c, 0x4004230000000000, 0x0);
205	try test__extendhftf2(0x1bb7, 0x3ff6edc000000000, 0x0);
206	}

lib/compiler_rt/extenddftf2.zig+1-2

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __extenddftf2(a: f64) callconv(.C) f128 {	16	pub fn __extenddftf2(a: f64) callconv(.C) f128 {
17	return extendf(f128, f64, @bitCast(u64, a));	17	return extendf(f128, f64, @bitCast(u64, a));
18	}	18	}
19		19
...	@@ -22,6 +22,5 @@ fn __extenddfkf2(a: f64) callconv(.C) f128 {	...	@@ -22,6 +22,5 @@ fn __extenddfkf2(a: f64) callconv(.C) f128 {
22	}	22	}
23		23
24	fn _Qp_dtoq(c: *f128, a: f64) callconv(.C) void {	24	fn _Qp_dtoq(c: *f128, a: f64) callconv(.C) void {
25	c.* = @import("extendXfYf2.zig").__extenddftf2(a);
26	c.* = extendf(f128, f64, @bitCast(u64, a));	25	c.* = extendf(f128, f64, @bitCast(u64, a));
27	}	26	}

lib/compiler_rt/extendf.zig+1-1

...	@@ -138,5 +138,5 @@ pub inline fn extend_f80(comptime src_t: type, a: std.meta.Int(.unsigned, @typeI	...	@@ -138,5 +138,5 @@ pub inline fn extend_f80(comptime src_t: type, a: std.meta.Int(.unsigned, @typeI
138	}	138	}
139		139
140	test {	140	test {
141	_ = @import("extendXfYf2_test.zig");	141	_ = @import("extendf_test.zig");
142	}	142	}

lib/compiler_rt/extendf_test.zig created+206

...	@@ -0,0 +1,206 @@
1	const builtin = @import("builtin");
2	const __extendhfsf2 = @import("extendhfsf2.zig").__extendhfsf2;
3	const __extendhftf2 = @import("extendhftf2.zig").__extendhftf2;
4	const __extendsftf2 = @import("extendsftf2.zig").__extendsftf2;
5	const __extenddftf2 = @import("extenddftf2.zig").__extenddftf2;
6	const F16T = @import("./common.zig").F16T;
7
8	fn test__extenddftf2(a: f64, expected_hi: u64, expected_lo: u64) !void {
9	const x = __extenddftf2(a);
10
11	const rep = @bitCast(u128, x);
12	const hi = @intCast(u64, rep >> 64);
13	const lo = @truncate(u64, rep);
14
15	if (hi == expected_hi and lo == expected_lo)
16	return;
17
18	// test other possible NaN representation(signal NaN)
19	if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
20	if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
21	((hi & 0xffffffffffff) > 0 or lo > 0))
22	{
23	return;
24	}
25	}
26
27	@panic("__extenddftf2 test failure");
28	}
29
30	fn test__extendhfsf2(a: u16, expected: u32) !void {
31	const x = __extendhfsf2(@bitCast(F16T, a));
32	const rep = @bitCast(u32, x);
33
34	if (rep == expected) {
35	if (rep & 0x7fffffff > 0x7f800000) {
36	return; // NaN is always unequal.
37	}
38	if (x == @bitCast(f32, expected)) {
39	return;
40	}
41	}
42
43	return error.TestFailure;
44	}
45
46	fn test__extendsftf2(a: f32, expected_hi: u64, expected_lo: u64) !void {
47	const x = __extendsftf2(a);
48
49	const rep = @bitCast(u128, x);
50	const hi = @intCast(u64, rep >> 64);
51	const lo = @truncate(u64, rep);
52
53	if (hi == expected_hi and lo == expected_lo)
54	return;
55
56	// test other possible NaN representation(signal NaN)
57	if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
58	if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
59	((hi & 0xffffffffffff) > 0 or lo > 0))
60	{
61	return;
62	}
63	}
64
65	return error.TestFailure;
66	}
67
68	test "extenddftf2" {
69	// qNaN
70	try test__extenddftf2(makeQNaN64(), 0x7fff800000000000, 0x0);
71
72	// NaN
73	try test__extenddftf2(makeNaN64(0x7100000000000), 0x7fff710000000000, 0x0);
74
75	// inf
76	try test__extenddftf2(makeInf64(), 0x7fff000000000000, 0x0);
77
78	// zero
79	try test__extenddftf2(0.0, 0x0, 0x0);
80
81	try test__extenddftf2(0x1.23456789abcdefp+5, 0x400423456789abcd, 0xf000000000000000);
82
83	try test__extenddftf2(0x1.edcba987654321fp-9, 0x3ff6edcba9876543, 0x2000000000000000);
84
85	try test__extenddftf2(0x1.23456789abcdefp+45, 0x402c23456789abcd, 0xf000000000000000);
86
87	try test__extenddftf2(0x1.edcba987654321fp-45, 0x3fd2edcba9876543, 0x2000000000000000);
88	}
89
90	test "extendhfsf2" {
91	try test__extendhfsf2(0x7e00, 0x7fc00000); // qNaN
92	try test__extendhfsf2(0x7f00, 0x7fe00000); // sNaN
93	// On x86 the NaN becomes quiet because the return is pushed on the x87
94	// stack due to ABI requirements
95	if (builtin.target.cpu.arch != .i386 and builtin.target.os.tag == .windows)
96	try test__extendhfsf2(0x7c01, 0x7f802000); // sNaN
97
98	try test__extendhfsf2(0, 0); // 0
99	try test__extendhfsf2(0x8000, 0x80000000); // -0
100
101	try test__extendhfsf2(0x7c00, 0x7f800000); // inf
102	try test__extendhfsf2(0xfc00, 0xff800000); // -inf
103
104	try test__extendhfsf2(0x0001, 0x33800000); // denormal (min), 2**-24
105	try test__extendhfsf2(0x8001, 0xb3800000); // denormal (min), -2**-24
106
107	try test__extendhfsf2(0x03ff, 0x387fc000); // denormal (max), 2-14 - 2-24
108	try test__extendhfsf2(0x83ff, 0xb87fc000); // denormal (max), -2-14 + 2-24
109
110	try test__extendhfsf2(0x0400, 0x38800000); // normal (min), 2**-14
111	try test__extendhfsf2(0x8400, 0xb8800000); // normal (min), -2**-14
112
113	try test__extendhfsf2(0x7bff, 0x477fe000); // normal (max), 65504
114	try test__extendhfsf2(0xfbff, 0xc77fe000); // normal (max), -65504
115
116	try test__extendhfsf2(0x3c01, 0x3f802000); // normal, 1 + 2**-10
117	try test__extendhfsf2(0xbc01, 0xbf802000); // normal, -1 - 2**-10
118
119	try test__extendhfsf2(0x3555, 0x3eaaa000); // normal, approx. 1/3
120	try test__extendhfsf2(0xb555, 0xbeaaa000); // normal, approx. -1/3
121	}
122
123	test "extendsftf2" {
124	// qNaN
125	try test__extendsftf2(makeQNaN32(), 0x7fff800000000000, 0x0);
126	// NaN
127	try test__extendsftf2(makeNaN32(0x410000), 0x7fff820000000000, 0x0);
128	// inf
129	try test__extendsftf2(makeInf32(), 0x7fff000000000000, 0x0);
130	// zero
131	try test__extendsftf2(0.0, 0x0, 0x0);
132	try test__extendsftf2(0x1.23456p+5, 0x4004234560000000, 0x0);
133	try test__extendsftf2(0x1.edcbap-9, 0x3ff6edcba0000000, 0x0);
134	try test__extendsftf2(0x1.23456p+45, 0x402c234560000000, 0x0);
135	try test__extendsftf2(0x1.edcbap-45, 0x3fd2edcba0000000, 0x0);
136	}
137
138	fn makeQNaN64() f64 {
139	return @bitCast(f64, @as(u64, 0x7ff8000000000000));
140	}
141
142	fn makeInf64() f64 {
143	return @bitCast(f64, @as(u64, 0x7ff0000000000000));
144	}
145
146	fn makeNaN64(rand: u64) f64 {
147	return @bitCast(f64, 0x7ff0000000000000 \| (rand & 0xfffffffffffff));
148	}
149
150	fn makeQNaN32() f32 {
151	return @bitCast(f32, @as(u32, 0x7fc00000));
152	}
153
154	fn makeNaN32(rand: u32) f32 {
155	return @bitCast(f32, 0x7f800000 \| (rand & 0x7fffff));
156	}
157
158	fn makeInf32() f32 {
159	return @bitCast(f32, @as(u32, 0x7f800000));
160	}
161
162	fn test__extendhftf2(a: u16, expected_hi: u64, expected_lo: u64) !void {
163	const x = __extendhftf2(@bitCast(F16T, a));
164
165	const rep = @bitCast(u128, x);
166	const hi = @intCast(u64, rep >> 64);
167	const lo = @truncate(u64, rep);
168
169	if (hi == expected_hi and lo == expected_lo)
170	return;
171
172	// test other possible NaN representation(signal NaN)
173	if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
174	if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
175	((hi & 0xffffffffffff) > 0 or lo > 0))
176	{
177	return;
178	}
179	}
180
181	return error.TestFailure;
182	}
183
184	test "extendhftf2" {
185	// qNaN
186	try test__extendhftf2(0x7e00, 0x7fff800000000000, 0x0);
187	// NaN
188	try test__extendhftf2(0x7d00, 0x7fff400000000000, 0x0);
189	// inf
190	try test__extendhftf2(0x7c00, 0x7fff000000000000, 0x0);
191	try test__extendhftf2(0xfc00, 0xffff000000000000, 0x0);
192	// zero
193	try test__extendhftf2(0x0000, 0x0000000000000000, 0x0);
194	try test__extendhftf2(0x8000, 0x8000000000000000, 0x0);
195	// denormal
196	try test__extendhftf2(0x0010, 0x3feb000000000000, 0x0);
197	try test__extendhftf2(0x0001, 0x3fe7000000000000, 0x0);
198	try test__extendhftf2(0x8001, 0xbfe7000000000000, 0x0);
199
200	// pi
201	try test__extendhftf2(0x4248, 0x4000920000000000, 0x0);
202	try test__extendhftf2(0xc248, 0xc000920000000000, 0x0);
203
204	try test__extendhftf2(0x508c, 0x4004230000000000, 0x0);
205	try test__extendhftf2(0x1bb7, 0x3ff6edc000000000, 0x0);
206	}

lib/compiler_rt/extendhfsf2.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __extendhfsf2(a: common.F16T) callconv(.C) f32 {	16	pub fn __extendhfsf2(a: common.F16T) callconv(.C) f32 {
17	return extendf(f32, f16, @bitCast(u16, a));	17	return extendf(f32, f16, @bitCast(u16, a));
18	}	18	}
19		19

lib/compiler_rt/extendhftf2.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__extendhftf2, .{ .name = "__extendhftf2", .linkage = common.linkage });	7	@export(__extendhftf2, .{ .name = "__extendhftf2", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __extendhftf2(a: common.F16T) callconv(.C) f128 {	10	pub fn __extendhftf2(a: common.F16T) callconv(.C) f128 {
11	return extendf(f128, f16, @bitCast(u16, a));	11	return extendf(f128, f16, @bitCast(u16, a));
12	}	12	}

lib/compiler_rt/extendsftf2.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __extendsftf2(a: f32) callconv(.C) f128 {	16	pub fn __extendsftf2(a: f32) callconv(.C) f128 {
17	return extendf(f128, f32, @bitCast(u32, a));	17	return extendf(f128, f32, @bitCast(u32, a));
18	}	18	}
19		19

lib/compiler_rt/fixdfdi.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __fixdfdi(a: f64) callconv(.C) i64 {	14	pub fn __fixdfdi(a: f64) callconv(.C) i64 {
15	return floatToInt(i64, a);	15	return floatToInt(i64, a);
16	}	16	}
17		17

lib/compiler_rt/fixdfsi.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __fixdfsi(a: f64) callconv(.C) i32 {	14	pub fn __fixdfsi(a: f64) callconv(.C) i32 {
15	return floatToInt(i32, a);	15	return floatToInt(i32, a);
16	}	16	}
17		17

lib/compiler_rt/fixdfti.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__fixdfti, .{ .name = "__fixdfti", .linkage = common.linkage });	7	@export(__fixdfti, .{ .name = "__fixdfti", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __fixdfti(a: f64) callconv(.C) i128 {	10	pub fn __fixdfti(a: f64) callconv(.C) i128 {
11	return floatToInt(i128, a);	11	return floatToInt(i128, a);
12	}	12	}

lib/compiler_rt/fixsfdi.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __fixsfdi(a: f32) callconv(.C) i64 {	14	pub fn __fixsfdi(a: f32) callconv(.C) i64 {
15	return floatToInt(i64, a);	15	return floatToInt(i64, a);
16	}	16	}
17		17

lib/compiler_rt/fixsfsi.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __fixsfsi(a: f32) callconv(.C) i32 {	14	pub fn __fixsfsi(a: f32) callconv(.C) i32 {
15	return floatToInt(i32, a);	15	return floatToInt(i32, a);
16	}	16	}
17		17

lib/compiler_rt/fixsfti.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__fixsfti, .{ .name = "__fixsfti", .linkage = common.linkage });	7	@export(__fixsfti, .{ .name = "__fixsfti", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __fixsfti(a: f32) callconv(.C) i128 {	10	pub fn __fixsfti(a: f32) callconv(.C) i128 {
11	return floatToInt(i128, a);	11	return floatToInt(i128, a);
12	}	12	}

lib/compiler_rt/fixtfdi.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __fixtfdi(a: f128) callconv(.C) i64 {	16	pub fn __fixtfdi(a: f128) callconv(.C) i64 {
17	return floatToInt(i64, a);	17	return floatToInt(i64, a);
18	}	18	}
19		19

lib/compiler_rt/fixtfsi.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __fixtfsi(a: f128) callconv(.C) i32 {	16	pub fn __fixtfsi(a: f128) callconv(.C) i32 {
17	return floatToInt(i32, a);	17	return floatToInt(i32, a);
18	}	18	}
19		19

lib/compiler_rt/fixtfti.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__fixtfti, .{ .name = "__fixtfti", .linkage = common.linkage });	7	@export(__fixtfti, .{ .name = "__fixtfti", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __fixtfti(a: f128) callconv(.C) i128 {	10	pub fn __fixtfti(a: f128) callconv(.C) i128 {
11	return floatToInt(i128, a);	11	return floatToInt(i128, a);
12	}	12	}

lib/compiler_rt/fixunsdfdi.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __fixunsdfdi(a: f64) callconv(.C) u64 {	14	pub fn __fixunsdfdi(a: f64) callconv(.C) u64 {
15	return floatToInt(u64, a);	15	return floatToInt(u64, a);
16	}	16	}
17		17

lib/compiler_rt/fixunsdfsi.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __fixunsdfsi(a: f64) callconv(.C) u32 {	14	pub fn __fixunsdfsi(a: f64) callconv(.C) u32 {
15	return floatToInt(u32, a);	15	return floatToInt(u32, a);
16	}	16	}
17		17

lib/compiler_rt/fixunsdfti.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = common.linkage });	7	@export(__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __fixunsdfti(a: f64) callconv(.C) u128 {	10	pub fn __fixunsdfti(a: f64) callconv(.C) u128 {
11	return floatToInt(u128, a);	11	return floatToInt(u128, a);
12	}	12	}

lib/compiler_rt/fixunshfti.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__fixunshfti, .{ .name = "__fixunshfti", .linkage = common.linkage });	7	@export(__fixunshfti, .{ .name = "__fixunshfti", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __fixunshfti(a: f16) callconv(.C) u128 {	10	pub fn __fixunshfti(a: f16) callconv(.C) u128 {
11	return floatToInt(u128, a);	11	return floatToInt(u128, a);
12	}	12	}

lib/compiler_rt/fixunssfdi.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __fixunssfdi(a: f32) callconv(.C) u64 {	14	pub fn __fixunssfdi(a: f32) callconv(.C) u64 {
15	return floatToInt(u64, a);	15	return floatToInt(u64, a);
16	}	16	}
17		17

lib/compiler_rt/fixunssfsi.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __fixunssfsi(a: f32) callconv(.C) u32 {	14	pub fn __fixunssfsi(a: f32) callconv(.C) u32 {
15	return floatToInt(u32, a);	15	return floatToInt(u32, a);
16	}	16	}
17		17

lib/compiler_rt/fixunssfti.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__fixunssfti, .{ .name = "__fixunssfti", .linkage = common.linkage });	7	@export(__fixunssfti, .{ .name = "__fixunssfti", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __fixunssfti(a: f32) callconv(.C) u128 {	10	pub fn __fixunssfti(a: f32) callconv(.C) u128 {
11	return floatToInt(u128, a);	11	return floatToInt(u128, a);
12	}	12	}

lib/compiler_rt/fixunstfdi.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __fixunstfdi(a: f128) callconv(.C) u64 {	16	pub fn __fixunstfdi(a: f128) callconv(.C) u64 {
17	return floatToInt(u64, a);	17	return floatToInt(u64, a);
18	}	18	}
19		19

lib/compiler_rt/fixunstfsi.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __fixunstfsi(a: f128) callconv(.C) u32 {	16	pub fn __fixunstfsi(a: f128) callconv(.C) u32 {
17	return floatToInt(u32, a);	17	return floatToInt(u32, a);
18	}	18	}
19		19

lib/compiler_rt/fixunstfti.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = common.linkage });	7	@export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __fixunstfti(a: f128) callconv(.C) u128 {	10	pub fn __fixunstfti(a: f128) callconv(.C) u128 {
11	return floatToInt(u128, a);	11	return floatToInt(u128, a);
12	}	12	}

lib/compiler_rt/fixunsxfti.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__fixunsxfti, .{ .name = "__fixunsxfti", .linkage = common.linkage });	7	@export(__fixunsxfti, .{ .name = "__fixunsxfti", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __fixunsxfti(a: f80) callconv(.C) u128 {	10	pub fn __fixunsxfti(a: f80) callconv(.C) u128 {
11	return floatToInt(u128, a);	11	return floatToInt(u128, a);
12	}	12	}

lib/compiler_rt/floatXiYf_test.zig deleted-835

...	@@ -1,835 +0,0 @@
1	const std = @import("std");
2	const builtin = @import("builtin");
3	const testing = std.testing;
4	const math = std.math;
5	const floatXiYf = @import("floatXiYf.zig").floatXiYf;
6
7	// Conversion to f32
8	const __floatsisf = @import("floatXiYf.zig").__floatsisf;
9	const __floatunsisf = @import("floatXiYf.zig").__floatunsisf;
10	const __floatdisf = @import("floatXiYf.zig").__floatdisf;
11	const __floatundisf = @import("floatXiYf.zig").__floatundisf;
12	const __floattisf = @import("floatXiYf.zig").__floattisf;
13	const __floatuntisf = @import("floatXiYf.zig").__floatuntisf;
14
15	// Conversion to f64
16	const __floatsidf = @import("floatXiYf.zig").__floatsidf;
17	const __floatunsidf = @import("floatXiYf.zig").__floatunsidf;
18	const __floatdidf = @import("floatXiYf.zig").__floatdidf;
19	const __floatundidf = @import("floatXiYf.zig").__floatundidf;
20	const __floattidf = @import("floatXiYf.zig").__floattidf;
21	const __floatuntidf = @import("floatXiYf.zig").__floatuntidf;
22
23	// Conversion to f128
24	const __floatsitf = @import("floatXiYf.zig").__floatsitf;
25	const __floatunsitf = @import("floatXiYf.zig").__floatunsitf;
26	const __floatditf = @import("floatXiYf.zig").__floatditf;
27	const __floatunditf = @import("floatXiYf.zig").__floatunditf;
28	const __floattitf = @import("floatXiYf.zig").__floattitf;
29	const __floatuntitf = @import("floatXiYf.zig").__floatuntitf;
30
31	fn test__floatsisf(a: i32, expected: u32) !void {
32	const r = __floatsisf(a);
33	try std.testing.expect(@bitCast(u32, r) == expected);
34	}
35
36	fn test_one_floatunsisf(a: u32, expected: u32) !void {
37	const r = __floatunsisf(a);
38	try std.testing.expect(@bitCast(u32, r) == expected);
39	}
40
41	test "floatsisf" {
42	try test__floatsisf(0, 0x00000000);
43	try test__floatsisf(1, 0x3f800000);
44	try test__floatsisf(-1, 0xbf800000);
45	try test__floatsisf(0x7FFFFFFF, 0x4f000000);
46	try test__floatsisf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xcf000000);
47	}
48
49	test "floatunsisf" {
50	// Test the produced bit pattern
51	try test_one_floatunsisf(0, 0);
52	try test_one_floatunsisf(1, 0x3f800000);
53	try test_one_floatunsisf(0x7FFFFFFF, 0x4f000000);
54	try test_one_floatunsisf(0x80000000, 0x4f000000);
55	try test_one_floatunsisf(0xFFFFFFFF, 0x4f800000);
56	}
57
58	fn test__floatdisf(a: i64, expected: f32) !void {
59	const x = __floatdisf(a);
60	try testing.expect(x == expected);
61	}
62
63	fn test__floatundisf(a: u64, expected: f32) !void {
64	try std.testing.expectEqual(expected, __floatundisf(a));
65	}
66
67	test "floatdisf" {
68	try test__floatdisf(0, 0.0);
69	try test__floatdisf(1, 1.0);
70	try test__floatdisf(2, 2.0);
71	try test__floatdisf(-1, -1.0);
72	try test__floatdisf(-2, -2.0);
73	try test__floatdisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
74	try test__floatdisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
75	try test__floatdisf(@bitCast(i64, @as(u64, 0x8000008000000000)), -0x1.FFFFFEp+62);
76	try test__floatdisf(@bitCast(i64, @as(u64, 0x8000010000000000)), -0x1.FFFFFCp+62);
77	try test__floatdisf(@bitCast(i64, @as(u64, 0x8000000000000000)), -0x1.000000p+63);
78	try test__floatdisf(@bitCast(i64, @as(u64, 0x8000000000000001)), -0x1.000000p+63);
79	try test__floatdisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
80	try test__floatdisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
81	try test__floatdisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
82	try test__floatdisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
83	try test__floatdisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
84	try test__floatdisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
85	try test__floatdisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
86	try test__floatdisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
87	try test__floatdisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
88	try test__floatdisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
89	try test__floatdisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
90	}
91
92	test "floatundisf" {
93	try test__floatundisf(0, 0.0);
94	try test__floatundisf(1, 1.0);
95	try test__floatundisf(2, 2.0);
96	try test__floatundisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
97	try test__floatundisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
98	try test__floatundisf(0x8000008000000000, 0x1p+63);
99	try test__floatundisf(0x8000010000000000, 0x1.000002p+63);
100	try test__floatundisf(0x8000000000000000, 0x1p+63);
101	try test__floatundisf(0x8000000000000001, 0x1p+63);
102	try test__floatundisf(0xFFFFFFFFFFFFFFFE, 0x1p+64);
103	try test__floatundisf(0xFFFFFFFFFFFFFFFF, 0x1p+64);
104	try test__floatundisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
105	try test__floatundisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
106	try test__floatundisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
107	try test__floatundisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
108	try test__floatundisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
109	try test__floatundisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
110	try test__floatundisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
111	try test__floatundisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
112	try test__floatundisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
113	try test__floatundisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
114	try test__floatundisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
115	}
116
117	fn test__floattisf(a: i128, expected: f32) !void {
118	const x = __floattisf(a);
119	try testing.expect(x == expected);
120	}
121
122	fn test__floatuntisf(a: u128, expected: f32) !void {
123	const x = __floatuntisf(a);
124	try testing.expect(x == expected);
125	}
126
127	test "floattisf" {
128	try test__floattisf(0, 0.0);
129
130	try test__floattisf(1, 1.0);
131	try test__floattisf(2, 2.0);
132	try test__floattisf(-1, -1.0);
133	try test__floattisf(-2, -2.0);
134
135	try test__floattisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
136	try test__floattisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
137
138	try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000008000000000), -0x1.FFFFFEp+62);
139	try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000010000000000), -0x1.FFFFFCp+62);
140
141	try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000000), -0x1.000000p+63);
142	try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000001), -0x1.000000p+63);
143
144	try test__floattisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
145
146	try test__floattisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
147	try test__floattisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
148	try test__floattisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
149	try test__floattisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
150	try test__floattisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
151
152	try test__floattisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
153	try test__floattisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
154	try test__floattisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
155	try test__floattisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
156	try test__floattisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
157
158	try test__floattisf(make_ti(0x0007FB72E8000000, 0), 0x1.FEDCBAp+114);
159
160	try test__floattisf(make_ti(0x0007FB72EA000000, 0), 0x1.FEDCBAp+114);
161	try test__floattisf(make_ti(0x0007FB72EB000000, 0), 0x1.FEDCBAp+114);
162	try test__floattisf(make_ti(0x0007FB72EBFFFFFF, 0), 0x1.FEDCBAp+114);
163	try test__floattisf(make_ti(0x0007FB72EC000000, 0), 0x1.FEDCBCp+114);
164	try test__floattisf(make_ti(0x0007FB72E8000001, 0), 0x1.FEDCBAp+114);
165
166	try test__floattisf(make_ti(0x0007FB72E6000000, 0), 0x1.FEDCBAp+114);
167	try test__floattisf(make_ti(0x0007FB72E7000000, 0), 0x1.FEDCBAp+114);
168	try test__floattisf(make_ti(0x0007FB72E7FFFFFF, 0), 0x1.FEDCBAp+114);
169	try test__floattisf(make_ti(0x0007FB72E4000001, 0), 0x1.FEDCBAp+114);
170	try test__floattisf(make_ti(0x0007FB72E4000000, 0), 0x1.FEDCB8p+114);
171	}
172
173	test "floatuntisf" {
174	try test__floatuntisf(0, 0.0);
175
176	try test__floatuntisf(1, 1.0);
177	try test__floatuntisf(2, 2.0);
178	try test__floatuntisf(20, 20.0);
179
180	try test__floatuntisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
181	try test__floatuntisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
182
183	try test__floatuntisf(make_uti(0x8000008000000000, 0), 0x1.000001p+127);
184	try test__floatuntisf(make_uti(0x8000000000000800, 0), 0x1.0p+127);
185	try test__floatuntisf(make_uti(0x8000010000000000, 0), 0x1.000002p+127);
186
187	try test__floatuntisf(make_uti(0x8000000000000000, 0), 0x1.000000p+127);
188
189	try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
190
191	try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
192	try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
193
194	try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
195
196	try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
197	try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
198	try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
199
200	try test__floatuntisf(0xFFFFFFFFFFFFFFFE, 0x1p+64);
201	try test__floatuntisf(0xFFFFFFFFFFFFFFFF, 0x1p+64);
202
203	try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
204
205	try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
206	try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
207	try test__floatuntisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
208	try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
209	try test__floatuntisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
210
211	try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
212	try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
213	try test__floatuntisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
214	try test__floatuntisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
215	try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
216
217	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCB90000000000001), 0x1.FEDCBAp+76);
218	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBA0000000000000), 0x1.FEDCBAp+76);
219	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBAFFFFFFFFFFFFF), 0x1.FEDCBAp+76);
220	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBB0000000000000), 0x1.FEDCBCp+76);
221	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBB0000000000001), 0x1.FEDCBCp+76);
222	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBBFFFFFFFFFFFFF), 0x1.FEDCBCp+76);
223	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBC0000000000000), 0x1.FEDCBCp+76);
224	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBC0000000000001), 0x1.FEDCBCp+76);
225	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBD0000000000000), 0x1.FEDCBCp+76);
226	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBD0000000000001), 0x1.FEDCBEp+76);
227	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBDFFFFFFFFFFFFF), 0x1.FEDCBEp+76);
228	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBE0000000000000), 0x1.FEDCBEp+76);
229
230	// Test overflow to infinity
231	try test__floatuntisf(@as(u128, math.maxInt(u128)), @bitCast(f32, math.inf(f32)));
232	}
233
234	fn test_one_floatsidf(a: i32, expected: u64) !void {
235	const r = __floatsidf(a);
236	try std.testing.expect(@bitCast(u64, r) == expected);
237	}
238
239	fn test_one_floatunsidf(a: u32, expected: u64) !void {
240	const r = __floatunsidf(a);
241	try std.testing.expect(@bitCast(u64, r) == expected);
242	}
243
244	test "floatsidf" {
245	try test_one_floatsidf(0, 0x0000000000000000);
246	try test_one_floatsidf(1, 0x3ff0000000000000);
247	try test_one_floatsidf(-1, 0xbff0000000000000);
248	try test_one_floatsidf(0x7FFFFFFF, 0x41dfffffffc00000);
249	try test_one_floatsidf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc1e0000000000000);
250	}
251
252	test "floatunsidf" {
253	try test_one_floatunsidf(0, 0x0000000000000000);
254	try test_one_floatunsidf(1, 0x3ff0000000000000);
255	try test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000);
256	try test_one_floatunsidf(@intCast(u32, 0x80000000), 0x41e0000000000000);
257	try test_one_floatunsidf(@intCast(u32, 0xFFFFFFFF), 0x41efffffffe00000);
258	}
259
260	fn test__floatdidf(a: i64, expected: f64) !void {
261	const r = __floatdidf(a);
262	try testing.expect(r == expected);
263	}
264
265	fn test__floatundidf(a: u64, expected: f64) !void {
266	const r = __floatundidf(a);
267	try testing.expect(r == expected);
268	}
269
270	test "floatdidf" {
271	try test__floatdidf(0, 0.0);
272	try test__floatdidf(1, 1.0);
273	try test__floatdidf(2, 2.0);
274	try test__floatdidf(20, 20.0);
275	try test__floatdidf(-1, -1.0);
276	try test__floatdidf(-2, -2.0);
277	try test__floatdidf(-20, -20.0);
278	try test__floatdidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
279	try test__floatdidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
280	try test__floatdidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
281	try test__floatdidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
282	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000008000000000)), -0x1.FFFFFEp+62);
283	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000800)), -0x1.FFFFFFFFFFFFEp+62);
284	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000010000000000)), -0x1.FFFFFCp+62);
285	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000001000)), -0x1.FFFFFFFFFFFFCp+62);
286	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000000)), -0x1.000000p+63);
287	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000001)), -0x1.000000p+63); // 0x8000000000000001
288	try test__floatdidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
289	try test__floatdidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
290	try test__floatdidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
291	try test__floatdidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
292	try test__floatdidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
293	try test__floatdidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
294	try test__floatdidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
295	try test__floatdidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
296	try test__floatdidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
297	try test__floatdidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
298	try test__floatdidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
299	try test__floatdidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
300	try test__floatdidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
301	try test__floatdidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
302	try test__floatdidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
303	try test__floatdidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
304	try test__floatdidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
305	try test__floatdidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
306	try test__floatdidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
307	try test__floatdidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
308	try test__floatdidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
309	try test__floatdidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
310	try test__floatdidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
311	try test__floatdidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
312	try test__floatdidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
313	try test__floatdidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
314	}
315
316	test "floatundidf" {
317	try test__floatundidf(0, 0.0);
318	try test__floatundidf(1, 1.0);
319	try test__floatundidf(2, 2.0);
320	try test__floatundidf(20, 20.0);
321	try test__floatundidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
322	try test__floatundidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
323	try test__floatundidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
324	try test__floatundidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
325	try test__floatundidf(0x8000008000000000, 0x1.000001p+63);
326	try test__floatundidf(0x8000000000000800, 0x1.0000000000001p+63);
327	try test__floatundidf(0x8000010000000000, 0x1.000002p+63);
328	try test__floatundidf(0x8000000000001000, 0x1.0000000000002p+63);
329	try test__floatundidf(0x8000000000000000, 0x1p+63);
330	try test__floatundidf(0x8000000000000001, 0x1p+63);
331	try test__floatundidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
332	try test__floatundidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
333	try test__floatundidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
334	try test__floatundidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
335	try test__floatundidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
336	try test__floatundidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
337	try test__floatundidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
338	try test__floatundidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
339	try test__floatundidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
340	try test__floatundidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
341	try test__floatundidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
342	try test__floatundidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
343	try test__floatundidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
344	try test__floatundidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
345	try test__floatundidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
346	try test__floatundidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
347	try test__floatundidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
348	try test__floatundidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
349	try test__floatundidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
350	try test__floatundidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
351	try test__floatundidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
352	try test__floatundidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
353	try test__floatundidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
354	try test__floatundidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
355	try test__floatundidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
356	try test__floatundidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
357	}
358
359	fn test__floattidf(a: i128, expected: f64) !void {
360	const x = __floattidf(a);
361	try testing.expect(x == expected);
362	}
363
364	fn test__floatuntidf(a: u128, expected: f64) !void {
365	const x = __floatuntidf(a);
366	try testing.expect(x == expected);
367	}
368
369	test "floattidf" {
370	try test__floattidf(0, 0.0);
371
372	try test__floattidf(1, 1.0);
373	try test__floattidf(2, 2.0);
374	try test__floattidf(20, 20.0);
375	try test__floattidf(-1, -1.0);
376	try test__floattidf(-2, -2.0);
377	try test__floattidf(-20, -20.0);
378
379	try test__floattidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
380	try test__floattidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
381	try test__floattidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
382	try test__floattidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
383
384	try test__floattidf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);
385	try test__floattidf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);
386	try test__floattidf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);
387	try test__floattidf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);
388
389	try test__floattidf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);
390	try test__floattidf(make_ti(0x8000000000000001, 0), -0x1.000000p+127);
391
392	try test__floattidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
393
394	try test__floattidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
395	try test__floattidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
396	try test__floattidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
397	try test__floattidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
398	try test__floattidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
399
400	try test__floattidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
401	try test__floattidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
402	try test__floattidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
403	try test__floattidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
404	try test__floattidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
405
406	try test__floattidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
407	try test__floattidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
408	try test__floattidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
409	try test__floattidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
410	try test__floattidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
411	try test__floattidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
412	try test__floattidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
413	try test__floattidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
414	try test__floattidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
415	try test__floattidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
416	try test__floattidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
417	try test__floattidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
418	try test__floattidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
419	try test__floattidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
420	try test__floattidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
421
422	try test__floattidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
423	try test__floattidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121);
424	try test__floattidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121);
425	try test__floattidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121);
426	try test__floattidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121);
427	try test__floattidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121);
428	try test__floattidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121);
429	try test__floattidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121);
430	try test__floattidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121);
431	try test__floattidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121);
432	try test__floattidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121);
433	try test__floattidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121);
434	try test__floattidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121);
435	try test__floattidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121);
436	try test__floattidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
437	}
438
439	test "floatuntidf" {
440	try test__floatuntidf(0, 0.0);
441
442	try test__floatuntidf(1, 1.0);
443	try test__floatuntidf(2, 2.0);
444	try test__floatuntidf(20, 20.0);
445
446	try test__floatuntidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
447	try test__floatuntidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
448	try test__floatuntidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
449	try test__floatuntidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
450
451	try test__floatuntidf(make_uti(0x8000008000000000, 0), 0x1.000001p+127);
452	try test__floatuntidf(make_uti(0x8000000000000800, 0), 0x1.0000000000001p+127);
453	try test__floatuntidf(make_uti(0x8000010000000000, 0), 0x1.000002p+127);
454	try test__floatuntidf(make_uti(0x8000000000001000, 0), 0x1.0000000000002p+127);
455
456	try test__floatuntidf(make_uti(0x8000000000000000, 0), 0x1.000000p+127);
457	try test__floatuntidf(make_uti(0x8000000000000001, 0), 0x1.0000000000000002p+127);
458
459	try test__floatuntidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
460
461	try test__floatuntidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
462	try test__floatuntidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
463	try test__floatuntidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
464	try test__floatuntidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
465	try test__floatuntidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
466
467	try test__floatuntidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
468	try test__floatuntidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
469	try test__floatuntidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
470	try test__floatuntidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
471	try test__floatuntidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
472
473	try test__floatuntidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
474	try test__floatuntidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
475	try test__floatuntidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
476	try test__floatuntidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
477	try test__floatuntidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
478	try test__floatuntidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
479	try test__floatuntidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
480	try test__floatuntidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
481	try test__floatuntidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
482	try test__floatuntidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
483	try test__floatuntidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
484	try test__floatuntidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
485	try test__floatuntidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
486	try test__floatuntidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
487	try test__floatuntidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
488
489	try test__floatuntidf(make_uti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
490	try test__floatuntidf(make_uti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121);
491	try test__floatuntidf(make_uti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121);
492	try test__floatuntidf(make_uti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121);
493	try test__floatuntidf(make_uti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121);
494	try test__floatuntidf(make_uti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121);
495	try test__floatuntidf(make_uti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121);
496	try test__floatuntidf(make_uti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121);
497	try test__floatuntidf(make_uti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121);
498	try test__floatuntidf(make_uti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121);
499	try test__floatuntidf(make_uti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121);
500	try test__floatuntidf(make_uti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121);
501	try test__floatuntidf(make_uti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121);
502	try test__floatuntidf(make_uti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121);
503	try test__floatuntidf(make_uti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
504	}
505
506	fn test__floatsitf(a: i32, expected: u128) !void {
507	const r = __floatsitf(a);
508	try std.testing.expect(@bitCast(u128, r) == expected);
509	}
510
511	test "floatsitf" {
512	try test__floatsitf(0, 0);
513	try test__floatsitf(0x7FFFFFFF, 0x401dfffffffc00000000000000000000);
514	try test__floatsitf(0x12345678, 0x401b2345678000000000000000000000);
515	try test__floatsitf(-0x12345678, 0xc01b2345678000000000000000000000);
516	try test__floatsitf(@bitCast(i32, @intCast(u32, 0xffffffff)), 0xbfff0000000000000000000000000000);
517	try test__floatsitf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc01e0000000000000000000000000000);
518	}
519
520	fn test__floatunsitf(a: u32, expected_hi: u64, expected_lo: u64) !void {
521	const x = __floatunsitf(a);
522
523	const x_repr = @bitCast(u128, x);
524	const x_hi = @intCast(u64, x_repr >> 64);
525	const x_lo = @truncate(u64, x_repr);
526
527	if (x_hi == expected_hi and x_lo == expected_lo) {
528	return;
529	}
530	// nan repr
531	else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
532	if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) {
533	return;
534	}
535	}
536
537	@panic("__floatunsitf test failure");
538	}
539
540	test "floatunsitf" {
541	try test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0);
542	try test__floatunsitf(0, 0x0, 0x0);
543	try test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0);
544	try test__floatunsitf(0x12345678, 0x401b234567800000, 0x0);
545	}
546
547	fn test__floatditf(a: i64, expected: f128) !void {
548	const x = __floatditf(a);
549	try testing.expect(x == expected);
550	}
551
552	fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) !void {
553	const x = __floatunditf(a);
554
555	const x_repr = @bitCast(u128, x);
556	const x_hi = @intCast(u64, x_repr >> 64);
557	const x_lo = @truncate(u64, x_repr);
558
559	if (x_hi == expected_hi and x_lo == expected_lo) {
560	return;
561	}
562	// nan repr
563	else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
564	if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) {
565	return;
566	}
567	}
568
569	@panic("__floatunditf test failure");
570	}
571
572	test "floatditf" {
573	try test__floatditf(0x7fffffffffffffff, make_tf(0x403dffffffffffff, 0xfffc000000000000));
574	try test__floatditf(0x123456789abcdef1, make_tf(0x403b23456789abcd, 0xef10000000000000));
575	try test__floatditf(0x2, make_tf(0x4000000000000000, 0x0));
576	try test__floatditf(0x1, make_tf(0x3fff000000000000, 0x0));
577	try test__floatditf(0x0, make_tf(0x0, 0x0));
578	try test__floatditf(@bitCast(i64, @as(u64, 0xffffffffffffffff)), make_tf(0xbfff000000000000, 0x0));
579	try test__floatditf(@bitCast(i64, @as(u64, 0xfffffffffffffffe)), make_tf(0xc000000000000000, 0x0));
580	try test__floatditf(-0x123456789abcdef1, make_tf(0xc03b23456789abcd, 0xef10000000000000));
581	try test__floatditf(@bitCast(i64, @as(u64, 0x8000000000000000)), make_tf(0xc03e000000000000, 0x0));
582	}
583
584	test "floatunditf" {
585	try test__floatunditf(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000);
586	try test__floatunditf(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000);
587	try test__floatunditf(0x8000000000000000, 0x403e000000000000, 0x0);
588	try test__floatunditf(0x7fffffffffffffff, 0x403dffffffffffff, 0xfffc000000000000);
589	try test__floatunditf(0x123456789abcdef1, 0x403b23456789abcd, 0xef10000000000000);
590	try test__floatunditf(0x2, 0x4000000000000000, 0x0);
591	try test__floatunditf(0x1, 0x3fff000000000000, 0x0);
592	try test__floatunditf(0x0, 0x0, 0x0);
593	}
594
595	fn test__floattitf(a: i128, expected: f128) !void {
596	const x = __floattitf(a);
597	try testing.expect(x == expected);
598	}
599
600	fn test__floatuntitf(a: u128, expected: f128) !void {
601	const x = __floatuntitf(a);
602	try testing.expect(x == expected);
603	}
604
605	test "floattitf" {
606	try test__floattitf(0, 0.0);
607
608	try test__floattitf(1, 1.0);
609	try test__floattitf(2, 2.0);
610	try test__floattitf(20, 20.0);
611	try test__floattitf(-1, -1.0);
612	try test__floattitf(-2, -2.0);
613	try test__floattitf(-20, -20.0);
614
615	try test__floattitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
616	try test__floattitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
617	try test__floattitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
618	try test__floattitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
619
620	try test__floattitf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);
621	try test__floattitf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);
622	try test__floattitf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);
623	try test__floattitf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);
624
625	try test__floattitf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);
626	try test__floattitf(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126);
627
628	try test__floattitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
629
630	try test__floattitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
631	try test__floattitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
632	try test__floattitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
633	try test__floattitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
634	try test__floattitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
635
636	try test__floattitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
637	try test__floattitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
638	try test__floattitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
639	try test__floattitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
640	try test__floattitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
641
642	try test__floattitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
643	try test__floattitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);
644	try test__floattitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);
645	try test__floattitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);
646	try test__floattitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);
647	try test__floattitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);
648	try test__floattitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);
649	try test__floattitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);
650	try test__floattitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);
651	try test__floattitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);
652	try test__floattitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);
653	try test__floattitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);
654	try test__floattitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);
655	try test__floattitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);
656	try test__floattitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
657
658	try test__floattitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
659	try test__floattitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);
660	try test__floattitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);
661	try test__floattitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);
662	try test__floattitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);
663	try test__floattitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);
664	try test__floattitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);
665	try test__floattitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);
666	try test__floattitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);
667	try test__floattitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);
668	try test__floattitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);
669	try test__floattitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);
670	try test__floattitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);
671	try test__floattitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);
672	try test__floattitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
673
674	try test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);
675
676	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);
677	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);
678	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);
679	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);
680	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);
681	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);
682	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);
683	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);
684	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);
685	}
686
687	test "floatuntitf" {
688	try test__floatuntitf(0, 0.0);
689
690	try test__floatuntitf(1, 1.0);
691	try test__floatuntitf(2, 2.0);
692	try test__floatuntitf(20, 20.0);
693
694	try test__floatuntitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
695	try test__floatuntitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
696	try test__floatuntitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
697	try test__floatuntitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
698	try test__floatuntitf(0x7FFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFEp+59);
699	try test__floatuntitf(0xFFFFFFFFFFFFFFFE, 0xF.FFFFFFFFFFFFFFEp+60);
700	try test__floatuntitf(0xFFFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFFp+60);
701
702	try test__floatuntitf(0x8000008000000000, 0x8.000008p+60);
703	try test__floatuntitf(0x8000000000000800, 0x8.0000000000008p+60);
704	try test__floatuntitf(0x8000010000000000, 0x8.00001p+60);
705	try test__floatuntitf(0x8000000000001000, 0x8.000000000001p+60);
706
707	try test__floatuntitf(0x8000000000000000, 0x8p+60);
708	try test__floatuntitf(0x8000000000000001, 0x8.000000000000001p+60);
709
710	try test__floatuntitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
711
712	try test__floatuntitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
713	try test__floatuntitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
714	try test__floatuntitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
715	try test__floatuntitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
716	try test__floatuntitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
717
718	try test__floatuntitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
719	try test__floatuntitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
720	try test__floatuntitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
721	try test__floatuntitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
722	try test__floatuntitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
723
724	try test__floatuntitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
725	try test__floatuntitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);
726	try test__floatuntitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);
727	try test__floatuntitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);
728	try test__floatuntitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);
729	try test__floatuntitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);
730	try test__floatuntitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);
731	try test__floatuntitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);
732	try test__floatuntitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);
733	try test__floatuntitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);
734	try test__floatuntitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);
735	try test__floatuntitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);
736	try test__floatuntitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);
737	try test__floatuntitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);
738	try test__floatuntitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
739
740	try test__floatuntitf(make_uti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
741	try test__floatuntitf(make_uti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);
742	try test__floatuntitf(make_uti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);
743	try test__floatuntitf(make_uti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);
744	try test__floatuntitf(make_uti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);
745	try test__floatuntitf(make_uti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);
746	try test__floatuntitf(make_uti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);
747	try test__floatuntitf(make_uti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);
748	try test__floatuntitf(make_uti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);
749	try test__floatuntitf(make_uti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);
750	try test__floatuntitf(make_uti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);
751	try test__floatuntitf(make_uti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);
752	try test__floatuntitf(make_uti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);
753	try test__floatuntitf(make_uti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);
754	try test__floatuntitf(make_uti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
755
756	try test__floatuntitf(make_uti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);
757
758	try test__floatuntitf(make_uti(0xFFFFFFFFFFFFFFFF, 0x0000000000000000), 0x1.FFFFFFFFFFFFFFFEp+127);
759	try test__floatuntitf(make_uti(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x1.0000000000000000p+128);
760
761	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);
762	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);
763	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);
764	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);
765	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);
766	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);
767	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);
768	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);
769	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);
770	}
771
772	fn make_ti(high: u64, low: u64) i128 {
773	var result: u128 = high;
774	result <<= 64;
775	result \|= low;
776	return @bitCast(i128, result);
777	}
778
779	fn make_uti(high: u64, low: u64) u128 {
780	var result: u128 = high;
781	result <<= 64;
782	result \|= low;
783	return result;
784	}
785
786	fn make_tf(high: u64, low: u64) f128 {
787	var result: u128 = high;
788	result <<= 64;
789	result \|= low;
790	return @bitCast(f128, result);
791	}
792
793	test "conversion to f16" {
794	try testing.expect(floatXiYf(f16, @as(u32, 0)) == 0.0);
795	try testing.expect(floatXiYf(f16, @as(u32, 1)) == 1.0);
796	try testing.expect(floatXiYf(f16, @as(u32, 65504)) == 65504);
797	try testing.expect(floatXiYf(f16, @as(u32, 65504 + (1 << 4))) == math.inf(f16));
798	}
799
800	test "conversion to f32" {
801	try testing.expect(floatXiYf(f32, @as(u32, 0)) == 0.0);
802	try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u32))) != 1.0);
803	try testing.expect(floatXiYf(f32, @as(i32, math.minInt(i32))) != 1.0);
804	try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u24))) == math.maxInt(u24));
805	try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u24)) + 1) == math.maxInt(u24) + 1); // 0x100_0000 - Exact
806	try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u24)) + 2) == math.maxInt(u24) + 1); // 0x100_0001 - Tie: Rounds down to even
807	try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u24)) + 3) == math.maxInt(u24) + 3); // 0x100_0002 - Exact
808	try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u24)) + 4) == math.maxInt(u24) + 5); // 0x100_0003 - Tie: Rounds up to even
809	try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u24)) + 5) == math.maxInt(u24) + 5); // 0x100_0004 - Exact
810	}
811
812	test "conversion to f80" {
813	if (builtin.zig_backend == .stage1 and builtin.cpu.arch != .x86_64)
814	return error.SkipZigTest; // https://github.com/ziglang/zig/issues/11408
815
816	try testing.expect(floatXiYf(f80, @as(i80, -12)) == -12);
817	try testing.expect(@floatToInt(u80, floatXiYf(f80, @as(u64, math.maxInt(u64)) + 0)) == math.maxInt(u64) + 0);
818	try testing.expect(@floatToInt(u80, floatXiYf(f80, @as(u80, math.maxInt(u64)) + 1)) == math.maxInt(u64) + 1);
819
820	try testing.expect(floatXiYf(f80, @as(u32, 0)) == 0.0);
821	try testing.expect(floatXiYf(f80, @as(u32, 1)) == 1.0);
822	try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u32, math.maxInt(u24)) + 0)) == math.maxInt(u24));
823	try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u64)) + 0)) == math.maxInt(u64));
824	try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u64)) + 1)) == math.maxInt(u64) + 1); // Exact
825	try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u64)) + 2)) == math.maxInt(u64) + 1); // Rounds down
826	try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u64)) + 3)) == math.maxInt(u64) + 3); // Tie - Exact
827	try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u64)) + 4)) == math.maxInt(u64) + 5); // Rounds up
828
829	try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u65)) + 0)) == math.maxInt(u65) + 1); // Rounds up
830	try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u65)) + 1)) == math.maxInt(u65) + 1); // Exact
831	try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u65)) + 2)) == math.maxInt(u65) + 1); // Rounds down
832	try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u65)) + 3)) == math.maxInt(u65) + 1); // Tie - Rounds down
833	try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u65)) + 4)) == math.maxInt(u65) + 5); // Rounds up
834	try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u65)) + 5)) == math.maxInt(u65) + 5); // Exact
835	}

lib/compiler_rt/float_to_int_test.zig+25-23

...	@@ -1,31 +1,33 @@	...	@@ -1,31 +1,33 @@
1	const std = @import("std");	1	const std = @import("std");
2	const testing = std.testing;	2	const testing = std.testing;
3	const math = std.math;	3	const math = std.math;
4	const fixXfYi = @import("fixXfYi.zig").fixXfYi;	4
		5	const __fixunshfti = @import("fixunshfti.zig").__fixunshfti;
		6	const __fixunsxfti = @import("fixunsxfti.zig").__fixunsxfti;
5		7
6	// Conversion from f32	8	// Conversion from f32
7	const __fixsfsi = @import("fixXfYi.zig").__fixsfsi;	9	const __fixsfsi = @import("fixsfsi.zig").__fixsfsi;
8	const __fixunssfsi = @import("fixXfYi.zig").__fixunssfsi;	10	const __fixunssfsi = @import("fixunssfsi.zig").__fixunssfsi;
9	const __fixsfdi = @import("fixXfYi.zig").__fixsfdi;	11	const __fixsfdi = @import("fixsfdi.zig").__fixsfdi;
10	const __fixunssfdi = @import("fixXfYi.zig").__fixunssfdi;	12	const __fixunssfdi = @import("fixunssfdi.zig").__fixunssfdi;
11	const __fixsfti = @import("fixXfYi.zig").__fixsfti;	13	const __fixsfti = @import("fixsfti.zig").__fixsfti;
12	const __fixunssfti = @import("fixXfYi.zig").__fixunssfti;	14	const __fixunssfti = @import("fixunssfti.zig").__fixunssfti;
13		15
14	// Conversion from f64	16	// Conversion from f64
15	const __fixdfsi = @import("fixXfYi.zig").__fixdfsi;	17	const __fixdfsi = @import("fixdfsi.zig").__fixdfsi;
16	const __fixunsdfsi = @import("fixXfYi.zig").__fixunsdfsi;	18	const __fixunsdfsi = @import("fixunsdfsi.zig").__fixunsdfsi;
17	const __fixdfdi = @import("fixXfYi.zig").__fixdfdi;	19	const __fixdfdi = @import("fixdfdi.zig").__fixdfdi;
18	const __fixunsdfdi = @import("fixXfYi.zig").__fixunsdfdi;	20	const __fixunsdfdi = @import("fixunsdfdi.zig").__fixunsdfdi;
19	const __fixdfti = @import("fixXfYi.zig").__fixdfti;	21	const __fixdfti = @import("fixdfti.zig").__fixdfti;
20	const __fixunsdfti = @import("fixXfYi.zig").__fixunsdfti;	22	const __fixunsdfti = @import("fixunsdfti.zig").__fixunsdfti;
21		23
22	// Conversion from f128	24	// Conversion from f128
23	const __fixtfsi = @import("fixXfYi.zig").__fixtfsi;	25	const __fixtfsi = @import("fixtfsi.zig").__fixtfsi;
24	const __fixunstfsi = @import("fixXfYi.zig").__fixunstfsi;	26	const __fixunstfsi = @import("fixunstfsi.zig").__fixunstfsi;
25	const __fixtfdi = @import("fixXfYi.zig").__fixtfdi;	27	const __fixtfdi = @import("fixtfdi.zig").__fixtfdi;
26	const __fixunstfdi = @import("fixXfYi.zig").__fixunstfdi;	28	const __fixunstfdi = @import("fixunstfdi.zig").__fixunstfdi;
27	const __fixtfti = @import("fixXfYi.zig").__fixtfti;	29	const __fixtfti = @import("fixtfti.zig").__fixtfti;
28	const __fixunstfti = @import("fixXfYi.zig").__fixunstfti;	30	const __fixunstfti = @import("fixunstfti.zig").__fixunstfti;
29		31
30	fn test__fixsfsi(a: f32, expected: i32) !void {	32	fn test__fixsfsi(a: f32, expected: i32) !void {
31	const x = __fixsfsi(a);	33	const x = __fixsfsi(a);
...	@@ -927,21 +929,21 @@ test "fixunstfti" {	...	@@ -927,21 +929,21 @@ test "fixunstfti" {
927	}	929	}
928		930
929	fn test__fixunshfti(a: f16, expected: u128) !void {	931	fn test__fixunshfti(a: f16, expected: u128) !void {
930	const x = fixXfYi(u128, a);	932	const x = __fixunshfti(a);
931	try testing.expect(x == expected);	933	try testing.expect(x == expected);
932	}	934	}
933		935
934	test "fixXfYi for f16" {	936	test "fixunshfti for f16" {
935	try test__fixunshfti(math.inf(f16), math.maxInt(u128));	937	try test__fixunshfti(math.inf(f16), math.maxInt(u128));
936	try test__fixunshfti(math.floatMax(f16), 65504);	938	try test__fixunshfti(math.floatMax(f16), 65504);
937	}	939	}
938		940
939	fn test__fixunsxfti(a: f80, expected: u128) !void {	941	fn test__fixunsxfti(a: f80, expected: u128) !void {
940	const x = fixXfYi(u128, a);	942	const x = __fixunsxfti(a);
941	try testing.expect(x == expected);	943	try testing.expect(x == expected);
942	}	944	}
943		945
944	test "fixXfYi for f80" {	946	test "fixunsxfti for f80" {
945	try test__fixunsxfti(math.inf(f80), math.maxInt(u128));	947	try test__fixunsxfti(math.inf(f80), math.maxInt(u128));
946	try test__fixunsxfti(math.floatMax(f80), math.maxInt(u128));	948	try test__fixunsxfti(math.floatMax(f80), math.maxInt(u128));
947	try test__fixunsxfti(math.maxInt(u64), math.maxInt(u64));	949	try test__fixunsxfti(math.maxInt(u64), math.maxInt(u64));

lib/compiler_rt/floatdidf.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __floatdidf(a: i64) callconv(.C) f64 {	14	pub fn __floatdidf(a: i64) callconv(.C) f64 {
15	return intToFloat(f64, a);	15	return intToFloat(f64, a);
16	}	16	}
17		17

lib/compiler_rt/floatdisf.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __floatdisf(a: i64) callconv(.C) f32 {	14	pub fn __floatdisf(a: i64) callconv(.C) f32 {
15	return intToFloat(f32, a);	15	return intToFloat(f32, a);
16	}	16	}
17		17

lib/compiler_rt/floatditf.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __floatditf(a: i64) callconv(.C) f128 {	16	pub fn __floatditf(a: i64) callconv(.C) f128 {
17	return intToFloat(f128, a);	17	return intToFloat(f128, a);
18	}	18	}
19		19

lib/compiler_rt/floatsidf.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __floatsidf(a: i32) callconv(.C) f64 {	14	pub fn __floatsidf(a: i32) callconv(.C) f64 {
15	return intToFloat(f64, a);	15	return intToFloat(f64, a);
16	}	16	}
17		17

lib/compiler_rt/floatsisf.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __floatsisf(a: i32) callconv(.C) f32 {	14	pub fn __floatsisf(a: i32) callconv(.C) f32 {
15	return intToFloat(f32, a);	15	return intToFloat(f32, a);
16	}	16	}
17		17

lib/compiler_rt/floatsitf.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __floatsitf(a: i32) callconv(.C) f128 {	16	pub fn __floatsitf(a: i32) callconv(.C) f128 {
17	return intToFloat(f128, a);	17	return intToFloat(f128, a);
18	}	18	}
19		19

lib/compiler_rt/floattidf.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__floattidf, .{ .name = "__floattidf", .linkage = common.linkage });	7	@export(__floattidf, .{ .name = "__floattidf", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __floattidf(a: i128) callconv(.C) f64 {	10	pub fn __floattidf(a: i128) callconv(.C) f64 {
11	return intToFloat(f64, a);	11	return intToFloat(f64, a);
12	}	12	}

lib/compiler_rt/floattisf.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__floattisf, .{ .name = "__floattisf", .linkage = common.linkage });	7	@export(__floattisf, .{ .name = "__floattisf", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __floattisf(a: i128) callconv(.C) f32 {	10	pub fn __floattisf(a: i128) callconv(.C) f32 {
11	return intToFloat(f32, a);	11	return intToFloat(f32, a);
12	}	12	}

lib/compiler_rt/floattitf.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__floattitf, .{ .name = "__floattitf", .linkage = common.linkage });	7	@export(__floattitf, .{ .name = "__floattitf", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __floattitf(a: i128) callconv(.C) f128 {	10	pub fn __floattitf(a: i128) callconv(.C) f128 {
11	return intToFloat(f128, a);	11	return intToFloat(f128, a);
12	}	12	}

lib/compiler_rt/floatundidf.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __floatundidf(a: u64) callconv(.C) f64 {	14	pub fn __floatundidf(a: u64) callconv(.C) f64 {
15	return intToFloat(f64, a);	15	return intToFloat(f64, a);
16	}	16	}
17		17

lib/compiler_rt/floatundisf.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __floatundisf(a: u64) callconv(.C) f32 {	14	pub fn __floatundisf(a: u64) callconv(.C) f32 {
15	return intToFloat(f32, a);	15	return intToFloat(f32, a);
16	}	16	}
17		17

lib/compiler_rt/floatunditf.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __floatunditf(a: u64) callconv(.C) f128 {	16	pub fn __floatunditf(a: u64) callconv(.C) f128 {
17	return intToFloat(f128, a);	17	return intToFloat(f128, a);
18	}	18	}
19		19

lib/compiler_rt/floatunsidf.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __floatunsidf(a: u32) callconv(.C) f64 {	14	pub fn __floatunsidf(a: u32) callconv(.C) f64 {
15	return intToFloat(f64, a);	15	return intToFloat(f64, a);
16	}	16	}
17		17

lib/compiler_rt/floatunsihf.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__floatunsihf, .{ .name = "__floatunsihf", .linkage = common.linkage });	7	@export(__floatunsihf, .{ .name = "__floatunsihf", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __floatunsihf(a: u32) callconv(.C) f16 {	10	pub fn __floatunsihf(a: u32) callconv(.C) f16 {
11	return intToFloat(f16, a);	11	return intToFloat(f16, a);
12	}	12	}

lib/compiler_rt/floatunsisf.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __floatunsisf(a: u32) callconv(.C) f32 {	14	pub fn __floatunsisf(a: u32) callconv(.C) f32 {
15	return intToFloat(f32, a);	15	return intToFloat(f32, a);
16	}	16	}
17		17

lib/compiler_rt/floatunsitf.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __floatunsitf(a: u32) callconv(.C) f128 {	16	pub fn __floatunsitf(a: u32) callconv(.C) f128 {
17	return intToFloat(f128, a);	17	return intToFloat(f128, a);
18	}	18	}
19		19

lib/compiler_rt/floatuntidf.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = common.linkage });	7	@export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __floatuntidf(a: u128) callconv(.C) f64 {	10	pub fn __floatuntidf(a: u128) callconv(.C) f64 {
11	return intToFloat(f64, a);	11	return intToFloat(f64, a);
12	}	12	}

lib/compiler_rt/floatuntisf.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = common.linkage });	7	@export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __floatuntisf(a: u128) callconv(.C) f32 {	10	pub fn __floatuntisf(a: u128) callconv(.C) f32 {
11	return intToFloat(f32, a);	11	return intToFloat(f32, a);
12	}	12	}

lib/compiler_rt/floatuntitf.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __floatuntitf(a: u128) callconv(.C) f128 {	14	pub fn __floatuntitf(a: u128) callconv(.C) f128 {
15	return intToFloat(f128, a);	15	return intToFloat(f128, a);
16	}	16	}
17		17

lib/compiler_rt/gedf2.zig+2-2

...	@@ -17,13 +17,13 @@ comptime {	...	@@ -17,13 +17,13 @@ comptime {
17		17
18	/// "These functions return a value greater than or equal to zero if neither	18	/// "These functions return a value greater than or equal to zero if neither
19	/// argument is NaN, and a is greater than or equal to b."	19	/// argument is NaN, and a is greater than or equal to b."
20	fn __gedf2(a: f64, b: f64) callconv(.C) i32 {	20	pub fn __gedf2(a: f64, b: f64) callconv(.C) i32 {
21	return @enumToInt(comparef.cmpf2(f64, comparef.GE, a, b));	21	return @enumToInt(comparef.cmpf2(f64, comparef.GE, a, b));
22	}	22	}
23		23
24	/// "These functions return a value greater than zero if neither argument is NaN,	24	/// "These functions return a value greater than zero if neither argument is NaN,
25	/// and a is strictly greater than b."	25	/// and a is strictly greater than b."
26	fn __gtdf2(a: f64, b: f64) callconv(.C) i32 {	26	pub fn __gtdf2(a: f64, b: f64) callconv(.C) i32 {
27	return __gedf2(a, b);	27	return __gedf2(a, b);
28	}	28	}
29		29

lib/compiler_rt/gesf2.zig+2-2

...	@@ -17,13 +17,13 @@ comptime {	...	@@ -17,13 +17,13 @@ comptime {
17		17
18	/// "These functions return a value greater than or equal to zero if neither	18	/// "These functions return a value greater than or equal to zero if neither
19	/// argument is NaN, and a is greater than or equal to b."	19	/// argument is NaN, and a is greater than or equal to b."
20	fn __gesf2(a: f32, b: f32) callconv(.C) i32 {	20	pub fn __gesf2(a: f32, b: f32) callconv(.C) i32 {
21	return @enumToInt(comparef.cmpf2(f32, comparef.GE, a, b));	21	return @enumToInt(comparef.cmpf2(f32, comparef.GE, a, b));
22	}	22	}
23		23
24	/// "These functions return a value greater than zero if neither argument is NaN,	24	/// "These functions return a value greater than zero if neither argument is NaN,
25	/// and a is strictly greater than b."	25	/// and a is strictly greater than b."
26	fn __gtsf2(a: f32, b: f32) callconv(.C) i32 {	26	pub fn __gtsf2(a: f32, b: f32) callconv(.C) i32 {
27	return __gesf2(a, b);	27	return __gesf2(a, b);
28	}	28	}
29		29

lib/compiler_rt/int_to_float.zig+1-1

...	@@ -54,5 +54,5 @@ pub fn intToFloat(comptime T: type, x: anytype) T {	...	@@ -54,5 +54,5 @@ pub fn intToFloat(comptime T: type, x: anytype) T {
54	}	54	}
55		55
56	test {	56	test {
57	_ = @import("floatXiYf_test.zig");	57	_ = @import("int_to_float_test.zig");
58	}	58	}

lib/compiler_rt/int_to_float_test.zig created+838

...	@@ -0,0 +1,838 @@
1	const std = @import("std");
2	const builtin = @import("builtin");
3	const testing = std.testing;
4	const math = std.math;
5
6	const __floatunsihf = @import("floatunsihf.zig").__floatunsihf;
7
8	// Conversion to f32
9	const __floatsisf = @import("floatsisf.zig").__floatsisf;
10	const __floatunsisf = @import("floatunsisf.zig").__floatunsisf;
11	const __floatdisf = @import("floatdisf.zig").__floatdisf;
12	const __floatundisf = @import("floatundisf.zig").__floatundisf;
13	const __floattisf = @import("floattisf.zig").__floattisf;
14	const __floatuntisf = @import("floatuntisf.zig").__floatuntisf;
15
16	// Conversion to f64
17	const __floatsidf = @import("floatsidf.zig").__floatsidf;
18	const __floatunsidf = @import("floatunsidf.zig").__floatunsidf;
19	const __floatdidf = @import("floatdidf.zig").__floatdidf;
20	const __floatundidf = @import("floatundidf.zig").__floatundidf;
21	const __floattidf = @import("floattidf.zig").__floattidf;
22	const __floatuntidf = @import("floatuntidf.zig").__floatuntidf;
23
24	// Conversion to f128
25	const __floatsitf = @import("floatsitf.zig").__floatsitf;
26	const __floatunsitf = @import("floatunsitf.zig").__floatunsitf;
27	const __floatditf = @import("floatditf.zig").__floatditf;
28	const __floatunditf = @import("floatunditf.zig").__floatunditf;
29	const __floattitf = @import("floattitf.zig").__floattitf;
30	const __floatuntitf = @import("floatuntitf.zig").__floatuntitf;
31
32	fn test__floatsisf(a: i32, expected: u32) !void {
33	const r = __floatsisf(a);
34	try std.testing.expect(@bitCast(u32, r) == expected);
35	}
36
37	fn test_one_floatunsisf(a: u32, expected: u32) !void {
38	const r = __floatunsisf(a);
39	try std.testing.expect(@bitCast(u32, r) == expected);
40	}
41
42	test "floatsisf" {
43	try test__floatsisf(0, 0x00000000);
44	try test__floatsisf(1, 0x3f800000);
45	try test__floatsisf(-1, 0xbf800000);
46	try test__floatsisf(0x7FFFFFFF, 0x4f000000);
47	try test__floatsisf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xcf000000);
48	}
49
50	test "floatunsisf" {
51	// Test the produced bit pattern
52	try test_one_floatunsisf(0, 0);
53	try test_one_floatunsisf(1, 0x3f800000);
54	try test_one_floatunsisf(0x7FFFFFFF, 0x4f000000);
55	try test_one_floatunsisf(0x80000000, 0x4f000000);
56	try test_one_floatunsisf(0xFFFFFFFF, 0x4f800000);
57	}
58
59	fn test__floatdisf(a: i64, expected: f32) !void {
60	const x = __floatdisf(a);
61	try testing.expect(x == expected);
62	}
63
64	fn test__floatundisf(a: u64, expected: f32) !void {
65	try std.testing.expectEqual(expected, __floatundisf(a));
66	}
67
68	test "floatdisf" {
69	try test__floatdisf(0, 0.0);
70	try test__floatdisf(1, 1.0);
71	try test__floatdisf(2, 2.0);
72	try test__floatdisf(-1, -1.0);
73	try test__floatdisf(-2, -2.0);
74	try test__floatdisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
75	try test__floatdisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
76	try test__floatdisf(@bitCast(i64, @as(u64, 0x8000008000000000)), -0x1.FFFFFEp+62);
77	try test__floatdisf(@bitCast(i64, @as(u64, 0x8000010000000000)), -0x1.FFFFFCp+62);
78	try test__floatdisf(@bitCast(i64, @as(u64, 0x8000000000000000)), -0x1.000000p+63);
79	try test__floatdisf(@bitCast(i64, @as(u64, 0x8000000000000001)), -0x1.000000p+63);
80	try test__floatdisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
81	try test__floatdisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
82	try test__floatdisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
83	try test__floatdisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
84	try test__floatdisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
85	try test__floatdisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
86	try test__floatdisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
87	try test__floatdisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
88	try test__floatdisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
89	try test__floatdisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
90	try test__floatdisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
91	}
92
93	test "floatundisf" {
94	try test__floatundisf(0, 0.0);
95	try test__floatundisf(1, 1.0);
96	try test__floatundisf(2, 2.0);
97	try test__floatundisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
98	try test__floatundisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
99	try test__floatundisf(0x8000008000000000, 0x1p+63);
100	try test__floatundisf(0x8000010000000000, 0x1.000002p+63);
101	try test__floatundisf(0x8000000000000000, 0x1p+63);
102	try test__floatundisf(0x8000000000000001, 0x1p+63);
103	try test__floatundisf(0xFFFFFFFFFFFFFFFE, 0x1p+64);
104	try test__floatundisf(0xFFFFFFFFFFFFFFFF, 0x1p+64);
105	try test__floatundisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
106	try test__floatundisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
107	try test__floatundisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
108	try test__floatundisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
109	try test__floatundisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
110	try test__floatundisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
111	try test__floatundisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
112	try test__floatundisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
113	try test__floatundisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
114	try test__floatundisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
115	try test__floatundisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
116	}
117
118	fn test__floattisf(a: i128, expected: f32) !void {
119	const x = __floattisf(a);
120	try testing.expect(x == expected);
121	}
122
123	fn test__floatuntisf(a: u128, expected: f32) !void {
124	const x = __floatuntisf(a);
125	try testing.expect(x == expected);
126	}
127
128	test "floattisf" {
129	try test__floattisf(0, 0.0);
130
131	try test__floattisf(1, 1.0);
132	try test__floattisf(2, 2.0);
133	try test__floattisf(-1, -1.0);
134	try test__floattisf(-2, -2.0);
135
136	try test__floattisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
137	try test__floattisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
138
139	try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000008000000000), -0x1.FFFFFEp+62);
140	try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000010000000000), -0x1.FFFFFCp+62);
141
142	try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000000), -0x1.000000p+63);
143	try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000001), -0x1.000000p+63);
144
145	try test__floattisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
146
147	try test__floattisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
148	try test__floattisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
149	try test__floattisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
150	try test__floattisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
151	try test__floattisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
152
153	try test__floattisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
154	try test__floattisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
155	try test__floattisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
156	try test__floattisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
157	try test__floattisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
158
159	try test__floattisf(make_ti(0x0007FB72E8000000, 0), 0x1.FEDCBAp+114);
160
161	try test__floattisf(make_ti(0x0007FB72EA000000, 0), 0x1.FEDCBAp+114);
162	try test__floattisf(make_ti(0x0007FB72EB000000, 0), 0x1.FEDCBAp+114);
163	try test__floattisf(make_ti(0x0007FB72EBFFFFFF, 0), 0x1.FEDCBAp+114);
164	try test__floattisf(make_ti(0x0007FB72EC000000, 0), 0x1.FEDCBCp+114);
165	try test__floattisf(make_ti(0x0007FB72E8000001, 0), 0x1.FEDCBAp+114);
166
167	try test__floattisf(make_ti(0x0007FB72E6000000, 0), 0x1.FEDCBAp+114);
168	try test__floattisf(make_ti(0x0007FB72E7000000, 0), 0x1.FEDCBAp+114);
169	try test__floattisf(make_ti(0x0007FB72E7FFFFFF, 0), 0x1.FEDCBAp+114);
170	try test__floattisf(make_ti(0x0007FB72E4000001, 0), 0x1.FEDCBAp+114);
171	try test__floattisf(make_ti(0x0007FB72E4000000, 0), 0x1.FEDCB8p+114);
172	}
173
174	test "floatuntisf" {
175	try test__floatuntisf(0, 0.0);
176
177	try test__floatuntisf(1, 1.0);
178	try test__floatuntisf(2, 2.0);
179	try test__floatuntisf(20, 20.0);
180
181	try test__floatuntisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
182	try test__floatuntisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
183
184	try test__floatuntisf(make_uti(0x8000008000000000, 0), 0x1.000001p+127);
185	try test__floatuntisf(make_uti(0x8000000000000800, 0), 0x1.0p+127);
186	try test__floatuntisf(make_uti(0x8000010000000000, 0), 0x1.000002p+127);
187
188	try test__floatuntisf(make_uti(0x8000000000000000, 0), 0x1.000000p+127);
189
190	try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
191
192	try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
193	try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
194
195	try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
196
197	try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
198	try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
199	try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
200
201	try test__floatuntisf(0xFFFFFFFFFFFFFFFE, 0x1p+64);
202	try test__floatuntisf(0xFFFFFFFFFFFFFFFF, 0x1p+64);
203
204	try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
205
206	try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
207	try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
208	try test__floatuntisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
209	try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
210	try test__floatuntisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
211
212	try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
213	try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
214	try test__floatuntisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
215	try test__floatuntisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
216	try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
217
218	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCB90000000000001), 0x1.FEDCBAp+76);
219	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBA0000000000000), 0x1.FEDCBAp+76);
220	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBAFFFFFFFFFFFFF), 0x1.FEDCBAp+76);
221	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBB0000000000000), 0x1.FEDCBCp+76);
222	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBB0000000000001), 0x1.FEDCBCp+76);
223	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBBFFFFFFFFFFFFF), 0x1.FEDCBCp+76);
224	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBC0000000000000), 0x1.FEDCBCp+76);
225	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBC0000000000001), 0x1.FEDCBCp+76);
226	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBD0000000000000), 0x1.FEDCBCp+76);
227	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBD0000000000001), 0x1.FEDCBEp+76);
228	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBDFFFFFFFFFFFFF), 0x1.FEDCBEp+76);
229	try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBE0000000000000), 0x1.FEDCBEp+76);
230
231	// Test overflow to infinity
232	try test__floatuntisf(@as(u128, math.maxInt(u128)), @bitCast(f32, math.inf(f32)));
233	}
234
235	fn test_one_floatsidf(a: i32, expected: u64) !void {
236	const r = __floatsidf(a);
237	try std.testing.expect(@bitCast(u64, r) == expected);
238	}
239
240	fn test_one_floatunsidf(a: u32, expected: u64) !void {
241	const r = __floatunsidf(a);
242	try std.testing.expect(@bitCast(u64, r) == expected);
243	}
244
245	test "floatsidf" {
246	try test_one_floatsidf(0, 0x0000000000000000);
247	try test_one_floatsidf(1, 0x3ff0000000000000);
248	try test_one_floatsidf(-1, 0xbff0000000000000);
249	try test_one_floatsidf(0x7FFFFFFF, 0x41dfffffffc00000);
250	try test_one_floatsidf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc1e0000000000000);
251	}
252
253	test "floatunsidf" {
254	try test_one_floatunsidf(0, 0x0000000000000000);
255	try test_one_floatunsidf(1, 0x3ff0000000000000);
256	try test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000);
257	try test_one_floatunsidf(@intCast(u32, 0x80000000), 0x41e0000000000000);
258	try test_one_floatunsidf(@intCast(u32, 0xFFFFFFFF), 0x41efffffffe00000);
259	}
260
261	fn test__floatdidf(a: i64, expected: f64) !void {
262	const r = __floatdidf(a);
263	try testing.expect(r == expected);
264	}
265
266	fn test__floatundidf(a: u64, expected: f64) !void {
267	const r = __floatundidf(a);
268	try testing.expect(r == expected);
269	}
270
271	test "floatdidf" {
272	try test__floatdidf(0, 0.0);
273	try test__floatdidf(1, 1.0);
274	try test__floatdidf(2, 2.0);
275	try test__floatdidf(20, 20.0);
276	try test__floatdidf(-1, -1.0);
277	try test__floatdidf(-2, -2.0);
278	try test__floatdidf(-20, -20.0);
279	try test__floatdidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
280	try test__floatdidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
281	try test__floatdidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
282	try test__floatdidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
283	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000008000000000)), -0x1.FFFFFEp+62);
284	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000800)), -0x1.FFFFFFFFFFFFEp+62);
285	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000010000000000)), -0x1.FFFFFCp+62);
286	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000001000)), -0x1.FFFFFFFFFFFFCp+62);
287	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000000)), -0x1.000000p+63);
288	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000001)), -0x1.000000p+63); // 0x8000000000000001
289	try test__floatdidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
290	try test__floatdidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
291	try test__floatdidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
292	try test__floatdidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
293	try test__floatdidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
294	try test__floatdidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
295	try test__floatdidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
296	try test__floatdidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
297	try test__floatdidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
298	try test__floatdidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
299	try test__floatdidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
300	try test__floatdidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
301	try test__floatdidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
302	try test__floatdidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
303	try test__floatdidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
304	try test__floatdidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
305	try test__floatdidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
306	try test__floatdidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
307	try test__floatdidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
308	try test__floatdidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
309	try test__floatdidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
310	try test__floatdidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
311	try test__floatdidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
312	try test__floatdidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
313	try test__floatdidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
314	try test__floatdidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
315	}
316
317	test "floatundidf" {
318	try test__floatundidf(0, 0.0);
319	try test__floatundidf(1, 1.0);
320	try test__floatundidf(2, 2.0);
321	try test__floatundidf(20, 20.0);
322	try test__floatundidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
323	try test__floatundidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
324	try test__floatundidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
325	try test__floatundidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
326	try test__floatundidf(0x8000008000000000, 0x1.000001p+63);
327	try test__floatundidf(0x8000000000000800, 0x1.0000000000001p+63);
328	try test__floatundidf(0x8000010000000000, 0x1.000002p+63);
329	try test__floatundidf(0x8000000000001000, 0x1.0000000000002p+63);
330	try test__floatundidf(0x8000000000000000, 0x1p+63);
331	try test__floatundidf(0x8000000000000001, 0x1p+63);
332	try test__floatundidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
333	try test__floatundidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
334	try test__floatundidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
335	try test__floatundidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
336	try test__floatundidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
337	try test__floatundidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
338	try test__floatundidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
339	try test__floatundidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
340	try test__floatundidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
341	try test__floatundidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
342	try test__floatundidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
343	try test__floatundidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
344	try test__floatundidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
345	try test__floatundidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
346	try test__floatundidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
347	try test__floatundidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
348	try test__floatundidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
349	try test__floatundidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
350	try test__floatundidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
351	try test__floatundidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
352	try test__floatundidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
353	try test__floatundidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
354	try test__floatundidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
355	try test__floatundidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
356	try test__floatundidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
357	try test__floatundidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
358	}
359
360	fn test__floattidf(a: i128, expected: f64) !void {
361	const x = __floattidf(a);
362	try testing.expect(x == expected);
363	}
364
365	fn test__floatuntidf(a: u128, expected: f64) !void {
366	const x = __floatuntidf(a);
367	try testing.expect(x == expected);
368	}
369
370	test "floattidf" {
371	try test__floattidf(0, 0.0);
372
373	try test__floattidf(1, 1.0);
374	try test__floattidf(2, 2.0);
375	try test__floattidf(20, 20.0);
376	try test__floattidf(-1, -1.0);
377	try test__floattidf(-2, -2.0);
378	try test__floattidf(-20, -20.0);
379
380	try test__floattidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
381	try test__floattidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
382	try test__floattidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
383	try test__floattidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
384
385	try test__floattidf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);
386	try test__floattidf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);
387	try test__floattidf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);
388	try test__floattidf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);
389
390	try test__floattidf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);
391	try test__floattidf(make_ti(0x8000000000000001, 0), -0x1.000000p+127);
392
393	try test__floattidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
394
395	try test__floattidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
396	try test__floattidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
397	try test__floattidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
398	try test__floattidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
399	try test__floattidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
400
401	try test__floattidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
402	try test__floattidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
403	try test__floattidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
404	try test__floattidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
405	try test__floattidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
406
407	try test__floattidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
408	try test__floattidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
409	try test__floattidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
410	try test__floattidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
411	try test__floattidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
412	try test__floattidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
413	try test__floattidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
414	try test__floattidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
415	try test__floattidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
416	try test__floattidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
417	try test__floattidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
418	try test__floattidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
419	try test__floattidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
420	try test__floattidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
421	try test__floattidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
422
423	try test__floattidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
424	try test__floattidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121);
425	try test__floattidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121);
426	try test__floattidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121);
427	try test__floattidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121);
428	try test__floattidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121);
429	try test__floattidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121);
430	try test__floattidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121);
431	try test__floattidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121);
432	try test__floattidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121);
433	try test__floattidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121);
434	try test__floattidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121);
435	try test__floattidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121);
436	try test__floattidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121);
437	try test__floattidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
438	}
439
440	test "floatuntidf" {
441	try test__floatuntidf(0, 0.0);
442
443	try test__floatuntidf(1, 1.0);
444	try test__floatuntidf(2, 2.0);
445	try test__floatuntidf(20, 20.0);
446
447	try test__floatuntidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
448	try test__floatuntidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
449	try test__floatuntidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
450	try test__floatuntidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
451
452	try test__floatuntidf(make_uti(0x8000008000000000, 0), 0x1.000001p+127);
453	try test__floatuntidf(make_uti(0x8000000000000800, 0), 0x1.0000000000001p+127);
454	try test__floatuntidf(make_uti(0x8000010000000000, 0), 0x1.000002p+127);
455	try test__floatuntidf(make_uti(0x8000000000001000, 0), 0x1.0000000000002p+127);
456
457	try test__floatuntidf(make_uti(0x8000000000000000, 0), 0x1.000000p+127);
458	try test__floatuntidf(make_uti(0x8000000000000001, 0), 0x1.0000000000000002p+127);
459
460	try test__floatuntidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
461
462	try test__floatuntidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
463	try test__floatuntidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
464	try test__floatuntidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
465	try test__floatuntidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
466	try test__floatuntidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
467
468	try test__floatuntidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
469	try test__floatuntidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
470	try test__floatuntidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
471	try test__floatuntidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
472	try test__floatuntidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
473
474	try test__floatuntidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
475	try test__floatuntidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
476	try test__floatuntidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
477	try test__floatuntidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
478	try test__floatuntidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
479	try test__floatuntidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
480	try test__floatuntidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
481	try test__floatuntidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
482	try test__floatuntidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
483	try test__floatuntidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
484	try test__floatuntidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
485	try test__floatuntidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
486	try test__floatuntidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
487	try test__floatuntidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
488	try test__floatuntidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
489
490	try test__floatuntidf(make_uti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
491	try test__floatuntidf(make_uti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121);
492	try test__floatuntidf(make_uti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121);
493	try test__floatuntidf(make_uti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121);
494	try test__floatuntidf(make_uti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121);
495	try test__floatuntidf(make_uti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121);
496	try test__floatuntidf(make_uti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121);
497	try test__floatuntidf(make_uti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121);
498	try test__floatuntidf(make_uti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121);
499	try test__floatuntidf(make_uti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121);
500	try test__floatuntidf(make_uti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121);
501	try test__floatuntidf(make_uti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121);
502	try test__floatuntidf(make_uti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121);
503	try test__floatuntidf(make_uti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121);
504	try test__floatuntidf(make_uti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
505	}
506
507	fn test__floatsitf(a: i32, expected: u128) !void {
508	const r = __floatsitf(a);
509	try std.testing.expect(@bitCast(u128, r) == expected);
510	}
511
512	test "floatsitf" {
513	try test__floatsitf(0, 0);
514	try test__floatsitf(0x7FFFFFFF, 0x401dfffffffc00000000000000000000);
515	try test__floatsitf(0x12345678, 0x401b2345678000000000000000000000);
516	try test__floatsitf(-0x12345678, 0xc01b2345678000000000000000000000);
517	try test__floatsitf(@bitCast(i32, @intCast(u32, 0xffffffff)), 0xbfff0000000000000000000000000000);
518	try test__floatsitf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc01e0000000000000000000000000000);
519	}
520
521	fn test__floatunsitf(a: u32, expected_hi: u64, expected_lo: u64) !void {
522	const x = __floatunsitf(a);
523
524	const x_repr = @bitCast(u128, x);
525	const x_hi = @intCast(u64, x_repr >> 64);
526	const x_lo = @truncate(u64, x_repr);
527
528	if (x_hi == expected_hi and x_lo == expected_lo) {
529	return;
530	}
531	// nan repr
532	else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
533	if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) {
534	return;
535	}
536	}
537
538	@panic("__floatunsitf test failure");
539	}
540
541	test "floatunsitf" {
542	try test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0);
543	try test__floatunsitf(0, 0x0, 0x0);
544	try test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0);
545	try test__floatunsitf(0x12345678, 0x401b234567800000, 0x0);
546	}
547
548	fn test__floatditf(a: i64, expected: f128) !void {
549	const x = __floatditf(a);
550	try testing.expect(x == expected);
551	}
552
553	fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) !void {
554	const x = __floatunditf(a);
555
556	const x_repr = @bitCast(u128, x);
557	const x_hi = @intCast(u64, x_repr >> 64);
558	const x_lo = @truncate(u64, x_repr);
559
560	if (x_hi == expected_hi and x_lo == expected_lo) {
561	return;
562	}
563	// nan repr
564	else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
565	if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) {
566	return;
567	}
568	}
569
570	@panic("__floatunditf test failure");
571	}
572
573	test "floatditf" {
574	try test__floatditf(0x7fffffffffffffff, make_tf(0x403dffffffffffff, 0xfffc000000000000));
575	try test__floatditf(0x123456789abcdef1, make_tf(0x403b23456789abcd, 0xef10000000000000));
576	try test__floatditf(0x2, make_tf(0x4000000000000000, 0x0));
577	try test__floatditf(0x1, make_tf(0x3fff000000000000, 0x0));
578	try test__floatditf(0x0, make_tf(0x0, 0x0));
579	try test__floatditf(@bitCast(i64, @as(u64, 0xffffffffffffffff)), make_tf(0xbfff000000000000, 0x0));
580	try test__floatditf(@bitCast(i64, @as(u64, 0xfffffffffffffffe)), make_tf(0xc000000000000000, 0x0));
581	try test__floatditf(-0x123456789abcdef1, make_tf(0xc03b23456789abcd, 0xef10000000000000));
582	try test__floatditf(@bitCast(i64, @as(u64, 0x8000000000000000)), make_tf(0xc03e000000000000, 0x0));
583	}
584
585	test "floatunditf" {
586	try test__floatunditf(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000);
587	try test__floatunditf(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000);
588	try test__floatunditf(0x8000000000000000, 0x403e000000000000, 0x0);
589	try test__floatunditf(0x7fffffffffffffff, 0x403dffffffffffff, 0xfffc000000000000);
590	try test__floatunditf(0x123456789abcdef1, 0x403b23456789abcd, 0xef10000000000000);
591	try test__floatunditf(0x2, 0x4000000000000000, 0x0);
592	try test__floatunditf(0x1, 0x3fff000000000000, 0x0);
593	try test__floatunditf(0x0, 0x0, 0x0);
594	}
595
596	fn test__floattitf(a: i128, expected: f128) !void {
597	const x = __floattitf(a);
598	try testing.expect(x == expected);
599	}
600
601	fn test__floatuntitf(a: u128, expected: f128) !void {
602	const x = __floatuntitf(a);
603	try testing.expect(x == expected);
604	}
605
606	test "floattitf" {
607	try test__floattitf(0, 0.0);
608
609	try test__floattitf(1, 1.0);
610	try test__floattitf(2, 2.0);
611	try test__floattitf(20, 20.0);
612	try test__floattitf(-1, -1.0);
613	try test__floattitf(-2, -2.0);
614	try test__floattitf(-20, -20.0);
615
616	try test__floattitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
617	try test__floattitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
618	try test__floattitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
619	try test__floattitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
620
621	try test__floattitf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);
622	try test__floattitf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);
623	try test__floattitf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);
624	try test__floattitf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);
625
626	try test__floattitf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);
627	try test__floattitf(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126);
628
629	try test__floattitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
630
631	try test__floattitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
632	try test__floattitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
633	try test__floattitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
634	try test__floattitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
635	try test__floattitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
636
637	try test__floattitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
638	try test__floattitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
639	try test__floattitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
640	try test__floattitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
641	try test__floattitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
642
643	try test__floattitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
644	try test__floattitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);
645	try test__floattitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);
646	try test__floattitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);
647	try test__floattitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);
648	try test__floattitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);
649	try test__floattitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);
650	try test__floattitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);
651	try test__floattitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);
652	try test__floattitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);
653	try test__floattitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);
654	try test__floattitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);
655	try test__floattitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);
656	try test__floattitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);
657	try test__floattitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
658
659	try test__floattitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
660	try test__floattitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);
661	try test__floattitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);
662	try test__floattitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);
663	try test__floattitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);
664	try test__floattitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);
665	try test__floattitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);
666	try test__floattitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);
667	try test__floattitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);
668	try test__floattitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);
669	try test__floattitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);
670	try test__floattitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);
671	try test__floattitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);
672	try test__floattitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);
673	try test__floattitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
674
675	try test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);
676
677	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);
678	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);
679	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);
680	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);
681	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);
682	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);
683	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);
684	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);
685	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);
686	}
687
688	test "floatuntitf" {
689	try test__floatuntitf(0, 0.0);
690
691	try test__floatuntitf(1, 1.0);
692	try test__floatuntitf(2, 2.0);
693	try test__floatuntitf(20, 20.0);
694
695	try test__floatuntitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
696	try test__floatuntitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
697	try test__floatuntitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
698	try test__floatuntitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
699	try test__floatuntitf(0x7FFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFEp+59);
700	try test__floatuntitf(0xFFFFFFFFFFFFFFFE, 0xF.FFFFFFFFFFFFFFEp+60);
701	try test__floatuntitf(0xFFFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFFp+60);
702
703	try test__floatuntitf(0x8000008000000000, 0x8.000008p+60);
704	try test__floatuntitf(0x8000000000000800, 0x8.0000000000008p+60);
705	try test__floatuntitf(0x8000010000000000, 0x8.00001p+60);
706	try test__floatuntitf(0x8000000000001000, 0x8.000000000001p+60);
707
708	try test__floatuntitf(0x8000000000000000, 0x8p+60);
709	try test__floatuntitf(0x8000000000000001, 0x8.000000000000001p+60);
710
711	try test__floatuntitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
712
713	try test__floatuntitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
714	try test__floatuntitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
715	try test__floatuntitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
716	try test__floatuntitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
717	try test__floatuntitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
718
719	try test__floatuntitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
720	try test__floatuntitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
721	try test__floatuntitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
722	try test__floatuntitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
723	try test__floatuntitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
724
725	try test__floatuntitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
726	try test__floatuntitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);
727	try test__floatuntitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);
728	try test__floatuntitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);
729	try test__floatuntitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);
730	try test__floatuntitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);
731	try test__floatuntitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);
732	try test__floatuntitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);
733	try test__floatuntitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);
734	try test__floatuntitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);
735	try test__floatuntitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);
736	try test__floatuntitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);
737	try test__floatuntitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);
738	try test__floatuntitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);
739	try test__floatuntitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
740
741	try test__floatuntitf(make_uti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
742	try test__floatuntitf(make_uti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);
743	try test__floatuntitf(make_uti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);
744	try test__floatuntitf(make_uti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);
745	try test__floatuntitf(make_uti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);
746	try test__floatuntitf(make_uti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);
747	try test__floatuntitf(make_uti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);
748	try test__floatuntitf(make_uti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);
749	try test__floatuntitf(make_uti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);
750	try test__floatuntitf(make_uti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);
751	try test__floatuntitf(make_uti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);
752	try test__floatuntitf(make_uti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);
753	try test__floatuntitf(make_uti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);
754	try test__floatuntitf(make_uti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);
755	try test__floatuntitf(make_uti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
756
757	try test__floatuntitf(make_uti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);
758
759	try test__floatuntitf(make_uti(0xFFFFFFFFFFFFFFFF, 0x0000000000000000), 0x1.FFFFFFFFFFFFFFFEp+127);
760	try test__floatuntitf(make_uti(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x1.0000000000000000p+128);
761
762	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);
763	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);
764	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);
765	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);
766	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);
767	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);
768	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);
769	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);
770	try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);
771	}
772
773	fn make_ti(high: u64, low: u64) i128 {
774	var result: u128 = high;
775	result <<= 64;
776	result \|= low;
777	return @bitCast(i128, result);
778	}
779
780	fn make_uti(high: u64, low: u64) u128 {
781	var result: u128 = high;
782	result <<= 64;
783	result \|= low;
784	return result;
785	}
786
787	fn make_tf(high: u64, low: u64) f128 {
788	var result: u128 = high;
789	result <<= 64;
790	result \|= low;
791	return @bitCast(f128, result);
792	}
793
794	test "conversion to f16" {
795	try testing.expect(__floatunsihf(@as(u32, 0)) == 0.0);
796	try testing.expect(__floatunsihf(@as(u32, 1)) == 1.0);
797	try testing.expect(__floatunsihf(@as(u32, 65504)) == 65504);
798	try testing.expect(__floatunsihf(@as(u32, 65504 + (1 << 4))) == math.inf(f16));
799	}
800
801	test "conversion to f32" {
802	try testing.expect(__floatunsisf(@as(u32, 0)) == 0.0);
803	try testing.expect(__floatunsisf(@as(u32, math.maxInt(u32))) != 1.0);
804	try testing.expect(__floatsisf(@as(i32, math.minInt(i32))) != 1.0);
805	try testing.expect(__floatunsisf(@as(u32, math.maxInt(u24))) == math.maxInt(u24));
806	try testing.expect(__floatunsisf(@as(u32, math.maxInt(u24)) + 1) == math.maxInt(u24) + 1); // 0x100_0000 - Exact
807	try testing.expect(__floatunsisf(@as(u32, math.maxInt(u24)) + 2) == math.maxInt(u24) + 1); // 0x100_0001 - Tie: Rounds down to even
808	try testing.expect(__floatunsisf(@as(u32, math.maxInt(u24)) + 3) == math.maxInt(u24) + 3); // 0x100_0002 - Exact
809	try testing.expect(__floatunsisf(@as(u32, math.maxInt(u24)) + 4) == math.maxInt(u24) + 5); // 0x100_0003 - Tie: Rounds up to even
810	try testing.expect(__floatunsisf(@as(u32, math.maxInt(u24)) + 5) == math.maxInt(u24) + 5); // 0x100_0004 - Exact
811	}
812
813	test "conversion to f80" {
814	if (builtin.zig_backend == .stage1 and builtin.cpu.arch != .x86_64)
815	return error.SkipZigTest; // https://github.com/ziglang/zig/issues/11408
816
817	const intToFloat = @import("./int_to_float.zig").intToFloat;
818
819	try testing.expect(intToFloat(f80, @as(i80, -12)) == -12);
820	try testing.expect(@floatToInt(u80, intToFloat(f80, @as(u64, math.maxInt(u64)) + 0)) == math.maxInt(u64) + 0);
821	try testing.expect(@floatToInt(u80, intToFloat(f80, @as(u80, math.maxInt(u64)) + 1)) == math.maxInt(u64) + 1);
822
823	try testing.expect(intToFloat(f80, @as(u32, 0)) == 0.0);
824	try testing.expect(intToFloat(f80, @as(u32, 1)) == 1.0);
825	try testing.expect(@floatToInt(u128, intToFloat(f80, @as(u32, math.maxInt(u24)) + 0)) == math.maxInt(u24));
826	try testing.expect(@floatToInt(u128, intToFloat(f80, @as(u80, math.maxInt(u64)) + 0)) == math.maxInt(u64));
827	try testing.expect(@floatToInt(u128, intToFloat(f80, @as(u80, math.maxInt(u64)) + 1)) == math.maxInt(u64) + 1); // Exact
828	try testing.expect(@floatToInt(u128, intToFloat(f80, @as(u80, math.maxInt(u64)) + 2)) == math.maxInt(u64) + 1); // Rounds down
829	try testing.expect(@floatToInt(u128, intToFloat(f80, @as(u80, math.maxInt(u64)) + 3)) == math.maxInt(u64) + 3); // Tie - Exact
830	try testing.expect(@floatToInt(u128, intToFloat(f80, @as(u80, math.maxInt(u64)) + 4)) == math.maxInt(u64) + 5); // Rounds up
831
832	try testing.expect(@floatToInt(u128, intToFloat(f80, @as(u80, math.maxInt(u65)) + 0)) == math.maxInt(u65) + 1); // Rounds up
833	try testing.expect(@floatToInt(u128, intToFloat(f80, @as(u80, math.maxInt(u65)) + 1)) == math.maxInt(u65) + 1); // Exact
834	try testing.expect(@floatToInt(u128, intToFloat(f80, @as(u80, math.maxInt(u65)) + 2)) == math.maxInt(u65) + 1); // Rounds down
835	try testing.expect(@floatToInt(u128, intToFloat(f80, @as(u80, math.maxInt(u65)) + 3)) == math.maxInt(u65) + 1); // Tie - Rounds down
836	try testing.expect(@floatToInt(u128, intToFloat(f80, @as(u80, math.maxInt(u65)) + 4)) == math.maxInt(u65) + 5); // Rounds up
837	try testing.expect(@floatToInt(u128, intToFloat(f80, @as(u80, math.maxInt(u65)) + 5)) == math.maxInt(u65) + 5); // Exact
838	}

lib/compiler_rt/muldf3.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __muldf3(a: f64, b: f64) callconv(.C) f64 {	14	pub fn __muldf3(a: f64, b: f64) callconv(.C) f64 {
15	return mulf3(f64, a, b);	15	return mulf3(f64, a, b);
16	}	16	}
17		17

lib/compiler_rt/mulf3_test.zig+4-4

...	@@ -7,10 +7,10 @@ const math = std.math;	...	@@ -7,10 +7,10 @@ const math = std.math;
7	const qnan128 = @bitCast(f128, @as(u128, 0x7fff800000000000) << 64);	7	const qnan128 = @bitCast(f128, @as(u128, 0x7fff800000000000) << 64);
8	const inf128 = @bitCast(f128, @as(u128, 0x7fff000000000000) << 64);	8	const inf128 = @bitCast(f128, @as(u128, 0x7fff000000000000) << 64);
9		9
10	const __multf3 = @import("mulf3.zig").__multf3;	10	const __multf3 = @import("multf3.zig").__multf3;
11	const __mulxf3 = @import("mulf3.zig").__mulxf3;	11	const __mulxf3 = @import("mulxf3.zig").__mulxf3;
12	const __muldf3 = @import("mulf3.zig").__muldf3;	12	const __muldf3 = @import("muldf3.zig").__muldf3;
13	const __mulsf3 = @import("mulf3.zig").__mulsf3;	13	const __mulsf3 = @import("mulsf3.zig").__mulsf3;
14		14
15	// return true if equal	15	// return true if equal
16	// use two 64-bit integers intead of one 128-bit integer	16	// use two 64-bit integers intead of one 128-bit integer

lib/compiler_rt/mulsf3.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __mulsf3(a: f32, b: f32) callconv(.C) f32 {	14	pub fn __mulsf3(a: f32, b: f32) callconv(.C) f32 {
15	return mulf3(f32, a, b);	15	return mulf3(f32, a, b);
16	}	16	}
17		17

lib/compiler_rt/multf3.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __multf3(a: f128, b: f128) callconv(.C) f128 {	16	pub fn __multf3(a: f128, b: f128) callconv(.C) f128 {
17	return mulf3(f128, a, b);	17	return mulf3(f128, a, b);
18	}	18	}
19		19

lib/compiler_rt/subtf3.zig+1-1

...	@@ -12,7 +12,7 @@ comptime {	...	@@ -12,7 +12,7 @@ comptime {
12	}	12	}
13	}	13	}
14		14
15	fn __subtf3(a: f128, b: f128) callconv(.C) f128 {	15	pub fn __subtf3(a: f128, b: f128) callconv(.C) f128 {
16	return sub(a, b);	16	return sub(a, b);
17	}	17	}
18		18

lib/compiler_rt/truncdfhf2.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __truncdfhf2(a: f64) callconv(.C) common.F16T {	14	pub fn __truncdfhf2(a: f64) callconv(.C) common.F16T {
15	return @bitCast(common.F16T, truncf(f16, f64, a));	15	return @bitCast(common.F16T, truncf(f16, f64, a));
16	}	16	}
17		17

lib/compiler_rt/truncdfsf2.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __truncdfsf2(a: f64) callconv(.C) f32 {	14	pub fn __truncdfsf2(a: f64) callconv(.C) f32 {
15	return truncf(f32, f64, a);	15	return truncf(f32, f64, a);
16	}	16	}
17		17

lib/compiler_rt/truncf_test.zig+7-11

...	@@ -1,6 +1,12 @@	...	@@ -1,6 +1,12 @@
1	const std = @import("std");	1	const std = @import("std");
2	const testing = std.testing;	2	const testing = std.testing;
3	const __truncsfhf2 = @import("truncXfYf2.zig").__truncsfhf2;	3
		4	const __truncsfhf2 = @import("truncsfhf2.zig").__truncsfhf2;
		5	const __truncdfhf2 = @import("truncdfhf2.zig").__truncdfhf2;
		6	const __truncdfsf2 = @import("truncdfsf2.zig").__truncdfsf2;
		7	const __trunctfhf2 = @import("trunctfhf2.zig").__trunctfhf2;
		8	const __trunctfsf2 = @import("trunctfsf2.zig").__trunctfsf2;
		9	const __trunctfdf2 = @import("trunctfdf2.zig").__trunctfdf2;
4	const __trunctfxf2 = @import("trunctfxf2.zig").__trunctfxf2;	10	const __trunctfxf2 = @import("trunctfxf2.zig").__trunctfxf2;
5		11
6	fn test__truncsfhf2(a: u32, expected: u16) !void {	12	fn test__truncsfhf2(a: u32, expected: u16) !void {
...	@@ -66,8 +72,6 @@ test "truncsfhf2" {	...	@@ -66,8 +72,6 @@ test "truncsfhf2" {
66	try test__truncsfhf2(0x33000000, 0x0000); // 0x1.0p-25 -> zero	72	try test__truncsfhf2(0x33000000, 0x0000); // 0x1.0p-25 -> zero
67	}	73	}
68		74
69	const __truncdfhf2 = @import("truncXfYf2.zig").__truncdfhf2;
70
71	fn test__truncdfhf2(a: f64, expected: u16) void {	75	fn test__truncdfhf2(a: f64, expected: u16) void {
72	const rep = @bitCast(u16, __truncdfhf2(a));	76	const rep = @bitCast(u16, __truncdfhf2(a));
73		77
...	@@ -134,8 +138,6 @@ test "truncdfhf2" {	...	@@ -134,8 +138,6 @@ test "truncdfhf2" {
134	test__truncdfhf2(65536.0, 0x7c00);	138	test__truncdfhf2(65536.0, 0x7c00);
135	}	139	}
136		140
137	const __trunctfsf2 = @import("truncXfYf2.zig").__trunctfsf2;
138
139	fn test__trunctfsf2(a: f128, expected: u32) void {	141	fn test__trunctfsf2(a: f128, expected: u32) void {
140	const x = __trunctfsf2(a);	142	const x = __trunctfsf2(a);
141		143
...	@@ -169,8 +171,6 @@ test "trunctfsf2" {	...	@@ -169,8 +171,6 @@ test "trunctfsf2" {
169	test__trunctfsf2(0x1.edcba9bb8c76a5a43dd21f334634p-435, 0x0);	171	test__trunctfsf2(0x1.edcba9bb8c76a5a43dd21f334634p-435, 0x0);
170	}	172	}
171		173
172	const __trunctfdf2 = @import("truncXfYf2.zig").__trunctfdf2;
173
174	fn test__trunctfdf2(a: f128, expected: u64) void {	174	fn test__trunctfdf2(a: f128, expected: u64) void {
175	const x = __trunctfdf2(a);	175	const x = __trunctfdf2(a);
176		176
...	@@ -204,8 +204,6 @@ test "trunctfdf2" {	...	@@ -204,8 +204,6 @@ test "trunctfdf2" {
204	test__trunctfdf2(0x1.edcbff8ad76ab5bf46463233214fp-435, 0x24cedcbff8ad76ab);	204	test__trunctfdf2(0x1.edcbff8ad76ab5bf46463233214fp-435, 0x24cedcbff8ad76ab);
205	}	205	}
206		206
207	const __truncdfsf2 = @import("truncXfYf2.zig").__truncdfsf2;
208
209	fn test__truncdfsf2(a: f64, expected: u32) void {	207	fn test__truncdfsf2(a: f64, expected: u32) void {
210	const x = __truncdfsf2(a);	208	const x = __truncdfsf2(a);
211		209
...	@@ -241,8 +239,6 @@ test "truncdfsf2" {	...	@@ -241,8 +239,6 @@ test "truncdfsf2" {
241	test__truncdfsf2(340282366920938463463374607431768211456.0, 0x7f800000);	239	test__truncdfsf2(340282366920938463463374607431768211456.0, 0x7f800000);
242	}	240	}
243		241
244	const __trunctfhf2 = @import("truncXfYf2.zig").__trunctfhf2;
245
246	fn test__trunctfhf2(a: f128, expected: u16) void {	242	fn test__trunctfhf2(a: f128, expected: u16) void {
247	const x = __trunctfhf2(a);	243	const x = __trunctfhf2(a);
248		244

lib/compiler_rt/truncsfhf2.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __truncsfhf2(a: f32) callconv(.C) common.F16T {	16	pub fn __truncsfhf2(a: f32) callconv(.C) common.F16T {
17	return @bitCast(common.F16T, truncf(f16, f32, a));	17	return @bitCast(common.F16T, truncf(f16, f32, a));
18	}	18	}
19		19

lib/compiler_rt/trunctfdf2.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __trunctfdf2(a: f128) callconv(.C) f64 {	16	pub fn __trunctfdf2(a: f128) callconv(.C) f64 {
17	return truncf(f64, f128, a);	17	return truncf(f64, f128, a);
18	}	18	}
19		19

lib/compiler_rt/trunctfhf2.zig+1-1

...	@@ -7,6 +7,6 @@ comptime {	...	@@ -7,6 +7,6 @@ comptime {
7	@export(__trunctfhf2, .{ .name = "__trunctfhf2", .linkage = common.linkage });	7	@export(__trunctfhf2, .{ .name = "__trunctfhf2", .linkage = common.linkage });
8	}	8	}
9		9
10	fn __trunctfhf2(a: f128) callconv(.C) common.F16T {	10	pub fn __trunctfhf2(a: f128) callconv(.C) common.F16T {
11	return @bitCast(common.F16T, truncf(f16, f128, a));	11	return @bitCast(common.F16T, truncf(f16, f128, a));
12	}	12	}

lib/compiler_rt/trunctfsf2.zig+1-1

...	@@ -13,7 +13,7 @@ comptime {	...	@@ -13,7 +13,7 @@ comptime {
13	}	13	}
14	}	14	}
15		15
16	fn __trunctfsf2(a: f128) callconv(.C) f32 {	16	pub fn __trunctfsf2(a: f128) callconv(.C) f32 {
17	return truncf(f32, f128, a);	17	return truncf(f32, f128, a);
18	}	18	}
19		19

lib/compiler_rt/trunctfxf2.zig+1-1

...	@@ -8,7 +8,7 @@ comptime {	...	@@ -8,7 +8,7 @@ comptime {
8	@export(__trunctfxf2, .{ .name = "__trunctfxf2", .linkage = common.linkage });	8	@export(__trunctfxf2, .{ .name = "__trunctfxf2", .linkage = common.linkage });
9	}	9	}
10		10
11	fn __trunctfxf2(a: f128) callconv(.C) f80 {	11	pub fn __trunctfxf2(a: f128) callconv(.C) f80 {
12	const src_sig_bits = math.floatMantissaBits(f128);	12	const src_sig_bits = math.floatMantissaBits(f128);
13	const dst_sig_bits = math.floatMantissaBits(f80) - 1; // -1 for the integer bit	13	const dst_sig_bits = math.floatMantissaBits(f80) - 1; // -1 for the integer bit
14		14

lib/compiler_rt/unorddf2.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __unorddf2(a: f64, b: f64) callconv(.C) i32 {	14	pub fn __unorddf2(a: f64, b: f64) callconv(.C) i32 {
15	return comparef.unordcmp(f64, a, b);	15	return comparef.unordcmp(f64, a, b);
16	}	16	}
17		17

lib/compiler_rt/unordsf2.zig+1-1

...	@@ -11,7 +11,7 @@ comptime {	...	@@ -11,7 +11,7 @@ comptime {
11	}	11	}
12	}	12	}
13		13
14	fn __unordsf2(a: f32, b: f32) callconv(.C) i32 {	14	pub fn __unordsf2(a: f32, b: f32) callconv(.C) i32 {
15	return comparef.unordcmp(f32, a, b);	15	return comparef.unordcmp(f32, a, b);
16	}	16	}
17		17

...	@@ -31,27 +31,27 @@ fn __cmpdf2(a: f64, b: f64) callconv(.C) i32 {	...	@@ -31,27 +31,27 @@ fn __cmpdf2(a: f64, b: f64) callconv(.C) i32 {
31		31
32	/// "These functions return a value less than or equal to zero if neither argument is NaN,	32	/// "These functions return a value less than or equal to zero if neither argument is NaN,
33	/// and a is less than or equal to b."	33	/// and a is less than or equal to b."
34	fn __ledf2(a: f64, b: f64) callconv(.C) i32 {	34	pub fn __ledf2(a: f64, b: f64) callconv(.C) i32 {
35	return __cmpdf2(a, b);	35	return __cmpdf2(a, b);
36	}	36	}
37		37
38	/// "These functions return zero if neither argument is NaN, and a and b are equal."	38	/// "These functions return zero if neither argument is NaN, and a and b are equal."
39	/// Note that due to some kind of historical accident, __eqdf2 and __nedf2 are defined	39	/// Note that due to some kind of historical accident, __eqdf2 and __nedf2 are defined
40	/// to have the same return value.	40	/// to have the same return value.
41	fn __eqdf2(a: f64, b: f64) callconv(.C) i32 {	41	pub fn __eqdf2(a: f64, b: f64) callconv(.C) i32 {
42	return __cmpdf2(a, b);	42	return __cmpdf2(a, b);
43	}	43	}
44		44
45	/// "These functions return a nonzero value if either argument is NaN, or if a and b are unequal."	45	/// "These functions return a nonzero value if either argument is NaN, or if a and b are unequal."
46	/// Note that due to some kind of historical accident, __eqdf2 and __nedf2 are defined	46	/// Note that due to some kind of historical accident, __eqdf2 and __nedf2 are defined
47	/// to have the same return value.	47	/// to have the same return value.
48	fn __nedf2(a: f64, b: f64) callconv(.C) i32 {	48	pub fn __nedf2(a: f64, b: f64) callconv(.C) i32 {
49	return __cmpdf2(a, b);	49	return __cmpdf2(a, b);
50	}	50	}
51		51
52	/// "These functions return a value less than zero if neither argument is NaN, and a	52	/// "These functions return a value less than zero if neither argument is NaN, and a
53	/// is strictly less than b."	53	/// is strictly less than b."
54	fn __ltdf2(a: f64, b: f64) callconv(.C) i32 {	54	pub fn __ltdf2(a: f64, b: f64) callconv(.C) i32 {
55	return __cmpdf2(a, b);	55	return __cmpdf2(a, b);
56	}	56	}
57		57

...	@@ -31,27 +31,27 @@ fn __cmpsf2(a: f32, b: f32) callconv(.C) i32 {	...	@@ -31,27 +31,27 @@ fn __cmpsf2(a: f32, b: f32) callconv(.C) i32 {
31		31
32	/// "These functions return a value less than or equal to zero if neither argument is NaN,	32	/// "These functions return a value less than or equal to zero if neither argument is NaN,
33	/// and a is less than or equal to b."	33	/// and a is less than or equal to b."
34	fn __lesf2(a: f32, b: f32) callconv(.C) i32 {	34	pub fn __lesf2(a: f32, b: f32) callconv(.C) i32 {
35	return __cmpsf2(a, b);	35	return __cmpsf2(a, b);
36	}	36	}
37		37
38	/// "These functions return zero if neither argument is NaN, and a and b are equal."	38	/// "These functions return zero if neither argument is NaN, and a and b are equal."
39	/// Note that due to some kind of historical accident, __eqsf2 and __nesf2 are defined	39	/// Note that due to some kind of historical accident, __eqsf2 and __nesf2 are defined
40	/// to have the same return value.	40	/// to have the same return value.
41	fn __eqsf2(a: f32, b: f32) callconv(.C) i32 {	41	pub fn __eqsf2(a: f32, b: f32) callconv(.C) i32 {
42	return __cmpsf2(a, b);	42	return __cmpsf2(a, b);
43	}	43	}
44		44
45	/// "These functions return a nonzero value if either argument is NaN, or if a and b are unequal."	45	/// "These functions return a nonzero value if either argument is NaN, or if a and b are unequal."
46	/// Note that due to some kind of historical accident, __eqsf2 and __nesf2 are defined	46	/// Note that due to some kind of historical accident, __eqsf2 and __nesf2 are defined
47	/// to have the same return value.	47	/// to have the same return value.
48	fn __nesf2(a: f32, b: f32) callconv(.C) i32 {	48	pub fn __nesf2(a: f32, b: f32) callconv(.C) i32 {
49	return __cmpsf2(a, b);	49	return __cmpsf2(a, b);
50	}	50	}
51		51
52	/// "These functions return a value less than zero if neither argument is NaN, and a	52	/// "These functions return a value less than zero if neither argument is NaN, and a
53	/// is strictly less than b."	53	/// is strictly less than b."
54	fn __ltsf2(a: f32, b: f32) callconv(.C) i32 {	54	pub fn __ltsf2(a: f32, b: f32) callconv(.C) i32 {
55	return __cmpsf2(a, b);	55	return __cmpsf2(a, b);
56	}	56	}
57		57