[COMPILER-RT] Implement long double comparison functions

[koviankevin]

Summary

The following functions are implemented:
letf2, gttf2, netf2, getf2, eqtf2, lttf2, __unordtf2

[koviankevin]

Since we use __uint128_t type, which is undefined in 32-bit machine toolchain, we enable these functions only when using 64-bit machine.

[joerg]

That would be a problem as i.e. SPARC uses soft-float for long double.

[koviankevin]

We assume sizeof(long double)=16 (IEEE-754 128-bit format)
SIZEOF_LONG_DOUBLE=8 in SPARC and SIZEOF_LONG_DOUBLE=16 in SPARC64
SIZEOF_INT128 =16 is also defined in SPARC64, so these funcitons can be compiled in SPARC64

Could you specify the situation about when the problem occurs? Thanks

[joerg]

OK, forget my comment. I misremembered the sate of 32bit SPARC. Ideally, __uint128_t would be supported on all targets, but that's a fundamentally different question.

[koviankevin]

Use CRT_HAS_128BIT

[joerg]

Can you add a define similar to CRT_HAS_128BIT to flag whether a platform should use this code? x86_64 uses 80bit long double, so it doesn't match. Checking LDBL_MANT_DIG == 113 or so would be a good first approximiation.

[koviankevin]

introduce CRT_LDBL_128BIT

I will upload patches for other functions if my modifications are what you want, thanks.

[joerg]

Missing test case, otherwise LGTM.

[koviankevin]

add test

[koviankevin]

modify by gribozavr's comment and use COMPILER_RT_ABI

[gribozavr]

Hi GuanHong Liu,

Thank you for working on this!

This set of patches looks good, but because I don't contribute regularly to compiler-rt, I will defer to other reviewers to stamp the final LGTM.

Dmitri

lib/builtins/comparetf2.c

70–76 ↗

(On Diff #7674)

Could you sink the comment into the else {} block? It is not immediately obvious that the 'if' statement continues there.

[koviankevin]

sink the comment

[gribozavr]

Hi GuanHong Liu,

I don't know if you noticed, but Joerg signed off on this patch, so please commit!

Dmitri

[koviankevin]

Hi Dmitri

I don't have commit authority, could you help me to commit them? thanks.

GuanHong

[gribozavr]

Joerg,

Since this patch depends on D2796, which is owned by you, I will defer to you on this patch.

Dmitri

[koviankevin]

I want to ask that whether our patches (including D2796, which is owned by Joerg now) can be commited?

Thanks,
GuanHong

[joerg]

Sorry, I thought I had it committed already. No objections from me, but I can't test this.

[koviankevin]

Since I don't have commit authority, can you help me to commit other patches for quad precision? Thanks!
(i.e, D2797 to D2800, D2802 to D2805)

[joerg]

Closed by commit rL205312 (authored by @joerg).

[koviankevin]

Hi Joerg

Can I commit D2798, D2799, D2800, D2802, D2803, D2804 and D2805 ?
These patches are also implemented for IEEE quad precision.

Thanks,
GuanHong

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

+//===-- lib/comparetf2.c - Quad-precision comparisons -------------*- 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 the following soft-float comparison routines:
+//
+//   __eqtf2   __getf2   __unordtf2
+//   __letf2   __gttf2
+//   __lttf2
+//   __netf2
+//
+// The semantics of the routines grouped in each column are identical, so there
+// is a single implementation for each, and wrappers to provide the other names.
+//
+// The main routines behave as follows:
+//
+//   __letf2(a,b) returns -1 if a < b
+//                         0 if a == b
+//                         1 if a > b
+//                         1 if either a or b is NaN
+//
+//   __getf2(a,b) returns -1 if a < b
+//                         0 if a == b
+//                         1 if a > b
+//                        -1 if either a or b is NaN
+//
+//   __unordtf2(a,b) returns 0 if both a and b are numbers
+//                           1 if either a or b is NaN
+//
+// Note that __letf2( ) and __getf2( ) are identical except in their handling of
+// NaN values.
+//
+//===----------------------------------------------------------------------===//
+
+#define QUAD_PRECISION
+#include "fp_lib.h"
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+enum LE_RESULT {
+    LE_LESS      = -1,
+    LE_EQUAL     =  0,
+    LE_GREATER   =  1,
+    LE_UNORDERED =  1
+};
+
+COMPILER_RT_ABI enum LE_RESULT __letf2(fp_t a, fp_t b) {
+
+    const srep_t aInt = toRep(a);
+    const srep_t bInt = toRep(b);
+    const rep_t aAbs = aInt & absMask;
+    const rep_t bAbs = bInt & absMask;
+
+    // If either a or b is NaN, they are unordered.
+    if (aAbs > infRep || bAbs > infRep) return LE_UNORDERED;
+
+    // If a and b are both zeros, they are equal.
+    if ((aAbs | bAbs) == 0) return LE_EQUAL;
+
+    // If at least one of a and b is positive, we get the same result comparing
+    // a and b as signed integers as we would with a floating-point compare.
+    if ((aInt & bInt) >= 0) {
+        if (aInt < bInt) return LE_LESS;
+        else if (aInt == bInt) return LE_EQUAL;
+        else return LE_GREATER;
+    }
+    else {
+        // Otherwise, both are negative, so we need to flip the sense of the
+        // comparison to get the correct result.  (This assumes a twos- or ones-
+        // complement integer representation; if integers are represented in a
+        // sign-magnitude representation, then this flip is incorrect).
+        if (aInt > bInt) return LE_LESS;
+        else if (aInt == bInt) return LE_EQUAL;
+        else return LE_GREATER;
+    }
+}
+
+enum GE_RESULT {
+    GE_LESS      = -1,
+    GE_EQUAL     =  0,
+    GE_GREATER   =  1,
+    GE_UNORDERED = -1   // Note: different from LE_UNORDERED
+};
+
+COMPILER_RT_ABI enum GE_RESULT __getf2(fp_t a, fp_t b) {
+
+    const srep_t aInt = toRep(a);
+    const srep_t bInt = toRep(b);
+    const rep_t aAbs = aInt & absMask;
+    const rep_t bAbs = bInt & absMask;
+
+    if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED;
+    if ((aAbs | bAbs) == 0) return GE_EQUAL;
+    if ((aInt & bInt) >= 0) {
+        if (aInt < bInt) return GE_LESS;
+        else if (aInt == bInt) return GE_EQUAL;
+        else return GE_GREATER;
+    } else {
+        if (aInt > bInt) return GE_LESS;
+        else if (aInt == bInt) return GE_EQUAL;
+        else return GE_GREATER;
+    }
+}
+
+COMPILER_RT_ABI int __unordtf2(fp_t a, fp_t b) {
+    const rep_t aAbs = toRep(a) & absMask;
+    const rep_t bAbs = toRep(b) & absMask;
+    return aAbs > infRep || bAbs > infRep;
+}
+
+// The following are alternative names for the preceeding routines.
+
+COMPILER_RT_ABI enum LE_RESULT __eqtf2(fp_t a, fp_t b) {
+    return __letf2(a, b);
+}
+
+COMPILER_RT_ABI enum LE_RESULT __lttf2(fp_t a, fp_t b) {
+    return __letf2(a, b);
+}
+
+COMPILER_RT_ABI enum LE_RESULT __netf2(fp_t a, fp_t b) {
+    return __letf2(a, b);
+}
+
+COMPILER_RT_ABI enum GE_RESULT __gttf2(fp_t a, fp_t b) {
+    return __getf2(a, b);
+}
+
+#endif

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

+//===------------ eqtf2_test.c - Test __eqtf2------------------------------===//
+//
+//                     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 __eqtf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __eqtf2(long double a, long double b);
+
+int test__eqtf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __eqtf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__eqtf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__eqtf2(makeQNaN128(),
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // <
+    // exp
+    if (test__eqtf2(0x1.234567890abcdef1234567890abcp-3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // mantissa
+    if (test__eqtf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.334567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // sign
+    if (test__eqtf2(-0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // ==
+    if (test__eqtf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    EQUAL_0))
+        return 1;
+    // >
+    // exp
+    if (test__eqtf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp-3L,
+                    NEQUAL_0))
+        return 1;
+    // mantissa
+    if (test__eqtf2(0x1.334567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // sign
+    if (test__eqtf2(0x1.234567890abcdef1234567890abcp+3L,
+                    -0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}

compiler-rt/trunk/test/builtins/Unit/fp_test.h

+//===--------------------------- fp_test.h - ------------------------------===//
+//
+//                     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 defines shared functions for the test.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+
+enum EXPECTED_RESULT {
+    LESS_0, LESS_EQUAL_0, EQUAL_0, GREATER_0, GREATER_EQUAL_0, NEQUAL_0
+};
+
+static inline float fromRep32(uint32_t x)
+{
+    float ret;
+    memcpy(&ret, &x, 4);
+    return ret;
+}
+
+static inline double fromRep64(uint64_t x)
+{
+    double ret;
+    memcpy(&ret, &x, 8);
+    return ret;
+}
+
+static inline long double fromRep128(uint64_t hi, uint64_t lo)
+{
+    __uint128_t x = ((__uint128_t)hi << 64) + lo;
+    long double ret;
+    memcpy(&ret, &x, 16);
+    return ret;
+}
+
+static inline uint32_t toRep32(float x)
+{
+    uint32_t ret;
+    memcpy(&ret, &x, 4);
+    return ret;
+}
+
+static inline uint64_t toRep64(double x)
+{
+    uint64_t ret;
+    memcpy(&ret, &x, 8);
+    return ret;
+}
+
+static inline __uint128_t toRep128(long double x)
+{
+    __uint128_t ret;
+    memcpy(&ret, &x, 16);
+    return ret;
+}
+
+static inline int compareResultF(float result,
+                                 uint32_t expected)
+{
+    uint32_t rep = toRep32(result);
+
+    if (rep == expected){
+        return 0;
+    }
+    // test other posible NaN representation(signal NaN)
+    else if (expected == 0x7fc00000U){
+        if ((rep & 0x7f800000U) == 0x7f800000U &&
+            (rep & 0x7fffffU) > 0){
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static inline int compareResultD(double result,
+                                 uint64_t expected)
+{
+    uint64_t rep = toRep64(result);
+
+    if (rep == expected){
+        return 0;
+    }
+    // test other posible NaN representation(signal NaN)
+    else if (expected == 0x7ff8000000000000UL){
+        if ((rep & 0x7ff0000000000000UL) == 0x7ff0000000000000UL &&
+            (rep & 0xfffffffffffffUL) > 0){
+            return 0;
+        }
+    }
+    return 1;
+}
+
+// return 0 if equal
+// use two 64-bit integers intead of one 128-bit integer
+// because 128-bit integer constant can't be assigned directly
+static inline int compareResultLD(long double result,
+                                  uint64_t expectedHi,
+                                  uint64_t expectedLo)
+{
+    __uint128_t rep = toRep128(result);
+    uint64_t hi = rep >> 64;
+    uint64_t lo = rep;
+
+    if (hi == expectedHi && lo == expectedLo){
+        return 0;
+    }
+    // test other posible NaN representation(signal NaN)
+    else if (expectedHi == 0x7fff800000000000UL && expectedLo == 0x0UL){
+        if ((hi & 0x7fff000000000000UL) == 0x7fff000000000000UL &&
+            ((hi & 0xffffffffffffUL) > 0 || lo > 0)){
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static inline int compareResultCMP(int result,
+                                   enum EXPECTED_RESULT expected)
+{
+    switch(expected){
+        case LESS_0:
+            if (result < 0)
+                return 0;
+            break;
+        case LESS_EQUAL_0:
+            if (result <= 0)
+                return 0;
+            break;
+        case EQUAL_0:
+            if (result == 0)
+                return 0;
+            break;
+        case NEQUAL_0:
+            if (result != 0)
+                return 0;
+            break;
+        case GREATER_EQUAL_0:
+            if (result >= 0)
+                return 0;
+            break;
+        case GREATER_0:
+            if (result > 0)
+                return 0;
+            break;
+        default:
+            return 1;
+    }
+    return 1;
+}
+
+static inline char *expectedStr(enum EXPECTED_RESULT expected)
+{
+    switch(expected){
+        case LESS_0:
+            return "<0";
+        case LESS_EQUAL_0:
+            return "<=0";
+        case EQUAL_0:
+            return "=0";
+        case NEQUAL_0:
+            return "!=0";
+        case GREATER_EQUAL_0:
+            return ">=0";
+        case GREATER_0:
+            return ">0";
+        default:
+            return "";
+    }
+    return "";
+}
+
+static inline float makeQNaN32()
+{
+    return fromRep32(0x7fc00000U);
+}
+
+static inline double makeQNaN64()
+{
+    return fromRep64(0x7ff8000000000000UL);
+}
+
+static inline long double makeQNaN128()
+{
+    return fromRep128(0x7fff800000000000UL, 0x0UL);
+}
+
+static inline float makeNaN32(uint32_t rand)
+{
+    return fromRep32(0x7f800000U | (rand & 0x7fffffU));
+}
+
+static inline double makeNaN64(uint64_t rand)
+{
+    return fromRep64(0x7ff0000000000000UL | (rand & 0xfffffffffffffUL));
+}
+
+static inline long double makeNaN128(uint64_t rand)
+{
+    return fromRep128(0x7fff000000000000UL | (rand & 0xffffffffffffUL), 0x0UL);
+}
+
+static inline float makeInf32()
+{
+    return fromRep32(0x7f800000U);
+}
+
+static inline double makeInf64()
+{
+    return fromRep64(0x7ff0000000000000UL);
+}
+
+static inline long double makeInf128()
+{
+    return fromRep128(0x7fff000000000000UL, 0x0UL);
+}

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

+//===------------ getf2_test.c - Test __getf2------------------------------===//
+//
+//                     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 __getf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __getf2(long double a, long double b);
+
+int test__getf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __getf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__getf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__getf2(makeQNaN128(),
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // <
+    // exp
+    if (test__getf2(0x1.234567890abcdef1234567890abcp-3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // mantissa
+    if (test__getf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.334567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // sign
+    if (test__getf2(-0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // ==
+    if (test__getf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // >
+    // exp
+    if (test__getf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp-3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // mantissa
+    if (test__getf2(0x1.334567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // sign
+    if (test__getf2(0x1.234567890abcdef1234567890abcp+3L,
+                    -0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}

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

+//===------------ gttf2_test.c - Test __gttf2------------------------------===//
+//
+//                     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 __gttf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __gttf2(long double a, long double b);
+
+int test__gttf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __gttf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__gttf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__gttf2(makeQNaN128(),
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // <
+    // exp
+    if (test__gttf2(0x1.234567890abcdef1234567890abcp-3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // mantissa
+    if (test__gttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.334567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // sign
+    if (test__gttf2(-0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // ==
+    if (test__gttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // >
+    // exp
+    if (test__gttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp-3L,
+                    GREATER_0))
+        return 1;
+    // mantissa
+    if (test__gttf2(0x1.334567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_0))
+        return 1;
+    // sign
+    if (test__gttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    -0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}

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

+//===------------ letf2_test.c - Test __letf2------------------------------===//
+//
+//                     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 __letf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __letf2(long double a, long double b);
+
+int test__letf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __letf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__letf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__letf2(makeQNaN128(),
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_0))
+        return 1;
+    // <
+    // exp
+    if (test__letf2(0x1.234567890abcdef1234567890abcp-3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // mantissa
+    if (test__letf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.334567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // sign
+    if (test__letf2(-0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // ==
+    if (test__letf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_EQUAL_0))
+        return 1;
+    // >
+    // exp
+    if (test__letf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp-3L,
+                    GREATER_0))
+        return 1;
+    // mantissa
+    if (test__letf2(0x1.334567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_0))
+        return 1;
+    // sign
+    if (test__letf2(0x1.234567890abcdef1234567890abcp+3L,
+                    -0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}

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

+//===------------ lttf2_test.c - Test __lttf2------------------------------===//
+//
+//                     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 __lttf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __lttf2(long double a, long double b);
+
+int test__lttf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __lttf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__lttf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__lttf2(makeQNaN128(),
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // <
+    // exp
+    if (test__lttf2(0x1.234567890abcdef1234567890abcp-3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // mantissa
+    if (test__lttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.334567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // sign
+    if (test__lttf2(-0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    LESS_0))
+        return 1;
+    // ==
+    if (test__lttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // >
+    // exp
+    if (test__lttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp-3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // mantissa
+    if (test__lttf2(0x1.334567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+    // sign
+    if (test__lttf2(0x1.234567890abcdef1234567890abcp+3L,
+                    -0x1.234567890abcdef1234567890abcp+3L,
+                    GREATER_EQUAL_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}

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

+//===------------ netf2_test.c - Test __netf2------------------------------===//
+//
+//                     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 __netf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __netf2(long double a, long double b);
+
+int test__netf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __netf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__netf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__netf2(makeQNaN128(),
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // <
+    // exp
+    if (test__netf2(0x1.234567890abcdef1234567890abcp-3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // mantissa
+    if (test__netf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.334567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // sign
+    if (test__netf2(-0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // ==
+    if (test__netf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    EQUAL_0))
+        return 1;
+    // >
+    // exp
+    if (test__netf2(0x1.234567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp-3L,
+                    NEQUAL_0))
+        return 1;
+    // mantissa
+    if (test__netf2(0x1.334567890abcdef1234567890abcp+3L,
+                    0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+    // sign
+    if (test__netf2(0x1.234567890abcdef1234567890abcp+3L,
+                    -0x1.234567890abcdef1234567890abcp+3L,
+                    NEQUAL_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}

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

+//===------------ unordtf2_test.c - Test __unordtf2------------------------===//
+//
+//                     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 __unordtf2 for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+int __unordtf2(long double a, long double b);
+
+int test__unordtf2(long double a, long double b, enum EXPECTED_RESULT expected)
+{
+    int x = __unordtf2(a, b);
+    int ret = compareResultCMP(x, expected);
+
+    if (ret){
+        printf("error in test__unordtf2(%.20Lf, %.20Lf) = %d, "
+               "expected %s\n", a, b, x, expectedStr(expected));
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LP64__ && __LDBL_MANT_DIG__ == 113
+    // NaN
+    if (test__unordtf2(makeQNaN128(),
+                       0x1.234567890abcdef1234567890abcp+3L,
+                       NEQUAL_0))
+        return 1;
+    // other
+    if (test__unordtf2(0x1.234567890abcdef1234567890abcp+3L,
+                       0x1.334567890abcdef1234567890abcp+3L,
+                       EQUAL_0))
+        return 1;
+    if (test__unordtf2(0x1.234567890abcdef1234567890abcp+3L,
+                       0x1.234567890abcdef1234567890abcp+3L,
+                       EQUAL_0))
+        return 1;
+    if (test__unordtf2(0x1.234567890abcdef1234567890abcp+3L,
+                       0x1.234567890abcdef1234567890abcp-3L,
+                       EQUAL_0))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}