[libc][math] Optimize nearest integer functions using builtins when available (#98376)

Author: overmighty

libc/cmake/modules/CheckCompilerFeatures.cmake

@@ -2,7 +2,15 @@
 # Compiler features definition and flags
 # ------------------------------------------------------------------------------
 
-set(ALL_COMPILER_FEATURES "float16" "float128" "fixed_point")
+set(
+  ALL_COMPILER_FEATURES
+    "builtin_ceil_floor_rint_trunc"
+    "builtin_round"
+    "builtin_roundeven"
+    "float16"
+    "float128"
+    "fixed_point"
+)
 
 # Making sure ALL_COMPILER_FEATURES is sorted.
 list(SORT ALL_COMPILER_FEATURES)
@@ -39,18 +47,30 @@ endfunction()
 set(AVAILABLE_COMPILER_FEATURES "")
 
 # Try compile a C file to check if flag is supported.
-set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
 foreach(feature IN LISTS ALL_COMPILER_FEATURES)
+  set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
   set(compile_options ${LIBC_COMPILE_OPTIONS_NATIVE})
+  set(link_options "")
   if(${feature} STREQUAL "fixed_point")
     list(APPEND compile_options "-ffixed-point")
+  elseif(${feature} MATCHES "^builtin_")
+    set(compile_options ${LIBC_COMPILE_OPTIONS_DEFAULT})
+    set(link_options -nostdlib)
+    # The compiler might handle calls to rounding builtins by generating calls
+    # to the respective libc math functions, in which case we cannot use these
+    # builtins in our implementations of these functions. We check that this is
+    # not the case by trying to link an executable, since linking would fail due
+    # to unresolved references with -nostdlib if calls to libc functions were
+    # generated.
+    set(CMAKE_TRY_COMPILE_TARGET_TYPE EXECUTABLE)
   endif()
 
   try_compile(
     has_feature
     ${CMAKE_CURRENT_BINARY_DIR}/compiler_features
     SOURCES ${LIBC_SOURCE_DIR}/cmake/modules/compiler_features/check_${feature}.cpp
     COMPILE_DEFINITIONS -I${LIBC_SOURCE_DIR} ${compile_options}
+    LINK_OPTIONS ${link_options}
   )
   if(has_feature)
     list(APPEND AVAILABLE_COMPILER_FEATURES ${feature})
@@ -60,6 +80,12 @@ foreach(feature IN LISTS ALL_COMPILER_FEATURES)
       set(LIBC_TYPES_HAS_FLOAT128 TRUE)
     elseif(${feature} STREQUAL "fixed_point")
       set(LIBC_COMPILER_HAS_FIXED_POINT TRUE)
+    elseif(${feature} STREQUAL "builtin_ceil_floor_rint_trunc")
+      set(LIBC_COMPILER_HAS_BUILTIN_CEIL_FLOOR_RINT_TRUNC TRUE)
+    elseif(${feature} STREQUAL "builtin_round")
+      set(LIBC_COMPILER_HAS_BUILTIN_ROUND TRUE)
+    elseif(${feature} STREQUAL "builtin_roundeven")
+      set(LIBC_COMPILER_HAS_BUILTIN_ROUNDEVEN TRUE)
     endif()
   endif()
 endforeach()

libc/cmake/modules/LLVMLibCCompileOptionRules.cmake

@@ -4,7 +4,7 @@ function(_get_compile_options_from_flags output_var)
   if(LIBC_TARGET_ARCHITECTURE_IS_RISCV64 OR(LIBC_CPU_FEATURES MATCHES "FMA"))
     check_flag(ADD_FMA_FLAG ${FMA_OPT_FLAG} ${ARGN})
   endif()
-  check_flag(ADD_SSE4_2_FLAG ${ROUND_OPT_FLAG} ${ARGN})
+  check_flag(ADD_ROUND_OPT_FLAG ${ROUND_OPT_FLAG} ${ARGN})
   check_flag(ADD_EXPLICIT_SIMD_OPT_FLAG ${EXPLICIT_SIMD_OPT_FLAG} ${ARGN})
 
   if(LLVM_COMPILER_IS_GCC_COMPATIBLE)
@@ -16,8 +16,23 @@ function(_get_compile_options_from_flags output_var)
         list(APPEND compile_options "-D__LIBC_RISCV_USE_FMA")
       endif()
     endif()
-    if(ADD_SSE4_2_FLAG)
-      list(APPEND compile_options "-msse4.2")
+    if(ADD_ROUND_OPT_FLAG)
+      if(LIBC_TARGET_ARCHITECTURE_IS_X86)
+        # ROUND_OPT_FLAG is only enabled if SSE4.2 is detected, not just SSE4.1,
+        # because there was code to check for SSE4.2 already, and few CPUs only
+        # have SSE4.1.
+        list(APPEND compile_options "-msse4.2")
+      endif()
+      if(LIBC_COMPILER_HAS_BUILTIN_CEIL_FLOOR_RINT_TRUNC)
+        list(APPEND compile_options
+             "-D__LIBC_USE_BUILTIN_CEIL_FLOOR_RINT_TRUNC")
+      endif()
+      if(LIBC_COMPILER_HAS_BUILTIN_ROUND)
+        list(APPEND compile_options "-D__LIBC_USE_BUILTIN_ROUND")
+      endif()
+      if(LIBC_COMPILER_HAS_BUILTIN_ROUNDEVEN)
+        list(APPEND compile_options "-D__LIBC_USE_BUILTIN_ROUNDEVEN")
+      endif()
     endif()
     if(ADD_EXPLICIT_SIMD_OPT_FLAG)
       list(APPEND compile_options "-D__LIBC_EXPLICIT_SIMD_OPT")

libc/cmake/modules/LLVMLibCFlagRules.cmake

@@ -277,6 +277,7 @@ if(NOT(LIBC_TARGET_ARCHITECTURE_IS_X86 AND (LIBC_CPU_FEATURES MATCHES "SSE2")))
 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")))
+if(NOT((LIBC_TARGET_ARCHITECTURE_IS_X86 AND (LIBC_CPU_FEATURES MATCHES "SSE4_2")) OR
+       LIBC_TARGET_ARCHITECTURE_IS_AARCH64))
   set(SKIP_FLAG_EXPANSION_ROUND_OPT TRUE)
 endif()

libc/cmake/modules/compiler_features/check_builtin_ceil_floor_rint_trunc.cpp

@@ -0,0 +1,11 @@
+float try_builtin_ceilf(float x) { return __builtin_ceilf(x); }
+float try_builtin_floorf(float x) { return __builtin_floorf(x); }
+float try_builtin_rintf(float x) { return __builtin_rintf(x); }
+float try_builtin_truncf(float x) { return __builtin_truncf(x); }
+
+double try_builtin_ceil(double x) { return __builtin_ceil(x); }
+double try_builtin_floor(double x) { return __builtin_floor(x); }
+double try_builtin_rint(double x) { return __builtin_rint(x); }
+double try_builtin_trunc(double x) { return __builtin_trunc(x); }
+
+extern "C" void _start() {}

libc/cmake/modules/compiler_features/check_builtin_round.cpp

@@ -0,0 +1,5 @@
+float try_builtin_roundf(float x) { return __builtin_roundf(x); }
+
+double try_builtin_round(double x) { return __builtin_round(x); }
+
+extern "C" void _start() {}

libc/cmake/modules/compiler_features/check_builtin_roundeven.cpp

@@ -0,0 +1,5 @@
+float try_builtin_roundevenf(float x) { return __builtin_roundevenf(x); }
+
+double try_builtin_roundeven(double x) { return __builtin_roundeven(x); }
+
+extern "C" void _start() {}