[libcxx] Use builtin in isinf/isnormal/fpclassify/isfinite

[qiucf]

Summary

In bootstrap testing on Power9 target with libcxx enabled, build would fail because glibc uses __builtin_types_compatible_p in definition of these macros but the builtin is not available in C++ mode. And glibc assumes:

/* Since __builtin_isinf_sign is broken for float128 before GCC 7.0,
   use the helper function, __isinff128, with older compilers.  This is
   only provided for C mode, because in C++ mode, GCC has no support
   for __builtin_types_compatible_p (and when in C++ mode, this macro is
   not used anyway, because libstdc++ headers undefine it).  */

So we need another way to do the implementation, just like rG767eadd78.

[TokarIP]

FYI https://reviews.llvm.org/D88854 does this for more builtins/functions

[ldionne]

In D96121#2545476, @TokarIP wrote:

FYI https://reviews.llvm.org/D88854 does this for more builtins/functions

That revision wasn't easily discoverable. I added the LLVM Monorepo tag to it and now it's in the review queue.

[ldionne]

I looked at the other review and it does seem to supersede this one. I would suggest we go ahead with the other one once CI passes, and so we should be able to just abandon this one. I'll let the two authors decide if they want to do that or something else (e.g. ship this one and rebase the other one).

[qiucf]

In D96121#2545476, @TokarIP wrote:

FYI https://reviews.llvm.org/D88854 does this for more builtins/functions

Thanks for the information! I did not notice another patch about this exists. I can abandon this after that is committed.

[ldionne]

The other patch has been landed, I think we can abandon this. Thanks!

libcxx/include/math.h

 
 #ifdef fpclassify
 
 template <class _A1>
 _LIBCPP_INLINE_VISIBILITY
 int
 __libcpp_fpclassify(_A1 __lcpp_x) _NOEXCEPT
 {
+#if __has_builtin(__builtin_fpclassify)
+    return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL,
+                                FP_ZERO, __lcpp_x);
+#else
     return fpclassify(__lcpp_x);
+#endif
 }
 
 #undef fpclassify
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_floating_point<_A1>::value, int>::type
 fpclassify(_A1 __lcpp_x) _NOEXCEPT

 
 #ifdef isfinite
 
 template <class _A1>
 _LIBCPP_INLINE_VISIBILITY
 bool
 __libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT
 {
+#if __has_builtin(__builtin_isfinite)
+    return __builtin_isfinite(__lcpp_x);
+#else
     return isfinite(__lcpp_x);
+#endif
 }
 
 #undef isfinite
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<
     std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity,

 
 #ifdef isinf
 
 template <class _A1>
 _LIBCPP_INLINE_VISIBILITY
 bool
 __libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT
 {
+#if __has_builtin(__builtin_isinf)
+    return __builtin_isinf(__lcpp_x);
+#else
     return isinf(__lcpp_x);
+#endif
 }
 
 #undef isinf
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<
     std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity,

 
 #ifdef isnormal
 
 template <class _A1>
 _LIBCPP_INLINE_VISIBILITY
 bool
 __libcpp_isnormal(_A1 __lcpp_x) _NOEXCEPT
 {
+#if __has_builtin(__builtin_isnormal)
+    return __builtin_isnormal(__lcpp_x);
+#else
     return isnormal(__lcpp_x);
+#endif
 }
 
 #undef isnormal
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
 isnormal(_A1 __lcpp_x) _NOEXCEPT