Commit be861a85c8

@@ -0,0 +1,191 @@
+// Ported from:
+//
+// https://github.com/llvm-mirror/compiler-rt/blob/92f7768ce940f6437b32ecc0985a1446cd040f7a/lib/builtins/fp_add_impl.inc
+
+const std = @import("std");
+const builtin = @import("builtin");
+const compiler_rt = @import("index.zig");
+
+pub extern fn __addtf3(a: f128, b: f128) f128 {
+    return addXf3(f128, a, b);
+}
+
+pub extern fn __subtf3(a: f128, b: f128) f128 {
+    const neg_b = @bitCast(f128, @bitCast(u128, b) ^ (u128(1) << 127));
+    return addXf3(f128, a, neg_b);
+}
+
+inline fn normalize(comptime T: type, significand: *@IntType(false, T.bit_count)) i32 {
+    const Z = @IntType(false, T.bit_count);
+    const significandBits = std.math.floatMantissaBits(T);
+    const implicitBit = Z(1) << significandBits;
+
+    const shift = @clz(significand.*) - @clz(implicitBit);
+    significand.* <<= @intCast(u7, shift);
+    return 1 - shift;
+}
+
+inline fn addXf3(comptime T: type, a: T, b: T) T {
+    const Z = @IntType(false, T.bit_count);
+
+    const typeWidth = T.bit_count;
+    const significandBits = std.math.floatMantissaBits(T);
+    const exponentBits = std.math.floatExponentBits(T);
+
+    const signBit = (Z(1) << (significandBits + exponentBits));
+    const maxExponent = ((1 << exponentBits) - 1);
+    const exponentBias = (maxExponent >> 1);
+
+    const implicitBit = (Z(1) << significandBits);
+    const quietBit = implicitBit >> 1;
+    const significandMask = implicitBit - 1;
+
+    const absMask = signBit - 1;
+    const exponentMask = absMask ^ significandMask;
+    const qnanRep = exponentMask | quietBit;
+
+    var aRep = @bitCast(Z, a);
+    var bRep = @bitCast(Z, b);
+    const aAbs = aRep & absMask;
+    const bAbs = bRep & absMask;
+
+    const negative = (aRep & signBit) != 0;
+    const exponent = @intCast(i32, aAbs >> significandBits) - exponentBias;
+    const significand = (aAbs & significandMask) | implicitBit;
+
+    const infRep = @bitCast(Z, std.math.inf(T));
+
+    // Detect if a or b is zero, infinity, or NaN.
+    if (aAbs - Z(1) >= infRep - Z(1) or
+        bAbs - Z(1) >= infRep - Z(1))
+    {
+        // NaN + anything = qNaN
+        if (aAbs > infRep) return @bitCast(T, @bitCast(Z, a) | quietBit);
+        // anything + NaN = qNaN
+        if (bAbs > infRep) return @bitCast(T, @bitCast(Z, b) | quietBit);
+
+        if (aAbs == infRep) {
+            // +/-infinity + -/+infinity = qNaN
+            if ((@bitCast(Z, a) ^ @bitCast(Z, b)) == signBit) {
+                return @bitCast(T, qnanRep);
+            }
+            // +/-infinity + anything remaining = +/- infinity
+            else {
+                return a;
+            }
+        }
+
+        // anything remaining + +/-infinity = +/-infinity
+        if (bAbs == infRep) return b;
+
+        // zero + anything = anything
+        if (aAbs == 0) {
+            // but we need to get the sign right for zero + zero
+            if (bAbs == 0) {
+                return @bitCast(T, @bitCast(Z, a) & @bitCast(Z, b));
+            } else {
+                return b;
+            }
+        }
+
+        // anything + zero = anything
+        if (bAbs == 0) return a;
+    }
+
+    // Swap a and b if necessary so that a has the larger absolute value.
+    if (bAbs > aAbs) {
+        const temp = aRep;
+        aRep = bRep;
+        bRep = temp;
+    }
+
+    // Extract the exponent and significand from the (possibly swapped) a and b.
+    var aExponent = @intCast(i32, (aRep >> significandBits) & maxExponent);
+    var bExponent = @intCast(i32, (bRep >> significandBits) & maxExponent);
+    var aSignificand = aRep & significandMask;
+    var bSignificand = bRep & significandMask;
+
+    // Normalize any denormals, and adjust the exponent accordingly.
+    if (aExponent == 0) aExponent = normalize(T, &aSignificand);
+    if (bExponent == 0) bExponent = normalize(T, &bSignificand);
+
+    // The sign of the result is the sign of the larger operand, a.  If they
+    // have opposite signs, we are performing a subtraction; otherwise addition.
+    const resultSign = aRep & signBit;
+    const subtraction = (aRep ^ bRep) & signBit != 0;
+
+    // Shift the significands to give us round, guard and sticky, and or in the
+    // implicit significand bit.  (If we fell through from the denormal path it
+    // was already set by normalize( ), but setting it twice won't hurt
+    // anything.)
+    aSignificand = (aSignificand | implicitBit) << 3;
+    bSignificand = (bSignificand | implicitBit) << 3;
+
+    // Shift the significand of b by the difference in exponents, with a sticky
+    // bottom bit to get rounding correct.
+    const @"align" = @intCast(Z, aExponent - bExponent);
+    if (@"align" != 0) {
+        if (@"align" < typeWidth) {
+            const sticky = if (bSignificand << @intCast(u7, typeWidth - @"align") != 0) Z(1) else 0;
+            bSignificand = (bSignificand >> @truncate(u7, @"align")) | sticky;
+        } else {
+            bSignificand = 1; // sticky; b is known to be non-zero.
+        }
+    }
+    if (subtraction) {
+        aSignificand -= bSignificand;
+        // If a == -b, return +zero.
+        if (aSignificand == 0) return @bitCast(T, Z(0));
+
+        // If partial cancellation occured, we need to left-shift the result
+        // and adjust the exponent:
+        if (aSignificand < implicitBit << 3) {
+            const shift = @intCast(i32, @clz(aSignificand)) - @intCast(i32, @clz(implicitBit << 3));
+            aSignificand <<= @intCast(u7, shift);
+            aExponent -= shift;
+        }
+    } else { // addition
+        aSignificand += bSignificand;
+
+        // If the addition carried up, we need to right-shift the result and
+        // adjust the exponent:
+        if (aSignificand & (implicitBit << 4) != 0) {
+            const sticky = aSignificand & 1;
+            aSignificand = aSignificand >> 1 | sticky;
+            aExponent += 1;
+        }
+    }
+
+    // If we have overflowed the type, return +/- infinity:
+    if (aExponent >= maxExponent) return @bitCast(T, infRep | resultSign);
+
+    if (aExponent <= 0) {
+        // Result is denormal before rounding; the exponent is zero and we
+        // need to shift the significand.
+        const shift = @intCast(Z, 1 - aExponent);
+        const sticky = if (aSignificand << @intCast(u7, typeWidth - shift) != 0) Z(1) else 0;
+        aSignificand = aSignificand >> @intCast(u7, shift | sticky);
+        aExponent = 0;
+    }
+
+    // Low three bits are round, guard, and sticky.
+    const roundGuardSticky = aSignificand & 0x7;
+
+    // Shift the significand into place, and mask off the implicit bit.
+    var result = (aSignificand >> 3) & significandMask;
+
+    // Insert the exponent and sign.
+    result |= @intCast(Z, aExponent) << significandBits;
+    result |= resultSign;
+
+    // Final rounding.  The result may overflow to infinity, but that is the
+    // correct result in that case.
+    if (roundGuardSticky > 0x4) result += 1;
+    if (roundGuardSticky == 0x4) result += result & 1;
+
+    return @bitCast(T, result);
+}
+
+test "import addXf3" {
+    _ = @import("addXf3_test.zig");
+}

@@ -0,0 +1,85 @@
+// Ported from:
+//
+// https://github.com/llvm-mirror/compiler-rt/blob/92f7768ce940f6437b32ecc0985a1446cd040f7a/test/builtins/Unit/addtf3_test.c
+// https://github.com/llvm-mirror/compiler-rt/blob/92f7768ce940f6437b32ecc0985a1446cd040f7a/test/builtins/Unit/subtf3_test.c
+
+const qnan128 = @bitCast(f128, u128(0x7fff800000000000) << 64);
+const inf128 = @bitCast(f128, u128(0x7fff000000000000) << 64);
+
+const __addtf3 = @import("addXf3.zig").__addtf3;
+
+fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
+    const x = __addtf3(a, b);
+
+    const rep = @bitCast(u128, x);
+    const hi = @intCast(u64, rep >> 64);
+    const lo = @truncate(u64, rep);
+
+    if (hi == expected_hi and lo == expected_lo) {
+        return;
+    }
+    // test other possible NaN representation (signal NaN)
+    else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
+        if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
+            ((hi & 0xffffffffffff) > 0 or lo > 0))
+        {
+            return;
+        }
+    }
+
+    @panic("__addtf3 test failure");
+}
+
+test "addtf3" {
+    test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+
+    // NaN + any = NaN
+    test__addtf3(@bitCast(f128, (u128(0x7fff000000000000) << 64) | u128(0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+
+    // inf + inf = inf
+    test__addtf3(inf128, inf128, 0x7fff000000000000, 0x0);
+
+    // inf + any = inf
+    test__addtf3(inf128, 0x1.2335653452436234723489432abcdefp+5, 0x7fff000000000000, 0x0);
+
+    // any + any
+    test__addtf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);
+}
+
+const __subtf3 = @import("addXf3.zig").__subtf3;
+
+fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
+    const x = __subtf3(a, b);
+
+    const rep = @bitCast(u128, x);
+    const hi = @intCast(u64, rep >> 64);
+    const lo = @truncate(u64, rep);
+
+    if (hi == expected_hi and lo == expected_lo) {
+        return;
+    }
+    // test other possible NaN representation (signal NaN)
+    else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
+        if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
+            ((hi & 0xffffffffffff) > 0 or lo > 0))
+        {
+            return;
+        }
+    }
+
+    @panic("__subtf3 test failure");
+}
+
+test "subtf3" {
+    // qNaN - any = qNaN
+    test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+
+    // NaN + any = NaN
+    test__subtf3(@bitCast(f128, (u128(0x7fff000000000000) << 64) | u128(0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+
+    // inf - any = inf
+    test__subtf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
+
+    // any + any
+    test__subtf3(0x1.234567829a3bcdef5678ade36734p+5, 0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x40041b8af1915166, 0xa44a7bca780a166c);
+}

@@ -21,6 +21,9 @@ comptime {
 
     @export("__unordtf2", @import("comparetf2.zig").__unordtf2, linkage);
 
+    @export("__addtf3", @import("addXf3.zig").__addtf3, linkage);
+    @export("__subtf3", @import("addXf3.zig").__subtf3, linkage);
+
     @export("__floattitf", @import("floattitf.zig").__floattitf, linkage);
     @export("__floattidf", @import("floattidf.zig").__floattidf, linkage);
     @export("__floattisf", @import("floattisf.zig").__floattisf, linkage);
@@ -37,6 +40,7 @@ comptime {
     @export("__extendhfsf2", @import("extendXfYf2.zig").__extendhfsf2, linkage);
 
     @export("__truncsfhf2", @import("truncXfYf2.zig").__truncsfhf2, linkage);
+    @export("__truncdfhf2", @import("truncXfYf2.zig").__truncdfhf2, linkage);
     @export("__trunctfdf2", @import("truncXfYf2.zig").__trunctfdf2, linkage);
     @export("__trunctfsf2", @import("truncXfYf2.zig").__trunctfsf2, linkage);
 

@@ -4,6 +4,10 @@ pub extern fn __truncsfhf2(a: f32) u16 {
     return @bitCast(u16, truncXfYf2(f16, f32, a));
 }
 
+pub extern fn __truncdfhf2(a: f64) u16 {
+    return @bitCast(u16, truncXfYf2(f16, f64, a));
+}
+
 pub extern fn __trunctfsf2(a: f128) f32 {
     return truncXfYf2(f32, f128, a);
 }

@@ -63,6 +63,74 @@ test "truncsfhf2" {
     test__truncsfhf2(0x33000000, 0x0000); // 0x1.0p-25 -> zero
 }
 
+const __truncdfhf2 = @import("truncXfYf2.zig").__truncdfhf2;
+
+fn test__truncdfhf2(a: f64, expected: u16) void {
+    const rep = @bitCast(u16, __truncdfhf2(a));
+
+    if (rep == expected) {
+        return;
+    }
+    // test other possible NaN representation(signal NaN)
+    else if (expected == 0x7e00) {
+        if ((rep & 0x7c00) == 0x7c00 and (rep & 0x3ff) > 0) {
+            return;
+        }
+    }
+
+    @panic("__truncdfhf2 test failure");
+}
+
+fn test__truncdfhf2_raw(a: u64, expected: u16) void {
+    const actual = __truncdfhf2(@bitCast(f64, a));
+
+    if (actual == expected) {
+        return;
+    }
+
+    @panic("__truncdfhf2 test failure");
+}
+
+test "truncdfhf2" {
+    test__truncdfhf2_raw(0x7ff8000000000000, 0x7e00); // qNaN
+    test__truncdfhf2_raw(0x7ff0000000008000, 0x7e00); // NaN
+
+    test__truncdfhf2_raw(0x7ff0000000000000, 0x7c00); //inf
+    test__truncdfhf2_raw(0xfff0000000000000, 0xfc00); // -inf
+
+    test__truncdfhf2(0.0, 0x0); // zero
+    test__truncdfhf2_raw(0x80000000 << 32, 0x8000); // -zero
+
+    test__truncdfhf2(3.1415926535, 0x4248);
+    test__truncdfhf2(-3.1415926535, 0xc248);
+
+    test__truncdfhf2(0x1.987124876876324p+1000, 0x7c00);
+    test__truncdfhf2(0x1.987124876876324p+12, 0x6e62);
+    test__truncdfhf2(0x1.0p+0, 0x3c00);
+    test__truncdfhf2(0x1.0p-14, 0x0400);
+
+    // denormal
+    test__truncdfhf2(0x1.0p-20, 0x0010);
+    test__truncdfhf2(0x1.0p-24, 0x0001);
+    test__truncdfhf2(-0x1.0p-24, 0x8001);
+    test__truncdfhf2(0x1.5p-25, 0x0001);
+
+    // and back to zero
+    test__truncdfhf2(0x1.0p-25, 0x0000);
+    test__truncdfhf2(-0x1.0p-25, 0x8000);
+
+    // max (precise)
+    test__truncdfhf2(65504.0, 0x7bff);
+
+    // max (rounded)
+    test__truncdfhf2(65519.0, 0x7bff);
+
+    // max (to +inf)
+    test__truncdfhf2(65520.0, 0x7c00);
+    test__truncdfhf2(-65520.0, 0xfc00);
+    test__truncdfhf2(65536.0, 0x7c00);
+}
+
 const __trunctfsf2 = @import("truncXfYf2.zig").__trunctfsf2;
 
 fn test__trunctfsf2(a: f128, expected: u32) void {

@@ -608,6 +608,7 @@ set(ZIG_STD_FILES
     "special/bootstrap_lib.zig"
     "special/build_runner.zig"
     "special/builtin.zig"
+    "special/compiler_rt/addXf3.zig"
     "special/compiler_rt/aulldiv.zig"
     "special/compiler_rt/aullrem.zig"
     "special/compiler_rt/comparetf2.zig"