mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-14 05:20:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #11407 from topolarity/float-fix

Browse Source 
compiler_rt: Add `f80` support to `floatXiYf`/`fixXfYi`
This commit is contained in:
Andrew Kelley 2022-04-13 01:08:33 -04:00 committed by GitHub
commit 8ada446b1f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
81 changed files with 2496 additions and 3144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
CMakeLists.txt
View File

@ -493,41 +493,8 @@ set(ZIG_STAGE2_SOURCES
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/divtf3.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/divti3.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/extendXfYf2.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixdfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixdfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixdfti.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixint.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixsfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixsfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixsfti.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixtfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixtfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixtfti.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixuint.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunsdfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunsdfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunsdfti.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunssfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunssfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunssfti.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunstfdi.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunstfsi.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixunstfti.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatXisf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatdidf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatditf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatsiXf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floattidf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floattitf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatundidf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatundisf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatunditf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatunsidf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatunsisf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatunsitf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatuntidf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatuntisf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatuntitf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/fixXfYi.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/floatXiYf.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/int.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/modti3.zig"
"${CMAKE_SOURCE_DIR}/lib/std/special/compiler_rt/mulXf3.zig"

14
deps/SoftFloat-3e-prebuilt/platform.h vendored
View File

@ -17,8 +17,6 @@
#define BIGENDIAN 1
#elif defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#define BIGENDIAN 1
#elif defined(_BIG_ENDIAN)
#define BIGENDIAN 1
#elif defined(__sparc)
#define BIGENDIAN 1
#elif defined(__sparc__)
@ -37,7 +35,9 @@
#define BIGENDIAN 1
#elif defined(__s390__)
#define BIGENDIAN 1
#elif defined(__LITTLE_ENDIAN__)
#endif
#if defined(__LITTLE_ENDIAN__)
#define LITTLEENDIAN 1
#elif defined(__ARMEL__)
#define LITTLEENDIAN 1
@ -53,8 +53,6 @@
#define LITTLEENDIAN 1
#elif defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define LITTLEENDIAN 1
#elif defined(_LITTLE_ENDIAN)
#define LITTLEENDIAN 1
#elif defined(__i386__)
#define LITTLEENDIAN 1
#elif defined(__alpha__)
@ -83,7 +81,11 @@
#define LITTLEENDIAN 1
#elif defined(__bfin__)
#define LITTLEENDIAN 1
#else
#endif
#if defined(LITTLEENDIAN) && defined(BIGENDIAN)
#error unable to detect endianness
#elif !defined(LITTLEENDIAN) && !defined(BIGENDIAN)
#error unable to detect endianness
#endif

2
lib/std/math.zig
View File

@ -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;

24
lib/std/math/float.zig
View File

@ -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));
}
}

2
lib/std/math/isnormal.zig
View File

@ -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)));

249
lib/std/special/compiler_rt.zig
View File

@ -291,47 +291,140 @@ 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;
// Integral -> Float Conversion
// Conversion to f32
const __floatsisf = @import("compiler_rt/floatXiYf.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 });
const __floatunsisf = @import("compiler_rt/floatunsisf.zig").__floatunsisf;
const __floatunsisf = @import("compiler_rt/floatXiYf.zig").__floatunsisf;
@export(__floatunsisf, .{ .name = "__floatunsisf", .linkage = linkage });
const __floatundisf = @import("compiler_rt/floatundisf.zig").__floatundisf;
@export(__floatundisf, .{ .name = "__floatundisf", .linkage = linkage });
const __floatunsidf = @import("compiler_rt/floatunsidf.zig").__floatunsidf;
@export(__floatunsidf, .{ .name = "__floatunsidf", .linkage = linkage });
const __floatundidf = @import("compiler_rt/floatundidf.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;
@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;
const __floatundisf = @import("compiler_rt/floatXiYf.zig").__floatundisf;
@export(__floatundisf, .{ .name = "__floatundisf", .linkage = linkage });
const __floatdisf = @import("compiler_rt/floatXiYf.zig").__floatdisf;
@export(__floatdisf, .{ .name = "__floatdisf", .linkage = linkage });
const __floatunditf = @import("compiler_rt/floatunditf.zig").__floatunditf;
@export(__floatunditf, .{ .name = "__floatunditf", .linkage = linkage });
const __floatunsitf = @import("compiler_rt/floatunsitf.zig").__floatunsitf;
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 __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 __floattidf = @import("compiler_rt/floatXiYf.zig").__floattidf;
@export(__floattidf, .{ .name = "__floattidf", .linkage = linkage });
const __floatuntidf = @import("compiler_rt/floatXiYf.zig").__floatuntidf;
@export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = linkage });
// 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 });
// Float -> Integral Conversion
// 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 __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 __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 });
// 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 __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 __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 });
// 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 __fixtfdi = @import("compiler_rt/fixXfYi.zig").__fixtfdi;
@export(__fixtfdi, .{ .name = "__fixtfdi", .linkage = linkage });
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 });
@ -341,50 +434,6 @@ comptime {
const __extendsfdf2 = @import("compiler_rt/extendXfYf2.zig").__extendsfdf2;
@export(__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = linkage });
// Integral / floating point conversion (part 2/2)
const __fixunssfsi = @import("compiler_rt/fixunssfsi.zig").__fixunssfsi;
@export(__fixunssfsi, .{ .name = "__fixunssfsi", .linkage = linkage });
const __fixunssfdi = @import("compiler_rt/fixunssfdi.zig").__fixunssfdi;
@export(__fixunssfdi, .{ .name = "__fixunssfdi", .linkage = linkage });
const __fixunssfti = @import("compiler_rt/fixunssfti.zig").__fixunssfti;
@export(__fixunssfti, .{ .name = "__fixunssfti", .linkage = linkage });
const __fixunsdfsi = @import("compiler_rt/fixunsdfsi.zig").__fixunsdfsi;
@export(__fixunsdfsi, .{ .name = "__fixunsdfsi", .linkage = linkage });
const __fixunsdfdi = @import("compiler_rt/fixunsdfdi.zig").__fixunsdfdi;
@export(__fixunsdfdi, .{ .name = "__fixunsdfdi", .linkage = linkage });
const __fixunsdfti = @import("compiler_rt/fixunsdfti.zig").__fixunsdfti;
@export(__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = linkage });
const __fixunstfsi = @import("compiler_rt/fixunstfsi.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;
@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;
@export(__fixtfti, .{ .name = "__fixtfti", .linkage = linkage });
const __udivmoddi4 = @import("compiler_rt/int.zig").__udivmoddi4;
@export(__udivmoddi4, .{ .name = "__udivmoddi4", .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 {

224
lib/std/special/compiler_rt/fixXfYi.zig Normal file
View File

@ -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");
}

948
lib/std/special/compiler_rt/fixXfYi_test.zig Normal file
View File

@ -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));
}

16
lib/std/special/compiler_rt/fixdfdi.zig
View File

@ -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");
}

62
lib/std/special/compiler_rt/fixdfdi_test.zig
View File

@ -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));
}

16
lib/std/special/compiler_rt/fixdfsi.zig
View File

@ -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");
}

70
lib/std/special/compiler_rt/fixdfsi_test.zig
View File

@ -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));
}

11
lib/std/special/compiler_rt/fixdfti.zig
View File

@ -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");
}

62
lib/std/special/compiler_rt/fixdfti_test.zig
View File

@ -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));
}

75
lib/std/special/compiler_rt/fixint.zig
View File

@ -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");
}

16
lib/std/special/compiler_rt/fixsfdi.zig
View File

@ -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");
}

64
lib/std/special/compiler_rt/fixsfdi_test.zig
View File

@ -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));
}

16
lib/std/special/compiler_rt/fixsfsi.zig
View File

@ -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");
}

72
lib/std/special/compiler_rt/fixsfsi_test.zig
View File

@ -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));
}

11
lib/std/special/compiler_rt/fixsfti.zig
View File

@ -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");
}

80
lib/std/special/compiler_rt/fixsfti_test.zig
View File

@ -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));
}

11
lib/std/special/compiler_rt/fixtfdi.zig
View File

@ -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");
}

72
lib/std/special/compiler_rt/fixtfdi_test.zig
View File

@ -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));
}

11
lib/std/special/compiler_rt/fixtfsi.zig
View File

@ -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");
}

72
lib/std/special/compiler_rt/fixtfsi_test.zig
View File

@ -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));
}

11
lib/std/special/compiler_rt/fixtfti.zig
View File

@ -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");
}

62
lib/std/special/compiler_rt/fixtfti_test.zig
View File

@ -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));
}

50
lib/std/special/compiler_rt/fixuint.zig
View File

@ -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);
}
}

16
lib/std/special/compiler_rt/fixunsdfdi.zig
View File

@ -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");
}

39
lib/std/special/compiler_rt/fixunsdfdi_test.zig
View File

@ -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);
}

16
lib/std/special/compiler_rt/fixunsdfsi.zig
View File

@ -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");
}

39
lib/std/special/compiler_rt/fixunsdfsi_test.zig
View File

@ -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);
}

11
lib/std/special/compiler_rt/fixunsdfti.zig
View File

@ -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");
}

46
lib/std/special/compiler_rt/fixunsdfti_test.zig
View File

@ -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);
}

16
lib/std/special/compiler_rt/fixunssfdi.zig
View File

@ -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");
}

35
lib/std/special/compiler_rt/fixunssfdi_test.zig
View File

@ -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);
}

16
lib/std/special/compiler_rt/fixunssfsi.zig
View File

@ -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");
}

36
lib/std/special/compiler_rt/fixunssfsi_test.zig
View File

@ -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);
}

11
lib/std/special/compiler_rt/fixunssfti.zig
View File

@ -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");
}

41
lib/std/special/compiler_rt/fixunssfti_test.zig
View File

@ -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);
}

11
lib/std/special/compiler_rt/fixunstfdi.zig
View File

@ -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");
}

49
lib/std/special/compiler_rt/fixunstfdi_test.zig
View File

@ -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);
}

11
lib/std/special/compiler_rt/fixunstfsi.zig
View File

@ -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");
}

22
lib/std/special/compiler_rt/fixunstfsi_test.zig
View File

@ -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);
}

11
lib/std/special/compiler_rt/fixunstfti.zig
View File

@ -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");
}

32
lib/std/special/compiler_rt/fixunstfti_test.zig
View File

@ -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);
}

222
lib/std/special/compiler_rt/floatXiYf.zig Normal file
View File

@ -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");
}

835
lib/std/special/compiler_rt/floatXiYf_test.zig Normal file
View File

@ -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
}

90
lib/std/special/compiler_rt/floatXisf.zig
View File

@ -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");
}

27
lib/std/special/compiler_rt/floatdidf.zig
View File

@ -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");
}

53
lib/std/special/compiler_rt/floatdidf_test.zig
View File

@ -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);
}

32
lib/std/special/compiler_rt/floatdisf_test.zig
View File

@ -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);
}

38
lib/std/special/compiler_rt/floatditf.zig
View File

@ -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");
}

26
lib/std/special/compiler_rt/floatditf_test.zig
View File

@ -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);
}

46
lib/std/special/compiler_rt/floatfmodl_test.zig
View File

@ -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();
}

12
lib/std/special/compiler_rt/floatfmodl.zig → lib/std/special/compiler_rt/floatfmodq.zig
View File

@ -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");
}

46
lib/std/special/compiler_rt/floatfmodq_test.zig Normal file
View File

@ -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();
}

120
lib/std/special/compiler_rt/floatsiXf.zig
View File

@ -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);
}

71
lib/std/special/compiler_rt/floattidf.zig
View File

@ -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");
}

84
lib/std/special/compiler_rt/floattidf_test.zig
View File

@ -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);
}

60
lib/std/special/compiler_rt/floattisf_test.zig
View File

@ -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);
}

71
lib/std/special/compiler_rt/floattitf.zig
View File

@ -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");
}

96
lib/std/special/compiler_rt/floattitf_test.zig
View File

@ -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);
}

29
lib/std/special/compiler_rt/floatundidf.zig
View File

@ -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");
}

50
lib/std/special/compiler_rt/floatundidf_test.zig
View File

@ -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);
}

94
lib/std/special/compiler_rt/floatundisf.zig
View File

@ -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);
}

28
lib/std/special/compiler_rt/floatunditf.zig
View File

@ -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");
}

32
lib/std/special/compiler_rt/floatunditf_test.zig
View File

@ -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);
}

41
lib/std/special/compiler_rt/floatunsidf.zig
View File

@ -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);
}

61
lib/std/special/compiler_rt/floatunsisf.zig
View File

@ -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);
}

29
lib/std/special/compiler_rt/floatunsitf.zig
View File

@ -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");
}

28
lib/std/special/compiler_rt/floatunsitf_test.zig
View File

@ -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);
}

62
lib/std/special/compiler_rt/floatuntidf.zig
View File

@ -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");
}

81
lib/std/special/compiler_rt/floatuntidf_test.zig
View File

@ -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;
}

61
lib/std/special/compiler_rt/floatuntisf.zig
View File

@ -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");
}

72
lib/std/special/compiler_rt/floatuntisf_test.zig
View File

@ -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;
}

62
lib/std/special/compiler_rt/floatuntitf.zig
View File

@ -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");
}

99
lib/std/special/compiler_rt/floatuntitf_test.zig
View File

@ -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;
}

16
lib/std/special/compiler_rt/sparc.zig
View File

@ -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 {

34
lib/std/special/compiler_rt/trunc_f80.zig
View File

@ -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);
}

14
test/behavior/math.zig
View File

@ -923,6 +923,8 @@ test "comptime float rem int" {
}
test "remainder division" {
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
comptime try remdiv(f16);
comptime try remdiv(f32);
comptime try remdiv(f64);
@ -938,11 +940,7 @@ fn remdiv(comptime T: type) !void {
}
test "float remainder division using @rem" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
comptime try frem(f16);
comptime try frem(f32);
@ -973,11 +971,7 @@ fn frem(comptime T: type) !void {
}
test "float modulo division using @mod" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
comptime try fmod(f16);
comptime try fmod(f32);