diff options
Diffstat (limited to 'lib')
78 files changed, 2470 insertions, 3081 deletions
diff --git a/lib/std/math.zig b/lib/std/math.zig index 94e3ab6d2a..be49ba8030 100644 --- a/lib/std/math.zig +++ b/lib/std/math.zig @@ -38,7 +38,7 @@ pub const sqrt1_2 = 0.707106781186547524400844362104849039; pub const floatExponentBits = @import("math/float.zig").floatExponentBits; pub const floatMantissaBits = @import("math/float.zig").floatMantissaBits; -pub const floatMantissaDigits = @import("math/float.zig").floatMantissaDigits; +pub const floatFractionalBits = @import("math/float.zig").floatFractionalBits; pub const floatExponentMin = @import("math/float.zig").floatExponentMin; pub const floatExponentMax = @import("math/float.zig").floatExponentMax; pub const floatTrueMin = @import("math/float.zig").floatTrueMin; diff --git a/lib/std/math/float.zig b/lib/std/math/float.zig index 6d9c17d2a2..30e2268908 100644 --- a/lib/std/math/float.zig +++ b/lib/std/math/float.zig @@ -4,7 +4,7 @@ const expect = std.testing.expect; /// Creates a raw "1.0" mantissa for floating point type T. Used to dedupe f80 logic. fn mantissaOne(comptime T: type) comptime_int { - return if (floatMantissaDigits(T) == 64) 1 << 63 else 0; + return if (T == f80) 1 << floatFractionalBits(T) else 0; } /// Creates floating point type T from an unbiased exponent and raw mantissa. @@ -42,19 +42,19 @@ pub fn floatMantissaBits(comptime T: type) comptime_int { }; } -/// Returns the number of binary digits in the mantissa of floating point type T. -pub fn floatMantissaDigits(comptime T: type) comptime_int { +/// Returns the number of fractional bits in the mantissa of floating point type T. +pub fn floatFractionalBits(comptime T: type) comptime_int { assert(@typeInfo(T) == .Float); // standard IEEE floats have an implicit 0.m or 1.m integer part // f80 is special and has an explicitly stored bit in the MSB - // this function corresponds to `MANT_DIG' constants from C + // this function corresponds to `MANT_DIG - 1' from C return switch (@typeInfo(T).Float.bits) { - 16 => 11, - 32 => 24, - 64 => 53, - 80 => 64, - 128 => 113, + 16 => 10, + 32 => 23, + 64 => 52, + 80 => 63, + 128 => 112, else => @compileError("unknown floating point type " ++ @typeName(T)), }; } @@ -89,7 +89,7 @@ pub fn floatMax(comptime T: type) T { /// Returns the machine epsilon of floating point type T. pub fn floatEps(comptime T: type) T { - return reconstructFloat(T, -(floatMantissaDigits(T) - 1), mantissaOne(T)); + return reconstructFloat(T, -floatFractionalBits(T), mantissaOne(T)); } /// Returns the value inf for floating point type T. @@ -104,7 +104,7 @@ test "std.math.float" { try expect(@bitSizeOf(T) == size); // for machine epsilon, assert expmin <= -prec <= expmax - try expect(floatExponentMin(T) <= -(floatMantissaDigits(T) - 1)); - try expect(-(floatMantissaDigits(T) - 1) <= floatExponentMax(T)); + try expect(floatExponentMin(T) <= -floatFractionalBits(T)); + try expect(-floatFractionalBits(T) <= floatExponentMax(T)); } } diff --git a/lib/std/math/isnormal.zig b/lib/std/math/isnormal.zig index 7376b86eb9..42b2e1c188 100644 --- a/lib/std/math/isnormal.zig +++ b/lib/std/math/isnormal.zig @@ -41,7 +41,7 @@ test "math.isNormal" { try expect(!isNormal(@as(T, math.floatTrueMin(T)))); // largest subnormal - try expect(!isNormal(@bitCast(T, ~(~@as(TBits, 0) << math.floatMantissaDigits(T) - 1)))); + try expect(!isNormal(@bitCast(T, ~(~@as(TBits, 0) << math.floatFractionalBits(T))))); // non-finite numbers try expect(!isNormal(-math.inf(T))); diff --git a/lib/std/special/compiler_rt.zig b/lib/std/special/compiler_rt.zig index a017266304..b54a1e980e 100644 --- a/lib/std/special/compiler_rt.zig +++ b/lib/std/special/compiler_rt.zig @@ -291,100 +291,149 @@ comptime { const __bswapti2 = @import("compiler_rt/bswap.zig").__bswapti2; @export(__bswapti2, .{ .name = "__bswapti2", .linkage = linkage }); - // Integral / floating point conversion (part 1/2) - const __floatsidf = @import("compiler_rt/floatsiXf.zig").__floatsidf; - @export(__floatsidf, .{ .name = "__floatsidf", .linkage = linkage }); - const __floatsisf = @import("compiler_rt/floatsiXf.zig").__floatsisf; - @export(__floatsisf, .{ .name = "__floatsisf", .linkage = linkage }); - const __floatdidf = @import("compiler_rt/floatdidf.zig").__floatdidf; - @export(__floatdidf, .{ .name = "__floatdidf", .linkage = linkage }); - const __floatsitf = @import("compiler_rt/floatsiXf.zig").__floatsitf; - @export(__floatsitf, .{ .name = "__floatsitf", .linkage = linkage }); + // Integral -> Float Conversion - const __floatunsisf = @import("compiler_rt/floatunsisf.zig").__floatunsisf; + // Conversion to f32 + const __floatsisf = @import("compiler_rt/floatXiYf.zig").__floatsisf; + @export(__floatsisf, .{ .name = "__floatsisf", .linkage = linkage }); + const __floatunsisf = @import("compiler_rt/floatXiYf.zig").__floatunsisf; @export(__floatunsisf, .{ .name = "__floatunsisf", .linkage = linkage }); - const __floatundisf = @import("compiler_rt/floatundisf.zig").__floatundisf; + + const __floatundisf = @import("compiler_rt/floatXiYf.zig").__floatundisf; @export(__floatundisf, .{ .name = "__floatundisf", .linkage = linkage }); - const __floatunsidf = @import("compiler_rt/floatunsidf.zig").__floatunsidf; + const __floatdisf = @import("compiler_rt/floatXiYf.zig").__floatdisf; + @export(__floatdisf, .{ .name = "__floatdisf", .linkage = linkage }); + + const __floattisf = @import("compiler_rt/floatXiYf.zig").__floattisf; + @export(__floattisf, .{ .name = "__floattisf", .linkage = linkage }); + const __floatuntisf = @import("compiler_rt/floatXiYf.zig").__floatuntisf; + @export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = linkage }); + + // Conversion to f64 + const __floatsidf = @import("compiler_rt/floatXiYf.zig").__floatsidf; + @export(__floatsidf, .{ .name = "__floatsidf", .linkage = linkage }); + const __floatunsidf = @import("compiler_rt/floatXiYf.zig").__floatunsidf; @export(__floatunsidf, .{ .name = "__floatunsidf", .linkage = linkage }); - const __floatundidf = @import("compiler_rt/floatundidf.zig").__floatundidf; + + const __floatdidf = @import("compiler_rt/floatXiYf.zig").__floatdidf; + @export(__floatdidf, .{ .name = "__floatdidf", .linkage = linkage }); + const __floatundidf = @import("compiler_rt/floatXiYf.zig").__floatundidf; @export(__floatundidf, .{ .name = "__floatundidf", .linkage = linkage }); - const __floatditf = @import("compiler_rt/floatditf.zig").__floatditf; - @export(__floatditf, .{ .name = "__floatditf", .linkage = linkage }); - const __floattitf = @import("compiler_rt/floattitf.zig").__floattitf; - @export(__floattitf, .{ .name = "__floattitf", .linkage = linkage }); - const __floattidf = @import("compiler_rt/floattidf.zig").__floattidf; + const __floattidf = @import("compiler_rt/floatXiYf.zig").__floattidf; @export(__floattidf, .{ .name = "__floattidf", .linkage = linkage }); - const __floattisf = @import("compiler_rt/floatXisf.zig").__floattisf; - @export(__floattisf, .{ .name = "__floattisf", .linkage = linkage }); - const __floatdisf = @import("compiler_rt/floatXisf.zig").__floatdisf; - @export(__floatdisf, .{ .name = "__floatdisf", .linkage = linkage }); + const __floatuntidf = @import("compiler_rt/floatXiYf.zig").__floatuntidf; + @export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = linkage }); - const __floatunditf = @import("compiler_rt/floatunditf.zig").__floatunditf; - @export(__floatunditf, .{ .name = "__floatunditf", .linkage = linkage }); - const __floatunsitf = @import("compiler_rt/floatunsitf.zig").__floatunsitf; + // Conversion to f80 + const __floatsixf = @import("compiler_rt/floatXiYf.zig").__floatsixf; + @export(__floatsixf, .{ .name = "__floatsixf", .linkage = linkage }); + const __floatunsixf = @import("compiler_rt/floatXiYf.zig").__floatunsixf; + @export(__floatunsixf, .{ .name = "__floatunsixf", .linkage = linkage }); + + const __floatdixf = @import("compiler_rt/floatXiYf.zig").__floatdixf; + @export(__floatdixf, .{ .name = "__floatdixf", .linkage = linkage }); + const __floatundixf = @import("compiler_rt/floatXiYf.zig").__floatundixf; + @export(__floatundixf, .{ .name = "__floatundixf", .linkage = linkage }); + + const __floattixf = @import("compiler_rt/floatXiYf.zig").__floattixf; + @export(__floattixf, .{ .name = "__floattixf", .linkage = linkage }); + const __floatuntixf = @import("compiler_rt/floatXiYf.zig").__floatuntixf; + @export(__floatuntixf, .{ .name = "__floatuntixf", .linkage = linkage }); + + // Conversion to f128 + const __floatsitf = @import("compiler_rt/floatXiYf.zig").__floatsitf; + @export(__floatsitf, .{ .name = "__floatsitf", .linkage = linkage }); + const __floatunsitf = @import("compiler_rt/floatXiYf.zig").__floatunsitf; @export(__floatunsitf, .{ .name = "__floatunsitf", .linkage = linkage }); - const __floatuntitf = @import("compiler_rt/floatuntitf.zig").__floatuntitf; + const __floatditf = @import("compiler_rt/floatXiYf.zig").__floatditf; + @export(__floatditf, .{ .name = "__floatditf", .linkage = linkage }); + const __floatunditf = @import("compiler_rt/floatXiYf.zig").__floatunditf; + @export(__floatunditf, .{ .name = "__floatunditf", .linkage = linkage }); + + const __floattitf = @import("compiler_rt/floatXiYf.zig").__floattitf; + @export(__floattitf, .{ .name = "__floattitf", .linkage = linkage }); + const __floatuntitf = @import("compiler_rt/floatXiYf.zig").__floatuntitf; @export(__floatuntitf, .{ .name = "__floatuntitf", .linkage = linkage }); - const __floatuntidf = @import("compiler_rt/floatuntidf.zig").__floatuntidf; - @export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = linkage }); - const __floatuntisf = @import("compiler_rt/floatuntisf.zig").__floatuntisf; - @export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = linkage }); - const __truncsfhf2 = @import("compiler_rt/truncXfYf2.zig").__truncsfhf2; - @export(__truncsfhf2, .{ .name = "__truncsfhf2", .linkage = linkage }); - if (!is_test) { - @export(__truncsfhf2, .{ .name = "__gnu_f2h_ieee", .linkage = linkage }); - } - const __extendsfdf2 = @import("compiler_rt/extendXfYf2.zig").__extendsfdf2; - @export(__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = linkage }); + // Float -> Integral Conversion - // Integral / floating point conversion (part 2/2) - const __fixunssfsi = @import("compiler_rt/fixunssfsi.zig").__fixunssfsi; + // Conversion from f32 + const __fixsfsi = @import("compiler_rt/fixXfYi.zig").__fixsfsi; + @export(__fixsfsi, .{ .name = "__fixsfsi", .linkage = linkage }); + const __fixunssfsi = @import("compiler_rt/fixXfYi.zig").__fixunssfsi; @export(__fixunssfsi, .{ .name = "__fixunssfsi", .linkage = linkage }); - const __fixunssfdi = @import("compiler_rt/fixunssfdi.zig").__fixunssfdi; + + const __fixsfdi = @import("compiler_rt/fixXfYi.zig").__fixsfdi; + @export(__fixsfdi, .{ .name = "__fixsfdi", .linkage = linkage }); + const __fixunssfdi = @import("compiler_rt/fixXfYi.zig").__fixunssfdi; @export(__fixunssfdi, .{ .name = "__fixunssfdi", .linkage = linkage }); - const __fixunssfti = @import("compiler_rt/fixunssfti.zig").__fixunssfti; + + const __fixsfti = @import("compiler_rt/fixXfYi.zig").__fixsfti; + @export(__fixsfti, .{ .name = "__fixsfti", .linkage = linkage }); + const __fixunssfti = @import("compiler_rt/fixXfYi.zig").__fixunssfti; @export(__fixunssfti, .{ .name = "__fixunssfti", .linkage = linkage }); - const __fixunsdfsi = @import("compiler_rt/fixunsdfsi.zig").__fixunsdfsi; + // Conversion from f64 + const __fixdfsi = @import("compiler_rt/fixXfYi.zig").__fixdfsi; + @export(__fixdfsi, .{ .name = "__fixdfsi", .linkage = linkage }); + const __fixunsdfsi = @import("compiler_rt/fixXfYi.zig").__fixunsdfsi; @export(__fixunsdfsi, .{ .name = "__fixunsdfsi", .linkage = linkage }); - const __fixunsdfdi = @import("compiler_rt/fixunsdfdi.zig").__fixunsdfdi; + + const __fixdfdi = @import("compiler_rt/fixXfYi.zig").__fixdfdi; + @export(__fixdfdi, .{ .name = "__fixdfdi", .linkage = linkage }); + const __fixunsdfdi = @import("compiler_rt/fixXfYi.zig").__fixunsdfdi; @export(__fixunsdfdi, .{ .name = "__fixunsdfdi", .linkage = linkage }); - const __fixunsdfti = @import("compiler_rt/fixunsdfti.zig").__fixunsdfti; + + const __fixdfti = @import("compiler_rt/fixXfYi.zig").__fixdfti; + @export(__fixdfti, .{ .name = "__fixdfti", .linkage = linkage }); + const __fixunsdfti = @import("compiler_rt/fixXfYi.zig").__fixunsdfti; @export(__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = linkage }); - const __fixunstfsi = @import("compiler_rt/fixunstfsi.zig").__fixunstfsi; + // Conversion from f80 + const __fixxfsi = @import("compiler_rt/fixXfYi.zig").__fixxfsi; + @export(__fixxfsi, .{ .name = "__fixxfsi", .linkage = linkage }); + const __fixunsxfsi = @import("compiler_rt/fixXfYi.zig").__fixunsxfsi; + @export(__fixunsxfsi, .{ .name = "__fixunsxfsi", .linkage = linkage }); + + const __fixxfdi = @import("compiler_rt/fixXfYi.zig").__fixxfdi; + @export(__fixxfdi, .{ .name = "__fixxfdi", .linkage = linkage }); + const __fixunsxfdi = @import("compiler_rt/fixXfYi.zig").__fixunsxfdi; + @export(__fixunsxfdi, .{ .name = "__fixunsxfdi", .linkage = linkage }); + + const __fixxfti = @import("compiler_rt/fixXfYi.zig").__fixxfti; + @export(__fixxfti, .{ .name = "__fixxfti", .linkage = linkage }); + const __fixunsxfti = @import("compiler_rt/fixXfYi.zig").__fixunsxfti; + @export(__fixunsxfti, .{ .name = "__fixunsxfti", .linkage = linkage }); + + // Conversion from f128 + const __fixtfsi = @import("compiler_rt/fixXfYi.zig").__fixtfsi; + @export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = linkage }); + const __fixunstfsi = @import("compiler_rt/fixXfYi.zig").__fixunstfsi; @export(__fixunstfsi, .{ .name = "__fixunstfsi", .linkage = linkage }); - const __fixunstfdi = @import("compiler_rt/fixunstfdi.zig").__fixunstfdi; - @export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = linkage }); - const __fixunstfti = @import("compiler_rt/fixunstfti.zig").__fixunstfti; - @export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = linkage }); - const __fixdfdi = @import("compiler_rt/fixdfdi.zig").__fixdfdi; - @export(__fixdfdi, .{ .name = "__fixdfdi", .linkage = linkage }); - const __fixdfsi = @import("compiler_rt/fixdfsi.zig").__fixdfsi; - @export(__fixdfsi, .{ .name = "__fixdfsi", .linkage = linkage }); - const __fixdfti = @import("compiler_rt/fixdfti.zig").__fixdfti; - @export(__fixdfti, .{ .name = "__fixdfti", .linkage = linkage }); - const __fixsfdi = @import("compiler_rt/fixsfdi.zig").__fixsfdi; - @export(__fixsfdi, .{ .name = "__fixsfdi", .linkage = linkage }); - const __fixsfsi = @import("compiler_rt/fixsfsi.zig").__fixsfsi; - @export(__fixsfsi, .{ .name = "__fixsfsi", .linkage = linkage }); - const __fixsfti = @import("compiler_rt/fixsfti.zig").__fixsfti; - @export(__fixsfti, .{ .name = "__fixsfti", .linkage = linkage }); - const __fixtfdi = @import("compiler_rt/fixtfdi.zig").__fixtfdi; + const __fixtfdi = @import("compiler_rt/fixXfYi.zig").__fixtfdi; @export(__fixtfdi, .{ .name = "__fixtfdi", .linkage = linkage }); - const __fixtfsi = @import("compiler_rt/fixtfsi.zig").__fixtfsi; - @export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = linkage }); - const __fixtfti = @import("compiler_rt/fixtfti.zig").__fixtfti; + const __fixunstfdi = @import("compiler_rt/fixXfYi.zig").__fixunstfdi; + @export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = linkage }); + + const __fixtfti = @import("compiler_rt/fixXfYi.zig").__fixtfti; @export(__fixtfti, .{ .name = "__fixtfti", .linkage = linkage }); + const __fixunstfti = @import("compiler_rt/fixXfYi.zig").__fixunstfti; + @export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = linkage }); const __udivmoddi4 = @import("compiler_rt/int.zig").__udivmoddi4; @export(__udivmoddi4, .{ .name = "__udivmoddi4", .linkage = linkage }); + const __truncsfhf2 = @import("compiler_rt/truncXfYf2.zig").__truncsfhf2; + @export(__truncsfhf2, .{ .name = "__truncsfhf2", .linkage = linkage }); + if (!is_test) { + @export(__truncsfhf2, .{ .name = "__gnu_f2h_ieee", .linkage = linkage }); + } + const __extendsfdf2 = @import("compiler_rt/extendXfYf2.zig").__extendsfdf2; + @export(__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = linkage }); + if (is_darwin) { const __isPlatformVersionAtLeast = @import("compiler_rt/os_version_check.zig").__isPlatformVersionAtLeast; @export(__isPlatformVersionAtLeast, .{ .name = "__isPlatformVersionAtLeast", .linkage = linkage }); @@ -553,19 +602,19 @@ comptime { const __aeabi_f2d = @import("compiler_rt/extendXfYf2.zig").__aeabi_f2d; @export(__aeabi_f2d, .{ .name = "__aeabi_f2d", .linkage = linkage }); - const __aeabi_i2d = @import("compiler_rt/floatsiXf.zig").__aeabi_i2d; + const __aeabi_i2d = @import("compiler_rt/floatXiYf.zig").__aeabi_i2d; @export(__aeabi_i2d, .{ .name = "__aeabi_i2d", .linkage = linkage }); - const __aeabi_l2d = @import("compiler_rt/floatdidf.zig").__aeabi_l2d; + const __aeabi_l2d = @import("compiler_rt/floatXiYf.zig").__aeabi_l2d; @export(__aeabi_l2d, .{ .name = "__aeabi_l2d", .linkage = linkage }); - const __aeabi_l2f = @import("compiler_rt/floatXisf.zig").__aeabi_l2f; + const __aeabi_l2f = @import("compiler_rt/floatXiYf.zig").__aeabi_l2f; @export(__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = linkage }); - const __aeabi_ui2d = @import("compiler_rt/floatunsidf.zig").__aeabi_ui2d; + const __aeabi_ui2d = @import("compiler_rt/floatXiYf.zig").__aeabi_ui2d; @export(__aeabi_ui2d, .{ .name = "__aeabi_ui2d", .linkage = linkage }); - const __aeabi_ul2d = @import("compiler_rt/floatundidf.zig").__aeabi_ul2d; + const __aeabi_ul2d = @import("compiler_rt/floatXiYf.zig").__aeabi_ul2d; @export(__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = linkage }); - const __aeabi_ui2f = @import("compiler_rt/floatunsisf.zig").__aeabi_ui2f; + const __aeabi_ui2f = @import("compiler_rt/floatXiYf.zig").__aeabi_ui2f; @export(__aeabi_ui2f, .{ .name = "__aeabi_ui2f", .linkage = linkage }); - const __aeabi_ul2f = @import("compiler_rt/floatundisf.zig").__aeabi_ul2f; + const __aeabi_ul2f = @import("compiler_rt/floatXiYf.zig").__aeabi_ul2f; @export(__aeabi_ul2f, .{ .name = "__aeabi_ul2f", .linkage = linkage }); const __aeabi_fneg = @import("compiler_rt/negXf2.zig").__aeabi_fneg; @@ -581,17 +630,17 @@ comptime { const __aeabi_d2h = @import("compiler_rt/truncXfYf2.zig").__aeabi_d2h; @export(__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = linkage }); - const __aeabi_f2ulz = @import("compiler_rt/fixunssfdi.zig").__aeabi_f2ulz; + const __aeabi_f2ulz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2ulz; @export(__aeabi_f2ulz, .{ .name = "__aeabi_f2ulz", .linkage = linkage }); - const __aeabi_d2ulz = @import("compiler_rt/fixunsdfdi.zig").__aeabi_d2ulz; + const __aeabi_d2ulz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2ulz; @export(__aeabi_d2ulz, .{ .name = "__aeabi_d2ulz", .linkage = linkage }); - const __aeabi_f2lz = @import("compiler_rt/fixsfdi.zig").__aeabi_f2lz; + const __aeabi_f2lz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2lz; @export(__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = linkage }); - const __aeabi_d2lz = @import("compiler_rt/fixdfdi.zig").__aeabi_d2lz; + const __aeabi_d2lz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2lz; @export(__aeabi_d2lz, .{ .name = "__aeabi_d2lz", .linkage = linkage }); - const __aeabi_d2uiz = @import("compiler_rt/fixunsdfsi.zig").__aeabi_d2uiz; + const __aeabi_d2uiz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2uiz; @export(__aeabi_d2uiz, .{ .name = "__aeabi_d2uiz", .linkage = linkage }); const __aeabi_h2f = @import("compiler_rt/extendXfYf2.zig").__aeabi_h2f; @@ -599,7 +648,7 @@ comptime { const __aeabi_f2h = @import("compiler_rt/truncXfYf2.zig").__aeabi_f2h; @export(__aeabi_f2h, .{ .name = "__aeabi_f2h", .linkage = linkage }); - const __aeabi_i2f = @import("compiler_rt/floatsiXf.zig").__aeabi_i2f; + const __aeabi_i2f = @import("compiler_rt/floatXiYf.zig").__aeabi_i2f; @export(__aeabi_i2f, .{ .name = "__aeabi_i2f", .linkage = linkage }); const __aeabi_d2f = @import("compiler_rt/truncXfYf2.zig").__aeabi_d2f; @export(__aeabi_d2f, .{ .name = "__aeabi_d2f", .linkage = linkage }); @@ -613,12 +662,12 @@ comptime { const __aeabi_dsub = @import("compiler_rt/addXf3.zig").__aeabi_dsub; @export(__aeabi_dsub, .{ .name = "__aeabi_dsub", .linkage = linkage }); - const __aeabi_f2uiz = @import("compiler_rt/fixunssfsi.zig").__aeabi_f2uiz; + const __aeabi_f2uiz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2uiz; @export(__aeabi_f2uiz, .{ .name = "__aeabi_f2uiz", .linkage = linkage }); - const __aeabi_f2iz = @import("compiler_rt/fixsfsi.zig").__aeabi_f2iz; + const __aeabi_f2iz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2iz; @export(__aeabi_f2iz, .{ .name = "__aeabi_f2iz", .linkage = linkage }); - const __aeabi_d2iz = @import("compiler_rt/fixdfsi.zig").__aeabi_d2iz; + const __aeabi_d2iz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2iz; @export(__aeabi_d2iz, .{ .name = "__aeabi_d2iz", .linkage = linkage }); const __aeabi_fdiv = @import("compiler_rt/divsf3.zig").__aeabi_fdiv; @@ -672,9 +721,13 @@ comptime { @export(_aullrem, .{ .name = "\x01__aullrem", .linkage = strong_linkage }); } - const fmodl = @import("compiler_rt/floatfmodl.zig").fmodl; if (!is_test) { @export(fmodl, .{ .name = "fmodl", .linkage = linkage }); + if (long_double_is_f128) { + @export(fmodl, .{ .name = "fmodq", .linkage = linkage }); + } else { + @export(fmodq, .{ .name = "fmodq", .linkage = linkage }); + } @export(floorf, .{ .name = "floorf", .linkage = linkage }); @export(floor, .{ .name = "floor", .linkage = linkage }); @@ -828,6 +881,14 @@ fn ceill(x: c_longdouble) callconv(.C) c_longdouble { return math.ceil(x); } +const fmodq = @import("compiler_rt/floatfmodq.zig").fmodq; +fn fmodl(x: c_longdouble, y: c_longdouble) callconv(.C) c_longdouble { + if (!long_double_is_f128) { + @panic("TODO implement this"); + } + return @floatCast(c_longdouble, fmodq(x, y)); +} + // Avoid dragging in the runtime safety mechanisms into this .o file, // unless we're trying to test this file. pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn { diff --git a/lib/std/special/compiler_rt/fixXfYi.zig b/lib/std/special/compiler_rt/fixXfYi.zig new file mode 100644 index 0000000000..01832ec56f --- /dev/null +++ b/lib/std/special/compiler_rt/fixXfYi.zig @@ -0,0 +1,224 @@ +const std = @import("std"); +const math = std.math; +const Log2Int = math.Log2Int; +const is_test = @import("builtin").is_test; + +pub inline fn fixXfYi(comptime I: type, a: anytype) I { + @setRuntimeSafety(is_test); + + const F = @TypeOf(a); + const float_bits = @typeInfo(F).Float.bits; + const int_bits = @typeInfo(I).Int.bits; + const rep_t = std.meta.Int(.unsigned, float_bits); + const sig_bits = math.floatMantissaBits(F); + const exp_bits = math.floatExponentBits(F); + const fractional_bits = math.floatFractionalBits(F); + + const implicit_bit = if (F != f80) (@as(rep_t, 1) << sig_bits) else 0; + const max_exp = (1 << (exp_bits - 1)); + const exp_bias = max_exp - 1; + const sig_mask = (@as(rep_t, 1) << sig_bits) - 1; + + // Break a into sign, exponent, significand + const a_rep: rep_t = @bitCast(rep_t, a); + const negative = (a_rep >> (float_bits - 1)) != 0; + const exponent = @intCast(i32, (a_rep << 1) >> (sig_bits + 1)) - exp_bias; + const significand: rep_t = (a_rep & sig_mask) | implicit_bit; + + // If the exponent is negative, the result rounds to zero. + if (exponent < 0) return 0; + + // If the value is too large for the integer type, saturate. + switch (@typeInfo(I).Int.signedness) { + .unsigned => { + if (negative) return 0; + if (@intCast(c_uint, exponent) >= @minimum(int_bits, max_exp)) return math.maxInt(I); + }, + .signed => if (@intCast(c_uint, exponent) >= @minimum(int_bits - 1, max_exp)) { + return if (negative) math.minInt(I) else math.maxInt(I); + }, + } + + // If 0 <= exponent < sig_bits, right shift to get the result. + // Otherwise, shift left. + var result: I = undefined; + if (exponent < fractional_bits) { + result = @intCast(I, significand >> @intCast(Log2Int(rep_t), fractional_bits - exponent)); + } else { + result = @intCast(I, significand) << @intCast(Log2Int(I), exponent - fractional_bits); + } + + if ((@typeInfo(I).Int.signedness == .signed) and negative) + return ~result +% 1; + return result; +} + +// Conversion from f16 + +pub fn __fixhfsi(a: f16) callconv(.C) i32 { + return fixXfYi(i32, a); +} + +pub fn __fixunshfsi(a: f16) callconv(.C) u32 { + return fixXfYi(u32, a); +} + +pub fn __fixhfdi(a: f16) callconv(.C) i64 { + return fixXfYi(i64, a); +} + +pub fn __fixunshfdi(a: f16) callconv(.C) u64 { + return fixXfYi(u64, a); +} + +pub fn __fixhfti(a: f16) callconv(.C) i128 { + return fixXfYi(i128, a); +} + +pub fn __fixunshfti(a: f16) callconv(.C) u128 { + return fixXfYi(u128, a); +} + +// Conversion from f32 + +pub fn __fixsfsi(a: f32) callconv(.C) i32 { + return fixXfYi(i32, a); +} + +pub fn __fixunssfsi(a: f32) callconv(.C) u32 { + return fixXfYi(u32, a); +} + +pub fn __fixsfdi(a: f32) callconv(.C) i64 { + return fixXfYi(i64, a); +} + +pub fn __fixunssfdi(a: f32) callconv(.C) u64 { + return fixXfYi(u64, a); +} + +pub fn __fixsfti(a: f32) callconv(.C) i128 { + return fixXfYi(i128, a); +} + +pub fn __fixunssfti(a: f32) callconv(.C) u128 { + return fixXfYi(u128, a); +} + +// Conversion from f64 + +pub fn __fixdfsi(a: f64) callconv(.C) i32 { + return fixXfYi(i32, a); +} + +pub fn __fixunsdfsi(a: f64) callconv(.C) u32 { + return fixXfYi(u32, a); +} + +pub fn __fixdfdi(a: f64) callconv(.C) i64 { + return fixXfYi(i64, a); +} + +pub fn __fixunsdfdi(a: f64) callconv(.C) u64 { + return fixXfYi(u64, a); +} + +pub fn __fixdfti(a: f64) callconv(.C) i128 { + return fixXfYi(i128, a); +} + +pub fn __fixunsdfti(a: f64) callconv(.C) u128 { + return fixXfYi(u128, a); +} + +// Conversion from f80 + +pub fn __fixxfsi(a: f80) callconv(.C) i32 { + return fixXfYi(i32, a); +} + +pub fn __fixunsxfsi(a: f80) callconv(.C) u32 { + return fixXfYi(u32, a); +} + +pub fn __fixxfdi(a: f80) callconv(.C) i64 { + return fixXfYi(i64, a); +} + +pub fn __fixunsxfdi(a: f80) callconv(.C) u64 { + return fixXfYi(u64, a); +} + +pub fn __fixxfti(a: f80) callconv(.C) i128 { + return fixXfYi(i128, a); +} + +pub fn __fixunsxfti(a: f80) callconv(.C) u128 { + return fixXfYi(u128, a); +} + +// Conversion from f128 + +pub fn __fixtfsi(a: f128) callconv(.C) i32 { + return fixXfYi(i32, a); +} + +pub fn __fixunstfsi(a: f128) callconv(.C) u32 { + return fixXfYi(u32, a); +} + +pub fn __fixtfdi(a: f128) callconv(.C) i64 { + return fixXfYi(i64, a); +} + +pub fn __fixunstfdi(a: f128) callconv(.C) u64 { + return fixXfYi(u64, a); +} + +pub fn __fixtfti(a: f128) callconv(.C) i128 { + return fixXfYi(i128, a); +} + +pub fn __fixunstfti(a: f128) callconv(.C) u128 { + return fixXfYi(u128, a); +} + +// Conversion from f32 + +pub fn __aeabi_f2iz(a: f32) callconv(.AAPCS) i32 { + return fixXfYi(i32, a); +} + +pub fn __aeabi_f2uiz(a: f32) callconv(.AAPCS) u32 { + return fixXfYi(u32, a); +} + +pub fn __aeabi_f2lz(a: f32) callconv(.AAPCS) i64 { + return fixXfYi(i64, a); +} + +pub fn __aeabi_f2ulz(a: f32) callconv(.AAPCS) u64 { + return fixXfYi(u64, a); +} + +// Conversion from f64 + +pub fn __aeabi_d2iz(a: f64) callconv(.AAPCS) i32 { + return fixXfYi(i32, a); +} + +pub fn __aeabi_d2uiz(a: f64) callconv(.AAPCS) u32 { + return fixXfYi(u32, a); +} + +pub fn __aeabi_d2lz(a: f64) callconv(.AAPCS) i64 { + return fixXfYi(i64, a); +} + +pub fn __aeabi_d2ulz(a: f64) callconv(.AAPCS) u64 { + return fixXfYi(u64, a); +} + +test { + _ = @import("fixXfYi_test.zig"); +} diff --git a/lib/std/special/compiler_rt/fixXfYi_test.zig b/lib/std/special/compiler_rt/fixXfYi_test.zig new file mode 100644 index 0000000000..00ed455609 --- /dev/null +++ b/lib/std/special/compiler_rt/fixXfYi_test.zig @@ -0,0 +1,948 @@ +const std = @import("std"); +const testing = std.testing; +const math = std.math; +const fixXfYi = @import("fixXfYi.zig").fixXfYi; + +// Conversion from f32 +const __fixsfsi = @import("fixXfYi.zig").__fixsfsi; +const __fixunssfsi = @import("fixXfYi.zig").__fixunssfsi; +const __fixsfdi = @import("fixXfYi.zig").__fixsfdi; +const __fixunssfdi = @import("fixXfYi.zig").__fixunssfdi; +const __fixsfti = @import("fixXfYi.zig").__fixsfti; +const __fixunssfti = @import("fixXfYi.zig").__fixunssfti; + +// Conversion from f64 +const __fixdfsi = @import("fixXfYi.zig").__fixdfsi; +const __fixunsdfsi = @import("fixXfYi.zig").__fixunsdfsi; +const __fixdfdi = @import("fixXfYi.zig").__fixdfdi; +const __fixunsdfdi = @import("fixXfYi.zig").__fixunsdfdi; +const __fixdfti = @import("fixXfYi.zig").__fixdfti; +const __fixunsdfti = @import("fixXfYi.zig").__fixunsdfti; + +// Conversion from f128 +const __fixtfsi = @import("fixXfYi.zig").__fixtfsi; +const __fixunstfsi = @import("fixXfYi.zig").__fixunstfsi; +const __fixtfdi = @import("fixXfYi.zig").__fixtfdi; +const __fixunstfdi = @import("fixXfYi.zig").__fixunstfdi; +const __fixtfti = @import("fixXfYi.zig").__fixtfti; +const __fixunstfti = @import("fixXfYi.zig").__fixunstfti; + +fn test__fixsfsi(a: f32, expected: i32) !void { + const x = __fixsfsi(a); + try testing.expect(x == expected); +} + +fn test__fixunssfsi(a: f32, expected: u32) !void { + const x = __fixunssfsi(a); + try testing.expect(x == expected); +} + +test "fixsfsi" { + try test__fixsfsi(-math.floatMax(f32), math.minInt(i32)); + + try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32)); + try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000); + + try test__fixsfsi(-0x1.0000000000000p+127, -0x80000000); + try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000); + try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000); + + try test__fixsfsi(-0x1.0000000000001p+63, -0x80000000); + try test__fixsfsi(-0x1.0000000000000p+63, -0x80000000); + try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000); + try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000); + + try test__fixsfsi(-0x1.FFFFFEp+62, -0x80000000); + try test__fixsfsi(-0x1.FFFFFCp+62, -0x80000000); + + try test__fixsfsi(-0x1.000000p+31, -0x80000000); + try test__fixsfsi(-0x1.FFFFFFp+30, -0x80000000); + try test__fixsfsi(-0x1.FFFFFEp+30, -0x7FFFFF80); + try test__fixsfsi(-0x1.FFFFFCp+30, -0x7FFFFF00); + + try test__fixsfsi(-2.01, -2); + try test__fixsfsi(-2.0, -2); + try test__fixsfsi(-1.99, -1); + try test__fixsfsi(-1.0, -1); + try test__fixsfsi(-0.99, 0); + try test__fixsfsi(-0.5, 0); + try test__fixsfsi(-math.floatMin(f32), 0); + try test__fixsfsi(0.0, 0); + try test__fixsfsi(math.floatMin(f32), 0); + try test__fixsfsi(0.5, 0); + try test__fixsfsi(0.99, 0); + try test__fixsfsi(1.0, 1); + try test__fixsfsi(1.5, 1); + try test__fixsfsi(1.99, 1); + try test__fixsfsi(2.0, 2); + try test__fixsfsi(2.01, 2); + + try test__fixsfsi(0x1.FFFFFCp+30, 0x7FFFFF00); + try test__fixsfsi(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixsfsi(0x1.FFFFFFp+30, 0x7FFFFFFF); + try test__fixsfsi(0x1.000000p+31, 0x7FFFFFFF); + + try test__fixsfsi(0x1.FFFFFCp+62, 0x7FFFFFFF); + try test__fixsfsi(0x1.FFFFFEp+62, 0x7FFFFFFF); + + try test__fixsfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF); + try test__fixsfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF); + try test__fixsfsi(0x1.0000000000000p+63, 0x7FFFFFFF); + try test__fixsfsi(0x1.0000000000001p+63, 0x7FFFFFFF); + + try test__fixsfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF); + try test__fixsfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF); + try test__fixsfsi(0x1.0000000000000p+127, 0x7FFFFFFF); + + try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF); + try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32)); + + try test__fixsfsi(math.floatMax(f32), math.maxInt(i32)); +} + +test "fixunssfsi" { + try test__fixunssfsi(0.0, 0); + + try test__fixunssfsi(0.5, 0); + try test__fixunssfsi(0.99, 0); + try test__fixunssfsi(1.0, 1); + try test__fixunssfsi(1.5, 1); + try test__fixunssfsi(1.99, 1); + try test__fixunssfsi(2.0, 2); + try test__fixunssfsi(2.01, 2); + try test__fixunssfsi(-0.5, 0); + try test__fixunssfsi(-0.99, 0); + + try test__fixunssfsi(-1.0, 0); + try test__fixunssfsi(-1.5, 0); + try test__fixunssfsi(-1.99, 0); + try test__fixunssfsi(-2.0, 0); + try test__fixunssfsi(-2.01, 0); + + try test__fixunssfsi(0x1.000000p+31, 0x80000000); + try test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF); + try test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00); + try test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00); + + try test__fixunssfsi(-0x1.FFFFFEp+30, 0); + try test__fixunssfsi(-0x1.FFFFFCp+30, 0); +} + +fn test__fixsfdi(a: f32, expected: i64) !void { + const x = __fixsfdi(a); + try testing.expect(x == expected); +} + +fn test__fixunssfdi(a: f32, expected: u64) !void { + const x = __fixunssfdi(a); + try testing.expect(x == expected); +} + +test "fixsfdi" { + try test__fixsfdi(-math.floatMax(f32), math.minInt(i64)); + + try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64)); + try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000); + + try test__fixsfdi(-0x1.0000000000000p+127, -0x8000000000000000); + try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000); + try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000); + + try test__fixsfdi(-0x1.0000000000001p+63, -0x8000000000000000); + try test__fixsfdi(-0x1.0000000000000p+63, -0x8000000000000000); + try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000); + try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000); + + try test__fixsfdi(-0x1.FFFFFFp+62, -0x8000000000000000); + try test__fixsfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000); + try test__fixsfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000); + + try test__fixsfdi(-2.01, -2); + try test__fixsfdi(-2.0, -2); + try test__fixsfdi(-1.99, -1); + try test__fixsfdi(-1.0, -1); + try test__fixsfdi(-0.99, 0); + try test__fixsfdi(-0.5, 0); + try test__fixsfdi(-math.floatMin(f32), 0); + try test__fixsfdi(0.0, 0); + try test__fixsfdi(math.floatMin(f32), 0); + try test__fixsfdi(0.5, 0); + try test__fixsfdi(0.99, 0); + try test__fixsfdi(1.0, 1); + try test__fixsfdi(1.5, 1); + try test__fixsfdi(1.99, 1); + try test__fixsfdi(2.0, 2); + try test__fixsfdi(2.01, 2); + + try test__fixsfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixsfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixsfdi(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF); + + try test__fixsfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF); + + try test__fixsfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF); + + try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF); + try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64)); + + try test__fixsfdi(math.floatMax(f32), math.maxInt(i64)); +} + +test "fixunssfdi" { + try test__fixunssfdi(0.0, 0); + + try test__fixunssfdi(0.5, 0); + try test__fixunssfdi(0.99, 0); + try test__fixunssfdi(1.0, 1); + try test__fixunssfdi(1.5, 1); + try test__fixunssfdi(1.99, 1); + try test__fixunssfdi(2.0, 2); + try test__fixunssfdi(2.01, 2); + try test__fixunssfdi(-0.5, 0); + try test__fixunssfdi(-0.99, 0); + + try test__fixunssfdi(-1.0, 0); + try test__fixunssfdi(-1.5, 0); + try test__fixunssfdi(-1.99, 0); + try test__fixunssfdi(-2.0, 0); + try test__fixunssfdi(-2.01, 0); + + try test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000); + try test__fixunssfdi(0x1.000000p+63, 0x8000000000000000); + try test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + + try test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000); + try test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000); +} + +fn test__fixsfti(a: f32, expected: i128) !void { + const x = __fixsfti(a); + try testing.expect(x == expected); +} + +fn test__fixunssfti(a: f32, expected: u128) !void { + const x = __fixunssfti(a); + try testing.expect(x == expected); +} + +test "fixsfti" { + try test__fixsfti(-math.floatMax(f32), math.minInt(i128)); + + try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128)); + try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000); + + try test__fixsfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000); + try test__fixsfti(-0x1.FFFFFFFFFFFFFp+126, -0x80000000000000000000000000000000); + try test__fixsfti(-0x1.FFFFFFFFFFFFEp+126, -0x80000000000000000000000000000000); + try test__fixsfti(-0x1.FFFFFF0000000p+126, -0x80000000000000000000000000000000); + try test__fixsfti(-0x1.FFFFFE0000000p+126, -0x7FFFFF80000000000000000000000000); + try test__fixsfti(-0x1.FFFFFC0000000p+126, -0x7FFFFF00000000000000000000000000); + + try test__fixsfti(-0x1.0000000000001p+63, -0x8000000000000000); + try test__fixsfti(-0x1.0000000000000p+63, -0x8000000000000000); + try test__fixsfti(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000); + try test__fixsfti(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000); + + try test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000); + try test__fixsfti(-0x1.FFFFFEp+62, -0x7fffff8000000000); + try test__fixsfti(-0x1.FFFFFCp+62, -0x7fffff0000000000); + + try test__fixsfti(-0x1.000000p+31, -0x80000000); + try test__fixsfti(-0x1.FFFFFFp+30, -0x80000000); + try test__fixsfti(-0x1.FFFFFEp+30, -0x7FFFFF80); + try test__fixsfti(-0x1.FFFFFCp+30, -0x7FFFFF00); + + try test__fixsfti(-2.01, -2); + try test__fixsfti(-2.0, -2); + try test__fixsfti(-1.99, -1); + try test__fixsfti(-1.0, -1); + try test__fixsfti(-0.99, 0); + try test__fixsfti(-0.5, 0); + try test__fixsfti(-math.floatMin(f32), 0); + try test__fixsfti(0.0, 0); + try test__fixsfti(math.floatMin(f32), 0); + try test__fixsfti(0.5, 0); + try test__fixsfti(0.99, 0); + try test__fixsfti(1.0, 1); + try test__fixsfti(1.5, 1); + try test__fixsfti(1.99, 1); + try test__fixsfti(2.0, 2); + try test__fixsfti(2.01, 2); + + try test__fixsfti(0x1.FFFFFCp+30, 0x7FFFFF00); + try test__fixsfti(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixsfti(0x1.FFFFFFp+30, 0x80000000); + try test__fixsfti(0x1.000000p+31, 0x80000000); + + try test__fixsfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixsfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixsfti(0x1.FFFFFFp+62, 0x8000000000000000); + + try test__fixsfti(0x1.FFFFFFFFFFFFEp+62, 0x8000000000000000); + try test__fixsfti(0x1.FFFFFFFFFFFFFp+62, 0x8000000000000000); + try test__fixsfti(0x1.0000000000000p+63, 0x8000000000000000); + try test__fixsfti(0x1.0000000000001p+63, 0x8000000000000000); + + try test__fixsfti(0x1.FFFFFC0000000p+126, 0x7FFFFF00000000000000000000000000); + try test__fixsfti(0x1.FFFFFE0000000p+126, 0x7FFFFF80000000000000000000000000); + try test__fixsfti(0x1.FFFFFF0000000p+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixsfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixsfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixsfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + + try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128)); + + try test__fixsfti(math.floatMax(f32), math.maxInt(i128)); +} + +test "fixunssfti" { + try test__fixunssfti(0.0, 0); + + try test__fixunssfti(0.5, 0); + try test__fixunssfti(0.99, 0); + try test__fixunssfti(1.0, 1); + try test__fixunssfti(1.5, 1); + try test__fixunssfti(1.99, 1); + try test__fixunssfti(2.0, 2); + try test__fixunssfti(2.01, 2); + try test__fixunssfti(-0.5, 0); + try test__fixunssfti(-0.99, 0); + + try test__fixunssfti(-1.0, 0); + try test__fixunssfti(-1.5, 0); + try test__fixunssfti(-1.99, 0); + try test__fixunssfti(-2.0, 0); + try test__fixunssfti(-2.01, 0); + + try test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000); + try test__fixunssfti(0x1.000000p+63, 0x8000000000000000); + try test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000); + try test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000); + try test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000); + try test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000); + + try test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000); + try test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000); + try test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000); + try test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000); + try test__fixunssfti(math.floatMax(f32), 0xffffff00000000000000000000000000); + try test__fixunssfti(math.inf(f32), math.maxInt(u128)); +} + +fn test__fixdfsi(a: f64, expected: i32) !void { + const x = __fixdfsi(a); + try testing.expect(x == expected); +} + +fn test__fixunsdfsi(a: f64, expected: u32) !void { + const x = __fixunsdfsi(a); + try testing.expect(x == expected); +} + +test "fixdfsi" { + try test__fixdfsi(-math.floatMax(f64), math.minInt(i32)); + + try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32)); + try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000); + + try test__fixdfsi(-0x1.0000000000000p+127, -0x80000000); + try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000); + try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000); + + try test__fixdfsi(-0x1.0000000000001p+63, -0x80000000); + try test__fixdfsi(-0x1.0000000000000p+63, -0x80000000); + try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000); + try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000); + + try test__fixdfsi(-0x1.FFFFFEp+62, -0x80000000); + try test__fixdfsi(-0x1.FFFFFCp+62, -0x80000000); + + try test__fixdfsi(-0x1.000000p+31, -0x80000000); + try test__fixdfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0); + try test__fixdfsi(-0x1.FFFFFEp+30, -0x7FFFFF80); + + try test__fixdfsi(-2.01, -2); + try test__fixdfsi(-2.0, -2); + try test__fixdfsi(-1.99, -1); + try test__fixdfsi(-1.0, -1); + try test__fixdfsi(-0.99, 0); + try test__fixdfsi(-0.5, 0); + try test__fixdfsi(-math.floatMin(f64), 0); + try test__fixdfsi(0.0, 0); + try test__fixdfsi(math.floatMin(f64), 0); + try test__fixdfsi(0.5, 0); + try test__fixdfsi(0.99, 0); + try test__fixdfsi(1.0, 1); + try test__fixdfsi(1.5, 1); + try test__fixdfsi(1.99, 1); + try test__fixdfsi(2.0, 2); + try test__fixdfsi(2.01, 2); + + try test__fixdfsi(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixdfsi(0x1.FFFFFFp+30, 0x7FFFFFC0); + try test__fixdfsi(0x1.000000p+31, 0x7FFFFFFF); + + try test__fixdfsi(0x1.FFFFFCp+62, 0x7FFFFFFF); + try test__fixdfsi(0x1.FFFFFEp+62, 0x7FFFFFFF); + + try test__fixdfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF); + try test__fixdfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF); + try test__fixdfsi(0x1.0000000000000p+63, 0x7FFFFFFF); + try test__fixdfsi(0x1.0000000000001p+63, 0x7FFFFFFF); + + try test__fixdfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF); + try test__fixdfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF); + try test__fixdfsi(0x1.0000000000000p+127, 0x7FFFFFFF); + + try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF); + try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32)); + + try test__fixdfsi(math.floatMax(f64), math.maxInt(i32)); +} + +test "fixunsdfsi" { + try test__fixunsdfsi(0.0, 0); + + try test__fixunsdfsi(0.5, 0); + try test__fixunsdfsi(0.99, 0); + try test__fixunsdfsi(1.0, 1); + try test__fixunsdfsi(1.5, 1); + try test__fixunsdfsi(1.99, 1); + try test__fixunsdfsi(2.0, 2); + try test__fixunsdfsi(2.01, 2); + try test__fixunsdfsi(-0.5, 0); + try test__fixunsdfsi(-0.99, 0); + try test__fixunsdfsi(-1.0, 0); + try test__fixunsdfsi(-1.5, 0); + try test__fixunsdfsi(-1.99, 0); + try test__fixunsdfsi(-2.0, 0); + try test__fixunsdfsi(-2.01, 0); + + try test__fixunsdfsi(0x1.000000p+31, 0x80000000); + try test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF); + try test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00); + try test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00); + + try test__fixunsdfsi(-0x1.FFFFFEp+30, 0); + try test__fixunsdfsi(-0x1.FFFFFCp+30, 0); + + try test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF); + try test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF); + try test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE); +} + +fn test__fixdfdi(a: f64, expected: i64) !void { + const x = __fixdfdi(a); + try testing.expect(x == expected); +} + +fn test__fixunsdfdi(a: f64, expected: u64) !void { + const x = __fixunsdfdi(a); + try testing.expect(x == expected); +} + +test "fixdfdi" { + try test__fixdfdi(-math.floatMax(f64), math.minInt(i64)); + + try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64)); + try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000); + + try test__fixdfdi(-0x1.0000000000000p+127, -0x8000000000000000); + try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000); + try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000); + + try test__fixdfdi(-0x1.0000000000001p+63, -0x8000000000000000); + try test__fixdfdi(-0x1.0000000000000p+63, -0x8000000000000000); + try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); + try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); + + try test__fixdfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000); + try test__fixdfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000); + + try test__fixdfdi(-2.01, -2); + try test__fixdfdi(-2.0, -2); + try test__fixdfdi(-1.99, -1); + try test__fixdfdi(-1.0, -1); + try test__fixdfdi(-0.99, 0); + try test__fixdfdi(-0.5, 0); + try test__fixdfdi(-math.floatMin(f64), 0); + try test__fixdfdi(0.0, 0); + try test__fixdfdi(math.floatMin(f64), 0); + try test__fixdfdi(0.5, 0); + try test__fixdfdi(0.99, 0); + try test__fixdfdi(1.0, 1); + try test__fixdfdi(1.5, 1); + try test__fixdfdi(1.99, 1); + try test__fixdfdi(2.0, 2); + try test__fixdfdi(2.01, 2); + + try test__fixdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + + try test__fixdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + try test__fixdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixdfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF); + try test__fixdfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF); + + try test__fixdfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF); + try test__fixdfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF); + try test__fixdfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF); + + try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF); + try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64)); + + try test__fixdfdi(math.floatMax(f64), math.maxInt(i64)); +} + +test "fixunsdfdi" { + try test__fixunsdfdi(0.0, 0); + try test__fixunsdfdi(0.5, 0); + try test__fixunsdfdi(0.99, 0); + try test__fixunsdfdi(1.0, 1); + try test__fixunsdfdi(1.5, 1); + try test__fixunsdfdi(1.99, 1); + try test__fixunsdfdi(2.0, 2); + try test__fixunsdfdi(2.01, 2); + try test__fixunsdfdi(-0.5, 0); + try test__fixunsdfdi(-0.99, 0); + try test__fixunsdfdi(-1.0, 0); + try test__fixunsdfdi(-1.5, 0); + try test__fixunsdfdi(-1.99, 0); + try test__fixunsdfdi(-2.0, 0); + try test__fixunsdfdi(-2.01, 0); + + try test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + + try test__fixunsdfdi(-0x1.FFFFFEp+62, 0); + try test__fixunsdfdi(-0x1.FFFFFCp+62, 0); + + try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800); + try test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000); + try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + + try test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0); + try test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0); +} + +fn test__fixdfti(a: f64, expected: i128) !void { + const x = __fixdfti(a); + try testing.expect(x == expected); +} + +fn test__fixunsdfti(a: f64, expected: u128) !void { + const x = __fixunsdfti(a); + try testing.expect(x == expected); +} + +test "fixdfti" { + try test__fixdfti(-math.floatMax(f64), math.minInt(i128)); + + try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128)); + try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000); + + try test__fixdfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000); + try test__fixdfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000); + try test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000); + + try test__fixdfti(-0x1.0000000000001p+63, -0x8000000000000800); + try test__fixdfti(-0x1.0000000000000p+63, -0x8000000000000000); + try test__fixdfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); + try test__fixdfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); + + try test__fixdfti(-0x1.FFFFFEp+62, -0x7fffff8000000000); + try test__fixdfti(-0x1.FFFFFCp+62, -0x7fffff0000000000); + + try test__fixdfti(-2.01, -2); + try test__fixdfti(-2.0, -2); + try test__fixdfti(-1.99, -1); + try test__fixdfti(-1.0, -1); + try test__fixdfti(-0.99, 0); + try test__fixdfti(-0.5, 0); + try test__fixdfti(-math.floatMin(f64), 0); + try test__fixdfti(0.0, 0); + try test__fixdfti(math.floatMin(f64), 0); + try test__fixdfti(0.5, 0); + try test__fixdfti(0.99, 0); + try test__fixdfti(1.0, 1); + try test__fixdfti(1.5, 1); + try test__fixdfti(1.99, 1); + try test__fixdfti(2.0, 2); + try test__fixdfti(2.01, 2); + + try test__fixdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + + try test__fixdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + try test__fixdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixdfti(0x1.0000000000000p+63, 0x8000000000000000); + try test__fixdfti(0x1.0000000000001p+63, 0x8000000000000800); + + try test__fixdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000); + try test__fixdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000); + try test__fixdfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + + try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128)); + + try test__fixdfti(math.floatMax(f64), math.maxInt(i128)); +} + +test "fixunsdfti" { + try test__fixunsdfti(0.0, 0); + + try test__fixunsdfti(0.5, 0); + try test__fixunsdfti(0.99, 0); + try test__fixunsdfti(1.0, 1); + try test__fixunsdfti(1.5, 1); + try test__fixunsdfti(1.99, 1); + try test__fixunsdfti(2.0, 2); + try test__fixunsdfti(2.01, 2); + try test__fixunsdfti(-0.5, 0); + try test__fixunsdfti(-0.99, 0); + try test__fixunsdfti(-1.0, 0); + try test__fixunsdfti(-1.5, 0); + try test__fixunsdfti(-1.99, 0); + try test__fixunsdfti(-2.0, 0); + try test__fixunsdfti(-2.01, 0); + + try test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + + try test__fixunsdfti(-0x1.FFFFFEp+62, 0); + try test__fixunsdfti(-0x1.FFFFFCp+62, 0); + + try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800); + try test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000); + try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + + try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000); + try test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000); + try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000); + try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000); + try test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + + try test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0); + try test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0); +} + +fn test__fixtfsi(a: f128, expected: i32) !void { + const x = __fixtfsi(a); + try testing.expect(x == expected); +} + +fn test__fixunstfsi(a: f128, expected: u32) !void { + const x = __fixunstfsi(a); + try testing.expect(x == expected); +} + +test "fixtfsi" { + try test__fixtfsi(-math.floatMax(f128), math.minInt(i32)); + + try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32)); + try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000); + + try test__fixtfsi(-0x1.0000000000000p+127, -0x80000000); + try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000); + try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000); + + try test__fixtfsi(-0x1.0000000000001p+63, -0x80000000); + try test__fixtfsi(-0x1.0000000000000p+63, -0x80000000); + try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000); + try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000); + + try test__fixtfsi(-0x1.FFFFFEp+62, -0x80000000); + try test__fixtfsi(-0x1.FFFFFCp+62, -0x80000000); + + try test__fixtfsi(-0x1.000000p+31, -0x80000000); + try test__fixtfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0); + try test__fixtfsi(-0x1.FFFFFEp+30, -0x7FFFFF80); + try test__fixtfsi(-0x1.FFFFFCp+30, -0x7FFFFF00); + + try test__fixtfsi(-2.01, -2); + try test__fixtfsi(-2.0, -2); + try test__fixtfsi(-1.99, -1); + try test__fixtfsi(-1.0, -1); + try test__fixtfsi(-0.99, 0); + try test__fixtfsi(-0.5, 0); + try test__fixtfsi(-math.floatMin(f32), 0); + try test__fixtfsi(0.0, 0); + try test__fixtfsi(math.floatMin(f32), 0); + try test__fixtfsi(0.5, 0); + try test__fixtfsi(0.99, 0); + try test__fixtfsi(1.0, 1); + try test__fixtfsi(1.5, 1); + try test__fixtfsi(1.99, 1); + try test__fixtfsi(2.0, 2); + try test__fixtfsi(2.01, 2); + + try test__fixtfsi(0x1.FFFFFCp+30, 0x7FFFFF00); + try test__fixtfsi(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixtfsi(0x1.FFFFFFp+30, 0x7FFFFFC0); + try test__fixtfsi(0x1.000000p+31, 0x7FFFFFFF); + + try test__fixtfsi(0x1.FFFFFCp+62, 0x7FFFFFFF); + try test__fixtfsi(0x1.FFFFFEp+62, 0x7FFFFFFF); + + try test__fixtfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF); + try test__fixtfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF); + try test__fixtfsi(0x1.0000000000000p+63, 0x7FFFFFFF); + try test__fixtfsi(0x1.0000000000001p+63, 0x7FFFFFFF); + + try test__fixtfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF); + try test__fixtfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF); + try test__fixtfsi(0x1.0000000000000p+127, 0x7FFFFFFF); + + try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF); + try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32)); + + try test__fixtfsi(math.floatMax(f128), math.maxInt(i32)); +} + +test "fixunstfsi" { + try test__fixunstfsi(math.inf(f128), 0xffffffff); + try test__fixunstfsi(0, 0x0); + try test__fixunstfsi(0x1.23456789abcdefp+5, 0x24); + try test__fixunstfsi(0x1.23456789abcdefp-3, 0x0); + try test__fixunstfsi(0x1.23456789abcdefp+20, 0x123456); + try test__fixunstfsi(0x1.23456789abcdefp+40, 0xffffffff); + try test__fixunstfsi(0x1.23456789abcdefp+256, 0xffffffff); + try test__fixunstfsi(-0x1.23456789abcdefp+3, 0x0); + + try test__fixunstfsi(0x1p+32, 0xFFFFFFFF); +} + +fn test__fixtfdi(a: f128, expected: i64) !void { + const x = __fixtfdi(a); + try testing.expect(x == expected); +} + +fn test__fixunstfdi(a: f128, expected: u64) !void { + const x = __fixunstfdi(a); + try testing.expect(x == expected); +} + +test "fixtfdi" { + try test__fixtfdi(-math.floatMax(f128), math.minInt(i64)); + + try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64)); + try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000); + + try test__fixtfdi(-0x1.0000000000000p+127, -0x8000000000000000); + try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000); + try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000); + + try test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000); + try test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000); + try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); + try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); + + try test__fixtfdi(-0x1.FFFFFEp+62, -0x7FFFFF8000000000); + try test__fixtfdi(-0x1.FFFFFCp+62, -0x7FFFFF0000000000); + + try test__fixtfdi(-0x1.000000p+31, -0x80000000); + try test__fixtfdi(-0x1.FFFFFFp+30, -0x7FFFFFC0); + try test__fixtfdi(-0x1.FFFFFEp+30, -0x7FFFFF80); + try test__fixtfdi(-0x1.FFFFFCp+30, -0x7FFFFF00); + + try test__fixtfdi(-2.01, -2); + try test__fixtfdi(-2.0, -2); + try test__fixtfdi(-1.99, -1); + try test__fixtfdi(-1.0, -1); + try test__fixtfdi(-0.99, 0); + try test__fixtfdi(-0.5, 0); + try test__fixtfdi(-math.floatMin(f64), 0); + try test__fixtfdi(0.0, 0); + try test__fixtfdi(math.floatMin(f64), 0); + try test__fixtfdi(0.5, 0); + try test__fixtfdi(0.99, 0); + try test__fixtfdi(1.0, 1); + try test__fixtfdi(1.5, 1); + try test__fixtfdi(1.99, 1); + try test__fixtfdi(2.0, 2); + try test__fixtfdi(2.01, 2); + + try test__fixtfdi(0x1.FFFFFCp+30, 0x7FFFFF00); + try test__fixtfdi(0x1.FFFFFEp+30, 0x7FFFFF80); + try test__fixtfdi(0x1.FFFFFFp+30, 0x7FFFFFC0); + try test__fixtfdi(0x1.000000p+31, 0x80000000); + + try test__fixtfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixtfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + + try test__fixtfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + try test__fixtfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixtfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF); + try test__fixtfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF); + + try test__fixtfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF); + try test__fixtfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF); + try test__fixtfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF); + + try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF); + try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64)); + + try test__fixtfdi(math.floatMax(f128), math.maxInt(i64)); +} + +test "fixunstfdi" { + try test__fixunstfdi(0.0, 0); + + try test__fixunstfdi(0.5, 0); + try test__fixunstfdi(0.99, 0); + try test__fixunstfdi(1.0, 1); + try test__fixunstfdi(1.5, 1); + try test__fixunstfdi(1.99, 1); + try test__fixunstfdi(2.0, 2); + try test__fixunstfdi(2.01, 2); + try test__fixunstfdi(-0.5, 0); + try test__fixunstfdi(-0.99, 0); + try test__fixunstfdi(-1.0, 0); + try test__fixunstfdi(-1.5, 0); + try test__fixunstfdi(-1.99, 0); + try test__fixunstfdi(-2.0, 0); + try test__fixunstfdi(-2.01, 0); + + try test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + try test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + + try test__fixunstfdi(-0x1.FFFFFEp+62, 0); + try test__fixunstfdi(-0x1.FFFFFCp+62, 0); + + try test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + + try test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0); + try test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0); + + try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF); + try test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001); + try test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000); + try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF); + try test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE); + try test__fixunstfdi(0x1p+64, 0xFFFFFFFFFFFFFFFF); + + try test__fixunstfdi(-0x1.0000000000000000p+63, 0); + try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0); + try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0); +} + +fn test__fixtfti(a: f128, expected: i128) !void { + const x = __fixtfti(a); + try testing.expect(x == expected); +} + +fn test__fixunstfti(a: f128, expected: u128) !void { + const x = __fixunstfti(a); + try testing.expect(x == expected); +} + +test "fixtfti" { + try test__fixtfti(-math.floatMax(f128), math.minInt(i128)); + + try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128)); + try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000); + + try test__fixtfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000); + try test__fixtfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000); + try test__fixtfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000); + + try test__fixtfti(-0x1.0000000000001p+63, -0x8000000000000800); + try test__fixtfti(-0x1.0000000000000p+63, -0x8000000000000000); + try test__fixtfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); + try test__fixtfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); + + try test__fixtfti(-0x1.FFFFFEp+62, -0x7fffff8000000000); + try test__fixtfti(-0x1.FFFFFCp+62, -0x7fffff0000000000); + + try test__fixtfti(-2.01, -2); + try test__fixtfti(-2.0, -2); + try test__fixtfti(-1.99, -1); + try test__fixtfti(-1.0, -1); + try test__fixtfti(-0.99, 0); + try test__fixtfti(-0.5, 0); + try test__fixtfti(-math.floatMin(f128), 0); + try test__fixtfti(0.0, 0); + try test__fixtfti(math.floatMin(f128), 0); + try test__fixtfti(0.5, 0); + try test__fixtfti(0.99, 0); + try test__fixtfti(1.0, 1); + try test__fixtfti(1.5, 1); + try test__fixtfti(1.99, 1); + try test__fixtfti(2.0, 2); + try test__fixtfti(2.01, 2); + + try test__fixtfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); + try test__fixtfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); + + try test__fixtfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); + try test__fixtfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); + try test__fixtfti(0x1.0000000000000p+63, 0x8000000000000000); + try test__fixtfti(0x1.0000000000001p+63, 0x8000000000000800); + + try test__fixtfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000); + try test__fixtfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000); + try test__fixtfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + + try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); + try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128)); + + try test__fixtfti(math.floatMax(f128), math.maxInt(i128)); +} + +test "fixunstfti" { + try test__fixunstfti(math.inf(f128), 0xffffffffffffffffffffffffffffffff); + + try test__fixunstfti(0.0, 0); + + try test__fixunstfti(0.5, 0); + try test__fixunstfti(0.99, 0); + try test__fixunstfti(1.0, 1); + try test__fixunstfti(1.5, 1); + try test__fixunstfti(1.99, 1); + try test__fixunstfti(2.0, 2); + try test__fixunstfti(2.01, 2); + try test__fixunstfti(-0.01, 0); + try test__fixunstfti(-0.99, 0); + + try test__fixunstfti(0x1p+128, 0xffffffffffffffffffffffffffffffff); + + try test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000); + try test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000); + try test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff); + try test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff); +} + +fn test__fixunshfti(a: f16, expected: u128) !void { + const x = fixXfYi(u128, a); + try testing.expect(x == expected); +} + +test "fixXfYi for f16" { + try test__fixunshfti(math.inf(f16), math.maxInt(u128)); + try test__fixunshfti(math.floatMax(f16), 65504); +} + +fn test__fixunsxfti(a: f80, expected: u128) !void { + const x = fixXfYi(u128, a); + try testing.expect(x == expected); +} + +test "fixXfYi for f80" { + try test__fixunsxfti(math.inf(f80), math.maxInt(u128)); + try test__fixunsxfti(math.floatMax(f80), math.maxInt(u128)); + try test__fixunsxfti(math.maxInt(u64), math.maxInt(u64)); +} diff --git a/lib/std/special/compiler_rt/fixdfdi.zig b/lib/std/special/compiler_rt/fixdfdi.zig deleted file mode 100644 index 6c69f10e09..0000000000 --- a/lib/std/special/compiler_rt/fixdfdi.zig +++ /dev/null @@ -1,16 +0,0 @@ -const fixint = @import("fixint.zig").fixint; -const builtin = @import("builtin"); - -pub fn __fixdfdi(a: f64) callconv(.C) i64 { - @setRuntimeSafety(builtin.is_test); - return fixint(f64, i64, a); -} - -pub fn __aeabi_d2lz(arg: f64) callconv(.AAPCS) i64 { - @setRuntimeSafety(false); - return @call(.{ .modifier = .always_inline }, __fixdfdi, .{arg}); -} - -test { - _ = @import("fixdfdi_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixdfdi_test.zig b/lib/std/special/compiler_rt/fixdfdi_test.zig deleted file mode 100644 index e80a875800..0000000000 --- a/lib/std/special/compiler_rt/fixdfdi_test.zig +++ /dev/null @@ -1,62 +0,0 @@ -const __fixdfdi = @import("fixdfdi.zig").__fixdfdi; -const std = @import("std"); -const math = std.math; -const testing = std.testing; - -fn test__fixdfdi(a: f64, expected: i64) !void { - const x = __fixdfdi(a); - try testing.expect(x == expected); -} - -test "fixdfdi" { - try test__fixdfdi(-math.floatMax(f64), math.minInt(i64)); - - try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64)); - try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000); - - try test__fixdfdi(-0x1.0000000000000p+127, -0x8000000000000000); - try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000); - try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000); - - try test__fixdfdi(-0x1.0000000000001p+63, -0x8000000000000000); - try test__fixdfdi(-0x1.0000000000000p+63, -0x8000000000000000); - try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); - try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); - - try test__fixdfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000); - try test__fixdfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000); - - try test__fixdfdi(-2.01, -2); - try test__fixdfdi(-2.0, -2); - try test__fixdfdi(-1.99, -1); - try test__fixdfdi(-1.0, -1); - try test__fixdfdi(-0.99, 0); - try test__fixdfdi(-0.5, 0); - try test__fixdfdi(-math.floatMin(f64), 0); - try test__fixdfdi(0.0, 0); - try test__fixdfdi(math.floatMin(f64), 0); - try test__fixdfdi(0.5, 0); - try test__fixdfdi(0.99, 0); - try test__fixdfdi(1.0, 1); - try test__fixdfdi(1.5, 1); - try test__fixdfdi(1.99, 1); - try test__fixdfdi(2.0, 2); - try test__fixdfdi(2.01, 2); - - try test__fixdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - try test__fixdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - - try test__fixdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - try test__fixdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - try test__fixdfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF); - try test__fixdfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF); - - try test__fixdfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF); - try test__fixdfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF); - try test__fixdfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF); - - try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF); - try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64)); - - try test__fixdfdi(math.floatMax(f64), math.maxInt(i64)); -} diff --git a/lib/std/special/compiler_rt/fixdfsi.zig b/lib/std/special/compiler_rt/fixdfsi.zig deleted file mode 100644 index 5842d99cd3..0000000000 --- a/lib/std/special/compiler_rt/fixdfsi.zig +++ /dev/null @@ -1,16 +0,0 @@ -const fixint = @import("fixint.zig").fixint; -const builtin = @import("builtin"); - -pub fn __fixdfsi(a: f64) callconv(.C) i32 { - @setRuntimeSafety(builtin.is_test); - return fixint(f64, i32, a); -} - -pub fn __aeabi_d2iz(a: f64) callconv(.AAPCS) i32 { - @setRuntimeSafety(false); - return @call(.{ .modifier = .always_inline }, __fixdfsi, .{a}); -} - -test { - _ = @import("fixdfsi_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixdfsi_test.zig b/lib/std/special/compiler_rt/fixdfsi_test.zig deleted file mode 100644 index a1e76a6ee4..0000000000 --- a/lib/std/special/compiler_rt/fixdfsi_test.zig +++ /dev/null @@ -1,70 +0,0 @@ -const __fixdfsi = @import("fixdfsi.zig").__fixdfsi; -const std = @import("std"); -const math = std.math; -const testing = std.testing; - -fn test__fixdfsi(a: f64, expected: i32) !void { - const x = __fixdfsi(a); - try testing.expect(x == expected); -} - -test "fixdfsi" { - try test__fixdfsi(-math.floatMax(f64), math.minInt(i32)); - - try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32)); - try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000); - - try test__fixdfsi(-0x1.0000000000000p+127, -0x80000000); - try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000); - try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000); - - try test__fixdfsi(-0x1.0000000000001p+63, -0x80000000); - try test__fixdfsi(-0x1.0000000000000p+63, -0x80000000); - try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000); - try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000); - - try test__fixdfsi(-0x1.FFFFFEp+62, -0x80000000); - try test__fixdfsi(-0x1.FFFFFCp+62, -0x80000000); - - try test__fixdfsi(-0x1.000000p+31, -0x80000000); - try test__fixdfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0); - try test__fixdfsi(-0x1.FFFFFEp+30, -0x7FFFFF80); - - try test__fixdfsi(-2.01, -2); - try test__fixdfsi(-2.0, -2); - try test__fixdfsi(-1.99, -1); - try test__fixdfsi(-1.0, -1); - try test__fixdfsi(-0.99, 0); - try test__fixdfsi(-0.5, 0); - try test__fixdfsi(-math.floatMin(f64), 0); - try test__fixdfsi(0.0, 0); - try test__fixdfsi(math.floatMin(f64), 0); - try test__fixdfsi(0.5, 0); - try test__fixdfsi(0.99, 0); - try test__fixdfsi(1.0, 1); - try test__fixdfsi(1.5, 1); - try test__fixdfsi(1.99, 1); - try test__fixdfsi(2.0, 2); - try test__fixdfsi(2.01, 2); - - try test__fixdfsi(0x1.FFFFFEp+30, 0x7FFFFF80); - try test__fixdfsi(0x1.FFFFFFp+30, 0x7FFFFFC0); - try test__fixdfsi(0x1.000000p+31, 0x7FFFFFFF); - - try test__fixdfsi(0x1.FFFFFCp+62, 0x7FFFFFFF); - try test__fixdfsi(0x1.FFFFFEp+62, 0x7FFFFFFF); - - try test__fixdfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF); - try test__fixdfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF); - try test__fixdfsi(0x1.0000000000000p+63, 0x7FFFFFFF); - try test__fixdfsi(0x1.0000000000001p+63, 0x7FFFFFFF); - - try test__fixdfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF); - try test__fixdfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF); - try test__fixdfsi(0x1.0000000000000p+127, 0x7FFFFFFF); - - try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF); - try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32)); - - try test__fixdfsi(math.floatMax(f64), math.maxInt(i32)); -} diff --git a/lib/std/special/compiler_rt/fixdfti.zig b/lib/std/special/compiler_rt/fixdfti.zig deleted file mode 100644 index e8af6a2daf..0000000000 --- a/lib/std/special/compiler_rt/fixdfti.zig +++ /dev/null @@ -1,11 +0,0 @@ -const fixint = @import("fixint.zig").fixint; -const builtin = @import("builtin"); - -pub fn __fixdfti(a: f64) callconv(.C) i128 { - @setRuntimeSafety(builtin.is_test); - return fixint(f64, i128, a); -} - -test { - _ = @import("fixdfti_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixdfti_test.zig b/lib/std/special/compiler_rt/fixdfti_test.zig deleted file mode 100644 index cc6eec6b23..0000000000 --- a/lib/std/special/compiler_rt/fixdfti_test.zig +++ /dev/null @@ -1,62 +0,0 @@ -const __fixdfti = @import("fixdfti.zig").__fixdfti; -const std = @import("std"); -const math = std.math; -const testing = std.testing; - -fn test__fixdfti(a: f64, expected: i128) !void { - const x = __fixdfti(a); - try testing.expect(x == expected); -} - -test "fixdfti" { - try test__fixdfti(-math.floatMax(f64), math.minInt(i128)); - - try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128)); - try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000); - - try test__fixdfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000); - try test__fixdfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000); - try test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000); - - try test__fixdfti(-0x1.0000000000001p+63, -0x8000000000000800); - try test__fixdfti(-0x1.0000000000000p+63, -0x8000000000000000); - try test__fixdfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); - try test__fixdfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); - - try test__fixdfti(-0x1.FFFFFEp+62, -0x7fffff8000000000); - try test__fixdfti(-0x1.FFFFFCp+62, -0x7fffff0000000000); - - try test__fixdfti(-2.01, -2); - try test__fixdfti(-2.0, -2); - try test__fixdfti(-1.99, -1); - try test__fixdfti(-1.0, -1); - try test__fixdfti(-0.99, 0); - try test__fixdfti(-0.5, 0); - try test__fixdfti(-math.floatMin(f64), 0); - try test__fixdfti(0.0, 0); - try test__fixdfti(math.floatMin(f64), 0); - try test__fixdfti(0.5, 0); - try test__fixdfti(0.99, 0); - try test__fixdfti(1.0, 1); - try test__fixdfti(1.5, 1); - try test__fixdfti(1.99, 1); - try test__fixdfti(2.0, 2); - try test__fixdfti(2.01, 2); - - try test__fixdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - try test__fixdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - - try test__fixdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - try test__fixdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - try test__fixdfti(0x1.0000000000000p+63, 0x8000000000000000); - try test__fixdfti(0x1.0000000000001p+63, 0x8000000000000800); - - try test__fixdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000); - try test__fixdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000); - try test__fixdfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - - try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128)); - - try test__fixdfti(math.floatMax(f64), math.maxInt(i128)); -} diff --git a/lib/std/special/compiler_rt/fixint.zig b/lib/std/special/compiler_rt/fixint.zig deleted file mode 100644 index ff0577c115..0000000000 --- a/lib/std/special/compiler_rt/fixint.zig +++ /dev/null @@ -1,75 +0,0 @@ -const is_test = @import("builtin").is_test; -const std = @import("std"); -const math = std.math; -const Log2Int = std.math.Log2Int; -const maxInt = std.math.maxInt; -const minInt = std.math.minInt; - -const DBG = false; - -pub fn fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t) fixint_t { - @setRuntimeSafety(is_test); - - const rep_t = switch (fp_t) { - f32 => u32, - f64 => u64, - f128 => u128, - else => unreachable, - }; - const significandBits = switch (fp_t) { - f32 => 23, - f64 => 52, - f128 => 112, - else => unreachable, - }; - - const typeWidth = @typeInfo(rep_t).Int.bits; - const exponentBits = (typeWidth - significandBits - 1); - const signBit = (@as(rep_t, 1) << (significandBits + exponentBits)); - const maxExponent = ((1 << exponentBits) - 1); - const exponentBias = (maxExponent >> 1); - - const implicitBit = (@as(rep_t, 1) << significandBits); - const significandMask = (implicitBit - 1); - - // Break a into sign, exponent, significand - const aRep: rep_t = @bitCast(rep_t, a); - const absMask = signBit - 1; - const aAbs: rep_t = aRep & absMask; - - const negative = (aRep & signBit) != 0; - const exponent = @intCast(i32, aAbs >> significandBits) - exponentBias; - const significand: rep_t = (aAbs & significandMask) | implicitBit; - - // If exponent is negative, the uint_result is zero. - if (exponent < 0) return 0; - - // The unsigned result needs to be large enough to handle an fixint_t or rep_t - const fixint_bits = @typeInfo(fixint_t).Int.bits; - const fixuint_t = std.meta.Int(.unsigned, fixint_bits); - const UintResultType = if (fixint_bits > typeWidth) fixuint_t else rep_t; - var uint_result: UintResultType = undefined; - - // If the value is too large for the integer type, saturate. - if (@intCast(usize, exponent) >= fixint_bits) { - return if (negative) @as(fixint_t, minInt(fixint_t)) else @as(fixint_t, maxInt(fixint_t)); - } - - // If 0 <= exponent < significandBits, right shift else left shift - if (exponent < significandBits) { - uint_result = @intCast(UintResultType, significand) >> @intCast(Log2Int(UintResultType), significandBits - exponent); - } else { - uint_result = @intCast(UintResultType, significand) << @intCast(Log2Int(UintResultType), exponent - significandBits); - } - - // Cast to final signed result - if (negative) { - return if (uint_result >= -math.minInt(fixint_t)) math.minInt(fixint_t) else -@intCast(fixint_t, uint_result); - } else { - return if (uint_result >= math.maxInt(fixint_t)) math.maxInt(fixint_t) else @intCast(fixint_t, uint_result); - } -} - -test { - _ = @import("fixint_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixsfdi.zig b/lib/std/special/compiler_rt/fixsfdi.zig deleted file mode 100644 index 64961075d0..0000000000 --- a/lib/std/special/compiler_rt/fixsfdi.zig +++ /dev/null @@ -1,16 +0,0 @@ -const fixint = @import("fixint.zig").fixint; -const builtin = @import("builtin"); - -pub fn __fixsfdi(a: f32) callconv(.C) i64 { - @setRuntimeSafety(builtin.is_test); - return fixint(f32, i64, a); -} - -pub fn __aeabi_f2lz(arg: f32) callconv(.AAPCS) i64 { - @setRuntimeSafety(false); - return @call(.{ .modifier = .always_inline }, __fixsfdi, .{arg}); -} - -test { - _ = @import("fixsfdi_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixsfdi_test.zig b/lib/std/special/compiler_rt/fixsfdi_test.zig deleted file mode 100644 index 1ddd99bbe8..0000000000 --- a/lib/std/special/compiler_rt/fixsfdi_test.zig +++ /dev/null @@ -1,64 +0,0 @@ -const __fixsfdi = @import("fixsfdi.zig").__fixsfdi; -const std = @import("std"); -const math = std.math; -const testing = std.testing; - -fn test__fixsfdi(a: f32, expected: i64) !void { - const x = __fixsfdi(a); - try testing.expect(x == expected); -} - -test "fixsfdi" { - try test__fixsfdi(-math.floatMax(f32), math.minInt(i64)); - - try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64)); - try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000); - - try test__fixsfdi(-0x1.0000000000000p+127, -0x8000000000000000); - try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000); - try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000); - - try test__fixsfdi(-0x1.0000000000001p+63, -0x8000000000000000); - try test__fixsfdi(-0x1.0000000000000p+63, -0x8000000000000000); - try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000); - try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000); - - try test__fixsfdi(-0x1.FFFFFFp+62, -0x8000000000000000); - try test__fixsfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000); - try test__fixsfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000); - - try test__fixsfdi(-2.01, -2); - try test__fixsfdi(-2.0, -2); - try test__fixsfdi(-1.99, -1); - try test__fixsfdi(-1.0, -1); - try test__fixsfdi(-0.99, 0); - try test__fixsfdi(-0.5, 0); - try test__fixsfdi(-math.floatMin(f32), 0); - try test__fixsfdi(0.0, 0); - try test__fixsfdi(math.floatMin(f32), 0); - try test__fixsfdi(0.5, 0); - try test__fixsfdi(0.99, 0); - try test__fixsfdi(1.0, 1); - try test__fixsfdi(1.5, 1); - try test__fixsfdi(1.99, 1); - try test__fixsfdi(2.0, 2); - try test__fixsfdi(2.01, 2); - - try test__fixsfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - try test__fixsfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - try test__fixsfdi(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF); - - try test__fixsfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF); - try test__fixsfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF); - try test__fixsfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF); - try test__fixsfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF); - - try test__fixsfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF); - try test__fixsfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF); - try test__fixsfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF); - - try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF); - try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64)); - - try test__fixsfdi(math.floatMax(f32), math.maxInt(i64)); -} diff --git a/lib/std/special/compiler_rt/fixsfsi.zig b/lib/std/special/compiler_rt/fixsfsi.zig deleted file mode 100644 index 932a6e1a4f..0000000000 --- a/lib/std/special/compiler_rt/fixsfsi.zig +++ /dev/null @@ -1,16 +0,0 @@ -const fixint = @import("fixint.zig").fixint; -const builtin = @import("builtin"); - -pub fn __fixsfsi(a: f32) callconv(.C) i32 { - @setRuntimeSafety(builtin.is_test); - return fixint(f32, i32, a); -} - -pub fn __aeabi_f2iz(a: f32) callconv(.AAPCS) i32 { - @setRuntimeSafety(false); - return @call(.{ .modifier = .always_inline }, __fixsfsi, .{a}); -} - -test { - _ = @import("fixsfsi_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixsfsi_test.zig b/lib/std/special/compiler_rt/fixsfsi_test.zig deleted file mode 100644 index 2393cc388e..0000000000 --- a/lib/std/special/compiler_rt/fixsfsi_test.zig +++ /dev/null @@ -1,72 +0,0 @@ -const __fixsfsi = @import("fixsfsi.zig").__fixsfsi; -const std = @import("std"); -const math = std.math; -const testing = std.testing; - -fn test__fixsfsi(a: f32, expected: i32) !void { - const x = __fixsfsi(a); - try testing.expect(x == expected); -} - -test "fixsfsi" { - try test__fixsfsi(-math.floatMax(f32), math.minInt(i32)); - - try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32)); - try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000); - - try test__fixsfsi(-0x1.0000000000000p+127, -0x80000000); - try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000); - try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000); - - try test__fixsfsi(-0x1.0000000000001p+63, -0x80000000); - try test__fixsfsi(-0x1.0000000000000p+63, -0x80000000); - try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000); - try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000); - - try test__fixsfsi(-0x1.FFFFFEp+62, -0x80000000); - try test__fixsfsi(-0x1.FFFFFCp+62, -0x80000000); - - try test__fixsfsi(-0x1.000000p+31, -0x80000000); - try test__fixsfsi(-0x1.FFFFFFp+30, -0x80000000); - try test__fixsfsi(-0x1.FFFFFEp+30, -0x7FFFFF80); - try test__fixsfsi(-0x1.FFFFFCp+30, -0x7FFFFF00); - - try test__fixsfsi(-2.01, -2); - try test__fixsfsi(-2.0, -2); - try test__fixsfsi(-1.99, -1); - try test__fixsfsi(-1.0, -1); - try test__fixsfsi(-0.99, 0); - try test__fixsfsi(-0.5, 0); - try test__fixsfsi(-math.floatMin(f32), 0); - try test__fixsfsi(0.0, 0); - try test__fixsfsi(math.floatMin(f32), 0); - try test__fixsfsi(0.5, 0); - try test__fixsfsi(0.99, 0); - try test__fixsfsi(1.0, 1); - try test__fixsfsi(1.5, 1); - try test__fixsfsi(1.99, 1); - try test__fixsfsi(2.0, 2); - try test__fixsfsi(2.01, 2); - - try test__fixsfsi(0x1.FFFFFCp+30, 0x7FFFFF00); - try test__fixsfsi(0x1.FFFFFEp+30, 0x7FFFFF80); - try test__fixsfsi(0x1.FFFFFFp+30, 0x7FFFFFFF); - try test__fixsfsi(0x1.000000p+31, 0x7FFFFFFF); - - try test__fixsfsi(0x1.FFFFFCp+62, 0x7FFFFFFF); - try test__fixsfsi(0x1.FFFFFEp+62, 0x7FFFFFFF); - - try test__fixsfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF); - try test__fixsfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF); - try test__fixsfsi(0x1.0000000000000p+63, 0x7FFFFFFF); - try test__fixsfsi(0x1.0000000000001p+63, 0x7FFFFFFF); - - try test__fixsfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF); - try test__fixsfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF); - try test__fixsfsi(0x1.0000000000000p+127, 0x7FFFFFFF); - - try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF); - try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32)); - - try test__fixsfsi(math.floatMax(f32), math.maxInt(i32)); -} diff --git a/lib/std/special/compiler_rt/fixsfti.zig b/lib/std/special/compiler_rt/fixsfti.zig deleted file mode 100644 index e67bbabbd7..0000000000 --- a/lib/std/special/compiler_rt/fixsfti.zig +++ /dev/null @@ -1,11 +0,0 @@ -const fixint = @import("fixint.zig").fixint; -const builtin = @import("builtin"); - -pub fn __fixsfti(a: f32) callconv(.C) i128 { - @setRuntimeSafety(builtin.is_test); - return fixint(f32, i128, a); -} - -test { - _ = @import("fixsfti_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixsfti_test.zig b/lib/std/special/compiler_rt/fixsfti_test.zig deleted file mode 100644 index 7149f300db..0000000000 --- a/lib/std/special/compiler_rt/fixsfti_test.zig +++ /dev/null @@ -1,80 +0,0 @@ -const __fixsfti = @import("fixsfti.zig").__fixsfti; -const std = @import("std"); -const math = std.math; -const testing = std.testing; - -fn test__fixsfti(a: f32, expected: i128) !void { - const x = __fixsfti(a); - try testing.expect(x == expected); -} - -test "fixsfti" { - try test__fixsfti(-math.floatMax(f32), math.minInt(i128)); - - try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128)); - try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000); - - try test__fixsfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000); - try test__fixsfti(-0x1.FFFFFFFFFFFFFp+126, -0x80000000000000000000000000000000); - try test__fixsfti(-0x1.FFFFFFFFFFFFEp+126, -0x80000000000000000000000000000000); - try test__fixsfti(-0x1.FFFFFF0000000p+126, -0x80000000000000000000000000000000); - try test__fixsfti(-0x1.FFFFFE0000000p+126, -0x7FFFFF80000000000000000000000000); - try test__fixsfti(-0x1.FFFFFC0000000p+126, -0x7FFFFF00000000000000000000000000); - - try test__fixsfti(-0x1.0000000000001p+63, -0x8000000000000000); - try test__fixsfti(-0x1.0000000000000p+63, -0x8000000000000000); - try test__fixsfti(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000); - try test__fixsfti(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000); - - try test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000); - try test__fixsfti(-0x1.FFFFFEp+62, -0x7fffff8000000000); - try test__fixsfti(-0x1.FFFFFCp+62, -0x7fffff0000000000); - - try test__fixsfti(-0x1.000000p+31, -0x80000000); - try test__fixsfti(-0x1.FFFFFFp+30, -0x80000000); - try test__fixsfti(-0x1.FFFFFEp+30, -0x7FFFFF80); - try test__fixsfti(-0x1.FFFFFCp+30, -0x7FFFFF00); - - try test__fixsfti(-2.01, -2); - try test__fixsfti(-2.0, -2); - try test__fixsfti(-1.99, -1); - try test__fixsfti(-1.0, -1); - try test__fixsfti(-0.99, 0); - try test__fixsfti(-0.5, 0); - try test__fixsfti(-math.floatMin(f32), 0); - try test__fixsfti(0.0, 0); - try test__fixsfti(math.floatMin(f32), 0); - try test__fixsfti(0.5, 0); - try test__fixsfti(0.99, 0); - try test__fixsfti(1.0, 1); - try test__fixsfti(1.5, 1); - try test__fixsfti(1.99, 1); - try test__fixsfti(2.0, 2); - try test__fixsfti(2.01, 2); - - try test__fixsfti(0x1.FFFFFCp+30, 0x7FFFFF00); - try test__fixsfti(0x1.FFFFFEp+30, 0x7FFFFF80); - try test__fixsfti(0x1.FFFFFFp+30, 0x80000000); - try test__fixsfti(0x1.000000p+31, 0x80000000); - - try test__fixsfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - try test__fixsfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - try test__fixsfti(0x1.FFFFFFp+62, 0x8000000000000000); - - try test__fixsfti(0x1.FFFFFFFFFFFFEp+62, 0x8000000000000000); - try test__fixsfti(0x1.FFFFFFFFFFFFFp+62, 0x8000000000000000); - try test__fixsfti(0x1.0000000000000p+63, 0x8000000000000000); - try test__fixsfti(0x1.0000000000001p+63, 0x8000000000000000); - - try test__fixsfti(0x1.FFFFFC0000000p+126, 0x7FFFFF00000000000000000000000000); - try test__fixsfti(0x1.FFFFFE0000000p+126, 0x7FFFFF80000000000000000000000000); - try test__fixsfti(0x1.FFFFFF0000000p+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - try test__fixsfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - try test__fixsfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - try test__fixsfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - - try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128)); - - try test__fixsfti(math.floatMax(f32), math.maxInt(i128)); -} diff --git a/lib/std/special/compiler_rt/fixtfdi.zig b/lib/std/special/compiler_rt/fixtfdi.zig deleted file mode 100644 index 6087d7e720..0000000000 --- a/lib/std/special/compiler_rt/fixtfdi.zig +++ /dev/null @@ -1,11 +0,0 @@ -const fixint = @import("fixint.zig").fixint; -const builtin = @import("builtin"); - -pub fn __fixtfdi(a: f128) callconv(.C) i64 { - @setRuntimeSafety(builtin.is_test); - return fixint(f128, i64, a); -} - -test { - _ = @import("fixtfdi_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixtfdi_test.zig b/lib/std/special/compiler_rt/fixtfdi_test.zig deleted file mode 100644 index 79c320f622..0000000000 --- a/lib/std/special/compiler_rt/fixtfdi_test.zig +++ /dev/null @@ -1,72 +0,0 @@ -const __fixtfdi = @import("fixtfdi.zig").__fixtfdi; -const std = @import("std"); -const math = std.math; -const testing = std.testing; - -fn test__fixtfdi(a: f128, expected: i64) !void { - const x = __fixtfdi(a); - try testing.expect(x == expected); -} - -test "fixtfdi" { - try test__fixtfdi(-math.floatMax(f128), math.minInt(i64)); - - try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64)); - try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000); - - try test__fixtfdi(-0x1.0000000000000p+127, -0x8000000000000000); - try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000); - try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000); - - try test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000); - try test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000); - try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); - try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); - - try test__fixtfdi(-0x1.FFFFFEp+62, -0x7FFFFF8000000000); - try test__fixtfdi(-0x1.FFFFFCp+62, -0x7FFFFF0000000000); - - try test__fixtfdi(-0x1.000000p+31, -0x80000000); - try test__fixtfdi(-0x1.FFFFFFp+30, -0x7FFFFFC0); - try test__fixtfdi(-0x1.FFFFFEp+30, -0x7FFFFF80); - try test__fixtfdi(-0x1.FFFFFCp+30, -0x7FFFFF00); - - try test__fixtfdi(-2.01, -2); - try test__fixtfdi(-2.0, -2); - try test__fixtfdi(-1.99, -1); - try test__fixtfdi(-1.0, -1); - try test__fixtfdi(-0.99, 0); - try test__fixtfdi(-0.5, 0); - try test__fixtfdi(-@as(f128, math.floatMin(f64)), 0); - try test__fixtfdi(0.0, 0); - try test__fixtfdi(@as(f128, math.floatMin(f64)), 0); - try test__fixtfdi(0.5, 0); - try test__fixtfdi(0.99, 0); - try test__fixtfdi(1.0, 1); - try test__fixtfdi(1.5, 1); - try test__fixtfdi(1.99, 1); - try test__fixtfdi(2.0, 2); - try test__fixtfdi(2.01, 2); - - try test__fixtfdi(0x1.FFFFFCp+30, 0x7FFFFF00); - try test__fixtfdi(0x1.FFFFFEp+30, 0x7FFFFF80); - try test__fixtfdi(0x1.FFFFFFp+30, 0x7FFFFFC0); - try test__fixtfdi(0x1.000000p+31, 0x80000000); - - try test__fixtfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - try test__fixtfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - - try test__fixtfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - try test__fixtfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - try test__fixtfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF); - try test__fixtfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF); - - try test__fixtfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF); - try test__fixtfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF); - try test__fixtfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF); - - try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF); - try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64)); - - try test__fixtfdi(math.floatMax(f128), math.maxInt(i64)); -} diff --git a/lib/std/special/compiler_rt/fixtfsi.zig b/lib/std/special/compiler_rt/fixtfsi.zig deleted file mode 100644 index b5fea97c5c..0000000000 --- a/lib/std/special/compiler_rt/fixtfsi.zig +++ /dev/null @@ -1,11 +0,0 @@ -const fixint = @import("fixint.zig").fixint; -const builtin = @import("builtin"); - -pub fn __fixtfsi(a: f128) callconv(.C) i32 { - @setRuntimeSafety(builtin.is_test); - return fixint(f128, i32, a); -} - -test { - _ = @import("fixtfsi_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixtfsi_test.zig b/lib/std/special/compiler_rt/fixtfsi_test.zig deleted file mode 100644 index f05a4778f0..0000000000 --- a/lib/std/special/compiler_rt/fixtfsi_test.zig +++ /dev/null @@ -1,72 +0,0 @@ -const __fixtfsi = @import("fixtfsi.zig").__fixtfsi; -const std = @import("std"); -const math = std.math; -const testing = std.testing; - -fn test__fixtfsi(a: f128, expected: i32) !void { - const x = __fixtfsi(a); - try testing.expect(x == expected); -} - -test "fixtfsi" { - try test__fixtfsi(-math.floatMax(f128), math.minInt(i32)); - - try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32)); - try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000); - - try test__fixtfsi(-0x1.0000000000000p+127, -0x80000000); - try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000); - try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000); - - try test__fixtfsi(-0x1.0000000000001p+63, -0x80000000); - try test__fixtfsi(-0x1.0000000000000p+63, -0x80000000); - try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000); - try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000); - - try test__fixtfsi(-0x1.FFFFFEp+62, -0x80000000); - try test__fixtfsi(-0x1.FFFFFCp+62, -0x80000000); - - try test__fixtfsi(-0x1.000000p+31, -0x80000000); - try test__fixtfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0); - try test__fixtfsi(-0x1.FFFFFEp+30, -0x7FFFFF80); - try test__fixtfsi(-0x1.FFFFFCp+30, -0x7FFFFF00); - - try test__fixtfsi(-2.01, -2); - try test__fixtfsi(-2.0, -2); - try test__fixtfsi(-1.99, -1); - try test__fixtfsi(-1.0, -1); - try test__fixtfsi(-0.99, 0); - try test__fixtfsi(-0.5, 0); - try test__fixtfsi(-@as(f128, math.floatMin(f32)), 0); - try test__fixtfsi(0.0, 0); - try test__fixtfsi(@as(f128, math.floatMin(f32)), 0); - try test__fixtfsi(0.5, 0); - try test__fixtfsi(0.99, 0); - try test__fixtfsi(1.0, 1); - try test__fixtfsi(1.5, 1); - try test__fixtfsi(1.99, 1); - try test__fixtfsi(2.0, 2); - try test__fixtfsi(2.01, 2); - - try test__fixtfsi(0x1.FFFFFCp+30, 0x7FFFFF00); - try test__fixtfsi(0x1.FFFFFEp+30, 0x7FFFFF80); - try test__fixtfsi(0x1.FFFFFFp+30, 0x7FFFFFC0); - try test__fixtfsi(0x1.000000p+31, 0x7FFFFFFF); - - try test__fixtfsi(0x1.FFFFFCp+62, 0x7FFFFFFF); - try test__fixtfsi(0x1.FFFFFEp+62, 0x7FFFFFFF); - - try test__fixtfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF); - try test__fixtfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF); - try test__fixtfsi(0x1.0000000000000p+63, 0x7FFFFFFF); - try test__fixtfsi(0x1.0000000000001p+63, 0x7FFFFFFF); - - try test__fixtfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF); - try test__fixtfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF); - try test__fixtfsi(0x1.0000000000000p+127, 0x7FFFFFFF); - - try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF); - try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32)); - - try test__fixtfsi(math.floatMax(f128), math.maxInt(i32)); -} diff --git a/lib/std/special/compiler_rt/fixtfti.zig b/lib/std/special/compiler_rt/fixtfti.zig deleted file mode 100644 index 5a001d0b69..0000000000 --- a/lib/std/special/compiler_rt/fixtfti.zig +++ /dev/null @@ -1,11 +0,0 @@ -const fixint = @import("fixint.zig").fixint; -const builtin = @import("builtin"); - -pub fn __fixtfti(a: f128) callconv(.C) i128 { - @setRuntimeSafety(builtin.is_test); - return fixint(f128, i128, a); -} - -test { - _ = @import("fixtfti_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixtfti_test.zig b/lib/std/special/compiler_rt/fixtfti_test.zig deleted file mode 100644 index 4c1c9bd640..0000000000 --- a/lib/std/special/compiler_rt/fixtfti_test.zig +++ /dev/null @@ -1,62 +0,0 @@ -const __fixtfti = @import("fixtfti.zig").__fixtfti; -const std = @import("std"); -const math = std.math; -const testing = std.testing; - -fn test__fixtfti(a: f128, expected: i128) !void { - const x = __fixtfti(a); - try testing.expect(x == expected); -} - -test "fixtfti" { - try test__fixtfti(-math.floatMax(f128), math.minInt(i128)); - - try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128)); - try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000); - - try test__fixtfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000); - try test__fixtfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000); - try test__fixtfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000); - - try test__fixtfti(-0x1.0000000000001p+63, -0x8000000000000800); - try test__fixtfti(-0x1.0000000000000p+63, -0x8000000000000000); - try test__fixtfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00); - try test__fixtfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800); - - try test__fixtfti(-0x1.FFFFFEp+62, -0x7fffff8000000000); - try test__fixtfti(-0x1.FFFFFCp+62, -0x7fffff0000000000); - - try test__fixtfti(-2.01, -2); - try test__fixtfti(-2.0, -2); - try test__fixtfti(-1.99, -1); - try test__fixtfti(-1.0, -1); - try test__fixtfti(-0.99, 0); - try test__fixtfti(-0.5, 0); - try test__fixtfti(-math.floatMin(f128), 0); - try test__fixtfti(0.0, 0); - try test__fixtfti(math.floatMin(f128), 0); - try test__fixtfti(0.5, 0); - try test__fixtfti(0.99, 0); - try test__fixtfti(1.0, 1); - try test__fixtfti(1.5, 1); - try test__fixtfti(1.99, 1); - try test__fixtfti(2.0, 2); - try test__fixtfti(2.01, 2); - - try test__fixtfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - try test__fixtfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - - try test__fixtfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - try test__fixtfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - try test__fixtfti(0x1.0000000000000p+63, 0x8000000000000000); - try test__fixtfti(0x1.0000000000001p+63, 0x8000000000000800); - - try test__fixtfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000); - try test__fixtfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000); - try test__fixtfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - - try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128)); - - try test__fixtfti(math.floatMax(f128), math.maxInt(i128)); -} diff --git a/lib/std/special/compiler_rt/fixuint.zig b/lib/std/special/compiler_rt/fixuint.zig deleted file mode 100644 index 6bfbcf6d65..0000000000 --- a/lib/std/special/compiler_rt/fixuint.zig +++ /dev/null @@ -1,50 +0,0 @@ -const is_test = @import("builtin").is_test; -const Log2Int = @import("std").math.Log2Int; - -pub inline fn fixuint(comptime fp_t: type, comptime fixuint_t: type, a: fp_t) fixuint_t { - @setRuntimeSafety(is_test); - - const rep_t = switch (fp_t) { - f32 => u32, - f64 => u64, - f128 => u128, - else => unreachable, - }; - const typeWidth = @typeInfo(rep_t).Int.bits; - const significandBits = switch (fp_t) { - f32 => 23, - f64 => 52, - f128 => 112, - else => unreachable, - }; - const exponentBits = (typeWidth - significandBits - 1); - const signBit = (@as(rep_t, 1) << (significandBits + exponentBits)); - const maxExponent = ((1 << exponentBits) - 1); - const exponentBias = (maxExponent >> 1); - - const implicitBit = (@as(rep_t, 1) << significandBits); - const significandMask = (implicitBit - 1); - - // Break a into sign, exponent, significand - const aRep: rep_t = @bitCast(rep_t, a); - const absMask = signBit - 1; - const aAbs: rep_t = aRep & absMask; - - const sign = if ((aRep & signBit) != 0) @as(i32, -1) else @as(i32, 1); - const exponent = @intCast(i32, aAbs >> significandBits) - exponentBias; - const significand: rep_t = (aAbs & significandMask) | implicitBit; - - // If either the value or the exponent is negative, the result is zero. - if (sign == -1 or exponent < 0) return 0; - - // If the value is too large for the integer type, saturate. - if (@intCast(c_uint, exponent) >= @typeInfo(fixuint_t).Int.bits) return ~@as(fixuint_t, 0); - - // If 0 <= exponent < significandBits, right shift to get the result. - // Otherwise, shift left. - if (exponent < significandBits) { - return @intCast(fixuint_t, significand >> @intCast(Log2Int(rep_t), significandBits - exponent)); - } else { - return @intCast(fixuint_t, significand) << @intCast(Log2Int(fixuint_t), exponent - significandBits); - } -} diff --git a/lib/std/special/compiler_rt/fixunsdfdi.zig b/lib/std/special/compiler_rt/fixunsdfdi.zig deleted file mode 100644 index c864f0f6c2..0000000000 --- a/lib/std/special/compiler_rt/fixunsdfdi.zig +++ /dev/null @@ -1,16 +0,0 @@ -const fixuint = @import("fixuint.zig").fixuint; -const builtin = @import("builtin"); - -pub fn __fixunsdfdi(a: f64) callconv(.C) u64 { - @setRuntimeSafety(builtin.is_test); - return fixuint(f64, u64, a); -} - -pub fn __aeabi_d2ulz(a: f64) callconv(.AAPCS) u64 { - @setRuntimeSafety(false); - return @call(.{ .modifier = .always_inline }, __fixunsdfdi, .{a}); -} - -test { - _ = @import("fixunsdfdi_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixunsdfdi_test.zig b/lib/std/special/compiler_rt/fixunsdfdi_test.zig deleted file mode 100644 index 59591cf181..0000000000 --- a/lib/std/special/compiler_rt/fixunsdfdi_test.zig +++ /dev/null @@ -1,39 +0,0 @@ -const __fixunsdfdi = @import("fixunsdfdi.zig").__fixunsdfdi; -const testing = @import("std").testing; - -fn test__fixunsdfdi(a: f64, expected: u64) !void { - const x = __fixunsdfdi(a); - try testing.expect(x == expected); -} - -test "fixunsdfdi" { - //test__fixunsdfdi(0.0, 0); - //test__fixunsdfdi(0.5, 0); - //test__fixunsdfdi(0.99, 0); - try test__fixunsdfdi(1.0, 1); - try test__fixunsdfdi(1.5, 1); - try test__fixunsdfdi(1.99, 1); - try test__fixunsdfdi(2.0, 2); - try test__fixunsdfdi(2.01, 2); - try test__fixunsdfdi(-0.5, 0); - try test__fixunsdfdi(-0.99, 0); - try test__fixunsdfdi(-1.0, 0); - try test__fixunsdfdi(-1.5, 0); - try test__fixunsdfdi(-1.99, 0); - try test__fixunsdfdi(-2.0, 0); - try test__fixunsdfdi(-2.01, 0); - - try test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - try test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - - try test__fixunsdfdi(-0x1.FFFFFEp+62, 0); - try test__fixunsdfdi(-0x1.FFFFFCp+62, 0); - - try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800); - try test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000); - try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - try test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - - try test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0); - try test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0); -} diff --git a/lib/std/special/compiler_rt/fixunsdfsi.zig b/lib/std/special/compiler_rt/fixunsdfsi.zig deleted file mode 100644 index c1f5173661..0000000000 --- a/lib/std/special/compiler_rt/fixunsdfsi.zig +++ /dev/null @@ -1,16 +0,0 @@ -const fixuint = @import("fixuint.zig").fixuint; -const builtin = @import("builtin"); - -pub fn __fixunsdfsi(a: f64) callconv(.C) u32 { - @setRuntimeSafety(builtin.is_test); - return fixuint(f64, u32, a); -} - -pub fn __aeabi_d2uiz(arg: f64) callconv(.AAPCS) u32 { - @setRuntimeSafety(false); - return @call(.{ .modifier = .always_inline }, __fixunsdfsi, .{arg}); -} - -test { - _ = @import("fixunsdfsi_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixunsdfsi_test.zig b/lib/std/special/compiler_rt/fixunsdfsi_test.zig deleted file mode 100644 index b4b7ec8840..0000000000 --- a/lib/std/special/compiler_rt/fixunsdfsi_test.zig +++ /dev/null @@ -1,39 +0,0 @@ -const __fixunsdfsi = @import("fixunsdfsi.zig").__fixunsdfsi; -const testing = @import("std").testing; - -fn test__fixunsdfsi(a: f64, expected: u32) !void { - const x = __fixunsdfsi(a); - try testing.expect(x == expected); -} - -test "fixunsdfsi" { - try test__fixunsdfsi(0.0, 0); - - try test__fixunsdfsi(0.5, 0); - try test__fixunsdfsi(0.99, 0); - try test__fixunsdfsi(1.0, 1); - try test__fixunsdfsi(1.5, 1); - try test__fixunsdfsi(1.99, 1); - try test__fixunsdfsi(2.0, 2); - try test__fixunsdfsi(2.01, 2); - try test__fixunsdfsi(-0.5, 0); - try test__fixunsdfsi(-0.99, 0); - try test__fixunsdfsi(-1.0, 0); - try test__fixunsdfsi(-1.5, 0); - try test__fixunsdfsi(-1.99, 0); - try test__fixunsdfsi(-2.0, 0); - try test__fixunsdfsi(-2.01, 0); - - try test__fixunsdfsi(0x1.000000p+31, 0x80000000); - try test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF); - try test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00); - try test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80); - try test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00); - - try test__fixunsdfsi(-0x1.FFFFFEp+30, 0); - try test__fixunsdfsi(-0x1.FFFFFCp+30, 0); - - try test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF); - try test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF); - try test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE); -} diff --git a/lib/std/special/compiler_rt/fixunsdfti.zig b/lib/std/special/compiler_rt/fixunsdfti.zig deleted file mode 100644 index 3c9871a4df..0000000000 --- a/lib/std/special/compiler_rt/fixunsdfti.zig +++ /dev/null @@ -1,11 +0,0 @@ -const fixuint = @import("fixuint.zig").fixuint; -const builtin = @import("builtin"); - -pub fn __fixunsdfti(a: f64) callconv(.C) u128 { - @setRuntimeSafety(builtin.is_test); - return fixuint(f64, u128, a); -} - -test { - _ = @import("fixunsdfti_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixunsdfti_test.zig b/lib/std/special/compiler_rt/fixunsdfti_test.zig deleted file mode 100644 index d9e1424836..0000000000 --- a/lib/std/special/compiler_rt/fixunsdfti_test.zig +++ /dev/null @@ -1,46 +0,0 @@ -const __fixunsdfti = @import("fixunsdfti.zig").__fixunsdfti; -const testing = @import("std").testing; - -fn test__fixunsdfti(a: f64, expected: u128) !void { - const x = __fixunsdfti(a); - try testing.expect(x == expected); -} - -test "fixunsdfti" { - try test__fixunsdfti(0.0, 0); - - try test__fixunsdfti(0.5, 0); - try test__fixunsdfti(0.99, 0); - try test__fixunsdfti(1.0, 1); - try test__fixunsdfti(1.5, 1); - try test__fixunsdfti(1.99, 1); - try test__fixunsdfti(2.0, 2); - try test__fixunsdfti(2.01, 2); - try test__fixunsdfti(-0.5, 0); - try test__fixunsdfti(-0.99, 0); - try test__fixunsdfti(-1.0, 0); - try test__fixunsdfti(-1.5, 0); - try test__fixunsdfti(-1.99, 0); - try test__fixunsdfti(-2.0, 0); - try test__fixunsdfti(-2.01, 0); - - try test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - try test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - - try test__fixunsdfti(-0x1.FFFFFEp+62, 0); - try test__fixunsdfti(-0x1.FFFFFCp+62, 0); - - try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800); - try test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000); - try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - - try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000); - try test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000); - try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000); - try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000); - try test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF); - - try test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0); - try test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0); -} diff --git a/lib/std/special/compiler_rt/fixunssfdi.zig b/lib/std/special/compiler_rt/fixunssfdi.zig deleted file mode 100644 index edad20e8bf..0000000000 --- a/lib/std/special/compiler_rt/fixunssfdi.zig +++ /dev/null @@ -1,16 +0,0 @@ -const fixuint = @import("fixuint.zig").fixuint; -const builtin = @import("builtin"); - -pub fn __fixunssfdi(a: f32) callconv(.C) u64 { - @setRuntimeSafety(builtin.is_test); - return fixuint(f32, u64, a); -} - -pub fn __aeabi_f2ulz(a: f32) callconv(.AAPCS) u64 { - @setRuntimeSafety(false); - return @call(.{ .modifier = .always_inline }, __fixunssfdi, .{a}); -} - -test { - _ = @import("fixunssfdi_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixunssfdi_test.zig b/lib/std/special/compiler_rt/fixunssfdi_test.zig deleted file mode 100644 index 3c46511b6d..0000000000 --- a/lib/std/special/compiler_rt/fixunssfdi_test.zig +++ /dev/null @@ -1,35 +0,0 @@ -const __fixunssfdi = @import("fixunssfdi.zig").__fixunssfdi; -const testing = @import("std").testing; - -fn test__fixunssfdi(a: f32, expected: u64) !void { - const x = __fixunssfdi(a); - try testing.expect(x == expected); -} - -test "fixunssfdi" { - try test__fixunssfdi(0.0, 0); - - try test__fixunssfdi(0.5, 0); - try test__fixunssfdi(0.99, 0); - try test__fixunssfdi(1.0, 1); - try test__fixunssfdi(1.5, 1); - try test__fixunssfdi(1.99, 1); - try test__fixunssfdi(2.0, 2); - try test__fixunssfdi(2.01, 2); - try test__fixunssfdi(-0.5, 0); - try test__fixunssfdi(-0.99, 0); - - try test__fixunssfdi(-1.0, 0); - try test__fixunssfdi(-1.5, 0); - try test__fixunssfdi(-1.99, 0); - try test__fixunssfdi(-2.0, 0); - try test__fixunssfdi(-2.01, 0); - - try test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000); - try test__fixunssfdi(0x1.000000p+63, 0x8000000000000000); - try test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - try test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - - try test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000); - try test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000); -} diff --git a/lib/std/special/compiler_rt/fixunssfsi.zig b/lib/std/special/compiler_rt/fixunssfsi.zig deleted file mode 100644 index 96722a2a36..0000000000 --- a/lib/std/special/compiler_rt/fixunssfsi.zig +++ /dev/null @@ -1,16 +0,0 @@ -const fixuint = @import("fixuint.zig").fixuint; -const builtin = @import("builtin"); - -pub fn __fixunssfsi(a: f32) callconv(.C) u32 { - @setRuntimeSafety(builtin.is_test); - return fixuint(f32, u32, a); -} - -pub fn __aeabi_f2uiz(a: f32) callconv(.AAPCS) u32 { - @setRuntimeSafety(false); - return @call(.{ .modifier = .always_inline }, __fixunssfsi, .{a}); -} - -test { - _ = @import("fixunssfsi_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixunssfsi_test.zig b/lib/std/special/compiler_rt/fixunssfsi_test.zig deleted file mode 100644 index 4bf90e4bff..0000000000 --- a/lib/std/special/compiler_rt/fixunssfsi_test.zig +++ /dev/null @@ -1,36 +0,0 @@ -const __fixunssfsi = @import("fixunssfsi.zig").__fixunssfsi; -const testing = @import("std").testing; - -fn test__fixunssfsi(a: f32, expected: u32) !void { - const x = __fixunssfsi(a); - try testing.expect(x == expected); -} - -test "fixunssfsi" { - try test__fixunssfsi(0.0, 0); - - try test__fixunssfsi(0.5, 0); - try test__fixunssfsi(0.99, 0); - try test__fixunssfsi(1.0, 1); - try test__fixunssfsi(1.5, 1); - try test__fixunssfsi(1.99, 1); - try test__fixunssfsi(2.0, 2); - try test__fixunssfsi(2.01, 2); - try test__fixunssfsi(-0.5, 0); - try test__fixunssfsi(-0.99, 0); - - try test__fixunssfsi(-1.0, 0); - try test__fixunssfsi(-1.5, 0); - try test__fixunssfsi(-1.99, 0); - try test__fixunssfsi(-2.0, 0); - try test__fixunssfsi(-2.01, 0); - - try test__fixunssfsi(0x1.000000p+31, 0x80000000); - try test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF); - try test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00); - try test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80); - try test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00); - - try test__fixunssfsi(-0x1.FFFFFEp+30, 0); - try test__fixunssfsi(-0x1.FFFFFCp+30, 0); -} diff --git a/lib/std/special/compiler_rt/fixunssfti.zig b/lib/std/special/compiler_rt/fixunssfti.zig deleted file mode 100644 index 4967202e69..0000000000 --- a/lib/std/special/compiler_rt/fixunssfti.zig +++ /dev/null @@ -1,11 +0,0 @@ -const fixuint = @import("fixuint.zig").fixuint; -const builtin = @import("builtin"); - -pub fn __fixunssfti(a: f32) callconv(.C) u128 { - @setRuntimeSafety(builtin.is_test); - return fixuint(f32, u128, a); -} - -test { - _ = @import("fixunssfti_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixunssfti_test.zig b/lib/std/special/compiler_rt/fixunssfti_test.zig deleted file mode 100644 index 3c1a314e91..0000000000 --- a/lib/std/special/compiler_rt/fixunssfti_test.zig +++ /dev/null @@ -1,41 +0,0 @@ -const __fixunssfti = @import("fixunssfti.zig").__fixunssfti; -const testing = @import("std").testing; - -fn test__fixunssfti(a: f32, expected: u128) !void { - const x = __fixunssfti(a); - try testing.expect(x == expected); -} - -test "fixunssfti" { - try test__fixunssfti(0.0, 0); - - try test__fixunssfti(0.5, 0); - try test__fixunssfti(0.99, 0); - try test__fixunssfti(1.0, 1); - try test__fixunssfti(1.5, 1); - try test__fixunssfti(1.99, 1); - try test__fixunssfti(2.0, 2); - try test__fixunssfti(2.01, 2); - try test__fixunssfti(-0.5, 0); - try test__fixunssfti(-0.99, 0); - - try test__fixunssfti(-1.0, 0); - try test__fixunssfti(-1.5, 0); - try test__fixunssfti(-1.99, 0); - try test__fixunssfti(-2.0, 0); - try test__fixunssfti(-2.01, 0); - - try test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000); - try test__fixunssfti(0x1.000000p+63, 0x8000000000000000); - try test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - try test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - try test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000); - try test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000); - try test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000); - try test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000); - - try test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000); - try test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000); - try test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000); - try test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000); -} diff --git a/lib/std/special/compiler_rt/fixunstfdi.zig b/lib/std/special/compiler_rt/fixunstfdi.zig deleted file mode 100644 index 0db4987a08..0000000000 --- a/lib/std/special/compiler_rt/fixunstfdi.zig +++ /dev/null @@ -1,11 +0,0 @@ -const fixuint = @import("fixuint.zig").fixuint; -const builtin = @import("builtin"); - -pub fn __fixunstfdi(a: f128) callconv(.C) u64 { - @setRuntimeSafety(builtin.is_test); - return fixuint(f128, u64, a); -} - -test { - _ = @import("fixunstfdi_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixunstfdi_test.zig b/lib/std/special/compiler_rt/fixunstfdi_test.zig deleted file mode 100644 index aa746799b7..0000000000 --- a/lib/std/special/compiler_rt/fixunstfdi_test.zig +++ /dev/null @@ -1,49 +0,0 @@ -const __fixunstfdi = @import("fixunstfdi.zig").__fixunstfdi; -const testing = @import("std").testing; - -fn test__fixunstfdi(a: f128, expected: u64) !void { - const x = __fixunstfdi(a); - try testing.expect(x == expected); -} - -test "fixunstfdi" { - try test__fixunstfdi(0.0, 0); - - try test__fixunstfdi(0.5, 0); - try test__fixunstfdi(0.99, 0); - try test__fixunstfdi(1.0, 1); - try test__fixunstfdi(1.5, 1); - try test__fixunstfdi(1.99, 1); - try test__fixunstfdi(2.0, 2); - try test__fixunstfdi(2.01, 2); - try test__fixunstfdi(-0.5, 0); - try test__fixunstfdi(-0.99, 0); - try test__fixunstfdi(-1.0, 0); - try test__fixunstfdi(-1.5, 0); - try test__fixunstfdi(-1.99, 0); - try test__fixunstfdi(-2.0, 0); - try test__fixunstfdi(-2.01, 0); - - try test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000); - try test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000); - - try test__fixunstfdi(-0x1.FFFFFEp+62, 0); - try test__fixunstfdi(-0x1.FFFFFCp+62, 0); - - try test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00); - try test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800); - - try test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0); - try test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0); - - try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF); - try test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001); - try test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000); - try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF); - try test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE); - try test__fixunstfdi(0x1p+64, 0xFFFFFFFFFFFFFFFF); - - try test__fixunstfdi(-0x1.0000000000000000p+63, 0); - try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0); - try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0); -} diff --git a/lib/std/special/compiler_rt/fixunstfsi.zig b/lib/std/special/compiler_rt/fixunstfsi.zig deleted file mode 100644 index 8cedc07a35..0000000000 --- a/lib/std/special/compiler_rt/fixunstfsi.zig +++ /dev/null @@ -1,11 +0,0 @@ -const fixuint = @import("fixuint.zig").fixuint; -const builtin = @import("builtin"); - -pub fn __fixunstfsi(a: f128) callconv(.C) u32 { - @setRuntimeSafety(builtin.is_test); - return fixuint(f128, u32, a); -} - -test { - _ = @import("fixunstfsi_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixunstfsi_test.zig b/lib/std/special/compiler_rt/fixunstfsi_test.zig deleted file mode 100644 index 206161bef5..0000000000 --- a/lib/std/special/compiler_rt/fixunstfsi_test.zig +++ /dev/null @@ -1,22 +0,0 @@ -const __fixunstfsi = @import("fixunstfsi.zig").__fixunstfsi; -const testing = @import("std").testing; - -fn test__fixunstfsi(a: f128, expected: u32) !void { - const x = __fixunstfsi(a); - try testing.expect(x == expected); -} - -const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000)); - -test "fixunstfsi" { - try test__fixunstfsi(inf128, 0xffffffff); - try test__fixunstfsi(0, 0x0); - try test__fixunstfsi(0x1.23456789abcdefp+5, 0x24); - try test__fixunstfsi(0x1.23456789abcdefp-3, 0x0); - try test__fixunstfsi(0x1.23456789abcdefp+20, 0x123456); - try test__fixunstfsi(0x1.23456789abcdefp+40, 0xffffffff); - try test__fixunstfsi(0x1.23456789abcdefp+256, 0xffffffff); - try test__fixunstfsi(-0x1.23456789abcdefp+3, 0x0); - - try test__fixunstfsi(0x1p+32, 0xFFFFFFFF); -} diff --git a/lib/std/special/compiler_rt/fixunstfti.zig b/lib/std/special/compiler_rt/fixunstfti.zig deleted file mode 100644 index 0359327027..0000000000 --- a/lib/std/special/compiler_rt/fixunstfti.zig +++ /dev/null @@ -1,11 +0,0 @@ -const fixuint = @import("fixuint.zig").fixuint; -const builtin = @import("builtin"); - -pub fn __fixunstfti(a: f128) callconv(.C) u128 { - @setRuntimeSafety(builtin.is_test); - return fixuint(f128, u128, a); -} - -test { - _ = @import("fixunstfti_test.zig"); -} diff --git a/lib/std/special/compiler_rt/fixunstfti_test.zig b/lib/std/special/compiler_rt/fixunstfti_test.zig deleted file mode 100644 index e35e2a65be..0000000000 --- a/lib/std/special/compiler_rt/fixunstfti_test.zig +++ /dev/null @@ -1,32 +0,0 @@ -const __fixunstfti = @import("fixunstfti.zig").__fixunstfti; -const testing = @import("std").testing; - -fn test__fixunstfti(a: f128, expected: u128) !void { - const x = __fixunstfti(a); - try testing.expect(x == expected); -} - -const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000)); - -test "fixunstfti" { - try test__fixunstfti(inf128, 0xffffffffffffffffffffffffffffffff); - - try test__fixunstfti(0.0, 0); - - try test__fixunstfti(0.5, 0); - try test__fixunstfti(0.99, 0); - try test__fixunstfti(1.0, 1); - try test__fixunstfti(1.5, 1); - try test__fixunstfti(1.99, 1); - try test__fixunstfti(2.0, 2); - try test__fixunstfti(2.01, 2); - try test__fixunstfti(-0.01, 0); - try test__fixunstfti(-0.99, 0); - - try test__fixunstfti(0x1p+128, 0xffffffffffffffffffffffffffffffff); - - try test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000); - try test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000); - try test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff); - try test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff); -} diff --git a/lib/std/special/compiler_rt/floatXiYf.zig b/lib/std/special/compiler_rt/floatXiYf.zig new file mode 100644 index 0000000000..068413f715 --- /dev/null +++ b/lib/std/special/compiler_rt/floatXiYf.zig @@ -0,0 +1,222 @@ +const builtin = @import("builtin"); +const is_test = builtin.is_test; +const std = @import("std"); +const math = std.math; +const expect = std.testing.expect; + +pub fn floatXiYf(comptime T: type, x: anytype) T { + @setRuntimeSafety(is_test); + + if (x == 0) return 0; + + // Various constants whose values follow from the type parameters. + // Any reasonable optimizer will fold and propagate all of these. + const Z = std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(x))); + const uT = std.meta.Int(.unsigned, @bitSizeOf(T)); + const inf = math.inf(T); + const float_bits = @bitSizeOf(T); + const int_bits = @bitSizeOf(@TypeOf(x)); + const exp_bits = math.floatExponentBits(T); + const fractional_bits = math.floatFractionalBits(T); + const exp_bias = math.maxInt(std.meta.Int(.unsigned, exp_bits - 1)); + const implicit_bit = if (T != f80) @as(uT, 1) << fractional_bits else 0; + const max_exp = exp_bias; + + // Sign + var abs_val = math.absCast(x); + const sign_bit = if (x < 0) @as(uT, 1) << (float_bits - 1) else 0; + var result: uT = sign_bit; + + // Compute significand + var exp = int_bits - @clz(Z, abs_val) - 1; + if (int_bits <= fractional_bits or exp <= fractional_bits) { + const shift_amt = fractional_bits - @intCast(math.Log2Int(uT), exp); + + // Shift up result to line up with the significand - no rounding required + result = (@intCast(uT, abs_val) << shift_amt); + result ^= implicit_bit; // Remove implicit integer bit + } else { + var shift_amt = @intCast(math.Log2Int(Z), exp - fractional_bits); + const exact_tie: bool = @ctz(Z, abs_val) == shift_amt - 1; + + // Shift down result and remove implicit integer bit + result = @intCast(uT, (abs_val >> (shift_amt - 1))) ^ (implicit_bit << 1); + + // Round result, including round-to-even for exact ties + result = ((result + 1) >> 1) & ~@as(uT, @boolToInt(exact_tie)); + } + + // Compute exponent + if ((int_bits > max_exp) and (exp > max_exp)) // If exponent too large, overflow to infinity + return @bitCast(T, sign_bit | @bitCast(uT, inf)); + + result += (@as(uT, exp) + exp_bias) << math.floatMantissaBits(T); + + // If the result included a carry, we need to restore the explicit integer bit + if (T == f80) result |= 1 << fractional_bits; + + return @bitCast(T, sign_bit | result); +} + +// Conversion to f16 +pub fn __floatsihf(a: i32) callconv(.C) f16 { + return floatXiYf(f16, a); +} + +pub fn __floatunsihf(a: u32) callconv(.C) f16 { + return floatXiYf(f16, a); +} + +pub fn __floatdihf(a: i64) callconv(.C) f16 { + return floatXiYf(f16, a); +} + +pub fn __floatundihf(a: u64) callconv(.C) f16 { + return floatXiYf(f16, a); +} + +pub fn __floattihf(a: i128) callconv(.C) f16 { + return floatXiYf(f16, a); +} + +pub fn __floatuntihf(a: u128) callconv(.C) f16 { + return floatXiYf(f16, a); +} + +// Conversion to f32 +pub fn __floatsisf(a: i32) callconv(.C) f32 { + return floatXiYf(f32, a); +} + +pub fn __floatunsisf(a: u32) callconv(.C) f32 { + return floatXiYf(f32, a); +} + +pub fn __floatdisf(a: i64) callconv(.C) f32 { + return floatXiYf(f32, a); +} + +pub fn __floatundisf(a: u64) callconv(.C) f32 { + return floatXiYf(f32, a); +} + +pub fn __floattisf(a: i128) callconv(.C) f32 { + return floatXiYf(f32, a); +} + +pub fn __floatuntisf(a: u128) callconv(.C) f32 { + return floatXiYf(f32, a); +} + +// Conversion to f64 +pub fn __floatsidf(a: i32) callconv(.C) f64 { + return floatXiYf(f64, a); +} + +pub fn __floatunsidf(a: u32) callconv(.C) f64 { + return floatXiYf(f64, a); +} + +pub fn __floatdidf(a: i64) callconv(.C) f64 { + return floatXiYf(f64, a); +} + +pub fn __floatundidf(a: u64) callconv(.C) f64 { + return floatXiYf(f64, a); +} + +pub fn __floattidf(a: i128) callconv(.C) f64 { + return floatXiYf(f64, a); +} + +pub fn __floatuntidf(a: u128) callconv(.C) f64 { + return floatXiYf(f64, a); +} + +// Conversion to f80 +pub fn __floatsixf(a: i32) callconv(.C) f80 { + return floatXiYf(f80, a); +} + +pub fn __floatunsixf(a: u32) callconv(.C) f80 { + return floatXiYf(f80, a); +} + +pub fn __floatdixf(a: i64) callconv(.C) f80 { + return floatXiYf(f80, a); +} + +pub fn __floatundixf(a: u64) callconv(.C) f80 { + return floatXiYf(f80, a); +} + +pub fn __floattixf(a: i128) callconv(.C) f80 { + return floatXiYf(f80, a); +} + +pub fn __floatuntixf(a: u128) callconv(.C) f80 { + return floatXiYf(f80, a); +} + +// Conversion to f128 +pub fn __floatsitf(a: i32) callconv(.C) f128 { + return floatXiYf(f128, a); +} + +pub fn __floatunsitf(a: u32) callconv(.C) f128 { + return floatXiYf(f128, a); +} + +pub fn __floatditf(a: i64) callconv(.C) f128 { + return floatXiYf(f128, a); +} + +pub fn __floatunditf(a: u64) callconv(.C) f128 { + return floatXiYf(f128, a); +} + +pub fn __floattitf(a: i128) callconv(.C) f128 { + return floatXiYf(f128, a); +} + +pub fn __floatuntitf(a: u128) callconv(.C) f128 { + return floatXiYf(f128, a); +} + +// Conversion to f32 +pub fn __aeabi_ui2f(arg: u32) callconv(.AAPCS) f32 { + return floatXiYf(f32, arg); +} + +pub fn __aeabi_i2f(arg: i32) callconv(.AAPCS) f32 { + return floatXiYf(f32, arg); +} + +pub fn __aeabi_ul2f(arg: u64) callconv(.AAPCS) f32 { + return floatXiYf(f32, arg); +} + +pub fn __aeabi_l2f(arg: i64) callconv(.AAPCS) f32 { + return floatXiYf(f32, arg); +} + +// Conversion to f64 +pub fn __aeabi_ui2d(arg: u32) callconv(.AAPCS) f64 { + return floatXiYf(f64, arg); +} + +pub fn __aeabi_i2d(arg: i32) callconv(.AAPCS) f64 { + return floatXiYf(f64, arg); +} + +pub fn __aeabi_ul2d(arg: u64) callconv(.AAPCS) f64 { + return floatXiYf(f64, arg); +} + +pub fn __aeabi_l2d(arg: i64) callconv(.AAPCS) f64 { + return floatXiYf(f64, arg); +} + +test { + _ = @import("floatXiYf_test.zig"); +} diff --git a/lib/std/special/compiler_rt/floatXiYf_test.zig b/lib/std/special/compiler_rt/floatXiYf_test.zig new file mode 100644 index 0000000000..cffa2a5b42 --- /dev/null +++ b/lib/std/special/compiler_rt/floatXiYf_test.zig @@ -0,0 +1,835 @@ +const std = @import("std"); +const builtin = @import("builtin"); +const testing = std.testing; +const math = std.math; +const floatXiYf = @import("floatXiYf.zig").floatXiYf; + +// Conversion to f32 +const __floatsisf = @import("floatXiYf.zig").__floatsisf; +const __floatunsisf = @import("floatXiYf.zig").__floatunsisf; +const __floatdisf = @import("floatXiYf.zig").__floatdisf; +const __floatundisf = @import("floatXiYf.zig").__floatundisf; +const __floattisf = @import("floatXiYf.zig").__floattisf; +const __floatuntisf = @import("floatXiYf.zig").__floatuntisf; + +// Conversion to f64 +const __floatsidf = @import("floatXiYf.zig").__floatsidf; +const __floatunsidf = @import("floatXiYf.zig").__floatunsidf; +const __floatdidf = @import("floatXiYf.zig").__floatdidf; +const __floatundidf = @import("floatXiYf.zig").__floatundidf; +const __floattidf = @import("floatXiYf.zig").__floattidf; +const __floatuntidf = @import("floatXiYf.zig").__floatuntidf; + +// Conversion to f128 +const __floatsitf = @import("floatXiYf.zig").__floatsitf; +const __floatunsitf = @import("floatXiYf.zig").__floatunsitf; +const __floatditf = @import("floatXiYf.zig").__floatditf; +const __floatunditf = @import("floatXiYf.zig").__floatunditf; +const __floattitf = @import("floatXiYf.zig").__floattitf; +const __floatuntitf = @import("floatXiYf.zig").__floatuntitf; + +fn test__floatsisf(a: i32, expected: u32) !void { + const r = __floatsisf(a); + try std.testing.expect(@bitCast(u32, r) == expected); +} + +fn test_one_floatunsisf(a: u32, expected: u32) !void { + const r = __floatunsisf(a); + try std.testing.expect(@bitCast(u32, r) == expected); +} + +test "floatsisf" { + try test__floatsisf(0, 0x00000000); + try test__floatsisf(1, 0x3f800000); + try test__floatsisf(-1, 0xbf800000); + try test__floatsisf(0x7FFFFFFF, 0x4f000000); + try test__floatsisf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xcf000000); +} + +test "floatunsisf" { + // Test the produced bit pattern + try test_one_floatunsisf(0, 0); + try test_one_floatunsisf(1, 0x3f800000); + try test_one_floatunsisf(0x7FFFFFFF, 0x4f000000); + try test_one_floatunsisf(0x80000000, 0x4f000000); + try test_one_floatunsisf(0xFFFFFFFF, 0x4f800000); +} + +fn test__floatdisf(a: i64, expected: f32) !void { + const x = __floatdisf(a); + try testing.expect(x == expected); +} + +fn test__floatundisf(a: u64, expected: f32) !void { + try std.testing.expectEqual(expected, __floatundisf(a)); +} + +test "floatdisf" { + try test__floatdisf(0, 0.0); + try test__floatdisf(1, 1.0); + try test__floatdisf(2, 2.0); + try test__floatdisf(-1, -1.0); + try test__floatdisf(-2, -2.0); + try test__floatdisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatdisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floatdisf(@bitCast(i64, @as(u64, 0x8000008000000000)), -0x1.FFFFFEp+62); + try test__floatdisf(@bitCast(i64, @as(u64, 0x8000010000000000)), -0x1.FFFFFCp+62); + try test__floatdisf(@bitCast(i64, @as(u64, 0x8000000000000000)), -0x1.000000p+63); + try test__floatdisf(@bitCast(i64, @as(u64, 0x8000000000000001)), -0x1.000000p+63); + try test__floatdisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); + try test__floatdisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); + try test__floatdisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); +} + +test "floatundisf" { + try test__floatundisf(0, 0.0); + try test__floatundisf(1, 1.0); + try test__floatundisf(2, 2.0); + try test__floatundisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatundisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floatundisf(0x8000008000000000, 0x1p+63); + try test__floatundisf(0x8000010000000000, 0x1.000002p+63); + try test__floatundisf(0x8000000000000000, 0x1p+63); + try test__floatundisf(0x8000000000000001, 0x1p+63); + try test__floatundisf(0xFFFFFFFFFFFFFFFE, 0x1p+64); + try test__floatundisf(0xFFFFFFFFFFFFFFFF, 0x1p+64); + try test__floatundisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); + try test__floatundisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); + try test__floatundisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); +} + +fn test__floattisf(a: i128, expected: f32) !void { + const x = __floattisf(a); + try testing.expect(x == expected); +} + +fn test__floatuntisf(a: u128, expected: f32) !void { + const x = __floatuntisf(a); + try testing.expect(x == expected); +} + +test "floattisf" { + try test__floattisf(0, 0.0); + + try test__floattisf(1, 1.0); + try test__floattisf(2, 2.0); + try test__floattisf(-1, -1.0); + try test__floattisf(-2, -2.0); + + try test__floattisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floattisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + + try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000008000000000), -0x1.FFFFFEp+62); + try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000010000000000), -0x1.FFFFFCp+62); + + try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000000), -0x1.000000p+63); + try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000001), -0x1.000000p+63); + + try test__floattisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + + try test__floattisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); + try test__floattisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); + + try test__floattisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); + try test__floattisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); + + try test__floattisf(make_ti(0x0007FB72E8000000, 0), 0x1.FEDCBAp+114); + + try test__floattisf(make_ti(0x0007FB72EA000000, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72EB000000, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72EBFFFFFF, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72EC000000, 0), 0x1.FEDCBCp+114); + try test__floattisf(make_ti(0x0007FB72E8000001, 0), 0x1.FEDCBAp+114); + + try test__floattisf(make_ti(0x0007FB72E6000000, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72E7000000, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72E7FFFFFF, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72E4000001, 0), 0x1.FEDCBAp+114); + try test__floattisf(make_ti(0x0007FB72E4000000, 0), 0x1.FEDCB8p+114); +} + +test "floatuntisf" { + try test__floatuntisf(0, 0.0); + + try test__floatuntisf(1, 1.0); + try test__floatuntisf(2, 2.0); + try test__floatuntisf(20, 20.0); + + try test__floatuntisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatuntisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + + try test__floatuntisf(make_uti(0x8000008000000000, 0), 0x1.000001p+127); + try test__floatuntisf(make_uti(0x8000000000000800, 0), 0x1.0p+127); + try test__floatuntisf(make_uti(0x8000010000000000, 0), 0x1.000002p+127); + + try test__floatuntisf(make_uti(0x8000000000000000, 0), 0x1.000000p+127); + + try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + + try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + + try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + + try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + + try test__floatuntisf(0xFFFFFFFFFFFFFFFE, 0x1p+64); + try test__floatuntisf(0xFFFFFFFFFFFFFFFF, 0x1p+64); + + try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + + try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); + try test__floatuntisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); + + try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); + try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); + + try test__floatuntisf(make_uti(0x0000000000001FED, 0xCB90000000000001), 0x1.FEDCBAp+76); + try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBA0000000000000), 0x1.FEDCBAp+76); + try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBAFFFFFFFFFFFFF), 0x1.FEDCBAp+76); + try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBB0000000000000), 0x1.FEDCBCp+76); + try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBB0000000000001), 0x1.FEDCBCp+76); + try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBBFFFFFFFFFFFFF), 0x1.FEDCBCp+76); + try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBC0000000000000), 0x1.FEDCBCp+76); + try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBC0000000000001), 0x1.FEDCBCp+76); + try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBD0000000000000), 0x1.FEDCBCp+76); + try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBD0000000000001), 0x1.FEDCBEp+76); + try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBDFFFFFFFFFFFFF), 0x1.FEDCBEp+76); + try test__floatuntisf(make_uti(0x0000000000001FED, 0xCBE0000000000000), 0x1.FEDCBEp+76); + + // Test overflow to infinity + try test__floatuntisf(@as(u128, math.maxInt(u128)), @bitCast(f32, math.inf(f32))); +} + +fn test_one_floatsidf(a: i32, expected: u64) !void { + const r = __floatsidf(a); + try std.testing.expect(@bitCast(u64, r) == expected); +} + +fn test_one_floatunsidf(a: u32, expected: u64) !void { + const r = __floatunsidf(a); + try std.testing.expect(@bitCast(u64, r) == expected); +} + +test "floatsidf" { + try test_one_floatsidf(0, 0x0000000000000000); + try test_one_floatsidf(1, 0x3ff0000000000000); + try test_one_floatsidf(-1, 0xbff0000000000000); + try test_one_floatsidf(0x7FFFFFFF, 0x41dfffffffc00000); + try test_one_floatsidf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc1e0000000000000); +} + +test "floatunsidf" { + try test_one_floatunsidf(0, 0x0000000000000000); + try test_one_floatunsidf(1, 0x3ff0000000000000); + try test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000); + try test_one_floatunsidf(@intCast(u32, 0x80000000), 0x41e0000000000000); + try test_one_floatunsidf(@intCast(u32, 0xFFFFFFFF), 0x41efffffffe00000); +} + +fn test__floatdidf(a: i64, expected: f64) !void { + const r = __floatdidf(a); + try testing.expect(r == expected); +} + +fn test__floatundidf(a: u64, expected: f64) !void { + const r = __floatundidf(a); + try testing.expect(r == expected); +} + +test "floatdidf" { + try test__floatdidf(0, 0.0); + try test__floatdidf(1, 1.0); + try test__floatdidf(2, 2.0); + try test__floatdidf(20, 20.0); + try test__floatdidf(-1, -1.0); + try test__floatdidf(-2, -2.0); + try test__floatdidf(-20, -20.0); + try test__floatdidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatdidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); + try test__floatdidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floatdidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); + try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000008000000000)), -0x1.FFFFFEp+62); + try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000800)), -0x1.FFFFFFFFFFFFEp+62); + try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000010000000000)), -0x1.FFFFFCp+62); + try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000001000)), -0x1.FFFFFFFFFFFFCp+62); + try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000000)), -0x1.000000p+63); + try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000001)), -0x1.000000p+63); // 0x8000000000000001 + try test__floatdidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floatdidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floatdidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + try test__floatdidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); + try test__floatdidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + try test__floatdidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); + try test__floatdidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floatdidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floatdidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); + try test__floatdidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); + try test__floatdidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + try test__floatdidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); + try test__floatdidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); + try test__floatdidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); + try test__floatdidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); + try test__floatdidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); + try test__floatdidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); +} + +test "floatundidf" { + try test__floatundidf(0, 0.0); + try test__floatundidf(1, 1.0); + try test__floatundidf(2, 2.0); + try test__floatundidf(20, 20.0); + try test__floatundidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatundidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); + try test__floatundidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floatundidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); + try test__floatundidf(0x8000008000000000, 0x1.000001p+63); + try test__floatundidf(0x8000000000000800, 0x1.0000000000001p+63); + try test__floatundidf(0x8000010000000000, 0x1.000002p+63); + try test__floatundidf(0x8000000000001000, 0x1.0000000000002p+63); + try test__floatundidf(0x8000000000000000, 0x1p+63); + try test__floatundidf(0x8000000000000001, 0x1p+63); + try test__floatundidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + try test__floatundidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floatundidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + try test__floatundidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); + try test__floatundidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + try test__floatundidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); + try test__floatundidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floatundidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floatundidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); + try test__floatundidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); + try test__floatundidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + try test__floatundidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); + try test__floatundidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); + try test__floatundidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); + try test__floatundidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); + try test__floatundidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); + try test__floatundidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); +} + +fn test__floattidf(a: i128, expected: f64) !void { + const x = __floattidf(a); + try testing.expect(x == expected); +} + +fn test__floatuntidf(a: u128, expected: f64) !void { + const x = __floatuntidf(a); + try testing.expect(x == expected); +} + +test "floattidf" { + try test__floattidf(0, 0.0); + + try test__floattidf(1, 1.0); + try test__floattidf(2, 2.0); + try test__floattidf(20, 20.0); + try test__floattidf(-1, -1.0); + try test__floattidf(-2, -2.0); + try test__floattidf(-20, -20.0); + + try test__floattidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floattidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); + try test__floattidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floattidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); + + try test__floattidf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126); + try test__floattidf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126); + try test__floattidf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126); + try test__floattidf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126); + + try test__floattidf(make_ti(0x8000000000000000, 0), -0x1.000000p+127); + try test__floattidf(make_ti(0x8000000000000001, 0), -0x1.000000p+127); + + try test__floattidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + + try test__floattidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floattidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + try test__floattidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); + try test__floattidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + try test__floattidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); + + try test__floattidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floattidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floattidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); + try test__floattidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); + try test__floattidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + + try test__floattidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); + try test__floattidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); + try test__floattidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); + try test__floattidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); + try test__floattidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); + try test__floattidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); + + try test__floattidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121); + try test__floattidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121); + try test__floattidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121); + try test__floattidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121); + try test__floattidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121); + try test__floattidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); +} + +test "floatuntidf" { + try test__floatuntidf(0, 0.0); + + try test__floatuntidf(1, 1.0); + try test__floatuntidf(2, 2.0); + try test__floatuntidf(20, 20.0); + + try test__floatuntidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatuntidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); + try test__floatuntidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floatuntidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); + + try test__floatuntidf(make_uti(0x8000008000000000, 0), 0x1.000001p+127); + try test__floatuntidf(make_uti(0x8000000000000800, 0), 0x1.0000000000001p+127); + try test__floatuntidf(make_uti(0x8000010000000000, 0), 0x1.000002p+127); + try test__floatuntidf(make_uti(0x8000000000001000, 0), 0x1.0000000000002p+127); + + try test__floatuntidf(make_uti(0x8000000000000000, 0), 0x1.000000p+127); + try test__floatuntidf(make_uti(0x8000000000000001, 0), 0x1.0000000000000002p+127); + + try test__floatuntidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + + try test__floatuntidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floatuntidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + try test__floatuntidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); + try test__floatuntidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + try test__floatuntidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); + + try test__floatuntidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floatuntidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floatuntidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); + try test__floatuntidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); + try test__floatuntidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + + try test__floatuntidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); + try test__floatuntidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); + try test__floatuntidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); + try test__floatuntidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); + try test__floatuntidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); + try test__floatuntidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); + + try test__floatuntidf(make_uti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_uti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121); + try test__floatuntidf(make_uti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_uti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_uti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_uti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_uti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_uti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_uti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_uti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_uti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121); + try test__floatuntidf(make_uti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121); + try test__floatuntidf(make_uti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121); + try test__floatuntidf(make_uti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121); + try test__floatuntidf(make_uti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); +} + +fn test__floatsitf(a: i32, expected: u128) !void { + const r = __floatsitf(a); + try std.testing.expect(@bitCast(u128, r) == expected); +} + +test "floatsitf" { + try test__floatsitf(0, 0); + try test__floatsitf(0x7FFFFFFF, 0x401dfffffffc00000000000000000000); + try test__floatsitf(0x12345678, 0x401b2345678000000000000000000000); + try test__floatsitf(-0x12345678, 0xc01b2345678000000000000000000000); + try test__floatsitf(@bitCast(i32, @intCast(u32, 0xffffffff)), 0xbfff0000000000000000000000000000); + try test__floatsitf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc01e0000000000000000000000000000); +} + +fn test__floatunsitf(a: u32, expected_hi: u64, expected_lo: u64) !void { + const x = __floatunsitf(a); + + const x_repr = @bitCast(u128, x); + const x_hi = @intCast(u64, x_repr >> 64); + const x_lo = @truncate(u64, x_repr); + + if (x_hi == expected_hi and x_lo == expected_lo) { + return; + } + // nan repr + else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) { + if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) { + return; + } + } + + @panic("__floatunsitf test failure"); +} + +test "floatunsitf" { + try test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0); + try test__floatunsitf(0, 0x0, 0x0); + try test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0); + try test__floatunsitf(0x12345678, 0x401b234567800000, 0x0); +} + +fn test__floatditf(a: i64, expected: f128) !void { + const x = __floatditf(a); + try testing.expect(x == expected); +} + +fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) !void { + const x = __floatunditf(a); + + const x_repr = @bitCast(u128, x); + const x_hi = @intCast(u64, x_repr >> 64); + const x_lo = @truncate(u64, x_repr); + + if (x_hi == expected_hi and x_lo == expected_lo) { + return; + } + // nan repr + else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) { + if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) { + return; + } + } + + @panic("__floatunditf test failure"); +} + +test "floatditf" { + try test__floatditf(0x7fffffffffffffff, make_tf(0x403dffffffffffff, 0xfffc000000000000)); + try test__floatditf(0x123456789abcdef1, make_tf(0x403b23456789abcd, 0xef10000000000000)); + try test__floatditf(0x2, make_tf(0x4000000000000000, 0x0)); + try test__floatditf(0x1, make_tf(0x3fff000000000000, 0x0)); + try test__floatditf(0x0, make_tf(0x0, 0x0)); + try test__floatditf(@bitCast(i64, @as(u64, 0xffffffffffffffff)), make_tf(0xbfff000000000000, 0x0)); + try test__floatditf(@bitCast(i64, @as(u64, 0xfffffffffffffffe)), make_tf(0xc000000000000000, 0x0)); + try test__floatditf(-0x123456789abcdef1, make_tf(0xc03b23456789abcd, 0xef10000000000000)); + try test__floatditf(@bitCast(i64, @as(u64, 0x8000000000000000)), make_tf(0xc03e000000000000, 0x0)); +} + +test "floatunditf" { + try test__floatunditf(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000); + try test__floatunditf(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000); + try test__floatunditf(0x8000000000000000, 0x403e000000000000, 0x0); + try test__floatunditf(0x7fffffffffffffff, 0x403dffffffffffff, 0xfffc000000000000); + try test__floatunditf(0x123456789abcdef1, 0x403b23456789abcd, 0xef10000000000000); + try test__floatunditf(0x2, 0x4000000000000000, 0x0); + try test__floatunditf(0x1, 0x3fff000000000000, 0x0); + try test__floatunditf(0x0, 0x0, 0x0); +} + +fn test__floattitf(a: i128, expected: f128) !void { + const x = __floattitf(a); + try testing.expect(x == expected); +} + +fn test__floatuntitf(a: u128, expected: f128) !void { + const x = __floatuntitf(a); + try testing.expect(x == expected); +} + +test "floattitf" { + try test__floattitf(0, 0.0); + + try test__floattitf(1, 1.0); + try test__floattitf(2, 2.0); + try test__floattitf(20, 20.0); + try test__floattitf(-1, -1.0); + try test__floattitf(-2, -2.0); + try test__floattitf(-20, -20.0); + + try test__floattitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floattitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); + try test__floattitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floattitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); + + try test__floattitf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126); + try test__floattitf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126); + try test__floattitf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126); + try test__floattitf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126); + + try test__floattitf(make_ti(0x8000000000000000, 0), -0x1.000000p+127); + try test__floattitf(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126); + + try test__floattitf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + + try test__floattitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floattitf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + try test__floattitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); + try test__floattitf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + try test__floattitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); + + try test__floattitf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floattitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floattitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); + try test__floattitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); + try test__floattitf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + + try test__floattitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); + try test__floattitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57); + try test__floattitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57); + try test__floattitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57); + try test__floattitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57); + try test__floattitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57); + try test__floattitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57); + try test__floattitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57); + try test__floattitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57); + try test__floattitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57); + try test__floattitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57); + try test__floattitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57); + try test__floattitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57); + try test__floattitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57); + try test__floattitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); + + try test__floattitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); + try test__floattitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121); + try test__floattitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121); + try test__floattitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121); + try test__floattitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121); + try test__floattitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121); + try test__floattitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121); + try test__floattitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121); + try test__floattitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121); + try test__floattitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121); + try test__floattitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121); + try test__floattitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121); + try test__floattitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121); + try test__floattitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121); + try test__floattitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); + + try test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63); + + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124); + try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124); +} + +test "floatuntitf" { + try test__floatuntitf(0, 0.0); + + try test__floatuntitf(1, 1.0); + try test__floatuntitf(2, 2.0); + try test__floatuntitf(20, 20.0); + + try test__floatuntitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); + try test__floatuntitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); + try test__floatuntitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); + try test__floatuntitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); + try test__floatuntitf(0x7FFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFEp+59); + try test__floatuntitf(0xFFFFFFFFFFFFFFFE, 0xF.FFFFFFFFFFFFFFEp+60); + try test__floatuntitf(0xFFFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFFp+60); + + try test__floatuntitf(0x8000008000000000, 0x8.000008p+60); + try test__floatuntitf(0x8000000000000800, 0x8.0000000000008p+60); + try test__floatuntitf(0x8000010000000000, 0x8.00001p+60); + try test__floatuntitf(0x8000000000001000, 0x8.000000000001p+60); + + try test__floatuntitf(0x8000000000000000, 0x8p+60); + try test__floatuntitf(0x8000000000000001, 0x8.000000000000001p+60); + + try test__floatuntitf(0x0007FB72E8000000, 0x1.FEDCBAp+50); + + try test__floatuntitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); + try test__floatuntitf(0x0007FB72EB000000, 0x1.FEDCBACp+50); + try test__floatuntitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); + try test__floatuntitf(0x0007FB72EC000000, 0x1.FEDCBBp+50); + try test__floatuntitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); + + try test__floatuntitf(0x0007FB72E6000000, 0x1.FEDCB98p+50); + try test__floatuntitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); + try test__floatuntitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); + try test__floatuntitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); + try test__floatuntitf(0x0007FB72E4000000, 0x1.FEDCB9p+50); + + try test__floatuntitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); + try test__floatuntitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57); + try test__floatuntitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57); + try test__floatuntitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57); + try test__floatuntitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57); + try test__floatuntitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57); + try test__floatuntitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57); + try test__floatuntitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57); + try test__floatuntitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57); + try test__floatuntitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57); + try test__floatuntitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57); + try test__floatuntitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57); + try test__floatuntitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57); + try test__floatuntitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57); + try test__floatuntitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); + + try test__floatuntitf(make_uti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); + try test__floatuntitf(make_uti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121); + try test__floatuntitf(make_uti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121); + try test__floatuntitf(make_uti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121); + try test__floatuntitf(make_uti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121); + try test__floatuntitf(make_uti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121); + try test__floatuntitf(make_uti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121); + try test__floatuntitf(make_uti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121); + try test__floatuntitf(make_uti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121); + try test__floatuntitf(make_uti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121); + try test__floatuntitf(make_uti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121); + try test__floatuntitf(make_uti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121); + try test__floatuntitf(make_uti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121); + try test__floatuntitf(make_uti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121); + try test__floatuntitf(make_uti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); + + try test__floatuntitf(make_uti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63); + + try test__floatuntitf(make_uti(0xFFFFFFFFFFFFFFFF, 0x0000000000000000), 0x1.FFFFFFFFFFFFFFFEp+127); + try test__floatuntitf(make_uti(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x1.0000000000000000p+128); + + try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124); + try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124); + try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124); + try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124); + try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124); + try test__floatuntitf(make_uti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124); +} + +fn make_ti(high: u64, low: u64) i128 { + var result: u128 = high; + result <<= 64; + result |= low; + return @bitCast(i128, result); +} + +fn make_uti(high: u64, low: u64) u128 { + var result: u128 = high; + result <<= 64; + result |= low; + return result; +} + +fn make_tf(high: u64, low: u64) f128 { + var result: u128 = high; + result <<= 64; + result |= low; + return @bitCast(f128, result); +} + +test "conversion to f16" { + try testing.expect(floatXiYf(f16, @as(u32, 0)) == 0.0); + try testing.expect(floatXiYf(f16, @as(u32, 1)) == 1.0); + try testing.expect(floatXiYf(f16, @as(u32, 65504)) == 65504); + try testing.expect(floatXiYf(f16, @as(u32, 65504 + (1 << 4))) == math.inf(f16)); +} + +test "conversion to f32" { + try testing.expect(floatXiYf(f32, @as(u32, 0)) == 0.0); + try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u32))) != 1.0); + try testing.expect(floatXiYf(f32, @as(i32, math.minInt(i32))) != 1.0); + try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u24))) == math.maxInt(u24)); + try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u24)) + 1) == math.maxInt(u24) + 1); // 0x100_0000 - Exact + try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u24)) + 2) == math.maxInt(u24) + 1); // 0x100_0001 - Tie: Rounds down to even + try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u24)) + 3) == math.maxInt(u24) + 3); // 0x100_0002 - Exact + try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u24)) + 4) == math.maxInt(u24) + 5); // 0x100_0003 - Tie: Rounds up to even + try testing.expect(floatXiYf(f32, @as(u32, math.maxInt(u24)) + 5) == math.maxInt(u24) + 5); // 0x100_0004 - Exact +} + +test "conversion to f80" { + if (builtin.zig_backend == .stage1 and builtin.cpu.arch != .x86_64) + return error.SkipZigTest; // https://github.com/ziglang/zig/issues/11408 + + try testing.expect(floatXiYf(f80, @as(i80, -12)) == -12); + try testing.expect(@floatToInt(u80, floatXiYf(f80, @as(u64, math.maxInt(u64)) + 0)) == math.maxInt(u64) + 0); + try testing.expect(@floatToInt(u80, floatXiYf(f80, @as(u80, math.maxInt(u64)) + 1)) == math.maxInt(u64) + 1); + + try testing.expect(floatXiYf(f80, @as(u32, 0)) == 0.0); + try testing.expect(floatXiYf(f80, @as(u32, 1)) == 1.0); + try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u32, math.maxInt(u24)) + 0)) == math.maxInt(u24)); + try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u64)) + 0)) == math.maxInt(u64)); + try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u64)) + 1)) == math.maxInt(u64) + 1); // Exact + try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u64)) + 2)) == math.maxInt(u64) + 1); // Rounds down + try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u64)) + 3)) == math.maxInt(u64) + 3); // Tie - Exact + try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u64)) + 4)) == math.maxInt(u64) + 5); // Rounds up + + try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u65)) + 0)) == math.maxInt(u65) + 1); // Rounds up + try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u65)) + 1)) == math.maxInt(u65) + 1); // Exact + try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u65)) + 2)) == math.maxInt(u65) + 1); // Rounds down + try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u65)) + 3)) == math.maxInt(u65) + 1); // Tie - Rounds down + try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u65)) + 4)) == math.maxInt(u65) + 5); // Rounds up + try testing.expect(@floatToInt(u128, floatXiYf(f80, @as(u80, math.maxInt(u65)) + 5)) == math.maxInt(u65) + 5); // Exact +} diff --git a/lib/std/special/compiler_rt/floatXisf.zig b/lib/std/special/compiler_rt/floatXisf.zig deleted file mode 100644 index de3f4495cb..0000000000 --- a/lib/std/special/compiler_rt/floatXisf.zig +++ /dev/null @@ -1,90 +0,0 @@ -const builtin = @import("builtin"); -const std = @import("std"); -const maxInt = std.math.maxInt; - -const FLT_MANT_DIG = 24; - -inline fn floatXisf(comptime T: type, arg: T) f32 { - @setRuntimeSafety(builtin.is_test); - - const bits = @typeInfo(T).Int.bits; - const Z = std.meta.Int(.unsigned, bits); - const S = std.meta.Int(.unsigned, bits - @clz(Z, @as(Z, bits) - 1)); - - if (arg == 0) { - return @as(f32, 0.0); - } - - var ai = arg; - const N: u32 = bits; - const si = ai >> @intCast(S, (N - 1)); - ai = ((ai ^ si) -% si); - var a = @bitCast(Z, ai); - - const sd = @bitCast(i32, N - @clz(Z, a)); // number of significant digits - var e: i32 = sd - 1; // exponent - - if (sd > FLT_MANT_DIG) { - // start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx - // finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR - // 12345678901234567890123456 - // 1 = msb 1 bit - // P = bit FLT_MANT_DIG-1 bits to the right of 1 - // Q = bit FLT_MANT_DIG bits to the right of 1 - // R = "or" of all bits to the right of Q - switch (sd) { - FLT_MANT_DIG + 1 => { - a <<= 1; - }, - FLT_MANT_DIG + 2 => {}, - else => { - const shift1_amt = @intCast(i32, sd - (FLT_MANT_DIG + 2)); - const shift1_amt_u7 = @intCast(S, shift1_amt); - - const shift2_amt = @intCast(i32, N + (FLT_MANT_DIG + 2)) - sd; - const shift2_amt_u7 = @intCast(S, shift2_amt); - - a = (a >> shift1_amt_u7) | @boolToInt((a & (@intCast(Z, maxInt(Z)) >> shift2_amt_u7)) != 0); - }, - } - // finish - a |= @boolToInt((a & 4) != 0); // Or P into R - a += 1; // round - this step may add a significant bit - a >>= 2; // dump Q and R - // a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits - if ((a & (@as(Z, 1) << FLT_MANT_DIG)) != 0) { - a >>= 1; - e += 1; - } - // a is now rounded to FLT_MANT_DIG bits - } else { - a <<= @intCast(S, FLT_MANT_DIG - sd); - // a is now rounded to FLT_MANT_DIG bits - } - - const s = @bitCast(Z, arg) >> (@typeInfo(T).Int.bits - 32); - const r = (@intCast(u32, s) & 0x80000000) | // sign - (@intCast(u32, (e + 127)) << 23) | // exponent - (@truncate(u32, a) & 0x007fffff); // mantissa-high - - return @bitCast(f32, r); -} - -pub fn __floatdisf(arg: i64) callconv(.C) f32 { - return floatXisf(i64, arg); -} - -pub fn __floattisf(arg: i128) callconv(.C) f32 { - return floatXisf(i128, arg); -} - -pub fn __aeabi_l2f(arg: i64) callconv(.AAPCS) f32 { - return floatXisf(i64, arg); -} - -test { - _ = @import("floattisf_test.zig"); -} -test { - _ = @import("floattisf_test.zig"); -} diff --git a/lib/std/special/compiler_rt/floatdidf.zig b/lib/std/special/compiler_rt/floatdidf.zig deleted file mode 100644 index 16a514b615..0000000000 --- a/lib/std/special/compiler_rt/floatdidf.zig +++ /dev/null @@ -1,27 +0,0 @@ -const builtin = @import("builtin"); -const std = @import("std"); - -const twop52: f64 = 0x1.0p52; -const twop32: f64 = 0x1.0p32; - -pub fn __floatdidf(a: i64) callconv(.C) f64 { - @setRuntimeSafety(builtin.is_test); - - if (a == 0) return 0; - - var low = @bitCast(i64, twop52); - const high = @intToFloat(f64, @truncate(i32, a >> 32)) * twop32; - - low |= @bitCast(i64, a & 0xFFFFFFFF); - - return (high - twop52) + @bitCast(f64, low); -} - -pub fn __aeabi_l2d(arg: i64) callconv(.AAPCS) f64 { - @setRuntimeSafety(false); - return @call(.{ .modifier = .always_inline }, __floatdidf, .{arg}); -} - -test { - _ = @import("floatdidf_test.zig"); -} diff --git a/lib/std/special/compiler_rt/floatdidf_test.zig b/lib/std/special/compiler_rt/floatdidf_test.zig deleted file mode 100644 index 6b01ac5f3f..0000000000 --- a/lib/std/special/compiler_rt/floatdidf_test.zig +++ /dev/null @@ -1,53 +0,0 @@ -const __floatdidf = @import("floatdidf.zig").__floatdidf; -const testing = @import("std").testing; - -fn test__floatdidf(a: i64, expected: f64) !void { - const r = __floatdidf(a); - try testing.expect(r == expected); -} - -test "floatdidf" { - try test__floatdidf(0, 0.0); - try test__floatdidf(1, 1.0); - try test__floatdidf(2, 2.0); - try test__floatdidf(20, 20.0); - try test__floatdidf(-1, -1.0); - try test__floatdidf(-2, -2.0); - try test__floatdidf(-20, -20.0); - try test__floatdidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - try test__floatdidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); - try test__floatdidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - try test__floatdidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); - try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000008000000000)), -0x1.FFFFFEp+62); - try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000800)), -0x1.FFFFFFFFFFFFEp+62); - try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000010000000000)), -0x1.FFFFFCp+62); - try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000001000)), -0x1.FFFFFFFFFFFFCp+62); - try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000000)), -0x1.000000p+63); - try test__floatdidf(@bitCast(i64, @intCast(u64, 0x8000000000000001)), -0x1.000000p+63); - try test__floatdidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - try test__floatdidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - try test__floatdidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - try test__floatdidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); - try test__floatdidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - try test__floatdidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); - try test__floatdidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - try test__floatdidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - try test__floatdidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); - try test__floatdidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); - try test__floatdidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - try test__floatdidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); - try test__floatdidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); - try test__floatdidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); - try test__floatdidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); - try test__floatdidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); - try test__floatdidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); - try test__floatdidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); - try test__floatdidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); - try test__floatdidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); - try test__floatdidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); - try test__floatdidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); - try test__floatdidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); - try test__floatdidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); - try test__floatdidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); - try test__floatdidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); -} diff --git a/lib/std/special/compiler_rt/floatdisf_test.zig b/lib/std/special/compiler_rt/floatdisf_test.zig deleted file mode 100644 index 010c4faddd..0000000000 --- a/lib/std/special/compiler_rt/floatdisf_test.zig +++ /dev/null @@ -1,32 +0,0 @@ -const __floatdisf = @import("floatXisf.zig").__floatdisf; -const testing = @import("std").testing; - -fn test__floatdisf(a: i64, expected: f32) !void { - const x = __floatdisf(a); - try testing.expect(x == expected); -} - -test "floatdisf" { - try test__floatdisf(0, 0.0); - try test__floatdisf(1, 1.0); - try test__floatdisf(2, 2.0); - try test__floatdisf(-1, -1.0); - try test__floatdisf(-2, -2.0); - try test__floatdisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - try test__floatdisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - try test__floatdisf(0x8000008000000000, -0x1.FFFFFEp+62); - try test__floatdisf(0x8000010000000000, -0x1.FFFFFCp+62); - try test__floatdisf(0x8000000000000000, -0x1.000000p+63); - try test__floatdisf(0x8000000000000001, -0x1.000000p+63); - try test__floatdisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - try test__floatdisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); - try test__floatdisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); - try test__floatdisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); - try test__floatdisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); - try test__floatdisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); - try test__floatdisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); - try test__floatdisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); - try test__floatdisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); - try test__floatdisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); - try test__floatdisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); -} diff --git a/lib/std/special/compiler_rt/floatditf.zig b/lib/std/special/compiler_rt/floatditf.zig deleted file mode 100644 index fef696e6fb..0000000000 --- a/lib/std/special/compiler_rt/floatditf.zig +++ /dev/null @@ -1,38 +0,0 @@ -const builtin = @import("builtin"); -const is_test = builtin.is_test; -const std = @import("std"); -const maxInt = std.math.maxInt; - -const significandBits = 112; -const exponentBias = 16383; -const implicitBit = (@as(u128, 1) << significandBits); - -pub fn __floatditf(arg: i64) callconv(.C) f128 { - @setRuntimeSafety(is_test); - - if (arg == 0) - return 0.0; - - // All other cases begin by extracting the sign and absolute value of a - var sign: u128 = 0; - var aAbs = @bitCast(u64, arg); - if (arg < 0) { - sign = 1 << 127; - aAbs = ~@bitCast(u64, arg) + 1; - } - - // Exponent of (fp_t)a is the width of abs(a). - const exponent = 63 - @clz(u64, aAbs); - var result: u128 = undefined; - - // Shift a into the significand field, rounding if it is a right-shift - const shift = significandBits - exponent; - result = @as(u128, aAbs) << shift ^ implicitBit; - - result += (@as(u128, exponent) + exponentBias) << significandBits; - return @bitCast(f128, result | sign); -} - -test { - _ = @import("floatditf_test.zig"); -} diff --git a/lib/std/special/compiler_rt/floatditf_test.zig b/lib/std/special/compiler_rt/floatditf_test.zig deleted file mode 100644 index cf8a81c68c..0000000000 --- a/lib/std/special/compiler_rt/floatditf_test.zig +++ /dev/null @@ -1,26 +0,0 @@ -const __floatditf = @import("floatditf.zig").__floatditf; -const testing = @import("std").testing; - -fn test__floatditf(a: i64, expected: f128) !void { - const x = __floatditf(a); - try testing.expect(x == expected); -} - -test "floatditf" { - try test__floatditf(0x7fffffffffffffff, make_ti(0x403dffffffffffff, 0xfffc000000000000)); - try test__floatditf(0x123456789abcdef1, make_ti(0x403b23456789abcd, 0xef10000000000000)); - try test__floatditf(0x2, make_ti(0x4000000000000000, 0x0)); - try test__floatditf(0x1, make_ti(0x3fff000000000000, 0x0)); - try test__floatditf(0x0, make_ti(0x0, 0x0)); - try test__floatditf(@bitCast(i64, @as(u64, 0xffffffffffffffff)), make_ti(0xbfff000000000000, 0x0)); - try test__floatditf(@bitCast(i64, @as(u64, 0xfffffffffffffffe)), make_ti(0xc000000000000000, 0x0)); - try test__floatditf(-0x123456789abcdef1, make_ti(0xc03b23456789abcd, 0xef10000000000000)); - try test__floatditf(@bitCast(i64, @as(u64, 0x8000000000000000)), make_ti(0xc03e000000000000, 0x0)); -} - -fn make_ti(high: u64, low: u64) f128 { - var result: u128 = high; - result <<= 64; - result |= low; - return @bitCast(f128, result); -} diff --git a/lib/std/special/compiler_rt/floatfmodl_test.zig b/lib/std/special/compiler_rt/floatfmodl_test.zig deleted file mode 100644 index 22b981d5f2..0000000000 --- a/lib/std/special/compiler_rt/floatfmodl_test.zig +++ /dev/null @@ -1,46 +0,0 @@ -const std = @import("std"); -const fmodl = @import("floatfmodl.zig"); -const testing = std.testing; - -fn test_fmodl(a: f128, b: f128, exp: f128) !void { - const res = fmodl.fmodl(a, b); - try testing.expect(exp == res); -} - -fn test_fmodl_nans() !void { - try testing.expect(std.math.isNan(fmodl.fmodl(1.0, std.math.nan_f128))); - try testing.expect(std.math.isNan(fmodl.fmodl(1.0, -std.math.nan_f128))); - try testing.expect(std.math.isNan(fmodl.fmodl(std.math.nan_f128, 1.0))); - try testing.expect(std.math.isNan(fmodl.fmodl(-std.math.nan_f128, 1.0))); -} - -fn test_fmodl_infs() !void { - try testing.expect(fmodl.fmodl(1.0, std.math.inf(f128)) == 1.0); - try testing.expect(fmodl.fmodl(1.0, -std.math.inf(f128)) == 1.0); - try testing.expect(std.math.isNan(fmodl.fmodl(std.math.inf(f128), 1.0))); - try testing.expect(std.math.isNan(fmodl.fmodl(-std.math.inf(f128), 1.0))); -} - -test "fmodl" { - try test_fmodl(6.8, 4.0, 2.8); - try test_fmodl(6.8, -4.0, 2.8); - try test_fmodl(-6.8, 4.0, -2.8); - try test_fmodl(-6.8, -4.0, -2.8); - try test_fmodl(3.0, 2.0, 1.0); - try test_fmodl(-5.0, 3.0, -2.0); - try test_fmodl(3.0, 2.0, 1.0); - try test_fmodl(1.0, 2.0, 1.0); - try test_fmodl(0.0, 1.0, 0.0); - try test_fmodl(-0.0, 1.0, -0.0); - try test_fmodl(7046119.0, 5558362.0, 1487757.0); - try test_fmodl(9010357.0, 1957236.0, 1181413.0); - - // Denormals - const a: f128 = 0xedcb34a235253948765432134674p-16494; - const b: f128 = 0x5d2e38791cfbc0737402da5a9518p-16494; - const exp: f128 = 0x336ec3affb2db8618e4e7d5e1c44p-16494; - try test_fmodl(a, b, exp); - - try test_fmodl_nans(); - try test_fmodl_infs(); -} diff --git a/lib/std/special/compiler_rt/floatfmodl.zig b/lib/std/special/compiler_rt/floatfmodq.zig index 942a7c1125..b8da727c90 100644 --- a/lib/std/special/compiler_rt/floatfmodl.zig +++ b/lib/std/special/compiler_rt/floatfmodq.zig @@ -1,9 +1,9 @@ const builtin = @import("builtin"); const std = @import("std"); -// fmodl - floating modulo large, returns the remainder of division for f128 types +// fmodq - floating modulo large, returns the remainder of division for f128 types // Logic and flow heavily inspired by MUSL fmodl for 113 mantissa digits -pub fn fmodl(a: f128, b: f128) callconv(.C) f128 { +pub fn fmodq(a: f128, b: f128) callconv(.C) f128 { @setRuntimeSafety(builtin.is_test); var amod = a; var bmod = b; @@ -30,9 +30,9 @@ pub fn fmodl(a: f128, b: f128) callconv(.C) f128 { var expB = bPtr_u16[exp_and_sign_index] & 0x7fff; // There are 3 cases where the answer is undefined, check for: - // - fmodl(val, 0) - // - fmodl(val, NaN) - // - fmodl(inf, val) + // - fmodq(val, 0) + // - fmodq(val, NaN) + // - fmodq(inf, val) // The sign on checked values does not matter. // Doing (a * b) / (a * b) procudes undefined results // because the three cases always produce undefined calculations: @@ -122,5 +122,5 @@ pub fn fmodl(a: f128, b: f128) callconv(.C) f128 { } test { - _ = @import("floatfmodl_test.zig"); + _ = @import("floatfmodq_test.zig"); } diff --git a/lib/std/special/compiler_rt/floatfmodq_test.zig b/lib/std/special/compiler_rt/floatfmodq_test.zig new file mode 100644 index 0000000000..a272b797e3 --- /dev/null +++ b/lib/std/special/compiler_rt/floatfmodq_test.zig @@ -0,0 +1,46 @@ +const std = @import("std"); +const fmodq = @import("floatfmodq.zig"); +const testing = std.testing; + +fn test_fmodq(a: f128, b: f128, exp: f128) !void { + const res = fmodq.fmodq(a, b); + try testing.expect(exp == res); +} + +fn test_fmodq_nans() !void { + try testing.expect(std.math.isNan(fmodq.fmodq(1.0, std.math.nan(f128)))); + try testing.expect(std.math.isNan(fmodq.fmodq(1.0, -std.math.nan(f128)))); + try testing.expect(std.math.isNan(fmodq.fmodq(std.math.nan(f128), 1.0))); + try testing.expect(std.math.isNan(fmodq.fmodq(-std.math.nan(f128), 1.0))); +} + +fn test_fmodq_infs() !void { + try testing.expect(fmodq.fmodq(1.0, std.math.inf(f128)) == 1.0); + try testing.expect(fmodq.fmodq(1.0, -std.math.inf(f128)) == 1.0); + try testing.expect(std.math.isNan(fmodq.fmodq(std.math.inf(f128), 1.0))); + try testing.expect(std.math.isNan(fmodq.fmodq(-std.math.inf(f128), 1.0))); +} + +test "fmodq" { + try test_fmodq(6.8, 4.0, 2.8); + try test_fmodq(6.8, -4.0, 2.8); + try test_fmodq(-6.8, 4.0, -2.8); + try test_fmodq(-6.8, -4.0, -2.8); + try test_fmodq(3.0, 2.0, 1.0); + try test_fmodq(-5.0, 3.0, -2.0); + try test_fmodq(3.0, 2.0, 1.0); + try test_fmodq(1.0, 2.0, 1.0); + try test_fmodq(0.0, 1.0, 0.0); + try test_fmodq(-0.0, 1.0, -0.0); + try test_fmodq(7046119.0, 5558362.0, 1487757.0); + try test_fmodq(9010357.0, 1957236.0, 1181413.0); + + // Denormals + const a: f128 = 0xedcb34a235253948765432134674p-16494; + const b: f128 = 0x5d2e38791cfbc0737402da5a9518p-16494; + const exp: f128 = 0x336ec3affb2db8618e4e7d5e1c44p-16494; + try test_fmodq(a, b, exp); + + try test_fmodq_nans(); + try test_fmodq_infs(); +} diff --git a/lib/std/special/compiler_rt/floatsiXf.zig b/lib/std/special/compiler_rt/floatsiXf.zig deleted file mode 100644 index ef551d1911..0000000000 --- a/lib/std/special/compiler_rt/floatsiXf.zig +++ /dev/null @@ -1,120 +0,0 @@ -const builtin = @import("builtin"); -const std = @import("std"); -const maxInt = std.math.maxInt; - -inline fn floatsiXf(comptime T: type, a: i32) T { - @setRuntimeSafety(builtin.is_test); - - const bits = @typeInfo(T).Float.bits; - const Z = std.meta.Int(.unsigned, bits); - const S = std.meta.Int(.unsigned, bits - @clz(Z, @as(Z, bits) - 1)); - - if (a == 0) { - return @as(T, 0.0); - } - - const significandBits = std.math.floatMantissaBits(T); - const exponentBits = std.math.floatExponentBits(T); - const exponentBias = ((1 << exponentBits - 1) - 1); - - const implicitBit = @as(Z, 1) << significandBits; - const signBit = @as(Z, 1 << bits - 1); - - const sign = a >> 31; - // Take absolute value of a via abs(x) = (x^(x >> 31)) - (x >> 31). - const abs_a = (a ^ sign) -% sign; - // The exponent is the width of abs(a) - const exp = @as(Z, 31 - @clz(i32, abs_a)); - - const sign_bit = if (sign < 0) signBit else 0; - - var mantissa: Z = undefined; - // Shift a into the significand field and clear the implicit bit. - if (exp <= significandBits) { - // No rounding needed - const shift = @intCast(S, significandBits - exp); - mantissa = @intCast(Z, @bitCast(u32, abs_a)) << shift ^ implicitBit; - } else { - const shift = @intCast(S, exp - significandBits); - // Round to the nearest number after truncation - mantissa = @intCast(Z, @bitCast(u32, abs_a)) >> shift ^ implicitBit; - // Align to the left and check if the truncated part is halfway over - const round = @bitCast(u32, abs_a) << @intCast(u5, 31 - shift); - mantissa += @boolToInt(round > 0x80000000); - // Tie to even - mantissa += mantissa & 1; - } - - // Use the addition instead of a or since we may have a carry from the - // mantissa to the exponent - var result = mantissa; - result += (exp + exponentBias) << significandBits; - result += sign_bit; - - return @bitCast(T, result); -} - -pub fn __floatsisf(arg: i32) callconv(.C) f32 { - @setRuntimeSafety(builtin.is_test); - return floatsiXf(f32, arg); -} - -pub fn __floatsidf(arg: i32) callconv(.C) f64 { - @setRuntimeSafety(builtin.is_test); - return floatsiXf(f64, arg); -} - -pub fn __floatsitf(arg: i32) callconv(.C) f128 { - @setRuntimeSafety(builtin.is_test); - return floatsiXf(f128, arg); -} - -pub fn __aeabi_i2d(arg: i32) callconv(.AAPCS) f64 { - @setRuntimeSafety(false); - return floatsiXf(f64, arg); -} - -pub fn __aeabi_i2f(arg: i32) callconv(.AAPCS) f32 { - @setRuntimeSafety(false); - return floatsiXf(f32, arg); -} - -fn test_one_floatsitf(a: i32, expected: u128) !void { - const r = __floatsitf(a); - try std.testing.expect(@bitCast(u128, r) == expected); -} - -fn test_one_floatsidf(a: i32, expected: u64) !void { - const r = __floatsidf(a); - try std.testing.expect(@bitCast(u64, r) == expected); -} - -fn test_one_floatsisf(a: i32, expected: u32) !void { - const r = __floatsisf(a); - try std.testing.expect(@bitCast(u32, r) == expected); -} - -test "floatsidf" { - try test_one_floatsidf(0, 0x0000000000000000); - try test_one_floatsidf(1, 0x3ff0000000000000); - try test_one_floatsidf(-1, 0xbff0000000000000); - try test_one_floatsidf(0x7FFFFFFF, 0x41dfffffffc00000); - try test_one_floatsidf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc1e0000000000000); -} - -test "floatsisf" { - try test_one_floatsisf(0, 0x00000000); - try test_one_floatsisf(1, 0x3f800000); - try test_one_floatsisf(-1, 0xbf800000); - try test_one_floatsisf(0x7FFFFFFF, 0x4f000000); - try test_one_floatsisf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xcf000000); -} - -test "floatsitf" { - try test_one_floatsitf(0, 0); - try test_one_floatsitf(0x7FFFFFFF, 0x401dfffffffc00000000000000000000); - try test_one_floatsitf(0x12345678, 0x401b2345678000000000000000000000); - try test_one_floatsitf(-0x12345678, 0xc01b2345678000000000000000000000); - try test_one_floatsitf(@bitCast(i32, @intCast(u32, 0xffffffff)), 0xbfff0000000000000000000000000000); - try test_one_floatsitf(@bitCast(i32, @intCast(u32, 0x80000000)), 0xc01e0000000000000000000000000000); -} diff --git a/lib/std/special/compiler_rt/floattidf.zig b/lib/std/special/compiler_rt/floattidf.zig deleted file mode 100644 index 85f84a23d6..0000000000 --- a/lib/std/special/compiler_rt/floattidf.zig +++ /dev/null @@ -1,71 +0,0 @@ -const builtin = @import("builtin"); -const is_test = builtin.is_test; -const std = @import("std"); -const maxInt = std.math.maxInt; - -const DBL_MANT_DIG = 53; - -pub fn __floattidf(arg: i128) callconv(.C) f64 { - @setRuntimeSafety(is_test); - - if (arg == 0) - return 0.0; - - var ai = arg; - const N: u32 = 128; - const si = ai >> @intCast(u7, (N - 1)); - ai = ((ai ^ si) -% si); - var a = @bitCast(u128, ai); - - const sd = @bitCast(i32, N - @clz(u128, a)); // number of significant digits - var e: i32 = sd - 1; // exponent - if (sd > DBL_MANT_DIG) { - // start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx - // finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR - // 12345678901234567890123456 - // 1 = msb 1 bit - // P = bit DBL_MANT_DIG-1 bits to the right of 1 - // Q = bit DBL_MANT_DIG bits to the right of 1 - // R = "or" of all bits to the right of Q - switch (sd) { - DBL_MANT_DIG + 1 => { - a <<= 1; - }, - DBL_MANT_DIG + 2 => {}, - else => { - const shift1_amt = @intCast(i32, sd - (DBL_MANT_DIG + 2)); - const shift1_amt_u7 = @intCast(u7, shift1_amt); - - const shift2_amt = @intCast(i32, N + (DBL_MANT_DIG + 2)) - sd; - const shift2_amt_u7 = @intCast(u7, shift2_amt); - - a = (a >> shift1_amt_u7) | @boolToInt((a & (@intCast(u128, maxInt(u128)) >> shift2_amt_u7)) != 0); - }, - } - // finish - a |= @boolToInt((a & 4) != 0); // Or P into R - a += 1; // round - this step may add a significant bit - a >>= 2; // dump Q and R - // a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits - if ((a & (@as(u128, 1) << DBL_MANT_DIG)) != 0) { - a >>= 1; - e += 1; - } - // a is now rounded to DBL_MANT_DIG bits - } else { - a <<= @intCast(u7, DBL_MANT_DIG - sd); - // a is now rounded to DBL_MANT_DIG bits - } - - const s = @bitCast(u128, arg) >> (128 - 32); - const high: u64 = (@intCast(u64, s) & 0x80000000) | // sign - (@intCast(u32, (e + 1023)) << 20) | // exponent - (@truncate(u32, a >> 32) & 0x000fffff); // mantissa-high - const low: u64 = @truncate(u32, a); // mantissa-low - - return @bitCast(f64, low | (high << 32)); -} - -test { - _ = @import("floattidf_test.zig"); -} diff --git a/lib/std/special/compiler_rt/floattidf_test.zig b/lib/std/special/compiler_rt/floattidf_test.zig deleted file mode 100644 index 62b131744f..0000000000 --- a/lib/std/special/compiler_rt/floattidf_test.zig +++ /dev/null @@ -1,84 +0,0 @@ -const __floattidf = @import("floattidf.zig").__floattidf; -const testing = @import("std").testing; - -fn test__floattidf(a: i128, expected: f64) !void { - const x = __floattidf(a); - try testing.expect(x == expected); -} - -test "floattidf" { - try test__floattidf(0, 0.0); - - try test__floattidf(1, 1.0); - try test__floattidf(2, 2.0); - try test__floattidf(20, 20.0); - try test__floattidf(-1, -1.0); - try test__floattidf(-2, -2.0); - try test__floattidf(-20, -20.0); - - try test__floattidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - try test__floattidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); - try test__floattidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - try test__floattidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); - - try test__floattidf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126); - try test__floattidf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126); - try test__floattidf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126); - try test__floattidf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126); - - try test__floattidf(make_ti(0x8000000000000000, 0), -0x1.000000p+127); - try test__floattidf(make_ti(0x8000000000000001, 0), -0x1.000000p+127); - - try test__floattidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - - try test__floattidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - try test__floattidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - try test__floattidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); - try test__floattidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - try test__floattidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); - - try test__floattidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - try test__floattidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - try test__floattidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); - try test__floattidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); - try test__floattidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - - try test__floattidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); - try test__floattidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); - try test__floattidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); - try test__floattidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); - try test__floattidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); - try test__floattidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); - try test__floattidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); - try test__floattidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); - try test__floattidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); - try test__floattidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); - try test__floattidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); - try test__floattidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); - try test__floattidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); - try test__floattidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); - try test__floattidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); - - try test__floattidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); - try test__floattidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121); - try test__floattidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121); - try test__floattidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121); - try test__floattidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121); - try test__floattidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121); - try test__floattidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121); - try test__floattidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121); - try test__floattidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121); - try test__floattidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121); - try test__floattidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121); - try test__floattidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121); - try test__floattidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121); - try test__floattidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121); - try test__floattidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); -} - -fn make_ti(high: u64, low: u64) i128 { - var result: u128 = high; - result <<= 64; - result |= low; - return @bitCast(i128, result); -} diff --git a/lib/std/special/compiler_rt/floattisf_test.zig b/lib/std/special/compiler_rt/floattisf_test.zig deleted file mode 100644 index 30b36c3f9f..0000000000 --- a/lib/std/special/compiler_rt/floattisf_test.zig +++ /dev/null @@ -1,60 +0,0 @@ -const __floattisf = @import("floatXisf.zig").__floattisf; -const testing = @import("std").testing; - -fn test__floattisf(a: i128, expected: f32) !void { - const x = __floattisf(a); - try testing.expect(x == expected); -} - -test "floattisf" { - try test__floattisf(0, 0.0); - - try test__floattisf(1, 1.0); - try test__floattisf(2, 2.0); - try test__floattisf(-1, -1.0); - try test__floattisf(-2, -2.0); - - try test__floattisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - try test__floattisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - - try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000008000000000), -0x1.FFFFFEp+62); - try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000010000000000), -0x1.FFFFFCp+62); - - try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000000), -0x1.000000p+63); - try test__floattisf(make_ti(0xFFFFFFFFFFFFFFFF, 0x8000000000000001), -0x1.000000p+63); - - try test__floattisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - - try test__floattisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); - try test__floattisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); - try test__floattisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); - try test__floattisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); - try test__floattisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); - - try test__floattisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); - try test__floattisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); - try test__floattisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); - try test__floattisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); - try test__floattisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); - - try test__floattisf(make_ti(0x0007FB72E8000000, 0), 0x1.FEDCBAp+114); - - try test__floattisf(make_ti(0x0007FB72EA000000, 0), 0x1.FEDCBAp+114); - try test__floattisf(make_ti(0x0007FB72EB000000, 0), 0x1.FEDCBAp+114); - try test__floattisf(make_ti(0x0007FB72EBFFFFFF, 0), 0x1.FEDCBAp+114); - try test__floattisf(make_ti(0x0007FB72EC000000, 0), 0x1.FEDCBCp+114); - try test__floattisf(make_ti(0x0007FB72E8000001, 0), 0x1.FEDCBAp+114); - - try test__floattisf(make_ti(0x0007FB72E6000000, 0), 0x1.FEDCBAp+114); - try test__floattisf(make_ti(0x0007FB72E7000000, 0), 0x1.FEDCBAp+114); - try test__floattisf(make_ti(0x0007FB72E7FFFFFF, 0), 0x1.FEDCBAp+114); - try test__floattisf(make_ti(0x0007FB72E4000001, 0), 0x1.FEDCBAp+114); - try test__floattisf(make_ti(0x0007FB72E4000000, 0), 0x1.FEDCB8p+114); -} - -fn make_ti(high: u64, low: u64) i128 { - var result: u128 = high; - result <<= 64; - result |= low; - return @bitCast(i128, result); -} diff --git a/lib/std/special/compiler_rt/floattitf.zig b/lib/std/special/compiler_rt/floattitf.zig deleted file mode 100644 index aa83f6686e..0000000000 --- a/lib/std/special/compiler_rt/floattitf.zig +++ /dev/null @@ -1,71 +0,0 @@ -const builtin = @import("builtin"); -const is_test = builtin.is_test; -const std = @import("std"); -const maxInt = std.math.maxInt; - -const LDBL_MANT_DIG = 113; - -pub fn __floattitf(arg: i128) callconv(.C) f128 { - @setRuntimeSafety(is_test); - - if (arg == 0) - return 0.0; - - var ai = arg; - const N: u32 = 128; - const si = ai >> @intCast(u7, (N - 1)); - ai = ((ai ^ si) -% si); - var a = @bitCast(u128, ai); - - const sd = @bitCast(i32, N - @clz(u128, a)); // number of significant digits - var e: i32 = sd - 1; // exponent - if (sd > LDBL_MANT_DIG) { - // start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx - // finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR - // 12345678901234567890123456 - // 1 = msb 1 bit - // P = bit LDBL_MANT_DIG-1 bits to the right of 1 - // Q = bit LDBL_MANT_DIG bits to the right of 1 - // R = "or" of all bits to the right of Q - switch (sd) { - LDBL_MANT_DIG + 1 => { - a <<= 1; - }, - LDBL_MANT_DIG + 2 => {}, - else => { - const shift1_amt = @intCast(i32, sd - (LDBL_MANT_DIG + 2)); - const shift1_amt_u7 = @intCast(u7, shift1_amt); - - const shift2_amt = @intCast(i32, N + (LDBL_MANT_DIG + 2)) - sd; - const shift2_amt_u7 = @intCast(u7, shift2_amt); - - a = (a >> shift1_amt_u7) | @boolToInt((a & (@intCast(u128, maxInt(u128)) >> shift2_amt_u7)) != 0); - }, - } - // finish - a |= @boolToInt((a & 4) != 0); // Or P into R - a += 1; // round - this step may add a significant bit - a >>= 2; // dump Q and R - // a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits - if ((a & (@as(u128, 1) << LDBL_MANT_DIG)) != 0) { - a >>= 1; - e += 1; - } - // a is now rounded to LDBL_MANT_DIG bits - } else { - a <<= @intCast(u7, LDBL_MANT_DIG - sd); - // a is now rounded to LDBL_MANT_DIG bits - } - - const s = @bitCast(u128, arg) >> (128 - 64); - const high: u128 = (@intCast(u64, s) & 0x8000000000000000) | // sign - (@intCast(u64, (e + 16383)) << 48) | // exponent - (@truncate(u64, a >> 64) & 0x0000ffffffffffff); // mantissa-high - const low = @truncate(u64, a); // mantissa-low - - return @bitCast(f128, low | (high << 64)); -} - -test { - _ = @import("floattitf_test.zig"); -} diff --git a/lib/std/special/compiler_rt/floattitf_test.zig b/lib/std/special/compiler_rt/floattitf_test.zig deleted file mode 100644 index 76dfc8fbfc..0000000000 --- a/lib/std/special/compiler_rt/floattitf_test.zig +++ /dev/null @@ -1,96 +0,0 @@ -const __floattitf = @import("floattitf.zig").__floattitf; -const testing = @import("std").testing; - -fn test__floattitf(a: i128, expected: f128) !void { - const x = __floattitf(a); - try testing.expect(x == expected); -} - -test "floattitf" { - try test__floattitf(0, 0.0); - - try test__floattitf(1, 1.0); - try test__floattitf(2, 2.0); - try test__floattitf(20, 20.0); - try test__floattitf(-1, -1.0); - try test__floattitf(-2, -2.0); - try test__floattitf(-20, -20.0); - - try test__floattitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - try test__floattitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); - try test__floattitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - try test__floattitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); - - try test__floattitf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126); - try test__floattitf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126); - try test__floattitf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126); - try test__floattitf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126); - - try test__floattitf(make_ti(0x8000000000000000, 0), -0x1.000000p+127); - try test__floattitf(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126); - - try test__floattitf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - - try test__floattitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - try test__floattitf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - try test__floattitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); - try test__floattitf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - try test__floattitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); - - try test__floattitf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - try test__floattitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - try test__floattitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); - try test__floattitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); - try test__floattitf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - - try test__floattitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); - try test__floattitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57); - try test__floattitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57); - try test__floattitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57); - try test__floattitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57); - try test__floattitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57); - try test__floattitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57); - try test__floattitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57); - try test__floattitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57); - try test__floattitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57); - try test__floattitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57); - try test__floattitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57); - try test__floattitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57); - try test__floattitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57); - try test__floattitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); - - try test__floattitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); - try test__floattitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121); - try test__floattitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121); - try test__floattitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121); - try test__floattitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121); - try test__floattitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121); - try test__floattitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121); - try test__floattitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121); - try test__floattitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121); - try test__floattitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121); - try test__floattitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121); - try test__floattitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121); - try test__floattitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121); - try test__floattitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121); - try test__floattitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); - - try test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63); - - try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124); - try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124); - try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124); - try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124); - try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124); - try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124); - try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124); - try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124); - try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124); -} - -fn make_ti(high: u64, low: u64) i128 { - var result: u128 = high; - result <<= 64; - result |= low; - return @bitCast(i128, result); -} diff --git a/lib/std/special/compiler_rt/floatundidf.zig b/lib/std/special/compiler_rt/floatundidf.zig deleted file mode 100644 index 14e7434490..0000000000 --- a/lib/std/special/compiler_rt/floatundidf.zig +++ /dev/null @@ -1,29 +0,0 @@ -const builtin = @import("builtin"); -const std = @import("std"); - -const twop52: f64 = 0x1.0p52; -const twop84: f64 = 0x1.0p84; -const twop84_plus_twop52: f64 = 0x1.00000001p84; - -pub fn __floatundidf(a: u64) callconv(.C) f64 { - @setRuntimeSafety(builtin.is_test); - - if (a == 0) return 0; - - var high = @bitCast(u64, twop84); - var low = @bitCast(u64, twop52); - - high |= a >> 32; - low |= a & 0xFFFFFFFF; - - return (@bitCast(f64, high) - twop84_plus_twop52) + @bitCast(f64, low); -} - -pub fn __aeabi_ul2d(arg: u64) callconv(.AAPCS) f64 { - @setRuntimeSafety(false); - return @call(.{ .modifier = .always_inline }, __floatundidf, .{arg}); -} - -test { - _ = @import("floatundidf_test.zig"); -} diff --git a/lib/std/special/compiler_rt/floatundidf_test.zig b/lib/std/special/compiler_rt/floatundidf_test.zig deleted file mode 100644 index 71bfdd3087..0000000000 --- a/lib/std/special/compiler_rt/floatundidf_test.zig +++ /dev/null @@ -1,50 +0,0 @@ -const __floatundidf = @import("floatundidf.zig").__floatundidf; -const testing = @import("std").testing; - -fn test__floatundidf(a: u64, expected: f64) !void { - const r = __floatundidf(a); - try testing.expect(r == expected); -} - -test "floatundidf" { - try test__floatundidf(0, 0.0); - try test__floatundidf(1, 1.0); - try test__floatundidf(2, 2.0); - try test__floatundidf(20, 20.0); - try test__floatundidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - try test__floatundidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); - try test__floatundidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - try test__floatundidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); - try test__floatundidf(0x8000008000000000, 0x1.000001p+63); - try test__floatundidf(0x8000000000000800, 0x1.0000000000001p+63); - try test__floatundidf(0x8000010000000000, 0x1.000002p+63); - try test__floatundidf(0x8000000000001000, 0x1.0000000000002p+63); - try test__floatundidf(0x8000000000000000, 0x1p+63); - try test__floatundidf(0x8000000000000001, 0x1p+63); - try test__floatundidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - try test__floatundidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - try test__floatundidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - try test__floatundidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); - try test__floatundidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - try test__floatundidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); - try test__floatundidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - try test__floatundidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - try test__floatundidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); - try test__floatundidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); - try test__floatundidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - try test__floatundidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); - try test__floatundidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); - try test__floatundidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); - try test__floatundidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); - try test__floatundidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); - try test__floatundidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); - try test__floatundidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); - try test__floatundidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); - try test__floatundidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); - try test__floatundidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); - try test__floatundidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); - try test__floatundidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); - try test__floatundidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); - try test__floatundidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); - try test__floatundidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); -} diff --git a/lib/std/special/compiler_rt/floatundisf.zig b/lib/std/special/compiler_rt/floatundisf.zig deleted file mode 100644 index ffbe3ef252..0000000000 --- a/lib/std/special/compiler_rt/floatundisf.zig +++ /dev/null @@ -1,94 +0,0 @@ -const builtin = @import("builtin"); -const std = @import("std"); -const maxInt = std.math.maxInt; - -const FLT_MANT_DIG = 24; - -inline fn floatundisf(arg: u64) f32 { - @setRuntimeSafety(builtin.is_test); - - if (arg == 0) return 0; - - var a = arg; - const N: usize = @typeInfo(@TypeOf(a)).Int.bits; - // Number of significant digits - const sd = N - @clz(u64, a); - // 8 exponent - var e = @intCast(u32, sd) - 1; - - if (sd > FLT_MANT_DIG) { - // start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx - // finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR - // 12345678901234567890123456 - // 1 = msb 1 bit - // P = bit FLT_MANT_DIG-1 bits to the right of 1 - // Q = bit FLT_MANT_DIG bits to the right of 1 - // R = "or" of all bits to the right of Q - switch (sd) { - FLT_MANT_DIG + 1 => a <<= 1, - FLT_MANT_DIG + 2 => {}, - else => { - const shift_amt = @intCast(u6, ((N + FLT_MANT_DIG + 2) - sd)); - const all_ones: u64 = maxInt(u64); - a = (a >> @intCast(u6, sd - (FLT_MANT_DIG + 2))) | - @boolToInt(a & (all_ones >> shift_amt) != 0); - }, - } - // Or P into R - a |= @boolToInt((a & 4) != 0); - // round - this step may add a significant bit - a += 1; - // dump Q and R - a >>= 2; - // a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits - if ((a & (@as(u64, 1) << FLT_MANT_DIG)) != 0) { - a >>= 1; - e += 1; - } - // a is now rounded to FLT_MANT_DIG bits - } else { - a <<= @intCast(u6, FLT_MANT_DIG - sd); - // a is now rounded to FLT_MANT_DIG bits - } - - const result: u32 = ((e + 127) << 23) | // exponent - @truncate(u32, a & 0x007FFFFF); // mantissa - return @bitCast(f32, result); -} - -pub fn __floatundisf(arg: u64) callconv(.C) f32 { - return floatundisf(arg); -} - -pub fn __aeabi_ul2f(arg: u64) callconv(.AAPCS) f32 { - return floatundisf(arg); -} - -fn test__floatundisf(a: u64, expected: f32) !void { - try std.testing.expectEqual(expected, __floatundisf(a)); -} - -test "floatundisf" { - try test__floatundisf(0, 0.0); - try test__floatundisf(1, 1.0); - try test__floatundisf(2, 2.0); - try test__floatundisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - try test__floatundisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - try test__floatundisf(0x8000008000000000, 0x1p+63); - try test__floatundisf(0x8000010000000000, 0x1.000002p+63); - try test__floatundisf(0x8000000000000000, 0x1p+63); - try test__floatundisf(0x8000000000000001, 0x1p+63); - try test__floatundisf(0xFFFFFFFFFFFFFFFE, 0x1p+64); - try test__floatundisf(0xFFFFFFFFFFFFFFFF, 0x1p+64); - try test__floatundisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - try test__floatundisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); - try test__floatundisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); - try test__floatundisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); - try test__floatundisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); - try test__floatundisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); - try test__floatundisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); - try test__floatundisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); - try test__floatundisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); - try test__floatundisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); - try test__floatundisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); -} diff --git a/lib/std/special/compiler_rt/floatunditf.zig b/lib/std/special/compiler_rt/floatunditf.zig deleted file mode 100644 index b304c8cdba..0000000000 --- a/lib/std/special/compiler_rt/floatunditf.zig +++ /dev/null @@ -1,28 +0,0 @@ -const builtin = @import("builtin"); -const is_test = builtin.is_test; -const std = @import("std"); - -pub fn __floatunditf(a: u64) callconv(.C) f128 { - @setRuntimeSafety(is_test); - - if (a == 0) { - return 0; - } - - const mantissa_bits = std.math.floatMantissaBits(f128); - const exponent_bits = std.math.floatExponentBits(f128); - const exponent_bias = (1 << (exponent_bits - 1)) - 1; - const implicit_bit = 1 << mantissa_bits; - - const exp: u128 = (64 - 1) - @clz(u64, a); - const shift: u7 = mantissa_bits - @intCast(u7, exp); - - var result: u128 = (@intCast(u128, a) << shift) ^ implicit_bit; - result += (exp + exponent_bias) << mantissa_bits; - - return @bitCast(f128, result); -} - -test { - _ = @import("floatunditf_test.zig"); -} diff --git a/lib/std/special/compiler_rt/floatunditf_test.zig b/lib/std/special/compiler_rt/floatunditf_test.zig deleted file mode 100644 index ae6834c082..0000000000 --- a/lib/std/special/compiler_rt/floatunditf_test.zig +++ /dev/null @@ -1,32 +0,0 @@ -const __floatunditf = @import("floatunditf.zig").__floatunditf; - -fn test__floatunditf(a: u64, expected_hi: u64, expected_lo: u64) !void { - const x = __floatunditf(a); - - const x_repr = @bitCast(u128, x); - const x_hi = @intCast(u64, x_repr >> 64); - const x_lo = @truncate(u64, x_repr); - - if (x_hi == expected_hi and x_lo == expected_lo) { - return; - } - // nan repr - else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) { - if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) { - return; - } - } - - @panic("__floatunditf test failure"); -} - -test "floatunditf" { - try test__floatunditf(0xffffffffffffffff, 0x403effffffffffff, 0xfffe000000000000); - try test__floatunditf(0xfffffffffffffffe, 0x403effffffffffff, 0xfffc000000000000); - try test__floatunditf(0x8000000000000000, 0x403e000000000000, 0x0); - try test__floatunditf(0x7fffffffffffffff, 0x403dffffffffffff, 0xfffc000000000000); - try test__floatunditf(0x123456789abcdef1, 0x403b23456789abcd, 0xef10000000000000); - try test__floatunditf(0x2, 0x4000000000000000, 0x0); - try test__floatunditf(0x1, 0x3fff000000000000, 0x0); - try test__floatunditf(0x0, 0x0, 0x0); -} diff --git a/lib/std/special/compiler_rt/floatunsidf.zig b/lib/std/special/compiler_rt/floatunsidf.zig deleted file mode 100644 index f474c1de8f..0000000000 --- a/lib/std/special/compiler_rt/floatunsidf.zig +++ /dev/null @@ -1,41 +0,0 @@ -const builtin = @import("builtin"); -const std = @import("std"); -const maxInt = std.math.maxInt; - -const implicitBit = @as(u64, 1) << 52; - -inline fn floatunsidf(arg: u32) f64 { - @setRuntimeSafety(builtin.is_test); - - if (arg == 0) return 0.0; - - // The exponent is the width of abs(a) - const exp = @as(u64, 31) - @clz(u32, arg); - // Shift a into the significand field and clear the implicit bit - const shift = @intCast(u6, 52 - exp); - const mant = @as(u64, arg) << shift ^ implicitBit; - - return @bitCast(f64, mant | (exp + 1023) << 52); -} - -pub fn __floatunsidf(arg: u32) callconv(.C) f64 { - return floatunsidf(arg); -} - -pub fn __aeabi_ui2d(arg: u32) callconv(.AAPCS) f64 { - return floatunsidf(arg); -} - -fn test_one_floatunsidf(a: u32, expected: u64) !void { - const r = __floatunsidf(a); - try std.testing.expect(@bitCast(u64, r) == expected); -} - -test "floatsidf" { - // Test the produced bit pattern - try test_one_floatunsidf(0, 0x0000000000000000); - try test_one_floatunsidf(1, 0x3ff0000000000000); - try test_one_floatunsidf(0x7FFFFFFF, 0x41dfffffffc00000); - try test_one_floatunsidf(@intCast(u32, 0x80000000), 0x41e0000000000000); - try test_one_floatunsidf(@intCast(u32, 0xFFFFFFFF), 0x41efffffffe00000); -} diff --git a/lib/std/special/compiler_rt/floatunsisf.zig b/lib/std/special/compiler_rt/floatunsisf.zig deleted file mode 100644 index d267baee01..0000000000 --- a/lib/std/special/compiler_rt/floatunsisf.zig +++ /dev/null @@ -1,61 +0,0 @@ -const builtin = @import("builtin"); -const std = @import("std"); -const maxInt = std.math.maxInt; - -const significandBits = 23; -const exponentBias = 127; -const implicitBit = @as(u32, 1) << significandBits; - -inline fn floatunsisf(arg: u32) f32 { - @setRuntimeSafety(builtin.is_test); - - if (arg == 0) return 0.0; - - // The exponent is the width of abs(a) - const exp = @as(u32, 31) - @clz(u32, arg); - - var mantissa: u32 = undefined; - if (exp <= significandBits) { - // Shift a into the significand field and clear the implicit bit - const shift = @intCast(u5, significandBits - exp); - mantissa = @as(u32, arg) << shift ^ implicitBit; - } else { - const shift = @intCast(u5, exp - significandBits); - // Round to the nearest number after truncation - mantissa = @as(u32, arg) >> shift ^ implicitBit; - // Align to the left and check if the truncated part is halfway over - const round = arg << @intCast(u5, 31 - shift); - mantissa += @boolToInt(round > 0x80000000); - // Tie to even - mantissa += mantissa & 1; - } - - // Use the addition instead of a or since we may have a carry from the - // mantissa to the exponent - var result = mantissa; - result += (exp + exponentBias) << significandBits; - - return @bitCast(f32, result); -} - -pub fn __floatunsisf(arg: u32) callconv(.C) f32 { - return floatunsisf(arg); -} - -pub fn __aeabi_ui2f(arg: u32) callconv(.AAPCS) f32 { - return floatunsisf(arg); -} - -fn test_one_floatunsisf(a: u32, expected: u32) !void { - const r = __floatunsisf(a); - try std.testing.expect(@bitCast(u32, r) == expected); -} - -test "floatunsisf" { - // Test the produced bit pattern - try test_one_floatunsisf(0, 0); - try test_one_floatunsisf(1, 0x3f800000); - try test_one_floatunsisf(0x7FFFFFFF, 0x4f000000); - try test_one_floatunsisf(0x80000000, 0x4f000000); - try test_one_floatunsisf(0xFFFFFFFF, 0x4f800000); -} diff --git a/lib/std/special/compiler_rt/floatunsitf.zig b/lib/std/special/compiler_rt/floatunsitf.zig deleted file mode 100644 index 8774d486ea..0000000000 --- a/lib/std/special/compiler_rt/floatunsitf.zig +++ /dev/null @@ -1,29 +0,0 @@ -const builtin = @import("builtin"); -const is_test = builtin.is_test; -const std = @import("std"); - -pub fn __floatunsitf(a: u32) callconv(.C) f128 { - @setRuntimeSafety(is_test); - - if (a == 0) { - return 0; - } - - const mantissa_bits = std.math.floatMantissaBits(f128); - const exponent_bits = std.math.floatExponentBits(f128); - const exponent_bias = (1 << (exponent_bits - 1)) - 1; - const implicit_bit = 1 << mantissa_bits; - - const exp = (32 - 1) - @clz(u32, a); - const shift = mantissa_bits - @intCast(u7, exp); - - // TODO(#1148): @bitCast alignment error - var result align(16) = (@intCast(u128, a) << shift) ^ implicit_bit; - result += (@intCast(u128, exp) + exponent_bias) << mantissa_bits; - - return @bitCast(f128, result); -} - -test { - _ = @import("floatunsitf_test.zig"); -} diff --git a/lib/std/special/compiler_rt/floatunsitf_test.zig b/lib/std/special/compiler_rt/floatunsitf_test.zig deleted file mode 100644 index 7ae7c43281..0000000000 --- a/lib/std/special/compiler_rt/floatunsitf_test.zig +++ /dev/null @@ -1,28 +0,0 @@ -const __floatunsitf = @import("floatunsitf.zig").__floatunsitf; - -fn test__floatunsitf(a: u32, expected_hi: u64, expected_lo: u64) !void { - const x = __floatunsitf(a); - - const x_repr = @bitCast(u128, x); - const x_hi = @intCast(u64, x_repr >> 64); - const x_lo = @truncate(u64, x_repr); - - if (x_hi == expected_hi and x_lo == expected_lo) { - return; - } - // nan repr - else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) { - if ((x_hi & 0x7fff000000000000) == 0x7fff000000000000 and ((x_hi & 0xffffffffffff) > 0 or x_lo > 0)) { - return; - } - } - - @panic("__floatunsitf test failure"); -} - -test "floatunsitf" { - try test__floatunsitf(0x7fffffff, 0x401dfffffffc0000, 0x0); - try test__floatunsitf(0, 0x0, 0x0); - try test__floatunsitf(0xffffffff, 0x401efffffffe0000, 0x0); - try test__floatunsitf(0x12345678, 0x401b234567800000, 0x0); -} diff --git a/lib/std/special/compiler_rt/floatuntidf.zig b/lib/std/special/compiler_rt/floatuntidf.zig deleted file mode 100644 index 2c4729a9d8..0000000000 --- a/lib/std/special/compiler_rt/floatuntidf.zig +++ /dev/null @@ -1,62 +0,0 @@ -const builtin = @import("builtin"); -const is_test = builtin.is_test; -const std = @import("std"); -const maxInt = std.math.maxInt; - -const DBL_MANT_DIG = 53; - -pub fn __floatuntidf(arg: u128) callconv(.C) f64 { - @setRuntimeSafety(is_test); - - if (arg == 0) - return 0.0; - - var a = arg; - const N: u32 = @sizeOf(u128) * 8; - const sd = @bitCast(i32, N - @clz(u128, a)); // number of significant digits - var e: i32 = sd - 1; // exponent - if (sd > DBL_MANT_DIG) { - // start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx - // finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR - // 12345678901234567890123456 - // 1 = msb 1 bit - // P = bit DBL_MANT_DIG-1 bits to the right of 1 - // Q = bit DBL_MANT_DIG bits to the right of 1 - // R = "or" of all bits to the right of Q - switch (sd) { - DBL_MANT_DIG + 1 => { - a <<= 1; - }, - DBL_MANT_DIG + 2 => {}, - else => { - const shift_amt = @bitCast(i32, N + (DBL_MANT_DIG + 2)) - sd; - const shift_amt_u7 = @intCast(u7, shift_amt); - a = (a >> @intCast(u7, sd - (DBL_MANT_DIG + 2))) | - @boolToInt((a & (@as(u128, maxInt(u128)) >> shift_amt_u7)) != 0); - }, - } - // finish - a |= @boolToInt((a & 4) != 0); // Or P into R - a += 1; // round - this step may add a significant bit - a >>= 2; // dump Q and R - // a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits - if ((a & (@as(u128, 1) << DBL_MANT_DIG)) != 0) { - a >>= 1; - e += 1; - } - // a is now rounded to DBL_MANT_DIG bits - } else { - a <<= @intCast(u7, DBL_MANT_DIG - sd); - // a is now rounded to DBL_MANT_DIG bits - } - - const high: u64 = @bitCast(u32, (e + 1023) << 20) | // exponent - (@truncate(u32, a >> 32) & 0x000FFFFF); // mantissa-high - const low = @truncate(u32, a); // mantissa-low - - return @bitCast(f64, low | (high << 32)); -} - -test { - _ = @import("floatuntidf_test.zig"); -} diff --git a/lib/std/special/compiler_rt/floatuntidf_test.zig b/lib/std/special/compiler_rt/floatuntidf_test.zig deleted file mode 100644 index 5fc6a47150..0000000000 --- a/lib/std/special/compiler_rt/floatuntidf_test.zig +++ /dev/null @@ -1,81 +0,0 @@ -const __floatuntidf = @import("floatuntidf.zig").__floatuntidf; -const testing = @import("std").testing; - -fn test__floatuntidf(a: u128, expected: f64) !void { - const x = __floatuntidf(a); - try testing.expect(x == expected); -} - -test "floatuntidf" { - try test__floatuntidf(0, 0.0); - - try test__floatuntidf(1, 1.0); - try test__floatuntidf(2, 2.0); - try test__floatuntidf(20, 20.0); - - try test__floatuntidf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - try test__floatuntidf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); - try test__floatuntidf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - try test__floatuntidf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); - - try test__floatuntidf(make_ti(0x8000008000000000, 0), 0x1.000001p+127); - try test__floatuntidf(make_ti(0x8000000000000800, 0), 0x1.0000000000001p+127); - try test__floatuntidf(make_ti(0x8000010000000000, 0), 0x1.000002p+127); - try test__floatuntidf(make_ti(0x8000000000001000, 0), 0x1.0000000000002p+127); - - try test__floatuntidf(make_ti(0x8000000000000000, 0), 0x1.000000p+127); - try test__floatuntidf(make_ti(0x8000000000000001, 0), 0x1.0000000000000002p+127); - - try test__floatuntidf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - - try test__floatuntidf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - try test__floatuntidf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - try test__floatuntidf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); - try test__floatuntidf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - try test__floatuntidf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); - - try test__floatuntidf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - try test__floatuntidf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - try test__floatuntidf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); - try test__floatuntidf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); - try test__floatuntidf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - - try test__floatuntidf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); - try test__floatuntidf(0x023479FD0E092DA1, 0x1.1A3CFE870496Dp+57); - try test__floatuntidf(0x023479FD0E092DB0, 0x1.1A3CFE870496Ep+57); - try test__floatuntidf(0x023479FD0E092DB8, 0x1.1A3CFE870496Ep+57); - try test__floatuntidf(0x023479FD0E092DB6, 0x1.1A3CFE870496Ep+57); - try test__floatuntidf(0x023479FD0E092DBF, 0x1.1A3CFE870496Ep+57); - try test__floatuntidf(0x023479FD0E092DC1, 0x1.1A3CFE870496Ep+57); - try test__floatuntidf(0x023479FD0E092DC7, 0x1.1A3CFE870496Ep+57); - try test__floatuntidf(0x023479FD0E092DC8, 0x1.1A3CFE870496Ep+57); - try test__floatuntidf(0x023479FD0E092DCF, 0x1.1A3CFE870496Ep+57); - try test__floatuntidf(0x023479FD0E092DD0, 0x1.1A3CFE870496Ep+57); - try test__floatuntidf(0x023479FD0E092DD1, 0x1.1A3CFE870496Fp+57); - try test__floatuntidf(0x023479FD0E092DD8, 0x1.1A3CFE870496Fp+57); - try test__floatuntidf(0x023479FD0E092DDF, 0x1.1A3CFE870496Fp+57); - try test__floatuntidf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); - - try test__floatuntidf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); - try test__floatuntidf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496Dp+121); - try test__floatuntidf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496Ep+121); - try test__floatuntidf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496Ep+121); - try test__floatuntidf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496Ep+121); - try test__floatuntidf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496Ep+121); - try test__floatuntidf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496Ep+121); - try test__floatuntidf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496Ep+121); - try test__floatuntidf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496Ep+121); - try test__floatuntidf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496Ep+121); - try test__floatuntidf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496Ep+121); - try test__floatuntidf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496Fp+121); - try test__floatuntidf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496Fp+121); - try test__floatuntidf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496Fp+121); - try test__floatuntidf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); -} - -fn make_ti(high: u64, low: u64) u128 { - var result: u128 = high; - result <<= 64; - result |= low; - return result; -} diff --git a/lib/std/special/compiler_rt/floatuntisf.zig b/lib/std/special/compiler_rt/floatuntisf.zig deleted file mode 100644 index 2a54c2e0f3..0000000000 --- a/lib/std/special/compiler_rt/floatuntisf.zig +++ /dev/null @@ -1,61 +0,0 @@ -const builtin = @import("builtin"); -const is_test = builtin.is_test; -const std = @import("std"); -const maxInt = std.math.maxInt; - -const FLT_MANT_DIG = 24; - -pub fn __floatuntisf(arg: u128) callconv(.C) f32 { - @setRuntimeSafety(is_test); - - if (arg == 0) - return 0.0; - - var a = arg; - const N: u32 = @sizeOf(u128) * 8; - const sd = @bitCast(i32, N - @clz(u128, a)); // number of significant digits - var e: i32 = sd - 1; // exponent - if (sd > FLT_MANT_DIG) { - // start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx - // finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR - // 12345678901234567890123456 - // 1 = msb 1 bit - // P = bit FLT_MANT_DIG-1 bits to the right of 1 - // Q = bit FLT_MANT_DIG bits to the right of 1 - // R = "or" of all bits to the right of Q - switch (sd) { - FLT_MANT_DIG + 1 => { - a <<= 1; - }, - FLT_MANT_DIG + 2 => {}, - else => { - const shift_amt = @bitCast(i32, N + (FLT_MANT_DIG + 2)) - sd; - const shift_amt_u7 = @intCast(u7, shift_amt); - a = (a >> @intCast(u7, sd - (FLT_MANT_DIG + 2))) | - @boolToInt((a & (@as(u128, maxInt(u128)) >> shift_amt_u7)) != 0); - }, - } - // finish - a |= @boolToInt((a & 4) != 0); // Or P into R - a += 1; // round - this step may add a significant bit - a >>= 2; // dump Q and R - // a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits - if ((a & (@as(u128, 1) << FLT_MANT_DIG)) != 0) { - a >>= 1; - e += 1; - } - // a is now rounded to FLT_MANT_DIG bits - } else { - a <<= @intCast(u7, FLT_MANT_DIG - sd); - // a is now rounded to FLT_MANT_DIG bits - } - - const high = @bitCast(u32, (e + 127) << 23); // exponent - const low = @truncate(u32, a) & 0x007fffff; // mantissa - - return @bitCast(f32, high | low); -} - -test { - _ = @import("floatuntisf_test.zig"); -} diff --git a/lib/std/special/compiler_rt/floatuntisf_test.zig b/lib/std/special/compiler_rt/floatuntisf_test.zig deleted file mode 100644 index dd06b7e3d7..0000000000 --- a/lib/std/special/compiler_rt/floatuntisf_test.zig +++ /dev/null @@ -1,72 +0,0 @@ -const __floatuntisf = @import("floatuntisf.zig").__floatuntisf; -const testing = @import("std").testing; - -fn test__floatuntisf(a: u128, expected: f32) !void { - const x = __floatuntisf(a); - try testing.expect(x == expected); -} - -test "floatuntisf" { - try test__floatuntisf(0, 0.0); - - try test__floatuntisf(1, 1.0); - try test__floatuntisf(2, 2.0); - try test__floatuntisf(20, 20.0); - - try test__floatuntisf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - try test__floatuntisf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - - try test__floatuntisf(make_ti(0x8000008000000000, 0), 0x1.000001p+127); - try test__floatuntisf(make_ti(0x8000000000000800, 0), 0x1.0p+127); - try test__floatuntisf(make_ti(0x8000010000000000, 0), 0x1.000002p+127); - - try test__floatuntisf(make_ti(0x8000000000000000, 0), 0x1.000000p+127); - - try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - - try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - - try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - - try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - - try test__floatuntisf(0xFFFFFFFFFFFFFFFE, 0x1p+64); - try test__floatuntisf(0xFFFFFFFFFFFFFFFF, 0x1p+64); - - try test__floatuntisf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - - try test__floatuntisf(0x0007FB72EA000000, 0x1.FEDCBAp+50); - try test__floatuntisf(0x0007FB72EB000000, 0x1.FEDCBAp+50); - try test__floatuntisf(0x0007FB72EBFFFFFF, 0x1.FEDCBAp+50); - try test__floatuntisf(0x0007FB72EC000000, 0x1.FEDCBCp+50); - try test__floatuntisf(0x0007FB72E8000001, 0x1.FEDCBAp+50); - - try test__floatuntisf(0x0007FB72E6000000, 0x1.FEDCBAp+50); - try test__floatuntisf(0x0007FB72E7000000, 0x1.FEDCBAp+50); - try test__floatuntisf(0x0007FB72E7FFFFFF, 0x1.FEDCBAp+50); - try test__floatuntisf(0x0007FB72E4000001, 0x1.FEDCBAp+50); - try test__floatuntisf(0x0007FB72E4000000, 0x1.FEDCB8p+50); - - try test__floatuntisf(make_ti(0x0000000000001FED, 0xCB90000000000001), 0x1.FEDCBAp+76); - try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBA0000000000000), 0x1.FEDCBAp+76); - try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBAFFFFFFFFFFFFF), 0x1.FEDCBAp+76); - try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000000), 0x1.FEDCBCp+76); - try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBB0000000000001), 0x1.FEDCBCp+76); - try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBBFFFFFFFFFFFFF), 0x1.FEDCBCp+76); - try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000000), 0x1.FEDCBCp+76); - try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBC0000000000001), 0x1.FEDCBCp+76); - try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000000), 0x1.FEDCBCp+76); - try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBD0000000000001), 0x1.FEDCBEp+76); - try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBDFFFFFFFFFFFFF), 0x1.FEDCBEp+76); - try test__floatuntisf(make_ti(0x0000000000001FED, 0xCBE0000000000000), 0x1.FEDCBEp+76); -} - -fn make_ti(high: u64, low: u64) u128 { - var result: u128 = high; - result <<= 64; - result |= low; - return result; -} diff --git a/lib/std/special/compiler_rt/floatuntitf.zig b/lib/std/special/compiler_rt/floatuntitf.zig deleted file mode 100644 index c35b4dcf74..0000000000 --- a/lib/std/special/compiler_rt/floatuntitf.zig +++ /dev/null @@ -1,62 +0,0 @@ -const builtin = @import("builtin"); -const is_test = builtin.is_test; -const std = @import("std"); -const maxInt = std.math.maxInt; - -const LDBL_MANT_DIG = 113; - -pub fn __floatuntitf(arg: u128) callconv(.C) f128 { - @setRuntimeSafety(is_test); - - if (arg == 0) - return 0.0; - - var a = arg; - const N: u32 = @sizeOf(u128) * 8; - const sd = @bitCast(i32, N - @clz(u128, a)); // number of significant digits - var e: i32 = sd - 1; // exponent - if (sd > LDBL_MANT_DIG) { - // start: 0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx - // finish: 000000000000000000000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQR - // 12345678901234567890123456 - // 1 = msb 1 bit - // P = bit LDBL_MANT_DIG-1 bits to the right of 1 - // Q = bit LDBL_MANT_DIG bits to the right of 1 - // R = "or" of all bits to the right of Q - switch (sd) { - LDBL_MANT_DIG + 1 => { - a <<= 1; - }, - LDBL_MANT_DIG + 2 => {}, - else => { - const shift_amt = @bitCast(i32, N + (LDBL_MANT_DIG + 2)) - sd; - const shift_amt_u7 = @intCast(u7, shift_amt); - a = (a >> @intCast(u7, sd - (LDBL_MANT_DIG + 2))) | - @boolToInt((a & (@as(u128, maxInt(u128)) >> shift_amt_u7)) != 0); - }, - } - // finish - a |= @boolToInt((a & 4) != 0); // Or P into R - a += 1; // round - this step may add a significant bit - a >>= 2; // dump Q and R - // a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits - if ((a & (@as(u128, 1) << LDBL_MANT_DIG)) != 0) { - a >>= 1; - e += 1; - } - // a is now rounded to LDBL_MANT_DIG bits - } else { - a <<= @intCast(u7, LDBL_MANT_DIG - sd); - // a is now rounded to LDBL_MANT_DIG bits - } - - const high: u128 = (@intCast(u64, (e + 16383)) << 48) | // exponent - (@truncate(u64, a >> 64) & 0x0000ffffffffffff); // mantissa-high - const low = @truncate(u64, a); // mantissa-low - - return @bitCast(f128, low | (high << 64)); -} - -test { - _ = @import("floatuntitf_test.zig"); -} diff --git a/lib/std/special/compiler_rt/floatuntitf_test.zig b/lib/std/special/compiler_rt/floatuntitf_test.zig deleted file mode 100644 index 5afbf348c6..0000000000 --- a/lib/std/special/compiler_rt/floatuntitf_test.zig +++ /dev/null @@ -1,99 +0,0 @@ -const __floatuntitf = @import("floatuntitf.zig").__floatuntitf; -const testing = @import("std").testing; - -fn test__floatuntitf(a: u128, expected: f128) !void { - const x = __floatuntitf(a); - try testing.expect(x == expected); -} - -test "floatuntitf" { - try test__floatuntitf(0, 0.0); - - try test__floatuntitf(1, 1.0); - try test__floatuntitf(2, 2.0); - try test__floatuntitf(20, 20.0); - - try test__floatuntitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62); - try test__floatuntitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62); - try test__floatuntitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62); - try test__floatuntitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62); - try test__floatuntitf(0x7FFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFEp+59); - try test__floatuntitf(0xFFFFFFFFFFFFFFFE, 0xF.FFFFFFFFFFFFFFEp+60); - try test__floatuntitf(0xFFFFFFFFFFFFFFFF, 0xF.FFFFFFFFFFFFFFFp+60); - - try test__floatuntitf(0x8000008000000000, 0x8.000008p+60); - try test__floatuntitf(0x8000000000000800, 0x8.0000000000008p+60); - try test__floatuntitf(0x8000010000000000, 0x8.00001p+60); - try test__floatuntitf(0x8000000000001000, 0x8.000000000001p+60); - - try test__floatuntitf(0x8000000000000000, 0x8p+60); - try test__floatuntitf(0x8000000000000001, 0x8.000000000000001p+60); - - try test__floatuntitf(0x0007FB72E8000000, 0x1.FEDCBAp+50); - - try test__floatuntitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50); - try test__floatuntitf(0x0007FB72EB000000, 0x1.FEDCBACp+50); - try test__floatuntitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50); - try test__floatuntitf(0x0007FB72EC000000, 0x1.FEDCBBp+50); - try test__floatuntitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50); - - try test__floatuntitf(0x0007FB72E6000000, 0x1.FEDCB98p+50); - try test__floatuntitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50); - try test__floatuntitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50); - try test__floatuntitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50); - try test__floatuntitf(0x0007FB72E4000000, 0x1.FEDCB9p+50); - - try test__floatuntitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57); - try test__floatuntitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57); - try test__floatuntitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57); - try test__floatuntitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57); - try test__floatuntitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57); - try test__floatuntitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57); - try test__floatuntitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57); - try test__floatuntitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57); - try test__floatuntitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57); - try test__floatuntitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57); - try test__floatuntitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57); - try test__floatuntitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57); - try test__floatuntitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57); - try test__floatuntitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57); - try test__floatuntitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57); - - try test__floatuntitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121); - try test__floatuntitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121); - try test__floatuntitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121); - try test__floatuntitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121); - try test__floatuntitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121); - try test__floatuntitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121); - try test__floatuntitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121); - try test__floatuntitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121); - try test__floatuntitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121); - try test__floatuntitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121); - try test__floatuntitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121); - try test__floatuntitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121); - try test__floatuntitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121); - try test__floatuntitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121); - try test__floatuntitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121); - - try test__floatuntitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63); - - try test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0x0000000000000000), 0x1.FFFFFFFFFFFFFFFEp+127); - try test__floatuntitf(make_ti(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF), 0x1.0000000000000000p+128); - - try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124); - try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124); - try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124); - try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124); - try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124); - try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124); - try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124); - try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124); - try test__floatuntitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124); -} - -fn make_ti(high: u64, low: u64) u128 { - var result: u128 = high; - result <<= 64; - result |= low; - return result; -} diff --git a/lib/std/special/compiler_rt/sparc.zig b/lib/std/special/compiler_rt/sparc.zig index 3f2cbd86b5..3b33afd29a 100644 --- a/lib/std/special/compiler_rt/sparc.zig +++ b/lib/std/special/compiler_rt/sparc.zig @@ -66,19 +66,19 @@ pub fn _Qp_fge(a: *f128, b: *f128) callconv(.C) bool { // Conversion pub fn _Qp_itoq(c: *f128, a: i32) callconv(.C) void { - c.* = @import("floatsiXf.zig").__floatsitf(a); + c.* = @import("floatXiYf.zig").__floatsitf(a); } pub fn _Qp_uitoq(c: *f128, a: u32) callconv(.C) void { - c.* = @import("floatunsitf.zig").__floatunsitf(a); + c.* = @import("floatXiYf.zig").__floatunsitf(a); } pub fn _Qp_xtoq(c: *f128, a: i64) callconv(.C) void { - c.* = @import("floatditf.zig").__floatditf(a); + c.* = @import("floatXiYf.zig").__floatditf(a); } pub fn _Qp_uxtoq(c: *f128, a: u64) callconv(.C) void { - c.* = @import("floatunditf.zig").__floatunditf(a); + c.* = @import("floatXiYf.zig").__floatunditf(a); } 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 { } pub fn _Qp_qtoi(a: *f128) callconv(.C) i32 { - return @import("fixtfsi.zig").__fixtfsi(a.*); + return @import("fixXfYi.zig").__fixtfsi(a.*); } pub fn _Qp_qtoui(a: *f128) callconv(.C) u32 { - return @import("fixunstfsi.zig").__fixunstfsi(a.*); + return @import("fixXfYi.zig").__fixunstfsi(a.*); } pub fn _Qp_qtox(a: *f128) callconv(.C) i64 { - return @import("fixtfdi.zig").__fixtfdi(a.*); + return @import("fixXfYi.zig").__fixtfdi(a.*); } pub fn _Qp_qtoux(a: *f128) callconv(.C) u64 { - return @import("fixunstfdi.zig").__fixunstfdi(a.*); + return @import("fixXfYi.zig").__fixunstfdi(a.*); } pub fn _Qp_qtos(a: *f128) callconv(.C) f32 { diff --git a/lib/std/special/compiler_rt/trunc_f80.zig b/lib/std/special/compiler_rt/trunc_f80.zig index 88381a28ee..107874aeeb 100644 --- a/lib/std/special/compiler_rt/trunc_f80.zig +++ b/lib/std/special/compiler_rt/trunc_f80.zig @@ -1,6 +1,7 @@ const std = @import("std"); const builtin = @import("builtin"); const native_arch = builtin.cpu.arch; +const testing = std.testing; // AArch64 is the only ABI (at the moment) to support f16 arguments without the // need for extending them to wider fp types. @@ -117,13 +118,12 @@ pub fn __trunctfxf2(a: f128) callconv(.C) f80 { const src_abs_mask = src_sign_mask - 1; const round_mask = (1 << (src_sig_bits - dst_sig_bits)) - 1; const halfway = 1 << (src_sig_bits - dst_sig_bits - 1); - const src_qnan = 1 << (src_sig_bits - 1); - const src_nan_mask = src_qnan - 1; // Break a into a sign and representation of the absolute value const a_rep = @bitCast(u128, a); const a_abs = a_rep & src_abs_mask; const sign: u16 = if (a_rep & src_sign_mask != 0) 0x8000 else 0; + const integer_bit = 1 << 63; var res: std.math.F80 = undefined; @@ -133,27 +133,41 @@ pub fn __trunctfxf2(a: f128) callconv(.C) f80 { // bit and inserting the (truncated) trailing NaN field. res.exp = 0x7fff; res.fraction = 0x8000000000000000; - res.fraction |= @truncate(u64, (a_abs & src_qnan) << (src_sig_bits - dst_sig_bits)); - res.fraction |= @truncate(u64, (a_abs & src_nan_mask) << (src_sig_bits - dst_sig_bits)); + res.fraction |= @truncate(u64, a_abs >> (src_sig_bits - dst_sig_bits)); } else { // The exponent of a is within the range of normal numbers in the // destination format. We can convert by simply right-shifting with - // rounding and adjusting the exponent. - res.fraction = @truncate(u64, a_abs >> (src_sig_bits - dst_sig_bits)); + // rounding, adding the explicit integer bit, and adjusting the exponent + res.fraction = @truncate(u64, a_abs >> (src_sig_bits - dst_sig_bits)) | integer_bit; res.exp = @truncate(u16, a_abs >> src_sig_bits); const round_bits = a_abs & round_mask; if (round_bits > halfway) { // Round to nearest - const exp = @addWithOverflow(u64, res.fraction, 1, &res.fraction); - res.exp += @boolToInt(exp); + const carry = @boolToInt(@addWithOverflow(u64, res.fraction, 1, &res.fraction)); + res.exp += carry; + res.fraction |= @as(u64, carry) << 63; // Restore integer bit after carry } else if (round_bits == halfway) { // Ties to even - const exp = @addWithOverflow(u64, res.fraction, res.fraction & 1, &res.fraction); - res.exp += @boolToInt(exp); + const carry = @boolToInt(@addWithOverflow(u64, res.fraction, res.fraction & 1, &res.fraction)); + res.exp += carry; + res.fraction |= @as(u64, carry) << 63; // Restore integer bit after carry } + if (res.exp == 0) res.fraction &= ~@as(u64, integer_bit); // Remove integer bit for de-normals } res.exp |= sign; return std.math.make_f80(res); } + +fn test__trunctfxf2(a: f128, expected: f80) !void { + const x = __trunctfxf2(a); + try testing.expect(x == expected); +} + +test { + try test__trunctfxf2(1.5, 1.5); + try test__trunctfxf2(2.5, 2.5); + try test__trunctfxf2(-2.5, -2.5); + try test__trunctfxf2(0.0, 0.0); +} |