[libc++][math.h] Remove __libcpp_<func> functions and instead call builtins directly

[Mordante]

In general a nice cleanup, but I have a question.

libcxx/include/math.h

534

This one and the next ones didn't call a __builtin. Does this work on all supported platforms?

[philnik]

libcxx/include/math.h

534

I think the builtin just resolves to either a compiler-rt/libgcc function call or an instruction on most (all?) platforms. At least on x86, armv7 and powerpc64: https://godbolt.org/z/8cb4z98hz, so I think it's fine. In glibc the normal functions are just aliases to the builtins.

[Mordante]

libcxx/include/math.h

534

Let's see what the CI says. If it's happy I'm happy. I like to see it run before approving. (It now fails to apply.)

[ldionne]

LGTM if CI is happy. This is a nice simplification and it gets us much closer to working on freestanding implementation that don't have a complete <math.h> implementation.

[philnik]

Rebased

[Mordante]

The CI is happy, so I'm happy. LGTM!

libcxx/include/math.h

 #include <__type_traits/promote.h>
 #include <limits>
 #include <stdlib.h>
 #include <type_traits>
 
 // signbit
 
 #    ifdef signbit
-
-template <class _A1>
-_LIBCPP_HIDE_FROM_ABI bool __libcpp_signbit(_A1 __x) _NOEXCEPT {
-  return __builtin_signbit(__x);
-}
-
 #      undef signbit
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
 signbit(_A1 __x) _NOEXCEPT {
-  return __libcpp_signbit(__x);
+  return __builtin_signbit(__x);
 }
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
     typename std::enable_if< std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type
     signbit(_A1 __x) _NOEXCEPT {
   return __x < 0;
 }
inline _LIBCPP_HIDE_FROM_ABI
   return false;
 }
 
 #    endif // signbit
 
 // fpclassify
 
 #    ifdef fpclassify
-
-template <class _A1>
-_LIBCPP_HIDE_FROM_ABI int __libcpp_fpclassify(_A1 __x) _NOEXCEPT {
-  return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x);
-}
-
 #      undef fpclassify
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_floating_point<_A1>::value, int>::type
 fpclassify(_A1 __x) _NOEXCEPT {
-  return __libcpp_fpclassify(__x);
+  return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x);
 }
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_integral<_A1>::value, int>::type
 fpclassify(_A1 __x) _NOEXCEPT {
   return __x == 0 ? FP_ZERO : FP_NORMAL;
 }
 
fpclassify(_A1 __x) _NOEXCEPT {
   return __x == 0 ? FP_ZERO : FP_NORMAL;
 }
 
 #    endif // fpclassify
 
 // isfinite
 
 #    ifdef isfinite
-
-template <class _A1>
-_LIBCPP_HIDE_FROM_ABI bool __libcpp_isfinite(_A1 __x) _NOEXCEPT {
-  return __builtin_isfinite(__x);
-}
-
 #      undef isfinite
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
     typename std::enable_if< std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity, bool>::type
     isfinite(_A1 __x) _NOEXCEPT {
-  return __libcpp_isfinite((typename std::__promote<_A1>::type)__x);
+  return __builtin_isfinite((typename std::__promote<_A1>::type)__x);
 }
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
     typename std::enable_if< std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity, bool>::type
     isfinite(_A1) _NOEXCEPT {
   return true;
 }
 
 #    endif // isfinite
 
 // isinf
 
 #    ifdef isinf
-
-template <class _A1>
-_LIBCPP_HIDE_FROM_ABI bool __libcpp_isinf(_A1 __x) _NOEXCEPT {
-  return __builtin_isinf(__x);
-}
-
 #      undef isinf
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
     typename std::enable_if< std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity, bool>::type
     isinf(_A1 __x) _NOEXCEPT {
-  return __libcpp_isinf((typename std::__promote<_A1>::type)__x);
+  return __builtin_isinf((typename std::__promote<_A1>::type)__x);
 }
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
     typename std::enable_if< std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity, bool>::type
     isinf(_A1) _NOEXCEPT {
   return false;
 }
 
 #      ifdef _LIBCPP_PREFERRED_OVERLOAD
-inline _LIBCPP_HIDE_FROM_ABI bool isinf(float __x) _NOEXCEPT { return __libcpp_isinf(__x); }
+inline _LIBCPP_HIDE_FROM_ABI bool isinf(float __x) _NOEXCEPT { return __builtin_isinf(__x); }
 
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool isinf(double __x) _NOEXCEPT { return __libcpp_isinf(__x); }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool isinf(double __x) _NOEXCEPT { return __builtin_isinf(__x); }
 
-inline _LIBCPP_HIDE_FROM_ABI bool isinf(long double __x) _NOEXCEPT { return __libcpp_isinf(__x); }
+inline _LIBCPP_HIDE_FROM_ABI bool isinf(long double __x) _NOEXCEPT { return __builtin_isinf(__x); }
 #      endif
 
 #    endif // isinf
 
 // isnan
 
 #    ifdef isnan
-
-template <class _A1>
-_LIBCPP_HIDE_FROM_ABI bool __libcpp_isnan(_A1 __x) _NOEXCEPT {
-  return __builtin_isnan(__x);
-}
-
 #      undef isnan
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
 isnan(_A1 __x) _NOEXCEPT {
-  return __libcpp_isnan(__x);
+  return __builtin_isnan(__x);
 }
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_integral<_A1>::value, bool>::type isnan(_A1) _NOEXCEPT {
   return false;
 }
 
 #      ifdef _LIBCPP_PREFERRED_OVERLOAD
-inline _LIBCPP_HIDE_FROM_ABI bool isnan(float __x) _NOEXCEPT { return __libcpp_isnan(__x); }
+inline _LIBCPP_HIDE_FROM_ABI bool isnan(float __x) _NOEXCEPT { return __builtin_isnan(__x); }
 
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool isnan(double __x) _NOEXCEPT { return __libcpp_isnan(__x); }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool isnan(double __x) _NOEXCEPT { return __builtin_isnan(__x); }
 
-inline _LIBCPP_HIDE_FROM_ABI bool isnan(long double __x) _NOEXCEPT { return __libcpp_isnan(__x); }
+inline _LIBCPP_HIDE_FROM_ABI bool isnan(long double __x) _NOEXCEPT { return __builtin_isnan(__x); }
 #      endif
 
 #    endif // isnan
 
 // isnormal
 
 #    ifdef isnormal
-
-template <class _A1>
-_LIBCPP_HIDE_FROM_ABI bool __libcpp_isnormal(_A1 __x) _NOEXCEPT {
-  return __builtin_isnormal(__x);
-}
-
 #      undef isnormal
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
 isnormal(_A1 __x) _NOEXCEPT {
-  return __libcpp_isnormal(__x);
+  return __builtin_isnormal(__x);
 }
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if<std::is_integral<_A1>::value, bool>::type
 isnormal(_A1 __x) _NOEXCEPT {
   return __x != 0;
 }
 
 #    endif // isnormal
 
 // isgreater
 
 #    ifdef isgreater
-
-template <class _A1, class _A2>
-_LIBCPP_HIDE_FROM_ABI bool __libcpp_isgreater(_A1 __x, _A2 __y) _NOEXCEPT {
-  return isgreater(__x, __y);
-}
-
 #      undef isgreater
 
 template <class _A1, class _A2>
 inline _LIBCPP_HIDE_FROM_ABI
     typename std::enable_if< std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type
     isgreater(_A1 __x, _A2 __y) _NOEXCEPT {
   typedef typename std::__promote<_A1, _A2>::type type;
-  return __libcpp_isgreater((type)__x, (type)__y);
+  return __builtin_isgreater((type)__x, (type)__y);
 }
 
 #    endif // isgreater
 
 // isgreaterequal
 
 #    ifdef isgreaterequal
-
-template <class _A1, class _A2>
-_LIBCPP_HIDE_FROM_ABI bool __libcpp_isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT {
-  return isgreaterequal(__x, __y);
-}
-
 #      undef isgreaterequal
 
 template <class _A1, class _A2>
 inline _LIBCPP_HIDE_FROM_ABI
     typename std::enable_if< std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type
     isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT {
   typedef typename std::__promote<_A1, _A2>::type type;
-  return __libcpp_isgreaterequal((type)__x, (type)__y);
+  return __builtin_isgreaterequal((type)__x, (type)__y);
 }
 
 #    endif // isgreaterequal
 
 // isless
 
 #    ifdef isless
-
-template <class _A1, class _A2>
-_LIBCPP_HIDE_FROM_ABI bool __libcpp_isless(_A1 __x, _A2 __y) _NOEXCEPT {
-  return isless(__x, __y);
-}
-
 #      undef isless
 
 template <class _A1, class _A2>
 inline _LIBCPP_HIDE_FROM_ABI
     typename std::enable_if< std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type
     isless(_A1 __x, _A2 __y) _NOEXCEPT {
   typedef typename std::__promote<_A1, _A2>::type type;
-  return __libcpp_isless((type)__x, (type)__y);
+  return __builtin_isless((type)__x, (type)__y);
 }
 
 #    endif // isless
 
 // islessequal
 
 #    ifdef islessequal
-
-template <class _A1, class _A2>
-_LIBCPP_HIDE_FROM_ABI bool __libcpp_islessequal(_A1 __x, _A2 __y) _NOEXCEPT {
-  return islessequal(__x, __y);
-}
-
 #      undef islessequal
 
 template <class _A1, class _A2>
 inline _LIBCPP_HIDE_FROM_ABI
     typename std::enable_if< std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type
     islessequal(_A1 __x, _A2 __y) _NOEXCEPT {
   typedef typename std::__promote<_A1, _A2>::type type;
-  return __libcpp_islessequal((type)__x, (type)__y);
+  return __builtin_islessequal((type)__x, (type)__y);
 }
 
 #    endif // islessequal
 
 // islessgreater
 
 #    ifdef islessgreater
-
-template <class _A1, class _A2>
-_LIBCPP_HIDE_FROM_ABI bool __libcpp_islessgreater(_A1 __x, _A2 __y) _NOEXCEPT {
-  return islessgreater(__x, __y);
-}
-
 #      undef islessgreater
 
 template <class _A1, class _A2>
 inline _LIBCPP_HIDE_FROM_ABI
     typename std::enable_if< std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type
     islessgreater(_A1 __x, _A2 __y) _NOEXCEPT {
   typedef typename std::__promote<_A1, _A2>::type type;
-  return __libcpp_islessgreater((type)__x, (type)__y);
+  return __builtin_islessgreater((type)__x, (type)__y);
 }
 
 #    endif // islessgreater
 
 // isunordered
 
 #    ifdef isunordered
-
-template <class _A1, class _A2>
-_LIBCPP_HIDE_FROM_ABI bool __libcpp_isunordered(_A1 __x, _A2 __y) _NOEXCEPT {
-  return isunordered(__x, __y);
-}
-
 #      undef isunordered
 
 template <class _A1, class _A2>
 inline _LIBCPP_HIDE_FROM_ABI
     typename std::enable_if< std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type
     isunordered(_A1 __x, _A2 __y) _NOEXCEPT {
   typedef typename std::__promote<_A1, _A2>::type type;
-  return __libcpp_isunordered((type)__x, (type)__y);
+  return __builtin_isunordered((type)__x, (type)__y);
 }
 
 #    endif // isunordered
 
 // abs
 //
 // handled in stdlib.h