[tests][compiler-rt] Implement generic_ldbl{80,128}_test targets

[atrosinenko]

Summary

This patch introduces two "generic" pseudo targets to simplify testing
the changes to builtins library on a developer machine.

These targets

• ignore any target-specific subdirectories
• use the specified size of long double (this may simplify testing of QUAD_PRECISION libcall variants when working on a generic implementation on an X86 host)
• are intended *for testing only*
• may produce false positives (at least when non-default size of long double is selected)

[atrosinenko]

See rG553833958fd as an example.

compiler-rt/cmake/base-config-ix.cmake

elseif(NOT APPLE) # Supported archs for Apple platforms are generated later
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "riscv64")
       test_target_arch(riscv64 "" "")
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "wasm32")
       test_target_arch(wasm32 "" "--target=wasm32-unknown-unknown")
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "wasm64")
       test_target_arch(wasm64 "" "--target=wasm64-unknown-unknown")
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "ve")
       test_target_arch(ve "__ve__" "--target=ve-unknown-none")
+    elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "generic_ldbl80_test")
+      test_target_arch(generic_ldbl80 "" "-mlong-double-80 -DGENERIC_TARGET")
+    elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "generic_ldbl128_test")
+      test_target_arch(generic_ldbl128 "" "-mlong-double-128 -DGENERIC_TARGET")
     endif()
     set(COMPILER_RT_OS_SUFFIX "")
   endif()
 endmacro()

compiler-rt/cmake/builtin-config-ix.cmake

 set(RISCV32 riscv32)
 set(RISCV64 riscv64)
 set(SPARC sparc)
 set(SPARCV9 sparcv9)
 set(WASM32 wasm32)
 set(WASM64 wasm64)
 set(VE ve)
 
+# Build as many generic LibCall implementations as possible while not using any
+# target-specific implementations.
+# This is intended for local testing only to help catch bugs for generic LibCall
+# implementations that are normally shadowed by target-specific ones or
+# not built at all (such as float128-related code on some X86 targets) on a
+# developer machine.
+# NB: The test results may be not absolutely reliable (at least when using
+#     non-default size of `long double` due to using system-provided libm),
+#     so false positives are possible.
+set(GENERIC_FOR_TESTS generic_ldbl80 generic_ldbl128)
+
 if(APPLE)
   set(ARM64 arm64 arm64e)
   set(ARM32 armv7 armv7k armv7s)
   set(X86_64 x86_64 x86_64h)
 endif()
 
 set(ALL_BUILTIN_SUPPORTED_ARCH
   ${X86} ${X86_64} ${ARM32} ${ARM64}
   ${HEXAGON} ${MIPS32} ${MIPS64} ${PPC64}
   ${RISCV32} ${RISCV64} ${SPARC} ${SPARCV9}
-  ${WASM32} ${WASM64} ${VE})
+  ${WASM32} ${WASM64} ${VE}
+  ${GENERIC_FOR_TESTS})
 
 include(CompilerRTUtils)
 include(CompilerRTDarwinUtils)
 
 if(APPLE)
 
   find_darwin_sdk_dir(DARWIN_osx_SYSROOT macosx)
   find_darwin_sdk_dir(DARWIN_iossim_SYSROOT iphonesimulator)

compiler-rt/lib/builtins/CMakeLists.txt

 )
 
 set(ve_SOURCES
   ve/grow_stack.S
   ve/grow_stack_align.S
   ${GENERIC_TF_SOURCES}
   ${GENERIC_SOURCES})
 
+# For local testing only.
+set(generic_ldbl80_SOURCES
+  ${GENERIC_SOURCES}
+  ${x86_80_BIT_SOURCES}
+)
+set(generic_ldbl128_SOURCES
+  ${GENERIC_SOURCES}
+  ${GENERIC_TF_SOURCES}
+)
+
 add_custom_target(builtins)
 set_target_properties(builtins PROPERTIES FOLDER "Compiler-RT Misc")
 
 if (APPLE)
   add_subdirectory(Darwin-excludes)
   add_subdirectory(macho_embedded)
   darwin_add_builtin_libraries(${BUILTIN_SUPPORTED_OS})
 else ()

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

if (test__addtf3(makeInf128(),
         return 1;
     // any + any
     if (test__addtf3(0x1.23456734245345543849abcdefp+5L,
                      0x1.edcba52449872455634654321fp-1L,
                      UINT64_C(0x40042afc95c8b579),
                      UINT64_C(0x61e58dd6c51eb77c)))
         return 1;
 
+#if !defined(GENERIC_TARGET)
 #if (defined(__arm__) || defined(__aarch64__)) && defined(__ARM_FP) || \
     defined(i386) || defined(__x86_64__)
     // Rounding mode tests on supported architectures
     const long double m = 1234.0L, n = 0.01L;
 
     fesetround(FE_UPWARD);
     if (test__addtf3(m, n,
                      UINT64_C(0x40093480a3d70a3d),
if (test__addtf3(m, n,
         return 1;
 
     fesetround(FE_TONEAREST);
     if (test__addtf3(m, n,
                      UINT64_C(0x40093480a3d70a3d),
                      UINT64_C(0x70a3d70a3d70a3d7)))
         return 1;
 #endif
+#endif // !defined(GENERIC_TARGET)
 
 #else
     printf("skipped\n");
 
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/compiler_rt_logbl_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 
 #define QUAD_PRECISION
 #include <math.h>
 #include <stdio.h>
 #include "fp_lib.h"
 #include "int_lib.h"
 
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+// GENERIC_TARGET may have non-default sizeof(long double), so it is useless
+// to compare __compiler_rt_logbl() against native logbl().
+
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) && \
+    !defined(GENERIC_TARGET)
 
 int test__compiler_rt_logbl(fp_t x) {
   fp_t crt_value = __compiler_rt_logbl(x);
   fp_t libm_value = logbl(x);
   // Compare the values, considering all NaNs equivalent, as the spec doesn't
   // specify the NaN signedness/payload.
   if (crt_value != libm_value &&
       !(crt_isnan(crt_value) && crt_isnan(libm_value))) {

 double cases[] = {
     1.e-6, -1.e-6, NAN, -NAN, INFINITY, -INFINITY, -1,
     -0.0,  0.0,    1,   -2,   2,        -0.5,      0.5,
 };
 
 #endif
 
 int main() {
-#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT) && \
+    !defined(GENERIC_TARGET)
   const unsigned N = sizeof(cases) / sizeof(cases[0]);
   unsigned i;
   for (i = 0; i < N; ++i) {
     if (test__compiler_rt_logbl(cases[i])) return 1;
   }
 
   // Test a moving 1 bit, especially to handle denormal values.
   // Test the negation as well.

compiler-rt/test/builtins/Unit/divtc3_test.c

 // RUN: %clang_builtins %s %librt -lm -o %t && %run %t
 // REQUIRES: librt_has_divtc3
 // REQUIRES: c99-complex
 
 //
 // Bug 42493
 // XFAIL: sparc-target-arch
 //
+
+// `long double` should have its default target-specific size
+// to be `classify()`ed properly.
+// XFAIL: generic_ldbl128-target-arch
+
 #include <stdio.h>
 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 
 
 // Returns: the quotient of (a + ib) / (c + id)

compiler-rt/test/builtins/Unit/divxc3_test.c

 // RUN: %clang_builtins %s %librt -lm -o %t && %run %t
 // REQUIRES: librt_has_divxc3
 // REQUIRES: x86-target-arch
 // UNSUPPORTED: powerpc64
 // UNSUPPORTED: mips
 // REQUIRES: c99-complex
 
+// `long double` should have its default target-specific size
+// to be `classify()`ed properly.
+// XFAIL: generic_ldbl80-target-arch
+
 #if !_ARCH_PPC
 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 #include <stdio.h>
 
 

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

if (test__subtf3(makeInf128(),
         return 1;
     // any - any
     if (test__subtf3(0x1.234567829a3bcdef5678ade36734p+5L,
                      0x1.ee9d7c52354a6936ab8d7654321fp-1L,
                      UINT64_C(0x40041b8af1915166),
                      UINT64_C(0xa44a7bca780a166c)))
         return 1;
 
+#if !defined(GENERIC_TARGET)
 #if (defined(__arm__) || defined(__aarch64__)) && defined(__ARM_FP) || \
     defined(i386) || defined(__x86_64__)
     // Rounding mode tests on supported architectures
     const long double m = 1234.02L, n = 0.01L;
 
     fesetround(FE_UPWARD);
     if (test__subtf3(m, n,
                      UINT64_C(0x40093480a3d70a3d),
if (test__subtf3(m, n,
         return 1;
 
     fesetround(FE_TONEAREST);
     if (test__subtf3(m, n,
                      UINT64_C(0x40093480a3d70a3d),
                      UINT64_C(0x70a3d70a3d70a3d7)))
         return 1;
 #endif
+#endif // !defined(GENERIC_TARGET)
 
 #else
     printf("skipped\n");
 
 #endif
     return 0;
 }