Commit 7fe39c4e9680870f0bf30368c9f5b345b262b0eb | zig

author	Veikka Tuominen <git@vexu.eu> 2021-05-06 09:32:29+03:00
committer	Veikka Tuominen <git@vexu.eu> 2021-05-08 15:15:30+03:00
log	7fe39c4e9680870f0bf30368c9f5b345b262b0eb
tree	5349a75c27a0242f643764ec3bdbaf8ac77f2e77
parent	42a95197f32b46ee7b504282ab345209cb43c247

update usage of std.testing in compiler_rt

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

lib
- std
  - special
    c.zig
    compiler_rt
    addXf3_test.zig
    ashldi3_test.zig
    ashlti3_test.zig
    ashrdi3_test.zig
    ashrti3_test.zig
    clzsi2_test.zig
    divdf3_test.zig
    divsf3_test.zig
    divtf3_test.zig
    divti3_test.zig
    extendXfYf2_test.zig
    fixdfdi_test.zig
    fixdfsi_test.zig
    fixdfti_test.zig
    fixint_test.zig
    fixsfdi_test.zig
    fixsfsi_test.zig
    fixsfti_test.zig
    fixtfdi_test.zig
    fixtfsi_test.zig
    fixtfti_test.zig
    fixunsdfdi_test.zig
    fixunsdfsi_test.zig
    fixunsdfti_test.zig
    fixunssfdi_test.zig
    fixunssfsi_test.zig
    fixunssfti_test.zig
    fixunstfdi_test.zig
    fixunstfsi_test.zig
    fixunstfti_test.zig
    floatdidf_test.zig
    floatdisf_test.zig
    floatditf_test.zig
    floatsiXf.zig
    floattidf_test.zig
    floattisf_test.zig
    floattitf_test.zig
    floatundidf_test.zig
    floatundisf.zig
    floatunditf_test.zig
    floatunsidf.zig
    floatunsisf.zig
    floatunsitf_test.zig
    floatuntidf_test.zig
    floatuntisf_test.zig
    floatuntitf_test.zig
    int.zig
    lshrdi3_test.zig
    lshrti3_test.zig
    modti3_test.zig
    mulXf3_test.zig
    muldi3_test.zig
    mulodi4_test.zig
    muloti4_test.zig
    multi3_test.zig
    popcountdi2_test.zig
    truncXfYf2_test.zig
    udivmoddi4_test.zig
    udivmodti4_test.zig

lib/std/special/c.zig+20-20

...	...	@@ -66,7 +66,7 @@ test "strcpy" {
66	66
67	67	s1[0] = 0;
68	68	_ = strcpy(&s1, "foobarbaz");
69		std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));
	69	try std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));
70	70	}
71	71
72	72	fn strncpy(dest: [:0]u8, src: [:0]const u8, n: usize) callconv(.C) [*:0]u8 {
...	...	@@ -86,7 +86,7 @@ test "strncpy" {
86	86
87	87	s1[0] = 0;
88	88	_ = strncpy(&s1, "foobarbaz", @sizeOf(@TypeOf(s1)));
89		std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));
	89	try std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));
90	90	}
91	91
92	92	fn strcat(dest: [:0]u8, src: [:0]const u8) callconv(.C) [*:0]u8 {
...	...	@@ -109,7 +109,7 @@ test "strcat" {
109	109	_ = strcat(&s1, "foo");
110	110	_ = strcat(&s1, "bar");
111	111	_ = strcat(&s1, "baz");
112		std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));
	112	try std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));
113	113	}
114	114
115	115	fn strncat(dest: [:0]u8, src: [:0]const u8, avail: usize) callconv(.C) [*:0]u8 {
...	...	@@ -132,7 +132,7 @@ test "strncat" {
132	132	_ = strncat(&s1, "foo1111", 3);
133	133	_ = strncat(&s1, "bar1111", 3);
134	134	_ = strncat(&s1, "baz1111", 3);
135		std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));
	135	try std.testing.expectEqualSlices(u8, "foobarbaz", std.mem.spanZ(&s1));
136	136	}
137	137
138	138	fn strcmp(s1: [:0]const u8, s2: [:0]const u8) callconv(.C) c_int {
...	...	@@ -871,13 +871,13 @@ test "fmod, fmodf" {
871	871	try std.testing.expect(isNan(generic_fmod(T, 0.0, 0.0)));
872	872	try std.testing.expect(isNan(generic_fmod(T, 1.0, 0.0)));
873	873
874		std.testing.expectEqual(@as(T, 0.0), generic_fmod(T, 0.0, 2.0));
875		std.testing.expectEqual(@as(T, -0.0), generic_fmod(T, -0.0, 2.0));
	874	try std.testing.expectEqual(@as(T, 0.0), generic_fmod(T, 0.0, 2.0));
	875	try std.testing.expectEqual(@as(T, -0.0), generic_fmod(T, -0.0, 2.0));
876	876
877		std.testing.expectEqual(@as(T, -2.0), generic_fmod(T, -32.0, 10.0));
878		std.testing.expectEqual(@as(T, -2.0), generic_fmod(T, -32.0, -10.0));
879		std.testing.expectEqual(@as(T, 2.0), generic_fmod(T, 32.0, 10.0));
880		std.testing.expectEqual(@as(T, 2.0), generic_fmod(T, 32.0, -10.0));
	877	try std.testing.expectEqual(@as(T, -2.0), generic_fmod(T, -32.0, 10.0));
	878	try std.testing.expectEqual(@as(T, -2.0), generic_fmod(T, -32.0, -10.0));
	879	try std.testing.expectEqual(@as(T, 2.0), generic_fmod(T, 32.0, 10.0));
	880	try std.testing.expectEqual(@as(T, 2.0), generic_fmod(T, 32.0, -10.0));
881	881	}
882	882	}
883	883
...	...	@@ -902,11 +902,11 @@ test "fmin, fminf" {
902	902	const nan_val = math.nan(T);
903	903
904	904	try std.testing.expect(isNan(generic_fmin(T, nan_val, nan_val)));
905		std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, nan_val, 1.0));
906		std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, 1.0, nan_val));
	905	try std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, nan_val, 1.0));
	906	try std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, 1.0, nan_val));
907	907
908		std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, 1.0, 10.0));
909		std.testing.expectEqual(@as(T, -1.0), generic_fmin(T, 1.0, -1.0));
	908	try std.testing.expectEqual(@as(T, 1.0), generic_fmin(T, 1.0, 10.0));
	909	try std.testing.expectEqual(@as(T, -1.0), generic_fmin(T, 1.0, -1.0));
910	910	}
911	911	}
912	912
...	...	@@ -931,11 +931,11 @@ test "fmax, fmaxf" {
931	931	const nan_val = math.nan(T);
932	932
933	933	try std.testing.expect(isNan(generic_fmax(T, nan_val, nan_val)));
934		std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, nan_val, 1.0));
935		std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, 1.0, nan_val));
	934	try std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, nan_val, 1.0));
	935	try std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, 1.0, nan_val));
936	936
937		std.testing.expectEqual(@as(T, 10.0), generic_fmax(T, 1.0, 10.0));
938		std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, 1.0, -1.0));
	937	try std.testing.expectEqual(@as(T, 10.0), generic_fmax(T, 1.0, 10.0));
	938	try std.testing.expectEqual(@as(T, 1.0), generic_fmax(T, 1.0, -1.0));
939	939	}
940	940	}
941	941
...	...	@@ -1090,7 +1090,7 @@ test "sqrt" {
1090	1090	// Note that @sqrt will either generate the sqrt opcode (if supported by the
1091	1091	// target ISA) or a call to `sqrtf` otherwise.
1092	1092	for (V) \|val\|
1093		std.testing.expectEqual(@sqrt(val), sqrt(val));
	1093	try std.testing.expectEqual(@sqrt(val), sqrt(val));
1094	1094	}
1095	1095
1096	1096	test "sqrt special" {
...	...	@@ -1195,7 +1195,7 @@ test "sqrtf" {
1195	1195	// Note that @sqrt will either generate the sqrt opcode (if supported by the
1196	1196	// target ISA) or a call to `sqrtf` otherwise.
1197	1197	for (V) \|val\|
1198		std.testing.expectEqual(@sqrt(val), sqrtf(val));
	1198	try std.testing.expectEqual(@sqrt(val), sqrtf(val));
1199	1199	}
1200	1200
1201	1201	test "sqrtf special" {

lib/std/special/compiler_rt/addXf3_test.zig+13-13

...	...	@@ -13,7 +13,7 @@ const inf128 = @bitCast(f128, @as(u128, 0x7fff000000000000) << 64);
13	13
14	14	const __addtf3 = @import("addXf3.zig").__addtf3;
15	15
16		fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
	16	fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
17	17	const x = __addtf3(a, b);
18	18
19	19	const rep = @bitCast(u128, x);
...	...	@@ -32,28 +32,28 @@ fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
32	32	}
33	33	}
34	34
35		@panic("__addtf3 test failure");
	35	return error.TestFailed;
36	36	}
37	37
38	38	test "addtf3" {
39		test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
	39	try test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
40	40
41	41	// NaN + any = NaN
42		test__addtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) \| @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
	42	try test__addtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) \| @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
43	43
44	44	// inf + inf = inf
45		test__addtf3(inf128, inf128, 0x7fff000000000000, 0x0);
	45	try test__addtf3(inf128, inf128, 0x7fff000000000000, 0x0);
46	46
47	47	// inf + any = inf
48		test__addtf3(inf128, 0x1.2335653452436234723489432abcdefp+5, 0x7fff000000000000, 0x0);
	48	try test__addtf3(inf128, 0x1.2335653452436234723489432abcdefp+5, 0x7fff000000000000, 0x0);
49	49
50	50	// any + any
51		test__addtf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);
	51	try test__addtf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);
52	52	}
53	53
54	54	const __subtf3 = @import("addXf3.zig").__subtf3;
55	55
56		fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
	56	fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
57	57	const x = __subtf3(a, b);
58	58
59	59	const rep = @bitCast(u128, x);
...	...	@@ -72,19 +72,19 @@ fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
72	72	}
73	73	}
74	74
75		@panic("__subtf3 test failure");
	75	return error.TestFailed;
76	76	}
77	77
78	78	test "subtf3" {
79	79	// qNaN - any = qNaN
80		test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
	80	try test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
81	81
82	82	// NaN + any = NaN
83		test__subtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) \| @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
	83	try test__subtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) \| @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
84	84
85	85	// inf - any = inf
86		test__subtf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
	86	try test__subtf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
87	87
88	88	// any + any
89		test__subtf3(0x1.234567829a3bcdef5678ade36734p+5, 0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x40041b8af1915166, 0xa44a7bca780a166c);
	89	try test__subtf3(0x1.234567829a3bcdef5678ade36734p+5, 0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x40041b8af1915166, 0xa44a7bca780a166c);
90	90	}

lib/std/special/compiler_rt/ashldi3_test.zig+20-20

...	...	@@ -6,32 +6,32 @@
6	6	const __ashldi3 = @import("shift.zig").__ashldi3;
7	7	const testing = @import("std").testing;
8	8
9		fn test__ashldi3(a: i64, b: i32, expected: u64) void {
	9	fn test__ashldi3(a: i64, b: i32, expected: u64) !void {
10	10	const x = __ashldi3(a, b);
11		testing.expectEqual(@bitCast(i64, expected), x);
	11	try testing.expectEqual(@bitCast(i64, expected), x);
12	12	}
13	13
14	14	test "ashldi3" {
15		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF);
16		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x2468ACF13579BDE);
17		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37BC);
18		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x91A2B3C4D5E6F78);
19		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDEF0);
	15	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF);
	16	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x2468ACF13579BDE);
	17	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37BC);
	18	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x91A2B3C4D5E6F78);
	19	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDEF0);
20	20
21		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x789ABCDEF0000000);
22		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0xF13579BDE0000000);
23		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0xE26AF37BC0000000);
24		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0xC4D5E6F780000000);
	21	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x789ABCDEF0000000);
	22	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0xF13579BDE0000000);
	23	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0xE26AF37BC0000000);
	24	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0xC4D5E6F780000000);
25	25
26		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x89ABCDEF00000000);
	26	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x89ABCDEF00000000);
27	27
28		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x13579BDE00000000);
29		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x26AF37BC00000000);
30		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x4D5E6F7800000000);
31		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x9ABCDEF000000000);
	28	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x13579BDE00000000);
	29	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x26AF37BC00000000);
	30	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x4D5E6F7800000000);
	31	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x9ABCDEF000000000);
32	32
33		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0xF000000000000000);
34		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0xE000000000000000);
35		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0xC000000000000000);
36		test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0x8000000000000000);
	33	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0xF000000000000000);
	34	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0xE000000000000000);
	35	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0xC000000000000000);
	36	try test__ashldi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0x8000000000000000);
37	37	}

lib/std/special/compiler_rt/ashlti3_test.zig+38-38

...	...	@@ -6,46 +6,46 @@
6	6	const __ashlti3 = @import("shift.zig").__ashlti3;
7	7	const testing = @import("std").testing;
8	8
9		fn test__ashlti3(a: i128, b: i32, expected: i128) void {
	9	fn test__ashlti3(a: i128, b: i32, expected: i128) !void {
10	10	const x = __ashlti3(a, b);
11		testing.expectEqual(expected, x);
	11	try testing.expectEqual(expected, x);
12	12	}
13	13
14	14	test "ashlti3" {
15		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)));
16		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0xFDB97530ECA8642BFDB97530ECA8642A)));
17		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0xFB72EA61D950C857FB72EA61D950C854)));
18		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0xF6E5D4C3B2A190AFF6E5D4C3B2A190A8)));
19		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0xEDCBA9876543215FEDCBA98765432150)));
20		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0x876543215FEDCBA98765432150000000)));
21		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0x0ECA8642BFDB97530ECA8642A0000000)));
22		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0x1D950C857FB72EA61D950C8540000000)));
23		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0x3B2A190AFF6E5D4C3B2A190A80000000)));
24		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0x76543215FEDCBA987654321500000000)));
25		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0xECA8642BFDB97530ECA8642A00000000)));
26		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0xD950C857FB72EA61D950C85400000000)));
27		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0xB2A190AFF6E5D4C3B2A190A800000000)));
28		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0x6543215FEDCBA9876543215000000000)));
29		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0x5FEDCBA9876543215000000000000000)));
30		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0xBFDB97530ECA8642A000000000000000)));
31		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0x7FB72EA61D950C854000000000000000)));
32		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0xFF6E5D4C3B2A190A8000000000000000)));
33		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0xFEDCBA98765432150000000000000000)));
34		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0xFDB97530ECA8642A0000000000000000)));
35		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0xFB72EA61D950C8540000000000000000)));
36		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0xF6E5D4C3B2A190A80000000000000000)));
37		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0xEDCBA987654321500000000000000000)));
38		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0x87654321500000000000000000000000)));
39		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0x0ECA8642A00000000000000000000000)));
40		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0x1D950C85400000000000000000000000)));
41		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0x3B2A190A800000000000000000000000)));
42		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0x76543215000000000000000000000000)));
43		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0xECA8642A000000000000000000000000)));
44		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0xD950C854000000000000000000000000)));
45		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0xB2A190A8000000000000000000000000)));
46		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0x65432150000000000000000000000000)));
47		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0x50000000000000000000000000000000)));
48		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0xA0000000000000000000000000000000)));
49		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0x40000000000000000000000000000000)));
50		test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0x80000000000000000000000000000000)));
	15	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)));
	16	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0xFDB97530ECA8642BFDB97530ECA8642A)));
	17	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0xFB72EA61D950C857FB72EA61D950C854)));
	18	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0xF6E5D4C3B2A190AFF6E5D4C3B2A190A8)));
	19	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0xEDCBA9876543215FEDCBA98765432150)));
	20	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0x876543215FEDCBA98765432150000000)));
	21	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0x0ECA8642BFDB97530ECA8642A0000000)));
	22	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0x1D950C857FB72EA61D950C8540000000)));
	23	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0x3B2A190AFF6E5D4C3B2A190A80000000)));
	24	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0x76543215FEDCBA987654321500000000)));
	25	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0xECA8642BFDB97530ECA8642A00000000)));
	26	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0xD950C857FB72EA61D950C85400000000)));
	27	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0xB2A190AFF6E5D4C3B2A190A800000000)));
	28	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0x6543215FEDCBA9876543215000000000)));
	29	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0x5FEDCBA9876543215000000000000000)));
	30	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0xBFDB97530ECA8642A000000000000000)));
	31	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0x7FB72EA61D950C854000000000000000)));
	32	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0xFF6E5D4C3B2A190A8000000000000000)));
	33	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0xFEDCBA98765432150000000000000000)));
	34	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0xFDB97530ECA8642A0000000000000000)));
	35	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0xFB72EA61D950C8540000000000000000)));
	36	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0xF6E5D4C3B2A190A80000000000000000)));
	37	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0xEDCBA987654321500000000000000000)));
	38	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0x87654321500000000000000000000000)));
	39	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0x0ECA8642A00000000000000000000000)));
	40	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0x1D950C85400000000000000000000000)));
	41	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0x3B2A190A800000000000000000000000)));
	42	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0x76543215000000000000000000000000)));
	43	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0xECA8642A000000000000000000000000)));
	44	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0xD950C854000000000000000000000000)));
	45	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0xB2A190A8000000000000000000000000)));
	46	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0x65432150000000000000000000000000)));
	47	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0x50000000000000000000000000000000)));
	48	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0xA0000000000000000000000000000000)));
	49	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0x40000000000000000000000000000000)));
	50	try test__ashlti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0x80000000000000000000000000000000)));
51	51	}

lib/std/special/compiler_rt/ashrdi3_test.zig+47-47

...	...	@@ -6,55 +6,55 @@
6	6	const __ashrdi3 = @import("shift.zig").__ashrdi3;
7	7	const testing = @import("std").testing;
8	8
9		fn test__ashrdi3(a: i64, b: i32, expected: u64) void {
	9	fn test__ashrdi3(a: i64, b: i32, expected: u64) !void {
10	10	const x = __ashrdi3(a, b);
11		testing.expectEqual(@bitCast(i64, expected), x);
	11	try testing.expectEqual(@bitCast(i64, expected), x);
12	12	}
13	13
14	14	test "ashrdi3" {
15		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF);
16		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x91A2B3C4D5E6F7);
17		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37B);
18		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x2468ACF13579BD);
19		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDE);
20
21		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x12345678);
22		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0x91A2B3C);
23		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0x48D159E);
24		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0x2468ACF);
25
26		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x1234567);
27
28		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x91A2B3);
29		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x48D159);
30		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x2468AC);
31		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x123456);
32
33		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0);
34		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0);
35		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0);
36		test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0);
37
38		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 0, 0xFEDCBA9876543210);
39		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 1, 0xFF6E5D4C3B2A1908);
40		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 2, 0xFFB72EA61D950C84);
41		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 3, 0xFFDB97530ECA8642);
42		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 4, 0xFFEDCBA987654321);
43
44		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 28, 0xFFFFFFFFEDCBA987);
45		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 29, 0xFFFFFFFFF6E5D4C3);
46		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 30, 0xFFFFFFFFFB72EA61);
47		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 31, 0xFFFFFFFFFDB97530);
48
49		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 32, 0xFFFFFFFFFEDCBA98);
50
51		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 33, 0xFFFFFFFFFF6E5D4C);
52		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 34, 0xFFFFFFFFFFB72EA6);
53		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 35, 0xFFFFFFFFFFDB9753);
54		test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 36, 0xFFFFFFFFFFEDCBA9);
55
56		test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 60, 0xFFFFFFFFFFFFFFFA);
57		test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 61, 0xFFFFFFFFFFFFFFFD);
58		test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 62, 0xFFFFFFFFFFFFFFFE);
59		test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 63, 0xFFFFFFFFFFFFFFFF);
	15	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF);
	16	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x91A2B3C4D5E6F7);
	17	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37B);
	18	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x2468ACF13579BD);
	19	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDE);
	20
	21	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x12345678);
	22	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0x91A2B3C);
	23	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0x48D159E);
	24	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0x2468ACF);
	25
	26	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x1234567);
	27
	28	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x91A2B3);
	29	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x48D159);
	30	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x2468AC);
	31	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x123456);
	32
	33	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0);
	34	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0);
	35	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0);
	36	try test__ashrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0);
	37
	38	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 0, 0xFEDCBA9876543210);
	39	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 1, 0xFF6E5D4C3B2A1908);
	40	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 2, 0xFFB72EA61D950C84);
	41	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 3, 0xFFDB97530ECA8642);
	42	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 4, 0xFFEDCBA987654321);
	43
	44	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 28, 0xFFFFFFFFEDCBA987);
	45	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 29, 0xFFFFFFFFF6E5D4C3);
	46	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 30, 0xFFFFFFFFFB72EA61);
	47	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 31, 0xFFFFFFFFFDB97530);
	48
	49	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 32, 0xFFFFFFFFFEDCBA98);
	50
	51	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 33, 0xFFFFFFFFFF6E5D4C);
	52	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 34, 0xFFFFFFFFFFB72EA6);
	53	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 35, 0xFFFFFFFFFFDB9753);
	54	try test__ashrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 36, 0xFFFFFFFFFFEDCBA9);
	55
	56	try test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 60, 0xFFFFFFFFFFFFFFFA);
	57	try test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 61, 0xFFFFFFFFFFFFFFFD);
	58	try test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 62, 0xFFFFFFFFFFFFFFFE);
	59	try test__ashrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 63, 0xFFFFFFFFFFFFFFFF);
60	60	}

lib/std/special/compiler_rt/ashrti3_test.zig+48-48

...	...	@@ -6,56 +6,56 @@
6	6	const __ashrti3 = @import("shift.zig").__ashrti3;
7	7	const testing = @import("std").testing;
8	8
9		fn test__ashrti3(a: i128, b: i32, expected: i128) void {
	9	fn test__ashrti3(a: i128, b: i32, expected: i128) !void {
10	10	const x = __ashrti3(a, b);
11		testing.expectEqual(expected, x);
	11	try testing.expectEqual(expected, x);
12	12	}
13	13
14	14	test "ashrti3" {
15		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)));
16		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0xFF6E5D4C3B2A190AFF6E5D4C3B2A190A)));
17		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0xFFB72EA61D950C857FB72EA61D950C85)));
18		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0xFFDB97530ECA8642BFDB97530ECA8642)));
19		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0xFFEDCBA9876543215FEDCBA987654321)));
20
21		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0xFFFFFFFFEDCBA9876543215FEDCBA987)));
22		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0xFFFFFFFFF6E5D4C3B2A190AFF6E5D4C3)));
23		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFB72EA61D950C857FB72EA61)));
24		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFDB97530ECA8642BFDB97530)));
25
26		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFEDCBA9876543215FEDCBA98)));
27
28		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFF6E5D4C3B2A190AFF6E5D4C)));
29		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFB72EA61D950C857FB72EA6)));
30		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFDB97530ECA8642BFDB9753)));
31		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFEDCBA9876543215FEDCBA9)));
32
33		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFEDCBA9876543215F)));
34		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFF6E5D4C3B2A190AF)));
35		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFB72EA61D950C857)));
36		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFDB97530ECA8642B)));
37
38		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFEDCBA9876543215)));
39
40		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFF6E5D4C3B2A190A)));
41		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFB72EA61D950C85)));
42		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFDB97530ECA8642)));
43		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFEDCBA987654321)));
44
45		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFEDCBA987)));
46		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFF6E5D4C3)));
47		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFB72EA61)));
48		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFDB97530)));
49
50		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA98)));
51
52		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFF6E5D4C)));
53		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFB72EA6)));
54		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFDB9753)));
55		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA9)));
56
57		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));
58		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));
59		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));
60		test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));
	15	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)));
	16	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0xFF6E5D4C3B2A190AFF6E5D4C3B2A190A)));
	17	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0xFFB72EA61D950C857FB72EA61D950C85)));
	18	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0xFFDB97530ECA8642BFDB97530ECA8642)));
	19	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0xFFEDCBA9876543215FEDCBA987654321)));
	20
	21	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0xFFFFFFFFEDCBA9876543215FEDCBA987)));
	22	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0xFFFFFFFFF6E5D4C3B2A190AFF6E5D4C3)));
	23	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFB72EA61D950C857FB72EA61)));
	24	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFDB97530ECA8642BFDB97530)));
	25
	26	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFEDCBA9876543215FEDCBA98)));
	27
	28	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFF6E5D4C3B2A190AFF6E5D4C)));
	29	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFB72EA61D950C857FB72EA6)));
	30	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFDB97530ECA8642BFDB9753)));
	31	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFEDCBA9876543215FEDCBA9)));
	32
	33	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFEDCBA9876543215F)));
	34	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFF6E5D4C3B2A190AF)));
	35	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFB72EA61D950C857)));
	36	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFDB97530ECA8642B)));
	37
	38	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFEDCBA9876543215)));
	39
	40	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFF6E5D4C3B2A190A)));
	41	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFB72EA61D950C85)));
	42	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFDB97530ECA8642)));
	43	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFEDCBA987654321)));
	44
	45	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFEDCBA987)));
	46	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFF6E5D4C3)));
	47	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFB72EA61)));
	48	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFDB97530)));
	49
	50	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA98)));
	51
	52	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFF6E5D4C)));
	53	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFB72EA6)));
	54	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFDB9753)));
	55	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFEDCBA9)));
	56
	57	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));
	58	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));
	59	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));
	60	try test__ashrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)));
61	61	}

lib/std/special/compiler_rt/clzsi2_test.zig+281-281

...	...	@@ -6,294 +6,294 @@
6	6	const clzsi2 = @import("clzsi2.zig");
7	7	const testing = @import("std").testing;
8	8
9		fn test__clzsi2(a: u32, expected: i32) void {
	9	fn test__clzsi2(a: u32, expected: i32) !void {
10	10	// XXX At high optimization levels this test may be horribly miscompiled if
11	11	// one of the naked implementations is selected.
12	12	var nakedClzsi2 = clzsi2.__clzsi2;
13	13	var actualClzsi2 = @ptrCast(fn (a: i32) callconv(.C) i32, nakedClzsi2);
14	14	var x = @bitCast(i32, a);
15	15	var result = actualClzsi2(x);
16		testing.expectEqual(expected, result);
	16	try testing.expectEqual(expected, result);
17	17	}
18	18
19	19	test "clzsi2" {
20		test__clzsi2(0x00800000, 8);
21		test__clzsi2(0x01000000, 7);
22		test__clzsi2(0x02000000, 6);
23		test__clzsi2(0x03000000, 6);
24		test__clzsi2(0x04000000, 5);
25		test__clzsi2(0x05000000, 5);
26		test__clzsi2(0x06000000, 5);
27		test__clzsi2(0x07000000, 5);
28		test__clzsi2(0x08000000, 4);
29		test__clzsi2(0x09000000, 4);
30		test__clzsi2(0x0A000000, 4);
31		test__clzsi2(0x0B000000, 4);
32		test__clzsi2(0x0C000000, 4);
33		test__clzsi2(0x0D000000, 4);
34		test__clzsi2(0x0E000000, 4);
35		test__clzsi2(0x0F000000, 4);
36		test__clzsi2(0x10000000, 3);
37		test__clzsi2(0x11000000, 3);
38		test__clzsi2(0x12000000, 3);
39		test__clzsi2(0x13000000, 3);
40		test__clzsi2(0x14000000, 3);
41		test__clzsi2(0x15000000, 3);
42		test__clzsi2(0x16000000, 3);
43		test__clzsi2(0x17000000, 3);
44		test__clzsi2(0x18000000, 3);
45		test__clzsi2(0x19000000, 3);
46		test__clzsi2(0x1A000000, 3);
47		test__clzsi2(0x1B000000, 3);
48		test__clzsi2(0x1C000000, 3);
49		test__clzsi2(0x1D000000, 3);
50		test__clzsi2(0x1E000000, 3);
51		test__clzsi2(0x1F000000, 3);
52		test__clzsi2(0x20000000, 2);
53		test__clzsi2(0x21000000, 2);
54		test__clzsi2(0x22000000, 2);
55		test__clzsi2(0x23000000, 2);
56		test__clzsi2(0x24000000, 2);
57		test__clzsi2(0x25000000, 2);
58		test__clzsi2(0x26000000, 2);
59		test__clzsi2(0x27000000, 2);
60		test__clzsi2(0x28000000, 2);
61		test__clzsi2(0x29000000, 2);
62		test__clzsi2(0x2A000000, 2);
63		test__clzsi2(0x2B000000, 2);
64		test__clzsi2(0x2C000000, 2);
65		test__clzsi2(0x2D000000, 2);
66		test__clzsi2(0x2E000000, 2);
67		test__clzsi2(0x2F000000, 2);
68		test__clzsi2(0x30000000, 2);
69		test__clzsi2(0x31000000, 2);
70		test__clzsi2(0x32000000, 2);
71		test__clzsi2(0x33000000, 2);
72		test__clzsi2(0x34000000, 2);
73		test__clzsi2(0x35000000, 2);
74		test__clzsi2(0x36000000, 2);
75		test__clzsi2(0x37000000, 2);
76		test__clzsi2(0x38000000, 2);
77		test__clzsi2(0x39000000, 2);
78		test__clzsi2(0x3A000000, 2);
79		test__clzsi2(0x3B000000, 2);
80		test__clzsi2(0x3C000000, 2);
81		test__clzsi2(0x3D000000, 2);
82		test__clzsi2(0x3E000000, 2);
83		test__clzsi2(0x3F000000, 2);
84		test__clzsi2(0x40000000, 1);
85		test__clzsi2(0x41000000, 1);
86		test__clzsi2(0x42000000, 1);
87		test__clzsi2(0x43000000, 1);
88		test__clzsi2(0x44000000, 1);
89		test__clzsi2(0x45000000, 1);
90		test__clzsi2(0x46000000, 1);
91		test__clzsi2(0x47000000, 1);
92		test__clzsi2(0x48000000, 1);
93		test__clzsi2(0x49000000, 1);
94		test__clzsi2(0x4A000000, 1);
95		test__clzsi2(0x4B000000, 1);
96		test__clzsi2(0x4C000000, 1);
97		test__clzsi2(0x4D000000, 1);
98		test__clzsi2(0x4E000000, 1);
99		test__clzsi2(0x4F000000, 1);
100		test__clzsi2(0x50000000, 1);
101		test__clzsi2(0x51000000, 1);
102		test__clzsi2(0x52000000, 1);
103		test__clzsi2(0x53000000, 1);
104		test__clzsi2(0x54000000, 1);
105		test__clzsi2(0x55000000, 1);
106		test__clzsi2(0x56000000, 1);
107		test__clzsi2(0x57000000, 1);
108		test__clzsi2(0x58000000, 1);
109		test__clzsi2(0x59000000, 1);
110		test__clzsi2(0x5A000000, 1);
111		test__clzsi2(0x5B000000, 1);
112		test__clzsi2(0x5C000000, 1);
113		test__clzsi2(0x5D000000, 1);
114		test__clzsi2(0x5E000000, 1);
115		test__clzsi2(0x5F000000, 1);
116		test__clzsi2(0x60000000, 1);
117		test__clzsi2(0x61000000, 1);
118		test__clzsi2(0x62000000, 1);
119		test__clzsi2(0x63000000, 1);
120		test__clzsi2(0x64000000, 1);
121		test__clzsi2(0x65000000, 1);
122		test__clzsi2(0x66000000, 1);
123		test__clzsi2(0x67000000, 1);
124		test__clzsi2(0x68000000, 1);
125		test__clzsi2(0x69000000, 1);
126		test__clzsi2(0x6A000000, 1);
127		test__clzsi2(0x6B000000, 1);
128		test__clzsi2(0x6C000000, 1);
129		test__clzsi2(0x6D000000, 1);
130		test__clzsi2(0x6E000000, 1);
131		test__clzsi2(0x6F000000, 1);
132		test__clzsi2(0x70000000, 1);
133		test__clzsi2(0x71000000, 1);
134		test__clzsi2(0x72000000, 1);
135		test__clzsi2(0x73000000, 1);
136		test__clzsi2(0x74000000, 1);
137		test__clzsi2(0x75000000, 1);
138		test__clzsi2(0x76000000, 1);
139		test__clzsi2(0x77000000, 1);
140		test__clzsi2(0x78000000, 1);
141		test__clzsi2(0x79000000, 1);
142		test__clzsi2(0x7A000000, 1);
143		test__clzsi2(0x7B000000, 1);
144		test__clzsi2(0x7C000000, 1);
145		test__clzsi2(0x7D000000, 1);
146		test__clzsi2(0x7E000000, 1);
147		test__clzsi2(0x7F000000, 1);
148		test__clzsi2(0x80000000, 0);
149		test__clzsi2(0x81000000, 0);
150		test__clzsi2(0x82000000, 0);
151		test__clzsi2(0x83000000, 0);
152		test__clzsi2(0x84000000, 0);
153		test__clzsi2(0x85000000, 0);
154		test__clzsi2(0x86000000, 0);
155		test__clzsi2(0x87000000, 0);
156		test__clzsi2(0x88000000, 0);
157		test__clzsi2(0x89000000, 0);
158		test__clzsi2(0x8A000000, 0);
159		test__clzsi2(0x8B000000, 0);
160		test__clzsi2(0x8C000000, 0);
161		test__clzsi2(0x8D000000, 0);
162		test__clzsi2(0x8E000000, 0);
163		test__clzsi2(0x8F000000, 0);
164		test__clzsi2(0x90000000, 0);
165		test__clzsi2(0x91000000, 0);
166		test__clzsi2(0x92000000, 0);
167		test__clzsi2(0x93000000, 0);
168		test__clzsi2(0x94000000, 0);
169		test__clzsi2(0x95000000, 0);
170		test__clzsi2(0x96000000, 0);
171		test__clzsi2(0x97000000, 0);
172		test__clzsi2(0x98000000, 0);
173		test__clzsi2(0x99000000, 0);
174		test__clzsi2(0x9A000000, 0);
175		test__clzsi2(0x9B000000, 0);
176		test__clzsi2(0x9C000000, 0);
177		test__clzsi2(0x9D000000, 0);
178		test__clzsi2(0x9E000000, 0);
179		test__clzsi2(0x9F000000, 0);
180		test__clzsi2(0xA0000000, 0);
181		test__clzsi2(0xA1000000, 0);
182		test__clzsi2(0xA2000000, 0);
183		test__clzsi2(0xA3000000, 0);
184		test__clzsi2(0xA4000000, 0);
185		test__clzsi2(0xA5000000, 0);
186		test__clzsi2(0xA6000000, 0);
187		test__clzsi2(0xA7000000, 0);
188		test__clzsi2(0xA8000000, 0);
189		test__clzsi2(0xA9000000, 0);
190		test__clzsi2(0xAA000000, 0);
191		test__clzsi2(0xAB000000, 0);
192		test__clzsi2(0xAC000000, 0);
193		test__clzsi2(0xAD000000, 0);
194		test__clzsi2(0xAE000000, 0);
195		test__clzsi2(0xAF000000, 0);
196		test__clzsi2(0xB0000000, 0);
197		test__clzsi2(0xB1000000, 0);
198		test__clzsi2(0xB2000000, 0);
199		test__clzsi2(0xB3000000, 0);
200		test__clzsi2(0xB4000000, 0);
201		test__clzsi2(0xB5000000, 0);
202		test__clzsi2(0xB6000000, 0);
203		test__clzsi2(0xB7000000, 0);
204		test__clzsi2(0xB8000000, 0);
205		test__clzsi2(0xB9000000, 0);
206		test__clzsi2(0xBA000000, 0);
207		test__clzsi2(0xBB000000, 0);
208		test__clzsi2(0xBC000000, 0);
209		test__clzsi2(0xBD000000, 0);
210		test__clzsi2(0xBE000000, 0);
211		test__clzsi2(0xBF000000, 0);
212		test__clzsi2(0xC0000000, 0);
213		test__clzsi2(0xC1000000, 0);
214		test__clzsi2(0xC2000000, 0);
215		test__clzsi2(0xC3000000, 0);
216		test__clzsi2(0xC4000000, 0);
217		test__clzsi2(0xC5000000, 0);
218		test__clzsi2(0xC6000000, 0);
219		test__clzsi2(0xC7000000, 0);
220		test__clzsi2(0xC8000000, 0);
221		test__clzsi2(0xC9000000, 0);
222		test__clzsi2(0xCA000000, 0);
223		test__clzsi2(0xCB000000, 0);
224		test__clzsi2(0xCC000000, 0);
225		test__clzsi2(0xCD000000, 0);
226		test__clzsi2(0xCE000000, 0);
227		test__clzsi2(0xCF000000, 0);
228		test__clzsi2(0xD0000000, 0);
229		test__clzsi2(0xD1000000, 0);
230		test__clzsi2(0xD2000000, 0);
231		test__clzsi2(0xD3000000, 0);
232		test__clzsi2(0xD4000000, 0);
233		test__clzsi2(0xD5000000, 0);
234		test__clzsi2(0xD6000000, 0);
235		test__clzsi2(0xD7000000, 0);
236		test__clzsi2(0xD8000000, 0);
237		test__clzsi2(0xD9000000, 0);
238		test__clzsi2(0xDA000000, 0);
239		test__clzsi2(0xDB000000, 0);
240		test__clzsi2(0xDC000000, 0);
241		test__clzsi2(0xDD000000, 0);
242		test__clzsi2(0xDE000000, 0);
243		test__clzsi2(0xDF000000, 0);
244		test__clzsi2(0xE0000000, 0);
245		test__clzsi2(0xE1000000, 0);
246		test__clzsi2(0xE2000000, 0);
247		test__clzsi2(0xE3000000, 0);
248		test__clzsi2(0xE4000000, 0);
249		test__clzsi2(0xE5000000, 0);
250		test__clzsi2(0xE6000000, 0);
251		test__clzsi2(0xE7000000, 0);
252		test__clzsi2(0xE8000000, 0);
253		test__clzsi2(0xE9000000, 0);
254		test__clzsi2(0xEA000000, 0);
255		test__clzsi2(0xEB000000, 0);
256		test__clzsi2(0xEC000000, 0);
257		test__clzsi2(0xED000000, 0);
258		test__clzsi2(0xEE000000, 0);
259		test__clzsi2(0xEF000000, 0);
260		test__clzsi2(0xF0000000, 0);
261		test__clzsi2(0xF1000000, 0);
262		test__clzsi2(0xF2000000, 0);
263		test__clzsi2(0xF3000000, 0);
264		test__clzsi2(0xF4000000, 0);
265		test__clzsi2(0xF5000000, 0);
266		test__clzsi2(0xF6000000, 0);
267		test__clzsi2(0xF7000000, 0);
268		test__clzsi2(0xF8000000, 0);
269		test__clzsi2(0xF9000000, 0);
270		test__clzsi2(0xFA000000, 0);
271		test__clzsi2(0xFB000000, 0);
272		test__clzsi2(0xFC000000, 0);
273		test__clzsi2(0xFD000000, 0);
274		test__clzsi2(0xFE000000, 0);
275		test__clzsi2(0xFF000000, 0);
276		test__clzsi2(0x00000001, 31);
277		test__clzsi2(0x00000002, 30);
278		test__clzsi2(0x00000004, 29);
279		test__clzsi2(0x00000008, 28);
280		test__clzsi2(0x00000010, 27);
281		test__clzsi2(0x00000020, 26);
282		test__clzsi2(0x00000040, 25);
283		test__clzsi2(0x00000080, 24);
284		test__clzsi2(0x00000100, 23);
285		test__clzsi2(0x00000200, 22);
286		test__clzsi2(0x00000400, 21);
287		test__clzsi2(0x00000800, 20);
288		test__clzsi2(0x00001000, 19);
289		test__clzsi2(0x00002000, 18);
290		test__clzsi2(0x00004000, 17);
291		test__clzsi2(0x00008000, 16);
292		test__clzsi2(0x00010000, 15);
293		test__clzsi2(0x00020000, 14);
294		test__clzsi2(0x00040000, 13);
295		test__clzsi2(0x00080000, 12);
296		test__clzsi2(0x00100000, 11);
297		test__clzsi2(0x00200000, 10);
298		test__clzsi2(0x00400000, 9);
	20	try test__clzsi2(0x00800000, 8);
	21	try test__clzsi2(0x01000000, 7);
	22	try test__clzsi2(0x02000000, 6);
	23	try test__clzsi2(0x03000000, 6);
	24	try test__clzsi2(0x04000000, 5);
	25	try test__clzsi2(0x05000000, 5);
	26	try test__clzsi2(0x06000000, 5);
	27	try test__clzsi2(0x07000000, 5);
	28	try test__clzsi2(0x08000000, 4);
	29	try test__clzsi2(0x09000000, 4);
	30	try test__clzsi2(0x0A000000, 4);
	31	try test__clzsi2(0x0B000000, 4);
	32	try test__clzsi2(0x0C000000, 4);
	33	try test__clzsi2(0x0D000000, 4);
	34	try test__clzsi2(0x0E000000, 4);
	35	try test__clzsi2(0x0F000000, 4);
	36	try test__clzsi2(0x10000000, 3);
	37	try test__clzsi2(0x11000000, 3);
	38	try test__clzsi2(0x12000000, 3);
	39	try test__clzsi2(0x13000000, 3);
	40	try test__clzsi2(0x14000000, 3);
	41	try test__clzsi2(0x15000000, 3);
	42	try test__clzsi2(0x16000000, 3);
	43	try test__clzsi2(0x17000000, 3);
	44	try test__clzsi2(0x18000000, 3);
	45	try test__clzsi2(0x19000000, 3);
	46	try test__clzsi2(0x1A000000, 3);
	47	try test__clzsi2(0x1B000000, 3);
	48	try test__clzsi2(0x1C000000, 3);
	49	try test__clzsi2(0x1D000000, 3);
	50	try test__clzsi2(0x1E000000, 3);
	51	try test__clzsi2(0x1F000000, 3);
	52	try test__clzsi2(0x20000000, 2);
	53	try test__clzsi2(0x21000000, 2);
	54	try test__clzsi2(0x22000000, 2);
	55	try test__clzsi2(0x23000000, 2);
	56	try test__clzsi2(0x24000000, 2);
	57	try test__clzsi2(0x25000000, 2);
	58	try test__clzsi2(0x26000000, 2);
	59	try test__clzsi2(0x27000000, 2);
	60	try test__clzsi2(0x28000000, 2);
	61	try test__clzsi2(0x29000000, 2);
	62	try test__clzsi2(0x2A000000, 2);
	63	try test__clzsi2(0x2B000000, 2);
	64	try test__clzsi2(0x2C000000, 2);
	65	try test__clzsi2(0x2D000000, 2);
	66	try test__clzsi2(0x2E000000, 2);
	67	try test__clzsi2(0x2F000000, 2);
	68	try test__clzsi2(0x30000000, 2);
	69	try test__clzsi2(0x31000000, 2);
	70	try test__clzsi2(0x32000000, 2);
	71	try test__clzsi2(0x33000000, 2);
	72	try test__clzsi2(0x34000000, 2);
	73	try test__clzsi2(0x35000000, 2);
	74	try test__clzsi2(0x36000000, 2);
	75	try test__clzsi2(0x37000000, 2);
	76	try test__clzsi2(0x38000000, 2);
	77	try test__clzsi2(0x39000000, 2);
	78	try test__clzsi2(0x3A000000, 2);
	79	try test__clzsi2(0x3B000000, 2);
	80	try test__clzsi2(0x3C000000, 2);
	81	try test__clzsi2(0x3D000000, 2);
	82	try test__clzsi2(0x3E000000, 2);
	83	try test__clzsi2(0x3F000000, 2);
	84	try test__clzsi2(0x40000000, 1);
	85	try test__clzsi2(0x41000000, 1);
	86	try test__clzsi2(0x42000000, 1);
	87	try test__clzsi2(0x43000000, 1);
	88	try test__clzsi2(0x44000000, 1);
	89	try test__clzsi2(0x45000000, 1);
	90	try test__clzsi2(0x46000000, 1);
	91	try test__clzsi2(0x47000000, 1);
	92	try test__clzsi2(0x48000000, 1);
	93	try test__clzsi2(0x49000000, 1);
	94	try test__clzsi2(0x4A000000, 1);
	95	try test__clzsi2(0x4B000000, 1);
	96	try test__clzsi2(0x4C000000, 1);
	97	try test__clzsi2(0x4D000000, 1);
	98	try test__clzsi2(0x4E000000, 1);
	99	try test__clzsi2(0x4F000000, 1);
	100	try test__clzsi2(0x50000000, 1);
	101	try test__clzsi2(0x51000000, 1);
	102	try test__clzsi2(0x52000000, 1);
	103	try test__clzsi2(0x53000000, 1);
	104	try test__clzsi2(0x54000000, 1);
	105	try test__clzsi2(0x55000000, 1);
	106	try test__clzsi2(0x56000000, 1);
	107	try test__clzsi2(0x57000000, 1);
	108	try test__clzsi2(0x58000000, 1);
	109	try test__clzsi2(0x59000000, 1);
	110	try test__clzsi2(0x5A000000, 1);
	111	try test__clzsi2(0x5B000000, 1);
	112	try test__clzsi2(0x5C000000, 1);
	113	try test__clzsi2(0x5D000000, 1);
	114	try test__clzsi2(0x5E000000, 1);
	115	try test__clzsi2(0x5F000000, 1);
	116	try test__clzsi2(0x60000000, 1);
	117	try test__clzsi2(0x61000000, 1);
	118	try test__clzsi2(0x62000000, 1);
	119	try test__clzsi2(0x63000000, 1);
	120	try test__clzsi2(0x64000000, 1);
	121	try test__clzsi2(0x65000000, 1);
	122	try test__clzsi2(0x66000000, 1);
	123	try test__clzsi2(0x67000000, 1);
	124	try test__clzsi2(0x68000000, 1);
	125	try test__clzsi2(0x69000000, 1);
	126	try test__clzsi2(0x6A000000, 1);
	127	try test__clzsi2(0x6B000000, 1);
	128	try test__clzsi2(0x6C000000, 1);
	129	try test__clzsi2(0x6D000000, 1);
	130	try test__clzsi2(0x6E000000, 1);
	131	try test__clzsi2(0x6F000000, 1);
	132	try test__clzsi2(0x70000000, 1);
	133	try test__clzsi2(0x71000000, 1);
	134	try test__clzsi2(0x72000000, 1);
	135	try test__clzsi2(0x73000000, 1);
	136	try test__clzsi2(0x74000000, 1);
	137	try test__clzsi2(0x75000000, 1);
	138	try test__clzsi2(0x76000000, 1);
	139	try test__clzsi2(0x77000000, 1);
	140	try test__clzsi2(0x78000000, 1);
	141	try test__clzsi2(0x79000000, 1);
	142	try test__clzsi2(0x7A000000, 1);
	143	try test__clzsi2(0x7B000000, 1);
	144	try test__clzsi2(0x7C000000, 1);
	145	try test__clzsi2(0x7D000000, 1);
	146	try test__clzsi2(0x7E000000, 1);
	147	try test__clzsi2(0x7F000000, 1);
	148	try test__clzsi2(0x80000000, 0);
	149	try test__clzsi2(0x81000000, 0);
	150	try test__clzsi2(0x82000000, 0);
	151	try test__clzsi2(0x83000000, 0);
	152	try test__clzsi2(0x84000000, 0);
	153	try test__clzsi2(0x85000000, 0);
	154	try test__clzsi2(0x86000000, 0);
	155	try test__clzsi2(0x87000000, 0);
	156	try test__clzsi2(0x88000000, 0);
	157	try test__clzsi2(0x89000000, 0);
	158	try test__clzsi2(0x8A000000, 0);
	159	try test__clzsi2(0x8B000000, 0);
	160	try test__clzsi2(0x8C000000, 0);
	161	try test__clzsi2(0x8D000000, 0);
	162	try test__clzsi2(0x8E000000, 0);
	163	try test__clzsi2(0x8F000000, 0);
	164	try test__clzsi2(0x90000000, 0);
	165	try test__clzsi2(0x91000000, 0);
	166	try test__clzsi2(0x92000000, 0);
	167	try test__clzsi2(0x93000000, 0);
	168	try test__clzsi2(0x94000000, 0);
	169	try test__clzsi2(0x95000000, 0);
	170	try test__clzsi2(0x96000000, 0);
	171	try test__clzsi2(0x97000000, 0);
	172	try test__clzsi2(0x98000000, 0);
	173	try test__clzsi2(0x99000000, 0);
	174	try test__clzsi2(0x9A000000, 0);
	175	try test__clzsi2(0x9B000000, 0);
	176	try test__clzsi2(0x9C000000, 0);
	177	try test__clzsi2(0x9D000000, 0);
	178	try test__clzsi2(0x9E000000, 0);
	179	try test__clzsi2(0x9F000000, 0);
	180	try test__clzsi2(0xA0000000, 0);
	181	try test__clzsi2(0xA1000000, 0);
	182	try test__clzsi2(0xA2000000, 0);
	183	try test__clzsi2(0xA3000000, 0);
	184	try test__clzsi2(0xA4000000, 0);
	185	try test__clzsi2(0xA5000000, 0);
	186	try test__clzsi2(0xA6000000, 0);
	187	try test__clzsi2(0xA7000000, 0);
	188	try test__clzsi2(0xA8000000, 0);
	189	try test__clzsi2(0xA9000000, 0);
	190	try test__clzsi2(0xAA000000, 0);
	191	try test__clzsi2(0xAB000000, 0);
	192	try test__clzsi2(0xAC000000, 0);
	193	try test__clzsi2(0xAD000000, 0);
	194	try test__clzsi2(0xAE000000, 0);
	195	try test__clzsi2(0xAF000000, 0);
	196	try test__clzsi2(0xB0000000, 0);
	197	try test__clzsi2(0xB1000000, 0);
	198	try test__clzsi2(0xB2000000, 0);
	199	try test__clzsi2(0xB3000000, 0);
	200	try test__clzsi2(0xB4000000, 0);
	201	try test__clzsi2(0xB5000000, 0);
	202	try test__clzsi2(0xB6000000, 0);
	203	try test__clzsi2(0xB7000000, 0);
	204	try test__clzsi2(0xB8000000, 0);
	205	try test__clzsi2(0xB9000000, 0);
	206	try test__clzsi2(0xBA000000, 0);
	207	try test__clzsi2(0xBB000000, 0);
	208	try test__clzsi2(0xBC000000, 0);
	209	try test__clzsi2(0xBD000000, 0);
	210	try test__clzsi2(0xBE000000, 0);
	211	try test__clzsi2(0xBF000000, 0);
	212	try test__clzsi2(0xC0000000, 0);
	213	try test__clzsi2(0xC1000000, 0);
	214	try test__clzsi2(0xC2000000, 0);
	215	try test__clzsi2(0xC3000000, 0);
	216	try test__clzsi2(0xC4000000, 0);
	217	try test__clzsi2(0xC5000000, 0);
	218	try test__clzsi2(0xC6000000, 0);
	219	try test__clzsi2(0xC7000000, 0);
	220	try test__clzsi2(0xC8000000, 0);
	221	try test__clzsi2(0xC9000000, 0);
	222	try test__clzsi2(0xCA000000, 0);
	223	try test__clzsi2(0xCB000000, 0);
	224	try test__clzsi2(0xCC000000, 0);
	225	try test__clzsi2(0xCD000000, 0);
	226	try test__clzsi2(0xCE000000, 0);
	227	try test__clzsi2(0xCF000000, 0);
	228	try test__clzsi2(0xD0000000, 0);
	229	try test__clzsi2(0xD1000000, 0);
	230	try test__clzsi2(0xD2000000, 0);
	231	try test__clzsi2(0xD3000000, 0);
	232	try test__clzsi2(0xD4000000, 0);
	233	try test__clzsi2(0xD5000000, 0);
	234	try test__clzsi2(0xD6000000, 0);
	235	try test__clzsi2(0xD7000000, 0);
	236	try test__clzsi2(0xD8000000, 0);
	237	try test__clzsi2(0xD9000000, 0);
	238	try test__clzsi2(0xDA000000, 0);
	239	try test__clzsi2(0xDB000000, 0);
	240	try test__clzsi2(0xDC000000, 0);
	241	try test__clzsi2(0xDD000000, 0);
	242	try test__clzsi2(0xDE000000, 0);
	243	try test__clzsi2(0xDF000000, 0);
	244	try test__clzsi2(0xE0000000, 0);
	245	try test__clzsi2(0xE1000000, 0);
	246	try test__clzsi2(0xE2000000, 0);
	247	try test__clzsi2(0xE3000000, 0);
	248	try test__clzsi2(0xE4000000, 0);
	249	try test__clzsi2(0xE5000000, 0);
	250	try test__clzsi2(0xE6000000, 0);
	251	try test__clzsi2(0xE7000000, 0);
	252	try test__clzsi2(0xE8000000, 0);
	253	try test__clzsi2(0xE9000000, 0);
	254	try test__clzsi2(0xEA000000, 0);
	255	try test__clzsi2(0xEB000000, 0);
	256	try test__clzsi2(0xEC000000, 0);
	257	try test__clzsi2(0xED000000, 0);
	258	try test__clzsi2(0xEE000000, 0);
	259	try test__clzsi2(0xEF000000, 0);
	260	try test__clzsi2(0xF0000000, 0);
	261	try test__clzsi2(0xF1000000, 0);
	262	try test__clzsi2(0xF2000000, 0);
	263	try test__clzsi2(0xF3000000, 0);
	264	try test__clzsi2(0xF4000000, 0);
	265	try test__clzsi2(0xF5000000, 0);
	266	try test__clzsi2(0xF6000000, 0);
	267	try test__clzsi2(0xF7000000, 0);
	268	try test__clzsi2(0xF8000000, 0);
	269	try test__clzsi2(0xF9000000, 0);
	270	try test__clzsi2(0xFA000000, 0);
	271	try test__clzsi2(0xFB000000, 0);
	272	try test__clzsi2(0xFC000000, 0);
	273	try test__clzsi2(0xFD000000, 0);
	274	try test__clzsi2(0xFE000000, 0);
	275	try test__clzsi2(0xFF000000, 0);
	276	try test__clzsi2(0x00000001, 31);
	277	try test__clzsi2(0x00000002, 30);
	278	try test__clzsi2(0x00000004, 29);
	279	try test__clzsi2(0x00000008, 28);
	280	try test__clzsi2(0x00000010, 27);
	281	try test__clzsi2(0x00000020, 26);
	282	try test__clzsi2(0x00000040, 25);
	283	try test__clzsi2(0x00000080, 24);
	284	try test__clzsi2(0x00000100, 23);
	285	try test__clzsi2(0x00000200, 22);
	286	try test__clzsi2(0x00000400, 21);
	287	try test__clzsi2(0x00000800, 20);
	288	try test__clzsi2(0x00001000, 19);
	289	try test__clzsi2(0x00002000, 18);
	290	try test__clzsi2(0x00004000, 17);
	291	try test__clzsi2(0x00008000, 16);
	292	try test__clzsi2(0x00010000, 15);
	293	try test__clzsi2(0x00020000, 14);
	294	try test__clzsi2(0x00040000, 13);
	295	try test__clzsi2(0x00080000, 12);
	296	try test__clzsi2(0x00100000, 11);
	297	try test__clzsi2(0x00200000, 10);
	298	try test__clzsi2(0x00400000, 9);
299	299	}

lib/std/special/compiler_rt/divdf3_test.zig+3-3

...	...	@@ -27,13 +27,13 @@ fn compareResultD(result: f64, expected: u64) bool {
27	27	return false;
28	28	}
29	29
30		fn test__divdf3(a: f64, b: f64, expected: u64) void {
	30	fn test__divdf3(a: f64, b: f64, expected: u64) !void {
31	31	const x = __divdf3(a, b);
32	32	const ret = compareResultD(x, expected);
33	33	try testing.expect(ret == true);
34	34	}
35	35
36	36	test "divdf3" {
37		test__divdf3(1.0, 3.0, 0x3fd5555555555555);
38		test__divdf3(4.450147717014403e-308, 2.0, 0x10000000000000);
	37	try test__divdf3(1.0, 3.0, 0x3fd5555555555555);
	38	try test__divdf3(4.450147717014403e-308, 2.0, 0x10000000000000);
39	39	}

lib/std/special/compiler_rt/divsf3_test.zig+3-3

...	...	@@ -27,13 +27,13 @@ fn compareResultF(result: f32, expected: u32) bool {
27	27	return false;
28	28	}
29	29
30		fn test__divsf3(a: f32, b: f32, expected: u32) void {
	30	fn test__divsf3(a: f32, b: f32, expected: u32) !void {
31	31	const x = __divsf3(a, b);
32	32	const ret = compareResultF(x, expected);
33	33	try testing.expect(ret == true);
34	34	}
35	35
36	36	test "divsf3" {
37		test__divsf3(1.0, 3.0, 0x3EAAAAAB);
38		test__divsf3(2.3509887e-38, 2.0, 0x00800000);
	37	try test__divsf3(1.0, 3.0, 0x3EAAAAAB);
	38	try test__divsf3(2.3509887e-38, 2.0, 0x00800000);
39	39	}

lib/std/special/compiler_rt/divtf3_test.zig+10-10

...	...	@@ -28,7 +28,7 @@ fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool {
28	28	return false;
29	29	}
30	30
31		fn test__divtf3(a: f128, b: f128, expectedHi: u64, expectedLo: u64) void {
	31	fn test__divtf3(a: f128, b: f128, expectedHi: u64, expectedLo: u64) !void {
32	32	const x = __divtf3(a, b);
33	33	const ret = compareResultLD(x, expectedHi, expectedLo);
34	34	try testing.expect(ret == true);
...	...	@@ -36,16 +36,16 @@ fn test__divtf3(a: f128, b: f128, expectedHi: u64, expectedLo: u64) void {
36	36
37	37	test "divtf3" {
38	38	// qNaN / any = qNaN
39		test__divtf3(math.qnan_f128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0);
	39	try test__divtf3(math.qnan_f128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0);
40	40	// NaN / any = NaN
41		test__divtf3(math.nan_f128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0);
	41	try test__divtf3(math.nan_f128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0);
42	42	// inf / any = inf
43		test__divtf3(math.inf_f128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0);
	43	try test__divtf3(math.inf_f128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0);
44	44
45		test__divtf3(0x1.a23b45362464523375893ab4cdefp+5, 0x1.eedcbaba3a94546558237654321fp-1, 0x4004b0b72924d407, 0x0717e84356c6eba2);
46		test__divtf3(0x1.a2b34c56d745382f9abf2c3dfeffp-50, 0x1.ed2c3ba15935332532287654321fp-9, 0x3fd5b2af3f828c9b, 0x40e51f64cde8b1f2);
47		test__divtf3(0x1.2345f6aaaa786555f42432abcdefp+456, 0x1.edacbba9874f765463544dd3621fp+6400, 0x28c62e15dc464466, 0xb5a07586348557ac);
48		test__divtf3(0x1.2d3456f789ba6322bc665544edefp-234, 0x1.eddcdba39f3c8b7a36564354321fp-4455, 0x507b38442b539266, 0x22ce0f1d024e1252);
49		test__divtf3(0x1.2345f6b77b7a8953365433abcdefp+234, 0x1.edcba987d6bb3aa467754354321fp-4055, 0x50bf2e02f0798d36, 0x5e6fcb6b60044078);
50		test__divtf3(6.72420628622418701252535563464350521E-4932, 2.0, 0x0001000000000000, 0);
	45	try test__divtf3(0x1.a23b45362464523375893ab4cdefp+5, 0x1.eedcbaba3a94546558237654321fp-1, 0x4004b0b72924d407, 0x0717e84356c6eba2);
	46	try test__divtf3(0x1.a2b34c56d745382f9abf2c3dfeffp-50, 0x1.ed2c3ba15935332532287654321fp-9, 0x3fd5b2af3f828c9b, 0x40e51f64cde8b1f2);
	47	try test__divtf3(0x1.2345f6aaaa786555f42432abcdefp+456, 0x1.edacbba9874f765463544dd3621fp+6400, 0x28c62e15dc464466, 0xb5a07586348557ac);
	48	try test__divtf3(0x1.2d3456f789ba6322bc665544edefp-234, 0x1.eddcdba39f3c8b7a36564354321fp-4455, 0x507b38442b539266, 0x22ce0f1d024e1252);
	49	try test__divtf3(0x1.2345f6b77b7a8953365433abcdefp+234, 0x1.edcba987d6bb3aa467754354321fp-4055, 0x50bf2e02f0798d36, 0x5e6fcb6b60044078);
	50	try test__divtf3(6.72420628622418701252535563464350521E-4932, 2.0, 0x0001000000000000, 0);
51	51	}

lib/std/special/compiler_rt/divti3_test.zig+11-11

...	...	@@ -6,21 +6,21 @@
6	6	const __divti3 = @import("divti3.zig").__divti3;
7	7	const testing = @import("std").testing;
8	8
9		fn test__divti3(a: i128, b: i128, expected: i128) void {
	9	fn test__divti3(a: i128, b: i128, expected: i128) !void {
10	10	const x = __divti3(a, b);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "divti3" {
15		test__divti3(0, 1, 0);
16		test__divti3(0, -1, 0);
17		test__divti3(2, 1, 2);
18		test__divti3(2, -1, -2);
19		test__divti3(-2, 1, -2);
20		test__divti3(-2, -1, 2);
	15	try test__divti3(0, 1, 0);
	16	try test__divti3(0, -1, 0);
	17	try test__divti3(2, 1, 2);
	18	try test__divti3(2, -1, -2);
	19	try test__divti3(-2, 1, -2);
	20	try test__divti3(-2, -1, 2);
21	21
22		test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 1, @bitCast(i128, @as(u128, 0x8 << 124)));
23		test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -1, @bitCast(i128, @as(u128, 0x8 << 124)));
24		test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -2, @bitCast(i128, @as(u128, 0x4 << 124)));
25		test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 2, @bitCast(i128, @as(u128, 0xc << 124)));
	22	try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 1, @bitCast(i128, @as(u128, 0x8 << 124)));
	23	try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -1, @bitCast(i128, @as(u128, 0x8 << 124)));
	24	try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -2, @bitCast(i128, @as(u128, 0x4 << 124)));
	25	try test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 2, @bitCast(i128, @as(u128, 0xc << 124)));
26	26	}

lib/std/special/compiler_rt/extendXfYf2_test.zig+55-55

...	...	@@ -9,7 +9,7 @@ const __extendhftf2 = @import("extendXfYf2.zig").__extendhftf2;
9	9	const __extendsftf2 = @import("extendXfYf2.zig").__extendsftf2;
10	10	const __extenddftf2 = @import("extendXfYf2.zig").__extenddftf2;
11	11
12		fn test__extenddftf2(a: f64, expectedHi: u64, expectedLo: u64) void {
	12	fn test__extenddftf2(a: f64, expectedHi: u64, expectedLo: u64) !void {
13	13	const x = __extenddftf2(a);
14	14
15	15	const rep = @bitCast(u128, x);
...	...	@@ -31,7 +31,7 @@ fn test__extenddftf2(a: f64, expectedHi: u64, expectedLo: u64) void {
31	31	@panic("__extenddftf2 test failure");
32	32	}
33	33
34		fn test__extendhfsf2(a: u16, expected: u32) void {
	34	fn test__extendhfsf2(a: u16, expected: u32) !void {
35	35	const x = __extendhfsf2(a);
36	36	const rep = @bitCast(u32, x);
37	37
...	...	@@ -44,10 +44,10 @@ fn test__extendhfsf2(a: u16, expected: u32) void {
44	44	}
45	45	}
46	46
47		@panic("__extendhfsf2 test failure");
	47	return error.TestFailure;
48	48	}
49	49
50		fn test__extendsftf2(a: f32, expectedHi: u64, expectedLo: u64) void {
	50	fn test__extendsftf2(a: f32, expectedHi: u64, expectedLo: u64) !void {
51	51	const x = __extendsftf2(a);
52	52
53	53	const rep = @bitCast(u128, x);
...	...	@@ -66,77 +66,77 @@ fn test__extendsftf2(a: f32, expectedHi: u64, expectedLo: u64) void {
66	66	}
67	67	}
68	68
69		@panic("__extendsftf2 test failure");
	69	return error.TestFailure;
70	70	}
71	71
72	72	test "extenddftf2" {
73	73	// qNaN
74		test__extenddftf2(makeQNaN64(), 0x7fff800000000000, 0x0);
	74	try test__extenddftf2(makeQNaN64(), 0x7fff800000000000, 0x0);
75	75
76	76	// NaN
77		test__extenddftf2(makeNaN64(0x7100000000000), 0x7fff710000000000, 0x0);
	77	try test__extenddftf2(makeNaN64(0x7100000000000), 0x7fff710000000000, 0x0);
78	78
79	79	// inf
80		test__extenddftf2(makeInf64(), 0x7fff000000000000, 0x0);
	80	try test__extenddftf2(makeInf64(), 0x7fff000000000000, 0x0);
81	81
82	82	// zero
83		test__extenddftf2(0.0, 0x0, 0x0);
	83	try test__extenddftf2(0.0, 0x0, 0x0);
84	84
85		test__extenddftf2(0x1.23456789abcdefp+5, 0x400423456789abcd, 0xf000000000000000);
	85	try test__extenddftf2(0x1.23456789abcdefp+5, 0x400423456789abcd, 0xf000000000000000);
86	86
87		test__extenddftf2(0x1.edcba987654321fp-9, 0x3ff6edcba9876543, 0x2000000000000000);
	87	try test__extenddftf2(0x1.edcba987654321fp-9, 0x3ff6edcba9876543, 0x2000000000000000);
88	88
89		test__extenddftf2(0x1.23456789abcdefp+45, 0x402c23456789abcd, 0xf000000000000000);
	89	try test__extenddftf2(0x1.23456789abcdefp+45, 0x402c23456789abcd, 0xf000000000000000);
90	90
91		test__extenddftf2(0x1.edcba987654321fp-45, 0x3fd2edcba9876543, 0x2000000000000000);
	91	try test__extenddftf2(0x1.edcba987654321fp-45, 0x3fd2edcba9876543, 0x2000000000000000);
92	92	}
93	93
94	94	test "extendhfsf2" {
95		test__extendhfsf2(0x7e00, 0x7fc00000); // qNaN
96		test__extendhfsf2(0x7f00, 0x7fe00000); // sNaN
	95	try test__extendhfsf2(0x7e00, 0x7fc00000); // qNaN
	96	try test__extendhfsf2(0x7f00, 0x7fe00000); // sNaN
97	97	// On x86 the NaN becomes quiet because the return is pushed on the x87
98	98	// stack due to ABI requirements
99	99	if (builtin.arch != .i386 and builtin.os.tag == .windows)
100		test__extendhfsf2(0x7c01, 0x7f802000); // sNaN
	100	try test__extendhfsf2(0x7c01, 0x7f802000); // sNaN
101	101
102		test__extendhfsf2(0, 0); // 0
103		test__extendhfsf2(0x8000, 0x80000000); // -0
	102	try test__extendhfsf2(0, 0); // 0
	103	try test__extendhfsf2(0x8000, 0x80000000); // -0
104	104
105		test__extendhfsf2(0x7c00, 0x7f800000); // inf
106		test__extendhfsf2(0xfc00, 0xff800000); // -inf
	105	try test__extendhfsf2(0x7c00, 0x7f800000); // inf
	106	try test__extendhfsf2(0xfc00, 0xff800000); // -inf
107	107
108		test__extendhfsf2(0x0001, 0x33800000); // denormal (min), 2**-24
109		test__extendhfsf2(0x8001, 0xb3800000); // denormal (min), -2**-24
	108	try test__extendhfsf2(0x0001, 0x33800000); // denormal (min), 2**-24
	109	try test__extendhfsf2(0x8001, 0xb3800000); // denormal (min), -2**-24
110	110
111		test__extendhfsf2(0x03ff, 0x387fc000); // denormal (max), 2-14 - 2-24
112		test__extendhfsf2(0x83ff, 0xb87fc000); // denormal (max), -2-14 + 2-24
	111	try test__extendhfsf2(0x03ff, 0x387fc000); // denormal (max), 2-14 - 2-24
	112	try test__extendhfsf2(0x83ff, 0xb87fc000); // denormal (max), -2-14 + 2-24
113	113
114		test__extendhfsf2(0x0400, 0x38800000); // normal (min), 2**-14
115		test__extendhfsf2(0x8400, 0xb8800000); // normal (min), -2**-14
	114	try test__extendhfsf2(0x0400, 0x38800000); // normal (min), 2**-14
	115	try test__extendhfsf2(0x8400, 0xb8800000); // normal (min), -2**-14
116	116
117		test__extendhfsf2(0x7bff, 0x477fe000); // normal (max), 65504
118		test__extendhfsf2(0xfbff, 0xc77fe000); // normal (max), -65504
	117	try test__extendhfsf2(0x7bff, 0x477fe000); // normal (max), 65504
	118	try test__extendhfsf2(0xfbff, 0xc77fe000); // normal (max), -65504
119	119
120		test__extendhfsf2(0x3c01, 0x3f802000); // normal, 1 + 2**-10
121		test__extendhfsf2(0xbc01, 0xbf802000); // normal, -1 - 2**-10
	120	try test__extendhfsf2(0x3c01, 0x3f802000); // normal, 1 + 2**-10
	121	try test__extendhfsf2(0xbc01, 0xbf802000); // normal, -1 - 2**-10
122	122
123		test__extendhfsf2(0x3555, 0x3eaaa000); // normal, approx. 1/3
124		test__extendhfsf2(0xb555, 0xbeaaa000); // normal, approx. -1/3
	123	try test__extendhfsf2(0x3555, 0x3eaaa000); // normal, approx. 1/3
	124	try test__extendhfsf2(0xb555, 0xbeaaa000); // normal, approx. -1/3
125	125	}
126	126
127	127	test "extendsftf2" {
128	128	// qNaN
129		test__extendsftf2(makeQNaN32(), 0x7fff800000000000, 0x0);
	129	try test__extendsftf2(makeQNaN32(), 0x7fff800000000000, 0x0);
130	130	// NaN
131		test__extendsftf2(makeNaN32(0x410000), 0x7fff820000000000, 0x0);
	131	try test__extendsftf2(makeNaN32(0x410000), 0x7fff820000000000, 0x0);
132	132	// inf
133		test__extendsftf2(makeInf32(), 0x7fff000000000000, 0x0);
	133	try test__extendsftf2(makeInf32(), 0x7fff000000000000, 0x0);
134	134	// zero
135		test__extendsftf2(0.0, 0x0, 0x0);
136		test__extendsftf2(0x1.23456p+5, 0x4004234560000000, 0x0);
137		test__extendsftf2(0x1.edcbap-9, 0x3ff6edcba0000000, 0x0);
138		test__extendsftf2(0x1.23456p+45, 0x402c234560000000, 0x0);
139		test__extendsftf2(0x1.edcbap-45, 0x3fd2edcba0000000, 0x0);
	135	try test__extendsftf2(0.0, 0x0, 0x0);
	136	try test__extendsftf2(0x1.23456p+5, 0x4004234560000000, 0x0);
	137	try test__extendsftf2(0x1.edcbap-9, 0x3ff6edcba0000000, 0x0);
	138	try test__extendsftf2(0x1.23456p+45, 0x402c234560000000, 0x0);
	139	try test__extendsftf2(0x1.edcbap-45, 0x3fd2edcba0000000, 0x0);
140	140	}
141	141
142	142	fn makeQNaN64() f64 {
...	...	@@ -163,7 +163,7 @@ fn makeInf32() f32 {
163	163	return @bitCast(f32, @as(u32, 0x7f800000));
164	164	}
165	165
166		fn test__extendhftf2(a: u16, expectedHi: u64, expectedLo: u64) void {
	166	fn test__extendhftf2(a: u16, expectedHi: u64, expectedLo: u64) !void {
167	167	const x = __extendhftf2(a);
168	168
169	169	const rep = @bitCast(u128, x);
...	...	@@ -182,29 +182,29 @@ fn test__extendhftf2(a: u16, expectedHi: u64, expectedLo: u64) void {
182	182	}
183	183	}
184	184
185		@panic("__extendhftf2 test failure");
	185	return error.TestFailure;
186	186	}
187	187
188	188	test "extendhftf2" {
189	189	// qNaN
190		test__extendhftf2(0x7e00, 0x7fff800000000000, 0x0);
	190	try test__extendhftf2(0x7e00, 0x7fff800000000000, 0x0);
191	191	// NaN
192		test__extendhftf2(0x7d00, 0x7fff400000000000, 0x0);
	192	try test__extendhftf2(0x7d00, 0x7fff400000000000, 0x0);
193	193	// inf
194		test__extendhftf2(0x7c00, 0x7fff000000000000, 0x0);
195		test__extendhftf2(0xfc00, 0xffff000000000000, 0x0);
	194	try test__extendhftf2(0x7c00, 0x7fff000000000000, 0x0);
	195	try test__extendhftf2(0xfc00, 0xffff000000000000, 0x0);
196	196	// zero
197		test__extendhftf2(0x0000, 0x0000000000000000, 0x0);
198		test__extendhftf2(0x8000, 0x8000000000000000, 0x0);
	197	try test__extendhftf2(0x0000, 0x0000000000000000, 0x0);
	198	try test__extendhftf2(0x8000, 0x8000000000000000, 0x0);
199	199	// denormal
200		test__extendhftf2(0x0010, 0x3feb000000000000, 0x0);
201		test__extendhftf2(0x0001, 0x3fe7000000000000, 0x0);
202		test__extendhftf2(0x8001, 0xbfe7000000000000, 0x0);
	200	try test__extendhftf2(0x0010, 0x3feb000000000000, 0x0);
	201	try test__extendhftf2(0x0001, 0x3fe7000000000000, 0x0);
	202	try test__extendhftf2(0x8001, 0xbfe7000000000000, 0x0);
203	203
204	204	// pi
205		test__extendhftf2(0x4248, 0x4000920000000000, 0x0);
206		test__extendhftf2(0xc248, 0xc000920000000000, 0x0);
	205	try test__extendhftf2(0x4248, 0x4000920000000000, 0x0);
	206	try test__extendhftf2(0xc248, 0xc000920000000000, 0x0);
207	207
208		test__extendhftf2(0x508c, 0x4004230000000000, 0x0);
209		test__extendhftf2(0x1bb7, 0x3ff6edc000000000, 0x0);
	208	try test__extendhftf2(0x508c, 0x4004230000000000, 0x0);
	209	try test__extendhftf2(0x1bb7, 0x3ff6edc000000000, 0x0);
210	210	}

lib/std/special/compiler_rt/fixdfdi_test.zig+41-41

...	...	@@ -9,7 +9,7 @@ const math = std.math;
9	9	const testing = std.testing;
10	10	const warn = std.debug.warn;
11	11
12		fn test__fixdfdi(a: f64, expected: i64) void {
	12	fn test__fixdfdi(a: f64, expected: i64) !void {
13	13	const x = __fixdfdi(a);
14	14	//warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u64, expected)});
15	15	try testing.expect(x == expected);
...	...	@@ -17,54 +17,54 @@ fn test__fixdfdi(a: f64, expected: i64) void {
17	17
18	18	test "fixdfdi" {
19	19	//warn("\n", .{});
20		test__fixdfdi(-math.f64_max, math.minInt(i64));
	20	try test__fixdfdi(-math.f64_max, math.minInt(i64));
21	21
22		test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
23		test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
	22	try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
	23	try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
24	24
25		test__fixdfdi(-0x1.0000000000000p+127, -0x8000000000000000);
26		test__fixdfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
27		test__fixdfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
	25	try test__fixdfdi(-0x1.0000000000000p+127, -0x8000000000000000);
	26	try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
	27	try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
28	28
29		test__fixdfdi(-0x1.0000000000001p+63, -0x8000000000000000);
30		test__fixdfdi(-0x1.0000000000000p+63, -0x8000000000000000);
31		test__fixdfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
32		test__fixdfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
	29	try test__fixdfdi(-0x1.0000000000001p+63, -0x8000000000000000);
	30	try test__fixdfdi(-0x1.0000000000000p+63, -0x8000000000000000);
	31	try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
	32	try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
33	33
34		test__fixdfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
35		test__fixdfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
	34	try test__fixdfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
	35	try test__fixdfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
36	36
37		test__fixdfdi(-2.01, -2);
38		test__fixdfdi(-2.0, -2);
39		test__fixdfdi(-1.99, -1);
40		test__fixdfdi(-1.0, -1);
41		test__fixdfdi(-0.99, 0);
42		test__fixdfdi(-0.5, 0);
43		test__fixdfdi(-math.f64_min, 0);
44		test__fixdfdi(0.0, 0);
45		test__fixdfdi(math.f64_min, 0);
46		test__fixdfdi(0.5, 0);
47		test__fixdfdi(0.99, 0);
48		test__fixdfdi(1.0, 1);
49		test__fixdfdi(1.5, 1);
50		test__fixdfdi(1.99, 1);
51		test__fixdfdi(2.0, 2);
52		test__fixdfdi(2.01, 2);
	37	try test__fixdfdi(-2.01, -2);
	38	try test__fixdfdi(-2.0, -2);
	39	try test__fixdfdi(-1.99, -1);
	40	try test__fixdfdi(-1.0, -1);
	41	try test__fixdfdi(-0.99, 0);
	42	try test__fixdfdi(-0.5, 0);
	43	try test__fixdfdi(-math.f64_min, 0);
	44	try test__fixdfdi(0.0, 0);
	45	try test__fixdfdi(math.f64_min, 0);
	46	try test__fixdfdi(0.5, 0);
	47	try test__fixdfdi(0.99, 0);
	48	try test__fixdfdi(1.0, 1);
	49	try test__fixdfdi(1.5, 1);
	50	try test__fixdfdi(1.99, 1);
	51	try test__fixdfdi(2.0, 2);
	52	try test__fixdfdi(2.01, 2);
53	53
54		test__fixdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
55		test__fixdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	54	try test__fixdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	55	try test__fixdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
56	56
57		test__fixdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
58		test__fixdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
59		test__fixdfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
60		test__fixdfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
	57	try test__fixdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	58	try test__fixdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	59	try test__fixdfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
	60	try test__fixdfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
61	61
62		test__fixdfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
63		test__fixdfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
64		test__fixdfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
	62	try test__fixdfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
	63	try test__fixdfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
	64	try test__fixdfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
65	65
66		test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
67		test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
	66	try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
	67	try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
68	68
69		test__fixdfdi(math.f64_max, math.maxInt(i64));
	69	try test__fixdfdi(math.f64_max, math.maxInt(i64));
70	70	}

lib/std/special/compiler_rt/fixdfsi_test.zig+47-47

...	...	@@ -9,7 +9,7 @@ const math = std.math;
9	9	const testing = std.testing;
10	10	const warn = std.debug.warn;
11	11
12		fn test__fixdfsi(a: f64, expected: i32) void {
	12	fn test__fixdfsi(a: f64, expected: i32) !void {
13	13	const x = __fixdfsi(a);
14	14	//warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u32, expected)});
15	15	try testing.expect(x == expected);
...	...	@@ -17,62 +17,62 @@ fn test__fixdfsi(a: f64, expected: i32) void {
17	17
18	18	test "fixdfsi" {
19	19	//warn("\n", .{});
20		test__fixdfsi(-math.f64_max, math.minInt(i32));
	20	try test__fixdfsi(-math.f64_max, math.minInt(i32));
21	21
22		test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
23		test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
	22	try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
	23	try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
24	24
25		test__fixdfsi(-0x1.0000000000000p+127, -0x80000000);
26		test__fixdfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
27		test__fixdfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
	25	try test__fixdfsi(-0x1.0000000000000p+127, -0x80000000);
	26	try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
	27	try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
28	28
29		test__fixdfsi(-0x1.0000000000001p+63, -0x80000000);
30		test__fixdfsi(-0x1.0000000000000p+63, -0x80000000);
31		test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
32		test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
	29	try test__fixdfsi(-0x1.0000000000001p+63, -0x80000000);
	30	try test__fixdfsi(-0x1.0000000000000p+63, -0x80000000);
	31	try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
	32	try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
33	33
34		test__fixdfsi(-0x1.FFFFFEp+62, -0x80000000);
35		test__fixdfsi(-0x1.FFFFFCp+62, -0x80000000);
	34	try test__fixdfsi(-0x1.FFFFFEp+62, -0x80000000);
	35	try test__fixdfsi(-0x1.FFFFFCp+62, -0x80000000);
36	36
37		test__fixdfsi(-0x1.000000p+31, -0x80000000);
38		test__fixdfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
39		test__fixdfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
	37	try test__fixdfsi(-0x1.000000p+31, -0x80000000);
	38	try test__fixdfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
	39	try test__fixdfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
40	40
41		test__fixdfsi(-2.01, -2);
42		test__fixdfsi(-2.0, -2);
43		test__fixdfsi(-1.99, -1);
44		test__fixdfsi(-1.0, -1);
45		test__fixdfsi(-0.99, 0);
46		test__fixdfsi(-0.5, 0);
47		test__fixdfsi(-math.f64_min, 0);
48		test__fixdfsi(0.0, 0);
49		test__fixdfsi(math.f64_min, 0);
50		test__fixdfsi(0.5, 0);
51		test__fixdfsi(0.99, 0);
52		test__fixdfsi(1.0, 1);
53		test__fixdfsi(1.5, 1);
54		test__fixdfsi(1.99, 1);
55		test__fixdfsi(2.0, 2);
56		test__fixdfsi(2.01, 2);
	41	try test__fixdfsi(-2.01, -2);
	42	try test__fixdfsi(-2.0, -2);
	43	try test__fixdfsi(-1.99, -1);
	44	try test__fixdfsi(-1.0, -1);
	45	try test__fixdfsi(-0.99, 0);
	46	try test__fixdfsi(-0.5, 0);
	47	try test__fixdfsi(-math.f64_min, 0);
	48	try test__fixdfsi(0.0, 0);
	49	try test__fixdfsi(math.f64_min, 0);
	50	try test__fixdfsi(0.5, 0);
	51	try test__fixdfsi(0.99, 0);
	52	try test__fixdfsi(1.0, 1);
	53	try test__fixdfsi(1.5, 1);
	54	try test__fixdfsi(1.99, 1);
	55	try test__fixdfsi(2.0, 2);
	56	try test__fixdfsi(2.01, 2);
57	57
58		test__fixdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
59		test__fixdfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
60		test__fixdfsi(0x1.000000p+31, 0x7FFFFFFF);
	58	try test__fixdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
	59	try test__fixdfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
	60	try test__fixdfsi(0x1.000000p+31, 0x7FFFFFFF);
61	61
62		test__fixdfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
63		test__fixdfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
	62	try test__fixdfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
	63	try test__fixdfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
64	64
65		test__fixdfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
66		test__fixdfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
67		test__fixdfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
68		test__fixdfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
	65	try test__fixdfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
	66	try test__fixdfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
	67	try test__fixdfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
	68	try test__fixdfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
69	69
70		test__fixdfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
71		test__fixdfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
72		test__fixdfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
	70	try test__fixdfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
	71	try test__fixdfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
	72	try test__fixdfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
73	73
74		test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
75		test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
	74	try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
	75	try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
76	76
77		test__fixdfsi(math.f64_max, math.maxInt(i32));
	77	try test__fixdfsi(math.f64_max, math.maxInt(i32));
78	78	}

lib/std/special/compiler_rt/fixdfti_test.zig+41-41

...	...	@@ -9,7 +9,7 @@ const math = std.math;
9	9	const testing = std.testing;
10	10	const warn = std.debug.warn;
11	11
12		fn test__fixdfti(a: f64, expected: i128) void {
	12	fn test__fixdfti(a: f64, expected: i128) !void {
13	13	const x = __fixdfti(a);
14	14	//warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u128, expected)});
15	15	try testing.expect(x == expected);
...	...	@@ -17,54 +17,54 @@ fn test__fixdfti(a: f64, expected: i128) void {
17	17
18	18	test "fixdfti" {
19	19	//warn("\n", .{});
20		test__fixdfti(-math.f64_max, math.minInt(i128));
	20	try test__fixdfti(-math.f64_max, math.minInt(i128));
21	21
22		test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
23		test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
	22	try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
	23	try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
24	24
25		test__fixdfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
26		test__fixdfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
27		test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
	25	try test__fixdfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
	26	try test__fixdfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
	27	try test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
28	28
29		test__fixdfti(-0x1.0000000000001p+63, -0x8000000000000800);
30		test__fixdfti(-0x1.0000000000000p+63, -0x8000000000000000);
31		test__fixdfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
32		test__fixdfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
	29	try test__fixdfti(-0x1.0000000000001p+63, -0x8000000000000800);
	30	try test__fixdfti(-0x1.0000000000000p+63, -0x8000000000000000);
	31	try test__fixdfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
	32	try test__fixdfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
33	33
34		test__fixdfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
35		test__fixdfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
	34	try test__fixdfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
	35	try test__fixdfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
36	36
37		test__fixdfti(-2.01, -2);
38		test__fixdfti(-2.0, -2);
39		test__fixdfti(-1.99, -1);
40		test__fixdfti(-1.0, -1);
41		test__fixdfti(-0.99, 0);
42		test__fixdfti(-0.5, 0);
43		test__fixdfti(-math.f64_min, 0);
44		test__fixdfti(0.0, 0);
45		test__fixdfti(math.f64_min, 0);
46		test__fixdfti(0.5, 0);
47		test__fixdfti(0.99, 0);
48		test__fixdfti(1.0, 1);
49		test__fixdfti(1.5, 1);
50		test__fixdfti(1.99, 1);
51		test__fixdfti(2.0, 2);
52		test__fixdfti(2.01, 2);
	37	try test__fixdfti(-2.01, -2);
	38	try test__fixdfti(-2.0, -2);
	39	try test__fixdfti(-1.99, -1);
	40	try test__fixdfti(-1.0, -1);
	41	try test__fixdfti(-0.99, 0);
	42	try test__fixdfti(-0.5, 0);
	43	try test__fixdfti(-math.f64_min, 0);
	44	try test__fixdfti(0.0, 0);
	45	try test__fixdfti(math.f64_min, 0);
	46	try test__fixdfti(0.5, 0);
	47	try test__fixdfti(0.99, 0);
	48	try test__fixdfti(1.0, 1);
	49	try test__fixdfti(1.5, 1);
	50	try test__fixdfti(1.99, 1);
	51	try test__fixdfti(2.0, 2);
	52	try test__fixdfti(2.01, 2);
53	53
54		test__fixdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
55		test__fixdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	54	try test__fixdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	55	try test__fixdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
56	56
57		test__fixdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
58		test__fixdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
59		test__fixdfti(0x1.0000000000000p+63, 0x8000000000000000);
60		test__fixdfti(0x1.0000000000001p+63, 0x8000000000000800);
	57	try test__fixdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	58	try test__fixdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	59	try test__fixdfti(0x1.0000000000000p+63, 0x8000000000000000);
	60	try test__fixdfti(0x1.0000000000001p+63, 0x8000000000000800);
61	61
62		test__fixdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
63		test__fixdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
64		test__fixdfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	62	try test__fixdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
	63	try test__fixdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
	64	try test__fixdfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
65	65
66		test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
67		test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
	66	try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	67	try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
68	68
69		test__fixdfti(math.f64_max, math.maxInt(i128));
	69	try test__fixdfti(math.f64_max, math.maxInt(i128));
70	70	}

lib/std/special/compiler_rt/fixint_test.zig+122-122

...	...	@@ -11,147 +11,147 @@ const warn = std.debug.warn;
11	11
12	12	const fixint = @import("fixint.zig").fixint;
13	13
14		fn test__fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t, expected: fixint_t) void {
	14	fn test__fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t, expected: fixint_t) !void {
15	15	const x = fixint(fp_t, fixint_t, a);
16	16	//warn("a={} x={}:{x} expected={}:{x})\n", .{a, x, x, expected, expected});
17	17	try testing.expect(x == expected);
18	18	}
19	19
20	20	test "fixint.i1" {
21		test__fixint(f32, i1, -math.inf_f32, -1);
22		test__fixint(f32, i1, -math.f32_max, -1);
23		test__fixint(f32, i1, -2.0, -1);
24		test__fixint(f32, i1, -1.1, -1);
25		test__fixint(f32, i1, -1.0, -1);
26		test__fixint(f32, i1, -0.9, 0);
27		test__fixint(f32, i1, -0.1, 0);
28		test__fixint(f32, i1, -math.f32_min, 0);
29		test__fixint(f32, i1, -0.0, 0);
30		test__fixint(f32, i1, 0.0, 0);
31		test__fixint(f32, i1, math.f32_min, 0);
32		test__fixint(f32, i1, 0.1, 0);
33		test__fixint(f32, i1, 0.9, 0);
34		test__fixint(f32, i1, 1.0, 0);
35		test__fixint(f32, i1, 2.0, 0);
36		test__fixint(f32, i1, math.f32_max, 0);
37		test__fixint(f32, i1, math.inf_f32, 0);
	21	try test__fixint(f32, i1, -math.inf_f32, -1);
	22	try test__fixint(f32, i1, -math.f32_max, -1);
	23	try test__fixint(f32, i1, -2.0, -1);
	24	try test__fixint(f32, i1, -1.1, -1);
	25	try test__fixint(f32, i1, -1.0, -1);
	26	try test__fixint(f32, i1, -0.9, 0);
	27	try test__fixint(f32, i1, -0.1, 0);
	28	try test__fixint(f32, i1, -math.f32_min, 0);
	29	try test__fixint(f32, i1, -0.0, 0);
	30	try test__fixint(f32, i1, 0.0, 0);
	31	try test__fixint(f32, i1, math.f32_min, 0);
	32	try test__fixint(f32, i1, 0.1, 0);
	33	try test__fixint(f32, i1, 0.9, 0);
	34	try test__fixint(f32, i1, 1.0, 0);
	35	try test__fixint(f32, i1, 2.0, 0);
	36	try test__fixint(f32, i1, math.f32_max, 0);
	37	try test__fixint(f32, i1, math.inf_f32, 0);
38	38	}
39	39
40	40	test "fixint.i2" {
41		test__fixint(f32, i2, -math.inf_f32, -2);
42		test__fixint(f32, i2, -math.f32_max, -2);
43		test__fixint(f32, i2, -2.0, -2);
44		test__fixint(f32, i2, -1.9, -1);
45		test__fixint(f32, i2, -1.1, -1);
46		test__fixint(f32, i2, -1.0, -1);
47		test__fixint(f32, i2, -0.9, 0);
48		test__fixint(f32, i2, -0.1, 0);
49		test__fixint(f32, i2, -math.f32_min, 0);
50		test__fixint(f32, i2, -0.0, 0);
51		test__fixint(f32, i2, 0.0, 0);
52		test__fixint(f32, i2, math.f32_min, 0);
53		test__fixint(f32, i2, 0.1, 0);
54		test__fixint(f32, i2, 0.9, 0);
55		test__fixint(f32, i2, 1.0, 1);
56		test__fixint(f32, i2, 2.0, 1);
57		test__fixint(f32, i2, math.f32_max, 1);
58		test__fixint(f32, i2, math.inf_f32, 1);
	41	try test__fixint(f32, i2, -math.inf_f32, -2);
	42	try test__fixint(f32, i2, -math.f32_max, -2);
	43	try test__fixint(f32, i2, -2.0, -2);
	44	try test__fixint(f32, i2, -1.9, -1);
	45	try test__fixint(f32, i2, -1.1, -1);
	46	try test__fixint(f32, i2, -1.0, -1);
	47	try test__fixint(f32, i2, -0.9, 0);
	48	try test__fixint(f32, i2, -0.1, 0);
	49	try test__fixint(f32, i2, -math.f32_min, 0);
	50	try test__fixint(f32, i2, -0.0, 0);
	51	try test__fixint(f32, i2, 0.0, 0);
	52	try test__fixint(f32, i2, math.f32_min, 0);
	53	try test__fixint(f32, i2, 0.1, 0);
	54	try test__fixint(f32, i2, 0.9, 0);
	55	try test__fixint(f32, i2, 1.0, 1);
	56	try test__fixint(f32, i2, 2.0, 1);
	57	try test__fixint(f32, i2, math.f32_max, 1);
	58	try test__fixint(f32, i2, math.inf_f32, 1);
59	59	}
60	60
61	61	test "fixint.i3" {
62		test__fixint(f32, i3, -math.inf_f32, -4);
63		test__fixint(f32, i3, -math.f32_max, -4);
64		test__fixint(f32, i3, -4.0, -4);
65		test__fixint(f32, i3, -3.0, -3);
66		test__fixint(f32, i3, -2.0, -2);
67		test__fixint(f32, i3, -1.9, -1);
68		test__fixint(f32, i3, -1.1, -1);
69		test__fixint(f32, i3, -1.0, -1);
70		test__fixint(f32, i3, -0.9, 0);
71		test__fixint(f32, i3, -0.1, 0);
72		test__fixint(f32, i3, -math.f32_min, 0);
73		test__fixint(f32, i3, -0.0, 0);
74		test__fixint(f32, i3, 0.0, 0);
75		test__fixint(f32, i3, math.f32_min, 0);
76		test__fixint(f32, i3, 0.1, 0);
77		test__fixint(f32, i3, 0.9, 0);
78		test__fixint(f32, i3, 1.0, 1);
79		test__fixint(f32, i3, 2.0, 2);
80		test__fixint(f32, i3, 3.0, 3);
81		test__fixint(f32, i3, 4.0, 3);
82		test__fixint(f32, i3, math.f32_max, 3);
83		test__fixint(f32, i3, math.inf_f32, 3);
	62	try test__fixint(f32, i3, -math.inf_f32, -4);
	63	try test__fixint(f32, i3, -math.f32_max, -4);
	64	try test__fixint(f32, i3, -4.0, -4);
	65	try test__fixint(f32, i3, -3.0, -3);
	66	try test__fixint(f32, i3, -2.0, -2);
	67	try test__fixint(f32, i3, -1.9, -1);
	68	try test__fixint(f32, i3, -1.1, -1);
	69	try test__fixint(f32, i3, -1.0, -1);
	70	try test__fixint(f32, i3, -0.9, 0);
	71	try test__fixint(f32, i3, -0.1, 0);
	72	try test__fixint(f32, i3, -math.f32_min, 0);
	73	try test__fixint(f32, i3, -0.0, 0);
	74	try test__fixint(f32, i3, 0.0, 0);
	75	try test__fixint(f32, i3, math.f32_min, 0);
	76	try test__fixint(f32, i3, 0.1, 0);
	77	try test__fixint(f32, i3, 0.9, 0);
	78	try test__fixint(f32, i3, 1.0, 1);
	79	try test__fixint(f32, i3, 2.0, 2);
	80	try test__fixint(f32, i3, 3.0, 3);
	81	try test__fixint(f32, i3, 4.0, 3);
	82	try test__fixint(f32, i3, math.f32_max, 3);
	83	try test__fixint(f32, i3, math.inf_f32, 3);
84	84	}
85	85
86	86	test "fixint.i32" {
87		test__fixint(f64, i32, -math.inf_f64, math.minInt(i32));
88		test__fixint(f64, i32, -math.f64_max, math.minInt(i32));
89		test__fixint(f64, i32, @as(f64, math.minInt(i32)), math.minInt(i32));
90		test__fixint(f64, i32, @as(f64, math.minInt(i32)) + 1, math.minInt(i32) + 1);
91		test__fixint(f64, i32, -2.0, -2);
92		test__fixint(f64, i32, -1.9, -1);
93		test__fixint(f64, i32, -1.1, -1);
94		test__fixint(f64, i32, -1.0, -1);
95		test__fixint(f64, i32, -0.9, 0);
96		test__fixint(f64, i32, -0.1, 0);
97		test__fixint(f64, i32, -math.f32_min, 0);
98		test__fixint(f64, i32, -0.0, 0);
99		test__fixint(f64, i32, 0.0, 0);
100		test__fixint(f64, i32, math.f32_min, 0);
101		test__fixint(f64, i32, 0.1, 0);
102		test__fixint(f64, i32, 0.9, 0);
103		test__fixint(f64, i32, 1.0, 1);
104		test__fixint(f64, i32, @as(f64, math.maxInt(i32)) - 1, math.maxInt(i32) - 1);
105		test__fixint(f64, i32, @as(f64, math.maxInt(i32)), math.maxInt(i32));
106		test__fixint(f64, i32, math.f64_max, math.maxInt(i32));
107		test__fixint(f64, i32, math.inf_f64, math.maxInt(i32));
	87	try test__fixint(f64, i32, -math.inf_f64, math.minInt(i32));
	88	try test__fixint(f64, i32, -math.f64_max, math.minInt(i32));
	89	try test__fixint(f64, i32, @as(f64, math.minInt(i32)), math.minInt(i32));
	90	try test__fixint(f64, i32, @as(f64, math.minInt(i32)) + 1, math.minInt(i32) + 1);
	91	try test__fixint(f64, i32, -2.0, -2);
	92	try test__fixint(f64, i32, -1.9, -1);
	93	try test__fixint(f64, i32, -1.1, -1);
	94	try test__fixint(f64, i32, -1.0, -1);
	95	try test__fixint(f64, i32, -0.9, 0);
	96	try test__fixint(f64, i32, -0.1, 0);
	97	try test__fixint(f64, i32, -math.f32_min, 0);
	98	try test__fixint(f64, i32, -0.0, 0);
	99	try test__fixint(f64, i32, 0.0, 0);
	100	try test__fixint(f64, i32, math.f32_min, 0);
	101	try test__fixint(f64, i32, 0.1, 0);
	102	try test__fixint(f64, i32, 0.9, 0);
	103	try test__fixint(f64, i32, 1.0, 1);
	104	try test__fixint(f64, i32, @as(f64, math.maxInt(i32)) - 1, math.maxInt(i32) - 1);
	105	try test__fixint(f64, i32, @as(f64, math.maxInt(i32)), math.maxInt(i32));
	106	try test__fixint(f64, i32, math.f64_max, math.maxInt(i32));
	107	try test__fixint(f64, i32, math.inf_f64, math.maxInt(i32));
108	108	}
109	109
110	110	test "fixint.i64" {
111		test__fixint(f64, i64, -math.inf_f64, math.minInt(i64));
112		test__fixint(f64, i64, -math.f64_max, math.minInt(i64));
113		test__fixint(f64, i64, @as(f64, math.minInt(i64)), math.minInt(i64));
114		test__fixint(f64, i64, @as(f64, math.minInt(i64)) + 1, math.minInt(i64));
115		test__fixint(f64, i64, @as(f64, math.minInt(i64) / 2), math.minInt(i64) / 2);
116		test__fixint(f64, i64, -2.0, -2);
117		test__fixint(f64, i64, -1.9, -1);
118		test__fixint(f64, i64, -1.1, -1);
119		test__fixint(f64, i64, -1.0, -1);
120		test__fixint(f64, i64, -0.9, 0);
121		test__fixint(f64, i64, -0.1, 0);
122		test__fixint(f64, i64, -math.f32_min, 0);
123		test__fixint(f64, i64, -0.0, 0);
124		test__fixint(f64, i64, 0.0, 0);
125		test__fixint(f64, i64, math.f32_min, 0);
126		test__fixint(f64, i64, 0.1, 0);
127		test__fixint(f64, i64, 0.9, 0);
128		test__fixint(f64, i64, 1.0, 1);
129		test__fixint(f64, i64, @as(f64, math.maxInt(i64)) - 1, math.maxInt(i64));
130		test__fixint(f64, i64, @as(f64, math.maxInt(i64)), math.maxInt(i64));
131		test__fixint(f64, i64, math.f64_max, math.maxInt(i64));
132		test__fixint(f64, i64, math.inf_f64, math.maxInt(i64));
	111	try test__fixint(f64, i64, -math.inf_f64, math.minInt(i64));
	112	try test__fixint(f64, i64, -math.f64_max, math.minInt(i64));
	113	try test__fixint(f64, i64, @as(f64, math.minInt(i64)), math.minInt(i64));
	114	try test__fixint(f64, i64, @as(f64, math.minInt(i64)) + 1, math.minInt(i64));
	115	try test__fixint(f64, i64, @as(f64, math.minInt(i64) / 2), math.minInt(i64) / 2);
	116	try test__fixint(f64, i64, -2.0, -2);
	117	try test__fixint(f64, i64, -1.9, -1);
	118	try test__fixint(f64, i64, -1.1, -1);
	119	try test__fixint(f64, i64, -1.0, -1);
	120	try test__fixint(f64, i64, -0.9, 0);
	121	try test__fixint(f64, i64, -0.1, 0);
	122	try test__fixint(f64, i64, -math.f32_min, 0);
	123	try test__fixint(f64, i64, -0.0, 0);
	124	try test__fixint(f64, i64, 0.0, 0);
	125	try test__fixint(f64, i64, math.f32_min, 0);
	126	try test__fixint(f64, i64, 0.1, 0);
	127	try test__fixint(f64, i64, 0.9, 0);
	128	try test__fixint(f64, i64, 1.0, 1);
	129	try test__fixint(f64, i64, @as(f64, math.maxInt(i64)) - 1, math.maxInt(i64));
	130	try test__fixint(f64, i64, @as(f64, math.maxInt(i64)), math.maxInt(i64));
	131	try test__fixint(f64, i64, math.f64_max, math.maxInt(i64));
	132	try test__fixint(f64, i64, math.inf_f64, math.maxInt(i64));
133	133	}
134	134
135	135	test "fixint.i128" {
136		test__fixint(f64, i128, -math.inf_f64, math.minInt(i128));
137		test__fixint(f64, i128, -math.f64_max, math.minInt(i128));
138		test__fixint(f64, i128, @as(f64, math.minInt(i128)), math.minInt(i128));
139		test__fixint(f64, i128, @as(f64, math.minInt(i128)) + 1, math.minInt(i128));
140		test__fixint(f64, i128, -2.0, -2);
141		test__fixint(f64, i128, -1.9, -1);
142		test__fixint(f64, i128, -1.1, -1);
143		test__fixint(f64, i128, -1.0, -1);
144		test__fixint(f64, i128, -0.9, 0);
145		test__fixint(f64, i128, -0.1, 0);
146		test__fixint(f64, i128, -math.f32_min, 0);
147		test__fixint(f64, i128, -0.0, 0);
148		test__fixint(f64, i128, 0.0, 0);
149		test__fixint(f64, i128, math.f32_min, 0);
150		test__fixint(f64, i128, 0.1, 0);
151		test__fixint(f64, i128, 0.9, 0);
152		test__fixint(f64, i128, 1.0, 1);
153		test__fixint(f64, i128, @as(f64, math.maxInt(i128)) - 1, math.maxInt(i128));
154		test__fixint(f64, i128, @as(f64, math.maxInt(i128)), math.maxInt(i128));
155		test__fixint(f64, i128, math.f64_max, math.maxInt(i128));
156		test__fixint(f64, i128, math.inf_f64, math.maxInt(i128));
	136	try test__fixint(f64, i128, -math.inf_f64, math.minInt(i128));
	137	try test__fixint(f64, i128, -math.f64_max, math.minInt(i128));
	138	try test__fixint(f64, i128, @as(f64, math.minInt(i128)), math.minInt(i128));
	139	try test__fixint(f64, i128, @as(f64, math.minInt(i128)) + 1, math.minInt(i128));
	140	try test__fixint(f64, i128, -2.0, -2);
	141	try test__fixint(f64, i128, -1.9, -1);
	142	try test__fixint(f64, i128, -1.1, -1);
	143	try test__fixint(f64, i128, -1.0, -1);
	144	try test__fixint(f64, i128, -0.9, 0);
	145	try test__fixint(f64, i128, -0.1, 0);
	146	try test__fixint(f64, i128, -math.f32_min, 0);
	147	try test__fixint(f64, i128, -0.0, 0);
	148	try test__fixint(f64, i128, 0.0, 0);
	149	try test__fixint(f64, i128, math.f32_min, 0);
	150	try test__fixint(f64, i128, 0.1, 0);
	151	try test__fixint(f64, i128, 0.9, 0);
	152	try test__fixint(f64, i128, 1.0, 1);
	153	try test__fixint(f64, i128, @as(f64, math.maxInt(i128)) - 1, math.maxInt(i128));
	154	try test__fixint(f64, i128, @as(f64, math.maxInt(i128)), math.maxInt(i128));
	155	try test__fixint(f64, i128, math.f64_max, math.maxInt(i128));
	156	try test__fixint(f64, i128, math.inf_f64, math.maxInt(i128));
157	157	}

lib/std/special/compiler_rt/fixsfdi_test.zig+43-43

...	...	@@ -9,7 +9,7 @@ const math = std.math;
9	9	const testing = std.testing;
10	10	const warn = std.debug.warn;
11	11
12		fn test__fixsfdi(a: f32, expected: i64) void {
	12	fn test__fixsfdi(a: f32, expected: i64) !void {
13	13	const x = __fixsfdi(a);
14	14	//warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u64, expected)});
15	15	try testing.expect(x == expected);
...	...	@@ -17,56 +17,56 @@ fn test__fixsfdi(a: f32, expected: i64) void {
17	17
18	18	test "fixsfdi" {
19	19	//warn("\n", .{});
20		test__fixsfdi(-math.f32_max, math.minInt(i64));
	20	try test__fixsfdi(-math.f32_max, math.minInt(i64));
21	21
22		test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
23		test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
	22	try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
	23	try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
24	24
25		test__fixsfdi(-0x1.0000000000000p+127, -0x8000000000000000);
26		test__fixsfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
27		test__fixsfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
	25	try test__fixsfdi(-0x1.0000000000000p+127, -0x8000000000000000);
	26	try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
	27	try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
28	28
29		test__fixsfdi(-0x1.0000000000001p+63, -0x8000000000000000);
30		test__fixsfdi(-0x1.0000000000000p+63, -0x8000000000000000);
31		test__fixsfdi(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
32		test__fixsfdi(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
	29	try test__fixsfdi(-0x1.0000000000001p+63, -0x8000000000000000);
	30	try test__fixsfdi(-0x1.0000000000000p+63, -0x8000000000000000);
	31	try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
	32	try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
33	33
34		test__fixsfdi(-0x1.FFFFFFp+62, -0x8000000000000000);
35		test__fixsfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
36		test__fixsfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
	34	try test__fixsfdi(-0x1.FFFFFFp+62, -0x8000000000000000);
	35	try test__fixsfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
	36	try test__fixsfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
37	37
38		test__fixsfdi(-2.01, -2);
39		test__fixsfdi(-2.0, -2);
40		test__fixsfdi(-1.99, -1);
41		test__fixsfdi(-1.0, -1);
42		test__fixsfdi(-0.99, 0);
43		test__fixsfdi(-0.5, 0);
44		test__fixsfdi(-math.f32_min, 0);
45		test__fixsfdi(0.0, 0);
46		test__fixsfdi(math.f32_min, 0);
47		test__fixsfdi(0.5, 0);
48		test__fixsfdi(0.99, 0);
49		test__fixsfdi(1.0, 1);
50		test__fixsfdi(1.5, 1);
51		test__fixsfdi(1.99, 1);
52		test__fixsfdi(2.0, 2);
53		test__fixsfdi(2.01, 2);
	38	try test__fixsfdi(-2.01, -2);
	39	try test__fixsfdi(-2.0, -2);
	40	try test__fixsfdi(-1.99, -1);
	41	try test__fixsfdi(-1.0, -1);
	42	try test__fixsfdi(-0.99, 0);
	43	try test__fixsfdi(-0.5, 0);
	44	try test__fixsfdi(-math.f32_min, 0);
	45	try test__fixsfdi(0.0, 0);
	46	try test__fixsfdi(math.f32_min, 0);
	47	try test__fixsfdi(0.5, 0);
	48	try test__fixsfdi(0.99, 0);
	49	try test__fixsfdi(1.0, 1);
	50	try test__fixsfdi(1.5, 1);
	51	try test__fixsfdi(1.99, 1);
	52	try test__fixsfdi(2.0, 2);
	53	try test__fixsfdi(2.01, 2);
54	54
55		test__fixsfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
56		test__fixsfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
57		test__fixsfdi(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
	55	try test__fixsfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	56	try test__fixsfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	57	try test__fixsfdi(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
58	58
59		test__fixsfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF);
60		test__fixsfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
61		test__fixsfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
62		test__fixsfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
	59	try test__fixsfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF);
	60	try test__fixsfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
	61	try test__fixsfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
	62	try test__fixsfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
63	63
64		test__fixsfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
65		test__fixsfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
66		test__fixsfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
	64	try test__fixsfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
	65	try test__fixsfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
	66	try test__fixsfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
67	67
68		test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
69		test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
	68	try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
	69	try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
70	70
71		test__fixsfdi(math.f64_max, math.maxInt(i64));
	71	try test__fixsfdi(math.f64_max, math.maxInt(i64));
72	72	}

lib/std/special/compiler_rt/fixsfsi_test.zig+49-49

...	...	@@ -9,7 +9,7 @@ const math = std.math;
9	9	const testing = std.testing;
10	10	const warn = std.debug.warn;
11	11
12		fn test__fixsfsi(a: f32, expected: i32) void {
	12	fn test__fixsfsi(a: f32, expected: i32) !void {
13	13	const x = __fixsfsi(a);
14	14	//warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u32, expected)});
15	15	try testing.expect(x == expected);
...	...	@@ -17,64 +17,64 @@ fn test__fixsfsi(a: f32, expected: i32) void {
17	17
18	18	test "fixsfsi" {
19	19	//warn("\n", .{});
20		test__fixsfsi(-math.f32_max, math.minInt(i32));
	20	try test__fixsfsi(-math.f32_max, math.minInt(i32));
21	21
22		test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
23		test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
	22	try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
	23	try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
24	24
25		test__fixsfsi(-0x1.0000000000000p+127, -0x80000000);
26		test__fixsfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
27		test__fixsfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
	25	try test__fixsfsi(-0x1.0000000000000p+127, -0x80000000);
	26	try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
	27	try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
28	28
29		test__fixsfsi(-0x1.0000000000001p+63, -0x80000000);
30		test__fixsfsi(-0x1.0000000000000p+63, -0x80000000);
31		test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
32		test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
	29	try test__fixsfsi(-0x1.0000000000001p+63, -0x80000000);
	30	try test__fixsfsi(-0x1.0000000000000p+63, -0x80000000);
	31	try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
	32	try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
33	33
34		test__fixsfsi(-0x1.FFFFFEp+62, -0x80000000);
35		test__fixsfsi(-0x1.FFFFFCp+62, -0x80000000);
	34	try test__fixsfsi(-0x1.FFFFFEp+62, -0x80000000);
	35	try test__fixsfsi(-0x1.FFFFFCp+62, -0x80000000);
36	36
37		test__fixsfsi(-0x1.000000p+31, -0x80000000);
38		test__fixsfsi(-0x1.FFFFFFp+30, -0x80000000);
39		test__fixsfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
40		test__fixsfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
	37	try test__fixsfsi(-0x1.000000p+31, -0x80000000);
	38	try test__fixsfsi(-0x1.FFFFFFp+30, -0x80000000);
	39	try test__fixsfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
	40	try test__fixsfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
41	41
42		test__fixsfsi(-2.01, -2);
43		test__fixsfsi(-2.0, -2);
44		test__fixsfsi(-1.99, -1);
45		test__fixsfsi(-1.0, -1);
46		test__fixsfsi(-0.99, 0);
47		test__fixsfsi(-0.5, 0);
48		test__fixsfsi(-math.f32_min, 0);
49		test__fixsfsi(0.0, 0);
50		test__fixsfsi(math.f32_min, 0);
51		test__fixsfsi(0.5, 0);
52		test__fixsfsi(0.99, 0);
53		test__fixsfsi(1.0, 1);
54		test__fixsfsi(1.5, 1);
55		test__fixsfsi(1.99, 1);
56		test__fixsfsi(2.0, 2);
57		test__fixsfsi(2.01, 2);
	42	try test__fixsfsi(-2.01, -2);
	43	try test__fixsfsi(-2.0, -2);
	44	try test__fixsfsi(-1.99, -1);
	45	try test__fixsfsi(-1.0, -1);
	46	try test__fixsfsi(-0.99, 0);
	47	try test__fixsfsi(-0.5, 0);
	48	try test__fixsfsi(-math.f32_min, 0);
	49	try test__fixsfsi(0.0, 0);
	50	try test__fixsfsi(math.f32_min, 0);
	51	try test__fixsfsi(0.5, 0);
	52	try test__fixsfsi(0.99, 0);
	53	try test__fixsfsi(1.0, 1);
	54	try test__fixsfsi(1.5, 1);
	55	try test__fixsfsi(1.99, 1);
	56	try test__fixsfsi(2.0, 2);
	57	try test__fixsfsi(2.01, 2);
58	58
59		test__fixsfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
60		test__fixsfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
61		test__fixsfsi(0x1.FFFFFFp+30, 0x7FFFFFFF);
62		test__fixsfsi(0x1.000000p+31, 0x7FFFFFFF);
	59	try test__fixsfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
	60	try test__fixsfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
	61	try test__fixsfsi(0x1.FFFFFFp+30, 0x7FFFFFFF);
	62	try test__fixsfsi(0x1.000000p+31, 0x7FFFFFFF);
63	63
64		test__fixsfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
65		test__fixsfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
	64	try test__fixsfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
	65	try test__fixsfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
66	66
67		test__fixsfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
68		test__fixsfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
69		test__fixsfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
70		test__fixsfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
	67	try test__fixsfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
	68	try test__fixsfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
	69	try test__fixsfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
	70	try test__fixsfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
71	71
72		test__fixsfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
73		test__fixsfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
74		test__fixsfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
	72	try test__fixsfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
	73	try test__fixsfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
	74	try test__fixsfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
75	75
76		test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
77		test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
	76	try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
	77	try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
78	78
79		test__fixsfsi(math.f32_max, math.maxInt(i32));
	79	try test__fixsfsi(math.f32_max, math.maxInt(i32));
80	80	}

lib/std/special/compiler_rt/fixsfti_test.zig+57-57

...	...	@@ -9,7 +9,7 @@ const math = std.math;
9	9	const testing = std.testing;
10	10	const warn = std.debug.warn;
11	11
12		fn test__fixsfti(a: f32, expected: i128) void {
	12	fn test__fixsfti(a: f32, expected: i128) !void {
13	13	const x = __fixsfti(a);
14	14	//warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", .{a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u128, expected)});
15	15	try testing.expect(x == expected);
...	...	@@ -17,72 +17,72 @@ fn test__fixsfti(a: f32, expected: i128) void {
17	17
18	18	test "fixsfti" {
19	19	//warn("\n", .{});
20		test__fixsfti(-math.f32_max, math.minInt(i128));
	20	try test__fixsfti(-math.f32_max, math.minInt(i128));
21	21
22		test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
23		test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
	22	try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
	23	try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
24	24
25		test__fixsfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
26		test__fixsfti(-0x1.FFFFFFFFFFFFFp+126, -0x80000000000000000000000000000000);
27		test__fixsfti(-0x1.FFFFFFFFFFFFEp+126, -0x80000000000000000000000000000000);
28		test__fixsfti(-0x1.FFFFFF0000000p+126, -0x80000000000000000000000000000000);
29		test__fixsfti(-0x1.FFFFFE0000000p+126, -0x7FFFFF80000000000000000000000000);
30		test__fixsfti(-0x1.FFFFFC0000000p+126, -0x7FFFFF00000000000000000000000000);
	25	try test__fixsfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
	26	try test__fixsfti(-0x1.FFFFFFFFFFFFFp+126, -0x80000000000000000000000000000000);
	27	try test__fixsfti(-0x1.FFFFFFFFFFFFEp+126, -0x80000000000000000000000000000000);
	28	try test__fixsfti(-0x1.FFFFFF0000000p+126, -0x80000000000000000000000000000000);
	29	try test__fixsfti(-0x1.FFFFFE0000000p+126, -0x7FFFFF80000000000000000000000000);
	30	try test__fixsfti(-0x1.FFFFFC0000000p+126, -0x7FFFFF00000000000000000000000000);
31	31
32		test__fixsfti(-0x1.0000000000001p+63, -0x8000000000000000);
33		test__fixsfti(-0x1.0000000000000p+63, -0x8000000000000000);
34		test__fixsfti(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
35		test__fixsfti(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
	32	try test__fixsfti(-0x1.0000000000001p+63, -0x8000000000000000);
	33	try test__fixsfti(-0x1.0000000000000p+63, -0x8000000000000000);
	34	try test__fixsfti(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
	35	try test__fixsfti(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
36	36
37		test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000);
38		test__fixsfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
39		test__fixsfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
	37	try test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000);
	38	try test__fixsfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
	39	try test__fixsfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
40	40
41		test__fixsfti(-0x1.000000p+31, -0x80000000);
42		test__fixsfti(-0x1.FFFFFFp+30, -0x80000000);
43		test__fixsfti(-0x1.FFFFFEp+30, -0x7FFFFF80);
44		test__fixsfti(-0x1.FFFFFCp+30, -0x7FFFFF00);
	41	try test__fixsfti(-0x1.000000p+31, -0x80000000);
	42	try test__fixsfti(-0x1.FFFFFFp+30, -0x80000000);
	43	try test__fixsfti(-0x1.FFFFFEp+30, -0x7FFFFF80);
	44	try test__fixsfti(-0x1.FFFFFCp+30, -0x7FFFFF00);
45	45
46		test__fixsfti(-2.01, -2);
47		test__fixsfti(-2.0, -2);
48		test__fixsfti(-1.99, -1);
49		test__fixsfti(-1.0, -1);
50		test__fixsfti(-0.99, 0);
51		test__fixsfti(-0.5, 0);
52		test__fixsfti(-math.f32_min, 0);
53		test__fixsfti(0.0, 0);
54		test__fixsfti(math.f32_min, 0);
55		test__fixsfti(0.5, 0);
56		test__fixsfti(0.99, 0);
57		test__fixsfti(1.0, 1);
58		test__fixsfti(1.5, 1);
59		test__fixsfti(1.99, 1);
60		test__fixsfti(2.0, 2);
61		test__fixsfti(2.01, 2);
	46	try test__fixsfti(-2.01, -2);
	47	try test__fixsfti(-2.0, -2);
	48	try test__fixsfti(-1.99, -1);
	49	try test__fixsfti(-1.0, -1);
	50	try test__fixsfti(-0.99, 0);
	51	try test__fixsfti(-0.5, 0);
	52	try test__fixsfti(-math.f32_min, 0);
	53	try test__fixsfti(0.0, 0);
	54	try test__fixsfti(math.f32_min, 0);
	55	try test__fixsfti(0.5, 0);
	56	try test__fixsfti(0.99, 0);
	57	try test__fixsfti(1.0, 1);
	58	try test__fixsfti(1.5, 1);
	59	try test__fixsfti(1.99, 1);
	60	try test__fixsfti(2.0, 2);
	61	try test__fixsfti(2.01, 2);
62	62
63		test__fixsfti(0x1.FFFFFCp+30, 0x7FFFFF00);
64		test__fixsfti(0x1.FFFFFEp+30, 0x7FFFFF80);
65		test__fixsfti(0x1.FFFFFFp+30, 0x80000000);
66		test__fixsfti(0x1.000000p+31, 0x80000000);
	63	try test__fixsfti(0x1.FFFFFCp+30, 0x7FFFFF00);
	64	try test__fixsfti(0x1.FFFFFEp+30, 0x7FFFFF80);
	65	try test__fixsfti(0x1.FFFFFFp+30, 0x80000000);
	66	try test__fixsfti(0x1.000000p+31, 0x80000000);
67	67
68		test__fixsfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
69		test__fixsfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
70		test__fixsfti(0x1.FFFFFFp+62, 0x8000000000000000);
	68	try test__fixsfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	69	try test__fixsfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	70	try test__fixsfti(0x1.FFFFFFp+62, 0x8000000000000000);
71	71
72		test__fixsfti(0x1.FFFFFFFFFFFFEp+62, 0x8000000000000000);
73		test__fixsfti(0x1.FFFFFFFFFFFFFp+62, 0x8000000000000000);
74		test__fixsfti(0x1.0000000000000p+63, 0x8000000000000000);
75		test__fixsfti(0x1.0000000000001p+63, 0x8000000000000000);
	72	try test__fixsfti(0x1.FFFFFFFFFFFFEp+62, 0x8000000000000000);
	73	try test__fixsfti(0x1.FFFFFFFFFFFFFp+62, 0x8000000000000000);
	74	try test__fixsfti(0x1.0000000000000p+63, 0x8000000000000000);
	75	try test__fixsfti(0x1.0000000000001p+63, 0x8000000000000000);
76	76
77		test__fixsfti(0x1.FFFFFC0000000p+126, 0x7FFFFF00000000000000000000000000);
78		test__fixsfti(0x1.FFFFFE0000000p+126, 0x7FFFFF80000000000000000000000000);
79		test__fixsfti(0x1.FFFFFF0000000p+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
80		test__fixsfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
81		test__fixsfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
82		test__fixsfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	77	try test__fixsfti(0x1.FFFFFC0000000p+126, 0x7FFFFF00000000000000000000000000);
	78	try test__fixsfti(0x1.FFFFFE0000000p+126, 0x7FFFFF80000000000000000000000000);
	79	try test__fixsfti(0x1.FFFFFF0000000p+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	80	try test__fixsfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	81	try test__fixsfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	82	try test__fixsfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
83	83
84		test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
85		test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
	84	try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	85	try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
86	86
87		test__fixsfti(math.f32_max, math.maxInt(i128));
	87	try test__fixsfti(math.f32_max, math.maxInt(i128));
88	88	}

lib/std/special/compiler_rt/fixtfdi_test.zig+49-49

...	...	@@ -9,7 +9,7 @@ const math = std.math;
9	9	const testing = std.testing;
10	10	const warn = std.debug.warn;
11	11
12		fn test__fixtfdi(a: f128, expected: i64) void {
	12	fn test__fixtfdi(a: f128, expected: i64) !void {
13	13	const x = __fixtfdi(a);
14	14	//warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u64, expected)});
15	15	try testing.expect(x == expected);
...	...	@@ -17,64 +17,64 @@ fn test__fixtfdi(a: f128, expected: i64) void {
17	17
18	18	test "fixtfdi" {
19	19	//warn("\n", .{});
20		test__fixtfdi(-math.f128_max, math.minInt(i64));
	20	try test__fixtfdi(-math.f128_max, math.minInt(i64));
21	21
22		test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
23		test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
	22	try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
	23	try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
24	24
25		test__fixtfdi(-0x1.0000000000000p+127, -0x8000000000000000);
26		test__fixtfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
27		test__fixtfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
	25	try test__fixtfdi(-0x1.0000000000000p+127, -0x8000000000000000);
	26	try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
	27	try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
28	28
29		test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000);
30		test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000);
31		test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
32		test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
	29	try test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000);
	30	try test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000);
	31	try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
	32	try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
33	33
34		test__fixtfdi(-0x1.FFFFFEp+62, -0x7FFFFF8000000000);
35		test__fixtfdi(-0x1.FFFFFCp+62, -0x7FFFFF0000000000);
	34	try test__fixtfdi(-0x1.FFFFFEp+62, -0x7FFFFF8000000000);
	35	try test__fixtfdi(-0x1.FFFFFCp+62, -0x7FFFFF0000000000);
36	36
37		test__fixtfdi(-0x1.000000p+31, -0x80000000);
38		test__fixtfdi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
39		test__fixtfdi(-0x1.FFFFFEp+30, -0x7FFFFF80);
40		test__fixtfdi(-0x1.FFFFFCp+30, -0x7FFFFF00);
	37	try test__fixtfdi(-0x1.000000p+31, -0x80000000);
	38	try test__fixtfdi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
	39	try test__fixtfdi(-0x1.FFFFFEp+30, -0x7FFFFF80);
	40	try test__fixtfdi(-0x1.FFFFFCp+30, -0x7FFFFF00);
41	41
42		test__fixtfdi(-2.01, -2);
43		test__fixtfdi(-2.0, -2);
44		test__fixtfdi(-1.99, -1);
45		test__fixtfdi(-1.0, -1);
46		test__fixtfdi(-0.99, 0);
47		test__fixtfdi(-0.5, 0);
48		test__fixtfdi(-math.f64_min, 0);
49		test__fixtfdi(0.0, 0);
50		test__fixtfdi(math.f64_min, 0);
51		test__fixtfdi(0.5, 0);
52		test__fixtfdi(0.99, 0);
53		test__fixtfdi(1.0, 1);
54		test__fixtfdi(1.5, 1);
55		test__fixtfdi(1.99, 1);
56		test__fixtfdi(2.0, 2);
57		test__fixtfdi(2.01, 2);
	42	try test__fixtfdi(-2.01, -2);
	43	try test__fixtfdi(-2.0, -2);
	44	try test__fixtfdi(-1.99, -1);
	45	try test__fixtfdi(-1.0, -1);
	46	try test__fixtfdi(-0.99, 0);
	47	try test__fixtfdi(-0.5, 0);
	48	try test__fixtfdi(-math.f64_min, 0);
	49	try test__fixtfdi(0.0, 0);
	50	try test__fixtfdi(math.f64_min, 0);
	51	try test__fixtfdi(0.5, 0);
	52	try test__fixtfdi(0.99, 0);
	53	try test__fixtfdi(1.0, 1);
	54	try test__fixtfdi(1.5, 1);
	55	try test__fixtfdi(1.99, 1);
	56	try test__fixtfdi(2.0, 2);
	57	try test__fixtfdi(2.01, 2);
58	58
59		test__fixtfdi(0x1.FFFFFCp+30, 0x7FFFFF00);
60		test__fixtfdi(0x1.FFFFFEp+30, 0x7FFFFF80);
61		test__fixtfdi(0x1.FFFFFFp+30, 0x7FFFFFC0);
62		test__fixtfdi(0x1.000000p+31, 0x80000000);
	59	try test__fixtfdi(0x1.FFFFFCp+30, 0x7FFFFF00);
	60	try test__fixtfdi(0x1.FFFFFEp+30, 0x7FFFFF80);
	61	try test__fixtfdi(0x1.FFFFFFp+30, 0x7FFFFFC0);
	62	try test__fixtfdi(0x1.000000p+31, 0x80000000);
63	63
64		test__fixtfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
65		test__fixtfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	64	try test__fixtfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	65	try test__fixtfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
66	66
67		test__fixtfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
68		test__fixtfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
69		test__fixtfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
70		test__fixtfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
	67	try test__fixtfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	68	try test__fixtfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	69	try test__fixtfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
	70	try test__fixtfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
71	71
72		test__fixtfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
73		test__fixtfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
74		test__fixtfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
	72	try test__fixtfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
	73	try test__fixtfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
	74	try test__fixtfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
75	75
76		test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
77		test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
	76	try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
	77	try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
78	78
79		test__fixtfdi(math.f128_max, math.maxInt(i64));
	79	try test__fixtfdi(math.f128_max, math.maxInt(i64));
80	80	}

lib/std/special/compiler_rt/fixtfsi_test.zig+49-49

...	...	@@ -9,7 +9,7 @@ const math = std.math;
9	9	const testing = std.testing;
10	10	const warn = std.debug.warn;
11	11
12		fn test__fixtfsi(a: f128, expected: i32) void {
	12	fn test__fixtfsi(a: f128, expected: i32) !void {
13	13	const x = __fixtfsi(a);
14	14	//warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u32, expected)});
15	15	try testing.expect(x == expected);
...	...	@@ -17,64 +17,64 @@ fn test__fixtfsi(a: f128, expected: i32) void {
17	17
18	18	test "fixtfsi" {
19	19	//warn("\n", .{});
20		test__fixtfsi(-math.f128_max, math.minInt(i32));
	20	try test__fixtfsi(-math.f128_max, math.minInt(i32));
21	21
22		test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
23		test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
	22	try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
	23	try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
24	24
25		test__fixtfsi(-0x1.0000000000000p+127, -0x80000000);
26		test__fixtfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
27		test__fixtfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
	25	try test__fixtfsi(-0x1.0000000000000p+127, -0x80000000);
	26	try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
	27	try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
28	28
29		test__fixtfsi(-0x1.0000000000001p+63, -0x80000000);
30		test__fixtfsi(-0x1.0000000000000p+63, -0x80000000);
31		test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
32		test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
	29	try test__fixtfsi(-0x1.0000000000001p+63, -0x80000000);
	30	try test__fixtfsi(-0x1.0000000000000p+63, -0x80000000);
	31	try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
	32	try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
33	33
34		test__fixtfsi(-0x1.FFFFFEp+62, -0x80000000);
35		test__fixtfsi(-0x1.FFFFFCp+62, -0x80000000);
	34	try test__fixtfsi(-0x1.FFFFFEp+62, -0x80000000);
	35	try test__fixtfsi(-0x1.FFFFFCp+62, -0x80000000);
36	36
37		test__fixtfsi(-0x1.000000p+31, -0x80000000);
38		test__fixtfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
39		test__fixtfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
40		test__fixtfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
	37	try test__fixtfsi(-0x1.000000p+31, -0x80000000);
	38	try test__fixtfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
	39	try test__fixtfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
	40	try test__fixtfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
41	41
42		test__fixtfsi(-2.01, -2);
43		test__fixtfsi(-2.0, -2);
44		test__fixtfsi(-1.99, -1);
45		test__fixtfsi(-1.0, -1);
46		test__fixtfsi(-0.99, 0);
47		test__fixtfsi(-0.5, 0);
48		test__fixtfsi(-math.f32_min, 0);
49		test__fixtfsi(0.0, 0);
50		test__fixtfsi(math.f32_min, 0);
51		test__fixtfsi(0.5, 0);
52		test__fixtfsi(0.99, 0);
53		test__fixtfsi(1.0, 1);
54		test__fixtfsi(1.5, 1);
55		test__fixtfsi(1.99, 1);
56		test__fixtfsi(2.0, 2);
57		test__fixtfsi(2.01, 2);
	42	try test__fixtfsi(-2.01, -2);
	43	try test__fixtfsi(-2.0, -2);
	44	try test__fixtfsi(-1.99, -1);
	45	try test__fixtfsi(-1.0, -1);
	46	try test__fixtfsi(-0.99, 0);
	47	try test__fixtfsi(-0.5, 0);
	48	try test__fixtfsi(-math.f32_min, 0);
	49	try test__fixtfsi(0.0, 0);
	50	try test__fixtfsi(math.f32_min, 0);
	51	try test__fixtfsi(0.5, 0);
	52	try test__fixtfsi(0.99, 0);
	53	try test__fixtfsi(1.0, 1);
	54	try test__fixtfsi(1.5, 1);
	55	try test__fixtfsi(1.99, 1);
	56	try test__fixtfsi(2.0, 2);
	57	try test__fixtfsi(2.01, 2);
58	58
59		test__fixtfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
60		test__fixtfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
61		test__fixtfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
62		test__fixtfsi(0x1.000000p+31, 0x7FFFFFFF);
	59	try test__fixtfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
	60	try test__fixtfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
	61	try test__fixtfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
	62	try test__fixtfsi(0x1.000000p+31, 0x7FFFFFFF);
63	63
64		test__fixtfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
65		test__fixtfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
	64	try test__fixtfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
	65	try test__fixtfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
66	66
67		test__fixtfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
68		test__fixtfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
69		test__fixtfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
70		test__fixtfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
	67	try test__fixtfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
	68	try test__fixtfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
	69	try test__fixtfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
	70	try test__fixtfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
71	71
72		test__fixtfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
73		test__fixtfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
74		test__fixtfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
	72	try test__fixtfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
	73	try test__fixtfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
	74	try test__fixtfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
75	75
76		test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
77		test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
	76	try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
	77	try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
78	78
79		test__fixtfsi(math.f128_max, math.maxInt(i32));
	79	try test__fixtfsi(math.f128_max, math.maxInt(i32));
80	80	}

lib/std/special/compiler_rt/fixtfti_test.zig+41-41

...	...	@@ -9,7 +9,7 @@ const math = std.math;
9	9	const testing = std.testing;
10	10	const warn = std.debug.warn;
11	11
12		fn test__fixtfti(a: f128, expected: i128) void {
	12	fn test__fixtfti(a: f128, expected: i128) !void {
13	13	const x = __fixtfti(a);
14	14	//warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", .{a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u128, expected)});
15	15	try testing.expect(x == expected);
...	...	@@ -17,54 +17,54 @@ fn test__fixtfti(a: f128, expected: i128) void {
17	17
18	18	test "fixtfti" {
19	19	//warn("\n", .{});
20		test__fixtfti(-math.f128_max, math.minInt(i128));
	20	try test__fixtfti(-math.f128_max, math.minInt(i128));
21	21
22		test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
23		test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
	22	try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
	23	try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
24	24
25		test__fixtfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
26		test__fixtfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
27		test__fixtfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
	25	try test__fixtfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
	26	try test__fixtfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
	27	try test__fixtfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
28	28
29		test__fixtfti(-0x1.0000000000001p+63, -0x8000000000000800);
30		test__fixtfti(-0x1.0000000000000p+63, -0x8000000000000000);
31		test__fixtfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
32		test__fixtfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
	29	try test__fixtfti(-0x1.0000000000001p+63, -0x8000000000000800);
	30	try test__fixtfti(-0x1.0000000000000p+63, -0x8000000000000000);
	31	try test__fixtfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
	32	try test__fixtfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
33	33
34		test__fixtfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
35		test__fixtfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
	34	try test__fixtfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
	35	try test__fixtfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
36	36
37		test__fixtfti(-2.01, -2);
38		test__fixtfti(-2.0, -2);
39		test__fixtfti(-1.99, -1);
40		test__fixtfti(-1.0, -1);
41		test__fixtfti(-0.99, 0);
42		test__fixtfti(-0.5, 0);
43		test__fixtfti(-math.f128_min, 0);
44		test__fixtfti(0.0, 0);
45		test__fixtfti(math.f128_min, 0);
46		test__fixtfti(0.5, 0);
47		test__fixtfti(0.99, 0);
48		test__fixtfti(1.0, 1);
49		test__fixtfti(1.5, 1);
50		test__fixtfti(1.99, 1);
51		test__fixtfti(2.0, 2);
52		test__fixtfti(2.01, 2);
	37	try test__fixtfti(-2.01, -2);
	38	try test__fixtfti(-2.0, -2);
	39	try test__fixtfti(-1.99, -1);
	40	try test__fixtfti(-1.0, -1);
	41	try test__fixtfti(-0.99, 0);
	42	try test__fixtfti(-0.5, 0);
	43	try test__fixtfti(-math.f128_min, 0);
	44	try test__fixtfti(0.0, 0);
	45	try test__fixtfti(math.f128_min, 0);
	46	try test__fixtfti(0.5, 0);
	47	try test__fixtfti(0.99, 0);
	48	try test__fixtfti(1.0, 1);
	49	try test__fixtfti(1.5, 1);
	50	try test__fixtfti(1.99, 1);
	51	try test__fixtfti(2.0, 2);
	52	try test__fixtfti(2.01, 2);
53	53
54		test__fixtfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
55		test__fixtfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	54	try test__fixtfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	55	try test__fixtfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
56	56
57		test__fixtfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
58		test__fixtfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
59		test__fixtfti(0x1.0000000000000p+63, 0x8000000000000000);
60		test__fixtfti(0x1.0000000000001p+63, 0x8000000000000800);
	57	try test__fixtfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	58	try test__fixtfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	59	try test__fixtfti(0x1.0000000000000p+63, 0x8000000000000000);
	60	try test__fixtfti(0x1.0000000000001p+63, 0x8000000000000800);
61	61
62		test__fixtfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
63		test__fixtfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
64		test__fixtfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	62	try test__fixtfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
	63	try test__fixtfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
	64	try test__fixtfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
65	65
66		test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
67		test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
	66	try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	67	try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
68	68
69		test__fixtfti(math.f128_max, math.maxInt(i128));
	69	try test__fixtfti(math.f128_max, math.maxInt(i128));
70	70	}

lib/std/special/compiler_rt/fixunsdfdi_test.zig+23-23

...	...	@@ -6,7 +6,7 @@
6	6	const __fixunsdfdi = @import("fixunsdfdi.zig").__fixunsdfdi;
7	7	const testing = @import("std").testing;
8	8
9		fn test__fixunsdfdi(a: f64, expected: u64) void {
	9	fn test__fixunsdfdi(a: f64, expected: u64) !void {
10	10	const x = __fixunsdfdi(a);
11	11	try testing.expect(x == expected);
12	12	}
...	...	@@ -15,30 +15,30 @@ test "fixunsdfdi" {
15	15	//test__fixunsdfdi(0.0, 0);
16	16	//test__fixunsdfdi(0.5, 0);
17	17	//test__fixunsdfdi(0.99, 0);
18		test__fixunsdfdi(1.0, 1);
19		test__fixunsdfdi(1.5, 1);
20		test__fixunsdfdi(1.99, 1);
21		test__fixunsdfdi(2.0, 2);
22		test__fixunsdfdi(2.01, 2);
23		test__fixunsdfdi(-0.5, 0);
24		test__fixunsdfdi(-0.99, 0);
25		test__fixunsdfdi(-1.0, 0);
26		test__fixunsdfdi(-1.5, 0);
27		test__fixunsdfdi(-1.99, 0);
28		test__fixunsdfdi(-2.0, 0);
29		test__fixunsdfdi(-2.01, 0);
	18	try test__fixunsdfdi(1.0, 1);
	19	try test__fixunsdfdi(1.5, 1);
	20	try test__fixunsdfdi(1.99, 1);
	21	try test__fixunsdfdi(2.0, 2);
	22	try test__fixunsdfdi(2.01, 2);
	23	try test__fixunsdfdi(-0.5, 0);
	24	try test__fixunsdfdi(-0.99, 0);
	25	try test__fixunsdfdi(-1.0, 0);
	26	try test__fixunsdfdi(-1.5, 0);
	27	try test__fixunsdfdi(-1.99, 0);
	28	try test__fixunsdfdi(-2.0, 0);
	29	try test__fixunsdfdi(-2.01, 0);
30	30
31		test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
32		test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	31	try test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	32	try test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
33	33
34		test__fixunsdfdi(-0x1.FFFFFEp+62, 0);
35		test__fixunsdfdi(-0x1.FFFFFCp+62, 0);
	34	try test__fixunsdfdi(-0x1.FFFFFEp+62, 0);
	35	try test__fixunsdfdi(-0x1.FFFFFCp+62, 0);
36	36
37		test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
38		test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000);
39		test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
40		test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	37	try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
	38	try test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000);
	39	try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	40	try test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
41	41
42		test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
43		test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
	42	try test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
	43	try test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
44	44	}

lib/std/special/compiler_rt/fixunsdfsi_test.zig+26-26

...	...	@@ -6,39 +6,39 @@
6	6	const __fixunsdfsi = @import("fixunsdfsi.zig").__fixunsdfsi;
7	7	const testing = @import("std").testing;
8	8
9		fn test__fixunsdfsi(a: f64, expected: u32) void {
	9	fn test__fixunsdfsi(a: f64, expected: u32) !void {
10	10	const x = __fixunsdfsi(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "fixunsdfsi" {
15		test__fixunsdfsi(0.0, 0);
	15	try test__fixunsdfsi(0.0, 0);
16	16
17		test__fixunsdfsi(0.5, 0);
18		test__fixunsdfsi(0.99, 0);
19		test__fixunsdfsi(1.0, 1);
20		test__fixunsdfsi(1.5, 1);
21		test__fixunsdfsi(1.99, 1);
22		test__fixunsdfsi(2.0, 2);
23		test__fixunsdfsi(2.01, 2);
24		test__fixunsdfsi(-0.5, 0);
25		test__fixunsdfsi(-0.99, 0);
26		test__fixunsdfsi(-1.0, 0);
27		test__fixunsdfsi(-1.5, 0);
28		test__fixunsdfsi(-1.99, 0);
29		test__fixunsdfsi(-2.0, 0);
30		test__fixunsdfsi(-2.01, 0);
	17	try test__fixunsdfsi(0.5, 0);
	18	try test__fixunsdfsi(0.99, 0);
	19	try test__fixunsdfsi(1.0, 1);
	20	try test__fixunsdfsi(1.5, 1);
	21	try test__fixunsdfsi(1.99, 1);
	22	try test__fixunsdfsi(2.0, 2);
	23	try test__fixunsdfsi(2.01, 2);
	24	try test__fixunsdfsi(-0.5, 0);
	25	try test__fixunsdfsi(-0.99, 0);
	26	try test__fixunsdfsi(-1.0, 0);
	27	try test__fixunsdfsi(-1.5, 0);
	28	try test__fixunsdfsi(-1.99, 0);
	29	try test__fixunsdfsi(-2.0, 0);
	30	try test__fixunsdfsi(-2.01, 0);
31	31
32		test__fixunsdfsi(0x1.000000p+31, 0x80000000);
33		test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF);
34		test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
35		test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
36		test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
	32	try test__fixunsdfsi(0x1.000000p+31, 0x80000000);
	33	try test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF);
	34	try test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
	35	try test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
	36	try test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
37	37
38		test__fixunsdfsi(-0x1.FFFFFEp+30, 0);
39		test__fixunsdfsi(-0x1.FFFFFCp+30, 0);
	38	try test__fixunsdfsi(-0x1.FFFFFEp+30, 0);
	39	try test__fixunsdfsi(-0x1.FFFFFCp+30, 0);
40	40
41		test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF);
42		test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF);
43		test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE);
	41	try test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF);
	42	try test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF);
	43	try test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE);
44	44	}

lib/std/special/compiler_rt/fixunsdfti_test.zig+37-37

...	...	@@ -6,46 +6,46 @@
6	6	const __fixunsdfti = @import("fixunsdfti.zig").__fixunsdfti;
7	7	const testing = @import("std").testing;
8	8
9		fn test__fixunsdfti(a: f64, expected: u128) void {
	9	fn test__fixunsdfti(a: f64, expected: u128) !void {
10	10	const x = __fixunsdfti(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "fixunsdfti" {
15		test__fixunsdfti(0.0, 0);
16
17		test__fixunsdfti(0.5, 0);
18		test__fixunsdfti(0.99, 0);
19		test__fixunsdfti(1.0, 1);
20		test__fixunsdfti(1.5, 1);
21		test__fixunsdfti(1.99, 1);
22		test__fixunsdfti(2.0, 2);
23		test__fixunsdfti(2.01, 2);
24		test__fixunsdfti(-0.5, 0);
25		test__fixunsdfti(-0.99, 0);
26		test__fixunsdfti(-1.0, 0);
27		test__fixunsdfti(-1.5, 0);
28		test__fixunsdfti(-1.99, 0);
29		test__fixunsdfti(-2.0, 0);
30		test__fixunsdfti(-2.01, 0);
31
32		test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
33		test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
34
35		test__fixunsdfti(-0x1.FFFFFEp+62, 0);
36		test__fixunsdfti(-0x1.FFFFFCp+62, 0);
37
38		test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
39		test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000);
40		test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
41		test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
42
43		test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000);
44		test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000);
45		test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
46		test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
47		test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
48
49		test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0);
50		test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0);
	15	try test__fixunsdfti(0.0, 0);
	16
	17	try test__fixunsdfti(0.5, 0);
	18	try test__fixunsdfti(0.99, 0);
	19	try test__fixunsdfti(1.0, 1);
	20	try test__fixunsdfti(1.5, 1);
	21	try test__fixunsdfti(1.99, 1);
	22	try test__fixunsdfti(2.0, 2);
	23	try test__fixunsdfti(2.01, 2);
	24	try test__fixunsdfti(-0.5, 0);
	25	try test__fixunsdfti(-0.99, 0);
	26	try test__fixunsdfti(-1.0, 0);
	27	try test__fixunsdfti(-1.5, 0);
	28	try test__fixunsdfti(-1.99, 0);
	29	try test__fixunsdfti(-2.0, 0);
	30	try test__fixunsdfti(-2.01, 0);
	31
	32	try test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	33	try test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	34
	35	try test__fixunsdfti(-0x1.FFFFFEp+62, 0);
	36	try test__fixunsdfti(-0x1.FFFFFCp+62, 0);
	37
	38	try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
	39	try test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000);
	40	try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	41	try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	42
	43	try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000);
	44	try test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000);
	45	try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
	46	try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
	47	try test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	48
	49	try test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0);
	50	try test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0);
51	51	}

lib/std/special/compiler_rt/fixunssfdi_test.zig+22-22

...	...	@@ -6,35 +6,35 @@
6	6	const __fixunssfdi = @import("fixunssfdi.zig").__fixunssfdi;
7	7	const testing = @import("std").testing;
8	8
9		fn test__fixunssfdi(a: f32, expected: u64) void {
	9	fn test__fixunssfdi(a: f32, expected: u64) !void {
10	10	const x = __fixunssfdi(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "fixunssfdi" {
15		test__fixunssfdi(0.0, 0);
	15	try test__fixunssfdi(0.0, 0);
16	16
17		test__fixunssfdi(0.5, 0);
18		test__fixunssfdi(0.99, 0);
19		test__fixunssfdi(1.0, 1);
20		test__fixunssfdi(1.5, 1);
21		test__fixunssfdi(1.99, 1);
22		test__fixunssfdi(2.0, 2);
23		test__fixunssfdi(2.01, 2);
24		test__fixunssfdi(-0.5, 0);
25		test__fixunssfdi(-0.99, 0);
	17	try test__fixunssfdi(0.5, 0);
	18	try test__fixunssfdi(0.99, 0);
	19	try test__fixunssfdi(1.0, 1);
	20	try test__fixunssfdi(1.5, 1);
	21	try test__fixunssfdi(1.99, 1);
	22	try test__fixunssfdi(2.0, 2);
	23	try test__fixunssfdi(2.01, 2);
	24	try test__fixunssfdi(-0.5, 0);
	25	try test__fixunssfdi(-0.99, 0);
26	26
27		test__fixunssfdi(-1.0, 0);
28		test__fixunssfdi(-1.5, 0);
29		test__fixunssfdi(-1.99, 0);
30		test__fixunssfdi(-2.0, 0);
31		test__fixunssfdi(-2.01, 0);
	27	try test__fixunssfdi(-1.0, 0);
	28	try test__fixunssfdi(-1.5, 0);
	29	try test__fixunssfdi(-1.99, 0);
	30	try test__fixunssfdi(-2.0, 0);
	31	try test__fixunssfdi(-2.01, 0);
32	32
33		test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
34		test__fixunssfdi(0x1.000000p+63, 0x8000000000000000);
35		test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
36		test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	33	try test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
	34	try test__fixunssfdi(0x1.000000p+63, 0x8000000000000000);
	35	try test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	36	try test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
37	37
38		test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000);
39		test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000);
	38	try test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000);
	39	try test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000);
40	40	}

lib/std/special/compiler_rt/fixunssfsi_test.zig+23-23

...	...	@@ -6,36 +6,36 @@
6	6	const __fixunssfsi = @import("fixunssfsi.zig").__fixunssfsi;
7	7	const testing = @import("std").testing;
8	8
9		fn test__fixunssfsi(a: f32, expected: u32) void {
	9	fn test__fixunssfsi(a: f32, expected: u32) !void {
10	10	const x = __fixunssfsi(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "fixunssfsi" {
15		test__fixunssfsi(0.0, 0);
	15	try test__fixunssfsi(0.0, 0);
16	16
17		test__fixunssfsi(0.5, 0);
18		test__fixunssfsi(0.99, 0);
19		test__fixunssfsi(1.0, 1);
20		test__fixunssfsi(1.5, 1);
21		test__fixunssfsi(1.99, 1);
22		test__fixunssfsi(2.0, 2);
23		test__fixunssfsi(2.01, 2);
24		test__fixunssfsi(-0.5, 0);
25		test__fixunssfsi(-0.99, 0);
	17	try test__fixunssfsi(0.5, 0);
	18	try test__fixunssfsi(0.99, 0);
	19	try test__fixunssfsi(1.0, 1);
	20	try test__fixunssfsi(1.5, 1);
	21	try test__fixunssfsi(1.99, 1);
	22	try test__fixunssfsi(2.0, 2);
	23	try test__fixunssfsi(2.01, 2);
	24	try test__fixunssfsi(-0.5, 0);
	25	try test__fixunssfsi(-0.99, 0);
26	26
27		test__fixunssfsi(-1.0, 0);
28		test__fixunssfsi(-1.5, 0);
29		test__fixunssfsi(-1.99, 0);
30		test__fixunssfsi(-2.0, 0);
31		test__fixunssfsi(-2.01, 0);
	27	try test__fixunssfsi(-1.0, 0);
	28	try test__fixunssfsi(-1.5, 0);
	29	try test__fixunssfsi(-1.99, 0);
	30	try test__fixunssfsi(-2.0, 0);
	31	try test__fixunssfsi(-2.01, 0);
32	32
33		test__fixunssfsi(0x1.000000p+31, 0x80000000);
34		test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF);
35		test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
36		test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
37		test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
	33	try test__fixunssfsi(0x1.000000p+31, 0x80000000);
	34	try test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF);
	35	try test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
	36	try test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
	37	try test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
38	38
39		test__fixunssfsi(-0x1.FFFFFEp+30, 0);
40		test__fixunssfsi(-0x1.FFFFFCp+30, 0);
	39	try test__fixunssfsi(-0x1.FFFFFEp+30, 0);
	40	try test__fixunssfsi(-0x1.FFFFFCp+30, 0);
41	41	}

lib/std/special/compiler_rt/fixunssfti_test.zig+28-28

...	...	@@ -6,41 +6,41 @@
6	6	const __fixunssfti = @import("fixunssfti.zig").__fixunssfti;
7	7	const testing = @import("std").testing;
8	8
9		fn test__fixunssfti(a: f32, expected: u128) void {
	9	fn test__fixunssfti(a: f32, expected: u128) !void {
10	10	const x = __fixunssfti(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "fixunssfti" {
15		test__fixunssfti(0.0, 0);
	15	try test__fixunssfti(0.0, 0);
16	16
17		test__fixunssfti(0.5, 0);
18		test__fixunssfti(0.99, 0);
19		test__fixunssfti(1.0, 1);
20		test__fixunssfti(1.5, 1);
21		test__fixunssfti(1.99, 1);
22		test__fixunssfti(2.0, 2);
23		test__fixunssfti(2.01, 2);
24		test__fixunssfti(-0.5, 0);
25		test__fixunssfti(-0.99, 0);
	17	try test__fixunssfti(0.5, 0);
	18	try test__fixunssfti(0.99, 0);
	19	try test__fixunssfti(1.0, 1);
	20	try test__fixunssfti(1.5, 1);
	21	try test__fixunssfti(1.99, 1);
	22	try test__fixunssfti(2.0, 2);
	23	try test__fixunssfti(2.01, 2);
	24	try test__fixunssfti(-0.5, 0);
	25	try test__fixunssfti(-0.99, 0);
26	26
27		test__fixunssfti(-1.0, 0);
28		test__fixunssfti(-1.5, 0);
29		test__fixunssfti(-1.99, 0);
30		test__fixunssfti(-2.0, 0);
31		test__fixunssfti(-2.01, 0);
	27	try test__fixunssfti(-1.0, 0);
	28	try test__fixunssfti(-1.5, 0);
	29	try test__fixunssfti(-1.99, 0);
	30	try test__fixunssfti(-2.0, 0);
	31	try test__fixunssfti(-2.01, 0);
32	32
33		test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
34		test__fixunssfti(0x1.000000p+63, 0x8000000000000000);
35		test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
36		test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
37		test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000);
38		test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000);
39		test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000);
40		test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000);
	33	try test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
	34	try test__fixunssfti(0x1.000000p+63, 0x8000000000000000);
	35	try test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	36	try test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	37	try test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000);
	38	try test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000);
	39	try test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000);
	40	try test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000);
41	41
42		test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000);
43		test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000);
44		test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000);
45		test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000);
	42	try test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000);
	43	try test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000);
	44	try test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000);
	45	try test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000);
46	46	}

lib/std/special/compiler_rt/fixunstfdi_test.zig+40-40

...	...	@@ -6,49 +6,49 @@
6	6	const __fixunstfdi = @import("fixunstfdi.zig").__fixunstfdi;
7	7	const testing = @import("std").testing;
8	8
9		fn test__fixunstfdi(a: f128, expected: u64) void {
	9	fn test__fixunstfdi(a: f128, expected: u64) !void {
10	10	const x = __fixunstfdi(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "fixunstfdi" {
15		test__fixunstfdi(0.0, 0);
16
17		test__fixunstfdi(0.5, 0);
18		test__fixunstfdi(0.99, 0);
19		test__fixunstfdi(1.0, 1);
20		test__fixunstfdi(1.5, 1);
21		test__fixunstfdi(1.99, 1);
22		test__fixunstfdi(2.0, 2);
23		test__fixunstfdi(2.01, 2);
24		test__fixunstfdi(-0.5, 0);
25		test__fixunstfdi(-0.99, 0);
26		test__fixunstfdi(-1.0, 0);
27		test__fixunstfdi(-1.5, 0);
28		test__fixunstfdi(-1.99, 0);
29		test__fixunstfdi(-2.0, 0);
30		test__fixunstfdi(-2.01, 0);
31
32		test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
33		test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
34
35		test__fixunstfdi(-0x1.FFFFFEp+62, 0);
36		test__fixunstfdi(-0x1.FFFFFCp+62, 0);
37
38		test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
39		test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
40
41		test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
42		test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
43
44		test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF);
45		test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001);
46		test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000);
47		test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF);
48		test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE);
49		test__fixunstfdi(0x1.p+64, 0xFFFFFFFFFFFFFFFF);
50
51		test__fixunstfdi(-0x1.0000000000000000p+63, 0);
52		test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0);
53		test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0);
	15	try test__fixunstfdi(0.0, 0);
	16
	17	try test__fixunstfdi(0.5, 0);
	18	try test__fixunstfdi(0.99, 0);
	19	try test__fixunstfdi(1.0, 1);
	20	try test__fixunstfdi(1.5, 1);
	21	try test__fixunstfdi(1.99, 1);
	22	try test__fixunstfdi(2.0, 2);
	23	try test__fixunstfdi(2.01, 2);
	24	try test__fixunstfdi(-0.5, 0);
	25	try test__fixunstfdi(-0.99, 0);
	26	try test__fixunstfdi(-1.0, 0);
	27	try test__fixunstfdi(-1.5, 0);
	28	try test__fixunstfdi(-1.99, 0);
	29	try test__fixunstfdi(-2.0, 0);
	30	try test__fixunstfdi(-2.01, 0);
	31
	32	try test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	33	try test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	34
	35	try test__fixunstfdi(-0x1.FFFFFEp+62, 0);
	36	try test__fixunstfdi(-0x1.FFFFFCp+62, 0);
	37
	38	try test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	39	try test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	40
	41	try test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
	42	try test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
	43
	44	try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF);
	45	try test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001);
	46	try test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000);
	47	try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF);
	48	try test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE);
	49	try test__fixunstfdi(0x1.p+64, 0xFFFFFFFFFFFFFFFF);
	50
	51	try test__fixunstfdi(-0x1.0000000000000000p+63, 0);
	52	try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0);
	53	try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0);
54	54	}

lib/std/special/compiler_rt/fixunstfsi_test.zig+10-10

...	...	@@ -6,7 +6,7 @@
6	6	const __fixunstfsi = @import("fixunstfsi.zig").__fixunstfsi;
7	7	const testing = @import("std").testing;
8	8
9		fn test__fixunstfsi(a: f128, expected: u32) void {
	9	fn test__fixunstfsi(a: f128, expected: u32) !void {
10	10	const x = __fixunstfsi(a);
11	11	try testing.expect(x == expected);
12	12	}
...	...	@@ -14,14 +14,14 @@ fn test__fixunstfsi(a: f128, expected: u32) void {
14	14	const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000));
15	15
16	16	test "fixunstfsi" {
17		test__fixunstfsi(inf128, 0xffffffff);
18		test__fixunstfsi(0, 0x0);
19		test__fixunstfsi(0x1.23456789abcdefp+5, 0x24);
20		test__fixunstfsi(0x1.23456789abcdefp-3, 0x0);
21		test__fixunstfsi(0x1.23456789abcdefp+20, 0x123456);
22		test__fixunstfsi(0x1.23456789abcdefp+40, 0xffffffff);
23		test__fixunstfsi(0x1.23456789abcdefp+256, 0xffffffff);
24		test__fixunstfsi(-0x1.23456789abcdefp+3, 0x0);
	17	try test__fixunstfsi(inf128, 0xffffffff);
	18	try test__fixunstfsi(0, 0x0);
	19	try test__fixunstfsi(0x1.23456789abcdefp+5, 0x24);
	20	try test__fixunstfsi(0x1.23456789abcdefp-3, 0x0);
	21	try test__fixunstfsi(0x1.23456789abcdefp+20, 0x123456);
	22	try test__fixunstfsi(0x1.23456789abcdefp+40, 0xffffffff);
	23	try test__fixunstfsi(0x1.23456789abcdefp+256, 0xffffffff);
	24	try test__fixunstfsi(-0x1.23456789abcdefp+3, 0x0);
25	25
26		test__fixunstfsi(0x1.p+32, 0xFFFFFFFF);
	26	try test__fixunstfsi(0x1.p+32, 0xFFFFFFFF);
27	27	}

lib/std/special/compiler_rt/fixunstfti_test.zig+17-17

...	...	@@ -6,7 +6,7 @@
6	6	const __fixunstfti = @import("fixunstfti.zig").__fixunstfti;
7	7	const testing = @import("std").testing;
8	8
9		fn test__fixunstfti(a: f128, expected: u128) void {
	9	fn test__fixunstfti(a: f128, expected: u128) !void {
10	10	const x = __fixunstfti(a);
11	11	try testing.expect(x == expected);
12	12	}
...	...	@@ -14,24 +14,24 @@ fn test__fixunstfti(a: f128, expected: u128) void {
14	14	const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000));
15	15
16	16	test "fixunstfti" {
17		test__fixunstfti(inf128, 0xffffffffffffffffffffffffffffffff);
	17	try test__fixunstfti(inf128, 0xffffffffffffffffffffffffffffffff);
18	18
19		test__fixunstfti(0.0, 0);
	19	try test__fixunstfti(0.0, 0);
20	20
21		test__fixunstfti(0.5, 0);
22		test__fixunstfti(0.99, 0);
23		test__fixunstfti(1.0, 1);
24		test__fixunstfti(1.5, 1);
25		test__fixunstfti(1.99, 1);
26		test__fixunstfti(2.0, 2);
27		test__fixunstfti(2.01, 2);
28		test__fixunstfti(-0.01, 0);
29		test__fixunstfti(-0.99, 0);
	21	try test__fixunstfti(0.5, 0);
	22	try test__fixunstfti(0.99, 0);
	23	try test__fixunstfti(1.0, 1);
	24	try test__fixunstfti(1.5, 1);
	25	try test__fixunstfti(1.99, 1);
	26	try test__fixunstfti(2.0, 2);
	27	try test__fixunstfti(2.01, 2);
	28	try test__fixunstfti(-0.01, 0);
	29	try test__fixunstfti(-0.99, 0);
30	30
31		test__fixunstfti(0x1.p+128, 0xffffffffffffffffffffffffffffffff);
	31	try test__fixunstfti(0x1.p+128, 0xffffffffffffffffffffffffffffffff);
32	32
33		test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000);
34		test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000);
35		test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff);
36		test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff);
	33	try test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000);
	34	try test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000);
	35	try test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff);
	36	try test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff);
37	37	}

lib/std/special/compiler_rt/floatdidf_test.zig+44-44

...	...	@@ -6,53 +6,53 @@
6	6	const __floatdidf = @import("floatdidf.zig").__floatdidf;
7	7	const testing = @import("std").testing;
8	8
9		fn test__floatdidf(a: i64, expected: f64) void {
	9	fn test__floatdidf(a: i64, expected: f64) !void {
10	10	const r = __floatdidf(a);
11	11	try testing.expect(r == expected);
12	12	}
13	13
14	14	test "floatdidf" {
15		test__floatdidf(0, 0.0);
16		test__floatdidf(1, 1.0);
17		test__floatdidf(2, 2.0);
18		test__floatdidf(20, 20.0);
19		test__floatdidf(-1, -1.0);
20		test__floatdidf(-2, -2.0);
21		test__floatdidf(-20, -20.0);
22		test__floatdidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
23		test__floatdidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
24		test__floatdidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
25		test__floatdidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
26		test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000008000000000)), -0x1.FFFFFEp+62);
27		test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000800)), -0x1.FFFFFFFFFFFFEp+62);
28		test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000010000000000)), -0x1.FFFFFCp+62);
29		test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000001000)), -0x1.FFFFFFFFFFFFCp+62);
30		test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000000)), -0x1.000000p+63);
31		test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000001)), -0x1.000000p+63);
32		test__floatdidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
33		test__floatdidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
34		test__floatdidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
35		test__floatdidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
36		test__floatdidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
37		test__floatdidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
38		test__floatdidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
39		test__floatdidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
40		test__floatdidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
41		test__floatdidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
42		test__floatdidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
43		test__floatdidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
44		test__floatdidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
45		test__floatdidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
46		test__floatdidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
47		test__floatdidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
48		test__floatdidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
49		test__floatdidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
50		test__floatdidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
51		test__floatdidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
52		test__floatdidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
53		test__floatdidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
54		test__floatdidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
55		test__floatdidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
56		test__floatdidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
57		test__floatdidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
	15	try test__floatdidf(0, 0.0);
	16	try test__floatdidf(1, 1.0);
	17	try test__floatdidf(2, 2.0);
	18	try test__floatdidf(20, 20.0);
	19	try test__floatdidf(-1, -1.0);
	20	try test__floatdidf(-2, -2.0);
	21	try test__floatdidf(-20, -20.0);
	22	try test__floatdidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
	23	try test__floatdidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
	24	try test__floatdidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
	25	try test__floatdidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
	26	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000008000000000)), -0x1.FFFFFEp+62);
	27	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000800)), -0x1.FFFFFFFFFFFFEp+62);
	28	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000010000000000)), -0x1.FFFFFCp+62);
	29	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000001000)), -0x1.FFFFFFFFFFFFCp+62);
	30	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000000)), -0x1.000000p+63);
	31	try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000001)), -0x1.000000p+63);
	32	try test__floatdidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
	33	try test__floatdidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
	34	try test__floatdidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
	35	try test__floatdidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
	36	try test__floatdidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
	37	try test__floatdidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
	38	try test__floatdidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
	39	try test__floatdidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
	40	try test__floatdidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
	41	try test__floatdidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
	42	try test__floatdidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
	43	try test__floatdidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
	44	try test__floatdidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
	45	try test__floatdidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
	46	try test__floatdidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
	47	try test__floatdidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
	48	try test__floatdidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
	49	try test__floatdidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
	50	try test__floatdidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
	51	try test__floatdidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
	52	try test__floatdidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
	53	try test__floatdidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
	54	try test__floatdidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
	55	try test__floatdidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
	56	try test__floatdidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
	57	try test__floatdidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
58	58	}

lib/std/special/compiler_rt/floatdisf_test.zig+23-23

...	...	@@ -6,32 +6,32 @@
6	6	const __floatdisf = @import("floatXisf.zig").__floatdisf;
7	7	const testing = @import("std").testing;
8	8
9		fn test__floatdisf(a: i64, expected: f32) void {
	9	fn test__floatdisf(a: i64, expected: f32) !void {
10	10	const x = __floatdisf(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "floatdisf" {
15		test__floatdisf(0, 0.0);
16		test__floatdisf(1, 1.0);
17		test__floatdisf(2, 2.0);
18		test__floatdisf(-1, -1.0);
19		test__floatdisf(-2, -2.0);
20		test__floatdisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
21		test__floatdisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
22		test__floatdisf(0x8000008000000000, -0x1.FFFFFEp+62);
23		test__floatdisf(0x8000010000000000, -0x1.FFFFFCp+62);
24		test__floatdisf(0x8000000000000000, -0x1.000000p+63);
25		test__floatdisf(0x8000000000000001, -0x1.000000p+63);
26		test__floatdisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
27		test__floatdisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
28		test__floatdisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
29		test__floatdisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
30		test__floatdisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
31		test__floatdisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
32		test__floatdisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
33		test__floatdisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
34		test__floatdisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
35		test__floatdisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
36		test__floatdisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
	15	try test__floatdisf(0, 0.0);
	16	try test__floatdisf(1, 1.0);
	17	try test__floatdisf(2, 2.0);
	18	try test__floatdisf(-1, -1.0);
	19	try test__floatdisf(-2, -2.0);
	20	try test__floatdisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
	21	try test__floatdisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
	22	try test__floatdisf(0x8000008000000000, -0x1.FFFFFEp+62);
	23	try test__floatdisf(0x8000010000000000, -0x1.FFFFFCp+62);
	24	try test__floatdisf(0x8000000000000000, -0x1.000000p+63);
	25	try test__floatdisf(0x8000000000000001, -0x1.000000p+63);
	26	try test__floatdisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
	27	try test__floatdisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
	28	try test__floatdisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
	29	try test__floatdisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
	30	try test__floatdisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
	31	try test__floatdisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
	32	try test__floatdisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
	33	try test__floatdisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
	34	try test__floatdisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
	35	try test__floatdisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
	36	try test__floatdisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
37	37	}

lib/std/special/compiler_rt/floatditf_test.zig+10-10

...	...	@@ -6,21 +6,21 @@
6	6	const __floatditf = @import("floatditf.zig").__floatditf;
7	7	const testing = @import("std").testing;
8	8
9		fn test__floatditf(a: i64, expected: f128) void {
	9	fn test__floatditf(a: i64, expected: f128) !void {
10	10	const x = __floatditf(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "floatditf" {
15		test__floatditf(0x7fffffffffffffff, make_ti(0x403dffffffffffff, 0xfffc000000000000));
16		test__floatditf(0x123456789abcdef1, make_ti(0x403b23456789abcd, 0xef10000000000000));
17		test__floatditf(0x2, make_ti(0x4000000000000000, 0x0));
18		test__floatditf(0x1, make_ti(0x3fff000000000000, 0x0));
19		test__floatditf(0x0, make_ti(0x0, 0x0));
20		test__floatditf(@bitCast(i64, @as(u64, 0xffffffffffffffff)), make_ti(0xbfff000000000000, 0x0));
21		test__floatditf(@bitCast(i64, @as(u64, 0xfffffffffffffffe)), make_ti(0xc000000000000000, 0x0));
22		test__floatditf(-0x123456789abcdef1, make_ti(0xc03b23456789abcd, 0xef10000000000000));
23		test__floatditf(@bitCast(i64, @as(u64, 0x8000000000000000)), make_ti(0xc03e000000000000, 0x0));
	15	try test__floatditf(0x7fffffffffffffff, make_ti(0x403dffffffffffff, 0xfffc000000000000));
	16	try test__floatditf(0x123456789abcdef1, make_ti(0x403b23456789abcd, 0xef10000000000000));
	17	try test__floatditf(0x2, make_ti(0x4000000000000000, 0x0));
	18	try test__floatditf(0x1, make_ti(0x3fff000000000000, 0x0));
	19	try test__floatditf(0x0, make_ti(0x0, 0x0));
	20	try test__floatditf(@bitCast(i64, @as(u64, 0xffffffffffffffff)), make_ti(0xbfff000000000000, 0x0));
	21	try test__floatditf(@bitCast(i64, @as(u64, 0xfffffffffffffffe)), make_ti(0xc000000000000000, 0x0));
	22	try test__floatditf(-0x123456789abcdef1, make_ti(0xc03b23456789abcd, 0xef10000000000000));
	23	try test__floatditf(@bitCast(i64, @as(u64, 0x8000000000000000)), make_ti(0xc03e000000000000, 0x0));
24	24	}
25	25
26	26	fn make_ti(high: u64, low: u64) f128 {

lib/std/special/compiler_rt/floatsiXf.zig+19-19

...	...	@@ -84,42 +84,42 @@ pub fn __aeabi_i2f(arg: i32) callconv(.AAPCS) f32 {
84	84	return @call(.{ .modifier = .always_inline }, __floatsisf, .{arg});
85	85	}
86	86
87		fn test_one_floatsitf(a: i32, expected: u128) void {
	87	fn test_one_floatsitf(a: i32, expected: u128) !void {
88	88	const r = __floatsitf(a);
89	89	try std.testing.expect(@bitCast(u128, r) == expected);
90	90	}
91	91
92		fn test_one_floatsidf(a: i32, expected: u64) void {
	92	fn test_one_floatsidf(a: i32, expected: u64) !void {
93	93	const r = __floatsidf(a);
94	94	try std.testing.expect(@bitCast(u64, r) == expected);
95	95	}
96	96
97		fn test_one_floatsisf(a: i32, expected: u32) void {
	97	fn test_one_floatsisf(a: i32, expected: u32) !void {
98	98	const r = __floatsisf(a);
99	99	try std.testing.expect(@bitCast(u32, r) == expected);
100	100	}
101	101
102	102	test "floatsidf" {
103		test_one_floatsidf(0, 0x0000000000000000);
104		test_one_floatsidf(1, 0x3ff0000000000000);
105		test_one_floatsidf(-1, 0xbff0000000000000);
106		test_one_floatsidf(0x7FFFFFFF, 0x41dfffffffc00000);
107		test_one_floatsidf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc1e0000000000000);
	103	try test_one_floatsidf(0, 0x0000000000000000);
	104	try test_one_floatsidf(1, 0x3ff0000000000000);
	105	try test_one_floatsidf(-1, 0xbff0000000000000);
	106	try test_one_floatsidf(0x7FFFFFFF, 0x41dfffffffc00000);
	107	try test_one_floatsidf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc1e0000000000000);
108	108	}
109	109
110	110	test "floatsisf" {
111		test_one_floatsisf(0, 0x00000000);
112		test_one_floatsisf(1, 0x3f800000);
113		test_one_floatsisf(-1, 0xbf800000);
114		test_one_floatsisf(0x7FFFFFFF, 0x4f000000);
115		test_one_floatsisf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xcf000000);
	111	try test_one_floatsisf(0, 0x00000000);
	112	try test_one_floatsisf(1, 0x3f800000);
	113	try test_one_floatsisf(-1, 0xbf800000);
	114	try test_one_floatsisf(0x7FFFFFFF, 0x4f000000);
	115	try test_one_floatsisf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xcf000000);
116	116	}
117	117
118	118	test "floatsitf" {
119		test_one_floatsitf(0, 0);
120		test_one_floatsitf(0x7FFFFFFF, 0x401dfffffffc00000000000000000000);
121		test_one_floatsitf(0x12345678, 0x401b2345678000000000000000000000);
122		test_one_floatsitf(-0x12345678, 0xc01b2345678000000000000000000000);
123		test_one_floatsitf(@bitCast(i32, @intCast(u32, 0xffffffff)), 0xbfff0000000000000000000000000000);
124		test_one_floatsitf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc01e0000000000000000000000000000);
	119	try test_one_floatsitf(0, 0);
	120	try test_one_floatsitf(0x7FFFFFFF, 0x401dfffffffc00000000000000000000);
	121	try test_one_floatsitf(0x12345678, 0x401b2345678000000000000000000000);
	122	try test_one_floatsitf(-0x12345678, 0xc01b2345678000000000000000000000);
	123	try test_one_floatsitf(@bitCast(i32, @intCast(u32, 0xffffffff)), 0xbfff0000000000000000000000000000);
	124	try test_one_floatsitf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc01e0000000000000000000000000000);
125	125	}

lib/std/special/compiler_rt/floattidf_test.zig+59-59

...	...	@@ -6,79 +6,79 @@
6	6	const __floattidf = @import("floattidf.zig").__floattidf;
7	7	const testing = @import("std").testing;
8	8
9		fn test__floattidf(a: i128, expected: f64) void {
	9	fn test__floattidf(a: i128, expected: f64) !void {
10	10	const x = __floattidf(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "floattidf" {
15		test__floattidf(0, 0.0);
	15	try test__floattidf(0, 0.0);
16	16
17		test__floattidf(1, 1.0);
18		test__floattidf(2, 2.0);
19		test__floattidf(20, 20.0);
20		test__floattidf(-1, -1.0);
21		test__floattidf(-2, -2.0);
22		test__floattidf(-20, -20.0);
	17	try test__floattidf(1, 1.0);
	18	try test__floattidf(2, 2.0);
	19	try test__floattidf(20, 20.0);
	20	try test__floattidf(-1, -1.0);
	21	try test__floattidf(-2, -2.0);
	22	try test__floattidf(-20, -20.0);
23	23
24		test__floattidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
25		test__floattidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
26		test__floattidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
27		test__floattidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
	24	try test__floattidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
	25	try test__floattidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
	26	try test__floattidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
	27	try test__floattidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
28	28
29		test__floattidf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);
30		test__floattidf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);
31		test__floattidf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);
32		test__floattidf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);
	29	try test__floattidf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);
	30	try test__floattidf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);
	31	try test__floattidf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);
	32	try test__floattidf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);
33	33
34		test__floattidf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);
35		test__floattidf(make_ti(0x8000000000000001, 0), -0x1.000000p+127);
	34	try test__floattidf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);
	35	try test__floattidf(make_ti(0x8000000000000001, 0), -0x1.000000p+127);
36	36
37		test__floattidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
	37	try test__floattidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
38	38
39		test__floattidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
40		test__floattidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
41		test__floattidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
42		test__floattidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
43		test__floattidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
	39	try test__floattidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
	40	try test__floattidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
	41	try test__floattidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
	42	try test__floattidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
	43	try test__floattidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
44	44
45		test__floattidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
46		test__floattidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
47		test__floattidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
48		test__floattidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
49		test__floattidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
	45	try test__floattidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
	46	try test__floattidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
	47	try test__floattidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
	48	try test__floattidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
	49	try test__floattidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
50	50
51		test__floattidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
52		test__floattidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
53		test__floattidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
54		test__floattidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
55		test__floattidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
56		test__floattidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
57		test__floattidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
58		test__floattidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
59		test__floattidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
60		test__floattidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
61		test__floattidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
62		test__floattidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
63		test__floattidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
64		test__floattidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
65		test__floattidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
	51	try test__floattidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
	52	try test__floattidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
	53	try test__floattidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
	54	try test__floattidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
	55	try test__floattidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
	56	try test__floattidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
	57	try test__floattidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
	58	try test__floattidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
	59	try test__floattidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
	60	try test__floattidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
	61	try test__floattidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
	62	try test__floattidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
	63	try test__floattidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
	64	try test__floattidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
	65	try test__floattidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
66	66
67		test__floattidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
68		test__floattidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121);
69		test__floattidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121);
70		test__floattidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121);
71		test__floattidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121);
72		test__floattidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121);
73		test__floattidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121);
74		test__floattidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121);
75		test__floattidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121);
76		test__floattidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121);
77		test__floattidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121);
78		test__floattidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121);
79		test__floattidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121);
80		test__floattidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121);
81		test__floattidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
	67	try test__floattidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
	68	try test__floattidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121);
	69	try test__floattidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121);
	70	try test__floattidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121);
	71	try test__floattidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121);
	72	try test__floattidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121);
	73	try test__floattidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121);
	74	try test__floattidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121);
	75	try test__floattidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121);
	76	try test__floattidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121);
	77	try test__floattidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121);
	78	try test__floattidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121);
	79	try test__floattidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121);
	80	try test__floattidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121);
	81	try test__floattidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
82	82	}
83	83
84	84	fn make_ti(high: u64, low: u64) i128 {

lib/std/special/compiler_rt/floattisf_test.zig+34-34

...	...	@@ -6,55 +6,55 @@
6	6	const __floattisf = @import("floatXisf.zig").__floattisf;
7	7	const testing = @import("std").testing;
8	8
9		fn test__floattisf(a: i128, expected: f32) void {
	9	fn test__floattisf(a: i128, expected: f32) !void {
10	10	const x = __floattisf(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "floattisf" {
15		test__floattisf(0, 0.0);
	15	try test__floattisf(0, 0.0);
16	16
17		test__floattisf(1, 1.0);
18		test__floattisf(2, 2.0);
19		test__floattisf(-1, -1.0);
20		test__floattisf(-2, -2.0);
	17	try test__floattisf(1, 1.0);
	18	try test__floattisf(2, 2.0);
	19	try test__floattisf(-1, -1.0);
	20	try test__floattisf(-2, -2.0);
21	21
22		test__floattisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
23		test__floattisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
	22	try test__floattisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
	23	try test__floattisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
24	24
25		test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000008000000000), -0x1.FFFFFEp+62);
26		test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000010000000000), -0x1.FFFFFCp+62);
	25	try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000008000000000), -0x1.FFFFFEp+62);
	26	try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000010000000000), -0x1.FFFFFCp+62);
27	27
28		test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000000), -0x1.000000p+63);
29		test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000001), -0x1.000000p+63);
	28	try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000000), -0x1.000000p+63);
	29	try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000001), -0x1.000000p+63);
30	30
31		test__floattisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
	31	try test__floattisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
32	32
33		test__floattisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
34		test__floattisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
35		test__floattisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
36		test__floattisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
37		test__floattisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
	33	try test__floattisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
	34	try test__floattisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
	35	try test__floattisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
	36	try test__floattisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
	37	try test__floattisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
38	38
39		test__floattisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
40		test__floattisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
41		test__floattisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
42		test__floattisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
43		test__floattisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
	39	try test__floattisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
	40	try test__floattisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
	41	try test__floattisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
	42	try test__floattisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
	43	try test__floattisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
44	44
45		test__floattisf(make_ti(0x0007FB72E8000000, 0), 0x1.FEDCBAp+114);
	45	try test__floattisf(make_ti(0x0007FB72E8000000, 0), 0x1.FEDCBAp+114);
46	46
47		test__floattisf(make_ti(0x0007FB72EA000000, 0), 0x1.FEDCBAp+114);
48		test__floattisf(make_ti(0x0007FB72EB000000, 0), 0x1.FEDCBAp+114);
49		test__floattisf(make_ti(0x0007FB72EBFFFFFF, 0), 0x1.FEDCBAp+114);
50		test__floattisf(make_ti(0x0007FB72EC000000, 0), 0x1.FEDCBCp+114);
51		test__floattisf(make_ti(0x0007FB72E8000001, 0), 0x1.FEDCBAp+114);
	47	try test__floattisf(make_ti(0x0007FB72EA000000, 0), 0x1.FEDCBAp+114);
	48	try test__floattisf(make_ti(0x0007FB72EB000000, 0), 0x1.FEDCBAp+114);
	49	try test__floattisf(make_ti(0x0007FB72EBFFFFFF, 0), 0x1.FEDCBAp+114);
	50	try test__floattisf(make_ti(0x0007FB72EC000000, 0), 0x1.FEDCBCp+114);
	51	try test__floattisf(make_ti(0x0007FB72E8000001, 0), 0x1.FEDCBAp+114);
52	52
53		test__floattisf(make_ti(0x0007FB72E6000000, 0), 0x1.FEDCBAp+114);
54		test__floattisf(make_ti(0x0007FB72E7000000, 0), 0x1.FEDCBAp+114);
55		test__floattisf(make_ti(0x0007FB72E7FFFFFF, 0), 0x1.FEDCBAp+114);
56		test__floattisf(make_ti(0x0007FB72E4000001, 0), 0x1.FEDCBAp+114);
57		test__floattisf(make_ti(0x0007FB72E4000000, 0), 0x1.FEDCB8p+114);
	53	try test__floattisf(make_ti(0x0007FB72E6000000, 0), 0x1.FEDCBAp+114);
	54	try test__floattisf(make_ti(0x0007FB72E7000000, 0), 0x1.FEDCBAp+114);
	55	try test__floattisf(make_ti(0x0007FB72E7FFFFFF, 0), 0x1.FEDCBAp+114);
	56	try test__floattisf(make_ti(0x0007FB72E4000001, 0), 0x1.FEDCBAp+114);
	57	try test__floattisf(make_ti(0x0007FB72E4000000, 0), 0x1.FEDCB8p+114);
58	58	}
59	59
60	60	fn make_ti(high: u64, low: u64) i128 {

lib/std/special/compiler_rt/floattitf_test.zig+69-69

...	...	@@ -6,91 +6,91 @@
6	6	const __floattitf = @import("floattitf.zig").__floattitf;
7	7	const testing = @import("std").testing;
8	8
9		fn test__floattitf(a: i128, expected: f128) void {
	9	fn test__floattitf(a: i128, expected: f128) !void {
10	10	const x = __floattitf(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "floattitf" {
15		test__floattitf(0, 0.0);
	15	try test__floattitf(0, 0.0);
16	16
17		test__floattitf(1, 1.0);
18		test__floattitf(2, 2.0);
19		test__floattitf(20, 20.0);
20		test__floattitf(-1, -1.0);
21		test__floattitf(-2, -2.0);
22		test__floattitf(-20, -20.0);
	17	try test__floattitf(1, 1.0);
	18	try test__floattitf(2, 2.0);
	19	try test__floattitf(20, 20.0);
	20	try test__floattitf(-1, -1.0);
	21	try test__floattitf(-2, -2.0);
	22	try test__floattitf(-20, -20.0);
23	23
24		test__floattitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
25		test__floattitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
26		test__floattitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
27		test__floattitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
	24	try test__floattitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
	25	try test__floattitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
	26	try test__floattitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
	27	try test__floattitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
28	28
29		test__floattitf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);
30		test__floattitf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);
31		test__floattitf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);
32		test__floattitf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);
	29	try test__floattitf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);
	30	try test__floattitf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);
	31	try test__floattitf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);
	32	try test__floattitf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);
33	33
34		test__floattitf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);
35		test__floattitf(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126);
	34	try test__floattitf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);
	35	try test__floattitf(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126);
36	36
37		test__floattitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
	37	try test__floattitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
38	38
39		test__floattitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
40		test__floattitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
41		test__floattitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
42		test__floattitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
43		test__floattitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
	39	try test__floattitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
	40	try test__floattitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
	41	try test__floattitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
	42	try test__floattitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
	43	try test__floattitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
44	44
45		test__floattitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
46		test__floattitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
47		test__floattitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
48		test__floattitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
49		test__floattitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
	45	try test__floattitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
	46	try test__floattitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
	47	try test__floattitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
	48	try test__floattitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
	49	try test__floattitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
50	50
51		test__floattitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
52		test__floattitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);
53		test__floattitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);
54		test__floattitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);
55		test__floattitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);
56		test__floattitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);
57		test__floattitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);
58		test__floattitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);
59		test__floattitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);
60		test__floattitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);
61		test__floattitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);
62		test__floattitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);
63		test__floattitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);
64		test__floattitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);
65		test__floattitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
	51	try test__floattitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
	52	try test__floattitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);
	53	try test__floattitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);
	54	try test__floattitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);
	55	try test__floattitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);
	56	try test__floattitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);
	57	try test__floattitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);
	58	try test__floattitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);
	59	try test__floattitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);
	60	try test__floattitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);
	61	try test__floattitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);
	62	try test__floattitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);
	63	try test__floattitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);
	64	try test__floattitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);
	65	try test__floattitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
66	66
67		test__floattitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
68		test__floattitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);
69		test__floattitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);
70		test__floattitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);
71		test__floattitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);
72		test__floattitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);
73		test__floattitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);
74		test__floattitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);
75		test__floattitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);
76		test__floattitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);
77		test__floattitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);
78		test__floattitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);
79		test__floattitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);
80		test__floattitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);
81		test__floattitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
	67	try test__floattitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
	68	try test__floattitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);
	69	try test__floattitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);
	70	try test__floattitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);
	71	try test__floattitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);
	72	try test__floattitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);
	73	try test__floattitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);
	74	try test__floattitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);
	75	try test__floattitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);
	76	try test__floattitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);
	77	try test__floattitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);
	78	try test__floattitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);
	79	try test__floattitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);
	80	try test__floattitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);
	81	try test__floattitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
82	82
83		test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);
	83	try test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);
84	84
85		test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);
86		test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);
87		test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);
88		test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);
89		test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);
90		test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);
91		test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);
92		test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);
93		test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);
	85	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);
	86	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);
	87	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);
	88	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);
	89	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);
	90	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);
	91	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);
	92	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);
	93	try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);
94	94	}
95	95
96	96	fn make_ti(high: u64, low: u64) i128 {

lib/std/special/compiler_rt/floatundidf_test.zig+41-41

...	...	@@ -6,50 +6,50 @@
6	6	const __floatundidf = @import("floatundidf.zig").__floatundidf;
7	7	const testing = @import("std").testing;
8	8
9		fn test__floatundidf(a: u64, expected: f64) void {
	9	fn test__floatundidf(a: u64, expected: f64) !void {
10	10	const r = __floatundidf(a);
11	11	try testing.expect(r == expected);
12	12	}
13	13
14	14	test "floatundidf" {
15		test__floatundidf(0, 0.0);
16		test__floatundidf(1, 1.0);
17		test__floatundidf(2, 2.0);
18		test__floatundidf(20, 20.0);
19		test__floatundidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
20		test__floatundidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
21		test__floatundidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
22		test__floatundidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
23		test__floatundidf(0x8000008000000000, 0x1.000001p+63);
24		test__floatundidf(0x8000000000000800, 0x1.0000000000001p+63);
25		test__floatundidf(0x8000010000000000, 0x1.000002p+63);
26		test__floatundidf(0x8000000000001000, 0x1.0000000000002p+63);
27		test__floatundidf(0x8000000000000000, 0x1p+63);
28		test__floatundidf(0x8000000000000001, 0x1p+63);
29		test__floatundidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
30		test__floatundidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
31		test__floatundidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
32		test__floatundidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
33		test__floatundidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
34		test__floatundidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
35		test__floatundidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
36		test__floatundidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
37		test__floatundidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
38		test__floatundidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
39		test__floatundidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
40		test__floatundidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
41		test__floatundidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
42		test__floatundidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
43		test__floatundidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
44		test__floatundidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
45		test__floatundidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
46		test__floatundidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
47		test__floatundidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
48		test__floatundidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
49		test__floatundidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
50		test__floatundidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
51		test__floatundidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
52		test__floatundidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
53		test__floatundidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
54		test__floatundidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
	15	try test__floatundidf(0, 0.0);
	16	try test__floatundidf(1, 1.0);
	17	try test__floatundidf(2, 2.0);
	18	try test__floatundidf(20, 20.0);
	19	try test__floatundidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
	20	try test__floatundidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
	21	try test__floatundidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
	22	try test__floatundidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
	23	try test__floatundidf(0x8000008000000000, 0x1.000001p+63);
	24	try test__floatundidf(0x8000000000000800, 0x1.0000000000001p+63);
	25	try test__floatundidf(0x8000010000000000, 0x1.000002p+63);
	26	try test__floatundidf(0x8000000000001000, 0x1.0000000000002p+63);
	27	try test__floatundidf(0x8000000000000000, 0x1p+63);
	28	try test__floatundidf(0x8000000000000001, 0x1p+63);
	29	try test__floatundidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
	30	try test__floatundidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
	31	try test__floatundidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
	32	try test__floatundidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
	33	try test__floatundidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
	34	try test__floatundidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
	35	try test__floatundidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
	36	try test__floatundidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
	37	try test__floatundidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
	38	try test__floatundidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
	39	try test__floatundidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
	40	try test__floatundidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
	41	try test__floatundidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
	42	try test__floatundidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
	43	try test__floatundidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
	44	try test__floatundidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
	45	try test__floatundidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
	46	try test__floatundidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
	47	try test__floatundidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
	48	try test__floatundidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
	49	try test__floatundidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
	50	try test__floatundidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
	51	try test__floatundidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
	52	try test__floatundidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
	53	try test__floatundidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
	54	try test__floatundidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
55	55	}

lib/std/special/compiler_rt/floatundisf.zig+24-24

...	...	@@ -66,31 +66,31 @@ pub fn __aeabi_ul2f(arg: u64) callconv(.AAPCS) f32 {
66	66	return @call(.{ .modifier = .always_inline }, __floatundisf, .{arg});
67	67	}
68	68
69		fn test__floatundisf(a: u64, expected: f32) void {
70		std.testing.expectEqual(expected, __floatundisf(a));
	69	fn test__floatundisf(a: u64, expected: f32) !void {
	70	try std.testing.expectEqual(expected, __floatundisf(a));
71	71	}
72	72
73	73	test "floatundisf" {
74		test__floatundisf(0, 0.0);
75		test__floatundisf(1, 1.0);
76		test__floatundisf(2, 2.0);
77		test__floatundisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
78		test__floatundisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
79		test__floatundisf(0x8000008000000000, 0x1p+63);
80		test__floatundisf(0x8000010000000000, 0x1.000002p+63);
81		test__floatundisf(0x8000000000000000, 0x1p+63);
82		test__floatundisf(0x8000000000000001, 0x1p+63);
83		test__floatundisf(0xFFFFFFFFFFFFFFFE, 0x1p+64);
84		test__floatundisf(0xFFFFFFFFFFFFFFFF, 0x1p+64);
85		test__floatundisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
86		test__floatundisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
87		test__floatundisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
88		test__floatundisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
89		test__floatundisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
90		test__floatundisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
91		test__floatundisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
92		test__floatundisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
93		test__floatundisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
94		test__floatundisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
95		test__floatundisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
	74	try test__floatundisf(0, 0.0);
	75	try test__floatundisf(1, 1.0);
	76	try test__floatundisf(2, 2.0);
	77	try test__floatundisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
	78	try test__floatundisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
	79	try test__floatundisf(0x8000008000000000, 0x1p+63);
	80	try test__floatundisf(0x8000010000000000, 0x1.000002p+63);
	81	try test__floatundisf(0x8000000000000000, 0x1p+63);
	82	try test__floatundisf(0x8000000000000001, 0x1p+63);
	83	try test__floatundisf(0xFFFFFFFFFFFFFFFE, 0x1p+64);
	84	try test__floatundisf(0xFFFFFFFFFFFFFFFF, 0x1p+64);
	85	try test__floatundisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
	86	try test__floatundisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
	87	try test__floatundisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
	88	try test__floatundisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
	89	try test__floatundisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
	90	try test__floatundisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
	91	try test__floatundisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
	92	try test__floatundisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
	93	try test__floatundisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
	94	try test__floatundisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
	95	try test__floatundisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
96	96	}

lib/std/special/compiler_rt/floatunditf_test.zig+9-9

...	...	@@ -5,7 +5,7 @@
5	5	// and substantial portions of the software.
6	6	const __floatunditf = @import("floatunditf.zig").__floatunditf;
7	7
8		fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) void {
	8	fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) !void {
9	9	const x = __floatunditf(a);
10	10
11	11	const x_repr = @bitCast(u128, x);
...	...	@@ -26,12 +26,12 @@ fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) void {
26	26	}
27	27
28	28	test "floatunditf" {
29		test__floatunditf(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000);
30		test__floatunditf(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000);
31		test__floatunditf(0x8000000000000000, 0x403e000000000000, 0x0);
32		test__floatunditf(0x7fffffffffffffff, 0x403dffffffffffff, 0xfffc000000000000);
33		test__floatunditf(0x123456789abcdef1, 0x403b23456789abcd, 0xef10000000000000);
34		test__floatunditf(0x2, 0x4000000000000000, 0x0);
35		test__floatunditf(0x1, 0x3fff000000000000, 0x0);
36		test__floatunditf(0x0, 0x0, 0x0);
	29	try test__floatunditf(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000);
	30	try test__floatunditf(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000);
	31	try test__floatunditf(0x8000000000000000, 0x403e000000000000, 0x0);
	32	try test__floatunditf(0x7fffffffffffffff, 0x403dffffffffffff, 0xfffc000000000000);
	33	try test__floatunditf(0x123456789abcdef1, 0x403b23456789abcd, 0xef10000000000000);
	34	try test__floatunditf(0x2, 0x4000000000000000, 0x0);
	35	try test__floatunditf(0x1, 0x3fff000000000000, 0x0);
	36	try test__floatunditf(0x0, 0x0, 0x0);
37	37	}

lib/std/special/compiler_rt/floatunsidf.zig+6-6

...	...	@@ -28,16 +28,16 @@ pub fn __aeabi_ui2d(arg: u32) callconv(.AAPCS) f64 {
28	28	return @call(.{ .modifier = .always_inline }, __floatunsidf, .{arg});
29	29	}
30	30
31		fn test_one_floatunsidf(a: u32, expected: u64) void {
	31	fn test_one_floatunsidf(a: u32, expected: u64) !void {
32	32	const r = __floatunsidf(a);
33	33	try std.testing.expect(@bitCast(u64, r) == expected);
34	34	}
35	35
36	36	test "floatsidf" {
37	37	// Test the produced bit pattern
38		test_one_floatunsidf(0, 0x0000000000000000);
39		test_one_floatunsidf(1, 0x3ff0000000000000);
40		test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000);
41		test_one_floatunsidf(@intCast(u32, 0x80000000), 0x41e0000000000000);
42		test_one_floatunsidf(@intCast(u32, 0xFFFFFFFF), 0x41efffffffe00000);
	38	try test_one_floatunsidf(0, 0x0000000000000000);
	39	try test_one_floatunsidf(1, 0x3ff0000000000000);
	40	try test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000);
	41	try test_one_floatunsidf(@intCast(u32, 0x80000000), 0x41e0000000000000);
	42	try test_one_floatunsidf(@intCast(u32, 0xFFFFFFFF), 0x41efffffffe00000);
43	43	}

lib/std/special/compiler_rt/floatunsisf.zig+6-6

...	...	@@ -48,16 +48,16 @@ pub fn __aeabi_ui2f(arg: u32) callconv(.AAPCS) f32 {
48	48	return @call(.{ .modifier = .always_inline }, __floatunsisf, .{arg});
49	49	}
50	50
51		fn test_one_floatunsisf(a: u32, expected: u32) void {
	51	fn test_one_floatunsisf(a: u32, expected: u32) !void {
52	52	const r = __floatunsisf(a);
53	53	try std.testing.expect(@bitCast(u32, r) == expected);
54	54	}
55	55
56	56	test "floatunsisf" {
57	57	// Test the produced bit pattern
58		test_one_floatunsisf(0, 0);
59		test_one_floatunsisf(1, 0x3f800000);
60		test_one_floatunsisf(0x7FFFFFFF, 0x4f000000);
61		test_one_floatunsisf(0x80000000, 0x4f000000);
62		test_one_floatunsisf(0xFFFFFFFF, 0x4f800000);
	58	try test_one_floatunsisf(0, 0);
	59	try test_one_floatunsisf(1, 0x3f800000);
	60	try test_one_floatunsisf(0x7FFFFFFF, 0x4f000000);
	61	try test_one_floatunsisf(0x80000000, 0x4f000000);
	62	try test_one_floatunsisf(0xFFFFFFFF, 0x4f800000);
63	63	}

lib/std/special/compiler_rt/floatunsitf_test.zig+5-5

...	...	@@ -5,7 +5,7 @@
5	5	// and substantial portions of the software.
6	6	const __floatunsitf = @import("floatunsitf.zig").__floatunsitf;
7	7
8		fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) void {
	8	fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) !void {
9	9	const x = __floatunsitf(a);
10	10
11	11	const x_repr = @bitCast(u128, x);
...	...	@@ -26,8 +26,8 @@ fn test__floatunsitf(a: u64, expected_hi: u64, expected_lo: u64) void {
26	26	}
27	27
28	28	test "floatunsitf" {
29		test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0);
30		test__floatunsitf(0, 0x0, 0x0);
31		test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0);
32		test__floatunsitf(0x12345678, 0x401b234567800000, 0x0);
	29	try test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0);
	30	try test__floatunsitf(0, 0x0, 0x0);
	31	try test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0);
	32	try test__floatunsitf(0x12345678, 0x401b234567800000, 0x0);
33	33	}

lib/std/special/compiler_rt/floatuntidf_test.zig+56-56

...	...	@@ -6,76 +6,76 @@
6	6	const __floatuntidf = @import("floatuntidf.zig").__floatuntidf;
7	7	const testing = @import("std").testing;
8	8
9		fn test__floatuntidf(a: u128, expected: f64) void {
	9	fn test__floatuntidf(a: u128, expected: f64) !void {
10	10	const x = __floatuntidf(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "floatuntidf" {
15		test__floatuntidf(0, 0.0);
	15	try test__floatuntidf(0, 0.0);
16	16
17		test__floatuntidf(1, 1.0);
18		test__floatuntidf(2, 2.0);
19		test__floatuntidf(20, 20.0);
	17	try test__floatuntidf(1, 1.0);
	18	try test__floatuntidf(2, 2.0);
	19	try test__floatuntidf(20, 20.0);
20	20
21		test__floatuntidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
22		test__floatuntidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
23		test__floatuntidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
24		test__floatuntidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
	21	try test__floatuntidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
	22	try test__floatuntidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
	23	try test__floatuntidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
	24	try test__floatuntidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
25	25
26		test__floatuntidf(make_ti(0x8000008000000000, 0), 0x1.000001p+127);
27		test__floatuntidf(make_ti(0x8000000000000800, 0), 0x1.0000000000001p+127);
28		test__floatuntidf(make_ti(0x8000010000000000, 0), 0x1.000002p+127);
29		test__floatuntidf(make_ti(0x8000000000001000, 0), 0x1.0000000000002p+127);
	26	try test__floatuntidf(make_ti(0x8000008000000000, 0), 0x1.000001p+127);
	27	try test__floatuntidf(make_ti(0x8000000000000800, 0), 0x1.0000000000001p+127);
	28	try test__floatuntidf(make_ti(0x8000010000000000, 0), 0x1.000002p+127);
	29	try test__floatuntidf(make_ti(0x8000000000001000, 0), 0x1.0000000000002p+127);
30	30
31		test__floatuntidf(make_ti(0x8000000000000000, 0), 0x1.000000p+127);
32		test__floatuntidf(make_ti(0x8000000000000001, 0), 0x1.0000000000000002p+127);
	31	try test__floatuntidf(make_ti(0x8000000000000000, 0), 0x1.000000p+127);
	32	try test__floatuntidf(make_ti(0x8000000000000001, 0), 0x1.0000000000000002p+127);
33	33
34		test__floatuntidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
	34	try test__floatuntidf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
35	35
36		test__floatuntidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
37		test__floatuntidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
38		test__floatuntidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
39		test__floatuntidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
40		test__floatuntidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
	36	try test__floatuntidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
	37	try test__floatuntidf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
	38	try test__floatuntidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
	39	try test__floatuntidf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
	40	try test__floatuntidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
41	41
42		test__floatuntidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
43		test__floatuntidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
44		test__floatuntidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
45		test__floatuntidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
46		test__floatuntidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
	42	try test__floatuntidf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
	43	try test__floatuntidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
	44	try test__floatuntidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
	45	try test__floatuntidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
	46	try test__floatuntidf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
47	47
48		test__floatuntidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
49		test__floatuntidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
50		test__floatuntidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
51		test__floatuntidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
52		test__floatuntidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
53		test__floatuntidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
54		test__floatuntidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
55		test__floatuntidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
56		test__floatuntidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
57		test__floatuntidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
58		test__floatuntidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
59		test__floatuntidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
60		test__floatuntidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
61		test__floatuntidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
62		test__floatuntidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
	48	try test__floatuntidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
	49	try test__floatuntidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57);
	50	try test__floatuntidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57);
	51	try test__floatuntidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57);
	52	try test__floatuntidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57);
	53	try test__floatuntidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57);
	54	try test__floatuntidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57);
	55	try test__floatuntidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57);
	56	try test__floatuntidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57);
	57	try test__floatuntidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57);
	58	try test__floatuntidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57);
	59	try test__floatuntidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57);
	60	try test__floatuntidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57);
	61	try test__floatuntidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57);
	62	try test__floatuntidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
63	63
64		test__floatuntidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
65		test__floatuntidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121);
66		test__floatuntidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121);
67		test__floatuntidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121);
68		test__floatuntidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121);
69		test__floatuntidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121);
70		test__floatuntidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121);
71		test__floatuntidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121);
72		test__floatuntidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121);
73		test__floatuntidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121);
74		test__floatuntidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121);
75		test__floatuntidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121);
76		test__floatuntidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121);
77		test__floatuntidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121);
78		test__floatuntidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
	64	try test__floatuntidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
	65	try test__floatuntidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121);
	66	try test__floatuntidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121);
	67	try test__floatuntidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121);
	68	try test__floatuntidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121);
	69	try test__floatuntidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121);
	70	try test__floatuntidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121);
	71	try test__floatuntidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121);
	72	try test__floatuntidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121);
	73	try test__floatuntidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121);
	74	try test__floatuntidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121);
	75	try test__floatuntidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121);
	76	try test__floatuntidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121);
	77	try test__floatuntidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121);
	78	try test__floatuntidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
79	79	}
80	80
81	81	fn make_ti(high: u64, low: u64) u128 {

lib/std/special/compiler_rt/floatuntisf_test.zig+43-43

...	...	@@ -6,67 +6,67 @@
6	6	const __floatuntisf = @import("floatuntisf.zig").__floatuntisf;
7	7	const testing = @import("std").testing;
8	8
9		fn test__floatuntisf(a: u128, expected: f32) void {
	9	fn test__floatuntisf(a: u128, expected: f32) !void {
10	10	const x = __floatuntisf(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "floatuntisf" {
15		test__floatuntisf(0, 0.0);
	15	try test__floatuntisf(0, 0.0);
16	16
17		test__floatuntisf(1, 1.0);
18		test__floatuntisf(2, 2.0);
19		test__floatuntisf(20, 20.0);
	17	try test__floatuntisf(1, 1.0);
	18	try test__floatuntisf(2, 2.0);
	19	try test__floatuntisf(20, 20.0);
20	20
21		test__floatuntisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
22		test__floatuntisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
	21	try test__floatuntisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
	22	try test__floatuntisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
23	23
24		test__floatuntisf(make_ti(0x8000008000000000, 0), 0x1.000001p+127);
25		test__floatuntisf(make_ti(0x8000000000000800, 0), 0x1.0p+127);
26		test__floatuntisf(make_ti(0x8000010000000000, 0), 0x1.000002p+127);
	24	try test__floatuntisf(make_ti(0x8000008000000000, 0), 0x1.000001p+127);
	25	try test__floatuntisf(make_ti(0x8000000000000800, 0), 0x1.0p+127);
	26	try test__floatuntisf(make_ti(0x8000010000000000, 0), 0x1.000002p+127);
27	27
28		test__floatuntisf(make_ti(0x8000000000000000, 0), 0x1.000000p+127);
	28	try test__floatuntisf(make_ti(0x8000000000000000, 0), 0x1.000000p+127);
29	29
30		test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
	30	try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
31	31
32		test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
33		test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
	32	try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
	33	try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
34	34
35		test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
	35	try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
36	36
37		test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
38		test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
39		test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
	37	try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
	38	try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
	39	try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
40	40
41		test__floatuntisf(0xFFFFFFFFFFFFFFFE, 0x1p+64);
42		test__floatuntisf(0xFFFFFFFFFFFFFFFF, 0x1p+64);
	41	try test__floatuntisf(0xFFFFFFFFFFFFFFFE, 0x1p+64);
	42	try test__floatuntisf(0xFFFFFFFFFFFFFFFF, 0x1p+64);
43	43
44		test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
	44	try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
45	45
46		test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
47		test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
48		test__floatuntisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
49		test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
50		test__floatuntisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
	46	try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
	47	try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
	48	try test__floatuntisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
	49	try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
	50	try test__floatuntisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
51	51
52		test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
53		test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
54		test__floatuntisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
55		test__floatuntisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
56		test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
	52	try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
	53	try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
	54	try test__floatuntisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
	55	try test__floatuntisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
	56	try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
57	57
58		test__floatuntisf(make_ti(0x0000000000001FED, 0xCB90000000000001), 0x1.FEDCBAp+76);
59		test__floatuntisf(make_ti(0x0000000000001FED, 0xCBA0000000000000), 0x1.FEDCBAp+76);
60		test__floatuntisf(make_ti(0x0000000000001FED, 0xCBAFFFFFFFFFFFFF), 0x1.FEDCBAp+76);
61		test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000000), 0x1.FEDCBCp+76);
62		test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000001), 0x1.FEDCBCp+76);
63		test__floatuntisf(make_ti(0x0000000000001FED, 0xCBBFFFFFFFFFFFFF), 0x1.FEDCBCp+76);
64		test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000000), 0x1.FEDCBCp+76);
65		test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000001), 0x1.FEDCBCp+76);
66		test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000000), 0x1.FEDCBCp+76);
67		test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000001), 0x1.FEDCBEp+76);
68		test__floatuntisf(make_ti(0x0000000000001FED, 0xCBDFFFFFFFFFFFFF), 0x1.FEDCBEp+76);
69		test__floatuntisf(make_ti(0x0000000000001FED, 0xCBE0000000000000), 0x1.FEDCBEp+76);
	58	try test__floatuntisf(make_ti(0x0000000000001FED, 0xCB90000000000001), 0x1.FEDCBAp+76);
	59	try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBA0000000000000), 0x1.FEDCBAp+76);
	60	try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBAFFFFFFFFFFFFF), 0x1.FEDCBAp+76);
	61	try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000000), 0x1.FEDCBCp+76);
	62	try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000001), 0x1.FEDCBCp+76);
	63	try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBBFFFFFFFFFFFFF), 0x1.FEDCBCp+76);
	64	try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000000), 0x1.FEDCBCp+76);
	65	try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000001), 0x1.FEDCBCp+76);
	66	try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000000), 0x1.FEDCBCp+76);
	67	try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000001), 0x1.FEDCBEp+76);
	68	try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBDFFFFFFFFFFFFF), 0x1.FEDCBEp+76);
	69	try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBE0000000000000), 0x1.FEDCBEp+76);
70	70	}
71	71
72	72	fn make_ti(high: u64, low: u64) u128 {

lib/std/special/compiler_rt/floatuntitf_test.zig+71-71

...	...	@@ -6,94 +6,94 @@
6	6	const __floatuntitf = @import("floatuntitf.zig").__floatuntitf;
7	7	const testing = @import("std").testing;
8	8
9		fn test__floatuntitf(a: u128, expected: f128) void {
	9	fn test__floatuntitf(a: u128, expected: f128) !void {
10	10	const x = __floatuntitf(a);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "floatuntitf" {
15		test__floatuntitf(0, 0.0);
	15	try test__floatuntitf(0, 0.0);
16	16
17		test__floatuntitf(1, 1.0);
18		test__floatuntitf(2, 2.0);
19		test__floatuntitf(20, 20.0);
	17	try test__floatuntitf(1, 1.0);
	18	try test__floatuntitf(2, 2.0);
	19	try test__floatuntitf(20, 20.0);
20	20
21		test__floatuntitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
22		test__floatuntitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
23		test__floatuntitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
24		test__floatuntitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
25		test__floatuntitf(0x7FFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFEp+59);
26		test__floatuntitf(0xFFFFFFFFFFFFFFFE, 0xF.FFFFFFFFFFFFFFEp+60);
27		test__floatuntitf(0xFFFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFFp+60);
	21	try test__floatuntitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
	22	try test__floatuntitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
	23	try test__floatuntitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
	24	try test__floatuntitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
	25	try test__floatuntitf(0x7FFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFEp+59);
	26	try test__floatuntitf(0xFFFFFFFFFFFFFFFE, 0xF.FFFFFFFFFFFFFFEp+60);
	27	try test__floatuntitf(0xFFFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFFp+60);
28	28
29		test__floatuntitf(0x8000008000000000, 0x8.000008p+60);
30		test__floatuntitf(0x8000000000000800, 0x8.0000000000008p+60);
31		test__floatuntitf(0x8000010000000000, 0x8.00001p+60);
32		test__floatuntitf(0x8000000000001000, 0x8.000000000001p+60);
	29	try test__floatuntitf(0x8000008000000000, 0x8.000008p+60);
	30	try test__floatuntitf(0x8000000000000800, 0x8.0000000000008p+60);
	31	try test__floatuntitf(0x8000010000000000, 0x8.00001p+60);
	32	try test__floatuntitf(0x8000000000001000, 0x8.000000000001p+60);
33	33
34		test__floatuntitf(0x8000000000000000, 0x8p+60);
35		test__floatuntitf(0x8000000000000001, 0x8.000000000000001p+60);
	34	try test__floatuntitf(0x8000000000000000, 0x8p+60);
	35	try test__floatuntitf(0x8000000000000001, 0x8.000000000000001p+60);
36	36
37		test__floatuntitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
	37	try test__floatuntitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
38	38
39		test__floatuntitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
40		test__floatuntitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
41		test__floatuntitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
42		test__floatuntitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
43		test__floatuntitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
	39	try test__floatuntitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
	40	try test__floatuntitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
	41	try test__floatuntitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
	42	try test__floatuntitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
	43	try test__floatuntitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
44	44
45		test__floatuntitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
46		test__floatuntitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
47		test__floatuntitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
48		test__floatuntitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
49		test__floatuntitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
	45	try test__floatuntitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
	46	try test__floatuntitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
	47	try test__floatuntitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
	48	try test__floatuntitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
	49	try test__floatuntitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
50	50
51		test__floatuntitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
52		test__floatuntitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);
53		test__floatuntitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);
54		test__floatuntitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);
55		test__floatuntitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);
56		test__floatuntitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);
57		test__floatuntitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);
58		test__floatuntitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);
59		test__floatuntitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);
60		test__floatuntitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);
61		test__floatuntitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);
62		test__floatuntitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);
63		test__floatuntitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);
64		test__floatuntitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);
65		test__floatuntitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
	51	try test__floatuntitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
	52	try test__floatuntitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);
	53	try test__floatuntitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);
	54	try test__floatuntitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);
	55	try test__floatuntitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);
	56	try test__floatuntitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);
	57	try test__floatuntitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);
	58	try test__floatuntitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);
	59	try test__floatuntitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);
	60	try test__floatuntitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);
	61	try test__floatuntitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);
	62	try test__floatuntitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);
	63	try test__floatuntitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);
	64	try test__floatuntitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);
	65	try test__floatuntitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
66	66
67		test__floatuntitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
68		test__floatuntitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);
69		test__floatuntitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);
70		test__floatuntitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);
71		test__floatuntitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);
72		test__floatuntitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);
73		test__floatuntitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);
74		test__floatuntitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);
75		test__floatuntitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);
76		test__floatuntitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);
77		test__floatuntitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);
78		test__floatuntitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);
79		test__floatuntitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);
80		test__floatuntitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);
81		test__floatuntitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
	67	try test__floatuntitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
	68	try test__floatuntitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);
	69	try test__floatuntitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);
	70	try test__floatuntitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);
	71	try test__floatuntitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);
	72	try test__floatuntitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);
	73	try test__floatuntitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);
	74	try test__floatuntitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);
	75	try test__floatuntitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);
	76	try test__floatuntitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);
	77	try test__floatuntitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);
	78	try test__floatuntitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);
	79	try test__floatuntitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);
	80	try test__floatuntitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);
	81	try test__floatuntitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
82	82
83		test__floatuntitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);
	83	try test__floatuntitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);
84	84
85		test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0x0000000000000000), 0x1.FFFFFFFFFFFFFFFEp+127);
86		test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x1.0000000000000000p+128);
	85	try test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0x0000000000000000), 0x1.FFFFFFFFFFFFFFFEp+127);
	86	try test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x1.0000000000000000p+128);
87	87
88		test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);
89		test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);
90		test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);
91		test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);
92		test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);
93		test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);
94		test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);
95		test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);
96		test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);
	88	try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);
	89	try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);
	90	try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);
	91	try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);
	92	try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);
	93	try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);
	94	try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);
	95	try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);
	96	try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);
97	97	}
98	98
99	99	fn make_ti(high: u64, low: u64) u128 {

lib/std/special/compiler_rt/int.zig+57-57

...	...	@@ -58,11 +58,11 @@ test "test_divdi3" {
58	58	};
59	59
60	60	for (cases) \|case\| {
61		test_one_divdi3(case[0], case[1], case[2]);
	61	try test_one_divdi3(case[0], case[1], case[2]);
62	62	}
63	63	}
64	64
65		fn test_one_divdi3(a: i64, b: i64, expected_q: i64) void {
	65	fn test_one_divdi3(a: i64, b: i64, expected_q: i64) !void {
66	66	const q: i64 = __divdi3(a, b);
67	67	try testing.expect(q == expected_q);
68	68	}
...	...	@@ -98,11 +98,11 @@ test "test_moddi3" {
98	98	};
99	99
100	100	for (cases) \|case\| {
101		test_one_moddi3(case[0], case[1], case[2]);
	101	try test_one_moddi3(case[0], case[1], case[2]);
102	102	}
103	103	}
104	104
105		fn test_one_moddi3(a: i64, b: i64, expected_r: i64) void {
	105	fn test_one_moddi3(a: i64, b: i64, expected_r: i64) !void {
106	106	const r: i64 = __moddi3(a, b);
107	107	try testing.expect(r == expected_r);
108	108	}
...	...	@@ -121,14 +121,14 @@ pub fn __umoddi3(a: u64, b: u64) callconv(.C) u64 {
121	121	}
122	122
123	123	test "test_umoddi3" {
124		test_one_umoddi3(0, 1, 0);
125		test_one_umoddi3(2, 1, 0);
126		test_one_umoddi3(0x8000000000000000, 1, 0x0);
127		test_one_umoddi3(0x8000000000000000, 2, 0x0);
128		test_one_umoddi3(0xFFFFFFFFFFFFFFFF, 2, 0x1);
	124	try test_one_umoddi3(0, 1, 0);
	125	try test_one_umoddi3(2, 1, 0);
	126	try test_one_umoddi3(0x8000000000000000, 1, 0x0);
	127	try test_one_umoddi3(0x8000000000000000, 2, 0x0);
	128	try test_one_umoddi3(0xFFFFFFFFFFFFFFFF, 2, 0x1);
129	129	}
130	130
131		fn test_one_umoddi3(a: u64, b: u64, expected_r: u64) void {
	131	fn test_one_umoddi3(a: u64, b: u64, expected_r: u64) !void {
132	132	const r = __umoddi3(a, b);
133	133	try testing.expect(r == expected_r);
134	134	}
...	...	@@ -159,11 +159,11 @@ test "test_divmodsi4" {
159	159	};
160	160
161	161	for (cases) \|case\| {
162		test_one_divmodsi4(case[0], case[1], case[2], case[3]);
	162	try test_one_divmodsi4(case[0], case[1], case[2], case[3]);
163	163	}
164	164	}
165	165
166		fn test_one_divmodsi4(a: i32, b: i32, expected_q: i32, expected_r: i32) void {
	166	fn test_one_divmodsi4(a: i32, b: i32, expected_q: i32, expected_r: i32) !void {
167	167	var r: i32 = undefined;
168	168	const q: i32 = __divmodsi4(a, b, &r);
169	169	try testing.expect(q == expected_q and r == expected_r);
...	...	@@ -207,11 +207,11 @@ test "test_divsi3" {
207	207	};
208	208
209	209	for (cases) \|case\| {
210		test_one_divsi3(case[0], case[1], case[2]);
	210	try test_one_divsi3(case[0], case[1], case[2]);
211	211	}
212	212	}
213	213
214		fn test_one_divsi3(a: i32, b: i32, expected_q: i32) void {
	214	fn test_one_divsi3(a: i32, b: i32, expected_q: i32) !void {
215	215	const q: i32 = __divsi3(a, b);
216	216	try testing.expect(q == expected_q);
217	217	}
...	...	@@ -394,11 +394,11 @@ test "test_udivsi3" {
394	394	};
395	395
396	396	for (cases) \|case\| {
397		test_one_udivsi3(case[0], case[1], case[2]);
	397	try test_one_udivsi3(case[0], case[1], case[2]);
398	398	}
399	399	}
400	400
401		fn test_one_udivsi3(a: u32, b: u32, expected_q: u32) void {
	401	fn test_one_udivsi3(a: u32, b: u32, expected_q: u32) !void {
402	402	const q: u32 = __udivsi3(a, b);
403	403	try testing.expect(q == expected_q);
404	404	}
...	...	@@ -425,11 +425,11 @@ test "test_modsi3" {
425	425	};
426	426
427	427	for (cases) \|case\| {
428		test_one_modsi3(case[0], case[1], case[2]);
	428	try test_one_modsi3(case[0], case[1], case[2]);
429	429	}
430	430	}
431	431
432		fn test_one_modsi3(a: i32, b: i32, expected_r: i32) void {
	432	fn test_one_modsi3(a: i32, b: i32, expected_r: i32) !void {
433	433	const r: i32 = __modsi3(a, b);
434	434	try testing.expect(r == expected_r);
435	435	}
...	...	@@ -577,11 +577,11 @@ test "test_umodsi3" {
577	577	};
578	578
579	579	for (cases) \|case\| {
580		test_one_umodsi3(case[0], case[1], case[2]);
	580	try test_one_umodsi3(case[0], case[1], case[2]);
581	581	}
582	582	}
583	583
584		fn test_one_umodsi3(a: u32, b: u32, expected_r: u32) void {
	584	fn test_one_umodsi3(a: u32, b: u32, expected_r: u32) !void {
585	585	const r: u32 = __umodsi3(a, b);
586	586	try testing.expect(r == expected_r);
587	587	}
...	...	@@ -602,44 +602,44 @@ pub fn __mulsi3(a: i32, b: i32) callconv(.C) i32 {
602	602	return @bitCast(i32, r);
603	603	}
604	604
605		fn test_one_mulsi3(a: i32, b: i32, result: i32) void {
606		testing.expectEqual(result, __mulsi3(a, b));
	605	fn test_one_mulsi3(a: i32, b: i32, result: i32) !void {
	606	try testing.expectEqual(result, __mulsi3(a, b));
607	607	}
608	608
609	609	test "mulsi3" {
610		test_one_mulsi3(0, 0, 0);
611		test_one_mulsi3(0, 1, 0);
612		test_one_mulsi3(1, 0, 0);
613		test_one_mulsi3(0, 10, 0);
614		test_one_mulsi3(10, 0, 0);
615		test_one_mulsi3(0, maxInt(i32), 0);
616		test_one_mulsi3(maxInt(i32), 0, 0);
617		test_one_mulsi3(0, -1, 0);
618		test_one_mulsi3(-1, 0, 0);
619		test_one_mulsi3(0, -10, 0);
620		test_one_mulsi3(-10, 0, 0);
621		test_one_mulsi3(0, minInt(i32), 0);
622		test_one_mulsi3(minInt(i32), 0, 0);
623		test_one_mulsi3(1, 1, 1);
624		test_one_mulsi3(1, 10, 10);
625		test_one_mulsi3(10, 1, 10);
626		test_one_mulsi3(1, maxInt(i32), maxInt(i32));
627		test_one_mulsi3(maxInt(i32), 1, maxInt(i32));
628		test_one_mulsi3(1, -1, -1);
629		test_one_mulsi3(1, -10, -10);
630		test_one_mulsi3(-10, 1, -10);
631		test_one_mulsi3(1, minInt(i32), minInt(i32));
632		test_one_mulsi3(minInt(i32), 1, minInt(i32));
633		test_one_mulsi3(46340, 46340, 2147395600);
634		test_one_mulsi3(-46340, 46340, -2147395600);
635		test_one_mulsi3(46340, -46340, -2147395600);
636		test_one_mulsi3(-46340, -46340, 2147395600);
637		test_one_mulsi3(4194303, 8192, @truncate(i32, 34359730176));
638		test_one_mulsi3(-4194303, 8192, @truncate(i32, -34359730176));
639		test_one_mulsi3(4194303, -8192, @truncate(i32, -34359730176));
640		test_one_mulsi3(-4194303, -8192, @truncate(i32, 34359730176));
641		test_one_mulsi3(8192, 4194303, @truncate(i32, 34359730176));
642		test_one_mulsi3(-8192, 4194303, @truncate(i32, -34359730176));
643		test_one_mulsi3(8192, -4194303, @truncate(i32, -34359730176));
644		test_one_mulsi3(-8192, -4194303, @truncate(i32, 34359730176));
	610	try test_one_mulsi3(0, 0, 0);
	611	try test_one_mulsi3(0, 1, 0);
	612	try test_one_mulsi3(1, 0, 0);
	613	try test_one_mulsi3(0, 10, 0);
	614	try test_one_mulsi3(10, 0, 0);
	615	try test_one_mulsi3(0, maxInt(i32), 0);
	616	try test_one_mulsi3(maxInt(i32), 0, 0);
	617	try test_one_mulsi3(0, -1, 0);
	618	try test_one_mulsi3(-1, 0, 0);
	619	try test_one_mulsi3(0, -10, 0);
	620	try test_one_mulsi3(-10, 0, 0);
	621	try test_one_mulsi3(0, minInt(i32), 0);
	622	try test_one_mulsi3(minInt(i32), 0, 0);
	623	try test_one_mulsi3(1, 1, 1);
	624	try test_one_mulsi3(1, 10, 10);
	625	try test_one_mulsi3(10, 1, 10);
	626	try test_one_mulsi3(1, maxInt(i32), maxInt(i32));
	627	try test_one_mulsi3(maxInt(i32), 1, maxInt(i32));
	628	try test_one_mulsi3(1, -1, -1);
	629	try test_one_mulsi3(1, -10, -10);
	630	try test_one_mulsi3(-10, 1, -10);
	631	try test_one_mulsi3(1, minInt(i32), minInt(i32));
	632	try test_one_mulsi3(minInt(i32), 1, minInt(i32));
	633	try test_one_mulsi3(46340, 46340, 2147395600);
	634	try test_one_mulsi3(-46340, 46340, -2147395600);
	635	try test_one_mulsi3(46340, -46340, -2147395600);
	636	try test_one_mulsi3(-46340, -46340, 2147395600);
	637	try test_one_mulsi3(4194303, 8192, @truncate(i32, 34359730176));
	638	try test_one_mulsi3(-4194303, 8192, @truncate(i32, -34359730176));
	639	try test_one_mulsi3(4194303, -8192, @truncate(i32, -34359730176));
	640	try test_one_mulsi3(-4194303, -8192, @truncate(i32, 34359730176));
	641	try test_one_mulsi3(8192, 4194303, @truncate(i32, 34359730176));
	642	try test_one_mulsi3(-8192, 4194303, @truncate(i32, -34359730176));
	643	try test_one_mulsi3(8192, -4194303, @truncate(i32, -34359730176));
	644	try test_one_mulsi3(-8192, -4194303, @truncate(i32, 34359730176));
645	645	}

lib/std/special/compiler_rt/lshrdi3_test.zig+47-47

...	...	@@ -6,55 +6,55 @@
6	6	const __lshrdi3 = @import("shift.zig").__lshrdi3;
7	7	const testing = @import("std").testing;
8	8
9		fn test__lshrdi3(a: i64, b: i32, expected: u64) void {
	9	fn test__lshrdi3(a: i64, b: i32, expected: u64) !void {
10	10	const x = __lshrdi3(a, b);
11		testing.expectEqual(@bitCast(i64, expected), x);
	11	try testing.expectEqual(@bitCast(i64, expected), x);
12	12	}
13	13
14	14	test "lshrdi3" {
15		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF);
16		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x91A2B3C4D5E6F7);
17		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37B);
18		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x2468ACF13579BD);
19		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDE);
20
21		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x12345678);
22		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0x91A2B3C);
23		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0x48D159E);
24		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0x2468ACF);
25
26		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x1234567);
27
28		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x91A2B3);
29		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x48D159);
30		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x2468AC);
31		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x123456);
32
33		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0);
34		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0);
35		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0);
36		test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0);
37
38		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 0, 0xFEDCBA9876543210);
39		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 1, 0x7F6E5D4C3B2A1908);
40		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 2, 0x3FB72EA61D950C84);
41		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 3, 0x1FDB97530ECA8642);
42		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 4, 0xFEDCBA987654321);
43
44		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 28, 0xFEDCBA987);
45		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 29, 0x7F6E5D4C3);
46		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 30, 0x3FB72EA61);
47		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 31, 0x1FDB97530);
48
49		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 32, 0xFEDCBA98);
50
51		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 33, 0x7F6E5D4C);
52		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 34, 0x3FB72EA6);
53		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 35, 0x1FDB9753);
54		test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 36, 0xFEDCBA9);
55
56		test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 60, 0xA);
57		test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 61, 0x5);
58		test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 62, 0x2);
59		test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 63, 0x1);
	15	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 0, 0x123456789ABCDEF);
	16	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 1, 0x91A2B3C4D5E6F7);
	17	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 2, 0x48D159E26AF37B);
	18	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 3, 0x2468ACF13579BD);
	19	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 4, 0x123456789ABCDE);
	20
	21	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 28, 0x12345678);
	22	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 29, 0x91A2B3C);
	23	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 30, 0x48D159E);
	24	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 31, 0x2468ACF);
	25
	26	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 32, 0x1234567);
	27
	28	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 33, 0x91A2B3);
	29	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 34, 0x48D159);
	30	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 35, 0x2468AC);
	31	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 36, 0x123456);
	32
	33	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 60, 0);
	34	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 61, 0);
	35	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 62, 0);
	36	try test__lshrdi3(@bitCast(i64, @as(u64, 0x0123456789ABCDEF)), 63, 0);
	37
	38	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 0, 0xFEDCBA9876543210);
	39	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 1, 0x7F6E5D4C3B2A1908);
	40	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 2, 0x3FB72EA61D950C84);
	41	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 3, 0x1FDB97530ECA8642);
	42	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 4, 0xFEDCBA987654321);
	43
	44	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 28, 0xFEDCBA987);
	45	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 29, 0x7F6E5D4C3);
	46	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 30, 0x3FB72EA61);
	47	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 31, 0x1FDB97530);
	48
	49	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 32, 0xFEDCBA98);
	50
	51	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 33, 0x7F6E5D4C);
	52	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 34, 0x3FB72EA6);
	53	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 35, 0x1FDB9753);
	54	try test__lshrdi3(@bitCast(i64, @as(u64, 0xFEDCBA9876543210)), 36, 0xFEDCBA9);
	55
	56	try test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 60, 0xA);
	57	try test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 61, 0x5);
	58	try test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 62, 0x2);
	59	try test__lshrdi3(@bitCast(i64, @as(u64, 0xAEDCBA9876543210)), 63, 0x1);
60	60	}

lib/std/special/compiler_rt/lshrti3_test.zig+38-38

...	...	@@ -6,46 +6,46 @@
6	6	const __lshrti3 = @import("shift.zig").__lshrti3;
7	7	const testing = @import("std").testing;
8	8
9		fn test__lshrti3(a: i128, b: i32, expected: i128) void {
	9	fn test__lshrti3(a: i128, b: i32, expected: i128) !void {
10	10	const x = __lshrti3(a, b);
11		testing.expectEqual(expected, x);
	11	try testing.expectEqual(expected, x);
12	12	}
13	13
14	14	test "lshrti3" {
15		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)));
16		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0x7F6E5D4C3B2A190AFF6E5D4C3B2A190A)));
17		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0x3FB72EA61D950C857FB72EA61D950C85)));
18		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0x1FDB97530ECA8642BFDB97530ECA8642)));
19		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0x0FEDCBA9876543215FEDCBA987654321)));
20		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0x0000000FEDCBA9876543215FEDCBA987)));
21		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0x00000007F6E5D4C3B2A190AFF6E5D4C3)));
22		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0x00000003FB72EA61D950C857FB72EA61)));
23		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0x00000001FDB97530ECA8642BFDB97530)));
24		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0x00000000FEDCBA9876543215FEDCBA98)));
25		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0x000000007F6E5D4C3B2A190AFF6E5D4C)));
26		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0x000000003FB72EA61D950C857FB72EA6)));
27		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0x000000001FDB97530ECA8642BFDB9753)));
28		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0x000000000FEDCBA9876543215FEDCBA9)));
29		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0x000000000000000FEDCBA9876543215F)));
30		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0x0000000000000007F6E5D4C3B2A190AF)));
31		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0x0000000000000003FB72EA61D950C857)));
32		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0x0000000000000001FDB97530ECA8642B)));
33		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0x0000000000000000FEDCBA9876543215)));
34		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0x00000000000000007F6E5D4C3B2A190A)));
35		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0x00000000000000003FB72EA61D950C85)));
36		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0x00000000000000001FDB97530ECA8642)));
37		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0x00000000000000000FEDCBA987654321)));
38		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0x00000000000000000000000FEDCBA987)));
39		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0x000000000000000000000007F6E5D4C3)));
40		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0x000000000000000000000003FB72EA61)));
41		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0x000000000000000000000001FDB97530)));
42		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0x000000000000000000000000FEDCBA98)));
43		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0x0000000000000000000000007F6E5D4C)));
44		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0x0000000000000000000000003FB72EA6)));
45		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0x0000000000000000000000001FDB9753)));
46		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0x0000000000000000000000000FEDCBA9)));
47		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0x0000000000000000000000000000000F)));
48		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000007)));
49		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000003)));
50		test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000001)));
	15	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 0, @bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)));
	16	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 1, @bitCast(i128, @intCast(u128, 0x7F6E5D4C3B2A190AFF6E5D4C3B2A190A)));
	17	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 2, @bitCast(i128, @intCast(u128, 0x3FB72EA61D950C857FB72EA61D950C85)));
	18	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 3, @bitCast(i128, @intCast(u128, 0x1FDB97530ECA8642BFDB97530ECA8642)));
	19	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 4, @bitCast(i128, @intCast(u128, 0x0FEDCBA9876543215FEDCBA987654321)));
	20	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 28, @bitCast(i128, @intCast(u128, 0x0000000FEDCBA9876543215FEDCBA987)));
	21	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 29, @bitCast(i128, @intCast(u128, 0x00000007F6E5D4C3B2A190AFF6E5D4C3)));
	22	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 30, @bitCast(i128, @intCast(u128, 0x00000003FB72EA61D950C857FB72EA61)));
	23	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 31, @bitCast(i128, @intCast(u128, 0x00000001FDB97530ECA8642BFDB97530)));
	24	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 32, @bitCast(i128, @intCast(u128, 0x00000000FEDCBA9876543215FEDCBA98)));
	25	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 33, @bitCast(i128, @intCast(u128, 0x000000007F6E5D4C3B2A190AFF6E5D4C)));
	26	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 34, @bitCast(i128, @intCast(u128, 0x000000003FB72EA61D950C857FB72EA6)));
	27	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 35, @bitCast(i128, @intCast(u128, 0x000000001FDB97530ECA8642BFDB9753)));
	28	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 36, @bitCast(i128, @intCast(u128, 0x000000000FEDCBA9876543215FEDCBA9)));
	29	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 60, @bitCast(i128, @intCast(u128, 0x000000000000000FEDCBA9876543215F)));
	30	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 61, @bitCast(i128, @intCast(u128, 0x0000000000000007F6E5D4C3B2A190AF)));
	31	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 62, @bitCast(i128, @intCast(u128, 0x0000000000000003FB72EA61D950C857)));
	32	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 63, @bitCast(i128, @intCast(u128, 0x0000000000000001FDB97530ECA8642B)));
	33	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 64, @bitCast(i128, @intCast(u128, 0x0000000000000000FEDCBA9876543215)));
	34	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 65, @bitCast(i128, @intCast(u128, 0x00000000000000007F6E5D4C3B2A190A)));
	35	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 66, @bitCast(i128, @intCast(u128, 0x00000000000000003FB72EA61D950C85)));
	36	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 67, @bitCast(i128, @intCast(u128, 0x00000000000000001FDB97530ECA8642)));
	37	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 68, @bitCast(i128, @intCast(u128, 0x00000000000000000FEDCBA987654321)));
	38	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 92, @bitCast(i128, @intCast(u128, 0x00000000000000000000000FEDCBA987)));
	39	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 93, @bitCast(i128, @intCast(u128, 0x000000000000000000000007F6E5D4C3)));
	40	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 94, @bitCast(i128, @intCast(u128, 0x000000000000000000000003FB72EA61)));
	41	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 95, @bitCast(i128, @intCast(u128, 0x000000000000000000000001FDB97530)));
	42	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 96, @bitCast(i128, @intCast(u128, 0x000000000000000000000000FEDCBA98)));
	43	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 97, @bitCast(i128, @intCast(u128, 0x0000000000000000000000007F6E5D4C)));
	44	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 98, @bitCast(i128, @intCast(u128, 0x0000000000000000000000003FB72EA6)));
	45	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 99, @bitCast(i128, @intCast(u128, 0x0000000000000000000000001FDB9753)));
	46	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 100, @bitCast(i128, @intCast(u128, 0x0000000000000000000000000FEDCBA9)));
	47	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 124, @bitCast(i128, @intCast(u128, 0x0000000000000000000000000000000F)));
	48	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 125, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000007)));
	49	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 126, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000003)));
	50	try test__lshrti3(@bitCast(i128, @intCast(u128, 0xFEDCBA9876543215FEDCBA9876543215)), 127, @bitCast(i128, @intCast(u128, 0x00000000000000000000000000000001)));
51	51	}

lib/std/special/compiler_rt/modti3_test.zig+19-19

...	...	@@ -6,32 +6,32 @@
6	6	const __modti3 = @import("modti3.zig").__modti3;
7	7	const testing = @import("std").testing;
8	8
9		fn test__modti3(a: i128, b: i128, expected: i128) void {
	9	fn test__modti3(a: i128, b: i128, expected: i128) !void {
10	10	const x = __modti3(a, b);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "modti3" {
15		test__modti3(0, 1, 0);
16		test__modti3(0, -1, 0);
17		test__modti3(5, 3, 2);
18		test__modti3(5, -3, 2);
19		test__modti3(-5, 3, -2);
20		test__modti3(-5, -3, -2);
	15	try test__modti3(0, 1, 0);
	16	try test__modti3(0, -1, 0);
	17	try test__modti3(5, 3, 2);
	18	try test__modti3(5, -3, 2);
	19	try test__modti3(-5, 3, -2);
	20	try test__modti3(-5, -3, -2);
21	21
22		test__modti3(0x8000000000000000, 1, 0x0);
23		test__modti3(0x8000000000000000, -1, 0x0);
24		test__modti3(0x8000000000000000, 2, 0x0);
25		test__modti3(0x8000000000000000, -2, 0x0);
26		test__modti3(0x8000000000000000, 3, 2);
27		test__modti3(0x8000000000000000, -3, 2);
	22	try test__modti3(0x8000000000000000, 1, 0x0);
	23	try test__modti3(0x8000000000000000, -1, 0x0);
	24	try test__modti3(0x8000000000000000, 2, 0x0);
	25	try test__modti3(0x8000000000000000, -2, 0x0);
	26	try test__modti3(0x8000000000000000, 3, 2);
	27	try test__modti3(0x8000000000000000, -3, 2);
28	28
29		test__modti3(make_ti(0x8000000000000000, 0), 1, 0x0);
30		test__modti3(make_ti(0x8000000000000000, 0), -1, 0x0);
31		test__modti3(make_ti(0x8000000000000000, 0), 2, 0x0);
32		test__modti3(make_ti(0x8000000000000000, 0), -2, 0x0);
33		test__modti3(make_ti(0x8000000000000000, 0), 3, -2);
34		test__modti3(make_ti(0x8000000000000000, 0), -3, -2);
	29	try test__modti3(make_ti(0x8000000000000000, 0), 1, 0x0);
	30	try test__modti3(make_ti(0x8000000000000000, 0), -1, 0x0);
	31	try test__modti3(make_ti(0x8000000000000000, 0), 2, 0x0);
	32	try test__modti3(make_ti(0x8000000000000000, 0), -2, 0x0);
	33	try test__modti3(make_ti(0x8000000000000000, 0), 3, -2);
	34	try test__modti3(make_ti(0x8000000000000000, 0), -3, -2);
35	35	}
36	36
37	37	fn make_ti(high: u64, low: u64) i128 {

lib/std/special/compiler_rt/mulXf3_test.zig+9-9

...	...	@@ -34,7 +34,7 @@ fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool {
34	34	return false;
35	35	}
36	36
37		fn test__multf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
	37	fn test__multf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
38	38	const x = __multf3(a, b);
39	39
40	40	if (compareResultLD(x, expected_hi, expected_lo))
...	...	@@ -50,42 +50,42 @@ fn makeNaN128(rand: u64) f128 {
50	50	}
51	51	test "multf3" {
52	52	// qNaN * any = qNaN
53		test__multf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
	53	try test__multf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
54	54
55	55	// NaN * any = NaN
56	56	const a = makeNaN128(0x800030000000);
57		test__multf3(a, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
	57	try test__multf3(a, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
58	58	// inf * any = inf
59		test__multf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
	59	try test__multf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
60	60
61	61	// any * any
62		test__multf3(
	62	try test__multf3(
63	63	@bitCast(f128, @as(u128, 0x40042eab345678439abcdefea5678234)),
64	64	@bitCast(f128, @as(u128, 0x3ffeedcb34a235253948765432134675)),
65	65	0x400423e7f9e3c9fc,
66	66	0xd906c2c2a85777c4,
67	67	);
68	68
69		test__multf3(
	69	try test__multf3(
70	70	@bitCast(f128, @as(u128, 0x3fcd353e45674d89abacc3a2ebf3ff50)),
71	71	@bitCast(f128, @as(u128, 0x3ff6ed8764648369535adf4be3214568)),
72	72	0x3fc52a163c6223fc,
73	73	0xc94c4bf0430768b4,
74	74	);
75	75
76		test__multf3(
	76	try test__multf3(
77	77	0x1.234425696abcad34a35eeffefdcbap+456,
78	78	0x451.ed98d76e5d46e5f24323dff21ffp+600,
79	79	0x44293a91de5e0e94,
80	80	0xe8ed17cc2cdf64ac,
81	81	);
82	82
83		test__multf3(
	83	try test__multf3(
84	84	@bitCast(f128, @as(u128, 0x3f154356473c82a9fabf2d22ace345df)),
85	85	@bitCast(f128, @as(u128, 0x3e38eda98765476743ab21da23d45679)),
86	86	0x3d4f37c1a3137cae,
87	87	0xfc6807048bc2836a,
88	88	);
89	89
90		test__multf3(0x1.23456734245345p-10000, 0x1.edcba524498724p-6497, 0x0, 0x0);
	90	try test__multf3(0x1.23456734245345p-10000, 0x1.edcba524498724p-6497, 0x0, 0x0);
91	91	}

lib/std/special/compiler_rt/muldi3_test.zig+42-42

...	...	@@ -6,51 +6,51 @@
6	6	const __muldi3 = @import("muldi3.zig").__muldi3;
7	7	const testing = @import("std").testing;
8	8
9		fn test__muldi3(a: i64, b: i64, expected: i64) void {
	9	fn test__muldi3(a: i64, b: i64, expected: i64) !void {
10	10	const x = __muldi3(a, b);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "muldi3" {
15		test__muldi3(0, 0, 0);
16		test__muldi3(0, 1, 0);
17		test__muldi3(1, 0, 0);
18		test__muldi3(0, 10, 0);
19		test__muldi3(10, 0, 0);
20		test__muldi3(0, 81985529216486895, 0);
21		test__muldi3(81985529216486895, 0, 0);
22
23		test__muldi3(0, -1, 0);
24		test__muldi3(-1, 0, 0);
25		test__muldi3(0, -10, 0);
26		test__muldi3(-10, 0, 0);
27		test__muldi3(0, -81985529216486895, 0);
28		test__muldi3(-81985529216486895, 0, 0);
29
30		test__muldi3(1, 1, 1);
31		test__muldi3(1, 10, 10);
32		test__muldi3(10, 1, 10);
33		test__muldi3(1, 81985529216486895, 81985529216486895);
34		test__muldi3(81985529216486895, 1, 81985529216486895);
35
36		test__muldi3(1, -1, -1);
37		test__muldi3(1, -10, -10);
38		test__muldi3(-10, 1, -10);
39		test__muldi3(1, -81985529216486895, -81985529216486895);
40		test__muldi3(-81985529216486895, 1, -81985529216486895);
41
42		test__muldi3(3037000499, 3037000499, 9223372030926249001);
43		test__muldi3(-3037000499, 3037000499, -9223372030926249001);
44		test__muldi3(3037000499, -3037000499, -9223372030926249001);
45		test__muldi3(-3037000499, -3037000499, 9223372030926249001);
46
47		test__muldi3(4398046511103, 2097152, 9223372036852678656);
48		test__muldi3(-4398046511103, 2097152, -9223372036852678656);
49		test__muldi3(4398046511103, -2097152, -9223372036852678656);
50		test__muldi3(-4398046511103, -2097152, 9223372036852678656);
51
52		test__muldi3(2097152, 4398046511103, 9223372036852678656);
53		test__muldi3(-2097152, 4398046511103, -9223372036852678656);
54		test__muldi3(2097152, -4398046511103, -9223372036852678656);
55		test__muldi3(-2097152, -4398046511103, 9223372036852678656);
	15	try test__muldi3(0, 0, 0);
	16	try test__muldi3(0, 1, 0);
	17	try test__muldi3(1, 0, 0);
	18	try test__muldi3(0, 10, 0);
	19	try test__muldi3(10, 0, 0);
	20	try test__muldi3(0, 81985529216486895, 0);
	21	try test__muldi3(81985529216486895, 0, 0);
	22
	23	try test__muldi3(0, -1, 0);
	24	try test__muldi3(-1, 0, 0);
	25	try test__muldi3(0, -10, 0);
	26	try test__muldi3(-10, 0, 0);
	27	try test__muldi3(0, -81985529216486895, 0);
	28	try test__muldi3(-81985529216486895, 0, 0);
	29
	30	try test__muldi3(1, 1, 1);
	31	try test__muldi3(1, 10, 10);
	32	try test__muldi3(10, 1, 10);
	33	try test__muldi3(1, 81985529216486895, 81985529216486895);
	34	try test__muldi3(81985529216486895, 1, 81985529216486895);
	35
	36	try test__muldi3(1, -1, -1);
	37	try test__muldi3(1, -10, -10);
	38	try test__muldi3(-10, 1, -10);
	39	try test__muldi3(1, -81985529216486895, -81985529216486895);
	40	try test__muldi3(-81985529216486895, 1, -81985529216486895);
	41
	42	try test__muldi3(3037000499, 3037000499, 9223372030926249001);
	43	try test__muldi3(-3037000499, 3037000499, -9223372030926249001);
	44	try test__muldi3(3037000499, -3037000499, -9223372030926249001);
	45	try test__muldi3(-3037000499, -3037000499, 9223372030926249001);
	46
	47	try test__muldi3(4398046511103, 2097152, 9223372036852678656);
	48	try test__muldi3(-4398046511103, 2097152, -9223372036852678656);
	49	try test__muldi3(4398046511103, -2097152, -9223372036852678656);
	50	try test__muldi3(-4398046511103, -2097152, 9223372036852678656);
	51
	52	try test__muldi3(2097152, 4398046511103, 9223372036852678656);
	53	try test__muldi3(-2097152, 4398046511103, -9223372036852678656);
	54	try test__muldi3(2097152, -4398046511103, -9223372036852678656);
	55	try test__muldi3(-2097152, -4398046511103, 9223372036852678656);
56	56	}

lib/std/special/compiler_rt/mulodi4_test.zig+66-66

...	...	@@ -6,85 +6,85 @@
6	6	const __mulodi4 = @import("mulodi4.zig").__mulodi4;
7	7	const testing = @import("std").testing;
8	8
9		fn test__mulodi4(a: i64, b: i64, expected: i64, expected_overflow: c_int) void {
	9	fn test__mulodi4(a: i64, b: i64, expected: i64, expected_overflow: c_int) !void {
10	10	var overflow: c_int = undefined;
11	11	const x = __mulodi4(a, b, &overflow);
12	12	try testing.expect(overflow == expected_overflow and (expected_overflow != 0 or x == expected));
13	13	}
14	14
15	15	test "mulodi4" {
16		test__mulodi4(0, 0, 0, 0);
17		test__mulodi4(0, 1, 0, 0);
18		test__mulodi4(1, 0, 0, 0);
19		test__mulodi4(0, 10, 0, 0);
20		test__mulodi4(10, 0, 0, 0);
21		test__mulodi4(0, 81985529216486895, 0, 0);
22		test__mulodi4(81985529216486895, 0, 0, 0);
	16	try test__mulodi4(0, 0, 0, 0);
	17	try test__mulodi4(0, 1, 0, 0);
	18	try test__mulodi4(1, 0, 0, 0);
	19	try test__mulodi4(0, 10, 0, 0);
	20	try test__mulodi4(10, 0, 0, 0);
	21	try test__mulodi4(0, 81985529216486895, 0, 0);
	22	try test__mulodi4(81985529216486895, 0, 0, 0);
23	23
24		test__mulodi4(0, -1, 0, 0);
25		test__mulodi4(-1, 0, 0, 0);
26		test__mulodi4(0, -10, 0, 0);
27		test__mulodi4(-10, 0, 0, 0);
28		test__mulodi4(0, -81985529216486895, 0, 0);
29		test__mulodi4(-81985529216486895, 0, 0, 0);
	24	try test__mulodi4(0, -1, 0, 0);
	25	try test__mulodi4(-1, 0, 0, 0);
	26	try test__mulodi4(0, -10, 0, 0);
	27	try test__mulodi4(-10, 0, 0, 0);
	28	try test__mulodi4(0, -81985529216486895, 0, 0);
	29	try test__mulodi4(-81985529216486895, 0, 0, 0);
30	30
31		test__mulodi4(1, 1, 1, 0);
32		test__mulodi4(1, 10, 10, 0);
33		test__mulodi4(10, 1, 10, 0);
34		test__mulodi4(1, 81985529216486895, 81985529216486895, 0);
35		test__mulodi4(81985529216486895, 1, 81985529216486895, 0);
	31	try test__mulodi4(1, 1, 1, 0);
	32	try test__mulodi4(1, 10, 10, 0);
	33	try test__mulodi4(10, 1, 10, 0);
	34	try test__mulodi4(1, 81985529216486895, 81985529216486895, 0);
	35	try test__mulodi4(81985529216486895, 1, 81985529216486895, 0);
36	36
37		test__mulodi4(1, -1, -1, 0);
38		test__mulodi4(1, -10, -10, 0);
39		test__mulodi4(-10, 1, -10, 0);
40		test__mulodi4(1, -81985529216486895, -81985529216486895, 0);
41		test__mulodi4(-81985529216486895, 1, -81985529216486895, 0);
	37	try test__mulodi4(1, -1, -1, 0);
	38	try test__mulodi4(1, -10, -10, 0);
	39	try test__mulodi4(-10, 1, -10, 0);
	40	try test__mulodi4(1, -81985529216486895, -81985529216486895, 0);
	41	try test__mulodi4(-81985529216486895, 1, -81985529216486895, 0);
42	42
43		test__mulodi4(3037000499, 3037000499, 9223372030926249001, 0);
44		test__mulodi4(-3037000499, 3037000499, -9223372030926249001, 0);
45		test__mulodi4(3037000499, -3037000499, -9223372030926249001, 0);
46		test__mulodi4(-3037000499, -3037000499, 9223372030926249001, 0);
	43	try test__mulodi4(3037000499, 3037000499, 9223372030926249001, 0);
	44	try test__mulodi4(-3037000499, 3037000499, -9223372030926249001, 0);
	45	try test__mulodi4(3037000499, -3037000499, -9223372030926249001, 0);
	46	try test__mulodi4(-3037000499, -3037000499, 9223372030926249001, 0);
47	47
48		test__mulodi4(4398046511103, 2097152, 9223372036852678656, 0);
49		test__mulodi4(-4398046511103, 2097152, -9223372036852678656, 0);
50		test__mulodi4(4398046511103, -2097152, -9223372036852678656, 0);
51		test__mulodi4(-4398046511103, -2097152, 9223372036852678656, 0);
	48	try test__mulodi4(4398046511103, 2097152, 9223372036852678656, 0);
	49	try test__mulodi4(-4398046511103, 2097152, -9223372036852678656, 0);
	50	try test__mulodi4(4398046511103, -2097152, -9223372036852678656, 0);
	51	try test__mulodi4(-4398046511103, -2097152, 9223372036852678656, 0);
52	52
53		test__mulodi4(2097152, 4398046511103, 9223372036852678656, 0);
54		test__mulodi4(-2097152, 4398046511103, -9223372036852678656, 0);
55		test__mulodi4(2097152, -4398046511103, -9223372036852678656, 0);
56		test__mulodi4(-2097152, -4398046511103, 9223372036852678656, 0);
	53	try test__mulodi4(2097152, 4398046511103, 9223372036852678656, 0);
	54	try test__mulodi4(-2097152, 4398046511103, -9223372036852678656, 0);
	55	try test__mulodi4(2097152, -4398046511103, -9223372036852678656, 0);
	56	try test__mulodi4(-2097152, -4398046511103, 9223372036852678656, 0);
57	57
58		test__mulodi4(0x7FFFFFFFFFFFFFFF, -2, 2, 1);
59		test__mulodi4(-2, 0x7FFFFFFFFFFFFFFF, 2, 1);
60		test__mulodi4(0x7FFFFFFFFFFFFFFF, -1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
61		test__mulodi4(-1, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
62		test__mulodi4(0x7FFFFFFFFFFFFFFF, 0, 0, 0);
63		test__mulodi4(0, 0x7FFFFFFFFFFFFFFF, 0, 0);
64		test__mulodi4(0x7FFFFFFFFFFFFFFF, 1, 0x7FFFFFFFFFFFFFFF, 0);
65		test__mulodi4(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF, 0);
66		test__mulodi4(0x7FFFFFFFFFFFFFFF, 2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
67		test__mulodi4(2, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
	58	try test__mulodi4(0x7FFFFFFFFFFFFFFF, -2, 2, 1);
	59	try test__mulodi4(-2, 0x7FFFFFFFFFFFFFFF, 2, 1);
	60	try test__mulodi4(0x7FFFFFFFFFFFFFFF, -1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
	61	try test__mulodi4(-1, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
	62	try test__mulodi4(0x7FFFFFFFFFFFFFFF, 0, 0, 0);
	63	try test__mulodi4(0, 0x7FFFFFFFFFFFFFFF, 0, 0);
	64	try test__mulodi4(0x7FFFFFFFFFFFFFFF, 1, 0x7FFFFFFFFFFFFFFF, 0);
	65	try test__mulodi4(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF, 0);
	66	try test__mulodi4(0x7FFFFFFFFFFFFFFF, 2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
	67	try test__mulodi4(2, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
68	68
69		test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
70		test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
71		test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -1, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
72		test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
73		test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0, 0);
74		test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0);
75		test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 1, @bitCast(i64, @as(u64, 0x8000000000000000)), 0);
76		test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 0);
77		test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
78		test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
	69	try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
	70	try test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
	71	try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -1, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
	72	try test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
	73	try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0, 0);
	74	try test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0);
	75	try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 1, @bitCast(i64, @as(u64, 0x8000000000000000)), 0);
	76	try test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 0);
	77	try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
	78	try test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
79	79
80		test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
81		test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
82		test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -1, 0x7FFFFFFFFFFFFFFF, 0);
83		test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0x7FFFFFFFFFFFFFFF, 0);
84		test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0, 0);
85		test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0);
86		test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
87		test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
88		test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
89		test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
	80	try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
	81	try test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
	82	try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -1, 0x7FFFFFFFFFFFFFFF, 0);
	83	try test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0x7FFFFFFFFFFFFFFF, 0);
	84	try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0, 0);
	85	try test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0);
	86	try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
	87	try test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
	88	try test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
	89	try test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
90	90	}

lib/std/special/compiler_rt/muloti4_test.zig+57-57

...	...	@@ -6,76 +6,76 @@
6	6	const __muloti4 = @import("muloti4.zig").__muloti4;
7	7	const testing = @import("std").testing;
8	8
9		fn test__muloti4(a: i128, b: i128, expected: i128, expected_overflow: c_int) void {
	9	fn test__muloti4(a: i128, b: i128, expected: i128, expected_overflow: c_int) !void {
10	10	var overflow: c_int = undefined;
11	11	const x = __muloti4(a, b, &overflow);
12	12	try testing.expect(overflow == expected_overflow and (expected_overflow != 0 or x == expected));
13	13	}
14	14
15	15	test "muloti4" {
16		test__muloti4(0, 0, 0, 0);
17		test__muloti4(0, 1, 0, 0);
18		test__muloti4(1, 0, 0, 0);
19		test__muloti4(0, 10, 0, 0);
20		test__muloti4(10, 0, 0, 0);
	16	try test__muloti4(0, 0, 0, 0);
	17	try test__muloti4(0, 1, 0, 0);
	18	try test__muloti4(1, 0, 0, 0);
	19	try test__muloti4(0, 10, 0, 0);
	20	try test__muloti4(10, 0, 0, 0);
21	21
22		test__muloti4(0, 81985529216486895, 0, 0);
23		test__muloti4(81985529216486895, 0, 0, 0);
	22	try test__muloti4(0, 81985529216486895, 0, 0);
	23	try test__muloti4(81985529216486895, 0, 0, 0);
24	24
25		test__muloti4(0, -1, 0, 0);
26		test__muloti4(-1, 0, 0, 0);
27		test__muloti4(0, -10, 0, 0);
28		test__muloti4(-10, 0, 0, 0);
29		test__muloti4(0, -81985529216486895, 0, 0);
30		test__muloti4(-81985529216486895, 0, 0, 0);
	25	try test__muloti4(0, -1, 0, 0);
	26	try test__muloti4(-1, 0, 0, 0);
	27	try test__muloti4(0, -10, 0, 0);
	28	try test__muloti4(-10, 0, 0, 0);
	29	try test__muloti4(0, -81985529216486895, 0, 0);
	30	try test__muloti4(-81985529216486895, 0, 0, 0);
31	31
32		test__muloti4(3037000499, 3037000499, 9223372030926249001, 0);
33		test__muloti4(-3037000499, 3037000499, -9223372030926249001, 0);
34		test__muloti4(3037000499, -3037000499, -9223372030926249001, 0);
35		test__muloti4(-3037000499, -3037000499, 9223372030926249001, 0);
	32	try test__muloti4(3037000499, 3037000499, 9223372030926249001, 0);
	33	try test__muloti4(-3037000499, 3037000499, -9223372030926249001, 0);
	34	try test__muloti4(3037000499, -3037000499, -9223372030926249001, 0);
	35	try test__muloti4(-3037000499, -3037000499, 9223372030926249001, 0);
36	36
37		test__muloti4(4398046511103, 2097152, 9223372036852678656, 0);
38		test__muloti4(-4398046511103, 2097152, -9223372036852678656, 0);
39		test__muloti4(4398046511103, -2097152, -9223372036852678656, 0);
40		test__muloti4(-4398046511103, -2097152, 9223372036852678656, 0);
	37	try test__muloti4(4398046511103, 2097152, 9223372036852678656, 0);
	38	try test__muloti4(-4398046511103, 2097152, -9223372036852678656, 0);
	39	try test__muloti4(4398046511103, -2097152, -9223372036852678656, 0);
	40	try test__muloti4(-4398046511103, -2097152, 9223372036852678656, 0);
41	41
42		test__muloti4(2097152, 4398046511103, 9223372036852678656, 0);
43		test__muloti4(-2097152, 4398046511103, -9223372036852678656, 0);
44		test__muloti4(2097152, -4398046511103, -9223372036852678656, 0);
45		test__muloti4(-2097152, -4398046511103, 9223372036852678656, 0);
	42	try test__muloti4(2097152, 4398046511103, 9223372036852678656, 0);
	43	try test__muloti4(-2097152, 4398046511103, -9223372036852678656, 0);
	44	try test__muloti4(2097152, -4398046511103, -9223372036852678656, 0);
	45	try test__muloti4(-2097152, -4398046511103, 9223372036852678656, 0);
46	46
47		test__muloti4(@bitCast(i128, @as(u128, 0x00000000000000B504F333F9DE5BE000)), @bitCast(i128, @as(u128, 0x000000000000000000B504F333F9DE5B)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFF328DF915DA296E8A000)), 0);
48		test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
49		test__muloti4(-2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
	47	try test__muloti4(@bitCast(i128, @as(u128, 0x00000000000000B504F333F9DE5BE000)), @bitCast(i128, @as(u128, 0x000000000000000000B504F333F9DE5B)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFF328DF915DA296E8A000)), 0);
	48	try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
	49	try test__muloti4(-2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
50	50
51		test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
52		test__muloti4(-1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
53		test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0, 0);
54		test__muloti4(0, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0);
55		test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
56		test__muloti4(1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
57		test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
58		test__muloti4(2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
	51	try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
	52	try test__muloti4(-1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
	53	try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0, 0);
	54	try test__muloti4(0, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0);
	55	try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
	56	try test__muloti4(1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
	57	try test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
	58	try test__muloti4(2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
59	59
60		test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
61		test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
62		test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
63		test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
64		test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0, 0);
65		test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0);
66		test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0);
67		test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0);
68		test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
69		test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
	60	try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
	61	try test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
	62	try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
	63	try test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
	64	try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0, 0);
	65	try test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0);
	66	try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0);
	67	try test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0);
	68	try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
	69	try test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
70	70
71		test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
72		test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
73		test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
74		test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
75		test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0, 0);
76		test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0);
77		test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
78		test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
79		test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
80		test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
	71	try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
	72	try test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
	73	try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
	74	try test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
	75	try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0, 0);
	76	try test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0);
	77	try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
	78	try test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
	79	try test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
	80	try test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
81	81	}

lib/std/special/compiler_rt/multi3_test.zig+44-44

...	...	@@ -6,53 +6,53 @@
6	6	const __multi3 = @import("multi3.zig").__multi3;
7	7	const testing = @import("std").testing;
8	8
9		fn test__multi3(a: i128, b: i128, expected: i128) void {
	9	fn test__multi3(a: i128, b: i128, expected: i128) !void {
10	10	const x = __multi3(a, b);
11	11	try testing.expect(x == expected);
12	12	}
13	13
14	14	test "multi3" {
15		test__multi3(0, 0, 0);
16		test__multi3(0, 1, 0);
17		test__multi3(1, 0, 0);
18		test__multi3(0, 10, 0);
19		test__multi3(10, 0, 0);
20		test__multi3(0, 81985529216486895, 0);
21		test__multi3(81985529216486895, 0, 0);
22
23		test__multi3(0, -1, 0);
24		test__multi3(-1, 0, 0);
25		test__multi3(0, -10, 0);
26		test__multi3(-10, 0, 0);
27		test__multi3(0, -81985529216486895, 0);
28		test__multi3(-81985529216486895, 0, 0);
29
30		test__multi3(1, 1, 1);
31		test__multi3(1, 10, 10);
32		test__multi3(10, 1, 10);
33		test__multi3(1, 81985529216486895, 81985529216486895);
34		test__multi3(81985529216486895, 1, 81985529216486895);
35
36		test__multi3(1, -1, -1);
37		test__multi3(1, -10, -10);
38		test__multi3(-10, 1, -10);
39		test__multi3(1, -81985529216486895, -81985529216486895);
40		test__multi3(-81985529216486895, 1, -81985529216486895);
41
42		test__multi3(3037000499, 3037000499, 9223372030926249001);
43		test__multi3(-3037000499, 3037000499, -9223372030926249001);
44		test__multi3(3037000499, -3037000499, -9223372030926249001);
45		test__multi3(-3037000499, -3037000499, 9223372030926249001);
46
47		test__multi3(4398046511103, 2097152, 9223372036852678656);
48		test__multi3(-4398046511103, 2097152, -9223372036852678656);
49		test__multi3(4398046511103, -2097152, -9223372036852678656);
50		test__multi3(-4398046511103, -2097152, 9223372036852678656);
51
52		test__multi3(2097152, 4398046511103, 9223372036852678656);
53		test__multi3(-2097152, 4398046511103, -9223372036852678656);
54		test__multi3(2097152, -4398046511103, -9223372036852678656);
55		test__multi3(-2097152, -4398046511103, 9223372036852678656);
56
57		test__multi3(0x00000000000000B504F333F9DE5BE000, 0x000000000000000000B504F333F9DE5B, 0x7FFFFFFFFFFFF328DF915DA296E8A000);
	15	try test__multi3(0, 0, 0);
	16	try test__multi3(0, 1, 0);
	17	try test__multi3(1, 0, 0);
	18	try test__multi3(0, 10, 0);
	19	try test__multi3(10, 0, 0);
	20	try test__multi3(0, 81985529216486895, 0);
	21	try test__multi3(81985529216486895, 0, 0);
	22
	23	try test__multi3(0, -1, 0);
	24	try test__multi3(-1, 0, 0);
	25	try test__multi3(0, -10, 0);
	26	try test__multi3(-10, 0, 0);
	27	try test__multi3(0, -81985529216486895, 0);
	28	try test__multi3(-81985529216486895, 0, 0);
	29
	30	try test__multi3(1, 1, 1);
	31	try test__multi3(1, 10, 10);
	32	try test__multi3(10, 1, 10);
	33	try test__multi3(1, 81985529216486895, 81985529216486895);
	34	try test__multi3(81985529216486895, 1, 81985529216486895);
	35
	36	try test__multi3(1, -1, -1);
	37	try test__multi3(1, -10, -10);
	38	try test__multi3(-10, 1, -10);
	39	try test__multi3(1, -81985529216486895, -81985529216486895);
	40	try test__multi3(-81985529216486895, 1, -81985529216486895);
	41
	42	try test__multi3(3037000499, 3037000499, 9223372030926249001);
	43	try test__multi3(-3037000499, 3037000499, -9223372030926249001);
	44	try test__multi3(3037000499, -3037000499, -9223372030926249001);
	45	try test__multi3(-3037000499, -3037000499, 9223372030926249001);
	46
	47	try test__multi3(4398046511103, 2097152, 9223372036852678656);
	48	try test__multi3(-4398046511103, 2097152, -9223372036852678656);
	49	try test__multi3(4398046511103, -2097152, -9223372036852678656);
	50	try test__multi3(-4398046511103, -2097152, 9223372036852678656);
	51
	52	try test__multi3(2097152, 4398046511103, 9223372036852678656);
	53	try test__multi3(-2097152, 4398046511103, -9223372036852678656);
	54	try test__multi3(2097152, -4398046511103, -9223372036852678656);
	55	try test__multi3(-2097152, -4398046511103, 9223372036852678656);
	56
	57	try test__multi3(0x00000000000000B504F333F9DE5BE000, 0x000000000000000000B504F333F9DE5B, 0x7FFFFFFFFFFFF328DF915DA296E8A000);
58	58	}

lib/std/special/compiler_rt/popcountdi2_test.zig+7-7

...	...	@@ -15,18 +15,18 @@ fn naive_popcount(a_param: i64) i32 {
15	15	return r;
16	16	}
17	17
18		fn test__popcountdi2(a: i64) void {
	18	fn test__popcountdi2(a: i64) !void {
19	19	const x = __popcountdi2(a);
20	20	const expected = naive_popcount(a);
21	21	try testing.expect(expected == x);
22	22	}
23	23
24	24	test "popcountdi2" {
25		test__popcountdi2(0);
26		test__popcountdi2(1);
27		test__popcountdi2(2);
28		test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFD)));
29		test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFE)));
30		test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFF)));
	25	try test__popcountdi2(0);
	26	try test__popcountdi2(1);
	27	try test__popcountdi2(2);
	28	try test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFD)));
	29	try test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFE)));
	30	try test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFF)));
31	31	// TODO some fuzz testing
32	32	}

lib/std/special/compiler_rt/truncXfYf2_test.zig+36-36

...	...	@@ -5,67 +5,67 @@
5	5	// and substantial portions of the software.
6	6	const __truncsfhf2 = @import("truncXfYf2.zig").__truncsfhf2;
7	7
8		fn test__truncsfhf2(a: u32, expected: u16) void {
	8	fn test__truncsfhf2(a: u32, expected: u16) !void {
9	9	const actual = __truncsfhf2(@bitCast(f32, a));
10	10
11	11	if (actual == expected) {
12	12	return;
13	13	}
14	14
15		@panic("__truncsfhf2 test failure");
	15	return error.TestFailure;
16	16	}
17	17
18	18	test "truncsfhf2" {
19		test__truncsfhf2(0x7fc00000, 0x7e00); // qNaN
20		test__truncsfhf2(0x7fe00000, 0x7f00); // sNaN
	19	try test__truncsfhf2(0x7fc00000, 0x7e00); // qNaN
	20	try test__truncsfhf2(0x7fe00000, 0x7f00); // sNaN
21	21
22		test__truncsfhf2(0, 0); // 0
23		test__truncsfhf2(0x80000000, 0x8000); // -0
	22	try test__truncsfhf2(0, 0); // 0
	23	try test__truncsfhf2(0x80000000, 0x8000); // -0
24	24
25		test__truncsfhf2(0x7f800000, 0x7c00); // inf
26		test__truncsfhf2(0xff800000, 0xfc00); // -inf
	25	try test__truncsfhf2(0x7f800000, 0x7c00); // inf
	26	try test__truncsfhf2(0xff800000, 0xfc00); // -inf
27	27
28		test__truncsfhf2(0x477ff000, 0x7c00); // 65520 -> inf
29		test__truncsfhf2(0xc77ff000, 0xfc00); // -65520 -> -inf
	28	try test__truncsfhf2(0x477ff000, 0x7c00); // 65520 -> inf
	29	try test__truncsfhf2(0xc77ff000, 0xfc00); // -65520 -> -inf
30	30
31		test__truncsfhf2(0x71cc3892, 0x7c00); // 0x1.987124876876324p+100 -> inf
32		test__truncsfhf2(0xf1cc3892, 0xfc00); // -0x1.987124876876324p+100 -> -inf
	31	try test__truncsfhf2(0x71cc3892, 0x7c00); // 0x1.987124876876324p+100 -> inf
	32	try test__truncsfhf2(0xf1cc3892, 0xfc00); // -0x1.987124876876324p+100 -> -inf
33	33
34		test__truncsfhf2(0x38800000, 0x0400); // normal (min), 2**-14
35		test__truncsfhf2(0xb8800000, 0x8400); // normal (min), -2**-14
	34	try test__truncsfhf2(0x38800000, 0x0400); // normal (min), 2**-14
	35	try test__truncsfhf2(0xb8800000, 0x8400); // normal (min), -2**-14
36	36
37		test__truncsfhf2(0x477fe000, 0x7bff); // normal (max), 65504
38		test__truncsfhf2(0xc77fe000, 0xfbff); // normal (max), -65504
	37	try test__truncsfhf2(0x477fe000, 0x7bff); // normal (max), 65504
	38	try test__truncsfhf2(0xc77fe000, 0xfbff); // normal (max), -65504
39	39
40		test__truncsfhf2(0x477fe100, 0x7bff); // normal, 65505 -> 65504
41		test__truncsfhf2(0xc77fe100, 0xfbff); // normal, -65505 -> -65504
	40	try test__truncsfhf2(0x477fe100, 0x7bff); // normal, 65505 -> 65504
	41	try test__truncsfhf2(0xc77fe100, 0xfbff); // normal, -65505 -> -65504
42	42
43		test__truncsfhf2(0x477fef00, 0x7bff); // normal, 65519 -> 65504
44		test__truncsfhf2(0xc77fef00, 0xfbff); // normal, -65519 -> -65504
	43	try test__truncsfhf2(0x477fef00, 0x7bff); // normal, 65519 -> 65504
	44	try test__truncsfhf2(0xc77fef00, 0xfbff); // normal, -65519 -> -65504
45	45
46		test__truncsfhf2(0x3f802000, 0x3c01); // normal, 1 + 2**-10
47		test__truncsfhf2(0xbf802000, 0xbc01); // normal, -1 - 2**-10
	46	try test__truncsfhf2(0x3f802000, 0x3c01); // normal, 1 + 2**-10
	47	try test__truncsfhf2(0xbf802000, 0xbc01); // normal, -1 - 2**-10
48	48
49		test__truncsfhf2(0x3eaaa000, 0x3555); // normal, approx. 1/3
50		test__truncsfhf2(0xbeaaa000, 0xb555); // normal, approx. -1/3
	49	try test__truncsfhf2(0x3eaaa000, 0x3555); // normal, approx. 1/3
	50	try test__truncsfhf2(0xbeaaa000, 0xb555); // normal, approx. -1/3
51	51
52		test__truncsfhf2(0x40490fdb, 0x4248); // normal, 3.1415926535
53		test__truncsfhf2(0xc0490fdb, 0xc248); // normal, -3.1415926535
	52	try test__truncsfhf2(0x40490fdb, 0x4248); // normal, 3.1415926535
	53	try test__truncsfhf2(0xc0490fdb, 0xc248); // normal, -3.1415926535
54	54
55		test__truncsfhf2(0x45cc3892, 0x6e62); // normal, 0x1.987124876876324p+12
	55	try test__truncsfhf2(0x45cc3892, 0x6e62); // normal, 0x1.987124876876324p+12
56	56
57		test__truncsfhf2(0x3f800000, 0x3c00); // normal, 1
58		test__truncsfhf2(0x38800000, 0x0400); // normal, 0x1.0p-14
	57	try test__truncsfhf2(0x3f800000, 0x3c00); // normal, 1
	58	try test__truncsfhf2(0x38800000, 0x0400); // normal, 0x1.0p-14
59	59
60		test__truncsfhf2(0x33800000, 0x0001); // denormal (min), 2**-24
61		test__truncsfhf2(0xb3800000, 0x8001); // denormal (min), -2**-24
	60	try test__truncsfhf2(0x33800000, 0x0001); // denormal (min), 2**-24
	61	try test__truncsfhf2(0xb3800000, 0x8001); // denormal (min), -2**-24
62	62
63		test__truncsfhf2(0x387fc000, 0x03ff); // denormal (max), 2-14 - 2-24
64		test__truncsfhf2(0xb87fc000, 0x83ff); // denormal (max), -2-14 + 2-24
	63	try test__truncsfhf2(0x387fc000, 0x03ff); // denormal (max), 2-14 - 2-24
	64	try test__truncsfhf2(0xb87fc000, 0x83ff); // denormal (max), -2-14 + 2-24
65	65
66		test__truncsfhf2(0x35800000, 0x0010); // denormal, 0x1.0p-20
67		test__truncsfhf2(0x33280000, 0x0001); // denormal, 0x1.5p-25 -> 0x1.0p-24
68		test__truncsfhf2(0x33000000, 0x0000); // 0x1.0p-25 -> zero
	66	try test__truncsfhf2(0x35800000, 0x0010); // denormal, 0x1.0p-20
	67	try test__truncsfhf2(0x33280000, 0x0001); // denormal, 0x1.5p-25 -> 0x1.0p-24
	68	try test__truncsfhf2(0x33000000, 0x0000); // 0x1.0p-25 -> zero
69	69	}
70	70
71	71	const __truncdfhf2 = @import("truncXfYf2.zig").__truncdfhf2;

lib/std/special/compiler_rt/udivmoddi4_test.zig+2-2

...	...	@@ -8,7 +8,7 @@
8	8	const __udivmoddi4 = @import("int.zig").__udivmoddi4;
9	9	const testing = @import("std").testing;
10	10
11		fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) void {
	11	fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) !void {
12	12	var r: u64 = undefined;
13	13	const q = __udivmoddi4(a, b, &r);
14	14	try testing.expect(q == expected_q);
...	...	@@ -17,7 +17,7 @@ fn test__udivmoddi4(a: u64, b: u64, expected_q: u64, expected_r: u64) void {
17	17
18	18	test "udivmoddi4" {
19	19	for (cases) \|case\| {
20		test__udivmoddi4(case[0], case[1], case[2], case[3]);
	20	try test__udivmoddi4(case[0], case[1], case[2], case[3]);
21	21	}
22	22	}
23	23

lib/std/special/compiler_rt/udivmodti4_test.zig+2-2

...	...	@@ -8,7 +8,7 @@
8	8	const __udivmodti4 = @import("udivmodti4.zig").__udivmodti4;
9	9	const testing = @import("std").testing;
10	10
11		fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) void {
	11	fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) !void {
12	12	var r: u128 = undefined;
13	13	const q = __udivmodti4(a, b, &r);
14	14	try testing.expect(q == expected_q);
...	...	@@ -17,7 +17,7 @@ fn test__udivmodti4(a: u128, b: u128, expected_q: u128, expected_r: u128) void {
17	17
18	18	test "udivmodti4" {
19	19	for (cases) \|case\| {
20		test__udivmodti4(case[0], case[1], case[2], case[3]);
	20	try test__udivmodti4(case[0], case[1], case[2], case[3]);
21	21	}
22	22	}
23	23