[compiler-rt][aarch64] New tests for 128-bit floating-point builtins, fixes of tests and __fixuint

[sdmitrouk]

Summary

The following tests for 128-bit floating-point type behaved in a strange way, thought it were bugs, but seem to be mistakes in tests:

• fixtfsi test checked for 0x80000001 as a value returned for number less than can be represented, while LONG_MIN should be returned on saturation;
• fixunstfdi wasn't enabled for AArch64, only for PPC, but there is nothing PPC specific in that test;
• multf3 tried to underflow multiplication by producing result with 16383 exponent, while there are still 112 bits of fraction plus implicit bit, so resultant exponent should be 16497.

Tests for some other builtins didn't exist:

• fixtfdi
• fixtfti
• fixunstfti

They were made by copying similar files and adjusting for wider types and adding/removing some reasonable/extra checks.

Also __fixuint seems to have off by one error, updated tests to catch this case.

[zatrazz]

test/builtins/Unit/fixunstfti_test.c

88 ↗

(On Diff #38767)

Shouldn't it be (0xFFFFFF0000000000, 0x0)?

[sdmitrouk]

Fixed off by one error in __fixuint and updated eight tests to check this case (expected 1...1 n times on input 2^n where n is width of output type in bits).

[sdmitrouk]

Somehow missed the inline comment.

test/builtins/Unit/fixunstfti_test.c

89 ↗

(On Diff #39183)

Actually it should be (0xffffffffffffffffLL, 0xffffffffffffffffLL) because input is larger than 2^128. __fixuint seems to have off by one error when checking for too large exponent (used > instead of >=), updated revision to address this. Thanks!

[zatrazz]

test/builtins/Unit/fixunstfti_test.c

89 ↗

(On Diff #39183)

Unless I am missing something here, the code:

void
func (void)
{
  mpfr_t number;
  mpfr_init2 (number, PRECISION);
  mpfr_set_ld (number, 0x1.FFFFFEp+127, MPFR_RNDN);
  mpfr_printf ("%Rf\n", number);

  mpz_t integer;
  mpz_init2 (integer, PRECISION);
  mpfr_get_z (integer, number, MPFR_RNDN);

  mpfr_printf ("float:   %Rf\n", number);
  mpfr_printf ("integer: %033ZX\n", integer);
}

Prints on a aarch64 machine:

float: 340282346638528859811704183484516925440.000000
integer: 0FFFFFF00000000000000000000000000

And the maximum value of an uint128_t is:

340282366920938463463374607431768211455L

So the value is still lower than 128 *unsigned* bits.

[sdmitrouk]

test/builtins/Unit/fixunstfti_test.c

89 ↗

(On Diff #39183)

I'm not sure I follow, your example confirms the line below:

if (test__fixunstfti(0x1.FFFFFEp+127, make_ti(0xffffff0000000000LL, 0x0)))

but your first comment was about this line:

if (test__fixunstfti(0x1.FFFFFEp+128, make_ti(0xfffffe0000000000LL, 0x0)))

which is 1FFFFFE00000000000000000000000000 (33 nibbles) in integer form. The most significant bit used to be truncated (same happened for unsigned si and di), which is fixed by second revision.

[zatrazz]

test/builtins/Unit/fixunstfti_test.c

89 ↗

(On Diff #39183)

Ah right, my confusion here. LGTM now.

compiler-rt/trunk/lib/builtins/fp_fixuint_impl.inc

static __inline fixuint_t __fixuint(fp_t a) {
     const int exponent = (aAbs >> significandBits) - exponentBias;
     const rep_t significand = (aAbs & significandMask) | implicitBit;
 
     // If either the value or the exponent is negative, the result is zero.
     if (sign == -1 || exponent < 0)
         return 0;
 
     // If the value is too large for the integer type, saturate.
-    if ((unsigned)exponent > sizeof(fixuint_t) * CHAR_BIT)
+    if ((unsigned)exponent >= sizeof(fixuint_t) * CHAR_BIT)
         return ~(fixuint_t)0;
 
     // If 0 <= exponent < significandBits, right shift to get the result.
     // Otherwise, shift left.
     if (exponent < significandBits)
         return significand >> (significandBits - exponent);
     else
         return (fixuint_t)significand << (exponent - significandBits);
 }

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

+//===--------------- fixtfdi_test.c - Test __fixtfdi ----------------------===//
+//
+//                     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 __fixtfdi for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+di_int __fixtfdi(long double a);
+
+int test__fixtfdi(long double a, di_int expected)
+{
+    di_int x = __fixtfdi(a);
+    int ret = (x != expected);
+
+    if (ret)
+    {
+        printf("error in test__fixtfdi(%.20Lf) = %llX, "
+               "expected %llX\n", a, x, expected);
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    if (test__fixtfdi(makeInf128(), 0x7fffffffffffffffLL))
+        return 1;
+    if (test__fixtfdi(0, 0x0))
+        return 1;
+    if (test__fixtfdi(0x1.23456789abcdefp+5L, 0x24LL))
+        return 1;
+    if (test__fixtfdi(0x1.23456789abcdefp-3L, 0x0LL))
+        return 1;
+    if (test__fixtfdi(0x1.23456789abcdef12345678p+20L, 0x123456LL))
+        return 1;
+    if (test__fixtfdi(0x1.23456789abcdef12345678p+40L, 0x123456789abLL))
+        return 1;
+    if (test__fixtfdi(0x1.23456789abcdef12345678p+60L, 0x123456789abcdef1LL))
+        return 1;
+    if (test__fixtfdi(0x1.23456789abcdefp+256L, 0x7fffffffffffffffLL))
+        return 1;
+    if (test__fixtfdi(-0x1.23456789abcdefp+20L, 0xffffffffffedcbaaLL))
+        return 1;
+    if (test__fixtfdi(-0x1.23456789abcdefp+40L, 0xfffffedcba987655LL))
+        return 1;
+    if (test__fixtfdi(-0x1.23456789abcdefp+256L, 0x8000000000000000LL))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}

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

#if __LDBL_MANT_DIG__ == 113
     if (test__fixtfsi(0x1.23456789abcdefp+20, 0x123456))
         return 1;
     if (test__fixtfsi(0x1.23456789abcdefp+40, 0x7fffffff))
         return 1;
     if (test__fixtfsi(0x1.23456789abcdefp+256, 0x7fffffff))
         return 1;
     if (test__fixtfsi(-0x1.23456789abcdefp+20, 0xffedcbaa))
         return 1;
-    if (test__fixtfsi(-0x1.23456789abcdefp+40, 0x80000001))
+    if (test__fixtfsi(-0x1.23456789abcdefp+40, 0x80000000))
         return 1;
 
 #else
     printf("skipped\n");
 
 #endif
     return 0;
 }

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

+//===--------------- fixtfti_test.c - Test __fixtfti ----------------------===//
+//
+//                     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 __fixtfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include "int_lib.h"
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+
+ti_int __fixtfti(long double a);
+
+int test__fixtfti(long double a, ti_int expected)
+{
+    ti_int x = __fixtfti(a);
+    int ret = (x != expected);
+
+    if (ret)
+    {
+        twords xt;
+        xt.all = x;
+
+        twords expectedt;
+        expectedt.all = expected;
+
+        printf("error in test__fixtfti(%.20Lf) = 0x%.16llX%.16llX, "
+               "expected 0x%.16llX%.16llX\n",
+               a, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low);
+    }
+    return ret;
+}
+
+char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    if (test__fixtfti(makeInf128(), make_ti(0x7fffffffffffffffLL,
+                                            0xffffffffffffffffLL)))
+        return 1;
+    if (test__fixtfti(0, make_ti(0x0LL, 0x0LL)))
+        return 1;
+    if (test__fixtfti(0x1.23456789abcdefp+5L, make_ti(0x0LL, 0x24LL)))
+        return 1;
+    if (test__fixtfti(0x1.23456789abcdefp-3L, make_ti(0x0LL, 0x0LL)))
+        return 1;
+    if (test__fixtfti(0x1.23456789abcdef12345678p+20L,
+                      make_ti(0x0LL, 0x123456LL)))
+        return 1;
+    if (test__fixtfti(0x1.23456789abcdef123456789abcdep+112L,
+                      make_ti(0x123456789abcdLL, 0xef123456789abcdeLL)))
+        return 1;
+    if (test__fixtfti(-0x1.23456789abcdef123456789abcdep+112L,
+                      make_ti(0xFFFEDCBA98765432LL, 0x10EDCBA987654322LL)))
+        return 1;
+    if (test__fixtfti(0x1.23456789abcdefp+256L, make_ti(0x7fffffffffffffffLL,
+                                                        0xffffffffffffffffLL)))
+        return 1;
+    if (test__fixtfti(-0x1.23456789abcdefp+20L, make_ti(0xffffffffffffffffLL,
+                                                        0xffffffffffedcbaaLL)))
+        return 1;
+    if (test__fixtfti(-0x1.23456789abcdefp+256L, make_ti(0x8000000000000000LL,
+                                                         0x0)))
+        return 1;
+
+#else
+    printf("skipped\n");
+
+#endif
+    return 0;
+}

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

if (test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800LL))
         return 1;
     if (test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000LL))
         return 1;
     if (test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00LL))
         return 1;
     if (test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800LL))
         return 1;
 
+    if (test__fixunsdfdi(0x1.p+64, 0xFFFFFFFFFFFFFFFFLL))
+        return 1;
+
 #if !TARGET_LIBGCC
     if (test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0))
         return 1;
     if (test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0))
         return 1;
 #endif
 
    return 0;
 }

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

#if !TARGET_LIBGCC
     if (test__fixunsdfsi(-2.0, 0))
         return 1;
     if (test__fixunsdfsi(-2.01, 0))
         return 1;
 #endif
 
     if (test__fixunsdfsi(0x1.000000p+31, 0x80000000))
         return 1;
+    if (test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF))
+        return 1;
     if (test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00))
         return 1;
     if (test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80))
         return 1;
     if (test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00))
         return 1;
 
 #if !TARGET_LIBGCC

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

#endif
     if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, make_ti(0xFFFFFFFFFFFFF800LL, 0)))
         return 1;
     if (test__fixunsdfti(0x1.0000000000000p+127, make_ti(0x8000000000000000LL, 0)))
         return 1;
     if (test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, make_ti(0x7FFFFFFFFFFFFC00LL, 0)))
         return 1;
     if (test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, make_ti(0x7FFFFFFFFFFFF800LL, 0)))
         return 1;
+    if (test__fixunsdfti(0x1.0000000000000p+128, make_ti(0xFFFFFFFFFFFFFFFFLL,
+                                                         0xFFFFFFFFFFFFFFFFLL)))
+        return 1;
 
 #if !TARGET_LIBGCC
     if (test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0))
         return 1;
     if (test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0))
         return 1;
 #endif
 
 #endif
    return 0;
 }

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

#if !TARGET_LIBGCC
     if (test__fixunssfdi(-2.01F, 0))
         return 1;
 #endif
 
     if (test__fixunssfdi(0x1.FFFFFEp+63F, 0xFFFFFF0000000000LL))
         return 1;
     if (test__fixunssfdi(0x1.000000p+63F, 0x8000000000000000LL))
         return 1;
+    if (test__fixunssfdi(0x1.000000p+64F, 0xFFFFFFFFFFFFFFFFLL))
+        return 1;
     if (test__fixunssfdi(0x1.FFFFFEp+62F, 0x7FFFFF8000000000LL))
         return 1;
     if (test__fixunssfdi(0x1.FFFFFCp+62F, 0x7FFFFF0000000000LL))
         return 1;
 
 #if !TARGET_LIBGCC
     if (test__fixunssfdi(-0x1.FFFFFEp+62F, 0x0000000000000000LL))
         return 1;
     if (test__fixunssfdi(-0x1.FFFFFCp+62F, 0x0000000000000000LL))
         return 1;
 #endif
 
    return 0;
 }

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

#if !TARGET_LIBGCC
     if (test__fixunssfsi(-2.0F, 0))
         return 1;
     if (test__fixunssfsi(-2.01F, 0))
         return 1;
 #endif
 
     if (test__fixunssfsi(0x1.000000p+31F, 0x80000000))
         return 1;
+    if (test__fixunssfsi(0x1.000000p+32F, 0xFFFFFFFF))
+        return 1;
     if (test__fixunssfsi(0x1.FFFFFEp+31F, 0xFFFFFF00))
         return 1;
     if (test__fixunssfsi(0x1.FFFFFEp+30F, 0x7FFFFF80))
         return 1;
     if (test__fixunssfsi(0x1.FFFFFCp+30F, 0x7FFFFF00))
         return 1;
 
 #if !TARGET_LIBGCC
     if (test__fixunssfsi(-0x1.FFFFFEp+30F, 0))
         return 1;
     if (test__fixunssfsi(-0x1.FFFFFCp+30F, 0))
         return 1;
 #endif
 
    return 0;
 }

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

 //===-- fixunstfdi_test.c - Test __fixunstfdi -----------------------------===//
 //
 //                     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 __fixunstfdi for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdio.h>
 
-#if _ARCH_PPC
+#if _ARCH_PPC || __aarch64__
 
 #include "int_lib.h"
 
 // Returns: convert a to a unsigned long long, rounding toward zero.
 //          Negative values all become zero.
 
-// Assumption: long double is a ppc 128 bit floating point type
+// Assumption: long double is a 128 bit floating point type
 //             du_int is a 64 bit integral type
 //             value in long double is representable in du_int or is negative 
 //                 (no range checking performed)
 
 COMPILER_RT_ABI du_int __fixunstfdi(long double a);
 
 int test__fixunstfdi(long double a, du_int expected)
 {
     du_int x = __fixunstfdi(a);
     if (x != expected)
         printf("error in __fixunstfdi(%LA) = %llX, expected %llX\n",
                a, x, expected);
     return x != expected;
 }
 
 char assumption_1[sizeof(du_int) == 2*sizeof(su_int)] = {0};
 char assumption_2[sizeof(du_int)*CHAR_BIT == 64] = {0};
 char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
 
 #endif
 
 int main()
 {
-#if _ARCH_PPC
+#if _ARCH_PPC || __aarch64__
     if (test__fixunstfdi(0.0, 0))
         return 1;
 
     if (test__fixunstfdi(0.5, 0))
         return 1;
     if (test__fixunstfdi(0.99, 0))
         return 1;
     if (test__fixunstfdi(1.0, 1))
#if _ARCH_PPC || __aarch64__
     if (test__fixunstfdi(0x1.0000000000000002p+63L, 0x8000000000000001LL))
         return 1;
     if (test__fixunstfdi(0x1.0000000000000000p+63L, 0x8000000000000000LL))
         return 1;
     if (test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62L, 0x7FFFFFFFFFFFFFFFLL))
         return 1;
     if (test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62L, 0x7FFFFFFFFFFFFFFELL))
         return 1;
+    if (test__fixunstfdi(0x1.p+64L, 0xFFFFFFFFFFFFFFFFLL))
+        return 1;
 
     if (test__fixunstfdi(-0x1.0000000000000000p+63L, 0))
         return 1;
     if (test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62L, 0))
         return 1;
     if (test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62L, 0))
         return 1;
 
 #else
     printf("skipped\n");
 #endif
    return 0;
 }

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

if (test__fixunstfsi(0x1.23456789abcdefp+20, UINT32_C(0x123456)))
         return 1;
     if (test__fixunstfsi(0x1.23456789abcdefp+40, UINT32_C(0xffffffff)))
         return 1;
     if (test__fixunstfsi(0x1.23456789abcdefp+256, UINT32_C(0xffffffff)))
         return 1;
     if (test__fixunstfsi(-0x1.23456789abcdefp+3, UINT32_C(0x0)))
         return 1;
 
+    if (test__fixunstfsi(0x1.p+32, 0xFFFFFFFFLL))
+        return 1;
+
 #else
     printf("skipped\n");
 
 #endif
     return 0;
 }

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

+//===-- fixunstfti_test.c - Test __fixunstfti -----------------------------===//
+//
+//                     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 __fixunstfti for the compiler_rt library.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+
+#if __LDBL_MANT_DIG__ == 113
+
+#include "fp_test.h"
+#include "int_lib.h"
+
+// Returns: convert a to a unsigned long long, rounding toward zero.
+//          Negative values all become zero.
+
+// Assumption: long double is a 128 bit floating point type
+//             tu_int is a 128 bit integral type
+//             value in long double is representable in tu_int or is negative 
+//                 (no range checking performed)
+
+COMPILER_RT_ABI tu_int __fixunstfti(long double a);
+
+int test__fixunstfti(long double a, tu_int expected)
+{
+    tu_int x = __fixunstfti(a);
+    if (x != expected)
+    {
+        twords xt;
+        xt.all = x;
+
+        twords expectedt;
+        expectedt.all = expected;
+
+        printf("error in __fixunstfti(%.20Lf) = 0x%.16llX%.16llX, "
+               "expected 0x%.16llX%.16llX\n",
+               a, xt.s.high, xt.s.low, expectedt.s.high, expectedt.s.low);
+    }
+    return x != expected;
+}
+
+char assumption_1[sizeof(tu_int) == 4*sizeof(su_int)] = {0};
+char assumption_2[sizeof(tu_int)*CHAR_BIT == 128] = {0};
+char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
+
+#endif
+
+int main()
+{
+#if __LDBL_MANT_DIG__ == 113
+    if (test__fixunstfti(makeInf128(), make_ti(0xffffffffffffffffLL,
+                                               0xffffffffffffffffLL)))
+        return 1;
+
+    if (test__fixunstfti(0.0, 0))
+        return 1;
+
+    if (test__fixunstfti(0.5, 0))
+        return 1;
+    if (test__fixunstfti(0.99, 0))
+        return 1;
+    if (test__fixunstfti(1.0, 1))
+        return 1;
+    if (test__fixunstfti(1.5, 1))
+        return 1;
+    if (test__fixunstfti(1.99, 1))
+        return 1;
+    if (test__fixunstfti(2.0, 2))
+        return 1;
+    if (test__fixunstfti(2.01, 2))
+        return 1;
+    if (test__fixunstfti(-0.01, 0))
+        return 1;
+    if (test__fixunstfti(-0.99, 0))
+        return 1;
+
+    if (test__fixunstfti(0x1.p+128, make_ti(0xffffffffffffffffLL,
+                                            0xffffffffffffffffLL)))
+        return 1;
+
+    if (test__fixunstfti(0x1.FFFFFEp+126, make_ti(0x7fffff8000000000LL, 0x0)))
+        return 1;
+    if (test__fixunstfti(0x1.FFFFFEp+127, make_ti(0xffffff0000000000LL, 0x0)))
+        return 1;
+    if (test__fixunstfti(0x1.FFFFFEp+128, make_ti(0xffffffffffffffffLL,
+                                                  0xffffffffffffffffLL)))
+        return 1;
+    if (test__fixunstfti(0x1.FFFFFEp+129, make_ti(0xffffffffffffffffLL,
+                                                  0xffffffffffffffffLL)))
+        return 1;
+
+#else
+    printf("skipped\n");
+#endif
+   return 0;
+}

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

if (test__multf3(0x1.234425696abcad34a35eeffefdcbap+456L,
         return 1;
     if (test__multf3(0x1.4356473c82a9fabf2d22ace345defp-234L,
                      0x1.eda98765476743ab21da23d45678fp-455L,
                      UINT64_C(0x3d4f37c1a3137cae),
                      UINT64_C(0xfc6807048bc2836a)))
         return 1;
     // underflow
     if (test__multf3(0x1.23456734245345p-10000L,
-                     0x1.edcba524498724p-6383L,
+                     0x1.edcba524498724p-6497L,
                      UINT64_C(0x0),
                      UINT64_C(0x0)))
         return 1;
 
 #else
     printf("skipped\n");
 
 #endif
     return 0;
 }