Commit b5d5685a4e
Changed files (76)
lib
std
special
compiler_rt
lib/std/special/compiler_rt/fixdfdi.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixdfdi_test.zig
@@ -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));
-}
lib/std/special/compiler_rt/fixdfsi.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixdfsi_test.zig
@@ -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));
-}
lib/std/special/compiler_rt/fixdfti.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixdfti_test.zig
@@ -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));
-}
lib/std/special/compiler_rt/fixint.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixsfdi.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixsfdi_test.zig
@@ -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));
-}
lib/std/special/compiler_rt/fixsfsi.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixsfsi_test.zig
@@ -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));
-}
lib/std/special/compiler_rt/fixsfti.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixsfti_test.zig
@@ -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));
-}
lib/std/special/compiler_rt/fixtfdi.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixtfdi_test.zig
@@ -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));
-}
lib/std/special/compiler_rt/fixtfsi.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixtfsi_test.zig
@@ -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));
-}
lib/std/special/compiler_rt/fixtfti.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixtfti_test.zig
@@ -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));
-}
lib/std/special/compiler_rt/fixuint.zig
@@ -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);
- }
-}
lib/std/special/compiler_rt/fixunsdfdi.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixunsdfdi_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/fixunsdfsi.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixunsdfsi_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/fixunsdfti.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixunsdfti_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/fixunssfdi.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixunssfdi_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/fixunssfsi.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixunssfsi_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/fixunssfti.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixunssfti_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/fixunstfdi.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixunstfdi_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/fixunstfsi.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixunstfsi_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/fixunstfti.zig
@@ -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");
-}
lib/std/special/compiler_rt/fixunstfti_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/fixXfYi.zig
@@ -0,0 +1,224 @@
+const std = @import("std");
+const math = std.math;
+const Log2Int = math.Log2Int;
+const is_test = @import("builtin").is_test;
+
+pub inline fn fixXfYi(comptime I: type, a: anytype) I {
+ @setRuntimeSafety(is_test);
+
+ const F = @TypeOf(a);
+ const float_bits = @typeInfo(F).Float.bits;
+ const int_bits = @typeInfo(I).Int.bits;
+ const rep_t = std.meta.Int(.unsigned, float_bits);
+ const sig_bits = math.floatMantissaBits(F);
+ const exp_bits = math.floatExponentBits(F);
+ const fractional_sig_bits = math.floatMantissaDigits(F) - 1;
+
+ 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_sig_bits) {
+ result = @intCast(I, significand >> @intCast(Log2Int(rep_t), fractional_sig_bits - exponent));
+ } else {
+ result = @intCast(I, significand) << @intCast(Log2Int(I), exponent - fractional_sig_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");
+}
lib/std/special/compiler_rt/fixXfYi_test.zig
@@ -0,0 +1,948 @@
+const std = @import("std");
+const testing = std.testing;
+const math = std.math;
+const fixXfYi = @import("fixXfYi.zig").fixXfYi;
+
+// Conversion from f32
+const __fixsfsi = @import("fixXfYi.zig").__fixsfsi;
+const __fixunssfsi = @import("fixXfYi.zig").__fixunssfsi;
+const __fixsfdi = @import("fixXfYi.zig").__fixsfdi;
+const __fixunssfdi = @import("fixXfYi.zig").__fixunssfdi;
+const __fixsfti = @import("fixXfYi.zig").__fixsfti;
+const __fixunssfti = @import("fixXfYi.zig").__fixunssfti;
+
+// Conversion from f64
+const __fixdfsi = @import("fixXfYi.zig").__fixdfsi;
+const __fixunsdfsi = @import("fixXfYi.zig").__fixunsdfsi;
+const __fixdfdi = @import("fixXfYi.zig").__fixdfdi;
+const __fixunsdfdi = @import("fixXfYi.zig").__fixunsdfdi;
+const __fixdfti = @import("fixXfYi.zig").__fixdfti;
+const __fixunsdfti = @import("fixXfYi.zig").__fixunsdfti;
+
+// Conversion from f128
+const __fixtfsi = @import("fixXfYi.zig").__fixtfsi;
+const __fixunstfsi = @import("fixXfYi.zig").__fixunstfsi;
+const __fixtfdi = @import("fixXfYi.zig").__fixtfdi;
+const __fixunstfdi = @import("fixXfYi.zig").__fixunstfdi;
+const __fixtfti = @import("fixXfYi.zig").__fixtfti;
+const __fixunstfti = @import("fixXfYi.zig").__fixunstfti;
+
+fn test__fixsfsi(a: f32, expected: i32) !void {
+ const x = __fixsfsi(a);
+ try testing.expect(x == expected);
+}
+
+fn test__fixunssfsi(a: f32, expected: u32) !void {
+ const x = __fixunssfsi(a);
+ try testing.expect(x == expected);
+}
+
+test "fixsfsi" {
+ try test__fixsfsi(-math.floatMax(f32), math.minInt(i32));
+
+ try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
+ try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
+
+ try test__fixsfsi(-0x1.0000000000000p+127, -0x80000000);
+ try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
+ try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
+
+ try test__fixsfsi(-0x1.0000000000001p+63, -0x80000000);
+ try test__fixsfsi(-0x1.0000000000000p+63, -0x80000000);
+ try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
+ try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
+
+ try test__fixsfsi(-0x1.FFFFFEp+62, -0x80000000);
+ try test__fixsfsi(-0x1.FFFFFCp+62, -0x80000000);
+
+ try test__fixsfsi(-0x1.000000p+31, -0x80000000);
+ try test__fixsfsi(-0x1.FFFFFFp+30, -0x80000000);
+ try test__fixsfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
+ try test__fixsfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
+
+ try test__fixsfsi(-2.01, -2);
+ try test__fixsfsi(-2.0, -2);
+ try test__fixsfsi(-1.99, -1);
+ try test__fixsfsi(-1.0, -1);
+ try test__fixsfsi(-0.99, 0);
+ try test__fixsfsi(-0.5, 0);
+ try test__fixsfsi(-math.floatMin(f32), 0);
+ try test__fixsfsi(0.0, 0);
+ try test__fixsfsi(math.floatMin(f32), 0);
+ try test__fixsfsi(0.5, 0);
+ try test__fixsfsi(0.99, 0);
+ try test__fixsfsi(1.0, 1);
+ try test__fixsfsi(1.5, 1);
+ try test__fixsfsi(1.99, 1);
+ try test__fixsfsi(2.0, 2);
+ try test__fixsfsi(2.01, 2);
+
+ try test__fixsfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
+ try test__fixsfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
+ try test__fixsfsi(0x1.FFFFFFp+30, 0x7FFFFFFF);
+ try test__fixsfsi(0x1.000000p+31, 0x7FFFFFFF);
+
+ try test__fixsfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
+ try test__fixsfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
+
+ try test__fixsfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
+ try test__fixsfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
+ try test__fixsfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
+ try test__fixsfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
+
+ try test__fixsfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
+ try test__fixsfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
+ try test__fixsfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
+
+ try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
+ try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
+
+ try test__fixsfsi(math.floatMax(f32), math.maxInt(i32));
+}
+
+test "fixunssfsi" {
+ try test__fixunssfsi(0.0, 0);
+
+ try test__fixunssfsi(0.5, 0);
+ try test__fixunssfsi(0.99, 0);
+ try test__fixunssfsi(1.0, 1);
+ try test__fixunssfsi(1.5, 1);
+ try test__fixunssfsi(1.99, 1);
+ try test__fixunssfsi(2.0, 2);
+ try test__fixunssfsi(2.01, 2);
+ try test__fixunssfsi(-0.5, 0);
+ try test__fixunssfsi(-0.99, 0);
+
+ try test__fixunssfsi(-1.0, 0);
+ try test__fixunssfsi(-1.5, 0);
+ try test__fixunssfsi(-1.99, 0);
+ try test__fixunssfsi(-2.0, 0);
+ try test__fixunssfsi(-2.01, 0);
+
+ try test__fixunssfsi(0x1.000000p+31, 0x80000000);
+ try test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF);
+ try test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
+ try test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
+ try test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
+
+ try test__fixunssfsi(-0x1.FFFFFEp+30, 0);
+ try test__fixunssfsi(-0x1.FFFFFCp+30, 0);
+}
+
+fn test__fixsfdi(a: f32, expected: i64) !void {
+ const x = __fixsfdi(a);
+ try testing.expect(x == expected);
+}
+
+fn test__fixunssfdi(a: f32, expected: u64) !void {
+ const x = __fixunssfdi(a);
+ try testing.expect(x == expected);
+}
+
+test "fixsfdi" {
+ try test__fixsfdi(-math.floatMax(f32), math.minInt(i64));
+
+ try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
+ try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
+
+ try test__fixsfdi(-0x1.0000000000000p+127, -0x8000000000000000);
+ try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
+ try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
+
+ try test__fixsfdi(-0x1.0000000000001p+63, -0x8000000000000000);
+ try test__fixsfdi(-0x1.0000000000000p+63, -0x8000000000000000);
+ try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
+ try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
+
+ try test__fixsfdi(-0x1.FFFFFFp+62, -0x8000000000000000);
+ try test__fixsfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
+ try test__fixsfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
+
+ try test__fixsfdi(-2.01, -2);
+ try test__fixsfdi(-2.0, -2);
+ try test__fixsfdi(-1.99, -1);
+ try test__fixsfdi(-1.0, -1);
+ try test__fixsfdi(-0.99, 0);
+ try test__fixsfdi(-0.5, 0);
+ try test__fixsfdi(-math.floatMin(f32), 0);
+ try test__fixsfdi(0.0, 0);
+ try test__fixsfdi(math.floatMin(f32), 0);
+ try test__fixsfdi(0.5, 0);
+ try test__fixsfdi(0.99, 0);
+ try test__fixsfdi(1.0, 1);
+ try test__fixsfdi(1.5, 1);
+ try test__fixsfdi(1.99, 1);
+ try test__fixsfdi(2.0, 2);
+ try test__fixsfdi(2.01, 2);
+
+ try test__fixsfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+ try test__fixsfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+ try test__fixsfdi(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
+
+ try test__fixsfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF);
+ try test__fixsfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
+ try test__fixsfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
+ try test__fixsfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
+
+ try test__fixsfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
+ try test__fixsfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
+ try test__fixsfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
+
+ try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
+ try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
+
+ try test__fixsfdi(math.floatMax(f32), math.maxInt(i64));
+}
+
+test "fixunssfdi" {
+ try test__fixunssfdi(0.0, 0);
+
+ try test__fixunssfdi(0.5, 0);
+ try test__fixunssfdi(0.99, 0);
+ try test__fixunssfdi(1.0, 1);
+ try test__fixunssfdi(1.5, 1);
+ try test__fixunssfdi(1.99, 1);
+ try test__fixunssfdi(2.0, 2);
+ try test__fixunssfdi(2.01, 2);
+ try test__fixunssfdi(-0.5, 0);
+ try test__fixunssfdi(-0.99, 0);
+
+ try test__fixunssfdi(-1.0, 0);
+ try test__fixunssfdi(-1.5, 0);
+ try test__fixunssfdi(-1.99, 0);
+ try test__fixunssfdi(-2.0, 0);
+ try test__fixunssfdi(-2.01, 0);
+
+ try test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
+ try test__fixunssfdi(0x1.000000p+63, 0x8000000000000000);
+ try test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+ try test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+
+ try test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000);
+ try test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000);
+}
+
+fn test__fixsfti(a: f32, expected: i128) !void {
+ const x = __fixsfti(a);
+ try testing.expect(x == expected);
+}
+
+fn test__fixunssfti(a: f32, expected: u128) !void {
+ const x = __fixunssfti(a);
+ try testing.expect(x == expected);
+}
+
+test "fixsfti" {
+ try test__fixsfti(-math.floatMax(f32), math.minInt(i128));
+
+ try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
+ try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
+
+ try test__fixsfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
+ try test__fixsfti(-0x1.FFFFFFFFFFFFFp+126, -0x80000000000000000000000000000000);
+ try test__fixsfti(-0x1.FFFFFFFFFFFFEp+126, -0x80000000000000000000000000000000);
+ try test__fixsfti(-0x1.FFFFFF0000000p+126, -0x80000000000000000000000000000000);
+ try test__fixsfti(-0x1.FFFFFE0000000p+126, -0x7FFFFF80000000000000000000000000);
+ try test__fixsfti(-0x1.FFFFFC0000000p+126, -0x7FFFFF00000000000000000000000000);
+
+ try test__fixsfti(-0x1.0000000000001p+63, -0x8000000000000000);
+ try test__fixsfti(-0x1.0000000000000p+63, -0x8000000000000000);
+ try test__fixsfti(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
+ try test__fixsfti(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
+
+ try test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000);
+ try test__fixsfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
+ try test__fixsfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
+
+ try test__fixsfti(-0x1.000000p+31, -0x80000000);
+ try test__fixsfti(-0x1.FFFFFFp+30, -0x80000000);
+ try test__fixsfti(-0x1.FFFFFEp+30, -0x7FFFFF80);
+ try test__fixsfti(-0x1.FFFFFCp+30, -0x7FFFFF00);
+
+ try test__fixsfti(-2.01, -2);
+ try test__fixsfti(-2.0, -2);
+ try test__fixsfti(-1.99, -1);
+ try test__fixsfti(-1.0, -1);
+ try test__fixsfti(-0.99, 0);
+ try test__fixsfti(-0.5, 0);
+ try test__fixsfti(-math.floatMin(f32), 0);
+ try test__fixsfti(0.0, 0);
+ try test__fixsfti(math.floatMin(f32), 0);
+ try test__fixsfti(0.5, 0);
+ try test__fixsfti(0.99, 0);
+ try test__fixsfti(1.0, 1);
+ try test__fixsfti(1.5, 1);
+ try test__fixsfti(1.99, 1);
+ try test__fixsfti(2.0, 2);
+ try test__fixsfti(2.01, 2);
+
+ try test__fixsfti(0x1.FFFFFCp+30, 0x7FFFFF00);
+ try test__fixsfti(0x1.FFFFFEp+30, 0x7FFFFF80);
+ try test__fixsfti(0x1.FFFFFFp+30, 0x80000000);
+ try test__fixsfti(0x1.000000p+31, 0x80000000);
+
+ try test__fixsfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+ try test__fixsfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+ try test__fixsfti(0x1.FFFFFFp+62, 0x8000000000000000);
+
+ try test__fixsfti(0x1.FFFFFFFFFFFFEp+62, 0x8000000000000000);
+ try test__fixsfti(0x1.FFFFFFFFFFFFFp+62, 0x8000000000000000);
+ try test__fixsfti(0x1.0000000000000p+63, 0x8000000000000000);
+ try test__fixsfti(0x1.0000000000001p+63, 0x8000000000000000);
+
+ try test__fixsfti(0x1.FFFFFC0000000p+126, 0x7FFFFF00000000000000000000000000);
+ try test__fixsfti(0x1.FFFFFE0000000p+126, 0x7FFFFF80000000000000000000000000);
+ try test__fixsfti(0x1.FFFFFF0000000p+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+ try test__fixsfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+ try test__fixsfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+ try test__fixsfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+
+ try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+ try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
+
+ try test__fixsfti(math.floatMax(f32), math.maxInt(i128));
+}
+
+test "fixunssfti" {
+ try test__fixunssfti(0.0, 0);
+
+ try test__fixunssfti(0.5, 0);
+ try test__fixunssfti(0.99, 0);
+ try test__fixunssfti(1.0, 1);
+ try test__fixunssfti(1.5, 1);
+ try test__fixunssfti(1.99, 1);
+ try test__fixunssfti(2.0, 2);
+ try test__fixunssfti(2.01, 2);
+ try test__fixunssfti(-0.5, 0);
+ try test__fixunssfti(-0.99, 0);
+
+ try test__fixunssfti(-1.0, 0);
+ try test__fixunssfti(-1.5, 0);
+ try test__fixunssfti(-1.99, 0);
+ try test__fixunssfti(-2.0, 0);
+ try test__fixunssfti(-2.01, 0);
+
+ try test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
+ try test__fixunssfti(0x1.000000p+63, 0x8000000000000000);
+ try test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+ try test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+ try test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000);
+ try test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000);
+ try test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000);
+ try test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000);
+
+ try test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000);
+ try test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000);
+ try test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000);
+ try test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000);
+ try test__fixunssfti(math.floatMax(f32), 0xffffff00000000000000000000000000);
+ try test__fixunssfti(math.inf(f32), math.maxInt(u128));
+}
+
+fn test__fixdfsi(a: f64, expected: i32) !void {
+ const x = __fixdfsi(a);
+ try testing.expect(x == expected);
+}
+
+fn test__fixunsdfsi(a: f64, expected: u32) !void {
+ const x = __fixunsdfsi(a);
+ try testing.expect(x == expected);
+}
+
+test "fixdfsi" {
+ try test__fixdfsi(-math.floatMax(f64), math.minInt(i32));
+
+ try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
+ try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
+
+ try test__fixdfsi(-0x1.0000000000000p+127, -0x80000000);
+ try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
+ try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
+
+ try test__fixdfsi(-0x1.0000000000001p+63, -0x80000000);
+ try test__fixdfsi(-0x1.0000000000000p+63, -0x80000000);
+ try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
+ try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
+
+ try test__fixdfsi(-0x1.FFFFFEp+62, -0x80000000);
+ try test__fixdfsi(-0x1.FFFFFCp+62, -0x80000000);
+
+ try test__fixdfsi(-0x1.000000p+31, -0x80000000);
+ try test__fixdfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
+ try test__fixdfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
+
+ try test__fixdfsi(-2.01, -2);
+ try test__fixdfsi(-2.0, -2);
+ try test__fixdfsi(-1.99, -1);
+ try test__fixdfsi(-1.0, -1);
+ try test__fixdfsi(-0.99, 0);
+ try test__fixdfsi(-0.5, 0);
+ try test__fixdfsi(-math.floatMin(f64), 0);
+ try test__fixdfsi(0.0, 0);
+ try test__fixdfsi(math.floatMin(f64), 0);
+ try test__fixdfsi(0.5, 0);
+ try test__fixdfsi(0.99, 0);
+ try test__fixdfsi(1.0, 1);
+ try test__fixdfsi(1.5, 1);
+ try test__fixdfsi(1.99, 1);
+ try test__fixdfsi(2.0, 2);
+ try test__fixdfsi(2.01, 2);
+
+ try test__fixdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
+ try test__fixdfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
+ try test__fixdfsi(0x1.000000p+31, 0x7FFFFFFF);
+
+ try test__fixdfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
+ try test__fixdfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
+
+ try test__fixdfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
+ try test__fixdfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
+ try test__fixdfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
+ try test__fixdfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
+
+ try test__fixdfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
+ try test__fixdfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
+ try test__fixdfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
+
+ try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
+ try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
+
+ try test__fixdfsi(math.floatMax(f64), math.maxInt(i32));
+}
+
+test "fixunsdfsi" {
+ try test__fixunsdfsi(0.0, 0);
+
+ try test__fixunsdfsi(0.5, 0);
+ try test__fixunsdfsi(0.99, 0);
+ try test__fixunsdfsi(1.0, 1);
+ try test__fixunsdfsi(1.5, 1);
+ try test__fixunsdfsi(1.99, 1);
+ try test__fixunsdfsi(2.0, 2);
+ try test__fixunsdfsi(2.01, 2);
+ try test__fixunsdfsi(-0.5, 0);
+ try test__fixunsdfsi(-0.99, 0);
+ try test__fixunsdfsi(-1.0, 0);
+ try test__fixunsdfsi(-1.5, 0);
+ try test__fixunsdfsi(-1.99, 0);
+ try test__fixunsdfsi(-2.0, 0);
+ try test__fixunsdfsi(-2.01, 0);
+
+ try test__fixunsdfsi(0x1.000000p+31, 0x80000000);
+ try test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF);
+ try test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
+ try test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
+ try test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
+
+ try test__fixunsdfsi(-0x1.FFFFFEp+30, 0);
+ try test__fixunsdfsi(-0x1.FFFFFCp+30, 0);
+
+ try test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF);
+ try test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF);
+ try test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE);
+}
+
+fn test__fixdfdi(a: f64, expected: i64) !void {
+ const x = __fixdfdi(a);
+ try testing.expect(x == expected);
+}
+
+fn test__fixunsdfdi(a: f64, expected: u64) !void {
+ const x = __fixunsdfdi(a);
+ try testing.expect(x == expected);
+}
+
+test "fixdfdi" {
+ try test__fixdfdi(-math.floatMax(f64), math.minInt(i64));
+
+ try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
+ try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
+
+ try test__fixdfdi(-0x1.0000000000000p+127, -0x8000000000000000);
+ try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
+ try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
+
+ try test__fixdfdi(-0x1.0000000000001p+63, -0x8000000000000000);
+ try test__fixdfdi(-0x1.0000000000000p+63, -0x8000000000000000);
+ try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
+ try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
+
+ try test__fixdfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
+ try test__fixdfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
+
+ try test__fixdfdi(-2.01, -2);
+ try test__fixdfdi(-2.0, -2);
+ try test__fixdfdi(-1.99, -1);
+ try test__fixdfdi(-1.0, -1);
+ try test__fixdfdi(-0.99, 0);
+ try test__fixdfdi(-0.5, 0);
+ try test__fixdfdi(-math.floatMin(f64), 0);
+ try test__fixdfdi(0.0, 0);
+ try test__fixdfdi(math.floatMin(f64), 0);
+ try test__fixdfdi(0.5, 0);
+ try test__fixdfdi(0.99, 0);
+ try test__fixdfdi(1.0, 1);
+ try test__fixdfdi(1.5, 1);
+ try test__fixdfdi(1.99, 1);
+ try test__fixdfdi(2.0, 2);
+ try test__fixdfdi(2.01, 2);
+
+ try test__fixdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+ try test__fixdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+
+ try test__fixdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+ try test__fixdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+ try test__fixdfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
+ try test__fixdfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
+
+ try test__fixdfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
+ try test__fixdfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
+ try test__fixdfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
+
+ try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
+ try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
+
+ try test__fixdfdi(math.floatMax(f64), math.maxInt(i64));
+}
+
+test "fixunsdfdi" {
+ try test__fixunsdfdi(0.0, 0);
+ try test__fixunsdfdi(0.5, 0);
+ try test__fixunsdfdi(0.99, 0);
+ try test__fixunsdfdi(1.0, 1);
+ try test__fixunsdfdi(1.5, 1);
+ try test__fixunsdfdi(1.99, 1);
+ try test__fixunsdfdi(2.0, 2);
+ try test__fixunsdfdi(2.01, 2);
+ try test__fixunsdfdi(-0.5, 0);
+ try test__fixunsdfdi(-0.99, 0);
+ try test__fixunsdfdi(-1.0, 0);
+ try test__fixunsdfdi(-1.5, 0);
+ try test__fixunsdfdi(-1.99, 0);
+ try test__fixunsdfdi(-2.0, 0);
+ try test__fixunsdfdi(-2.01, 0);
+
+ try test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+ try test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+
+ try test__fixunsdfdi(-0x1.FFFFFEp+62, 0);
+ try test__fixunsdfdi(-0x1.FFFFFCp+62, 0);
+
+ try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
+ try test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000);
+ try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+ try test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+
+ try test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
+ try test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
+}
+
+fn test__fixdfti(a: f64, expected: i128) !void {
+ const x = __fixdfti(a);
+ try testing.expect(x == expected);
+}
+
+fn test__fixunsdfti(a: f64, expected: u128) !void {
+ const x = __fixunsdfti(a);
+ try testing.expect(x == expected);
+}
+
+test "fixdfti" {
+ try test__fixdfti(-math.floatMax(f64), math.minInt(i128));
+
+ try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
+ try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
+
+ try test__fixdfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
+ try test__fixdfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
+ try test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
+
+ try test__fixdfti(-0x1.0000000000001p+63, -0x8000000000000800);
+ try test__fixdfti(-0x1.0000000000000p+63, -0x8000000000000000);
+ try test__fixdfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
+ try test__fixdfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
+
+ try test__fixdfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
+ try test__fixdfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
+
+ try test__fixdfti(-2.01, -2);
+ try test__fixdfti(-2.0, -2);
+ try test__fixdfti(-1.99, -1);
+ try test__fixdfti(-1.0, -1);
+ try test__fixdfti(-0.99, 0);
+ try test__fixdfti(-0.5, 0);
+ try test__fixdfti(-math.floatMin(f64), 0);
+ try test__fixdfti(0.0, 0);
+ try test__fixdfti(math.floatMin(f64), 0);
+ try test__fixdfti(0.5, 0);
+ try test__fixdfti(0.99, 0);
+ try test__fixdfti(1.0, 1);
+ try test__fixdfti(1.5, 1);
+ try test__fixdfti(1.99, 1);
+ try test__fixdfti(2.0, 2);
+ try test__fixdfti(2.01, 2);
+
+ try test__fixdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+ try test__fixdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+
+ try test__fixdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+ try test__fixdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+ try test__fixdfti(0x1.0000000000000p+63, 0x8000000000000000);
+ try test__fixdfti(0x1.0000000000001p+63, 0x8000000000000800);
+
+ try test__fixdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
+ try test__fixdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
+ try test__fixdfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+
+ try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+ try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
+
+ try test__fixdfti(math.floatMax(f64), math.maxInt(i128));
+}
+
+test "fixunsdfti" {
+ try test__fixunsdfti(0.0, 0);
+
+ try test__fixunsdfti(0.5, 0);
+ try test__fixunsdfti(0.99, 0);
+ try test__fixunsdfti(1.0, 1);
+ try test__fixunsdfti(1.5, 1);
+ try test__fixunsdfti(1.99, 1);
+ try test__fixunsdfti(2.0, 2);
+ try test__fixunsdfti(2.01, 2);
+ try test__fixunsdfti(-0.5, 0);
+ try test__fixunsdfti(-0.99, 0);
+ try test__fixunsdfti(-1.0, 0);
+ try test__fixunsdfti(-1.5, 0);
+ try test__fixunsdfti(-1.99, 0);
+ try test__fixunsdfti(-2.0, 0);
+ try test__fixunsdfti(-2.01, 0);
+
+ try test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+ try test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+
+ try test__fixunsdfti(-0x1.FFFFFEp+62, 0);
+ try test__fixunsdfti(-0x1.FFFFFCp+62, 0);
+
+ try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
+ try test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000);
+ try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+ try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+
+ try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000);
+ try test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000);
+ try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
+ try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
+ try test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+
+ try test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0);
+ try test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0);
+}
+
+fn test__fixtfsi(a: f128, expected: i32) !void {
+ const x = __fixtfsi(a);
+ try testing.expect(x == expected);
+}
+
+fn test__fixunstfsi(a: f128, expected: u32) !void {
+ const x = __fixunstfsi(a);
+ try testing.expect(x == expected);
+}
+
+test "fixtfsi" {
+ try test__fixtfsi(-math.floatMax(f128), math.minInt(i32));
+
+ try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
+ try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
+
+ try test__fixtfsi(-0x1.0000000000000p+127, -0x80000000);
+ try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
+ try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
+
+ try test__fixtfsi(-0x1.0000000000001p+63, -0x80000000);
+ try test__fixtfsi(-0x1.0000000000000p+63, -0x80000000);
+ try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
+ try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
+
+ try test__fixtfsi(-0x1.FFFFFEp+62, -0x80000000);
+ try test__fixtfsi(-0x1.FFFFFCp+62, -0x80000000);
+
+ try test__fixtfsi(-0x1.000000p+31, -0x80000000);
+ try test__fixtfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
+ try test__fixtfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
+ try test__fixtfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
+
+ try test__fixtfsi(-2.01, -2);
+ try test__fixtfsi(-2.0, -2);
+ try test__fixtfsi(-1.99, -1);
+ try test__fixtfsi(-1.0, -1);
+ try test__fixtfsi(-0.99, 0);
+ try test__fixtfsi(-0.5, 0);
+ try test__fixtfsi(-math.floatMin(f32), 0);
+ try test__fixtfsi(0.0, 0);
+ try test__fixtfsi(math.floatMin(f32), 0);
+ try test__fixtfsi(0.5, 0);
+ try test__fixtfsi(0.99, 0);
+ try test__fixtfsi(1.0, 1);
+ try test__fixtfsi(1.5, 1);
+ try test__fixtfsi(1.99, 1);
+ try test__fixtfsi(2.0, 2);
+ try test__fixtfsi(2.01, 2);
+
+ try test__fixtfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
+ try test__fixtfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
+ try test__fixtfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
+ try test__fixtfsi(0x1.000000p+31, 0x7FFFFFFF);
+
+ try test__fixtfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
+ try test__fixtfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
+
+ try test__fixtfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
+ try test__fixtfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
+ try test__fixtfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
+ try test__fixtfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
+
+ try test__fixtfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
+ try test__fixtfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
+ try test__fixtfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
+
+ try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
+ try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
+
+ try test__fixtfsi(math.floatMax(f128), math.maxInt(i32));
+}
+
+test "fixunstfsi" {
+ try test__fixunstfsi(math.inf(f128), 0xffffffff);
+ try test__fixunstfsi(0, 0x0);
+ try test__fixunstfsi(0x1.23456789abcdefp+5, 0x24);
+ try test__fixunstfsi(0x1.23456789abcdefp-3, 0x0);
+ try test__fixunstfsi(0x1.23456789abcdefp+20, 0x123456);
+ try test__fixunstfsi(0x1.23456789abcdefp+40, 0xffffffff);
+ try test__fixunstfsi(0x1.23456789abcdefp+256, 0xffffffff);
+ try test__fixunstfsi(-0x1.23456789abcdefp+3, 0x0);
+
+ try test__fixunstfsi(0x1p+32, 0xFFFFFFFF);
+}
+
+fn test__fixtfdi(a: f128, expected: i64) !void {
+ const x = __fixtfdi(a);
+ try testing.expect(x == expected);
+}
+
+fn test__fixunstfdi(a: f128, expected: u64) !void {
+ const x = __fixunstfdi(a);
+ try testing.expect(x == expected);
+}
+
+test "fixtfdi" {
+ try test__fixtfdi(-math.floatMax(f128), math.minInt(i64));
+
+ try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
+ try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
+
+ try test__fixtfdi(-0x1.0000000000000p+127, -0x8000000000000000);
+ try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
+ try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
+
+ try test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000);
+ try test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000);
+ try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
+ try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
+
+ try test__fixtfdi(-0x1.FFFFFEp+62, -0x7FFFFF8000000000);
+ try test__fixtfdi(-0x1.FFFFFCp+62, -0x7FFFFF0000000000);
+
+ try test__fixtfdi(-0x1.000000p+31, -0x80000000);
+ try test__fixtfdi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
+ try test__fixtfdi(-0x1.FFFFFEp+30, -0x7FFFFF80);
+ try test__fixtfdi(-0x1.FFFFFCp+30, -0x7FFFFF00);
+
+ try test__fixtfdi(-2.01, -2);
+ try test__fixtfdi(-2.0, -2);
+ try test__fixtfdi(-1.99, -1);
+ try test__fixtfdi(-1.0, -1);
+ try test__fixtfdi(-0.99, 0);
+ try test__fixtfdi(-0.5, 0);
+ try test__fixtfdi(-math.floatMin(f64), 0);
+ try test__fixtfdi(0.0, 0);
+ try test__fixtfdi(math.floatMin(f64), 0);
+ try test__fixtfdi(0.5, 0);
+ try test__fixtfdi(0.99, 0);
+ try test__fixtfdi(1.0, 1);
+ try test__fixtfdi(1.5, 1);
+ try test__fixtfdi(1.99, 1);
+ try test__fixtfdi(2.0, 2);
+ try test__fixtfdi(2.01, 2);
+
+ try test__fixtfdi(0x1.FFFFFCp+30, 0x7FFFFF00);
+ try test__fixtfdi(0x1.FFFFFEp+30, 0x7FFFFF80);
+ try test__fixtfdi(0x1.FFFFFFp+30, 0x7FFFFFC0);
+ try test__fixtfdi(0x1.000000p+31, 0x80000000);
+
+ try test__fixtfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+ try test__fixtfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+
+ try test__fixtfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+ try test__fixtfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+ try test__fixtfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
+ try test__fixtfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
+
+ try test__fixtfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
+ try test__fixtfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
+ try test__fixtfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
+
+ try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
+ try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
+
+ try test__fixtfdi(math.floatMax(f128), math.maxInt(i64));
+}
+
+test "fixunstfdi" {
+ try test__fixunstfdi(0.0, 0);
+
+ try test__fixunstfdi(0.5, 0);
+ try test__fixunstfdi(0.99, 0);
+ try test__fixunstfdi(1.0, 1);
+ try test__fixunstfdi(1.5, 1);
+ try test__fixunstfdi(1.99, 1);
+ try test__fixunstfdi(2.0, 2);
+ try test__fixunstfdi(2.01, 2);
+ try test__fixunstfdi(-0.5, 0);
+ try test__fixunstfdi(-0.99, 0);
+ try test__fixunstfdi(-1.0, 0);
+ try test__fixunstfdi(-1.5, 0);
+ try test__fixunstfdi(-1.99, 0);
+ try test__fixunstfdi(-2.0, 0);
+ try test__fixunstfdi(-2.01, 0);
+
+ try test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+ try test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+
+ try test__fixunstfdi(-0x1.FFFFFEp+62, 0);
+ try test__fixunstfdi(-0x1.FFFFFCp+62, 0);
+
+ try test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+ try test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+
+ try test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
+ try test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
+
+ try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF);
+ try test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001);
+ try test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000);
+ try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF);
+ try test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE);
+ try test__fixunstfdi(0x1p+64, 0xFFFFFFFFFFFFFFFF);
+
+ try test__fixunstfdi(-0x1.0000000000000000p+63, 0);
+ try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0);
+ try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0);
+}
+
+fn test__fixtfti(a: f128, expected: i128) !void {
+ const x = __fixtfti(a);
+ try testing.expect(x == expected);
+}
+
+fn test__fixunstfti(a: f128, expected: u128) !void {
+ const x = __fixunstfti(a);
+ try testing.expect(x == expected);
+}
+
+test "fixtfti" {
+ try test__fixtfti(-math.floatMax(f128), math.minInt(i128));
+
+ try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
+ try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
+
+ try test__fixtfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
+ try test__fixtfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
+ try test__fixtfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
+
+ try test__fixtfti(-0x1.0000000000001p+63, -0x8000000000000800);
+ try test__fixtfti(-0x1.0000000000000p+63, -0x8000000000000000);
+ try test__fixtfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
+ try test__fixtfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
+
+ try test__fixtfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
+ try test__fixtfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
+
+ try test__fixtfti(-2.01, -2);
+ try test__fixtfti(-2.0, -2);
+ try test__fixtfti(-1.99, -1);
+ try test__fixtfti(-1.0, -1);
+ try test__fixtfti(-0.99, 0);
+ try test__fixtfti(-0.5, 0);
+ try test__fixtfti(-math.floatMin(f128), 0);
+ try test__fixtfti(0.0, 0);
+ try test__fixtfti(math.floatMin(f128), 0);
+ try test__fixtfti(0.5, 0);
+ try test__fixtfti(0.99, 0);
+ try test__fixtfti(1.0, 1);
+ try test__fixtfti(1.5, 1);
+ try test__fixtfti(1.99, 1);
+ try test__fixtfti(2.0, 2);
+ try test__fixtfti(2.01, 2);
+
+ try test__fixtfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+ try test__fixtfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+
+ try test__fixtfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+ try test__fixtfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+ try test__fixtfti(0x1.0000000000000p+63, 0x8000000000000000);
+ try test__fixtfti(0x1.0000000000001p+63, 0x8000000000000800);
+
+ try test__fixtfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
+ try test__fixtfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
+ try test__fixtfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+
+ try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+ try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
+
+ try test__fixtfti(math.floatMax(f128), math.maxInt(i128));
+}
+
+test "fixunstfti" {
+ try test__fixunstfti(math.inf(f128), 0xffffffffffffffffffffffffffffffff);
+
+ try test__fixunstfti(0.0, 0);
+
+ try test__fixunstfti(0.5, 0);
+ try test__fixunstfti(0.99, 0);
+ try test__fixunstfti(1.0, 1);
+ try test__fixunstfti(1.5, 1);
+ try test__fixunstfti(1.99, 1);
+ try test__fixunstfti(2.0, 2);
+ try test__fixunstfti(2.01, 2);
+ try test__fixunstfti(-0.01, 0);
+ try test__fixunstfti(-0.99, 0);
+
+ try test__fixunstfti(0x1p+128, 0xffffffffffffffffffffffffffffffff);
+
+ try test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000);
+ try test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000);
+ try test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff);
+ try test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff);
+}
+
+fn test__fixunshfti(a: f16, expected: u128) !void {
+ const x = fixXfYi(u128, a);
+ try testing.expect(x == expected);
+}
+
+test "fixXfYi for f16" {
+ try test__fixunshfti(math.inf(f16), math.maxInt(u128));
+ try test__fixunshfti(math.floatMax(f16), 65504);
+}
+
+fn test__fixunsxfti(a: f80, expected: u128) !void {
+ const x = fixXfYi(u128, a);
+ try testing.expect(x == expected);
+}
+
+test "fixXfYi for f80" {
+ try test__fixunsxfti(math.inf(f80), math.maxInt(u128));
+ try test__fixunsxfti(math.floatMax(f80), math.maxInt(u128));
+ try test__fixunsxfti(math.maxInt(u64), math.maxInt(u64));
+}
lib/std/special/compiler_rt/floatdidf.zig
@@ -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");
-}
lib/std/special/compiler_rt/floatdidf_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/floatdisf_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/floatditf.zig
@@ -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");
-}
lib/std/special/compiler_rt/floatditf_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/floatfmodl_test.zig
@@ -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();
-}
lib/std/special/compiler_rt/floatfmodl.zig → lib/std/special/compiler_rt/floatfmodq.zig
@@ -1,9 +1,9 @@
const builtin = @import("builtin");
const std = @import("std");
-// fmodl - floating modulo large, returns the remainder of division for f128 types
+// fmodq - floating modulo large, returns the remainder of division for f128 types
// Logic and flow heavily inspired by MUSL fmodl for 113 mantissa digits
-pub fn fmodl(a: f128, b: f128) callconv(.C) f128 {
+pub fn fmodq(a: f128, b: f128) callconv(.C) f128 {
@setRuntimeSafety(builtin.is_test);
var amod = a;
var bmod = b;
@@ -30,9 +30,9 @@ pub fn fmodl(a: f128, b: f128) callconv(.C) f128 {
var expB = bPtr_u16[exp_and_sign_index] & 0x7fff;
// There are 3 cases where the answer is undefined, check for:
- // - fmodl(val, 0)
- // - fmodl(val, NaN)
- // - fmodl(inf, val)
+ // - fmodq(val, 0)
+ // - fmodq(val, NaN)
+ // - fmodq(inf, val)
// The sign on checked values does not matter.
// Doing (a * b) / (a * b) procudes undefined results
// because the three cases always produce undefined calculations:
@@ -122,5 +122,5 @@ pub fn fmodl(a: f128, b: f128) callconv(.C) f128 {
}
test {
- _ = @import("floatfmodl_test.zig");
+ _ = @import("floatfmodq_test.zig");
}
lib/std/special/compiler_rt/floatfmodq_test.zig
@@ -0,0 +1,46 @@
+const std = @import("std");
+const fmodq = @import("floatfmodq.zig");
+const testing = std.testing;
+
+fn test_fmodq(a: f128, b: f128, exp: f128) !void {
+ const res = fmodq.fmodq(a, b);
+ try testing.expect(exp == res);
+}
+
+fn test_fmodq_nans() !void {
+ try testing.expect(std.math.isNan(fmodq.fmodq(1.0, std.math.nan(f128))));
+ try testing.expect(std.math.isNan(fmodq.fmodq(1.0, -std.math.nan(f128))));
+ try testing.expect(std.math.isNan(fmodq.fmodq(std.math.nan(f128), 1.0)));
+ try testing.expect(std.math.isNan(fmodq.fmodq(-std.math.nan(f128), 1.0)));
+}
+
+fn test_fmodq_infs() !void {
+ try testing.expect(fmodq.fmodq(1.0, std.math.inf(f128)) == 1.0);
+ try testing.expect(fmodq.fmodq(1.0, -std.math.inf(f128)) == 1.0);
+ try testing.expect(std.math.isNan(fmodq.fmodq(std.math.inf(f128), 1.0)));
+ try testing.expect(std.math.isNan(fmodq.fmodq(-std.math.inf(f128), 1.0)));
+}
+
+test "fmodq" {
+ try test_fmodq(6.8, 4.0, 2.8);
+ try test_fmodq(6.8, -4.0, 2.8);
+ try test_fmodq(-6.8, 4.0, -2.8);
+ try test_fmodq(-6.8, -4.0, -2.8);
+ try test_fmodq(3.0, 2.0, 1.0);
+ try test_fmodq(-5.0, 3.0, -2.0);
+ try test_fmodq(3.0, 2.0, 1.0);
+ try test_fmodq(1.0, 2.0, 1.0);
+ try test_fmodq(0.0, 1.0, 0.0);
+ try test_fmodq(-0.0, 1.0, -0.0);
+ try test_fmodq(7046119.0, 5558362.0, 1487757.0);
+ try test_fmodq(9010357.0, 1957236.0, 1181413.0);
+
+ // Denormals
+ const a: f128 = 0xedcb34a235253948765432134674p-16494;
+ const b: f128 = 0x5d2e38791cfbc0737402da5a9518p-16494;
+ const exp: f128 = 0x336ec3affb2db8618e4e7d5e1c44p-16494;
+ try test_fmodq(a, b, exp);
+
+ try test_fmodq_nans();
+ try test_fmodq_infs();
+}
lib/std/special/compiler_rt/floatsiXf.zig
@@ -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);
-}
lib/std/special/compiler_rt/floattidf.zig
@@ -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");
-}
lib/std/special/compiler_rt/floattidf_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/floattisf_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/floattitf.zig
@@ -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");
-}
lib/std/special/compiler_rt/floattitf_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/floatundidf.zig
@@ -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");
-}
lib/std/special/compiler_rt/floatundidf_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/floatundisf.zig
@@ -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);
-}
lib/std/special/compiler_rt/floatunditf.zig
@@ -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");
-}
lib/std/special/compiler_rt/floatunditf_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/floatunsidf.zig
@@ -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);
-}
lib/std/special/compiler_rt/floatunsisf.zig
@@ -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);
-}
lib/std/special/compiler_rt/floatunsitf.zig
@@ -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");
-}
lib/std/special/compiler_rt/floatunsitf_test.zig
@@ -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);
-}
lib/std/special/compiler_rt/floatuntidf.zig
@@ -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");
-}
lib/std/special/compiler_rt/floatuntidf_test.zig
@@ -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;
-}
lib/std/special/compiler_rt/floatuntisf.zig
@@ -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");
-}
lib/std/special/compiler_rt/floatuntisf_test.zig
@@ -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;
-}
lib/std/special/compiler_rt/floatuntitf.zig
@@ -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");
-}
lib/std/special/compiler_rt/floatuntitf_test.zig
@@ -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;
-}
lib/std/special/compiler_rt/floatXisf.zig
@@ -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");
-}
lib/std/special/compiler_rt/floatXiYf.zig
@@ -0,0 +1,222 @@
+const builtin = @import("builtin");
+const is_test = builtin.is_test;
+const std = @import("std");
+const math = std.math;
+const expect = std.testing.expect;
+
+pub fn floatXiYf(comptime T: type, x: anytype) T {
+ @setRuntimeSafety(is_test);
+
+ if (x == 0) return 0;
+
+ // Various constants whose values follow from the type parameters.
+ // Any reasonable optimizer will fold and propagate all of these.
+ const Z = std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(x)));
+ const uT = std.meta.Int(.unsigned, @bitSizeOf(T));
+ const inf = math.inf(T);
+ const float_bits = @bitSizeOf(T);
+ const int_bits = @bitSizeOf(@TypeOf(x));
+ const exp_bits = math.floatExponentBits(T);
+ const sig_bits = math.floatMantissaDigits(T) - 1; // Only counts the fractional bits
+ const exp_bias = math.maxInt(std.meta.Int(.unsigned, exp_bits - 1));
+ const implicit_bit = if (T != f80) @as(uT, 1) << sig_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 <= sig_bits or exp <= sig_bits) {
+ const shift_amt = sig_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 - sig_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 << sig_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");
+}
lib/std/special/compiler_rt/floatXiYf_test.zig
@@ -0,0 +1,831 @@
+const std = @import("std");
+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" {
+ 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
+}
lib/std/special/compiler_rt/sparc.zig
@@ -66,19 +66,19 @@ pub fn _Qp_fge(a: *f128, b: *f128) callconv(.C) bool {
// Conversion
pub fn _Qp_itoq(c: *f128, a: i32) callconv(.C) void {
- c.* = @import("floatsiXf.zig").__floatsitf(a);
+ c.* = @import("floatXiYf.zig").__floatsitf(a);
}
pub fn _Qp_uitoq(c: *f128, a: u32) callconv(.C) void {
- c.* = @import("floatunsitf.zig").__floatunsitf(a);
+ c.* = @import("floatXiYf.zig").__floatunsitf(a);
}
pub fn _Qp_xtoq(c: *f128, a: i64) callconv(.C) void {
- c.* = @import("floatditf.zig").__floatditf(a);
+ c.* = @import("floatXiYf.zig").__floatditf(a);
}
pub fn _Qp_uxtoq(c: *f128, a: u64) callconv(.C) void {
- c.* = @import("floatunditf.zig").__floatunditf(a);
+ c.* = @import("floatXiYf.zig").__floatunditf(a);
}
pub fn _Qp_stoq(c: *f128, a: f32) callconv(.C) void {
@@ -90,19 +90,19 @@ pub fn _Qp_dtoq(c: *f128, a: f64) callconv(.C) void {
}
pub fn _Qp_qtoi(a: *f128) callconv(.C) i32 {
- return @import("fixtfsi.zig").__fixtfsi(a.*);
+ return @import("fixXfYi.zig").__fixtfsi(a.*);
}
pub fn _Qp_qtoui(a: *f128) callconv(.C) u32 {
- return @import("fixunstfsi.zig").__fixunstfsi(a.*);
+ return @import("fixXfYi.zig").__fixunstfsi(a.*);
}
pub fn _Qp_qtox(a: *f128) callconv(.C) i64 {
- return @import("fixtfdi.zig").__fixtfdi(a.*);
+ return @import("fixXfYi.zig").__fixtfdi(a.*);
}
pub fn _Qp_qtoux(a: *f128) callconv(.C) u64 {
- return @import("fixunstfdi.zig").__fixunstfdi(a.*);
+ return @import("fixXfYi.zig").__fixunstfdi(a.*);
}
pub fn _Qp_qtos(a: *f128) callconv(.C) f32 {
lib/std/special/compiler_rt/trunc_f80.zig
@@ -1,6 +1,7 @@
const std = @import("std");
const builtin = @import("builtin");
const native_arch = builtin.cpu.arch;
+const testing = std.testing;
// AArch64 is the only ABI (at the moment) to support f16 arguments without the
// need for extending them to wider fp types.
@@ -117,13 +118,12 @@ pub fn __trunctfxf2(a: f128) callconv(.C) f80 {
const src_abs_mask = src_sign_mask - 1;
const round_mask = (1 << (src_sig_bits - dst_sig_bits)) - 1;
const halfway = 1 << (src_sig_bits - dst_sig_bits - 1);
- const src_qnan = 1 << (src_sig_bits - 1);
- const src_nan_mask = src_qnan - 1;
// Break a into a sign and representation of the absolute value
const a_rep = @bitCast(u128, a);
const a_abs = a_rep & src_abs_mask;
const sign: u16 = if (a_rep & src_sign_mask != 0) 0x8000 else 0;
+ const integer_bit = 1 << 63;
var res: std.math.F80 = undefined;
@@ -133,27 +133,41 @@ pub fn __trunctfxf2(a: f128) callconv(.C) f80 {
// bit and inserting the (truncated) trailing NaN field.
res.exp = 0x7fff;
res.fraction = 0x8000000000000000;
- res.fraction |= @truncate(u64, (a_abs & src_qnan) << (src_sig_bits - dst_sig_bits));
- res.fraction |= @truncate(u64, (a_abs & src_nan_mask) << (src_sig_bits - dst_sig_bits));
+ res.fraction |= @truncate(u64, a_abs >> (src_sig_bits - dst_sig_bits));
} else {
// The exponent of a is within the range of normal numbers in the
// destination format. We can convert by simply right-shifting with
- // rounding and adjusting the exponent.
- res.fraction = @truncate(u64, a_abs >> (src_sig_bits - dst_sig_bits));
+ // rounding, adding the explicit integer bit, and adjusting the exponent
+ res.fraction = @truncate(u64, a_abs >> (src_sig_bits - dst_sig_bits)) | integer_bit;
res.exp = @truncate(u16, a_abs >> src_sig_bits);
const round_bits = a_abs & round_mask;
if (round_bits > halfway) {
// Round to nearest
- const exp = @addWithOverflow(u64, res.fraction, 1, &res.fraction);
- res.exp += @boolToInt(exp);
+ const carry = @boolToInt(@addWithOverflow(u64, res.fraction, 1, &res.fraction));
+ res.exp += carry;
+ res.fraction |= @as(u64, carry) << 63; // Restore integer bit after carry
} else if (round_bits == halfway) {
// Ties to even
- const exp = @addWithOverflow(u64, res.fraction, res.fraction & 1, &res.fraction);
- res.exp += @boolToInt(exp);
+ const carry = @boolToInt(@addWithOverflow(u64, res.fraction, res.fraction & 1, &res.fraction));
+ res.exp += carry;
+ res.fraction |= @as(u64, carry) << 63; // Restore integer bit after carry
}
+ if (res.exp == 0) res.fraction &= ~@as(u64, integer_bit); // Remove integer bit for de-normals
}
res.exp |= sign;
return std.math.make_f80(res);
}
+
+fn test__trunctfxf2(a: f128, expected: f80) !void {
+ const x = __trunctfxf2(a);
+ try testing.expect(x == expected);
+}
+
+test {
+ try test__trunctfxf2(1.5, 1.5);
+ try test__trunctfxf2(2.5, 2.5);
+ try test__trunctfxf2(-2.5, -2.5);
+ try test__trunctfxf2(0.0, 0.0);
+}
lib/std/special/compiler_rt.zig
@@ -291,100 +291,149 @@ comptime {
const __bswapti2 = @import("compiler_rt/bswap.zig").__bswapti2;
@export(__bswapti2, .{ .name = "__bswapti2", .linkage = linkage });
- // Integral / floating point conversion (part 1/2)
- const __floatsidf = @import("compiler_rt/floatsiXf.zig").__floatsidf;
- @export(__floatsidf, .{ .name = "__floatsidf", .linkage = linkage });
- const __floatsisf = @import("compiler_rt/floatsiXf.zig").__floatsisf;
- @export(__floatsisf, .{ .name = "__floatsisf", .linkage = linkage });
- const __floatdidf = @import("compiler_rt/floatdidf.zig").__floatdidf;
- @export(__floatdidf, .{ .name = "__floatdidf", .linkage = linkage });
- const __floatsitf = @import("compiler_rt/floatsiXf.zig").__floatsitf;
- @export(__floatsitf, .{ .name = "__floatsitf", .linkage = linkage });
+ // Integral -> Float Conversion
- const __floatunsisf = @import("compiler_rt/floatunsisf.zig").__floatunsisf;
+ // Conversion to f32
+ const __floatsisf = @import("compiler_rt/floatXiYf.zig").__floatsisf;
+ @export(__floatsisf, .{ .name = "__floatsisf", .linkage = linkage });
+ const __floatunsisf = @import("compiler_rt/floatXiYf.zig").__floatunsisf;
@export(__floatunsisf, .{ .name = "__floatunsisf", .linkage = linkage });
- const __floatundisf = @import("compiler_rt/floatundisf.zig").__floatundisf;
+
+ const __floatundisf = @import("compiler_rt/floatXiYf.zig").__floatundisf;
@export(__floatundisf, .{ .name = "__floatundisf", .linkage = linkage });
- const __floatunsidf = @import("compiler_rt/floatunsidf.zig").__floatunsidf;
+ const __floatdisf = @import("compiler_rt/floatXiYf.zig").__floatdisf;
+ @export(__floatdisf, .{ .name = "__floatdisf", .linkage = linkage });
+
+ const __floattisf = @import("compiler_rt/floatXiYf.zig").__floattisf;
+ @export(__floattisf, .{ .name = "__floattisf", .linkage = linkage });
+ const __floatuntisf = @import("compiler_rt/floatXiYf.zig").__floatuntisf;
+ @export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = linkage });
+
+ // Conversion to f64
+ const __floatsidf = @import("compiler_rt/floatXiYf.zig").__floatsidf;
+ @export(__floatsidf, .{ .name = "__floatsidf", .linkage = linkage });
+ const __floatunsidf = @import("compiler_rt/floatXiYf.zig").__floatunsidf;
@export(__floatunsidf, .{ .name = "__floatunsidf", .linkage = linkage });
- const __floatundidf = @import("compiler_rt/floatundidf.zig").__floatundidf;
+
+ const __floatdidf = @import("compiler_rt/floatXiYf.zig").__floatdidf;
+ @export(__floatdidf, .{ .name = "__floatdidf", .linkage = linkage });
+ const __floatundidf = @import("compiler_rt/floatXiYf.zig").__floatundidf;
@export(__floatundidf, .{ .name = "__floatundidf", .linkage = linkage });
- const __floatditf = @import("compiler_rt/floatditf.zig").__floatditf;
- @export(__floatditf, .{ .name = "__floatditf", .linkage = linkage });
- const __floattitf = @import("compiler_rt/floattitf.zig").__floattitf;
- @export(__floattitf, .{ .name = "__floattitf", .linkage = linkage });
- const __floattidf = @import("compiler_rt/floattidf.zig").__floattidf;
+ const __floattidf = @import("compiler_rt/floatXiYf.zig").__floattidf;
@export(__floattidf, .{ .name = "__floattidf", .linkage = linkage });
- const __floattisf = @import("compiler_rt/floatXisf.zig").__floattisf;
- @export(__floattisf, .{ .name = "__floattisf", .linkage = linkage });
- const __floatdisf = @import("compiler_rt/floatXisf.zig").__floatdisf;
- @export(__floatdisf, .{ .name = "__floatdisf", .linkage = linkage });
+ const __floatuntidf = @import("compiler_rt/floatXiYf.zig").__floatuntidf;
+ @export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = linkage });
- const __floatunditf = @import("compiler_rt/floatunditf.zig").__floatunditf;
- @export(__floatunditf, .{ .name = "__floatunditf", .linkage = linkage });
- const __floatunsitf = @import("compiler_rt/floatunsitf.zig").__floatunsitf;
+ // Conversion to f80
+ const __floatsixf = @import("compiler_rt/floatXiYf.zig").__floatsixf;
+ @export(__floatsixf, .{ .name = "__floatsixf", .linkage = linkage });
+ const __floatunsixf = @import("compiler_rt/floatXiYf.zig").__floatunsixf;
+ @export(__floatunsixf, .{ .name = "__floatunsixf", .linkage = linkage });
+
+ const __floatdixf = @import("compiler_rt/floatXiYf.zig").__floatdixf;
+ @export(__floatdixf, .{ .name = "__floatdixf", .linkage = linkage });
+ const __floatundixf = @import("compiler_rt/floatXiYf.zig").__floatundixf;
+ @export(__floatundixf, .{ .name = "__floatundixf", .linkage = linkage });
+
+ const __floattixf = @import("compiler_rt/floatXiYf.zig").__floattixf;
+ @export(__floattixf, .{ .name = "__floattixf", .linkage = linkage });
+ const __floatuntixf = @import("compiler_rt/floatXiYf.zig").__floatuntixf;
+ @export(__floatuntixf, .{ .name = "__floatuntixf", .linkage = linkage });
+
+ // Conversion to f128
+ const __floatsitf = @import("compiler_rt/floatXiYf.zig").__floatsitf;
+ @export(__floatsitf, .{ .name = "__floatsitf", .linkage = linkage });
+ const __floatunsitf = @import("compiler_rt/floatXiYf.zig").__floatunsitf;
@export(__floatunsitf, .{ .name = "__floatunsitf", .linkage = linkage });
- const __floatuntitf = @import("compiler_rt/floatuntitf.zig").__floatuntitf;
+ const __floatditf = @import("compiler_rt/floatXiYf.zig").__floatditf;
+ @export(__floatditf, .{ .name = "__floatditf", .linkage = linkage });
+ const __floatunditf = @import("compiler_rt/floatXiYf.zig").__floatunditf;
+ @export(__floatunditf, .{ .name = "__floatunditf", .linkage = linkage });
+
+ const __floattitf = @import("compiler_rt/floatXiYf.zig").__floattitf;
+ @export(__floattitf, .{ .name = "__floattitf", .linkage = linkage });
+ const __floatuntitf = @import("compiler_rt/floatXiYf.zig").__floatuntitf;
@export(__floatuntitf, .{ .name = "__floatuntitf", .linkage = linkage });
- const __floatuntidf = @import("compiler_rt/floatuntidf.zig").__floatuntidf;
- @export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = linkage });
- const __floatuntisf = @import("compiler_rt/floatuntisf.zig").__floatuntisf;
- @export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = linkage });
- const __truncsfhf2 = @import("compiler_rt/truncXfYf2.zig").__truncsfhf2;
- @export(__truncsfhf2, .{ .name = "__truncsfhf2", .linkage = linkage });
- if (!is_test) {
- @export(__truncsfhf2, .{ .name = "__gnu_f2h_ieee", .linkage = linkage });
- }
- const __extendsfdf2 = @import("compiler_rt/extendXfYf2.zig").__extendsfdf2;
- @export(__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = linkage });
+ // Float -> Integral Conversion
- // Integral / floating point conversion (part 2/2)
- const __fixunssfsi = @import("compiler_rt/fixunssfsi.zig").__fixunssfsi;
+ // Conversion from f32
+ const __fixsfsi = @import("compiler_rt/fixXfYi.zig").__fixsfsi;
+ @export(__fixsfsi, .{ .name = "__fixsfsi", .linkage = linkage });
+ const __fixunssfsi = @import("compiler_rt/fixXfYi.zig").__fixunssfsi;
@export(__fixunssfsi, .{ .name = "__fixunssfsi", .linkage = linkage });
- const __fixunssfdi = @import("compiler_rt/fixunssfdi.zig").__fixunssfdi;
+
+ const __fixsfdi = @import("compiler_rt/fixXfYi.zig").__fixsfdi;
+ @export(__fixsfdi, .{ .name = "__fixsfdi", .linkage = linkage });
+ const __fixunssfdi = @import("compiler_rt/fixXfYi.zig").__fixunssfdi;
@export(__fixunssfdi, .{ .name = "__fixunssfdi", .linkage = linkage });
- const __fixunssfti = @import("compiler_rt/fixunssfti.zig").__fixunssfti;
+
+ const __fixsfti = @import("compiler_rt/fixXfYi.zig").__fixsfti;
+ @export(__fixsfti, .{ .name = "__fixsfti", .linkage = linkage });
+ const __fixunssfti = @import("compiler_rt/fixXfYi.zig").__fixunssfti;
@export(__fixunssfti, .{ .name = "__fixunssfti", .linkage = linkage });
- const __fixunsdfsi = @import("compiler_rt/fixunsdfsi.zig").__fixunsdfsi;
+ // Conversion from f64
+ const __fixdfsi = @import("compiler_rt/fixXfYi.zig").__fixdfsi;
+ @export(__fixdfsi, .{ .name = "__fixdfsi", .linkage = linkage });
+ const __fixunsdfsi = @import("compiler_rt/fixXfYi.zig").__fixunsdfsi;
@export(__fixunsdfsi, .{ .name = "__fixunsdfsi", .linkage = linkage });
- const __fixunsdfdi = @import("compiler_rt/fixunsdfdi.zig").__fixunsdfdi;
+
+ const __fixdfdi = @import("compiler_rt/fixXfYi.zig").__fixdfdi;
+ @export(__fixdfdi, .{ .name = "__fixdfdi", .linkage = linkage });
+ const __fixunsdfdi = @import("compiler_rt/fixXfYi.zig").__fixunsdfdi;
@export(__fixunsdfdi, .{ .name = "__fixunsdfdi", .linkage = linkage });
- const __fixunsdfti = @import("compiler_rt/fixunsdfti.zig").__fixunsdfti;
+
+ const __fixdfti = @import("compiler_rt/fixXfYi.zig").__fixdfti;
+ @export(__fixdfti, .{ .name = "__fixdfti", .linkage = linkage });
+ const __fixunsdfti = @import("compiler_rt/fixXfYi.zig").__fixunsdfti;
@export(__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = linkage });
- const __fixunstfsi = @import("compiler_rt/fixunstfsi.zig").__fixunstfsi;
+ // Conversion from f80
+ const __fixxfsi = @import("compiler_rt/fixXfYi.zig").__fixxfsi;
+ @export(__fixxfsi, .{ .name = "__fixxfsi", .linkage = linkage });
+ const __fixunsxfsi = @import("compiler_rt/fixXfYi.zig").__fixunsxfsi;
+ @export(__fixunsxfsi, .{ .name = "__fixunsxfsi", .linkage = linkage });
+
+ const __fixxfdi = @import("compiler_rt/fixXfYi.zig").__fixxfdi;
+ @export(__fixxfdi, .{ .name = "__fixxfdi", .linkage = linkage });
+ const __fixunsxfdi = @import("compiler_rt/fixXfYi.zig").__fixunsxfdi;
+ @export(__fixunsxfdi, .{ .name = "__fixunsxfdi", .linkage = linkage });
+
+ const __fixxfti = @import("compiler_rt/fixXfYi.zig").__fixxfti;
+ @export(__fixxfti, .{ .name = "__fixxfti", .linkage = linkage });
+ const __fixunsxfti = @import("compiler_rt/fixXfYi.zig").__fixunsxfti;
+ @export(__fixunsxfti, .{ .name = "__fixunsxfti", .linkage = linkage });
+
+ // Conversion from f128
+ const __fixtfsi = @import("compiler_rt/fixXfYi.zig").__fixtfsi;
+ @export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = linkage });
+ const __fixunstfsi = @import("compiler_rt/fixXfYi.zig").__fixunstfsi;
@export(__fixunstfsi, .{ .name = "__fixunstfsi", .linkage = linkage });
- const __fixunstfdi = @import("compiler_rt/fixunstfdi.zig").__fixunstfdi;
- @export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = linkage });
- const __fixunstfti = @import("compiler_rt/fixunstfti.zig").__fixunstfti;
- @export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = linkage });
- const __fixdfdi = @import("compiler_rt/fixdfdi.zig").__fixdfdi;
- @export(__fixdfdi, .{ .name = "__fixdfdi", .linkage = linkage });
- const __fixdfsi = @import("compiler_rt/fixdfsi.zig").__fixdfsi;
- @export(__fixdfsi, .{ .name = "__fixdfsi", .linkage = linkage });
- const __fixdfti = @import("compiler_rt/fixdfti.zig").__fixdfti;
- @export(__fixdfti, .{ .name = "__fixdfti", .linkage = linkage });
- const __fixsfdi = @import("compiler_rt/fixsfdi.zig").__fixsfdi;
- @export(__fixsfdi, .{ .name = "__fixsfdi", .linkage = linkage });
- const __fixsfsi = @import("compiler_rt/fixsfsi.zig").__fixsfsi;
- @export(__fixsfsi, .{ .name = "__fixsfsi", .linkage = linkage });
- const __fixsfti = @import("compiler_rt/fixsfti.zig").__fixsfti;
- @export(__fixsfti, .{ .name = "__fixsfti", .linkage = linkage });
- const __fixtfdi = @import("compiler_rt/fixtfdi.zig").__fixtfdi;
+ const __fixtfdi = @import("compiler_rt/fixXfYi.zig").__fixtfdi;
@export(__fixtfdi, .{ .name = "__fixtfdi", .linkage = linkage });
- const __fixtfsi = @import("compiler_rt/fixtfsi.zig").__fixtfsi;
- @export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = linkage });
- const __fixtfti = @import("compiler_rt/fixtfti.zig").__fixtfti;
+ const __fixunstfdi = @import("compiler_rt/fixXfYi.zig").__fixunstfdi;
+ @export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = linkage });
+
+ const __fixtfti = @import("compiler_rt/fixXfYi.zig").__fixtfti;
@export(__fixtfti, .{ .name = "__fixtfti", .linkage = linkage });
+ const __fixunstfti = @import("compiler_rt/fixXfYi.zig").__fixunstfti;
+ @export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = linkage });
const __udivmoddi4 = @import("compiler_rt/int.zig").__udivmoddi4;
@export(__udivmoddi4, .{ .name = "__udivmoddi4", .linkage = linkage });
+ const __truncsfhf2 = @import("compiler_rt/truncXfYf2.zig").__truncsfhf2;
+ @export(__truncsfhf2, .{ .name = "__truncsfhf2", .linkage = linkage });
+ if (!is_test) {
+ @export(__truncsfhf2, .{ .name = "__gnu_f2h_ieee", .linkage = linkage });
+ }
+ const __extendsfdf2 = @import("compiler_rt/extendXfYf2.zig").__extendsfdf2;
+ @export(__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = linkage });
+
if (is_darwin) {
const __isPlatformVersionAtLeast = @import("compiler_rt/os_version_check.zig").__isPlatformVersionAtLeast;
@export(__isPlatformVersionAtLeast, .{ .name = "__isPlatformVersionAtLeast", .linkage = linkage });
@@ -553,19 +602,19 @@ comptime {
const __aeabi_f2d = @import("compiler_rt/extendXfYf2.zig").__aeabi_f2d;
@export(__aeabi_f2d, .{ .name = "__aeabi_f2d", .linkage = linkage });
- const __aeabi_i2d = @import("compiler_rt/floatsiXf.zig").__aeabi_i2d;
+ const __aeabi_i2d = @import("compiler_rt/floatXiYf.zig").__aeabi_i2d;
@export(__aeabi_i2d, .{ .name = "__aeabi_i2d", .linkage = linkage });
- const __aeabi_l2d = @import("compiler_rt/floatdidf.zig").__aeabi_l2d;
+ const __aeabi_l2d = @import("compiler_rt/floatXiYf.zig").__aeabi_l2d;
@export(__aeabi_l2d, .{ .name = "__aeabi_l2d", .linkage = linkage });
- const __aeabi_l2f = @import("compiler_rt/floatXisf.zig").__aeabi_l2f;
+ const __aeabi_l2f = @import("compiler_rt/floatXiYf.zig").__aeabi_l2f;
@export(__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = linkage });
- const __aeabi_ui2d = @import("compiler_rt/floatunsidf.zig").__aeabi_ui2d;
+ const __aeabi_ui2d = @import("compiler_rt/floatXiYf.zig").__aeabi_ui2d;
@export(__aeabi_ui2d, .{ .name = "__aeabi_ui2d", .linkage = linkage });
- const __aeabi_ul2d = @import("compiler_rt/floatundidf.zig").__aeabi_ul2d;
+ const __aeabi_ul2d = @import("compiler_rt/floatXiYf.zig").__aeabi_ul2d;
@export(__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = linkage });
- const __aeabi_ui2f = @import("compiler_rt/floatunsisf.zig").__aeabi_ui2f;
+ const __aeabi_ui2f = @import("compiler_rt/floatXiYf.zig").__aeabi_ui2f;
@export(__aeabi_ui2f, .{ .name = "__aeabi_ui2f", .linkage = linkage });
- const __aeabi_ul2f = @import("compiler_rt/floatundisf.zig").__aeabi_ul2f;
+ const __aeabi_ul2f = @import("compiler_rt/floatXiYf.zig").__aeabi_ul2f;
@export(__aeabi_ul2f, .{ .name = "__aeabi_ul2f", .linkage = linkage });
const __aeabi_fneg = @import("compiler_rt/negXf2.zig").__aeabi_fneg;
@@ -581,17 +630,17 @@ comptime {
const __aeabi_d2h = @import("compiler_rt/truncXfYf2.zig").__aeabi_d2h;
@export(__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = linkage });
- const __aeabi_f2ulz = @import("compiler_rt/fixunssfdi.zig").__aeabi_f2ulz;
+ const __aeabi_f2ulz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2ulz;
@export(__aeabi_f2ulz, .{ .name = "__aeabi_f2ulz", .linkage = linkage });
- const __aeabi_d2ulz = @import("compiler_rt/fixunsdfdi.zig").__aeabi_d2ulz;
+ const __aeabi_d2ulz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2ulz;
@export(__aeabi_d2ulz, .{ .name = "__aeabi_d2ulz", .linkage = linkage });
- const __aeabi_f2lz = @import("compiler_rt/fixsfdi.zig").__aeabi_f2lz;
+ const __aeabi_f2lz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2lz;
@export(__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = linkage });
- const __aeabi_d2lz = @import("compiler_rt/fixdfdi.zig").__aeabi_d2lz;
+ const __aeabi_d2lz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2lz;
@export(__aeabi_d2lz, .{ .name = "__aeabi_d2lz", .linkage = linkage });
- const __aeabi_d2uiz = @import("compiler_rt/fixunsdfsi.zig").__aeabi_d2uiz;
+ const __aeabi_d2uiz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2uiz;
@export(__aeabi_d2uiz, .{ .name = "__aeabi_d2uiz", .linkage = linkage });
const __aeabi_h2f = @import("compiler_rt/extendXfYf2.zig").__aeabi_h2f;
@@ -599,7 +648,7 @@ comptime {
const __aeabi_f2h = @import("compiler_rt/truncXfYf2.zig").__aeabi_f2h;
@export(__aeabi_f2h, .{ .name = "__aeabi_f2h", .linkage = linkage });
- const __aeabi_i2f = @import("compiler_rt/floatsiXf.zig").__aeabi_i2f;
+ const __aeabi_i2f = @import("compiler_rt/floatXiYf.zig").__aeabi_i2f;
@export(__aeabi_i2f, .{ .name = "__aeabi_i2f", .linkage = linkage });
const __aeabi_d2f = @import("compiler_rt/truncXfYf2.zig").__aeabi_d2f;
@export(__aeabi_d2f, .{ .name = "__aeabi_d2f", .linkage = linkage });
@@ -613,12 +662,12 @@ comptime {
const __aeabi_dsub = @import("compiler_rt/addXf3.zig").__aeabi_dsub;
@export(__aeabi_dsub, .{ .name = "__aeabi_dsub", .linkage = linkage });
- const __aeabi_f2uiz = @import("compiler_rt/fixunssfsi.zig").__aeabi_f2uiz;
+ const __aeabi_f2uiz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2uiz;
@export(__aeabi_f2uiz, .{ .name = "__aeabi_f2uiz", .linkage = linkage });
- const __aeabi_f2iz = @import("compiler_rt/fixsfsi.zig").__aeabi_f2iz;
+ const __aeabi_f2iz = @import("compiler_rt/fixXfYi.zig").__aeabi_f2iz;
@export(__aeabi_f2iz, .{ .name = "__aeabi_f2iz", .linkage = linkage });
- const __aeabi_d2iz = @import("compiler_rt/fixdfsi.zig").__aeabi_d2iz;
+ const __aeabi_d2iz = @import("compiler_rt/fixXfYi.zig").__aeabi_d2iz;
@export(__aeabi_d2iz, .{ .name = "__aeabi_d2iz", .linkage = linkage });
const __aeabi_fdiv = @import("compiler_rt/divsf3.zig").__aeabi_fdiv;
@@ -672,9 +721,12 @@ comptime {
@export(_aullrem, .{ .name = "\x01__aullrem", .linkage = strong_linkage });
}
- const fmodl = @import("compiler_rt/floatfmodl.zig").fmodl;
+ const fmodq = @import("compiler_rt/floatfmodq.zig").fmodq;
if (!is_test) {
- @export(fmodl, .{ .name = "fmodl", .linkage = linkage });
+ @export(fmodq, .{ .name = "fmodq", .linkage = linkage });
+ if (long_double_is_f128) {
+ @export(fmodq, .{ .name = "fmodl", .linkage = linkage });
+ }
@export(floorf, .{ .name = "floorf", .linkage = linkage });
@export(floor, .{ .name = "floor", .linkage = linkage });
CMakeLists.txt
@@ -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"