[COMPILER-RT] Implement __addtf3 and __subtf3

[koviankevin]

Summary

Implement addtf3 and subtf3, which performs long double addition and substraction

[koviankevin]

add test

[gribozavr]

Please just hardcode the expected results and compare them by using *integer* operations (or other runtime functions, if we have suitable ones).

test/builtins/Unit/addtf3_test.c

43–44 ↗

(On Diff #7226)

It can be. Just compare the binary representation.

[koviankevin]

Use CRT_HAS_128BIT and apply comments by gribozavr

[koviankevin]

introduce CRT_LDBL_128BIT

[gribozavr]

test/builtins/Unit/addtf3_test.c

21–57 ↗

(On Diff #7329)

Please don't duplicate these helpers, factor them out to a shared header.

83 ↗

(On Diff #7329)

It would be easier to read these tests if in addition to fromRep() there were makePlusInf(), makeQNaN() etc.

test/builtins/Unit/subtf3_test.c

21–32 ↗

(On Diff #7329)

Even though there is no intention of breaking this union trick in Clang, it is undefined behavior. The correct way to do this is to use memcpy() to copy from long double* to __uint128_t*.

[koviankevin]

modify by gribozavr's comment and use COMPILER_RT_ABI

[joerg]

Sorry for leaving this hanging so long. Can you just commit the refactoring of addsf3.c / adddf3.c first without changing the comment style?
The file diff should be just the constant translation. Adding the tf frontend with the test cases is fine after that.

[koviankevin]

use UINT64_C and drop le64
adddf3.c and addsf3.c are refactored in D3885

[danalbert]

I'm unfamiliar with this review system... is this just waiting for someone to submit?

[joerg]

Closed by commit rL211312 (authored by @joerg).

compiler-rt/trunk/lib/builtins/CMakeLists.txt

 # This directory contains a large amount of C code which provides
 # generic implementations of the core runtime library along with optimized
 # architecture-specific code in various subdirectories.
 
 set(GENERIC_SOURCES
   absvdi2.c
   absvsi2.c
   absvti2.c
   adddf3.c
   addsf3.c
+  addtf3.c
   addvdi3.c
   addvsi3.c
   addvti3.c
   apple_versioning.c
   ashldi3.c
   ashlti3.c
   ashrdi3.c
   ashrti3.c
set(GENERIC_SOURCES
   divdf3.c
   divdi3.c
   divmoddi4.c
   divmodsi4.c
   divsc3.c
   divsf3.c
   divsi3.c
   divti3.c
+  divtf3.c
   divxc3.c
   enable_execute_stack.c
   eprintf.c
   extendsfdf2.c
   ffsdi2.c
   ffsti2.c
   fixdfdi.c
   fixdfsi.c
set(GENERIC_SOURCES
   powisf2.c
   powitf2.c
   powixf2.c
   subdf3.c
   subsf3.c
   subvdi3.c
   subvsi3.c
   subvti3.c
+  subtf3.c
   trampoline_setup.c
   truncdfsf2.c
   ucmpdi2.c
   ucmpti2.c
   udivdi3.c
   udivmoddi4.c
   udivmodsi4.c
   udivmodti4.c

compiler-rt/trunk/lib/builtins/addtf3.c

+//===-- lib/addtf3.c - Quad-precision addition --------------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements quad-precision soft-float addition with the IEEE-754
+// default rounding (to nearest, ties to even).
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#include "fp_add_impl.inc"
+
+COMPILER_RT_ABI long double __addtf3(long double a, long double b){
+    return __addXf3__(a, b);
+}
+
+#endif

compiler-rt/trunk/lib/builtins/subtf3.c

+//===-- lib/subtf3.c - Quad-precision subtraction -----------------*- C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements quad-precision soft-float subtraction with the
+// IEEE-754 default rounding (to nearest, ties to even).
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+COMPILER_RT_ABI fp_t __addtf3(fp_t a, fp_t b);
+
+// Subtraction; flip the sign bit of b and add.
+COMPILER_RT_ABI fp_t
+__subtf3(fp_t a, fp_t b) {
+    return __addtf3(a, fromRep(toRep(b) ^ signBit));
+}
+
+#endif

compiler-rt/trunk/test/builtins/Unit/addtf3_test.c

+//===--------------- addtf3_test.c - Test __addtf3 ------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __addtf3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+// Returns: a + b
+long double __addtf3(long double a, long double b);
+
+int test__addtf3(long double a, long double b,
+                 uint64_t expectedHi, uint64_t expectedLo)
+{
+    long double x = __addtf3(a, b);
+    int ret = compareResultLD(x, expectedHi, expectedLo);
+
+    if (ret){
+        printf("error in test__addtf3(%.20Lf, %.20Lf) = %.20Lf, "
+               "expected %.20Lf\n", a, b, x,
+               fromRep128(expectedHi, expectedLo));
+    }
+
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    // qNaN + any = qNaN
+    if (test__addtf3(makeQNaN128(),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // NaN + any = NaN
+    if (test__addtf3(makeNaN128(UINT64_C(0x800030000000)),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // inf + inf = inf
+    if (test__addtf3(makeInf128(),
+                     makeInf128(),
+                     UINT64_C(0x7fff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // inf + any = inf
+    if (test__addtf3(makeInf128(),
+                     0x1.2335653452436234723489432abcdefp+5L,
+                     UINT64_C(0x7fff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // any + any
+    if (test__addtf3(0x1.23456734245345543849abcdefp+5L,
+                     0x1.edcba52449872455634654321fp-1L,
+                     UINT64_C(0x40042afc95c8b579),
+                     UINT64_C(0x61e58dd6c51eb77c)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}

compiler-rt/trunk/test/builtins/Unit/subtf3_test.c

+//===--------------- subtf3_test.c - Test __subtf3 ------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file tests __subtf3 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+// Returns: a - b
+long double __subtf3(long double a, long double b);
+
+int test__subtf3(long double a, long double b,
+                 uint64_t expectedHi, uint64_t expectedLo)
+{
+    long double x = __subtf3(a, b);
+    int ret = compareResultLD(x, expectedHi, expectedLo);
+
+    if (ret){
+        printf("error in test__subtf3(%.20Lf, %.20Lf) = %.20Lf, "
+               "expected %.20Lf\n", a, b, x,
+               fromRep128(expectedHi, expectedLo));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    // qNaN - any = qNaN
+    if (test__subtf3(makeQNaN128(),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // NaN - any = NaN
+    if (test__subtf3(makeNaN128(UINT64_C(0x800030000000)),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff800000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // inf - any = inf
+    if (test__subtf3(makeInf128(),
+                     0x1.23456789abcdefp+5L,
+                     UINT64_C(0x7fff000000000000),
+                     UINT64_C(0x0)))
+        return 1;
+    // any - any
+    if (test__subtf3(0x1.234567829a3bcdef5678ade36734p+5L,
+                     0x1.ee9d7c52354a6936ab8d7654321fp-1L,
+                     UINT64_C(0x40041b8af1915166),
+                     UINT64_C(0xa44a7bca780a166c)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}