[libc] move builtin_wrappers out of fputil

[michaelrj]

Summary

builtin_wrappers contains the wrappers for the clz builtins, which do
not depend on anything in fputil. This patch moves the file out of
FPUtil. The location is updated as appropriate.

[michaelrj]

bazel changes to match fputil split

libc/src/__support/CMakeLists.txt

 add_subdirectory(CPP)
 
 add_header_library(
   blockstore
   HDRS
     blockstore.h
 )
 
 add_header_library(
+  builtin_wrappers
+  HDRS
+    builtin_wrappers.h
+)
+
+add_header_library(
   common
   HDRS
     architectures.h
     common.h
     endian.h
     sanitizer.h
 )
 
add_header_library(
   DEPENDS
     .ctype_utils
     .high_precision_decimal
     .str_to_integer
     .uint128
     libc.include.errno
     libc.src.__support.CPP.limits
     libc.src.__support.FPUtil.fp_bits
-    libc.src.__support.FPUtil.builtin_wrappers
+    libc.src.__support.builtin_wrappers
     libc.src.errno.errno
 )
 
 add_header_library(
   integer_operations
   HDRS
     integer_operations.h
 )

libc/src/__support/FPUtil/CMakeLists.txt

 add_header_library(
-  builtin_wrappers
-  HDRS
-    builtin_wrappers.h
-)
-
-add_header_library(
   fenv_impl
   HDRS
     FEnvImpl.h
   DEPENDS
     libc.include.fenv
     libc.src.__support.common
 )
 

 
 add_header_library(
   fp_bits
   HDRS
     FPBits.h
   DEPENDS
     .platform_defs
     .float_properties
-    .builtin_wrappers
+    libc.src.__support.builtin_wrappers
     libc.src.__support.CPP.bit
     libc.src.__support.CPP.type_traits
     libc.src.__support.common
 )
 
 add_header_library(
   nearest_integer_operations
   HDRS

 add_header_library(
   hypot
   HDRS
     Hypot.h
   DEPENDS
     .basic_operations
     .fenv_impl
     .fp_bits
-    .builtin_wrappers
+    libc.src.__support.builtin_wrappers
     libc.src.__support.CPP.bit
     libc.src.__support.CPP.type_traits
     libc.src.__support.uint128
 )
 
 add_header_library(
   xfloat
   HDRS

libc/src/__support/FPUtil/FPBits.h

 //===-- Abstract class for bit manipulation of float numbers. ---*- C++ -*-===//
 //
 // 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_FP_BITS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H
 
 #include "PlatformDefs.h"
 
 #include "src/__support/CPP/bit.h"
 #include "src/__support/CPP/type_traits.h"
-#include "src/__support/FPUtil/builtin_wrappers.h"
+#include "src/__support/builtin_wrappers.h"
 #include "src/__support/common.h"
 
 #include "FloatProperties.h"
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
template <typename T> struct FPBits {
   //   2) The function add to +1 to ep for seamless normalized to denormalized
   //      transition.
   //   3) The function did not check exponent high limit.
   //   4) "number" zero value is not processed correctly.
   //   5) Number is unsigned, so the result can be only positive.
   inline static constexpr FPBits<T> make_value(UIntType number, int ep) {
     FPBits<T> result;
     // offset: +1 for sign, but -1 for implicit first bit
-    int lz = fputil::unsafe_clz(number) - FloatProp::EXPONENT_WIDTH;
+    int lz = unsafe_clz(number) - FloatProp::EXPONENT_WIDTH;
     number <<= lz;
     ep -= lz;
 
     if (likely(ep >= 0)) {
       // Implicit number bit will be removed by mask
       result.set_mantissa(number);
       result.set_unbiased_exponent(ep + 1);
     } else {

libc/src/__support/FPUtil/Hypot.h

 //===-- Implementation of hypotf function ---------------------------------===//
 //
 // 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_HYPOT_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_HYPOT_H
 
 #include "BasicOperations.h"
 #include "FEnvImpl.h"
 #include "FPBits.h"
-#include "builtin_wrappers.h"
 #include "src/__support/CPP/bit.h"
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/UInt128.h"
+#include "src/__support/builtin_wrappers.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
 template <typename T>
 static inline T find_leading_one(T mant, int &shift_length) {

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

 //===-- Common header for FMA implementations -------------------*- C++ -*-===//
 //
 // 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_GENERIC_FMA_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_FMA_H
 
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/FloatProperties.h"
-#include "src/__support/FPUtil/builtin_wrappers.h"
 #include "src/__support/UInt128.h"
+#include "src/__support/builtin_wrappers.h"
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 namespace fputil {
 namespace generic {
 
 template <typename T> static inline T fma(T x, T y, T z);
 

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

 //===-- Common header for fmod implementations ------------------*- C++ -*-===//
 //
 // 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_GENERIC_FMOD_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_FMOD_H
 
 #include "src/__support/CPP/limits.h"
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
-#include "src/__support/FPUtil/builtin_wrappers.h"
+#include "src/__support/builtin_wrappers.h"
 #include "src/__support/common.h"
 #include "src/math/generic/math_utils.h"
 
 namespace __llvm_libc {
 namespace fputil {
 namespace generic {
 
 //  Objective:

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/type_traits.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"
 #include "src/__support/UInt128.h"
+#include "src/__support/builtin_wrappers.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
 template <typename T> struct SpecialLongDouble {
   static constexpr bool VALUE = false;

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

 //===-- Square root of x86 long double numbers ------------------*- C++ -*-===//
 //
 // 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_GENERIC_SQRT_80_BIT_LONG_DOUBLE_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_SQRT_80_BIT_LONG_DOUBLE_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"
 #include "src/__support/UInt128.h"
+#include "src/__support/builtin_wrappers.h"
 
 namespace __llvm_libc {
 namespace fputil {
 namespace x86 {
 
 inline void normalize(int &exponent, UInt128 &mantissa) {
   const int shift =
       unsafe_clz(static_cast<uint64_t>(mantissa)) -

libc/src/__support/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
+#ifndef LLVM_LIBC_SRC_SUPPORT_BUILTIN_WRAPPERS_H
+#define LLVM_LIBC_SRC_SUPPORT_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.
 namespace __internal {
 
 template <typename T> static inline int correct_zero(T val, int bits) {

 template <typename T> static inline int safe_clz(T val) {
   return __internal::correct_zero(val, __internal::clz(val));
 }
 
 template <typename T> static inline int unsafe_clz(T val) {
   return __internal::clz(val);
 }
 
-} // namespace fputil
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_BUILTIN_WRAPPERS_H
+#endif // LLVM_LIBC_SRC_SUPPORT_BUILTIN_WRAPPERS_H

libc/src/__support/str_to_float.h

 //===-- String to float conversion utils ------------------------*- C++ -*-===//
 //
 // 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 LIBC_SRC_SUPPORT_STR_TO_FLOAT_H
 #define LIBC_SRC_SUPPORT_STR_TO_FLOAT_H
 
 #include "src/__support/CPP/limits.h"
 #include "src/__support/FPUtil/FPBits.h"
-#include "src/__support/FPUtil/builtin_wrappers.h"
 #include "src/__support/UInt128.h"
+#include "src/__support/builtin_wrappers.h"
 #include "src/__support/ctype_utils.h"
 #include "src/__support/detailed_powers_of_ten.h"
 #include "src/__support/high_precision_decimal.h"
 #include "src/__support/str_to_integer.h"
 #include <errno.h>
 
 namespace __llvm_libc {
 namespace internal {
template <class T> uint32_t inline leading_zeroes(T inputNumber) {
   }
   if (inputNumber >> cur_guess > 0) {
     cur_guess++;
   }
   return BITS_IN_T - cur_guess;
 }
 
 template <> uint32_t inline leading_zeroes<uint32_t>(uint32_t inputNumber) {
-  return fputil::safe_clz(inputNumber);
+  return safe_clz(inputNumber);
 }
 
 template <> uint32_t inline leading_zeroes<uint64_t>(uint64_t inputNumber) {
-  return fputil::safe_clz(inputNumber);
+  return safe_clz(inputNumber);
 }
 
 static inline uint64_t low64(const UInt128 &num) {
   return static_cast<uint64_t>(num & 0xffffffffffffffff);
 }
 
 static inline uint64_t high64(const UInt128 &num) {
   return static_cast<uint64_t>(num >> 64);

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

cc_library(
     deps = [
         ":__support_cpp_type_traits",
         ":__support_fputil_fp_bits",
         ":libc_root",
     ],
 )
 
 cc_library(
-    name = "__support_fputil_builtin_wrappers",
-    hdrs = ["src/__support/FPUtil/builtin_wrappers.h"],
+    name = "__support_builtin_wrappers",
+    hdrs = ["src/__support/builtin_wrappers.h"],
     deps = [
         ":libc_root",
     ],
 )
 
 cc_library(
     name = "__support_fputil_division_and_remainder_operations",
     hdrs = ["src/__support/FPUtil/DivisionAndRemainderOperations.h"],
cc_library(
     ],
 )
 
 cc_library(
     name = "__support_fputil_fp_bits",
     hdrs = ["src/__support/FPUtil/FPBits.h"],
     textual_hdrs = ["src/__support/FPUtil/x86_64/LongDoubleBits.h"],
     deps = [
+        ":__support_builtin_wrappers",
         ":__support_common",
         ":__support_cpp_bit",
         ":__support_cpp_type_traits",
-        ":__support_fputil_builtin_wrappers",
         ":__support_fputil_float_properties",
         ":__support_fputil_platform_defs",
         ":libc_root",
     ],
 )
 
 cc_library(
     name = "__support_fputil_hypot",
     hdrs = ["src/__support/FPUtil/Hypot.h"],
     deps = [
+        ":__support_builtin_wrappers",
         ":__support_cpp_bit",
         ":__support_cpp_type_traits",
         ":__support_fputil_basic_operations",
-        ":__support_fputil_builtin_wrappers",
         ":__support_fputil_fenv_impl",
         ":__support_fputil_fp_bits",
         ":__support_uint128",
         ":libc_root",
     ],
 )
 
 cc_library(
PLATFORM_CPU_ARM64: sqrt_common_hdrs + [
         "src/__support/FPUtil/aarch64/sqrt.h",
     ],
 })
 
 cc_library(
     name = "__support_fputil_sqrt",
     hdrs = sqrt_hdrs,
     deps = [
+        ":__support_builtin_wrappers",
         ":__support_common",
         ":__support_cpp_bit",
         ":__support_cpp_type_traits",
-        ":__support_fputil_builtin_wrappers",
         ":__support_fputil_fenv_impl",
         ":__support_fputil_fp_bits",
         ":__support_fputil_platform_defs",
         ":__support_uint128",
         ":libc_root",
     ],
 )
 

 
 cc_library(
     name = "__support_fputil_fma",
     hdrs = fma_common_hdrs,
     # These are conditionally included and will #error out if the platform
     # doesn't support FMA, so they can't be compiled on their own.
     textual_hdrs = fma_platform_hdrs,
     deps = [
+        ":__support_builtin_wrappers",
         ":__support_common",
         ":__support_cpp_bit",
         ":__support_cpp_type_traits",
-        ":__support_fputil_builtin_wrappers",
         ":__support_fputil_fenv_impl",
         ":__support_fputil_float_properties",
         ":__support_fputil_fp_bits",
         ":__support_uint128",
         ":libc_root",
     ],
 )
 

utils/bazel/llvm-project-overlay/libc/libc_build_rules.bzl

OLD_FPUTIL_DEPS = [
         ":__support_fputil_fenv_impl",
         ":__support_fputil_fp_bits",
         ":__support_fputil_float_properties",
         ":__support_fputil_hypot",
         ":__support_fputil_manipulation_functions",
         ":__support_fputil_nearest_integer_operations",
         ":__support_fputil_normal_float",
         ":__support_fputil_platform_defs",
-        ":__support_fputil_builtin_wrappers",
+        ":__support_builtin_wrappers",
         ":__support_fputil_except_value_utils",
     ]
     libc_function(
         name = name,
         srcs = selects.with_or(select_map),
         hdrs = ["src/math/" + name + ".h"],
         deps = [":__support_common"] + OLD_FPUTIL_DEPS + additional_deps,
     )