[Builtins] Fix test cases for xf/ti

[weimingz]

Summary

guard the tests that assume 80-bit floating point type representation with macro,
so targets that assumes __fp128 (IEEE quad-precision floating type) will be skipped.

This patch address PR 32260 (https://bugs.llvm.org//show_bug.cgi?id=32260)

[weimingz]

After we agree on the patch, __fixxfti() will be fixed similarly.

[joerg]

This doesn't make sense to me. XF *is* for modes with Intel extended precision. IEEE 128bit floats should be TF.

[weimingz]

I see. Should we mark the test as "Unsupported" for aarch64?

[joerg]

That would be perfectly reasonable. Some other places already tag it with HAS_80_BIT_LONG_DOUBLE, but I don't know what is responsible for setting that macro.

[weimingz]

I guess HAS_80_BIT_LONG_DOUBLE is passed as some build-time flags. I can't find it anywhere in the compiler-rt source tree that defines it.

I think we should guard it by checking "LDBL_MANT_DIG".

[joerg]

Please do not drop checks for CRT_HAS_128BIT -- the code requirse__ int128_t and doesn't work on platforms without.

[weimingz]

If the platform doesn't support it, the LDBL_MANT_DIG will be 53 (refer to clang/test/Preprocessor/init.c )

[efriedma]

If the platform doesn't support it, the LDBL_MANT_DIG will be 53

CRT_HAS_128BIT refers to support for 128-bit integers (__int128_t), which is unrelated to the size of long double.

[weimingz]

Change to HAS_80_BIT_LONG_DOUBLE just like other tests.
Also, if HAS_80_BIT_LONG_DOUBLE is not defined, we can set it if CRT_HAS_128BIT && LDBL_MANT_DIG == 64. So even if the build doesn't specify it, the test won't be skipped by mistake.

[efriedma]

lib/builtins/int_types.h

72 ↗

(On Diff #93950)

32-bit x86 Linux/Mac/Windows/etc. targets have 80-bit long double, but no __int128_t support.

[weimingz]

lib/builtins/int_types.h

72 ↗

(On Diff #93950)

the lib routines like fixunsxfti.c, floattixf.c etc are guarded by CRT_HAS_128BIT(that is LP64) macro.

[efriedma]

lib/builtins/int_types.h

72 ↗

(On Diff #93950)

The routines you mention are guarded by CRT_HAS_128BIT, but other 80-bit float routines aren't, e.g. __fixxfdi.

[weimingz]

seems no way to detect if 80-bit ldbl is supported or not. Leave it to the build time flags.

[weimingz]

In my view, LDBL_MANT_DIG == 64 implies HAS_80_BIT_LONG_DOUBLE, but need t to exclude MIPS as it clang BE doesn't support it.

[efriedma]

There are two kinds of systems with 80-bit long double: 64-bit x86, and 32-bit x86. On 32-bit x86 with 80-bit long double, CRT_HAS_128BIT is false, and __LDBL_MANT_DIG__ is 64. On 64-bit x86 with 80-bit long double, CRT_HAS_128BIT is true, and __LDBL_MANT_DIG__ is 64.

For the 80-bit long double tests which don't use 128-bit integers, you want to run them for all systems where LDBL_MANT_DIG is 64. For the 80-bit long double tests which do use 128-bit integers, you want to run them only on systems where CRT_HAS_128BIT is set and __LDBL_MANT_DIG__ is 64.

[weimingz]

these tests are the only 4 tests that use 128 bit long long.
Other tests that uses HAS_80_BIT_LONG_DOUBLE should be replaced with __LDBL_MANT_DIG__ == 64

[joerg]

Actually, there are three platforms that use: i386, amd64 and m68k. The latter might not currently be supported by LLVM, but it still exists.
__int64_t and therefore CRT_HAS_128BIT are supported by all 64bit platforms and only those. The two features are orthogonal.

In short, the combination of "TI mode" and "XF mode" is only amd64, "XF mode" applies to i386, amd64 and m68k.

[weimingz]

Thanks for the explanation. The current patch should address the problem, right?

[weimingz]

ping?

test/builtins/Unit/fixunsxfti_test.c

 //
 // This file tests __fixunsxfti for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
-#ifdef CRT_HAS_128BIT
+#if defined(CRT_HAS_128BIT) && __LDBL_MANT_DIG__ == 64
 
 // Returns: convert a to a unsigned long long, rounding toward zero.
 //          Negative values all become zero.
 
 // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
 //             tu_int is a 64 bit integral type
 //             value in long double is representable in tu_int or is negative 
 //                 (no range checking performed)

 char assumption_1[sizeof(tu_int) == 2*sizeof(du_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()
 {
-#ifdef CRT_HAS_128BIT
+#if defined(CRT_HAS_128BIT) && __LDBL_MANT_DIG__ == 64
     if (test__fixunsxfti(0.0, 0))
         return 1;
 
     if (test__fixunsxfti(0.5, 0))
         return 1;
     if (test__fixunsxfti(0.99, 0))
         return 1;
     if (test__fixunsxfti(1.0, 1))

test/builtins/Unit/fixxfti_test.c

 //
 // This file tests __fixxfti for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
-#ifdef CRT_HAS_128BIT
+#if defined(CRT_HAS_128BIT) && __LDBL_MANT_DIG__ == 64
 
 // Returns: convert a to a signed long long, rounding toward zero.
 
 // Assumption: long double is an intel 80 bit floating point type padded with 6 bytes
 //             su_int is a 32 bit integral type
 //             value in long double is representable in ti_int (no range checking performed)
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |

 char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
 char assumption_2[sizeof(su_int)*CHAR_BIT == 32] = {0};
 char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
 
 #endif
 
 int main()
 {
-#ifdef CRT_HAS_128BIT
+#if defined(CRT_HAS_128BIT) && __LDBL_MANT_DIG__ == 64
     if (test__fixxfti(0.0, 0))
         return 1;
 
     if (test__fixxfti(0.5, 0))
         return 1;
     if (test__fixxfti(0.99, 0))
         return 1;
     if (test__fixxfti(1.0, 1))

test/builtins/Unit/floattixf_test.c

 // This file tests __floattixf for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <float.h>
 #include <stdio.h>
 
-#ifdef CRT_HAS_128BIT
+#if defined(CRT_HAS_128BIT) && __LDBL_MANT_DIG__ == 64
 
 // Returns: convert a to a long double, rounding toward even.
 
 // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
 //             ti_int is a 128 bit integral type
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
 // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm

 char assumption_1[sizeof(ti_int) == 2*sizeof(di_int)] = {0};
 char assumption_2[sizeof(ti_int)*CHAR_BIT == 128] = {0};
 char assumption_3[sizeof(long double)*CHAR_BIT == 128] = {0};
 
 #endif
 
 int main()
 {
-#ifdef CRT_HAS_128BIT
+#if defined(CRT_HAS_128BIT) && __LDBL_MANT_DIG__ == 64
     if (test__floattixf(0, 0.0))
         return 1;
 
     if (test__floattixf(1, 1.0))
         return 1;
     if (test__floattixf(2, 2.0))
         return 1;
     if (test__floattixf(20, 20.0))

test/builtins/Unit/floatuntixf_test.c

 // This file tests __floatuntixf for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <float.h>
 #include <stdio.h>
 
-#ifdef CRT_HAS_128BIT
+#if defined(CRT_HAS_128BIT) && __LDBL_MANT_DIG__ == 64
 
 // Returns: convert a to a long double, rounding toward even.
 
 // Assumption: long double is a IEEE 80 bit floating point type padded to 128 bits
 //             tu_int is a 128 bit integral type
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee eeee |
 // 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm

 char assumption_1[sizeof(tu_int) == 2*sizeof(du_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()
 {
-#ifdef CRT_HAS_128BIT
+#if defined(CRT_HAS_128BIT) && __LDBL_MANT_DIG__ == 64
     if (test__floatuntixf(0, 0.0))
         return 1;
 
     if (test__floatuntixf(1, 1.0))
         return 1;
     if (test__floatuntixf(2, 2.0))
         return 1;
     if (test__floatuntixf(20, 20.0))