Commit 8ada446b1f69842793321978b4ae796a550d99a9 | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-04-13 01:08:33-04:00
committer	GitHub <noreply@github.com> 2022-04-13 01:08:33-04:00
log	8ada446b1f69842793321978b4ae796a550d99a9
tree	410426d150157802292d393604b1efd0d479e6e7
parent	7972bc8aa8edb7bd213bd5ccdc90d70fb730efd2
parent	319555a6690a43de143698f13d6d107a7873dce0
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #11407 from topolarity/float-fix

compiler_rt: Add `f80` support to `floatXiYf`/`fixXfYi`

82 files changed, 2604 insertions(+), 3252 deletions(-)

CMakeLists.txt
deps
- SoftFloat-3e-prebuilt
  - platform.h
lib
- std
test
- behavior
  - math.zig

CMakeLists.txt+2-35

...	...	@@ -493,41 +493,8 @@ set(ZIG_STAGE2_SOURCES
493	493	"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/divtf3.zig"
494	494	"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/divti3.zig"
495	495	"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/extendXfYf2.zig"
496		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixdfdi.zig"
497		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixdfsi.zig"
498		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixdfti.zig"
499		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixint.zig"
500		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixsfdi.zig"
501		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixsfsi.zig"
502		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixsfti.zig"
503		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixtfdi.zig"
504		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixtfsi.zig"
505		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixtfti.zig"
506		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixuint.zig"
507		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunsdfdi.zig"
508		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunsdfsi.zig"
509		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunsdfti.zig"
510		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunssfdi.zig"
511		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunssfsi.zig"
512		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunssfti.zig"
513		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunstfdi.zig"
514		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunstfsi.zig"
515		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunstfti.zig"
516		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatXisf.zig"
517		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatdidf.zig"
518		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatditf.zig"
519		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatsiXf.zig"
520		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floattidf.zig"
521		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floattitf.zig"
522		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatundidf.zig"
523		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatundisf.zig"
524		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatunditf.zig"
525		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatunsidf.zig"
526		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatunsisf.zig"
527		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatunsitf.zig"
528		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatuntidf.zig"
529		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatuntisf.zig"
530		"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatuntitf.zig"
	496	"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixXfYi.zig"
	497	"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatXiYf.zig"
531	498	"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/int.zig"
532	499	"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/modti3.zig"
533	500	"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/mulXf3.zig"

deps/SoftFloat-3e-prebuilt/platform.h+8-6

...	...	@@ -17,8 +17,6 @@
17	17	#define BIGENDIAN 1
18	18	#elif defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
19	19	#define BIGENDIAN 1
20		#elif defined(_BIG_ENDIAN)
21		#define BIGENDIAN 1
22	20	#elif defined(__sparc)
23	21	#define BIGENDIAN 1
24	22	#elif defined(__sparc__)
...	...	@@ -37,7 +35,9 @@
37	35	#define BIGENDIAN 1
38	36	#elif defined(__s390__)
39	37	#define BIGENDIAN 1
40		#elif defined(__LITTLE_ENDIAN__)
	38	#endif
	39
	40	#if defined(__LITTLE_ENDIAN__)
41	41	#define LITTLEENDIAN 1
42	42	#elif defined(__ARMEL__)
43	43	#define LITTLEENDIAN 1
...	...	@@ -53,8 +53,6 @@
53	53	#define LITTLEENDIAN 1
54	54	#elif defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
55	55	#define LITTLEENDIAN 1
56		#elif defined(_LITTLE_ENDIAN)
57		#define LITTLEENDIAN 1
58	56	#elif defined(__i386__)
59	57	#define LITTLEENDIAN 1
60	58	#elif defined(__alpha__)
...	...	@@ -83,7 +81,11 @@
83	81	#define LITTLEENDIAN 1
84	82	#elif defined(__bfin__)
85	83	#define LITTLEENDIAN 1
86		#else
	84	#endif
	85
	86	#if defined(LITTLEENDIAN) && defined(BIGENDIAN)
	87	#error unable to detect endianness
	88	#elif !defined(LITTLEENDIAN) && !defined(BIGENDIAN)
87	89	#error unable to detect endianness
88	90	#endif
89	91

lib/std/math.zig+1-1

...	...	@@ -38,7 +38,7 @@ pub const sqrt1_2 = 0.707106781186547524400844362104849039;
38	38
39	39	pub const floatExponentBits = @import("math/float.zig").floatExponentBits;
40	40	pub const floatMantissaBits = @import("math/float.zig").floatMantissaBits;
41		pub const floatMantissaDigits = @import("math/float.zig").floatMantissaDigits;
	41	pub const floatFractionalBits = @import("math/float.zig").floatFractionalBits;
42	42	pub const floatExponentMin = @import("math/float.zig").floatExponentMin;
43	43	pub const floatExponentMax = @import("math/float.zig").floatExponentMax;
44	44	pub const floatTrueMin = @import("math/float.zig").floatTrueMin;

lib/std/math/float.zig+12-12

...	...	@@ -4,7 +4,7 @@ const expect = std.testing.expect;
4	4
5	5	/// Creates a raw "1.0" mantissa for floating point type T. Used to dedupe f80 logic.
6	6	fn mantissaOne(comptime T: type) comptime_int {
7		return if (floatMantissaDigits(T) == 64) 1 << 63 else 0;
	7	return if (T == f80) 1 << floatFractionalBits(T) else 0;
8	8	}
9	9
10	10	/// Creates floating point type T from an unbiased exponent and raw mantissa.
...	...	@@ -42,19 +42,19 @@ pub fn floatMantissaBits(comptime T: type) comptime_int {
42	42	};
43	43	}
44	44
45		/// Returns the number of binary digits in the mantissa of floating point type T.
46		pub fn floatMantissaDigits(comptime T: type) comptime_int {
	45	/// Returns the number of fractional bits in the mantissa of floating point type T.
	46	pub fn floatFractionalBits(comptime T: type) comptime_int {
47	47	assert(@typeInfo(T) == .Float);
48	48
49	49	// standard IEEE floats have an implicit 0.m or 1.m integer part
50	50	// f80 is special and has an explicitly stored bit in the MSB
51		// this function corresponds to `MANT_DIG' constants from C
	51	// this function corresponds to `MANT_DIG - 1' from C
52	52	return switch (@typeInfo(T).Float.bits) {
53		16 => 11,
54		32 => 24,
55		64 => 53,
56		80 => 64,
57		128 => 113,
	53	16 => 10,
	54	32 => 23,
	55	64 => 52,
	56	80 => 63,
	57	128 => 112,
58	58	else => @compileError("unknown floating point type " ++ @typeName(T)),
59	59	};
60	60	}
...	...	@@ -89,7 +89,7 @@ pub fn floatMax(comptime T: type) T {
89	89
90	90	/// Returns the machine epsilon of floating point type T.
91	91	pub fn floatEps(comptime T: type) T {
92		return reconstructFloat(T, -(floatMantissaDigits(T) - 1), mantissaOne(T));
	92	return reconstructFloat(T, -floatFractionalBits(T), mantissaOne(T));
93	93	}
94	94
95	95	/// Returns the value inf for floating point type T.
...	...	@@ -104,7 +104,7 @@ test "std.math.float" {
104	104	try expect(@bitSizeOf(T) == size);
105	105
106	106	// for machine epsilon, assert expmin <= -prec <= expmax
107		try expect(floatExponentMin(T) <= -(floatMantissaDigits(T) - 1));
108		try expect(-(floatMantissaDigits(T) - 1) <= floatExponentMax(T));
	107	try expect(floatExponentMin(T) <= -floatFractionalBits(T));
	108	try expect(-floatFractionalBits(T) <= floatExponentMax(T));
109	109	}
110	110	}

lib/std/math/isnormal.zig+1-1

...	...	@@ -41,7 +41,7 @@ test "math.isNormal" {
41	41	try expect(!isNormal(@as(T, math.floatTrueMin(T))));
42	42
43	43	// largest subnormal
44		try expect(!isNormal(@bitCast(T, ~(~@as(TBits, 0) << math.floatMantissaDigits(T) - 1))));
	44	try expect(!isNormal(@bitCast(T, ~(~@as(TBits, 0) << math.floatFractionalBits(T)))));
45	45
46	46	// non-finite numbers
47	47	try expect(!isNormal(-math.inf(T)));

lib/std/special/compiler_rt.zig+143-82

...	...	@@ -291,100 +291,149 @@ comptime {
291	291	const __bswapti2 = @import("compiler_rt/bswap.zig").__bswapti2;
292	292	@export(__bswapti2, .{ .name = "__bswapti2", .linkage = linkage });
293	293
294		// Integral / floating point conversion (part 1/2)
295		const __floatsidf = @import("compiler_rt/floatsiXf.zig").__floatsidf;
296		@export(__floatsidf, .{ .name = "__floatsidf", .linkage = linkage });
297		const __floatsisf = @import("compiler_rt/floatsiXf.zig").__floatsisf;
298		@export(__floatsisf, .{ .name = "__floatsisf", .linkage = linkage });
299		const __floatdidf = @import("compiler_rt/floatdidf.zig").__floatdidf;
300		@export(__floatdidf, .{ .name = "__floatdidf", .linkage = linkage });
301		const __floatsitf = @import("compiler_rt/floatsiXf.zig").__floatsitf;
302		@export(__floatsitf, .{ .name = "__floatsitf", .linkage = linkage });
	294	// Integral -> Float Conversion
303	295
304		const __floatunsisf = @import("compiler_rt/floatunsisf.zig").__floatunsisf;
	296	// Conversion to f32
	297	const __floatsisf = @import("compiler_rt/floatXiYf.zig").__floatsisf;
	298	@export(__floatsisf, .{ .name = "__floatsisf", .linkage = linkage });
	299	const __floatunsisf = @import("compiler_rt/floatXiYf.zig").__floatunsisf;
305	300	@export(__floatunsisf, .{ .name = "__floatunsisf", .linkage = linkage });
306		const __floatundisf = @import("compiler_rt/floatundisf.zig").__floatundisf;
	301
	302	const __floatundisf = @import("compiler_rt/floatXiYf.zig").__floatundisf;
307	303	@export(__floatundisf, .{ .name = "__floatundisf", .linkage = linkage });
308		const __floatunsidf = @import("compiler_rt/floatunsidf.zig").__floatunsidf;
	304	const __floatdisf = @import("compiler_rt/floatXiYf.zig").__floatdisf;
	305	@export(__floatdisf, .{ .name = "__floatdisf", .linkage = linkage });
	306
	307	const __floattisf = @import("compiler_rt/floatXiYf.zig").__floattisf;
	308	@export(__floattisf, .{ .name = "__floattisf", .linkage = linkage });
	309	const __floatuntisf = @import("compiler_rt/floatXiYf.zig").__floatuntisf;
	310	@export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = linkage });
	311
	312	// Conversion to f64
	313	const __floatsidf = @import("compiler_rt/floatXiYf.zig").__floatsidf;
	314	@export(__floatsidf, .{ .name = "__floatsidf", .linkage = linkage });
	315	const __floatunsidf = @import("compiler_rt/floatXiYf.zig").__floatunsidf;
309	316	@export(__floatunsidf, .{ .name = "__floatunsidf", .linkage = linkage });
310		const __floatundidf = @import("compiler_rt/floatundidf.zig").__floatundidf;
	317
	318	const __floatdidf = @import("compiler_rt/floatXiYf.zig").__floatdidf;
	319	@export(__floatdidf, .{ .name = "__floatdidf", .linkage = linkage });
	320	const __floatundidf = @import("compiler_rt/floatXiYf.zig").__floatundidf;
311	321	@export(__floatundidf, .{ .name = "__floatundidf", .linkage = linkage });
312	322
313		const __floatditf = @import("compiler_rt/floatditf.zig").__floatditf;
314		@export(__floatditf, .{ .name = "__floatditf", .linkage = linkage });
315		const __floattitf = @import("compiler_rt/floattitf.zig").__floattitf;
316		@export(__floattitf, .{ .name = "__floattitf", .linkage = linkage });
317		const __floattidf = @import("compiler_rt/floattidf.zig").__floattidf;
	323	const __floattidf = @import("compiler_rt/floatXiYf.zig").__floattidf;
318	324	@export(__floattidf, .{ .name = "__floattidf", .linkage = linkage });
319		const __floattisf = @import("compiler_rt/floatXisf.zig").__floattisf;
320		@export(__floattisf, .{ .name = "__floattisf", .linkage = linkage });
321		const __floatdisf = @import("compiler_rt/floatXisf.zig").__floatdisf;
322		@export(__floatdisf, .{ .name = "__floatdisf", .linkage = linkage });
	325	const __floatuntidf = @import("compiler_rt/floatXiYf.zig").__floatuntidf;
	326	@export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = linkage });
323	327
324		const __floatunditf = @import("compiler_rt/floatunditf.zig").__floatunditf;
325		@export(__floatunditf, .{ .name = "__floatunditf", .linkage = linkage });
326		const __floatunsitf = @import("compiler_rt/floatunsitf.zig").__floatunsitf;
	328	// Conversion to f80
	329	const __floatsixf = @import("compiler_rt/floatXiYf.zig").__floatsixf;
	330	@export(__floatsixf, .{ .name = "__floatsixf", .linkage = linkage });
	331	const __floatunsixf = @import("compiler_rt/floatXiYf.zig").__floatunsixf;
	332	@export(__floatunsixf, .{ .name = "__floatunsixf", .linkage = linkage });
	333
	334	const __floatdixf = @import("compiler_rt/floatXiYf.zig").__floatdixf;
	335	@export(__floatdixf, .{ .name = "__floatdixf", .linkage = linkage });
	336	const __floatundixf = @import("compiler_rt/floatXiYf.zig").__floatundixf;
	337	@export(__floatundixf, .{ .name = "__floatundixf", .linkage = linkage });
	338
	339	const __floattixf = @import("compiler_rt/floatXiYf.zig").__floattixf;
	340	@export(__floattixf, .{ .name = "__floattixf", .linkage = linkage });
	341	const __floatuntixf = @import("compiler_rt/floatXiYf.zig").__floatuntixf;
	342	@export(__floatuntixf, .{ .name = "__floatuntixf", .linkage = linkage });
	343
	344	// Conversion to f128
	345	const __floatsitf = @import("compiler_rt/floatXiYf.zig").__floatsitf;
	346	@export(__floatsitf, .{ .name = "__floatsitf", .linkage = linkage });
	347	const __floatunsitf = @import("compiler_rt/floatXiYf.zig").__floatunsitf;
327	348	@export(__floatunsitf, .{ .name = "__floatunsitf", .linkage = linkage });
328	349
329		const __floatuntitf = @import("compiler_rt/floatuntitf.zig").__floatuntitf;
	350	const __floatditf = @import("compiler_rt/floatXiYf.zig").__floatditf;
	351	@export(__floatditf, .{ .name = "__floatditf", .linkage = linkage });
	352	const __floatunditf = @import("compiler_rt/floatXiYf.zig").__floatunditf;
	353	@export(__floatunditf, .{ .name = "__floatunditf", .linkage = linkage });
	354
	355	const __floattitf = @import("compiler_rt/floatXiYf.zig").__floattitf;
	356	@export(__floattitf, .{ .name = "__floattitf", .linkage = linkage });
	357	const __floatuntitf = @import("compiler_rt/floatXiYf.zig").__floatuntitf;
330	358	@export(__floatuntitf, .{ .name = "__floatuntitf", .linkage = linkage });
331		const __floatuntidf = @import("compiler_rt/floatuntidf.zig").__floatuntidf;
332		@export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = linkage });
333		const __floatuntisf = @import("compiler_rt/floatuntisf.zig").__floatuntisf;
334		@export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = linkage });
335	359
336		const __truncsfhf2 = @import("compiler_rt/truncXfYf2.zig").__truncsfhf2;
337		@export(__truncsfhf2, .{ .name = "__truncsfhf2", .linkage = linkage });
338		if (!is_test) {
339		@export(__truncsfhf2, .{ .name = "__gnu_f2h_ieee", .linkage = linkage });
340		}
341		const __extendsfdf2 = @import("compiler_rt/extendXfYf2.zig").__extendsfdf2;
342		@export(__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = linkage });
	360	// Float -> Integral Conversion
343	361
344		// Integral / floating point conversion (part 2/2)
345		const __fixunssfsi = @import("compiler_rt/fixunssfsi.zig").__fixunssfsi;
	362	// Conversion from f32
	363	const __fixsfsi = @import("compiler_rt/fixXfYi.zig").__fixsfsi;
	364	@export(__fixsfsi, .{ .name = "__fixsfsi", .linkage = linkage });
	365	const __fixunssfsi = @import("compiler_rt/fixXfYi.zig").__fixunssfsi;
346	366	@export(__fixunssfsi, .{ .name = "__fixunssfsi", .linkage = linkage });
347		const __fixunssfdi = @import("compiler_rt/fixunssfdi.zig").__fixunssfdi;
	367
	368	const __fixsfdi = @import("compiler_rt/fixXfYi.zig").__fixsfdi;
	369	@export(__fixsfdi, .{ .name = "__fixsfdi", .linkage = linkage });
	370	const __fixunssfdi = @import("compiler_rt/fixXfYi.zig").__fixunssfdi;
348	371	@export(__fixunssfdi, .{ .name = "__fixunssfdi", .linkage = linkage });
349		const __fixunssfti = @import("compiler_rt/fixunssfti.zig").__fixunssfti;
	372
	373	const __fixsfti = @import("compiler_rt/fixXfYi.zig").__fixsfti;
	374	@export(__fixsfti, .{ .name = "__fixsfti", .linkage = linkage });
	375	const __fixunssfti = @import("compiler_rt/fixXfYi.zig").__fixunssfti;
350	376	@export(__fixunssfti, .{ .name = "__fixunssfti", .linkage = linkage });
351	377
352		const __fixunsdfsi = @import("compiler_rt/fixunsdfsi.zig").__fixunsdfsi;
	378	// Conversion from f64
	379	const __fixdfsi = @import("compiler_rt/fixXfYi.zig").__fixdfsi;
	380	@export(__fixdfsi, .{ .name = "__fixdfsi", .linkage = linkage });
	381	const __fixunsdfsi = @import("compiler_rt/fixXfYi.zig").__fixunsdfsi;
353	382	@export(__fixunsdfsi, .{ .name = "__fixunsdfsi", .linkage = linkage });
354		const __fixunsdfdi = @import("compiler_rt/fixunsdfdi.zig").__fixunsdfdi;
	383
	384	const __fixdfdi = @import("compiler_rt/fixXfYi.zig").__fixdfdi;
	385	@export(__fixdfdi, .{ .name = "__fixdfdi", .linkage = linkage });
	386	const __fixunsdfdi = @import("compiler_rt/fixXfYi.zig").__fixunsdfdi;
355	387	@export(__fixunsdfdi, .{ .name = "__fixunsdfdi", .linkage = linkage });
356		const __fixunsdfti = @import("compiler_rt/fixunsdfti.zig").__fixunsdfti;
	388
	389	const __fixdfti = @import("compiler_rt/fixXfYi.zig").__fixdfti;
	390	@export(__fixdfti, .{ .name = "__fixdfti", .linkage = linkage });
	391	const __fixunsdfti = @import("compiler_rt/fixXfYi.zig").__fixunsdfti;
357	392	@export(__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = linkage });
358	393
359		const __fixunstfsi = @import("compiler_rt/fixunstfsi.zig").__fixunstfsi;
	394	// Conversion from f80
	395	const __fixxfsi = @import("compiler_rt/fixXfYi.zig").__fixxfsi;
	396	@export(__fixxfsi, .{ .name = "__fixxfsi", .linkage = linkage });
	397	const __fixunsxfsi = @import("compiler_rt/fixXfYi.zig").__fixunsxfsi;
	398	@export(__fixunsxfsi, .{ .name = "__fixunsxfsi", .linkage = linkage });
	399
	400	const __fixxfdi = @import("compiler_rt/fixXfYi.zig").__fixxfdi;
	401	@export(__fixxfdi, .{ .name = "__fixxfdi", .linkage = linkage });
	402	const __fixunsxfdi = @import("compiler_rt/fixXfYi.zig").__fixunsxfdi;
	403	@export(__fixunsxfdi, .{ .name = "__fixunsxfdi", .linkage = linkage });
	404
	405	const __fixxfti = @import("compiler_rt/fixXfYi.zig").__fixxfti;
	406	@export(__fixxfti, .{ .name = "__fixxfti", .linkage = linkage });
	407	const __fixunsxfti = @import("compiler_rt/fixXfYi.zig").__fixunsxfti;
	408	@export(__fixunsxfti, .{ .name = "__fixunsxfti", .linkage = linkage });
	409
	410	// Conversion from f128
	411	const __fixtfsi = @import("compiler_rt/fixXfYi.zig").__fixtfsi;
	412	@export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = linkage });
	413	const __fixunstfsi = @import("compiler_rt/fixXfYi.zig").__fixunstfsi;
360	414	@export(__fixunstfsi, .{ .name = "__fixunstfsi", .linkage = linkage });
361		const __fixunstfdi = @import("compiler_rt/fixunstfdi.zig").__fixunstfdi;
362		@export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = linkage });
363		const __fixunstfti = @import("compiler_rt/fixunstfti.zig").__fixunstfti;
364		@export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = linkage });
365	415
366		const __fixdfdi = @import("compiler_rt/fixdfdi.zig").__fixdfdi;
367		@export(__fixdfdi, .{ .name = "__fixdfdi", .linkage = linkage });
368		const __fixdfsi = @import("compiler_rt/fixdfsi.zig").__fixdfsi;
369		@export(__fixdfsi, .{ .name = "__fixdfsi", .linkage = linkage });
370		const __fixdfti = @import("compiler_rt/fixdfti.zig").__fixdfti;
371		@export(__fixdfti, .{ .name = "__fixdfti", .linkage = linkage });
372		const __fixsfdi = @import("compiler_rt/fixsfdi.zig").__fixsfdi;
373		@export(__fixsfdi, .{ .name = "__fixsfdi", .linkage = linkage });
374		const __fixsfsi = @import("compiler_rt/fixsfsi.zig").__fixsfsi;
375		@export(__fixsfsi, .{ .name = "__fixsfsi", .linkage = linkage });
376		const __fixsfti = @import("compiler_rt/fixsfti.zig").__fixsfti;
377		@export(__fixsfti, .{ .name = "__fixsfti", .linkage = linkage });
378		const __fixtfdi = @import("compiler_rt/fixtfdi.zig").__fixtfdi;
	416	const __fixtfdi = @import("compiler_rt/fixXfYi.zig").__fixtfdi;
379	417	@export(__fixtfdi, .{ .name = "__fixtfdi", .linkage = linkage });
380		const __fixtfsi = @import("compiler_rt/fixtfsi.zig").__fixtfsi;
381		@export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = linkage });
382		const __fixtfti = @import("compiler_rt/fixtfti.zig").__fixtfti;
	418	const __fixunstfdi = @import("compiler_rt/fixXfYi.zig").__fixunstfdi;
	419	@export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = linkage });
	420
	421	const __fixtfti = @import("compiler_rt/fixXfYi.zig").__fixtfti;
383	422	@export(__fixtfti, .{ .name = "__fixtfti", .linkage = linkage });
	423	const __fixunstfti = @import("compiler_rt/fixXfYi.zig").__fixunstfti;
	424	@export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = linkage });
384	425
385	426	const __udivmoddi4 = @import("compiler_rt/int.zig").__udivmoddi4;
386	427	@export(__udivmoddi4, .{ .name = "__udivmoddi4", .linkage = linkage });
387	428
	429	const __truncsfhf2 = @import("compiler_rt/truncXfYf2.zig").__truncsfhf2;
	430	@export(__truncsfhf2, .{ .name = "__truncsfhf2", .linkage = linkage });
	431	if (!is_test) {
	432	@export(__truncsfhf2, .{ .name = "__gnu_f2h_ieee", .linkage = linkage });
	433	}
	434	const __extendsfdf2 = @import("compiler_rt/extendXfYf2.zig").__extendsfdf2;
	435	@export(__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = linkage });
	436
388	437	if (is_darwin) {
389	438	const __isPlatformVersionAtLeast = @import("compiler_rt/os_version_check.zig").__isPlatformVersionAtLeast;
390	439	@export(__isPlatformVersionAtLeast, .{ .name = "__isPlatformVersionAtLeast", .linkage = linkage });
...	...	@@ -553,19 +602,19 @@ comptime {
553	602
554	603	const __aeabi_f2d = @import("compiler_rt/extendXfYf2.zig").__aeabi_f2d;
555	604	@export(__aeabi_f2d, .{ .name = "__aeabi_f2d", .linkage = linkage });
556		const __aeabi_i2d = @import("compiler_rt/floatsiXf.zig").__aeabi_i2d;
	605	const __aeabi_i2d = @import("compiler_rt/floatXiYf.zig").__aeabi_i2d;
557	606	@export(__aeabi_i2d, .{ .name = "__aeabi_i2d", .linkage = linkage });
558		const __aeabi_l2d = @import("compiler_rt/floatdidf.zig").__aeabi_l2d;
	607	const __aeabi_l2d = @import("compiler_rt/floatXiYf.zig").__aeabi_l2d;
559	608	@export(__aeabi_l2d, .{ .name = "__aeabi_l2d", .linkage = linkage });
560		const __aeabi_l2f = @import("compiler_rt/floatXisf.zig").__aeabi_l2f;
	609	const __aeabi_l2f = @import("compiler_rt/floatXiYf.zig").__aeabi_l2f;
561	610	@export(__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = linkage });
562		const __aeabi_ui2d = @import("compiler_rt/floatunsidf.zig").__aeabi_ui2d;
	611	const __aeabi_ui2d = @import("compiler_rt/floatXiYf.zig").__aeabi_ui2d;
563	612	@export(__aeabi_ui2d, .{ .name = "__aeabi_ui2d", .linkage = linkage });
564		const __aeabi_ul2d = @import("compiler_rt/floatundidf.zig").__aeabi_ul2d;
	613	const __aeabi_ul2d = @import("compiler_rt/floatXiYf.zig").__aeabi_ul2d;
565	614	@export(__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = linkage });
566		const __aeabi_ui2f = @import("compiler_rt/floatunsisf.zig").__aeabi_ui2f;
	615	const __aeabi_ui2f = @import("compiler_rt/floatXiYf.zig").__aeabi_ui2f;
567	616	@export(__aeabi_ui2f, .{ .name = "__aeabi_ui2f", .linkage = linkage });
568		const __aeabi_ul2f = @import("compiler_rt/floatundisf.zig").__aeabi_ul2f;
	617	const __aeabi_ul2f = @import("compiler_rt/floatXiYf.zig").__aeabi_ul2f;
569	618	@export(__aeabi_ul2f, .{ .name = "__aeabi_ul2f", .linkage = linkage });
570	619
571	620	const __aeabi_fneg = @import("compiler_rt/negXf2.zig").__aeabi_fneg;
...	...	@@ -581,17 +630,17 @@ comptime {
581	630	const __aeabi_d2h = @import("compiler_rt/truncXfYf2.zig").__aeabi_d2h;
582	631	@export(__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = linkage });
583	632
584		const __aeabi_f2ulz = @import("compiler_rt/fixunssfdi.zig").__aeabi_f2ulz;
	633	const __aeabi_f2ulz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2ulz;
585	634	@export(__aeabi_f2ulz, .{ .name = "__aeabi_f2ulz", .linkage = linkage });
586		const __aeabi_d2ulz = @import("compiler_rt/fixunsdfdi.zig").__aeabi_d2ulz;
	635	const __aeabi_d2ulz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2ulz;
587	636	@export(__aeabi_d2ulz, .{ .name = "__aeabi_d2ulz", .linkage = linkage });
588	637
589		const __aeabi_f2lz = @import("compiler_rt/fixsfdi.zig").__aeabi_f2lz;
	638	const __aeabi_f2lz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2lz;
590	639	@export(__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = linkage });
591		const __aeabi_d2lz = @import("compiler_rt/fixdfdi.zig").__aeabi_d2lz;
	640	const __aeabi_d2lz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2lz;
592	641	@export(__aeabi_d2lz, .{ .name = "__aeabi_d2lz", .linkage = linkage });
593	642
594		const __aeabi_d2uiz = @import("compiler_rt/fixunsdfsi.zig").__aeabi_d2uiz;
	643	const __aeabi_d2uiz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2uiz;
595	644	@export(__aeabi_d2uiz, .{ .name = "__aeabi_d2uiz", .linkage = linkage });
596	645
597	646	const __aeabi_h2f = @import("compiler_rt/extendXfYf2.zig").__aeabi_h2f;
...	...	@@ -599,7 +648,7 @@ comptime {
599	648	const __aeabi_f2h = @import("compiler_rt/truncXfYf2.zig").__aeabi_f2h;
600	649	@export(__aeabi_f2h, .{ .name = "__aeabi_f2h", .linkage = linkage });
601	650
602		const __aeabi_i2f = @import("compiler_rt/floatsiXf.zig").__aeabi_i2f;
	651	const __aeabi_i2f = @import("compiler_rt/floatXiYf.zig").__aeabi_i2f;
603	652	@export(__aeabi_i2f, .{ .name = "__aeabi_i2f", .linkage = linkage });
604	653	const __aeabi_d2f = @import("compiler_rt/truncXfYf2.zig").__aeabi_d2f;
605	654	@export(__aeabi_d2f, .{ .name = "__aeabi_d2f", .linkage = linkage });
...	...	@@ -613,12 +662,12 @@ comptime {
613	662	const __aeabi_dsub = @import("compiler_rt/addXf3.zig").__aeabi_dsub;
614	663	@export(__aeabi_dsub, .{ .name = "__aeabi_dsub", .linkage = linkage });
615	664
616		const __aeabi_f2uiz = @import("compiler_rt/fixunssfsi.zig").__aeabi_f2uiz;
	665	const __aeabi_f2uiz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2uiz;
617	666	@export(__aeabi_f2uiz, .{ .name = "__aeabi_f2uiz", .linkage = linkage });
618	667
619		const __aeabi_f2iz = @import("compiler_rt/fixsfsi.zig").__aeabi_f2iz;
	668	const __aeabi_f2iz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2iz;
620	669	@export(__aeabi_f2iz, .{ .name = "__aeabi_f2iz", .linkage = linkage });
621		const __aeabi_d2iz = @import("compiler_rt/fixdfsi.zig").__aeabi_d2iz;
	670	const __aeabi_d2iz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2iz;
622	671	@export(__aeabi_d2iz, .{ .name = "__aeabi_d2iz", .linkage = linkage });
623	672
624	673	const __aeabi_fdiv = @import("compiler_rt/divsf3.zig").__aeabi_fdiv;
...	...	@@ -672,9 +721,13 @@ comptime {
672	721	@export(_aullrem, .{ .name = "\x01__aullrem", .linkage = strong_linkage });
673	722	}
674	723
675		const fmodl = @import("compiler_rt/floatfmodl.zig").fmodl;
676	724	if (!is_test) {
677	725	@export(fmodl, .{ .name = "fmodl", .linkage = linkage });
	726	if (long_double_is_f128) {
	727	@export(fmodl, .{ .name = "fmodq", .linkage = linkage });
	728	} else {
	729	@export(fmodq, .{ .name = "fmodq", .linkage = linkage });
	730	}
678	731
679	732	@export(floorf, .{ .name = "floorf", .linkage = linkage });
680	733	@export(floor, .{ .name = "floor", .linkage = linkage });
...	...	@@ -828,6 +881,14 @@ fn ceill(x: c_longdouble) callconv(.C) c_longdouble {
828	881	return math.ceil(x);
829	882	}
830	883
	884	const fmodq = @import("compiler_rt/floatfmodq.zig").fmodq;
	885	fn fmodl(x: c_longdouble, y: c_longdouble) callconv(.C) c_longdouble {
	886	if (!long_double_is_f128) {
	887	@panic("TODO implement this");
	888	}
	889	return @floatCast(c_longdouble, fmodq(x, y));
	890	}
	891
831	892	// Avoid dragging in the runtime safety mechanisms into this .o file,
832	893	// unless we're trying to test this file.
833	894	pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn {

lib/std/special/compiler_rt/fixXfYi.zig created+224

...	...	@@ -0,0 +1,224 @@
	1	const std = @import("std");
	2	const math = std.math;
	3	const Log2Int = math.Log2Int;
	4	const is_test = @import("builtin").is_test;
	5
	6	pub inline fn fixXfYi(comptime I: type, a: anytype) I {
	7	@setRuntimeSafety(is_test);
	8
	9	const F = @TypeOf(a);
	10	const float_bits = @typeInfo(F).Float.bits;
	11	const int_bits = @typeInfo(I).Int.bits;
	12	const rep_t = std.meta.Int(.unsigned, float_bits);
	13	const sig_bits = math.floatMantissaBits(F);
	14	const exp_bits = math.floatExponentBits(F);
	15	const fractional_bits = math.floatFractionalBits(F);
	16
	17	const implicit_bit = if (F != f80) (@as(rep_t, 1) << sig_bits) else 0;
	18	const max_exp = (1 << (exp_bits - 1));
	19	const exp_bias = max_exp - 1;
	20	const sig_mask = (@as(rep_t, 1) << sig_bits) - 1;
	21
	22	// Break a into sign, exponent, significand
	23	const a_rep: rep_t = @bitCast(rep_t, a);
	24	const negative = (a_rep >> (float_bits - 1)) != 0;
	25	const exponent = @intCast(i32, (a_rep << 1) >> (sig_bits + 1)) - exp_bias;
	26	const significand: rep_t = (a_rep & sig_mask) \| implicit_bit;
	27
	28	// If the exponent is negative, the result rounds to zero.
	29	if (exponent < 0) return 0;
	30
	31	// If the value is too large for the integer type, saturate.
	32	switch (@typeInfo(I).Int.signedness) {
	33	.unsigned => {
	34	if (negative) return 0;
	35	if (@intCast(c_uint, exponent) >= @minimum(int_bits, max_exp)) return math.maxInt(I);
	36	},
	37	.signed => if (@intCast(c_uint, exponent) >= @minimum(int_bits - 1, max_exp)) {
	38	return if (negative) math.minInt(I) else math.maxInt(I);
	39	},
	40	}
	41
	42	// If 0 <= exponent < sig_bits, right shift to get the result.
	43	// Otherwise, shift left.
	44	var result: I = undefined;
	45	if (exponent < fractional_bits) {
	46	result = @intCast(I, significand >> @intCast(Log2Int(rep_t), fractional_bits - exponent));
	47	} else {
	48	result = @intCast(I, significand) << @intCast(Log2Int(I), exponent - fractional_bits);
	49	}
	50
	51	if ((@typeInfo(I).Int.signedness == .signed) and negative)
	52	return ~result +% 1;
	53	return result;
	54	}
	55
	56	// Conversion from f16
	57
	58	pub fn __fixhfsi(a: f16) callconv(.C) i32 {
	59	return fixXfYi(i32, a);
	60	}
	61
	62	pub fn __fixunshfsi(a: f16) callconv(.C) u32 {
	63	return fixXfYi(u32, a);
	64	}
	65
	66	pub fn __fixhfdi(a: f16) callconv(.C) i64 {
	67	return fixXfYi(i64, a);
	68	}
	69
	70	pub fn __fixunshfdi(a: f16) callconv(.C) u64 {
	71	return fixXfYi(u64, a);
	72	}
	73
	74	pub fn __fixhfti(a: f16) callconv(.C) i128 {
	75	return fixXfYi(i128, a);
	76	}
	77
	78	pub fn __fixunshfti(a: f16) callconv(.C) u128 {
	79	return fixXfYi(u128, a);
	80	}
	81
	82	// Conversion from f32
	83
	84	pub fn __fixsfsi(a: f32) callconv(.C) i32 {
	85	return fixXfYi(i32, a);
	86	}
	87
	88	pub fn __fixunssfsi(a: f32) callconv(.C) u32 {
	89	return fixXfYi(u32, a);
	90	}
	91
	92	pub fn __fixsfdi(a: f32) callconv(.C) i64 {
	93	return fixXfYi(i64, a);
	94	}
	95
	96	pub fn __fixunssfdi(a: f32) callconv(.C) u64 {
	97	return fixXfYi(u64, a);
	98	}
	99
	100	pub fn __fixsfti(a: f32) callconv(.C) i128 {
	101	return fixXfYi(i128, a);
	102	}
	103
	104	pub fn __fixunssfti(a: f32) callconv(.C) u128 {
	105	return fixXfYi(u128, a);
	106	}
	107
	108	// Conversion from f64
	109
	110	pub fn __fixdfsi(a: f64) callconv(.C) i32 {
	111	return fixXfYi(i32, a);
	112	}
	113
	114	pub fn __fixunsdfsi(a: f64) callconv(.C) u32 {
	115	return fixXfYi(u32, a);
	116	}
	117
	118	pub fn __fixdfdi(a: f64) callconv(.C) i64 {
	119	return fixXfYi(i64, a);
	120	}
	121
	122	pub fn __fixunsdfdi(a: f64) callconv(.C) u64 {
	123	return fixXfYi(u64, a);
	124	}
	125
	126	pub fn __fixdfti(a: f64) callconv(.C) i128 {
	127	return fixXfYi(i128, a);
	128	}
	129
	130	pub fn __fixunsdfti(a: f64) callconv(.C) u128 {
	131	return fixXfYi(u128, a);
	132	}
	133
	134	// Conversion from f80
	135
	136	pub fn __fixxfsi(a: f80) callconv(.C) i32 {
	137	return fixXfYi(i32, a);
	138	}
	139
	140	pub fn __fixunsxfsi(a: f80) callconv(.C) u32 {
	141	return fixXfYi(u32, a);
	142	}
	143
	144	pub fn __fixxfdi(a: f80) callconv(.C) i64 {
	145	return fixXfYi(i64, a);
	146	}
	147
	148	pub fn __fixunsxfdi(a: f80) callconv(.C) u64 {
	149	return fixXfYi(u64, a);
	150	}
	151
	152	pub fn __fixxfti(a: f80) callconv(.C) i128 {
	153	return fixXfYi(i128, a);
	154	}
	155
	156	pub fn __fixunsxfti(a: f80) callconv(.C) u128 {
	157	return fixXfYi(u128, a);
	158	}
	159
	160	// Conversion from f128
	161
	162	pub fn __fixtfsi(a: f128) callconv(.C) i32 {
	163	return fixXfYi(i32, a);
	164	}
	165
	166	pub fn __fixunstfsi(a: f128) callconv(.C) u32 {
	167	return fixXfYi(u32, a);
	168	}
	169
	170	pub fn __fixtfdi(a: f128) callconv(.C) i64 {
	171	return fixXfYi(i64, a);
	172	}
	173
	174	pub fn __fixunstfdi(a: f128) callconv(.C) u64 {
	175	return fixXfYi(u64, a);
	176	}
	177
	178	pub fn __fixtfti(a: f128) callconv(.C) i128 {
	179	return fixXfYi(i128, a);
	180	}
	181
	182	pub fn __fixunstfti(a: f128) callconv(.C) u128 {
	183	return fixXfYi(u128, a);
	184	}
	185
	186	// Conversion from f32
	187
	188	pub fn __aeabi_f2iz(a: f32) callconv(.AAPCS) i32 {
	189	return fixXfYi(i32, a);
	190	}
	191
	192	pub fn __aeabi_f2uiz(a: f32) callconv(.AAPCS) u32 {
	193	return fixXfYi(u32, a);
	194	}
	195
	196	pub fn __aeabi_f2lz(a: f32) callconv(.AAPCS) i64 {
	197	return fixXfYi(i64, a);
	198	}
	199
	200	pub fn __aeabi_f2ulz(a: f32) callconv(.AAPCS) u64 {
	201	return fixXfYi(u64, a);
	202	}
	203
	204	// Conversion from f64
	205
	206	pub fn __aeabi_d2iz(a: f64) callconv(.AAPCS) i32 {
	207	return fixXfYi(i32, a);
	208	}
	209
	210	pub fn __aeabi_d2uiz(a: f64) callconv(.AAPCS) u32 {
	211	return fixXfYi(u32, a);
	212	}
	213
	214	pub fn __aeabi_d2lz(a: f64) callconv(.AAPCS) i64 {
	215	return fixXfYi(i64, a);
	216	}
	217
	218	pub fn __aeabi_d2ulz(a: f64) callconv(.AAPCS) u64 {
	219	return fixXfYi(u64, a);
	220	}
	221
	222	test {
	223	_ = @import("fixXfYi_test.zig");
	224	}

lib/std/special/compiler_rt/fixXfYi_test.zig created+948

...	...	@@ -0,0 +1,948 @@
	1	const std = @import("std");
	2	const testing = std.testing;
	3	const math = std.math;
	4	const fixXfYi = @import("fixXfYi.zig").fixXfYi;
	5
	6	// Conversion from f32
	7	const __fixsfsi = @import("fixXfYi.zig").__fixsfsi;
	8	const __fixunssfsi = @import("fixXfYi.zig").__fixunssfsi;
	9	const __fixsfdi = @import("fixXfYi.zig").__fixsfdi;
	10	const __fixunssfdi = @import("fixXfYi.zig").__fixunssfdi;
	11	const __fixsfti = @import("fixXfYi.zig").__fixsfti;
	12	const __fixunssfti = @import("fixXfYi.zig").__fixunssfti;
	13
	14	// Conversion from f64
	15	const __fixdfsi = @import("fixXfYi.zig").__fixdfsi;
	16	const __fixunsdfsi = @import("fixXfYi.zig").__fixunsdfsi;
	17	const __fixdfdi = @import("fixXfYi.zig").__fixdfdi;
	18	const __fixunsdfdi = @import("fixXfYi.zig").__fixunsdfdi;
	19	const __fixdfti = @import("fixXfYi.zig").__fixdfti;
	20	const __fixunsdfti = @import("fixXfYi.zig").__fixunsdfti;
	21
	22	// Conversion from f128
	23	const __fixtfsi = @import("fixXfYi.zig").__fixtfsi;
	24	const __fixunstfsi = @import("fixXfYi.zig").__fixunstfsi;
	25	const __fixtfdi = @import("fixXfYi.zig").__fixtfdi;
	26	const __fixunstfdi = @import("fixXfYi.zig").__fixunstfdi;
	27	const __fixtfti = @import("fixXfYi.zig").__fixtfti;
	28	const __fixunstfti = @import("fixXfYi.zig").__fixunstfti;
	29
	30	fn test__fixsfsi(a: f32, expected: i32) !void {
	31	const x = __fixsfsi(a);
	32	try testing.expect(x == expected);
	33	}
	34
	35	fn test__fixunssfsi(a: f32, expected: u32) !void {
	36	const x = __fixunssfsi(a);
	37	try testing.expect(x == expected);
	38	}
	39
	40	test "fixsfsi" {
	41	try test__fixsfsi(-math.floatMax(f32), math.minInt(i32));
	42
	43	try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
	44	try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
	45
	46	try test__fixsfsi(-0x1.0000000000000p+127, -0x80000000);
	47	try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
	48	try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
	49
	50	try test__fixsfsi(-0x1.0000000000001p+63, -0x80000000);
	51	try test__fixsfsi(-0x1.0000000000000p+63, -0x80000000);
	52	try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
	53	try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
	54
	55	try test__fixsfsi(-0x1.FFFFFEp+62, -0x80000000);
	56	try test__fixsfsi(-0x1.FFFFFCp+62, -0x80000000);
	57
	58	try test__fixsfsi(-0x1.000000p+31, -0x80000000);
	59	try test__fixsfsi(-0x1.FFFFFFp+30, -0x80000000);
	60	try test__fixsfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
	61	try test__fixsfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
	62
	63	try test__fixsfsi(-2.01, -2);
	64	try test__fixsfsi(-2.0, -2);
	65	try test__fixsfsi(-1.99, -1);
	66	try test__fixsfsi(-1.0, -1);
	67	try test__fixsfsi(-0.99, 0);
	68	try test__fixsfsi(-0.5, 0);
	69	try test__fixsfsi(-math.floatMin(f32), 0);
	70	try test__fixsfsi(0.0, 0);
	71	try test__fixsfsi(math.floatMin(f32), 0);
	72	try test__fixsfsi(0.5, 0);
	73	try test__fixsfsi(0.99, 0);
	74	try test__fixsfsi(1.0, 1);
	75	try test__fixsfsi(1.5, 1);
	76	try test__fixsfsi(1.99, 1);
	77	try test__fixsfsi(2.0, 2);
	78	try test__fixsfsi(2.01, 2);
	79
	80	try test__fixsfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
	81	try test__fixsfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
	82	try test__fixsfsi(0x1.FFFFFFp+30, 0x7FFFFFFF);
	83	try test__fixsfsi(0x1.000000p+31, 0x7FFFFFFF);
	84
	85	try test__fixsfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
	86	try test__fixsfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
	87
	88	try test__fixsfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
	89	try test__fixsfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
	90	try test__fixsfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
	91	try test__fixsfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
	92
	93	try test__fixsfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
	94	try test__fixsfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
	95	try test__fixsfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
	96
	97	try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
	98	try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
	99
	100	try test__fixsfsi(math.floatMax(f32), math.maxInt(i32));
	101	}
	102
	103	test "fixunssfsi" {
	104	try test__fixunssfsi(0.0, 0);
	105
	106	try test__fixunssfsi(0.5, 0);
	107	try test__fixunssfsi(0.99, 0);
	108	try test__fixunssfsi(1.0, 1);
	109	try test__fixunssfsi(1.5, 1);
	110	try test__fixunssfsi(1.99, 1);
	111	try test__fixunssfsi(2.0, 2);
	112	try test__fixunssfsi(2.01, 2);
	113	try test__fixunssfsi(-0.5, 0);
	114	try test__fixunssfsi(-0.99, 0);
	115
	116	try test__fixunssfsi(-1.0, 0);
	117	try test__fixunssfsi(-1.5, 0);
	118	try test__fixunssfsi(-1.99, 0);
	119	try test__fixunssfsi(-2.0, 0);
	120	try test__fixunssfsi(-2.01, 0);
	121
	122	try test__fixunssfsi(0x1.000000p+31, 0x80000000);
	123	try test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF);
	124	try test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
	125	try test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
	126	try test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
	127
	128	try test__fixunssfsi(-0x1.FFFFFEp+30, 0);
	129	try test__fixunssfsi(-0x1.FFFFFCp+30, 0);
	130	}
	131
	132	fn test__fixsfdi(a: f32, expected: i64) !void {
	133	const x = __fixsfdi(a);
	134	try testing.expect(x == expected);
	135	}
	136
	137	fn test__fixunssfdi(a: f32, expected: u64) !void {
	138	const x = __fixunssfdi(a);
	139	try testing.expect(x == expected);
	140	}
	141
	142	test "fixsfdi" {
	143	try test__fixsfdi(-math.floatMax(f32), math.minInt(i64));
	144
	145	try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
	146	try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
	147
	148	try test__fixsfdi(-0x1.0000000000000p+127, -0x8000000000000000);
	149	try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
	150	try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
	151
	152	try test__fixsfdi(-0x1.0000000000001p+63, -0x8000000000000000);
	153	try test__fixsfdi(-0x1.0000000000000p+63, -0x8000000000000000);
	154	try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
	155	try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
	156
	157	try test__fixsfdi(-0x1.FFFFFFp+62, -0x8000000000000000);
	158	try test__fixsfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
	159	try test__fixsfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
	160
	161	try test__fixsfdi(-2.01, -2);
	162	try test__fixsfdi(-2.0, -2);
	163	try test__fixsfdi(-1.99, -1);
	164	try test__fixsfdi(-1.0, -1);
	165	try test__fixsfdi(-0.99, 0);
	166	try test__fixsfdi(-0.5, 0);
	167	try test__fixsfdi(-math.floatMin(f32), 0);
	168	try test__fixsfdi(0.0, 0);
	169	try test__fixsfdi(math.floatMin(f32), 0);
	170	try test__fixsfdi(0.5, 0);
	171	try test__fixsfdi(0.99, 0);
	172	try test__fixsfdi(1.0, 1);
	173	try test__fixsfdi(1.5, 1);
	174	try test__fixsfdi(1.99, 1);
	175	try test__fixsfdi(2.0, 2);
	176	try test__fixsfdi(2.01, 2);
	177
	178	try test__fixsfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	179	try test__fixsfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	180	try test__fixsfdi(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
	181
	182	try test__fixsfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF);
	183	try test__fixsfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
	184	try test__fixsfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
	185	try test__fixsfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
	186
	187	try test__fixsfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
	188	try test__fixsfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
	189	try test__fixsfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
	190
	191	try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
	192	try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
	193
	194	try test__fixsfdi(math.floatMax(f32), math.maxInt(i64));
	195	}
	196
	197	test "fixunssfdi" {
	198	try test__fixunssfdi(0.0, 0);
	199
	200	try test__fixunssfdi(0.5, 0);
	201	try test__fixunssfdi(0.99, 0);
	202	try test__fixunssfdi(1.0, 1);
	203	try test__fixunssfdi(1.5, 1);
	204	try test__fixunssfdi(1.99, 1);
	205	try test__fixunssfdi(2.0, 2);
	206	try test__fixunssfdi(2.01, 2);
	207	try test__fixunssfdi(-0.5, 0);
	208	try test__fixunssfdi(-0.99, 0);
	209
	210	try test__fixunssfdi(-1.0, 0);
	211	try test__fixunssfdi(-1.5, 0);
	212	try test__fixunssfdi(-1.99, 0);
	213	try test__fixunssfdi(-2.0, 0);
	214	try test__fixunssfdi(-2.01, 0);
	215
	216	try test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
	217	try test__fixunssfdi(0x1.000000p+63, 0x8000000000000000);
	218	try test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	219	try test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	220
	221	try test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000);
	222	try test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000);
	223	}
	224
	225	fn test__fixsfti(a: f32, expected: i128) !void {
	226	const x = __fixsfti(a);
	227	try testing.expect(x == expected);
	228	}
	229
	230	fn test__fixunssfti(a: f32, expected: u128) !void {
	231	const x = __fixunssfti(a);
	232	try testing.expect(x == expected);
	233	}
	234
	235	test "fixsfti" {
	236	try test__fixsfti(-math.floatMax(f32), math.minInt(i128));
	237
	238	try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
	239	try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
	240
	241	try test__fixsfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
	242	try test__fixsfti(-0x1.FFFFFFFFFFFFFp+126, -0x80000000000000000000000000000000);
	243	try test__fixsfti(-0x1.FFFFFFFFFFFFEp+126, -0x80000000000000000000000000000000);
	244	try test__fixsfti(-0x1.FFFFFF0000000p+126, -0x80000000000000000000000000000000);
	245	try test__fixsfti(-0x1.FFFFFE0000000p+126, -0x7FFFFF80000000000000000000000000);
	246	try test__fixsfti(-0x1.FFFFFC0000000p+126, -0x7FFFFF00000000000000000000000000);
	247
	248	try test__fixsfti(-0x1.0000000000001p+63, -0x8000000000000000);
	249	try test__fixsfti(-0x1.0000000000000p+63, -0x8000000000000000);
	250	try test__fixsfti(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
	251	try test__fixsfti(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
	252
	253	try test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000);
	254	try test__fixsfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
	255	try test__fixsfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
	256
	257	try test__fixsfti(-0x1.000000p+31, -0x80000000);
	258	try test__fixsfti(-0x1.FFFFFFp+30, -0x80000000);
	259	try test__fixsfti(-0x1.FFFFFEp+30, -0x7FFFFF80);
	260	try test__fixsfti(-0x1.FFFFFCp+30, -0x7FFFFF00);
	261
	262	try test__fixsfti(-2.01, -2);
	263	try test__fixsfti(-2.0, -2);
	264	try test__fixsfti(-1.99, -1);
	265	try test__fixsfti(-1.0, -1);
	266	try test__fixsfti(-0.99, 0);
	267	try test__fixsfti(-0.5, 0);
	268	try test__fixsfti(-math.floatMin(f32), 0);
	269	try test__fixsfti(0.0, 0);
	270	try test__fixsfti(math.floatMin(f32), 0);
	271	try test__fixsfti(0.5, 0);
	272	try test__fixsfti(0.99, 0);
	273	try test__fixsfti(1.0, 1);
	274	try test__fixsfti(1.5, 1);
	275	try test__fixsfti(1.99, 1);
	276	try test__fixsfti(2.0, 2);
	277	try test__fixsfti(2.01, 2);
	278
	279	try test__fixsfti(0x1.FFFFFCp+30, 0x7FFFFF00);
	280	try test__fixsfti(0x1.FFFFFEp+30, 0x7FFFFF80);
	281	try test__fixsfti(0x1.FFFFFFp+30, 0x80000000);
	282	try test__fixsfti(0x1.000000p+31, 0x80000000);
	283
	284	try test__fixsfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	285	try test__fixsfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	286	try test__fixsfti(0x1.FFFFFFp+62, 0x8000000000000000);
	287
	288	try test__fixsfti(0x1.FFFFFFFFFFFFEp+62, 0x8000000000000000);
	289	try test__fixsfti(0x1.FFFFFFFFFFFFFp+62, 0x8000000000000000);
	290	try test__fixsfti(0x1.0000000000000p+63, 0x8000000000000000);
	291	try test__fixsfti(0x1.0000000000001p+63, 0x8000000000000000);
	292
	293	try test__fixsfti(0x1.FFFFFC0000000p+126, 0x7FFFFF00000000000000000000000000);
	294	try test__fixsfti(0x1.FFFFFE0000000p+126, 0x7FFFFF80000000000000000000000000);
	295	try test__fixsfti(0x1.FFFFFF0000000p+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	296	try test__fixsfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	297	try test__fixsfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	298	try test__fixsfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	299
	300	try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	301	try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
	302
	303	try test__fixsfti(math.floatMax(f32), math.maxInt(i128));
	304	}
	305
	306	test "fixunssfti" {
	307	try test__fixunssfti(0.0, 0);
	308
	309	try test__fixunssfti(0.5, 0);
	310	try test__fixunssfti(0.99, 0);
	311	try test__fixunssfti(1.0, 1);
	312	try test__fixunssfti(1.5, 1);
	313	try test__fixunssfti(1.99, 1);
	314	try test__fixunssfti(2.0, 2);
	315	try test__fixunssfti(2.01, 2);
	316	try test__fixunssfti(-0.5, 0);
	317	try test__fixunssfti(-0.99, 0);
	318
	319	try test__fixunssfti(-1.0, 0);
	320	try test__fixunssfti(-1.5, 0);
	321	try test__fixunssfti(-1.99, 0);
	322	try test__fixunssfti(-2.0, 0);
	323	try test__fixunssfti(-2.01, 0);
	324
	325	try test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
	326	try test__fixunssfti(0x1.000000p+63, 0x8000000000000000);
	327	try test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	328	try test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	329	try test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000);
	330	try test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000);
	331	try test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000);
	332	try test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000);
	333
	334	try test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000);
	335	try test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000);
	336	try test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000);
	337	try test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000);
	338	try test__fixunssfti(math.floatMax(f32), 0xffffff00000000000000000000000000);
	339	try test__fixunssfti(math.inf(f32), math.maxInt(u128));
	340	}
	341
	342	fn test__fixdfsi(a: f64, expected: i32) !void {
	343	const x = __fixdfsi(a);
	344	try testing.expect(x == expected);
	345	}
	346
	347	fn test__fixunsdfsi(a: f64, expected: u32) !void {
	348	const x = __fixunsdfsi(a);
	349	try testing.expect(x == expected);
	350	}
	351
	352	test "fixdfsi" {
	353	try test__fixdfsi(-math.floatMax(f64), math.minInt(i32));
	354
	355	try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
	356	try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
	357
	358	try test__fixdfsi(-0x1.0000000000000p+127, -0x80000000);
	359	try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
	360	try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
	361
	362	try test__fixdfsi(-0x1.0000000000001p+63, -0x80000000);
	363	try test__fixdfsi(-0x1.0000000000000p+63, -0x80000000);
	364	try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
	365	try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
	366
	367	try test__fixdfsi(-0x1.FFFFFEp+62, -0x80000000);
	368	try test__fixdfsi(-0x1.FFFFFCp+62, -0x80000000);
	369
	370	try test__fixdfsi(-0x1.000000p+31, -0x80000000);
	371	try test__fixdfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
	372	try test__fixdfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
	373
	374	try test__fixdfsi(-2.01, -2);
	375	try test__fixdfsi(-2.0, -2);
	376	try test__fixdfsi(-1.99, -1);
	377	try test__fixdfsi(-1.0, -1);
	378	try test__fixdfsi(-0.99, 0);
	379	try test__fixdfsi(-0.5, 0);
	380	try test__fixdfsi(-math.floatMin(f64), 0);
	381	try test__fixdfsi(0.0, 0);
	382	try test__fixdfsi(math.floatMin(f64), 0);
	383	try test__fixdfsi(0.5, 0);
	384	try test__fixdfsi(0.99, 0);
	385	try test__fixdfsi(1.0, 1);
	386	try test__fixdfsi(1.5, 1);
	387	try test__fixdfsi(1.99, 1);
	388	try test__fixdfsi(2.0, 2);
	389	try test__fixdfsi(2.01, 2);
	390
	391	try test__fixdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
	392	try test__fixdfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
	393	try test__fixdfsi(0x1.000000p+31, 0x7FFFFFFF);
	394
	395	try test__fixdfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
	396	try test__fixdfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
	397
	398	try test__fixdfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
	399	try test__fixdfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
	400	try test__fixdfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
	401	try test__fixdfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
	402
	403	try test__fixdfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
	404	try test__fixdfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
	405	try test__fixdfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
	406
	407	try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
	408	try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
	409
	410	try test__fixdfsi(math.floatMax(f64), math.maxInt(i32));
	411	}
	412
	413	test "fixunsdfsi" {
	414	try test__fixunsdfsi(0.0, 0);
	415
	416	try test__fixunsdfsi(0.5, 0);
	417	try test__fixunsdfsi(0.99, 0);
	418	try test__fixunsdfsi(1.0, 1);
	419	try test__fixunsdfsi(1.5, 1);
	420	try test__fixunsdfsi(1.99, 1);
	421	try test__fixunsdfsi(2.0, 2);
	422	try test__fixunsdfsi(2.01, 2);
	423	try test__fixunsdfsi(-0.5, 0);
	424	try test__fixunsdfsi(-0.99, 0);
	425	try test__fixunsdfsi(-1.0, 0);
	426	try test__fixunsdfsi(-1.5, 0);
	427	try test__fixunsdfsi(-1.99, 0);
	428	try test__fixunsdfsi(-2.0, 0);
	429	try test__fixunsdfsi(-2.01, 0);
	430
	431	try test__fixunsdfsi(0x1.000000p+31, 0x80000000);
	432	try test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF);
	433	try test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
	434	try test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
	435	try test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
	436
	437	try test__fixunsdfsi(-0x1.FFFFFEp+30, 0);
	438	try test__fixunsdfsi(-0x1.FFFFFCp+30, 0);
	439
	440	try test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF);
	441	try test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF);
	442	try test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE);
	443	}
	444
	445	fn test__fixdfdi(a: f64, expected: i64) !void {
	446	const x = __fixdfdi(a);
	447	try testing.expect(x == expected);
	448	}
	449
	450	fn test__fixunsdfdi(a: f64, expected: u64) !void {
	451	const x = __fixunsdfdi(a);
	452	try testing.expect(x == expected);
	453	}
	454
	455	test "fixdfdi" {
	456	try test__fixdfdi(-math.floatMax(f64), math.minInt(i64));
	457
	458	try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
	459	try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
	460
	461	try test__fixdfdi(-0x1.0000000000000p+127, -0x8000000000000000);
	462	try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
	463	try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
	464
	465	try test__fixdfdi(-0x1.0000000000001p+63, -0x8000000000000000);
	466	try test__fixdfdi(-0x1.0000000000000p+63, -0x8000000000000000);
	467	try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
	468	try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
	469
	470	try test__fixdfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
	471	try test__fixdfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
	472
	473	try test__fixdfdi(-2.01, -2);
	474	try test__fixdfdi(-2.0, -2);
	475	try test__fixdfdi(-1.99, -1);
	476	try test__fixdfdi(-1.0, -1);
	477	try test__fixdfdi(-0.99, 0);
	478	try test__fixdfdi(-0.5, 0);
	479	try test__fixdfdi(-math.floatMin(f64), 0);
	480	try test__fixdfdi(0.0, 0);
	481	try test__fixdfdi(math.floatMin(f64), 0);
	482	try test__fixdfdi(0.5, 0);
	483	try test__fixdfdi(0.99, 0);
	484	try test__fixdfdi(1.0, 1);
	485	try test__fixdfdi(1.5, 1);
	486	try test__fixdfdi(1.99, 1);
	487	try test__fixdfdi(2.0, 2);
	488	try test__fixdfdi(2.01, 2);
	489
	490	try test__fixdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	491	try test__fixdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	492
	493	try test__fixdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	494	try test__fixdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	495	try test__fixdfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
	496	try test__fixdfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
	497
	498	try test__fixdfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
	499	try test__fixdfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
	500	try test__fixdfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
	501
	502	try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
	503	try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
	504
	505	try test__fixdfdi(math.floatMax(f64), math.maxInt(i64));
	506	}
	507
	508	test "fixunsdfdi" {
	509	try test__fixunsdfdi(0.0, 0);
	510	try test__fixunsdfdi(0.5, 0);
	511	try test__fixunsdfdi(0.99, 0);
	512	try test__fixunsdfdi(1.0, 1);
	513	try test__fixunsdfdi(1.5, 1);
	514	try test__fixunsdfdi(1.99, 1);
	515	try test__fixunsdfdi(2.0, 2);
	516	try test__fixunsdfdi(2.01, 2);
	517	try test__fixunsdfdi(-0.5, 0);
	518	try test__fixunsdfdi(-0.99, 0);
	519	try test__fixunsdfdi(-1.0, 0);
	520	try test__fixunsdfdi(-1.5, 0);
	521	try test__fixunsdfdi(-1.99, 0);
	522	try test__fixunsdfdi(-2.0, 0);
	523	try test__fixunsdfdi(-2.01, 0);
	524
	525	try test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	526	try test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	527
	528	try test__fixunsdfdi(-0x1.FFFFFEp+62, 0);
	529	try test__fixunsdfdi(-0x1.FFFFFCp+62, 0);
	530
	531	try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
	532	try test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000);
	533	try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	534	try test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	535
	536	try test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
	537	try test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
	538	}
	539
	540	fn test__fixdfti(a: f64, expected: i128) !void {
	541	const x = __fixdfti(a);
	542	try testing.expect(x == expected);
	543	}
	544
	545	fn test__fixunsdfti(a: f64, expected: u128) !void {
	546	const x = __fixunsdfti(a);
	547	try testing.expect(x == expected);
	548	}
	549
	550	test "fixdfti" {
	551	try test__fixdfti(-math.floatMax(f64), math.minInt(i128));
	552
	553	try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
	554	try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
	555
	556	try test__fixdfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
	557	try test__fixdfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
	558	try test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
	559
	560	try test__fixdfti(-0x1.0000000000001p+63, -0x8000000000000800);
	561	try test__fixdfti(-0x1.0000000000000p+63, -0x8000000000000000);
	562	try test__fixdfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
	563	try test__fixdfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
	564
	565	try test__fixdfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
	566	try test__fixdfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
	567
	568	try test__fixdfti(-2.01, -2);
	569	try test__fixdfti(-2.0, -2);
	570	try test__fixdfti(-1.99, -1);
	571	try test__fixdfti(-1.0, -1);
	572	try test__fixdfti(-0.99, 0);
	573	try test__fixdfti(-0.5, 0);
	574	try test__fixdfti(-math.floatMin(f64), 0);
	575	try test__fixdfti(0.0, 0);
	576	try test__fixdfti(math.floatMin(f64), 0);
	577	try test__fixdfti(0.5, 0);
	578	try test__fixdfti(0.99, 0);
	579	try test__fixdfti(1.0, 1);
	580	try test__fixdfti(1.5, 1);
	581	try test__fixdfti(1.99, 1);
	582	try test__fixdfti(2.0, 2);
	583	try test__fixdfti(2.01, 2);
	584
	585	try test__fixdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	586	try test__fixdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	587
	588	try test__fixdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	589	try test__fixdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	590	try test__fixdfti(0x1.0000000000000p+63, 0x8000000000000000);
	591	try test__fixdfti(0x1.0000000000001p+63, 0x8000000000000800);
	592
	593	try test__fixdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
	594	try test__fixdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
	595	try test__fixdfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	596
	597	try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	598	try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
	599
	600	try test__fixdfti(math.floatMax(f64), math.maxInt(i128));
	601	}
	602
	603	test "fixunsdfti" {
	604	try test__fixunsdfti(0.0, 0);
	605
	606	try test__fixunsdfti(0.5, 0);
	607	try test__fixunsdfti(0.99, 0);
	608	try test__fixunsdfti(1.0, 1);
	609	try test__fixunsdfti(1.5, 1);
	610	try test__fixunsdfti(1.99, 1);
	611	try test__fixunsdfti(2.0, 2);
	612	try test__fixunsdfti(2.01, 2);
	613	try test__fixunsdfti(-0.5, 0);
	614	try test__fixunsdfti(-0.99, 0);
	615	try test__fixunsdfti(-1.0, 0);
	616	try test__fixunsdfti(-1.5, 0);
	617	try test__fixunsdfti(-1.99, 0);
	618	try test__fixunsdfti(-2.0, 0);
	619	try test__fixunsdfti(-2.01, 0);
	620
	621	try test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	622	try test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	623
	624	try test__fixunsdfti(-0x1.FFFFFEp+62, 0);
	625	try test__fixunsdfti(-0x1.FFFFFCp+62, 0);
	626
	627	try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
	628	try test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000);
	629	try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	630	try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	631
	632	try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000);
	633	try test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000);
	634	try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
	635	try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
	636	try test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	637
	638	try test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0);
	639	try test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0);
	640	}
	641
	642	fn test__fixtfsi(a: f128, expected: i32) !void {
	643	const x = __fixtfsi(a);
	644	try testing.expect(x == expected);
	645	}
	646
	647	fn test__fixunstfsi(a: f128, expected: u32) !void {
	648	const x = __fixunstfsi(a);
	649	try testing.expect(x == expected);
	650	}
	651
	652	test "fixtfsi" {
	653	try test__fixtfsi(-math.floatMax(f128), math.minInt(i32));
	654
	655	try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
	656	try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
	657
	658	try test__fixtfsi(-0x1.0000000000000p+127, -0x80000000);
	659	try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
	660	try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
	661
	662	try test__fixtfsi(-0x1.0000000000001p+63, -0x80000000);
	663	try test__fixtfsi(-0x1.0000000000000p+63, -0x80000000);
	664	try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
	665	try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
	666
	667	try test__fixtfsi(-0x1.FFFFFEp+62, -0x80000000);
	668	try test__fixtfsi(-0x1.FFFFFCp+62, -0x80000000);
	669
	670	try test__fixtfsi(-0x1.000000p+31, -0x80000000);
	671	try test__fixtfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
	672	try test__fixtfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
	673	try test__fixtfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
	674
	675	try test__fixtfsi(-2.01, -2);
	676	try test__fixtfsi(-2.0, -2);
	677	try test__fixtfsi(-1.99, -1);
	678	try test__fixtfsi(-1.0, -1);
	679	try test__fixtfsi(-0.99, 0);
	680	try test__fixtfsi(-0.5, 0);
	681	try test__fixtfsi(-math.floatMin(f32), 0);
	682	try test__fixtfsi(0.0, 0);
	683	try test__fixtfsi(math.floatMin(f32), 0);
	684	try test__fixtfsi(0.5, 0);
	685	try test__fixtfsi(0.99, 0);
	686	try test__fixtfsi(1.0, 1);
	687	try test__fixtfsi(1.5, 1);
	688	try test__fixtfsi(1.99, 1);
	689	try test__fixtfsi(2.0, 2);
	690	try test__fixtfsi(2.01, 2);
	691
	692	try test__fixtfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
	693	try test__fixtfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
	694	try test__fixtfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
	695	try test__fixtfsi(0x1.000000p+31, 0x7FFFFFFF);
	696
	697	try test__fixtfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
	698	try test__fixtfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
	699
	700	try test__fixtfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
	701	try test__fixtfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
	702	try test__fixtfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
	703	try test__fixtfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
	704
	705	try test__fixtfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
	706	try test__fixtfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
	707	try test__fixtfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
	708
	709	try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
	710	try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
	711
	712	try test__fixtfsi(math.floatMax(f128), math.maxInt(i32));
	713	}
	714
	715	test "fixunstfsi" {
	716	try test__fixunstfsi(math.inf(f128), 0xffffffff);
	717	try test__fixunstfsi(0, 0x0);
	718	try test__fixunstfsi(0x1.23456789abcdefp+5, 0x24);
	719	try test__fixunstfsi(0x1.23456789abcdefp-3, 0x0);
	720	try test__fixunstfsi(0x1.23456789abcdefp+20, 0x123456);
	721	try test__fixunstfsi(0x1.23456789abcdefp+40, 0xffffffff);
	722	try test__fixunstfsi(0x1.23456789abcdefp+256, 0xffffffff);
	723	try test__fixunstfsi(-0x1.23456789abcdefp+3, 0x0);
	724
	725	try test__fixunstfsi(0x1p+32, 0xFFFFFFFF);
	726	}
	727
	728	fn test__fixtfdi(a: f128, expected: i64) !void {
	729	const x = __fixtfdi(a);
	730	try testing.expect(x == expected);
	731	}
	732
	733	fn test__fixunstfdi(a: f128, expected: u64) !void {
	734	const x = __fixunstfdi(a);
	735	try testing.expect(x == expected);
	736	}
	737
	738	test "fixtfdi" {
	739	try test__fixtfdi(-math.floatMax(f128), math.minInt(i64));
	740
	741	try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
	742	try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
	743
	744	try test__fixtfdi(-0x1.0000000000000p+127, -0x8000000000000000);
	745	try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
	746	try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
	747
	748	try test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000);
	749	try test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000);
	750	try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
	751	try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
	752
	753	try test__fixtfdi(-0x1.FFFFFEp+62, -0x7FFFFF8000000000);
	754	try test__fixtfdi(-0x1.FFFFFCp+62, -0x7FFFFF0000000000);
	755
	756	try test__fixtfdi(-0x1.000000p+31, -0x80000000);
	757	try test__fixtfdi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
	758	try test__fixtfdi(-0x1.FFFFFEp+30, -0x7FFFFF80);
	759	try test__fixtfdi(-0x1.FFFFFCp+30, -0x7FFFFF00);
	760
	761	try test__fixtfdi(-2.01, -2);
	762	try test__fixtfdi(-2.0, -2);
	763	try test__fixtfdi(-1.99, -1);
	764	try test__fixtfdi(-1.0, -1);
	765	try test__fixtfdi(-0.99, 0);
	766	try test__fixtfdi(-0.5, 0);
	767	try test__fixtfdi(-math.floatMin(f64), 0);
	768	try test__fixtfdi(0.0, 0);
	769	try test__fixtfdi(math.floatMin(f64), 0);
	770	try test__fixtfdi(0.5, 0);
	771	try test__fixtfdi(0.99, 0);
	772	try test__fixtfdi(1.0, 1);
	773	try test__fixtfdi(1.5, 1);
	774	try test__fixtfdi(1.99, 1);
	775	try test__fixtfdi(2.0, 2);
	776	try test__fixtfdi(2.01, 2);
	777
	778	try test__fixtfdi(0x1.FFFFFCp+30, 0x7FFFFF00);
	779	try test__fixtfdi(0x1.FFFFFEp+30, 0x7FFFFF80);
	780	try test__fixtfdi(0x1.FFFFFFp+30, 0x7FFFFFC0);
	781	try test__fixtfdi(0x1.000000p+31, 0x80000000);
	782
	783	try test__fixtfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	784	try test__fixtfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	785
	786	try test__fixtfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	787	try test__fixtfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	788	try test__fixtfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
	789	try test__fixtfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
	790
	791	try test__fixtfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
	792	try test__fixtfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
	793	try test__fixtfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
	794
	795	try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
	796	try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
	797
	798	try test__fixtfdi(math.floatMax(f128), math.maxInt(i64));
	799	}
	800
	801	test "fixunstfdi" {
	802	try test__fixunstfdi(0.0, 0);
	803
	804	try test__fixunstfdi(0.5, 0);
	805	try test__fixunstfdi(0.99, 0);
	806	try test__fixunstfdi(1.0, 1);
	807	try test__fixunstfdi(1.5, 1);
	808	try test__fixunstfdi(1.99, 1);
	809	try test__fixunstfdi(2.0, 2);
	810	try test__fixunstfdi(2.01, 2);
	811	try test__fixunstfdi(-0.5, 0);
	812	try test__fixunstfdi(-0.99, 0);
	813	try test__fixunstfdi(-1.0, 0);
	814	try test__fixunstfdi(-1.5, 0);
	815	try test__fixunstfdi(-1.99, 0);
	816	try test__fixunstfdi(-2.0, 0);
	817	try test__fixunstfdi(-2.01, 0);
	818
	819	try test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	820	try test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	821
	822	try test__fixunstfdi(-0x1.FFFFFEp+62, 0);
	823	try test__fixunstfdi(-0x1.FFFFFCp+62, 0);
	824
	825	try test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	826	try test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	827
	828	try test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
	829	try test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
	830
	831	try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF);
	832	try test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001);
	833	try test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000);
	834	try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF);
	835	try test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE);
	836	try test__fixunstfdi(0x1p+64, 0xFFFFFFFFFFFFFFFF);
	837
	838	try test__fixunstfdi(-0x1.0000000000000000p+63, 0);
	839	try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0);
	840	try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0);
	841	}
	842
	843	fn test__fixtfti(a: f128, expected: i128) !void {
	844	const x = __fixtfti(a);
	845	try testing.expect(x == expected);
	846	}
	847
	848	fn test__fixunstfti(a: f128, expected: u128) !void {
	849	const x = __fixunstfti(a);
	850	try testing.expect(x == expected);
	851	}
	852
	853	test "fixtfti" {
	854	try test__fixtfti(-math.floatMax(f128), math.minInt(i128));
	855
	856	try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
	857	try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
	858
	859	try test__fixtfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
	860	try test__fixtfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
	861	try test__fixtfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
	862
	863	try test__fixtfti(-0x1.0000000000001p+63, -0x8000000000000800);
	864	try test__fixtfti(-0x1.0000000000000p+63, -0x8000000000000000);
	865	try test__fixtfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
	866	try test__fixtfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
	867
	868	try test__fixtfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
	869	try test__fixtfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
	870
	871	try test__fixtfti(-2.01, -2);
	872	try test__fixtfti(-2.0, -2);
	873	try test__fixtfti(-1.99, -1);
	874	try test__fixtfti(-1.0, -1);
	875	try test__fixtfti(-0.99, 0);
	876	try test__fixtfti(-0.5, 0);
	877	try test__fixtfti(-math.floatMin(f128), 0);
	878	try test__fixtfti(0.0, 0);
	879	try test__fixtfti(math.floatMin(f128), 0);
	880	try test__fixtfti(0.5, 0);
	881	try test__fixtfti(0.99, 0);
	882	try test__fixtfti(1.0, 1);
	883	try test__fixtfti(1.5, 1);
	884	try test__fixtfti(1.99, 1);
	885	try test__fixtfti(2.0, 2);
	886	try test__fixtfti(2.01, 2);
	887
	888	try test__fixtfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
	889	try test__fixtfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
	890
	891	try test__fixtfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
	892	try test__fixtfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
	893	try test__fixtfti(0x1.0000000000000p+63, 0x8000000000000000);
	894	try test__fixtfti(0x1.0000000000001p+63, 0x8000000000000800);
	895
	896	try test__fixtfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
	897	try test__fixtfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
	898	try test__fixtfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	899
	900	try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
	901	try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
	902
	903	try test__fixtfti(math.floatMax(f128), math.maxInt(i128));
	904	}
	905
	906	test "fixunstfti" {
	907	try test__fixunstfti(math.inf(f128), 0xffffffffffffffffffffffffffffffff);
	908
	909	try test__fixunstfti(0.0, 0);
	910
	911	try test__fixunstfti(0.5, 0);
	912	try test__fixunstfti(0.99, 0);
	913	try test__fixunstfti(1.0, 1);
	914	try test__fixunstfti(1.5, 1);
	915	try test__fixunstfti(1.99, 1);
	916	try test__fixunstfti(2.0, 2);
	917	try test__fixunstfti(2.01, 2);
	918	try test__fixunstfti(-0.01, 0);
	919	try test__fixunstfti(-0.99, 0);
	920
	921	try test__fixunstfti(0x1p+128, 0xffffffffffffffffffffffffffffffff);
	922
	923	try test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000);
	924	try test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000);
	925	try test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff);
	926	try test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff);
	927	}
	928
	929	fn test__fixunshfti(a: f16, expected: u128) !void {
	930	const x = fixXfYi(u128, a);
	931	try testing.expect(x == expected);
	932	}
	933
	934	test "fixXfYi for f16" {
	935	try test__fixunshfti(math.inf(f16), math.maxInt(u128));
	936	try test__fixunshfti(math.floatMax(f16), 65504);
	937	}
	938
	939	fn test__fixunsxfti(a: f80, expected: u128) !void {
	940	const x = fixXfYi(u128, a);
	941	try testing.expect(x == expected);
	942	}
	943
	944	test "fixXfYi for f80" {
	945	try test__fixunsxfti(math.inf(f80), math.maxInt(u128));
	946	try test__fixunsxfti(math.floatMax(f80), math.maxInt(u128));
	947	try test__fixunsxfti(math.maxInt(u64), math.maxInt(u64));
	948	}

lib/std/special/compiler_rt/fixdfdi.zig deleted-16

...	...	@@ -1,16 +0,0 @@
1		const fixint = @import("fixint.zig").fixint;
2		const builtin = @import("builtin");
3
4		pub fn __fixdfdi(a: f64) callconv(.C) i64 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixint(f64, i64, a);
7		}
8
9		pub fn __aeabi_d2lz(arg: f64) callconv(.AAPCS) i64 {
10		@setRuntimeSafety(false);
11		return @call(.{ .modifier = .always_inline }, __fixdfdi, .{arg});
12		}
13
14		test {
15		_ = @import("fixdfdi_test.zig");
16		}

lib/std/special/compiler_rt/fixdfdi_test.zig deleted-62

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

lib/std/special/compiler_rt/fixdfsi.zig deleted-16

...	...	@@ -1,16 +0,0 @@
1		const fixint = @import("fixint.zig").fixint;
2		const builtin = @import("builtin");
3
4		pub fn __fixdfsi(a: f64) callconv(.C) i32 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixint(f64, i32, a);
7		}
8
9		pub fn __aeabi_d2iz(a: f64) callconv(.AAPCS) i32 {
10		@setRuntimeSafety(false);
11		return @call(.{ .modifier = .always_inline }, __fixdfsi, .{a});
12		}
13
14		test {
15		_ = @import("fixdfsi_test.zig");
16		}

lib/std/special/compiler_rt/fixdfsi_test.zig deleted-70

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

lib/std/special/compiler_rt/fixdfti.zig deleted-11

...	...	@@ -1,11 +0,0 @@
1		const fixint = @import("fixint.zig").fixint;
2		const builtin = @import("builtin");
3
4		pub fn __fixdfti(a: f64) callconv(.C) i128 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixint(f64, i128, a);
7		}
8
9		test {
10		_ = @import("fixdfti_test.zig");
11		}

lib/std/special/compiler_rt/fixdfti_test.zig deleted-62

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

lib/std/special/compiler_rt/fixint.zig deleted-75

...	...	@@ -1,75 +0,0 @@
1		const is_test = @import("builtin").is_test;
2		const std = @import("std");
3		const math = std.math;
4		const Log2Int = std.math.Log2Int;
5		const maxInt = std.math.maxInt;
6		const minInt = std.math.minInt;
7
8		const DBG = false;
9
10		pub fn fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t) fixint_t {
11		@setRuntimeSafety(is_test);
12
13		const rep_t = switch (fp_t) {
14		f32 => u32,
15		f64 => u64,
16		f128 => u128,
17		else => unreachable,
18		};
19		const significandBits = switch (fp_t) {
20		f32 => 23,
21		f64 => 52,
22		f128 => 112,
23		else => unreachable,
24		};
25
26		const typeWidth = @typeInfo(rep_t).Int.bits;
27		const exponentBits = (typeWidth - significandBits - 1);
28		const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
29		const maxExponent = ((1 << exponentBits) - 1);
30		const exponentBias = (maxExponent >> 1);
31
32		const implicitBit = (@as(rep_t, 1) << significandBits);
33		const significandMask = (implicitBit - 1);
34
35		// Break a into sign, exponent, significand
36		const aRep: rep_t = @bitCast(rep_t, a);
37		const absMask = signBit - 1;
38		const aAbs: rep_t = aRep & absMask;
39
40		const negative = (aRep & signBit) != 0;
41		const exponent = @intCast(i32, aAbs >> significandBits) - exponentBias;
42		const significand: rep_t = (aAbs & significandMask) \| implicitBit;
43
44		// If exponent is negative, the uint_result is zero.
45		if (exponent < 0) return 0;
46
47		// The unsigned result needs to be large enough to handle an fixint_t or rep_t
48		const fixint_bits = @typeInfo(fixint_t).Int.bits;
49		const fixuint_t = std.meta.Int(.unsigned, fixint_bits);
50		const UintResultType = if (fixint_bits > typeWidth) fixuint_t else rep_t;
51		var uint_result: UintResultType = undefined;
52
53		// If the value is too large for the integer type, saturate.
54		if (@intCast(usize, exponent) >= fixint_bits) {
55		return if (negative) @as(fixint_t, minInt(fixint_t)) else @as(fixint_t, maxInt(fixint_t));
56		}
57
58		// If 0 <= exponent < significandBits, right shift else left shift
59		if (exponent < significandBits) {
60		uint_result = @intCast(UintResultType, significand) >> @intCast(Log2Int(UintResultType), significandBits - exponent);
61		} else {
62		uint_result = @intCast(UintResultType, significand) << @intCast(Log2Int(UintResultType), exponent - significandBits);
63		}
64
65		// Cast to final signed result
66		if (negative) {
67		return if (uint_result >= -math.minInt(fixint_t)) math.minInt(fixint_t) else -@intCast(fixint_t, uint_result);
68		} else {
69		return if (uint_result >= math.maxInt(fixint_t)) math.maxInt(fixint_t) else @intCast(fixint_t, uint_result);
70		}
71		}
72
73		test {
74		_ = @import("fixint_test.zig");
75		}

lib/std/special/compiler_rt/fixsfdi.zig deleted-16

...	...	@@ -1,16 +0,0 @@
1		const fixint = @import("fixint.zig").fixint;
2		const builtin = @import("builtin");
3
4		pub fn __fixsfdi(a: f32) callconv(.C) i64 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixint(f32, i64, a);
7		}
8
9		pub fn __aeabi_f2lz(arg: f32) callconv(.AAPCS) i64 {
10		@setRuntimeSafety(false);
11		return @call(.{ .modifier = .always_inline }, __fixsfdi, .{arg});
12		}
13
14		test {
15		_ = @import("fixsfdi_test.zig");
16		}

lib/std/special/compiler_rt/fixsfdi_test.zig deleted-64

...	...	@@ -1,64 +0,0 @@
1		const __fixsfdi = @import("fixsfdi.zig").__fixsfdi;
2		const std = @import("std");
3		const math = std.math;
4		const testing = std.testing;
5
6		fn test__fixsfdi(a: f32, expected: i64) !void {
7		const x = __fixsfdi(a);
8		try testing.expect(x == expected);
9		}
10
11		test "fixsfdi" {
12		try test__fixsfdi(-math.floatMax(f32), math.minInt(i64));
13
14		try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
15		try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
16
17		try test__fixsfdi(-0x1.0000000000000p+127, -0x8000000000000000);
18		try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
19		try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
20
21		try test__fixsfdi(-0x1.0000000000001p+63, -0x8000000000000000);
22		try test__fixsfdi(-0x1.0000000000000p+63, -0x8000000000000000);
23		try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
24		try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
25
26		try test__fixsfdi(-0x1.FFFFFFp+62, -0x8000000000000000);
27		try test__fixsfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
28		try test__fixsfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
29
30		try test__fixsfdi(-2.01, -2);
31		try test__fixsfdi(-2.0, -2);
32		try test__fixsfdi(-1.99, -1);
33		try test__fixsfdi(-1.0, -1);
34		try test__fixsfdi(-0.99, 0);
35		try test__fixsfdi(-0.5, 0);
36		try test__fixsfdi(-math.floatMin(f32), 0);
37		try test__fixsfdi(0.0, 0);
38		try test__fixsfdi(math.floatMin(f32), 0);
39		try test__fixsfdi(0.5, 0);
40		try test__fixsfdi(0.99, 0);
41		try test__fixsfdi(1.0, 1);
42		try test__fixsfdi(1.5, 1);
43		try test__fixsfdi(1.99, 1);
44		try test__fixsfdi(2.0, 2);
45		try test__fixsfdi(2.01, 2);
46
47		try test__fixsfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
48		try test__fixsfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
49		try test__fixsfdi(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
50
51		try test__fixsfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF);
52		try test__fixsfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
53		try test__fixsfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
54		try test__fixsfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
55
56		try test__fixsfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
57		try test__fixsfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
58		try test__fixsfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
59
60		try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
61		try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
62
63		try test__fixsfdi(math.floatMax(f32), math.maxInt(i64));
64		}

lib/std/special/compiler_rt/fixsfsi.zig deleted-16

...	...	@@ -1,16 +0,0 @@
1		const fixint = @import("fixint.zig").fixint;
2		const builtin = @import("builtin");
3
4		pub fn __fixsfsi(a: f32) callconv(.C) i32 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixint(f32, i32, a);
7		}
8
9		pub fn __aeabi_f2iz(a: f32) callconv(.AAPCS) i32 {
10		@setRuntimeSafety(false);
11		return @call(.{ .modifier = .always_inline }, __fixsfsi, .{a});
12		}
13
14		test {
15		_ = @import("fixsfsi_test.zig");
16		}

lib/std/special/compiler_rt/fixsfsi_test.zig deleted-72

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

lib/std/special/compiler_rt/fixsfti.zig deleted-11

...	...	@@ -1,11 +0,0 @@
1		const fixint = @import("fixint.zig").fixint;
2		const builtin = @import("builtin");
3
4		pub fn __fixsfti(a: f32) callconv(.C) i128 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixint(f32, i128, a);
7		}
8
9		test {
10		_ = @import("fixsfti_test.zig");
11		}

lib/std/special/compiler_rt/fixsfti_test.zig deleted-80

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

lib/std/special/compiler_rt/fixtfdi.zig deleted-11

...	...	@@ -1,11 +0,0 @@
1		const fixint = @import("fixint.zig").fixint;
2		const builtin = @import("builtin");
3
4		pub fn __fixtfdi(a: f128) callconv(.C) i64 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixint(f128, i64, a);
7		}
8
9		test {
10		_ = @import("fixtfdi_test.zig");
11		}

lib/std/special/compiler_rt/fixtfdi_test.zig deleted-72

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

lib/std/special/compiler_rt/fixtfsi.zig deleted-11

...	...	@@ -1,11 +0,0 @@
1		const fixint = @import("fixint.zig").fixint;
2		const builtin = @import("builtin");
3
4		pub fn __fixtfsi(a: f128) callconv(.C) i32 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixint(f128, i32, a);
7		}
8
9		test {
10		_ = @import("fixtfsi_test.zig");
11		}

lib/std/special/compiler_rt/fixtfsi_test.zig deleted-72

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

lib/std/special/compiler_rt/fixtfti.zig deleted-11

...	...	@@ -1,11 +0,0 @@
1		const fixint = @import("fixint.zig").fixint;
2		const builtin = @import("builtin");
3
4		pub fn __fixtfti(a: f128) callconv(.C) i128 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixint(f128, i128, a);
7		}
8
9		test {
10		_ = @import("fixtfti_test.zig");
11		}

lib/std/special/compiler_rt/fixtfti_test.zig deleted-62

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

lib/std/special/compiler_rt/fixuint.zig deleted-50

...	...	@@ -1,50 +0,0 @@
1		const is_test = @import("builtin").is_test;
2		const Log2Int = @import("std").math.Log2Int;
3
4		pub inline fn fixuint(comptime fp_t: type, comptime fixuint_t: type, a: fp_t) fixuint_t {
5		@setRuntimeSafety(is_test);
6
7		const rep_t = switch (fp_t) {
8		f32 => u32,
9		f64 => u64,
10		f128 => u128,
11		else => unreachable,
12		};
13		const typeWidth = @typeInfo(rep_t).Int.bits;
14		const significandBits = switch (fp_t) {
15		f32 => 23,
16		f64 => 52,
17		f128 => 112,
18		else => unreachable,
19		};
20		const exponentBits = (typeWidth - significandBits - 1);
21		const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
22		const maxExponent = ((1 << exponentBits) - 1);
23		const exponentBias = (maxExponent >> 1);
24
25		const implicitBit = (@as(rep_t, 1) << significandBits);
26		const significandMask = (implicitBit - 1);
27
28		// Break a into sign, exponent, significand
29		const aRep: rep_t = @bitCast(rep_t, a);
30		const absMask = signBit - 1;
31		const aAbs: rep_t = aRep & absMask;
32
33		const sign = if ((aRep & signBit) != 0) @as(i32, -1) else @as(i32, 1);
34		const exponent = @intCast(i32, aAbs >> significandBits) - exponentBias;
35		const significand: rep_t = (aAbs & significandMask) \| implicitBit;
36
37		// If either the value or the exponent is negative, the result is zero.
38		if (sign == -1 or exponent < 0) return 0;
39
40		// If the value is too large for the integer type, saturate.
41		if (@intCast(c_uint, exponent) >= @typeInfo(fixuint_t).Int.bits) return ~@as(fixuint_t, 0);
42
43		// If 0 <= exponent < significandBits, right shift to get the result.
44		// Otherwise, shift left.
45		if (exponent < significandBits) {
46		return @intCast(fixuint_t, significand >> @intCast(Log2Int(rep_t), significandBits - exponent));
47		} else {
48		return @intCast(fixuint_t, significand) << @intCast(Log2Int(fixuint_t), exponent - significandBits);
49		}
50		}

lib/std/special/compiler_rt/fixunsdfdi.zig deleted-16

...	...	@@ -1,16 +0,0 @@
1		const fixuint = @import("fixuint.zig").fixuint;
2		const builtin = @import("builtin");
3
4		pub fn __fixunsdfdi(a: f64) callconv(.C) u64 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixuint(f64, u64, a);
7		}
8
9		pub fn __aeabi_d2ulz(a: f64) callconv(.AAPCS) u64 {
10		@setRuntimeSafety(false);
11		return @call(.{ .modifier = .always_inline }, __fixunsdfdi, .{a});
12		}
13
14		test {
15		_ = @import("fixunsdfdi_test.zig");
16		}

lib/std/special/compiler_rt/fixunsdfdi_test.zig deleted-39

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

lib/std/special/compiler_rt/fixunsdfsi.zig deleted-16

...	...	@@ -1,16 +0,0 @@
1		const fixuint = @import("fixuint.zig").fixuint;
2		const builtin = @import("builtin");
3
4		pub fn __fixunsdfsi(a: f64) callconv(.C) u32 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixuint(f64, u32, a);
7		}
8
9		pub fn __aeabi_d2uiz(arg: f64) callconv(.AAPCS) u32 {
10		@setRuntimeSafety(false);
11		return @call(.{ .modifier = .always_inline }, __fixunsdfsi, .{arg});
12		}
13
14		test {
15		_ = @import("fixunsdfsi_test.zig");
16		}

lib/std/special/compiler_rt/fixunsdfsi_test.zig deleted-39

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

lib/std/special/compiler_rt/fixunsdfti.zig deleted-11

...	...	@@ -1,11 +0,0 @@
1		const fixuint = @import("fixuint.zig").fixuint;
2		const builtin = @import("builtin");
3
4		pub fn __fixunsdfti(a: f64) callconv(.C) u128 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixuint(f64, u128, a);
7		}
8
9		test {
10		_ = @import("fixunsdfti_test.zig");
11		}

lib/std/special/compiler_rt/fixunsdfti_test.zig deleted-46

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

lib/std/special/compiler_rt/fixunssfdi.zig deleted-16

...	...	@@ -1,16 +0,0 @@
1		const fixuint = @import("fixuint.zig").fixuint;
2		const builtin = @import("builtin");
3
4		pub fn __fixunssfdi(a: f32) callconv(.C) u64 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixuint(f32, u64, a);
7		}
8
9		pub fn __aeabi_f2ulz(a: f32) callconv(.AAPCS) u64 {
10		@setRuntimeSafety(false);
11		return @call(.{ .modifier = .always_inline }, __fixunssfdi, .{a});
12		}
13
14		test {
15		_ = @import("fixunssfdi_test.zig");
16		}

lib/std/special/compiler_rt/fixunssfdi_test.zig deleted-35

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

lib/std/special/compiler_rt/fixunssfsi.zig deleted-16

...	...	@@ -1,16 +0,0 @@
1		const fixuint = @import("fixuint.zig").fixuint;
2		const builtin = @import("builtin");
3
4		pub fn __fixunssfsi(a: f32) callconv(.C) u32 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixuint(f32, u32, a);
7		}
8
9		pub fn __aeabi_f2uiz(a: f32) callconv(.AAPCS) u32 {
10		@setRuntimeSafety(false);
11		return @call(.{ .modifier = .always_inline }, __fixunssfsi, .{a});
12		}
13
14		test {
15		_ = @import("fixunssfsi_test.zig");
16		}

lib/std/special/compiler_rt/fixunssfsi_test.zig deleted-36

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

lib/std/special/compiler_rt/fixunssfti.zig deleted-11

...	...	@@ -1,11 +0,0 @@
1		const fixuint = @import("fixuint.zig").fixuint;
2		const builtin = @import("builtin");
3
4		pub fn __fixunssfti(a: f32) callconv(.C) u128 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixuint(f32, u128, a);
7		}
8
9		test {
10		_ = @import("fixunssfti_test.zig");
11		}

lib/std/special/compiler_rt/fixunssfti_test.zig deleted-41

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

lib/std/special/compiler_rt/fixunstfdi.zig deleted-11

...	...	@@ -1,11 +0,0 @@
1		const fixuint = @import("fixuint.zig").fixuint;
2		const builtin = @import("builtin");
3
4		pub fn __fixunstfdi(a: f128) callconv(.C) u64 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixuint(f128, u64, a);
7		}
8
9		test {
10		_ = @import("fixunstfdi_test.zig");
11		}

lib/std/special/compiler_rt/fixunstfdi_test.zig deleted-49

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

lib/std/special/compiler_rt/fixunstfsi.zig deleted-11

...	...	@@ -1,11 +0,0 @@
1		const fixuint = @import("fixuint.zig").fixuint;
2		const builtin = @import("builtin");
3
4		pub fn __fixunstfsi(a: f128) callconv(.C) u32 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixuint(f128, u32, a);
7		}
8
9		test {
10		_ = @import("fixunstfsi_test.zig");
11		}

lib/std/special/compiler_rt/fixunstfsi_test.zig deleted-22

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

lib/std/special/compiler_rt/fixunstfti.zig deleted-11

...	...	@@ -1,11 +0,0 @@
1		const fixuint = @import("fixuint.zig").fixuint;
2		const builtin = @import("builtin");
3
4		pub fn __fixunstfti(a: f128) callconv(.C) u128 {
5		@setRuntimeSafety(builtin.is_test);
6		return fixuint(f128, u128, a);
7		}
8
9		test {
10		_ = @import("fixunstfti_test.zig");
11		}

lib/std/special/compiler_rt/fixunstfti_test.zig deleted-32

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

lib/std/special/compiler_rt/floatXiYf.zig created+222

...	...	@@ -0,0 +1,222 @@
	1	const builtin = @import("builtin");
	2	const is_test = builtin.is_test;
	3	const std = @import("std");
	4	const math = std.math;
	5	const expect = std.testing.expect;
	6
	7	pub fn floatXiYf(comptime T: type, x: anytype) T {
	8	@setRuntimeSafety(is_test);
	9
	10	if (x == 0) return 0;
	11
	12	// Various constants whose values follow from the type parameters.
	13	// Any reasonable optimizer will fold and propagate all of these.
	14	const Z = std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(x)));
	15	const uT = std.meta.Int(.unsigned, @bitSizeOf(T));
	16	const inf = math.inf(T);
	17	const float_bits = @bitSizeOf(T);
	18	const int_bits = @bitSizeOf(@TypeOf(x));
	19	const exp_bits = math.floatExponentBits(T);
	20	const fractional_bits = math.floatFractionalBits(T);
	21	const exp_bias = math.maxInt(std.meta.Int(.unsigned, exp_bits - 1));
	22	const implicit_bit = if (T != f80) @as(uT, 1) << fractional_bits else 0;
	23	const max_exp = exp_bias;
	24
	25	// Sign
	26	var abs_val = math.absCast(x);
	27	const sign_bit = if (x < 0) @as(uT, 1) << (float_bits - 1) else 0;
	28	var result: uT = sign_bit;
	29
	30	// Compute significand
	31	var exp = int_bits - @clz(Z, abs_val) - 1;
	32	if (int_bits <= fractional_bits or exp <= fractional_bits) {
	33	const shift_amt = fractional_bits - @intCast(math.Log2Int(uT), exp);
	34
	35	// Shift up result to line up with the significand - no rounding required
	36	result = (@intCast(uT, abs_val) << shift_amt);
	37	result ^= implicit_bit; // Remove implicit integer bit
	38	} else {
	39	var shift_amt = @intCast(math.Log2Int(Z), exp - fractional_bits);
	40	const exact_tie: bool = @ctz(Z, abs_val) == shift_amt - 1;
	41
	42	// Shift down result and remove implicit integer bit
	43	result = @intCast(uT, (abs_val >> (shift_amt - 1))) ^ (implicit_bit << 1);
	44
	45	// Round result, including round-to-even for exact ties
	46	result = ((result + 1) >> 1) & ~@as(uT, @boolToInt(exact_tie));
	47	}
	48
	49	// Compute exponent
	50	if ((int_bits > max_exp) and (exp > max_exp)) // If exponent too large, overflow to infinity
	51	return @bitCast(T, sign_bit \| @bitCast(uT, inf));
	52
	53	result += (@as(uT, exp) + exp_bias) << math.floatMantissaBits(T);
	54
	55	// If the result included a carry, we need to restore the explicit integer bit
	56	if (T == f80) result \|= 1 << fractional_bits;
	57
	58	return @bitCast(T, sign_bit \| result);
	59	}
	60
	61	// Conversion to f16
	62	pub fn __floatsihf(a: i32) callconv(.C) f16 {
	63	return floatXiYf(f16, a);
	64	}
	65
	66	pub fn __floatunsihf(a: u32) callconv(.C) f16 {
	67	return floatXiYf(f16, a);
	68	}
	69
	70	pub fn __floatdihf(a: i64) callconv(.C) f16 {
	71	return floatXiYf(f16, a);
	72	}
	73
	74	pub fn __floatundihf(a: u64) callconv(.C) f16 {
	75	return floatXiYf(f16, a);
	76	}
	77
	78	pub fn __floattihf(a: i128) callconv(.C) f16 {
	79	return floatXiYf(f16, a);
	80	}
	81
	82	pub fn __floatuntihf(a: u128) callconv(.C) f16 {
	83	return floatXiYf(f16, a);
	84	}
	85
	86	// Conversion to f32
	87	pub fn __floatsisf(a: i32) callconv(.C) f32 {
	88	return floatXiYf(f32, a);
	89	}
	90
	91	pub fn __floatunsisf(a: u32) callconv(.C) f32 {
	92	return floatXiYf(f32, a);
	93	}
	94
	95	pub fn __floatdisf(a: i64) callconv(.C) f32 {
	96	return floatXiYf(f32, a);
	97	}
	98
	99	pub fn __floatundisf(a: u64) callconv(.C) f32 {
	100	return floatXiYf(f32, a);
	101	}
	102
	103	pub fn __floattisf(a: i128) callconv(.C) f32 {
	104	return floatXiYf(f32, a);
	105	}
	106
	107	pub fn __floatuntisf(a: u128) callconv(.C) f32 {
	108	return floatXiYf(f32, a);
	109	}
	110
	111	// Conversion to f64
	112	pub fn __floatsidf(a: i32) callconv(.C) f64 {
	113	return floatXiYf(f64, a);
	114	}
	115
	116	pub fn __floatunsidf(a: u32) callconv(.C) f64 {
	117	return floatXiYf(f64, a);
	118	}
	119
	120	pub fn __floatdidf(a: i64) callconv(.C) f64 {
	121	return floatXiYf(f64, a);
	122	}
	123
	124	pub fn __floatundidf(a: u64) callconv(.C) f64 {
	125	return floatXiYf(f64, a);
	126	}
	127
	128	pub fn __floattidf(a: i128) callconv(.C) f64 {
	129	return floatXiYf(f64, a);
	130	}
	131
	132	pub fn __floatuntidf(a: u128) callconv(.C) f64 {
	133	return floatXiYf(f64, a);
	134	}
	135
	136	// Conversion to f80
	137	pub fn __floatsixf(a: i32) callconv(.C) f80 {
	138	return floatXiYf(f80, a);
	139	}
	140
	141	pub fn __floatunsixf(a: u32) callconv(.C) f80 {
	142	return floatXiYf(f80, a);
	143	}
	144
	145	pub fn __floatdixf(a: i64) callconv(.C) f80 {
	146	return floatXiYf(f80, a);
	147	}
	148
	149	pub fn __floatundixf(a: u64) callconv(.C) f80 {
	150	return floatXiYf(f80, a);
	151	}
	152
	153	pub fn __floattixf(a: i128) callconv(.C) f80 {
	154	return floatXiYf(f80, a);
	155	}
	156
	157	pub fn __floatuntixf(a: u128) callconv(.C) f80 {
	158	return floatXiYf(f80, a);
	159	}
	160
	161	// Conversion to f128
	162	pub fn __floatsitf(a: i32) callconv(.C) f128 {
	163	return floatXiYf(f128, a);
	164	}
	165
	166	pub fn __floatunsitf(a: u32) callconv(.C) f128 {
	167	return floatXiYf(f128, a);
	168	}
	169
	170	pub fn __floatditf(a: i64) callconv(.C) f128 {
	171	return floatXiYf(f128, a);
	172	}
	173
	174	pub fn __floatunditf(a: u64) callconv(.C) f128 {
	175	return floatXiYf(f128, a);
	176	}
	177
	178	pub fn __floattitf(a: i128) callconv(.C) f128 {
	179	return floatXiYf(f128, a);
	180	}
	181
	182	pub fn __floatuntitf(a: u128) callconv(.C) f128 {
	183	return floatXiYf(f128, a);
	184	}
	185
	186	// Conversion to f32
	187	pub fn __aeabi_ui2f(arg: u32) callconv(.AAPCS) f32 {
	188	return floatXiYf(f32, arg);
	189	}
	190
	191	pub fn __aeabi_i2f(arg: i32) callconv(.AAPCS) f32 {
	192	return floatXiYf(f32, arg);
	193	}
	194
	195	pub fn __aeabi_ul2f(arg: u64) callconv(.AAPCS) f32 {
	196	return floatXiYf(f32, arg);
	197	}
	198
	199	pub fn __aeabi_l2f(arg: i64) callconv(.AAPCS) f32 {
	200	return floatXiYf(f32, arg);
	201	}
	202
	203	// Conversion to f64
	204	pub fn __aeabi_ui2d(arg: u32) callconv(.AAPCS) f64 {
	205	return floatXiYf(f64, arg);
	206	}
	207
	208	pub fn __aeabi_i2d(arg: i32) callconv(.AAPCS) f64 {
	209	return floatXiYf(f64, arg);
	210	}
	211
	212	pub fn __aeabi_ul2d(arg: u64) callconv(.AAPCS) f64 {
	213	return floatXiYf(f64, arg);
	214	}
	215
	216	pub fn __aeabi_l2d(arg: i64) callconv(.AAPCS) f64 {
	217	return floatXiYf(f64, arg);
	218	}
	219
	220	test {
	221	_ = @import("floatXiYf_test.zig");
	222	}

lib/std/special/compiler_rt/floatXiYf_test.zig created+835

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

lib/std/special/compiler_rt/floatXisf.zig deleted-90

...	...	@@ -1,90 +0,0 @@
1		const builtin = @import("builtin");
2		const std = @import("std");
3		const maxInt = std.math.maxInt;
4
5		const FLT_MANT_DIG = 24;
6
7		inline fn floatXisf(comptime T: type, arg: T) f32 {
8		@setRuntimeSafety(builtin.is_test);
9
10		const bits = @typeInfo(T).Int.bits;
11		const Z = std.meta.Int(.unsigned, bits);
12		const S = std.meta.Int(.unsigned, bits - @clz(Z, @as(Z, bits) - 1));
13
14		if (arg == 0) {
15		return @as(f32, 0.0);
16		}
17
18		var ai = arg;
19		const N: u32 = bits;
20		const si = ai >> @intCast(S, (N - 1));
21		ai = ((ai ^ si) -% si);
22		var a = @bitCast(Z, ai);
23
24		const sd = @bitCast(i32, N - @clz(Z, a)); // number of significant digits
25		var e: i32 = sd - 1; // exponent
26
27		if (sd > FLT_MANT_DIG) {
28		// start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
29		// finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
30		// 12345678901234567890123456
31		// 1 = msb 1 bit
32		// P = bit FLT_MANT_DIG-1 bits to the right of 1
33		// Q = bit FLT_MANT_DIG bits to the right of 1
34		// R = "or" of all bits to the right of Q
35		switch (sd) {
36		FLT_MANT_DIG + 1 => {
37		a <<= 1;
38		},
39		FLT_MANT_DIG + 2 => {},
40		else => {
41		const shift1_amt = @intCast(i32, sd - (FLT_MANT_DIG + 2));
42		const shift1_amt_u7 = @intCast(S, shift1_amt);
43
44		const shift2_amt = @intCast(i32, N + (FLT_MANT_DIG + 2)) - sd;
45		const shift2_amt_u7 = @intCast(S, shift2_amt);
46
47		a = (a >> shift1_amt_u7) \| @boolToInt((a & (@intCast(Z, maxInt(Z)) >> shift2_amt_u7)) != 0);
48		},
49		}
50		// finish
51		a \|= @boolToInt((a & 4) != 0); // Or P into R
52		a += 1; // round - this step may add a significant bit
53		a >>= 2; // dump Q and R
54		// a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits
55		if ((a & (@as(Z, 1) << FLT_MANT_DIG)) != 0) {
56		a >>= 1;
57		e += 1;
58		}
59		// a is now rounded to FLT_MANT_DIG bits
60		} else {
61		a <<= @intCast(S, FLT_MANT_DIG - sd);
62		// a is now rounded to FLT_MANT_DIG bits
63		}
64
65		const s = @bitCast(Z, arg) >> (@typeInfo(T).Int.bits - 32);
66		const r = (@intCast(u32, s) & 0x80000000) \| // sign
67		(@intCast(u32, (e + 127)) << 23) \| // exponent
68		(@truncate(u32, a) & 0x007fffff); // mantissa-high
69
70		return @bitCast(f32, r);
71		}
72
73		pub fn __floatdisf(arg: i64) callconv(.C) f32 {
74		return floatXisf(i64, arg);
75		}
76
77		pub fn __floattisf(arg: i128) callconv(.C) f32 {
78		return floatXisf(i128, arg);
79		}
80
81		pub fn __aeabi_l2f(arg: i64) callconv(.AAPCS) f32 {
82		return floatXisf(i64, arg);
83		}
84
85		test {
86		_ = @import("floattisf_test.zig");
87		}
88		test {
89		_ = @import("floattisf_test.zig");
90		}

lib/std/special/compiler_rt/floatdidf.zig deleted-27

...	...	@@ -1,27 +0,0 @@
1		const builtin = @import("builtin");
2		const std = @import("std");
3
4		const twop52: f64 = 0x1.0p52;
5		const twop32: f64 = 0x1.0p32;
6
7		pub fn __floatdidf(a: i64) callconv(.C) f64 {
8		@setRuntimeSafety(builtin.is_test);
9
10		if (a == 0) return 0;
11
12		var low = @bitCast(i64, twop52);
13		const high = @intToFloat(f64, @truncate(i32, a >> 32)) * twop32;
14
15		low \|= @bitCast(i64, a & 0xFFFFFFFF);
16
17		return (high - twop52) + @bitCast(f64, low);
18		}
19
20		pub fn __aeabi_l2d(arg: i64) callconv(.AAPCS) f64 {
21		@setRuntimeSafety(false);
22		return @call(.{ .modifier = .always_inline }, __floatdidf, .{arg});
23		}
24
25		test {
26		_ = @import("floatdidf_test.zig");
27		}

lib/std/special/compiler_rt/floatdidf_test.zig deleted-53

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

lib/std/special/compiler_rt/floatdisf_test.zig deleted-32

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

lib/std/special/compiler_rt/floatditf.zig deleted-38

...	...	@@ -1,38 +0,0 @@
1		const builtin = @import("builtin");
2		const is_test = builtin.is_test;
3		const std = @import("std");
4		const maxInt = std.math.maxInt;
5
6		const significandBits = 112;
7		const exponentBias = 16383;
8		const implicitBit = (@as(u128, 1) << significandBits);
9
10		pub fn __floatditf(arg: i64) callconv(.C) f128 {
11		@setRuntimeSafety(is_test);
12
13		if (arg == 0)
14		return 0.0;
15
16		// All other cases begin by extracting the sign and absolute value of a
17		var sign: u128 = 0;
18		var aAbs = @bitCast(u64, arg);
19		if (arg < 0) {
20		sign = 1 << 127;
21		aAbs = ~@bitCast(u64, arg) + 1;
22		}
23
24		// Exponent of (fp_t)a is the width of abs(a).
25		const exponent = 63 - @clz(u64, aAbs);
26		var result: u128 = undefined;
27
28		// Shift a into the significand field, rounding if it is a right-shift
29		const shift = significandBits - exponent;
30		result = @as(u128, aAbs) << shift ^ implicitBit;
31
32		result += (@as(u128, exponent) + exponentBias) << significandBits;
33		return @bitCast(f128, result \| sign);
34		}
35
36		test {
37		_ = @import("floatditf_test.zig");
38		}

lib/std/special/compiler_rt/floatditf_test.zig deleted-26

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

lib/std/special/compiler_rt/floatfmodl.zig deleted-126

...	...	@@ -1,126 +0,0 @@
1		const builtin = @import("builtin");
2		const std = @import("std");
3
4		// fmodl - floating modulo large, returns the remainder of division for f128 types
5		// Logic and flow heavily inspired by MUSL fmodl for 113 mantissa digits
6		pub fn fmodl(a: f128, b: f128) callconv(.C) f128 {
7		@setRuntimeSafety(builtin.is_test);
8		var amod = a;
9		var bmod = b;
10		const aPtr_u64 = @ptrCast([*]u64, &amod);
11		const bPtr_u64 = @ptrCast([*]u64, &bmod);
12		const aPtr_u16 = @ptrCast([*]u16, &amod);
13		const bPtr_u16 = @ptrCast([*]u16, &bmod);
14
15		const exp_and_sign_index = comptime switch (builtin.target.cpu.arch.endian()) {
16		.Little => 7,
17		.Big => 0,
18		};
19		const low_index = comptime switch (builtin.target.cpu.arch.endian()) {
20		.Little => 0,
21		.Big => 1,
22		};
23		const high_index = comptime switch (builtin.target.cpu.arch.endian()) {
24		.Little => 1,
25		.Big => 0,
26		};
27
28		const signA = aPtr_u16[exp_and_sign_index] & 0x8000;
29		var expA = @intCast(i32, (aPtr_u16[exp_and_sign_index] & 0x7fff));
30		var expB = bPtr_u16[exp_and_sign_index] & 0x7fff;
31
32		// There are 3 cases where the answer is undefined, check for:
33		// - fmodl(val, 0)
34		// - fmodl(val, NaN)
35		// - fmodl(inf, val)
36		// The sign on checked values does not matter.
37		// Doing (a * b) / (a * b) procudes undefined results
38		// because the three cases always produce undefined calculations:
39		// - 0 / 0
40		// - val * NaN
41		// - inf / inf
42		if (b == 0 or std.math.isNan(b) or expA == 0x7fff) {
43		return (a * b) / (a * b);
44		}
45
46		// Remove the sign from both
47		aPtr_u16[exp_and_sign_index] = @bitCast(u16, @intCast(i16, expA));
48		bPtr_u16[exp_and_sign_index] = @bitCast(u16, @intCast(i16, expB));
49		if (amod <= bmod) {
50		if (amod == bmod) {
51		return 0 * a;
52		}
53		return a;
54		}
55
56		if (expA == 0) {
57		amod *= 0x1p120;
58		expA = aPtr_u16[exp_and_sign_index] -% 120;
59		}
60
61		if (expB == 0) {
62		bmod *= 0x1p120;
63		expB = bPtr_u16[exp_and_sign_index] -% 120;
64		}
65
66		// OR in extra non-stored mantissa digit
67		var highA: u64 = (aPtr_u64[high_index] & (std.math.maxInt(u64) >> 16)) \| 1 << 48;
68		var highB: u64 = (bPtr_u64[high_index] & (std.math.maxInt(u64) >> 16)) \| 1 << 48;
69		var lowA: u64 = aPtr_u64[low_index];
70		var lowB: u64 = bPtr_u64[low_index];
71
72		while (expA > expB) : (expA -= 1) {
73		var high = highA -% highB;
74		var low = lowA -% lowB;
75		if (lowA < lowB) {
76		high = highA -% 1;
77		}
78		if (high >> 63 == 0) {
79		if ((high \| low) == 0) {
80		return 0 * a;
81		}
82		highA = 2 *% high + (low >> 63);
83		lowA = 2 *% low;
84		} else {
85		highA = 2 *% highA + (lowA >> 63);
86		lowA = 2 *% lowA;
87		}
88		}
89
90		var high = highA -% highB;
91		var low = lowA -% lowB;
92		if (lowA < lowB) {
93		high -= 1;
94		}
95		if (high >> 63 == 0) {
96		if ((high \| low) == 0) {
97		return 0 * a;
98		}
99		highA = high;
100		lowA = low;
101		}
102
103		while (highA >> 48 == 0) {
104		highA = 2 *% highA + (lowA >> 63);
105		lowA = 2 *% lowA;
106		expA = expA - 1;
107		}
108
109		// Overwrite the current amod with the values in highA and lowA
110		aPtr_u64[high_index] = highA;
111		aPtr_u64[low_index] = lowA;
112
113		// Combine the exponent with the sign, normalize if happend to be denormalized
114		if (expA <= 0) {
115		aPtr_u16[exp_and_sign_index] = @truncate(u16, @bitCast(u32, (expA +% 120))) \| signA;
116		amod *= 0x1p-120;
117		} else {
118		aPtr_u16[exp_and_sign_index] = @truncate(u16, @bitCast(u32, expA)) \| signA;
119		}
120
121		return amod;
122		}
123
124		test {
125		_ = @import("floatfmodl_test.zig");
126		}

lib/std/special/compiler_rt/floatfmodl_test.zig deleted-46

...	...	@@ -1,46 +0,0 @@
1		const std = @import("std");
2		const fmodl = @import("floatfmodl.zig");
3		const testing = std.testing;
4
5		fn test_fmodl(a: f128, b: f128, exp: f128) !void {
6		const res = fmodl.fmodl(a, b);
7		try testing.expect(exp == res);
8		}
9
10		fn test_fmodl_nans() !void {
11		try testing.expect(std.math.isNan(fmodl.fmodl(1.0, std.math.nan_f128)));
12		try testing.expect(std.math.isNan(fmodl.fmodl(1.0, -std.math.nan_f128)));
13		try testing.expect(std.math.isNan(fmodl.fmodl(std.math.nan_f128, 1.0)));
14		try testing.expect(std.math.isNan(fmodl.fmodl(-std.math.nan_f128, 1.0)));
15		}
16
17		fn test_fmodl_infs() !void {
18		try testing.expect(fmodl.fmodl(1.0, std.math.inf(f128)) == 1.0);
19		try testing.expect(fmodl.fmodl(1.0, -std.math.inf(f128)) == 1.0);
20		try testing.expect(std.math.isNan(fmodl.fmodl(std.math.inf(f128), 1.0)));
21		try testing.expect(std.math.isNan(fmodl.fmodl(-std.math.inf(f128), 1.0)));
22		}
23
24		test "fmodl" {
25		try test_fmodl(6.8, 4.0, 2.8);
26		try test_fmodl(6.8, -4.0, 2.8);
27		try test_fmodl(-6.8, 4.0, -2.8);
28		try test_fmodl(-6.8, -4.0, -2.8);
29		try test_fmodl(3.0, 2.0, 1.0);
30		try test_fmodl(-5.0, 3.0, -2.0);
31		try test_fmodl(3.0, 2.0, 1.0);
32		try test_fmodl(1.0, 2.0, 1.0);
33		try test_fmodl(0.0, 1.0, 0.0);
34		try test_fmodl(-0.0, 1.0, -0.0);
35		try test_fmodl(7046119.0, 5558362.0, 1487757.0);
36		try test_fmodl(9010357.0, 1957236.0, 1181413.0);
37
38		// Denormals
39		const a: f128 = 0xedcb34a235253948765432134674p-16494;
40		const b: f128 = 0x5d2e38791cfbc0737402da5a9518p-16494;
41		const exp: f128 = 0x336ec3affb2db8618e4e7d5e1c44p-16494;
42		try test_fmodl(a, b, exp);
43
44		try test_fmodl_nans();
45		try test_fmodl_infs();
46		}

lib/std/special/compiler_rt/floatfmodq.zig created+126

...	...	@@ -0,0 +1,126 @@
	1	const builtin = @import("builtin");
	2	const std = @import("std");
	3
	4	// fmodq - floating modulo large, returns the remainder of division for f128 types
	5	// Logic and flow heavily inspired by MUSL fmodl for 113 mantissa digits
	6	pub fn fmodq(a: f128, b: f128) callconv(.C) f128 {
	7	@setRuntimeSafety(builtin.is_test);
	8	var amod = a;
	9	var bmod = b;
	10	const aPtr_u64 = @ptrCast([*]u64, &amod);
	11	const bPtr_u64 = @ptrCast([*]u64, &bmod);
	12	const aPtr_u16 = @ptrCast([*]u16, &amod);
	13	const bPtr_u16 = @ptrCast([*]u16, &bmod);
	14
	15	const exp_and_sign_index = comptime switch (builtin.target.cpu.arch.endian()) {
	16	.Little => 7,
	17	.Big => 0,
	18	};
	19	const low_index = comptime switch (builtin.target.cpu.arch.endian()) {
	20	.Little => 0,
	21	.Big => 1,
	22	};
	23	const high_index = comptime switch (builtin.target.cpu.arch.endian()) {
	24	.Little => 1,
	25	.Big => 0,
	26	};
	27
	28	const signA = aPtr_u16[exp_and_sign_index] & 0x8000;
	29	var expA = @intCast(i32, (aPtr_u16[exp_and_sign_index] & 0x7fff));
	30	var expB = bPtr_u16[exp_and_sign_index] & 0x7fff;
	31
	32	// There are 3 cases where the answer is undefined, check for:
	33	// - fmodq(val, 0)
	34	// - fmodq(val, NaN)
	35	// - fmodq(inf, val)
	36	// The sign on checked values does not matter.
	37	// Doing (a * b) / (a * b) procudes undefined results
	38	// because the three cases always produce undefined calculations:
	39	// - 0 / 0
	40	// - val * NaN
	41	// - inf / inf
	42	if (b == 0 or std.math.isNan(b) or expA == 0x7fff) {
	43	return (a * b) / (a * b);
	44	}
	45
	46	// Remove the sign from both
	47	aPtr_u16[exp_and_sign_index] = @bitCast(u16, @intCast(i16, expA));
	48	bPtr_u16[exp_and_sign_index] = @bitCast(u16, @intCast(i16, expB));
	49	if (amod <= bmod) {
	50	if (amod == bmod) {
	51	return 0 * a;
	52	}
	53	return a;
	54	}
	55
	56	if (expA == 0) {
	57	amod *= 0x1p120;
	58	expA = aPtr_u16[exp_and_sign_index] -% 120;
	59	}
	60
	61	if (expB == 0) {
	62	bmod *= 0x1p120;
	63	expB = bPtr_u16[exp_and_sign_index] -% 120;
	64	}
	65
	66	// OR in extra non-stored mantissa digit
	67	var highA: u64 = (aPtr_u64[high_index] & (std.math.maxInt(u64) >> 16)) \| 1 << 48;
	68	var highB: u64 = (bPtr_u64[high_index] & (std.math.maxInt(u64) >> 16)) \| 1 << 48;
	69	var lowA: u64 = aPtr_u64[low_index];
	70	var lowB: u64 = bPtr_u64[low_index];
	71
	72	while (expA > expB) : (expA -= 1) {
	73	var high = highA -% highB;
	74	var low = lowA -% lowB;
	75	if (lowA < lowB) {
	76	high = highA -% 1;
	77	}
	78	if (high >> 63 == 0) {
	79	if ((high \| low) == 0) {
	80	return 0 * a;
	81	}
	82	highA = 2 *% high + (low >> 63);
	83	lowA = 2 *% low;
	84	} else {
	85	highA = 2 *% highA + (lowA >> 63);
	86	lowA = 2 *% lowA;
	87	}
	88	}
	89
	90	var high = highA -% highB;
	91	var low = lowA -% lowB;
	92	if (lowA < lowB) {
	93	high -= 1;
	94	}
	95	if (high >> 63 == 0) {
	96	if ((high \| low) == 0) {
	97	return 0 * a;
	98	}
	99	highA = high;
	100	lowA = low;
	101	}
	102
	103	while (highA >> 48 == 0) {
	104	highA = 2 *% highA + (lowA >> 63);
	105	lowA = 2 *% lowA;
	106	expA = expA - 1;
	107	}
	108
	109	// Overwrite the current amod with the values in highA and lowA
	110	aPtr_u64[high_index] = highA;
	111	aPtr_u64[low_index] = lowA;
	112
	113	// Combine the exponent with the sign, normalize if happend to be denormalized
	114	if (expA <= 0) {
	115	aPtr_u16[exp_and_sign_index] = @truncate(u16, @bitCast(u32, (expA +% 120))) \| signA;
	116	amod *= 0x1p-120;
	117	} else {
	118	aPtr_u16[exp_and_sign_index] = @truncate(u16, @bitCast(u32, expA)) \| signA;
	119	}
	120
	121	return amod;
	122	}
	123
	124	test {
	125	_ = @import("floatfmodq_test.zig");
	126	}

lib/std/special/compiler_rt/floatfmodq_test.zig created+46

...	...	@@ -0,0 +1,46 @@
	1	const std = @import("std");
	2	const fmodq = @import("floatfmodq.zig");
	3	const testing = std.testing;
	4
	5	fn test_fmodq(a: f128, b: f128, exp: f128) !void {
	6	const res = fmodq.fmodq(a, b);
	7	try testing.expect(exp == res);
	8	}
	9
	10	fn test_fmodq_nans() !void {
	11	try testing.expect(std.math.isNan(fmodq.fmodq(1.0, std.math.nan(f128))));
	12	try testing.expect(std.math.isNan(fmodq.fmodq(1.0, -std.math.nan(f128))));
	13	try testing.expect(std.math.isNan(fmodq.fmodq(std.math.nan(f128), 1.0)));
	14	try testing.expect(std.math.isNan(fmodq.fmodq(-std.math.nan(f128), 1.0)));
	15	}
	16
	17	fn test_fmodq_infs() !void {
	18	try testing.expect(fmodq.fmodq(1.0, std.math.inf(f128)) == 1.0);
	19	try testing.expect(fmodq.fmodq(1.0, -std.math.inf(f128)) == 1.0);
	20	try testing.expect(std.math.isNan(fmodq.fmodq(std.math.inf(f128), 1.0)));
	21	try testing.expect(std.math.isNan(fmodq.fmodq(-std.math.inf(f128), 1.0)));
	22	}
	23
	24	test "fmodq" {
	25	try test_fmodq(6.8, 4.0, 2.8);
	26	try test_fmodq(6.8, -4.0, 2.8);
	27	try test_fmodq(-6.8, 4.0, -2.8);
	28	try test_fmodq(-6.8, -4.0, -2.8);
	29	try test_fmodq(3.0, 2.0, 1.0);
	30	try test_fmodq(-5.0, 3.0, -2.0);
	31	try test_fmodq(3.0, 2.0, 1.0);
	32	try test_fmodq(1.0, 2.0, 1.0);
	33	try test_fmodq(0.0, 1.0, 0.0);
	34	try test_fmodq(-0.0, 1.0, -0.0);
	35	try test_fmodq(7046119.0, 5558362.0, 1487757.0);
	36	try test_fmodq(9010357.0, 1957236.0, 1181413.0);
	37
	38	// Denormals
	39	const a: f128 = 0xedcb34a235253948765432134674p-16494;
	40	const b: f128 = 0x5d2e38791cfbc0737402da5a9518p-16494;
	41	const exp: f128 = 0x336ec3affb2db8618e4e7d5e1c44p-16494;
	42	try test_fmodq(a, b, exp);
	43
	44	try test_fmodq_nans();
	45	try test_fmodq_infs();
	46	}

lib/std/special/compiler_rt/floatsiXf.zig deleted-120

...	...	@@ -1,120 +0,0 @@
1		const builtin = @import("builtin");
2		const std = @import("std");
3		const maxInt = std.math.maxInt;
4
5		inline fn floatsiXf(comptime T: type, a: i32) T {
6		@setRuntimeSafety(builtin.is_test);
7
8		const bits = @typeInfo(T).Float.bits;
9		const Z = std.meta.Int(.unsigned, bits);
10		const S = std.meta.Int(.unsigned, bits - @clz(Z, @as(Z, bits) - 1));
11
12		if (a == 0) {
13		return @as(T, 0.0);
14		}
15
16		const significandBits = std.math.floatMantissaBits(T);
17		const exponentBits = std.math.floatExponentBits(T);
18		const exponentBias = ((1 << exponentBits - 1) - 1);
19
20		const implicitBit = @as(Z, 1) << significandBits;
21		const signBit = @as(Z, 1 << bits - 1);
22
23		const sign = a >> 31;
24		// Take absolute value of a via abs(x) = (x^(x >> 31)) - (x >> 31).
25		const abs_a = (a ^ sign) -% sign;
26		// The exponent is the width of abs(a)
27		const exp = @as(Z, 31 - @clz(i32, abs_a));
28
29		const sign_bit = if (sign < 0) signBit else 0;
30
31		var mantissa: Z = undefined;
32		// Shift a into the significand field and clear the implicit bit.
33		if (exp <= significandBits) {
34		// No rounding needed
35		const shift = @intCast(S, significandBits - exp);
36		mantissa = @intCast(Z, @bitCast(u32, abs_a)) << shift ^ implicitBit;
37		} else {
38		const shift = @intCast(S, exp - significandBits);
39		// Round to the nearest number after truncation
40		mantissa = @intCast(Z, @bitCast(u32, abs_a)) >> shift ^ implicitBit;
41		// Align to the left and check if the truncated part is halfway over
42		const round = @bitCast(u32, abs_a) << @intCast(u5, 31 - shift);
43		mantissa += @boolToInt(round > 0x80000000);
44		// Tie to even
45		mantissa += mantissa & 1;
46		}
47
48		// Use the addition instead of a or since we may have a carry from the
49		// mantissa to the exponent
50		var result = mantissa;
51		result += (exp + exponentBias) << significandBits;
52		result += sign_bit;
53
54		return @bitCast(T, result);
55		}
56
57		pub fn __floatsisf(arg: i32) callconv(.C) f32 {
58		@setRuntimeSafety(builtin.is_test);
59		return floatsiXf(f32, arg);
60		}
61
62		pub fn __floatsidf(arg: i32) callconv(.C) f64 {
63		@setRuntimeSafety(builtin.is_test);
64		return floatsiXf(f64, arg);
65		}
66
67		pub fn __floatsitf(arg: i32) callconv(.C) f128 {
68		@setRuntimeSafety(builtin.is_test);
69		return floatsiXf(f128, arg);
70		}
71
72		pub fn __aeabi_i2d(arg: i32) callconv(.AAPCS) f64 {
73		@setRuntimeSafety(false);
74		return floatsiXf(f64, arg);
75		}
76
77		pub fn __aeabi_i2f(arg: i32) callconv(.AAPCS) f32 {
78		@setRuntimeSafety(false);
79		return floatsiXf(f32, arg);
80		}
81
82		fn test_one_floatsitf(a: i32, expected: u128) !void {
83		const r = __floatsitf(a);
84		try std.testing.expect(@bitCast(u128, r) == expected);
85		}
86
87		fn test_one_floatsidf(a: i32, expected: u64) !void {
88		const r = __floatsidf(a);
89		try std.testing.expect(@bitCast(u64, r) == expected);
90		}
91
92		fn test_one_floatsisf(a: i32, expected: u32) !void {
93		const r = __floatsisf(a);
94		try std.testing.expect(@bitCast(u32, r) == expected);
95		}
96
97		test "floatsidf" {
98		try test_one_floatsidf(0, 0x0000000000000000);
99		try test_one_floatsidf(1, 0x3ff0000000000000);
100		try test_one_floatsidf(-1, 0xbff0000000000000);
101		try test_one_floatsidf(0x7FFFFFFF, 0x41dfffffffc00000);
102		try test_one_floatsidf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc1e0000000000000);
103		}
104
105		test "floatsisf" {
106		try test_one_floatsisf(0, 0x00000000);
107		try test_one_floatsisf(1, 0x3f800000);
108		try test_one_floatsisf(-1, 0xbf800000);
109		try test_one_floatsisf(0x7FFFFFFF, 0x4f000000);
110		try test_one_floatsisf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xcf000000);
111		}
112
113		test "floatsitf" {
114		try test_one_floatsitf(0, 0);
115		try test_one_floatsitf(0x7FFFFFFF, 0x401dfffffffc00000000000000000000);
116		try test_one_floatsitf(0x12345678, 0x401b2345678000000000000000000000);
117		try test_one_floatsitf(-0x12345678, 0xc01b2345678000000000000000000000);
118		try test_one_floatsitf(@bitCast(i32, @intCast(u32, 0xffffffff)), 0xbfff0000000000000000000000000000);
119		try test_one_floatsitf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc01e0000000000000000000000000000);
120		}

lib/std/special/compiler_rt/floattidf.zig deleted-71

...	...	@@ -1,71 +0,0 @@
1		const builtin = @import("builtin");
2		const is_test = builtin.is_test;
3		const std = @import("std");
4		const maxInt = std.math.maxInt;
5
6		const DBL_MANT_DIG = 53;
7
8		pub fn __floattidf(arg: i128) callconv(.C) f64 {
9		@setRuntimeSafety(is_test);
10
11		if (arg == 0)
12		return 0.0;
13
14		var ai = arg;
15		const N: u32 = 128;
16		const si = ai >> @intCast(u7, (N - 1));
17		ai = ((ai ^ si) -% si);
18		var a = @bitCast(u128, ai);
19
20		const sd = @bitCast(i32, N - @clz(u128, a)); // number of significant digits
21		var e: i32 = sd - 1; // exponent
22		if (sd > DBL_MANT_DIG) {
23		// start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
24		// finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
25		// 12345678901234567890123456
26		// 1 = msb 1 bit
27		// P = bit DBL_MANT_DIG-1 bits to the right of 1
28		// Q = bit DBL_MANT_DIG bits to the right of 1
29		// R = "or" of all bits to the right of Q
30		switch (sd) {
31		DBL_MANT_DIG + 1 => {
32		a <<= 1;
33		},
34		DBL_MANT_DIG + 2 => {},
35		else => {
36		const shift1_amt = @intCast(i32, sd - (DBL_MANT_DIG + 2));
37		const shift1_amt_u7 = @intCast(u7, shift1_amt);
38
39		const shift2_amt = @intCast(i32, N + (DBL_MANT_DIG + 2)) - sd;
40		const shift2_amt_u7 = @intCast(u7, shift2_amt);
41
42		a = (a >> shift1_amt_u7) \| @boolToInt((a & (@intCast(u128, maxInt(u128)) >> shift2_amt_u7)) != 0);
43		},
44		}
45		// finish
46		a \|= @boolToInt((a & 4) != 0); // Or P into R
47		a += 1; // round - this step may add a significant bit
48		a >>= 2; // dump Q and R
49		// a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits
50		if ((a & (@as(u128, 1) << DBL_MANT_DIG)) != 0) {
51		a >>= 1;
52		e += 1;
53		}
54		// a is now rounded to DBL_MANT_DIG bits
55		} else {
56		a <<= @intCast(u7, DBL_MANT_DIG - sd);
57		// a is now rounded to DBL_MANT_DIG bits
58		}
59
60		const s = @bitCast(u128, arg) >> (128 - 32);
61		const high: u64 = (@intCast(u64, s) & 0x80000000) \| // sign
62		(@intCast(u32, (e + 1023)) << 20) \| // exponent
63		(@truncate(u32, a >> 32) & 0x000fffff); // mantissa-high
64		const low: u64 = @truncate(u32, a); // mantissa-low
65
66		return @bitCast(f64, low \| (high << 32));
67		}
68
69		test {
70		_ = @import("floattidf_test.zig");
71		}

lib/std/special/compiler_rt/floattidf_test.zig deleted-84

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

lib/std/special/compiler_rt/floattisf_test.zig deleted-60

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

lib/std/special/compiler_rt/floattitf.zig deleted-71

...	...	@@ -1,71 +0,0 @@
1		const builtin = @import("builtin");
2		const is_test = builtin.is_test;
3		const std = @import("std");
4		const maxInt = std.math.maxInt;
5
6		const LDBL_MANT_DIG = 113;
7
8		pub fn __floattitf(arg: i128) callconv(.C) f128 {
9		@setRuntimeSafety(is_test);
10
11		if (arg == 0)
12		return 0.0;
13
14		var ai = arg;
15		const N: u32 = 128;
16		const si = ai >> @intCast(u7, (N - 1));
17		ai = ((ai ^ si) -% si);
18		var a = @bitCast(u128, ai);
19
20		const sd = @bitCast(i32, N - @clz(u128, a)); // number of significant digits
21		var e: i32 = sd - 1; // exponent
22		if (sd > LDBL_MANT_DIG) {
23		// start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
24		// finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
25		// 12345678901234567890123456
26		// 1 = msb 1 bit
27		// P = bit LDBL_MANT_DIG-1 bits to the right of 1
28		// Q = bit LDBL_MANT_DIG bits to the right of 1
29		// R = "or" of all bits to the right of Q
30		switch (sd) {
31		LDBL_MANT_DIG + 1 => {
32		a <<= 1;
33		},
34		LDBL_MANT_DIG + 2 => {},
35		else => {
36		const shift1_amt = @intCast(i32, sd - (LDBL_MANT_DIG + 2));
37		const shift1_amt_u7 = @intCast(u7, shift1_amt);
38
39		const shift2_amt = @intCast(i32, N + (LDBL_MANT_DIG + 2)) - sd;
40		const shift2_amt_u7 = @intCast(u7, shift2_amt);
41
42		a = (a >> shift1_amt_u7) \| @boolToInt((a & (@intCast(u128, maxInt(u128)) >> shift2_amt_u7)) != 0);
43		},
44		}
45		// finish
46		a \|= @boolToInt((a & 4) != 0); // Or P into R
47		a += 1; // round - this step may add a significant bit
48		a >>= 2; // dump Q and R
49		// a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits
50		if ((a & (@as(u128, 1) << LDBL_MANT_DIG)) != 0) {
51		a >>= 1;
52		e += 1;
53		}
54		// a is now rounded to LDBL_MANT_DIG bits
55		} else {
56		a <<= @intCast(u7, LDBL_MANT_DIG - sd);
57		// a is now rounded to LDBL_MANT_DIG bits
58		}
59
60		const s = @bitCast(u128, arg) >> (128 - 64);
61		const high: u128 = (@intCast(u64, s) & 0x8000000000000000) \| // sign
62		(@intCast(u64, (e + 16383)) << 48) \| // exponent
63		(@truncate(u64, a >> 64) & 0x0000ffffffffffff); // mantissa-high
64		const low = @truncate(u64, a); // mantissa-low
65
66		return @bitCast(f128, low \| (high << 64));
67		}
68
69		test {
70		_ = @import("floattitf_test.zig");
71		}

lib/std/special/compiler_rt/floattitf_test.zig deleted-96

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

lib/std/special/compiler_rt/floatundidf.zig deleted-29

...	...	@@ -1,29 +0,0 @@
1		const builtin = @import("builtin");
2		const std = @import("std");
3
4		const twop52: f64 = 0x1.0p52;
5		const twop84: f64 = 0x1.0p84;
6		const twop84_plus_twop52: f64 = 0x1.00000001p84;
7
8		pub fn __floatundidf(a: u64) callconv(.C) f64 {
9		@setRuntimeSafety(builtin.is_test);
10
11		if (a == 0) return 0;
12
13		var high = @bitCast(u64, twop84);
14		var low = @bitCast(u64, twop52);
15
16		high \|= a >> 32;
17		low \|= a & 0xFFFFFFFF;
18
19		return (@bitCast(f64, high) - twop84_plus_twop52) + @bitCast(f64, low);
20		}
21
22		pub fn __aeabi_ul2d(arg: u64) callconv(.AAPCS) f64 {
23		@setRuntimeSafety(false);
24		return @call(.{ .modifier = .always_inline }, __floatundidf, .{arg});
25		}
26
27		test {
28		_ = @import("floatundidf_test.zig");
29		}

lib/std/special/compiler_rt/floatundidf_test.zig deleted-50

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

lib/std/special/compiler_rt/floatundisf.zig deleted-94

...	...	@@ -1,94 +0,0 @@
1		const builtin = @import("builtin");
2		const std = @import("std");
3		const maxInt = std.math.maxInt;
4
5		const FLT_MANT_DIG = 24;
6
7		inline fn floatundisf(arg: u64) f32 {
8		@setRuntimeSafety(builtin.is_test);
9
10		if (arg == 0) return 0;
11
12		var a = arg;
13		const N: usize = @typeInfo(@TypeOf(a)).Int.bits;
14		// Number of significant digits
15		const sd = N - @clz(u64, a);
16		// 8 exponent
17		var e = @intCast(u32, sd) - 1;
18
19		if (sd > FLT_MANT_DIG) {
20		// start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
21		// finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
22		// 12345678901234567890123456
23		// 1 = msb 1 bit
24		// P = bit FLT_MANT_DIG-1 bits to the right of 1
25		// Q = bit FLT_MANT_DIG bits to the right of 1
26		// R = "or" of all bits to the right of Q
27		switch (sd) {
28		FLT_MANT_DIG + 1 => a <<= 1,
29		FLT_MANT_DIG + 2 => {},
30		else => {
31		const shift_amt = @intCast(u6, ((N + FLT_MANT_DIG + 2) - sd));
32		const all_ones: u64 = maxInt(u64);
33		a = (a >> @intCast(u6, sd - (FLT_MANT_DIG + 2))) \|
34		@boolToInt(a & (all_ones >> shift_amt) != 0);
35		},
36		}
37		// Or P into R
38		a \|= @boolToInt((a & 4) != 0);
39		// round - this step may add a significant bit
40		a += 1;
41		// dump Q and R
42		a >>= 2;
43		// a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits
44		if ((a & (@as(u64, 1) << FLT_MANT_DIG)) != 0) {
45		a >>= 1;
46		e += 1;
47		}
48		// a is now rounded to FLT_MANT_DIG bits
49		} else {
50		a <<= @intCast(u6, FLT_MANT_DIG - sd);
51		// a is now rounded to FLT_MANT_DIG bits
52		}
53
54		const result: u32 = ((e + 127) << 23) \| // exponent
55		@truncate(u32, a & 0x007FFFFF); // mantissa
56		return @bitCast(f32, result);
57		}
58
59		pub fn __floatundisf(arg: u64) callconv(.C) f32 {
60		return floatundisf(arg);
61		}
62
63		pub fn __aeabi_ul2f(arg: u64) callconv(.AAPCS) f32 {
64		return floatundisf(arg);
65		}
66
67		fn test__floatundisf(a: u64, expected: f32) !void {
68		try std.testing.expectEqual(expected, __floatundisf(a));
69		}
70
71		test "floatundisf" {
72		try test__floatundisf(0, 0.0);
73		try test__floatundisf(1, 1.0);
74		try test__floatundisf(2, 2.0);
75		try test__floatundisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
76		try test__floatundisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
77		try test__floatundisf(0x8000008000000000, 0x1p+63);
78		try test__floatundisf(0x8000010000000000, 0x1.000002p+63);
79		try test__floatundisf(0x8000000000000000, 0x1p+63);
80		try test__floatundisf(0x8000000000000001, 0x1p+63);
81		try test__floatundisf(0xFFFFFFFFFFFFFFFE, 0x1p+64);
82		try test__floatundisf(0xFFFFFFFFFFFFFFFF, 0x1p+64);
83		try test__floatundisf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
84		try test__floatundisf(0x0007FB72EA000000, 0x1.FEDCBAp+50);
85		try test__floatundisf(0x0007FB72EB000000, 0x1.FEDCBAp+50);
86		try test__floatundisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50);
87		try test__floatundisf(0x0007FB72EC000000, 0x1.FEDCBCp+50);
88		try test__floatundisf(0x0007FB72E8000001, 0x1.FEDCBAp+50);
89		try test__floatundisf(0x0007FB72E6000000, 0x1.FEDCBAp+50);
90		try test__floatundisf(0x0007FB72E7000000, 0x1.FEDCBAp+50);
91		try test__floatundisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50);
92		try test__floatundisf(0x0007FB72E4000001, 0x1.FEDCBAp+50);
93		try test__floatundisf(0x0007FB72E4000000, 0x1.FEDCB8p+50);
94		}

lib/std/special/compiler_rt/floatunditf.zig deleted-28

...	...	@@ -1,28 +0,0 @@
1		const builtin = @import("builtin");
2		const is_test = builtin.is_test;
3		const std = @import("std");
4
5		pub fn __floatunditf(a: u64) callconv(.C) f128 {
6		@setRuntimeSafety(is_test);
7
8		if (a == 0) {
9		return 0;
10		}
11
12		const mantissa_bits = std.math.floatMantissaBits(f128);
13		const exponent_bits = std.math.floatExponentBits(f128);
14		const exponent_bias = (1 << (exponent_bits - 1)) - 1;
15		const implicit_bit = 1 << mantissa_bits;
16
17		const exp: u128 = (64 - 1) - @clz(u64, a);
18		const shift: u7 = mantissa_bits - @intCast(u7, exp);
19
20		var result: u128 = (@intCast(u128, a) << shift) ^ implicit_bit;
21		result += (exp + exponent_bias) << mantissa_bits;
22
23		return @bitCast(f128, result);
24		}
25
26		test {
27		_ = @import("floatunditf_test.zig");
28		}

lib/std/special/compiler_rt/floatunditf_test.zig deleted-32

...	...	@@ -1,32 +0,0 @@
1		const __floatunditf = @import("floatunditf.zig").__floatunditf;
2
3		fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) !void {
4		const x = __floatunditf(a);
5
6		const x_repr = @bitCast(u128, x);
7		const x_hi = @intCast(u64, x_repr >> 64);
8		const x_lo = @truncate(u64, x_repr);
9
10		if (x_hi == expected_hi and x_lo == expected_lo) {
11		return;
12		}
13		// nan repr
14		else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
15		if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) {
16		return;
17		}
18		}
19
20		@panic("__floatunditf test failure");
21		}
22
23		test "floatunditf" {
24		try test__floatunditf(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000);
25		try test__floatunditf(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000);
26		try test__floatunditf(0x8000000000000000, 0x403e000000000000, 0x0);
27		try test__floatunditf(0x7fffffffffffffff, 0x403dffffffffffff, 0xfffc000000000000);
28		try test__floatunditf(0x123456789abcdef1, 0x403b23456789abcd, 0xef10000000000000);
29		try test__floatunditf(0x2, 0x4000000000000000, 0x0);
30		try test__floatunditf(0x1, 0x3fff000000000000, 0x0);
31		try test__floatunditf(0x0, 0x0, 0x0);
32		}

lib/std/special/compiler_rt/floatunsidf.zig deleted-41

...	...	@@ -1,41 +0,0 @@
1		const builtin = @import("builtin");
2		const std = @import("std");
3		const maxInt = std.math.maxInt;
4
5		const implicitBit = @as(u64, 1) << 52;
6
7		inline fn floatunsidf(arg: u32) f64 {
8		@setRuntimeSafety(builtin.is_test);
9
10		if (arg == 0) return 0.0;
11
12		// The exponent is the width of abs(a)
13		const exp = @as(u64, 31) - @clz(u32, arg);
14		// Shift a into the significand field and clear the implicit bit
15		const shift = @intCast(u6, 52 - exp);
16		const mant = @as(u64, arg) << shift ^ implicitBit;
17
18		return @bitCast(f64, mant \| (exp + 1023) << 52);
19		}
20
21		pub fn __floatunsidf(arg: u32) callconv(.C) f64 {
22		return floatunsidf(arg);
23		}
24
25		pub fn __aeabi_ui2d(arg: u32) callconv(.AAPCS) f64 {
26		return floatunsidf(arg);
27		}
28
29		fn test_one_floatunsidf(a: u32, expected: u64) !void {
30		const r = __floatunsidf(a);
31		try std.testing.expect(@bitCast(u64, r) == expected);
32		}
33
34		test "floatsidf" {
35		// Test the produced bit pattern
36		try test_one_floatunsidf(0, 0x0000000000000000);
37		try test_one_floatunsidf(1, 0x3ff0000000000000);
38		try test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000);
39		try test_one_floatunsidf(@intCast(u32, 0x80000000), 0x41e0000000000000);
40		try test_one_floatunsidf(@intCast(u32, 0xFFFFFFFF), 0x41efffffffe00000);
41		}

lib/std/special/compiler_rt/floatunsisf.zig deleted-61

...	...	@@ -1,61 +0,0 @@
1		const builtin = @import("builtin");
2		const std = @import("std");
3		const maxInt = std.math.maxInt;
4
5		const significandBits = 23;
6		const exponentBias = 127;
7		const implicitBit = @as(u32, 1) << significandBits;
8
9		inline fn floatunsisf(arg: u32) f32 {
10		@setRuntimeSafety(builtin.is_test);
11
12		if (arg == 0) return 0.0;
13
14		// The exponent is the width of abs(a)
15		const exp = @as(u32, 31) - @clz(u32, arg);
16
17		var mantissa: u32 = undefined;
18		if (exp <= significandBits) {
19		// Shift a into the significand field and clear the implicit bit
20		const shift = @intCast(u5, significandBits - exp);
21		mantissa = @as(u32, arg) << shift ^ implicitBit;
22		} else {
23		const shift = @intCast(u5, exp - significandBits);
24		// Round to the nearest number after truncation
25		mantissa = @as(u32, arg) >> shift ^ implicitBit;
26		// Align to the left and check if the truncated part is halfway over
27		const round = arg << @intCast(u5, 31 - shift);
28		mantissa += @boolToInt(round > 0x80000000);
29		// Tie to even
30		mantissa += mantissa & 1;
31		}
32
33		// Use the addition instead of a or since we may have a carry from the
34		// mantissa to the exponent
35		var result = mantissa;
36		result += (exp + exponentBias) << significandBits;
37
38		return @bitCast(f32, result);
39		}
40
41		pub fn __floatunsisf(arg: u32) callconv(.C) f32 {
42		return floatunsisf(arg);
43		}
44
45		pub fn __aeabi_ui2f(arg: u32) callconv(.AAPCS) f32 {
46		return floatunsisf(arg);
47		}
48
49		fn test_one_floatunsisf(a: u32, expected: u32) !void {
50		const r = __floatunsisf(a);
51		try std.testing.expect(@bitCast(u32, r) == expected);
52		}
53
54		test "floatunsisf" {
55		// Test the produced bit pattern
56		try test_one_floatunsisf(0, 0);
57		try test_one_floatunsisf(1, 0x3f800000);
58		try test_one_floatunsisf(0x7FFFFFFF, 0x4f000000);
59		try test_one_floatunsisf(0x80000000, 0x4f000000);
60		try test_one_floatunsisf(0xFFFFFFFF, 0x4f800000);
61		}

lib/std/special/compiler_rt/floatunsitf.zig deleted-29

...	...	@@ -1,29 +0,0 @@
1		const builtin = @import("builtin");
2		const is_test = builtin.is_test;
3		const std = @import("std");
4
5		pub fn __floatunsitf(a: u32) callconv(.C) f128 {
6		@setRuntimeSafety(is_test);
7
8		if (a == 0) {
9		return 0;
10		}
11
12		const mantissa_bits = std.math.floatMantissaBits(f128);
13		const exponent_bits = std.math.floatExponentBits(f128);
14		const exponent_bias = (1 << (exponent_bits - 1)) - 1;
15		const implicit_bit = 1 << mantissa_bits;
16
17		const exp = (32 - 1) - @clz(u32, a);
18		const shift = mantissa_bits - @intCast(u7, exp);
19
20		// TODO(#1148): @bitCast alignment error
21		var result align(16) = (@intCast(u128, a) << shift) ^ implicit_bit;
22		result += (@intCast(u128, exp) + exponent_bias) << mantissa_bits;
23
24		return @bitCast(f128, result);
25		}
26
27		test {
28		_ = @import("floatunsitf_test.zig");
29		}

lib/std/special/compiler_rt/floatunsitf_test.zig deleted-28

...	...	@@ -1,28 +0,0 @@
1		const __floatunsitf = @import("floatunsitf.zig").__floatunsitf;
2
3		fn test__floatunsitf(a: u32, expected_hi: u64, expected_lo: u64) !void {
4		const x = __floatunsitf(a);
5
6		const x_repr = @bitCast(u128, x);
7		const x_hi = @intCast(u64, x_repr >> 64);
8		const x_lo = @truncate(u64, x_repr);
9
10		if (x_hi == expected_hi and x_lo == expected_lo) {
11		return;
12		}
13		// nan repr
14		else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
15		if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) {
16		return;
17		}
18		}
19
20		@panic("__floatunsitf test failure");
21		}
22
23		test "floatunsitf" {
24		try test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0);
25		try test__floatunsitf(0, 0x0, 0x0);
26		try test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0);
27		try test__floatunsitf(0x12345678, 0x401b234567800000, 0x0);
28		}

lib/std/special/compiler_rt/floatuntidf.zig deleted-62

...	...	@@ -1,62 +0,0 @@
1		const builtin = @import("builtin");
2		const is_test = builtin.is_test;
3		const std = @import("std");
4		const maxInt = std.math.maxInt;
5
6		const DBL_MANT_DIG = 53;
7
8		pub fn __floatuntidf(arg: u128) callconv(.C) f64 {
9		@setRuntimeSafety(is_test);
10
11		if (arg == 0)
12		return 0.0;
13
14		var a = arg;
15		const N: u32 = @sizeOf(u128) * 8;
16		const sd = @bitCast(i32, N - @clz(u128, a)); // number of significant digits
17		var e: i32 = sd - 1; // exponent
18		if (sd > DBL_MANT_DIG) {
19		// start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
20		// finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
21		// 12345678901234567890123456
22		// 1 = msb 1 bit
23		// P = bit DBL_MANT_DIG-1 bits to the right of 1
24		// Q = bit DBL_MANT_DIG bits to the right of 1
25		// R = "or" of all bits to the right of Q
26		switch (sd) {
27		DBL_MANT_DIG + 1 => {
28		a <<= 1;
29		},
30		DBL_MANT_DIG + 2 => {},
31		else => {
32		const shift_amt = @bitCast(i32, N + (DBL_MANT_DIG + 2)) - sd;
33		const shift_amt_u7 = @intCast(u7, shift_amt);
34		a = (a >> @intCast(u7, sd - (DBL_MANT_DIG + 2))) \|
35		@boolToInt((a & (@as(u128, maxInt(u128)) >> shift_amt_u7)) != 0);
36		},
37		}
38		// finish
39		a \|= @boolToInt((a & 4) != 0); // Or P into R
40		a += 1; // round - this step may add a significant bit
41		a >>= 2; // dump Q and R
42		// a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits
43		if ((a & (@as(u128, 1) << DBL_MANT_DIG)) != 0) {
44		a >>= 1;
45		e += 1;
46		}
47		// a is now rounded to DBL_MANT_DIG bits
48		} else {
49		a <<= @intCast(u7, DBL_MANT_DIG - sd);
50		// a is now rounded to DBL_MANT_DIG bits
51		}
52
53		const high: u64 = @bitCast(u32, (e + 1023) << 20) \| // exponent
54		(@truncate(u32, a >> 32) & 0x000FFFFF); // mantissa-high
55		const low = @truncate(u32, a); // mantissa-low
56
57		return @bitCast(f64, low \| (high << 32));
58		}
59
60		test {
61		_ = @import("floatuntidf_test.zig");
62		}

lib/std/special/compiler_rt/floatuntidf_test.zig deleted-81

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

lib/std/special/compiler_rt/floatuntisf.zig deleted-61

...	...	@@ -1,61 +0,0 @@
1		const builtin = @import("builtin");
2		const is_test = builtin.is_test;
3		const std = @import("std");
4		const maxInt = std.math.maxInt;
5
6		const FLT_MANT_DIG = 24;
7
8		pub fn __floatuntisf(arg: u128) callconv(.C) f32 {
9		@setRuntimeSafety(is_test);
10
11		if (arg == 0)
12		return 0.0;
13
14		var a = arg;
15		const N: u32 = @sizeOf(u128) * 8;
16		const sd = @bitCast(i32, N - @clz(u128, a)); // number of significant digits
17		var e: i32 = sd - 1; // exponent
18		if (sd > FLT_MANT_DIG) {
19		// start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
20		// finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
21		// 12345678901234567890123456
22		// 1 = msb 1 bit
23		// P = bit FLT_MANT_DIG-1 bits to the right of 1
24		// Q = bit FLT_MANT_DIG bits to the right of 1
25		// R = "or" of all bits to the right of Q
26		switch (sd) {
27		FLT_MANT_DIG + 1 => {
28		a <<= 1;
29		},
30		FLT_MANT_DIG + 2 => {},
31		else => {
32		const shift_amt = @bitCast(i32, N + (FLT_MANT_DIG + 2)) - sd;
33		const shift_amt_u7 = @intCast(u7, shift_amt);
34		a = (a >> @intCast(u7, sd - (FLT_MANT_DIG + 2))) \|
35		@boolToInt((a & (@as(u128, maxInt(u128)) >> shift_amt_u7)) != 0);
36		},
37		}
38		// finish
39		a \|= @boolToInt((a & 4) != 0); // Or P into R
40		a += 1; // round - this step may add a significant bit
41		a >>= 2; // dump Q and R
42		// a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits
43		if ((a & (@as(u128, 1) << FLT_MANT_DIG)) != 0) {
44		a >>= 1;
45		e += 1;
46		}
47		// a is now rounded to FLT_MANT_DIG bits
48		} else {
49		a <<= @intCast(u7, FLT_MANT_DIG - sd);
50		// a is now rounded to FLT_MANT_DIG bits
51		}
52
53		const high = @bitCast(u32, (e + 127) << 23); // exponent
54		const low = @truncate(u32, a) & 0x007fffff; // mantissa
55
56		return @bitCast(f32, high \| low);
57		}
58
59		test {
60		_ = @import("floatuntisf_test.zig");
61		}

lib/std/special/compiler_rt/floatuntisf_test.zig deleted-72

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

lib/std/special/compiler_rt/floatuntitf.zig deleted-62

...	...	@@ -1,62 +0,0 @@
1		const builtin = @import("builtin");
2		const is_test = builtin.is_test;
3		const std = @import("std");
4		const maxInt = std.math.maxInt;
5
6		const LDBL_MANT_DIG = 113;
7
8		pub fn __floatuntitf(arg: u128) callconv(.C) f128 {
9		@setRuntimeSafety(is_test);
10
11		if (arg == 0)
12		return 0.0;
13
14		var a = arg;
15		const N: u32 = @sizeOf(u128) * 8;
16		const sd = @bitCast(i32, N - @clz(u128, a)); // number of significant digits
17		var e: i32 = sd - 1; // exponent
18		if (sd > LDBL_MANT_DIG) {
19		// start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
20		// finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR
21		// 12345678901234567890123456
22		// 1 = msb 1 bit
23		// P = bit LDBL_MANT_DIG-1 bits to the right of 1
24		// Q = bit LDBL_MANT_DIG bits to the right of 1
25		// R = "or" of all bits to the right of Q
26		switch (sd) {
27		LDBL_MANT_DIG + 1 => {
28		a <<= 1;
29		},
30		LDBL_MANT_DIG + 2 => {},
31		else => {
32		const shift_amt = @bitCast(i32, N + (LDBL_MANT_DIG + 2)) - sd;
33		const shift_amt_u7 = @intCast(u7, shift_amt);
34		a = (a >> @intCast(u7, sd - (LDBL_MANT_DIG + 2))) \|
35		@boolToInt((a & (@as(u128, maxInt(u128)) >> shift_amt_u7)) != 0);
36		},
37		}
38		// finish
39		a \|= @boolToInt((a & 4) != 0); // Or P into R
40		a += 1; // round - this step may add a significant bit
41		a >>= 2; // dump Q and R
42		// a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits
43		if ((a & (@as(u128, 1) << LDBL_MANT_DIG)) != 0) {
44		a >>= 1;
45		e += 1;
46		}
47		// a is now rounded to LDBL_MANT_DIG bits
48		} else {
49		a <<= @intCast(u7, LDBL_MANT_DIG - sd);
50		// a is now rounded to LDBL_MANT_DIG bits
51		}
52
53		const high: u128 = (@intCast(u64, (e + 16383)) << 48) \| // exponent
54		(@truncate(u64, a >> 64) & 0x0000ffffffffffff); // mantissa-high
55		const low = @truncate(u64, a); // mantissa-low
56
57		return @bitCast(f128, low \| (high << 64));
58		}
59
60		test {
61		_ = @import("floatuntitf_test.zig");
62		}

lib/std/special/compiler_rt/floatuntitf_test.zig deleted-99

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

lib/std/special/compiler_rt/sparc.zig+8-8

...	...	@@ -66,19 +66,19 @@ pub fn _Qp_fge(a: f128, b: f128) callconv(.C) bool {
66	66	// Conversion
67	67
68	68	pub fn _Qp_itoq(c: *f128, a: i32) callconv(.C) void {
69		c.* = @import("floatsiXf.zig").__floatsitf(a);
	69	c.* = @import("floatXiYf.zig").__floatsitf(a);
70	70	}
71	71
72	72	pub fn _Qp_uitoq(c: *f128, a: u32) callconv(.C) void {
73		c.* = @import("floatunsitf.zig").__floatunsitf(a);
	73	c.* = @import("floatXiYf.zig").__floatunsitf(a);
74	74	}
75	75
76	76	pub fn _Qp_xtoq(c: *f128, a: i64) callconv(.C) void {
77		c.* = @import("floatditf.zig").__floatditf(a);
	77	c.* = @import("floatXiYf.zig").__floatditf(a);
78	78	}
79	79
80	80	pub fn _Qp_uxtoq(c: *f128, a: u64) callconv(.C) void {
81		c.* = @import("floatunditf.zig").__floatunditf(a);
	81	c.* = @import("floatXiYf.zig").__floatunditf(a);
82	82	}
83	83
84	84	pub fn _Qp_stoq(c: *f128, a: f32) callconv(.C) void {
...	...	@@ -90,19 +90,19 @@ pub fn _Qp_dtoq(c: *f128, a: f64) callconv(.C) void {
90	90	}
91	91
92	92	pub fn _Qp_qtoi(a: *f128) callconv(.C) i32 {
93		return @import("fixtfsi.zig").__fixtfsi(a.*);
	93	return @import("fixXfYi.zig").__fixtfsi(a.*);
94	94	}
95	95
96	96	pub fn _Qp_qtoui(a: *f128) callconv(.C) u32 {
97		return @import("fixunstfsi.zig").__fixunstfsi(a.*);
	97	return @import("fixXfYi.zig").__fixunstfsi(a.*);
98	98	}
99	99
100	100	pub fn _Qp_qtox(a: *f128) callconv(.C) i64 {
101		return @import("fixtfdi.zig").__fixtfdi(a.*);
	101	return @import("fixXfYi.zig").__fixtfdi(a.*);
102	102	}
103	103
104	104	pub fn _Qp_qtoux(a: *f128) callconv(.C) u64 {
105		return @import("fixunstfdi.zig").__fixunstfdi(a.*);
	105	return @import("fixXfYi.zig").__fixunstfdi(a.*);
106	106	}
107	107
108	108	pub fn _Qp_qtos(a: *f128) callconv(.C) f32 {

lib/std/special/compiler_rt/trunc_f80.zig+24-10

...	...	@@ -1,6 +1,7 @@
1	1	const std = @import("std");
2	2	const builtin = @import("builtin");
3	3	const native_arch = builtin.cpu.arch;
	4	const testing = std.testing;
4	5
5	6	// AArch64 is the only ABI (at the moment) to support f16 arguments without the
6	7	// need for extending them to wider fp types.
...	...	@@ -117,13 +118,12 @@ pub fn __trunctfxf2(a: f128) callconv(.C) f80 {
117	118	const src_abs_mask = src_sign_mask - 1;
118	119	const round_mask = (1 << (src_sig_bits - dst_sig_bits)) - 1;
119	120	const halfway = 1 << (src_sig_bits - dst_sig_bits - 1);
120		const src_qnan = 1 << (src_sig_bits - 1);
121		const src_nan_mask = src_qnan - 1;
122	121
123	122	// Break a into a sign and representation of the absolute value
124	123	const a_rep = @bitCast(u128, a);
125	124	const a_abs = a_rep & src_abs_mask;
126	125	const sign: u16 = if (a_rep & src_sign_mask != 0) 0x8000 else 0;
	126	const integer_bit = 1 << 63;
127	127
128	128	var res: std.math.F80 = undefined;
129	129
...	...	@@ -133,27 +133,41 @@ pub fn __trunctfxf2(a: f128) callconv(.C) f80 {
133	133	// bit and inserting the (truncated) trailing NaN field.
134	134	res.exp = 0x7fff;
135	135	res.fraction = 0x8000000000000000;
136		res.fraction \|= @truncate(u64, (a_abs & src_qnan) << (src_sig_bits - dst_sig_bits));
137		res.fraction \|= @truncate(u64, (a_abs & src_nan_mask) << (src_sig_bits - dst_sig_bits));
	136	res.fraction \|= @truncate(u64, a_abs >> (src_sig_bits - dst_sig_bits));
138	137	} else {
139	138	// The exponent of a is within the range of normal numbers in the
140	139	// destination format. We can convert by simply right-shifting with
141		// rounding and adjusting the exponent.
142		res.fraction = @truncate(u64, a_abs >> (src_sig_bits - dst_sig_bits));
	140	// rounding, adding the explicit integer bit, and adjusting the exponent
	141	res.fraction = @truncate(u64, a_abs >> (src_sig_bits - dst_sig_bits)) \| integer_bit;
143	142	res.exp = @truncate(u16, a_abs >> src_sig_bits);
144	143
145	144	const round_bits = a_abs & round_mask;
146	145	if (round_bits > halfway) {
147	146	// Round to nearest
148		const exp = @addWithOverflow(u64, res.fraction, 1, &res.fraction);
149		res.exp += @boolToInt(exp);
	147	const carry = @boolToInt(@addWithOverflow(u64, res.fraction, 1, &res.fraction));
	148	res.exp += carry;
	149	res.fraction \|= @as(u64, carry) << 63; // Restore integer bit after carry
150	150	} else if (round_bits == halfway) {
151	151	// Ties to even
152		const exp = @addWithOverflow(u64, res.fraction, res.fraction & 1, &res.fraction);
153		res.exp += @boolToInt(exp);
	152	const carry = @boolToInt(@addWithOverflow(u64, res.fraction, res.fraction & 1, &res.fraction));
	153	res.exp += carry;
	154	res.fraction \|= @as(u64, carry) << 63; // Restore integer bit after carry
154	155	}
	156	if (res.exp == 0) res.fraction &= ~@as(u64, integer_bit); // Remove integer bit for de-normals
155	157	}
156	158
157	159	res.exp \|= sign;
158	160	return std.math.make_f80(res);
159	161	}
	162
	163	fn test__trunctfxf2(a: f128, expected: f80) !void {
	164	const x = __trunctfxf2(a);
	165	try testing.expect(x == expected);
	166	}
	167
	168	test {
	169	try test__trunctfxf2(1.5, 1.5);
	170	try test__trunctfxf2(2.5, 2.5);
	171	try test__trunctfxf2(-2.5, -2.5);
	172	try test__trunctfxf2(0.0, 0.0);
	173	}

test/behavior/math.zig+4-10

...	...	@@ -923,6 +923,8 @@ test "comptime float rem int" {
923	923	}
924	924
925	925	test "remainder division" {
	926	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
	927
926	928	comptime try remdiv(f16);
927	929	comptime try remdiv(f32);
928	930	comptime try remdiv(f64);
...	...	@@ -938,11 +940,7 @@ fn remdiv(comptime T: type) !void {
938	940	}
939	941
940	942	test "float remainder division using @rem" {
941		if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
942		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
943		if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
944		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
945		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	943	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
946	944
947	945	comptime try frem(f16);
948	946	comptime try frem(f32);
...	...	@@ -973,11 +971,7 @@ fn frem(comptime T: type) !void {
973	971	}
974	972
975	973	test "float modulo division using @mod" {
976		if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
977		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
978		if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
979		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
980		if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	974	if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
981	975
982	976	comptime try fmod(f16);
983	977	comptime try fmod(f32);