[libc][math] Separated builtin function in special FPUtils header.

[orex]

Summary

A small refactoring of builtin functions in preparation to adding fmod/fmodf function.

[lntue]

libc/src/__support/FPUtil/builtin_wrappers.h

11

Update header guard to match file name.

[orex]

Fixed header protection name.

libc/src/__support/FPUtil/CMakeLists.txt

 #TODO(michaelrj): separate the fputil library into individual targets.
 add_header_library(
   fputil
   HDRS
     FEnvImpl.h
     BasicOperations.h
     DivisionAndRemainderOperations.h
     FloatProperties.h
     FPBits.h
     BasicOperations.h
     ManipulationFunctions.h
     NearestIntegerOperations.h
     NormalFloat.h
     PlatformDefs.h
     UInt.h
+    builtin_wrappers.h
   DEPENDS
     libc.include.math
     libc.include.errno
     libc.include.fenv
     libc.src.__support.common
     libc.src.__support.CPP.type_traits
     libc.src.__support.CPP.bit
     libc.src.errno.errno

libc/src/__support/FPUtil/builtin_wrappers.h

+//===--Convenient template for builtins -------------------------*- C++ -*-===//
+//             (Count Lead Zeroes) and (Count Trailing Zeros)
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_BUILTIN_WRAPPERS_H
+#define LLVM_LIBC_SRC_SUPPORT_FPUTIL_BUILTIN_WRAPPERS_H
+
+namespace __llvm_libc {
+namespace fputil {
+
+// The following overloads are matched based on what is accepted by
+// __builtin_clz/ctz* rather than using the exactly-sized aliases from stdint.h.
+// This way, we can avoid making any assumptions about integer sizes and let the
+// compiler match for us.
+template <typename T> static inline int clz(T val);
+template <> inline int clz<unsigned int>(unsigned int val) {
+  return __builtin_clz(val);
+}
+template <> inline int clz<unsigned long int>(unsigned long int val) {
+  return __builtin_clzl(val);
+}
+template <> inline int clz<unsigned long long int>(unsigned long long int val) {
+  return __builtin_clzll(val);
+}
+
+template <typename T> static inline int ctz(T val);
+template <> inline int ctz<unsigned int>(unsigned int val) {
+  return __builtin_ctz(val);
+}
+template <> inline int ctz<unsigned long int>(unsigned long int val) {
+  return __builtin_ctzl(val);
+}
+template <> inline int ctz<unsigned long long int>(unsigned long long int val) {
+  return __builtin_ctzll(val);
+}
+
+template <typename T> static inline bool isnan(T val) {
+  return __builtin_isnan(val);
+}
+
+template <typename T> static inline bool isinf(T val) {
+  return __builtin_isinf(val);
+}
+
+template <typename T> static inline bool isfinite(T val) {
+  return __builtin_isfinite(val);
+}
+
+inline float quiet_NaN(float) { return __builtin_nanf(""); }
+inline double quiet_NaN(double) { return __builtin_nan(""); }
+inline long double quiet_NaN(long double) { return __builtin_nanl(""); }
+
+} // namespace fputil
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_BUILTIN_WRAPPERS_H

libc/src/__support/FPUtil/generic/sqrt.h

 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_SQRT_H
 
 #include "sqrt_80_bit_long_double.h"
 #include "src/__support/CPP/Bit.h"
 #include "src/__support/CPP/TypeTraits.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/PlatformDefs.h"
+#include "src/__support/FPUtil/builtin_wrappers.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
 template <typename T> struct SpecialLongDouble {
   static constexpr bool VALUE = false;
 };
 
 #if defined(SPECIAL_X86_LONG_DOUBLE)
 template <> struct SpecialLongDouble<long double> {
   static constexpr bool VALUE = true;
 };
 #endif // SPECIAL_X86_LONG_DOUBLE
 
-// The following overloads are matched based on what is accepted by
-// __builtin_clz* rather than using the exactly-sized aliases from stdint.h.
-// This way, we can avoid making any assumptions about integer sizes and let the
-// compiler match for us.
-template <typename T> static inline int clz(T val);
-template <> inline int clz<unsigned int>(unsigned int val) {
-  return __builtin_clz(val);
-}
-template <> inline int clz<unsigned long int>(unsigned long int val) {
-  return __builtin_clzl(val);
-}
-template <> inline int clz<unsigned long long int>(unsigned long long int val) {
-  return __builtin_clzll(val);
-}
+using fputil::ctz;
 
 template <typename T>
 static inline void normalize(int &exponent,
                              typename FPBits<T>::UIntType &mantissa) {
   const int shift =
       clz(mantissa) - (8 * sizeof(mantissa) - 1 - MantissaWidth<T>::VALUE);
   exponent -= shift;
   mantissa <<= shift;