[libc] Enabled more tests for targets other than x86_64

[mikhail.ramalho]

Summary

This patch makes two changes to enable several trigonometric tests that
required FMA_OPT and ROUND_OPT.

For ROUND_OPT, we only need to remove the SSE4.2 requirement, as the
libc implementation is able to build the test even if this set of
instruction are not available.

For FMA_OPT, we need to set cmake to check if the target has the FMA
instruction available and disable the skip if the target is not x86_64.

[mikhail.ramalho]

@sivachandra I only tested this in x86_64 and riscv 64, since I don't have aarch64 or armv7 machines available for testing.

Do we have build bots for arm targets? May I ask if you have the hardware to test this patch?

[michaelrj]

We do have aarch64 and arm32 buildbots (see https://lab.llvm.org/buildbot/#/builders/138 and https://lab.llvm.org/buildbot/#/builders/229). I'll test this patch on those machines.

[michaelrj]

The patch passed on aarch64, I couldn't test on the arm32 machine due to unrelated reasons but I'd guess it's fine.

[lntue]

@mikhail.ramalho : why do you need to force the FMA_OPT and ROUND_OPT for RISC-V target? These are to expand to build and test both with and without those instructions automatically. Do you plan the same thing for RISC-V? Without this, the current setup should test the trig functions with FMA and rounding instructions by default, and not testing trig functions without those instructions.

With this change, on AArch64, AArch32, RISC-V, and GPU, each math function will have 2-4 targets, with and without FMA_OPT and ROUND_OPT flags, and since the build system does not do anything, add any special compile options or flags, those targets are all identical. So I don't think that's your intention?

Do you want to test both non-FMA and FMA math implementations on RISC-V64 automatically similar to x86-64 instead?

[mikhail.ramalho]

In D146253#4201018, @lntue wrote:

@mikhail.ramalho : why do you need to force the FMA_OPT and ROUND_OPT for RISC-V target? These are to expand to build and test both with and without those instructions automatically. Do you plan the same thing for RISC-V? Without this, the current setup should test the trig functions with FMA and rounding instructions by default, and not testing trig functions without those instructions.

With this change, on AArch64, AArch32, RISC-V, and GPU, each math function will have 2-4 targets, with and without FMA_OPT and ROUND_OPT flags, and since the build system does not do anything, add any special compile options or flags, those targets are all identical. So I don't think that's your intention?

Do you want to test both non-FMA and FMA math implementations on RISC-V64 automatically similar to x86-64 instead?

Yeah, that was my plan: I assumed that by disabling the FMA flag, the tests would automatically pick up the generic fma implementation, but checking the generated asm I saw that's not the case. I'll check how we can fix that, at least for riscv.

Also, I was assuming that the ROUND_OPT flag was related to rounding modes (e.g., adding -fno-rounding-math), but it actually checks for SSE 4.2. May I ask what's the purpose of this flag exactly?

[lntue]

In D146253#4216411, @mikhail.ramalho wrote:

In D146253#4201018, @lntue wrote:

@mikhail.ramalho : why do you need to force the FMA_OPT and ROUND_OPT for RISC-V target? These are to expand to build and test both with and without those instructions automatically. Do you plan the same thing for RISC-V? Without this, the current setup should test the trig functions with FMA and rounding instructions by default, and not testing trig functions without those instructions.

With this change, on AArch64, AArch32, RISC-V, and GPU, each math function will have 2-4 targets, with and without FMA_OPT and ROUND_OPT flags, and since the build system does not do anything, add any special compile options or flags, those targets are all identical. So I don't think that's your intention?

Do you want to test both non-FMA and FMA math implementations on RISC-V64 automatically similar to x86-64 instead?

Yeah, that was my plan: I assumed that by disabling the FMA flag, the tests would automatically pick up the generic fma implementation, but checking the generated asm I saw that's not the case. I'll check how we can fix that, at least for riscv.

Also, I was assuming that the ROUND_OPT flag was related to rounding modes (e.g., adding -fno-rounding-math), but it actually checks for SSE 4.2. May I ask what's the purpose of this flag exactly?

By default, it will pick up the fma instruction implementations if available. This can be seen as follow (I tried this on a VisionFive2 board):

$ cmake ../llvm -GNinja -DLLVM_ENABLE_PROJECTS=libc -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
...
$ ninja libc 
[286/286] Linking CXX static library projects/libc/lib/libllvmlibc.a
$ objdump -D projects/libc/src/math/generic/CMakeFiles/libc.src.math.generic.logf.dir/logf.cpp.o | grep fma
 1c4:	1230f0c3          	fmadd.d	ft1,ft1,ft3,ft2
 204:	1a207143          	fmadd.d	ft2,ft0,ft2,ft3
 208:	22207143          	fmadd.d	ft2,ft0,ft2,ft4
 20c:	2a207143          	fmadd.d	ft2,ft0,ft2,ft5
 210:	32207143          	fmadd.d	ft2,ft0,ft2,ft6
 214:	0a207043          	fmadd.d	ft0,ft0,ft2,ft1

If you also want to test the generic (non-FMA) version in the same build, similar to what we have for x86-64, then something like https://reviews.llvm.org/D146730 is what you need.
With that patch, I tested on a VisionFive2 board as follow:

$ cmake ../llvm -GNinja -DLLVM_ENABLE_PROJECTS=libc -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
...
$ ninja libc 
[286/286] Linking CXX static library projects/libc/lib/libllvmlibc.a
$ objdump -D projects/libc/src/math/generic/CMakeFiles/libc.src.math.generic.logf.dir/logf.cpp.o | grep fma
 1c4:	1230f0c3          	fmadd.d	ft1,ft1,ft3,ft2
 204:	1a207143          	fmadd.d	ft2,ft0,ft2,ft3
 208:	22207143          	fmadd.d	ft2,ft0,ft2,ft4
 20c:	2a207143          	fmadd.d	ft2,ft0,ft2,ft5
 210:	32207143          	fmadd.d	ft2,ft0,ft2,ft6
 214:	0a207043          	fmadd.d	ft0,ft0,ft2,ft1
$ ninja libc.test.src.math.logf_test.__NO_FMA_OPT
...
$ objdump -D projects/libc/src/math/generic/CMakeFiles/libc.src.math.generic.logf.__NO_FMA_OPT.dir/logf.cpp.o | grep fma
$

Notice that the .__NO_FMA_OPT test targets will also be included when running ninja check-libc

And the ROUND_OPT is for similar purpose, with using floating point rounding instructions instead of generic quick rounding functions (see libc/src/__support/FPUtil/nearest_integer.h).

[lntue]

@mikhail.ramalho I've committed https://reviews.llvm.org/D146730. Can you double check to see if math tests on RISC-V are running both with and without FMA?

libc/cmake/modules/LLVMLibCCheckCpuFeatures.cmake

 # ------------------------------------------------------------------------------
 # Cpu features definition and flags
 # ------------------------------------------------------------------------------
 
 # Initialize ALL_CPU_FEATURES as empty list.
 set(ALL_CPU_FEATURES "")
 
 if(LIBC_TARGET_ARCHITECTURE_IS_GPU)
   return()
 endif()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   set(ALL_CPU_FEATURES SSE2 SSE4_2 AVX2 AVX512F AVX512BW FMA)
   set(LIBC_COMPILE_OPTIONS_NATIVE -march=native)
 elseif(${LIBC_TARGET_ARCHITECTURE_IS_AARCH64})
   set(LIBC_COMPILE_OPTIONS_NATIVE -mcpu=native)
+elseif(${LIBC_TARGET_ARCHITECTURE_IS_RISCV64})
+  set(ALL_CPU_FEATURES FMA)
 endif()
 
 # Making sure ALL_CPU_FEATURES is sorted.
 list(SORT ALL_CPU_FEATURES)
 
 # Function to check whether the target CPU supports the provided set of features.
 # Usage:
 # cpu_supports(

libc/cmake/modules/LLVMLibCFlagRules.cmake

function(get_fq_dep_list_without_flag output_list flag)
   set(${output_list} ${fq_dep_no_flag_list} PARENT_SCOPE)
 endfunction(get_fq_dep_list_without_flag)
 
 # Special flags
 set(FMA_OPT_FLAG "FMA_OPT")
 set(ROUND_OPT_FLAG "ROUND_OPT")
 
 # Skip FMA_OPT flag for targets that don't support fma.
-if(NOT(LIBC_TARGET_ARCHITECTURE_IS_X86 AND (LIBC_CPU_FEATURES MATCHES "FMA")))
+if(NOT LIBC_CPU_FEATURES MATCHES "FMA")
   set(SKIP_FLAG_EXPANSION_FMA_OPT TRUE)
 endif()
-
-# Skip ROUND_OPT flag for targets that don't support SSE 4.2.
-if(NOT(LIBC_TARGET_ARCHITECTURE_IS_X86 AND (LIBC_CPU_FEATURES MATCHES "SSE4_2")))
-  set(SKIP_FLAG_EXPANSION_ROUND_OPT TRUE)
-endif()

libc/cmake/modules/LLVMLibCObjectRules.cmake

if(LLVM_COMPILER_IS_GCC_COMPATIBLE)
     list(APPEND compile_options "-Wwrite-strings")
     list(APPEND compile_options "-Wextra-semi")
     if(NOT CMAKE_COMPILER_IS_GNUCXX)
       list(APPEND compile_options "-Wnewline-eof")
       list(APPEND compile_options "-Wnonportable-system-include-path")
       list(APPEND compile_options "-Wstrict-prototypes")
       list(APPEND compile_options "-Wthread-safety")
     endif()
-    if(ADD_FMA_FLAG)
+    if(ADD_FMA_FLAG AND LIBC_TARGET_ARCHITECTURE_IS_X86)
       list(APPEND compile_options "-mavx2")
       list(APPEND compile_options "-mfma")
     endif()
     if(ADD_SSE4_2_FLAG)
       list(APPEND compile_options "-msse4.2")
     endif()
   elseif(MSVC)
     list(APPEND compile_options "/EHs-c-")
     list(APPEND compile_options "/GR-")
-    if(ADD_FMA_FLAG)
+    if(ADD_FMA_FLAG AND LIBC_TARGET_ARCHITECTURE_IS_X86)
       list(APPEND compile_options "/arch:AVX2")
     endif()
   endif()
   if (LIBC_TARGET_ARCHITECTURE_IS_GPU)
     list(APPEND compile_options "-nogpulib")
     list(APPEND compile_options "-fvisibility=hidden")
   endif()
   set(${output_var} ${compile_options} PARENT_SCOPE)