[libc] Fix compilation with gcc

[gchatelet]

Summary

We may want to break this patch into smaller independent pieces but it's easier to have the full perspective first.

1. Type punning is used throughout llvmlibc but this is undefined behavior in C++ (e.g. FPUtils using FP/Integral union)
2. Clang is happy with vector type conversions in elements_x86.h but vector types are slightly different in GCC and so bit casting is necessary.
3. Some compilation options were only available in Clang, preventing compilation with GCC.

I still have compilation issues with an asm statement and link errors so I'll iterate a bit more on the patch.

[gchatelet]

libc/src/math/generic/log10f.cpp

167

This is just a copy, right? This could be FPBits f = xbits;

[lntue]

libc/src/math/generic/log10f.cpp

167

Yes, it's just a copy.

[sivachandra]

Thanks for doing this. As you have mentioned in the description, please split this into independent patches.

libc/src/__support/FPUtil/FPBits.h

108–112

To be consistent with other getters, we might want to call this get_val.

libc/src/__support/FPUtil/x86_64/LongDoubleBits.h

99

While here, can we make these constructors constexpr?

libc/src/__support/builtin_bit_cast.h

22 ↗

(On Diff #405972)

Few comments, some of them might just be bikeshed kind:

1. Why should the name have builtin in it? For that matter, remove the llvmlibc_ prefix and put it in a namespace.
2. constexpr instead of static?
3. This should ideally be in __support/CPP/bit.h?

libc/src/__support/builtin_memcpy.h

21 ↗

(On Diff #405972)

Seems like we can just inline this into llvmlibc_bit_cast?

libc/src/fenv/fesetexceptflag.cpp

30

Why is this required?

libc/utils/MPFRWrapper/MPFRUtils.cpp

486

Why was this block moved?

[sivachandra]

While doing this cleanup is great, I think protecting against slipping is also important. So, a few things that need to be done in parallel or as immediate follow ups:

1. Update developer guidance on how and what to build and test as part of their development workflows.
2. Update or add CI builders to protect against slipping.

[gchatelet]

• Address comments

[gchatelet]

In D119002#3297298, @sivachandra wrote:

While doing this cleanup is great, I think protecting against slipping is also important. So, a few things that need to be done in parallel or as immediate follow ups:

1. Update developer guidance on how and what to build and test as part of their development workflows.
2. Update or add CI builders to protect against slipping.

For type punning not all compilers warn about it, do you mean we should ask developers to test their code against both Clang and GCC? I think we should have this covered by the CI.

Also I'm seeing build error for Bazel that weren't there before, any idea why? Which headers should be picked for <stddef.h> and similar headers?

 % bazelisk-linux-amd64 test --sandbox_base=/dev/shm --config=generic_clang @llvm-project//libc:all
INFO: Analyzed 254 targets (15 packages loaded, 591 targets configured).
INFO: Found 254 targets and 0 test targets...
ERROR: /redacted/.cache/bazel/_bazel_gchatelet/903566bd2da61ef16af7f3375ea676d6/external/llvm-project/libc/BUILD.bazel:572:14: Compiling libc/src/stdlib/bsearch.cpp failed: undeclared inclusion(s) in rule '@llvm-project//libc:bsearch':
this rule is missing dependency declarations for the following files included by 'libc/src/stdlib/bsearch.cpp':
  '/usr/lib/clang/13.0.1/include/stddef.h'
  '/usr/lib/clang/13.0.1/include/stdint.h'

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

36–37

@lntue I had to use +t here for gcc to be happy.
https://stackoverflow.com/a/53680288

libc/src/fenv/fesetexceptflag.cpp

30

sizeof(fexcept_t) is unknown as it depends on the opaque fexcept_t data type.
When I tried to bitcast *flagp into an int I had a static assert failure from bit_cast implementation that sizeof(fexcept_t) != sizeof(int), it turns out that on my system sizeof(fexcept_t) != sizeof(int16_t).
So for the bitcast to be correct we need to pick the right integral type and then convert it to int.
I've selected int16_t and int32_t but we may need to provide other integral types depending on sizeof(fexcept_t)

libc/utils/MPFRWrapper/MPFRUtils.cpp

486

Explicit template instantiation cannot be declared within the class itself. It has to be defined outside of the class.

[gchatelet]

• Fix Bazel build

[gchatelet]

In D119002#3300263, @gchatelet wrote:

Also I'm seeing build error for Bazel that weren't there before, any idea why? Which headers should be picked for <stddef.h> and similar headers?

 % bazelisk-linux-amd64 test --sandbox_base=/dev/shm --config=generic_clang @llvm-project//libc:all
INFO: Analyzed 254 targets (15 packages loaded, 591 targets configured).
INFO: Found 254 targets and 0 test targets...
ERROR: /redacted/.cache/bazel/_bazel_gchatelet/903566bd2da61ef16af7f3375ea676d6/external/llvm-project/libc/BUILD.bazel:572:14: Compiling libc/src/stdlib/bsearch.cpp failed: undeclared inclusion(s) in rule '@llvm-project//libc:bsearch':
this rule is missing dependency declarations for the following files included by 'libc/src/stdlib/bsearch.cpp':
  '/usr/lib/clang/13.0.1/include/stddef.h'
  '/usr/lib/clang/13.0.1/include/stdint.h'

This seems to be related to caching. This is now fixed.

[gchatelet]

• Fixed typo and documentation

[lntue]

libc/src/__support/CPP/Bit.h

36–43

Nit: alignment

[gchatelet]

• Fix wrong code alignment

[gchatelet]

Since most of the comments here have been fixed, I'll split the patch, one for each issue. We can continue the discussion on the individual patches.

[sivachandra]

In D119002#3300263, @gchatelet wrote:

For type punning not all compilers warn about it, do you mean we should ask developers to test their code against both Clang and GCC? I think we should have this covered by the CI.

You have kind of provided GCC compilation as the motivation for your changes. My view is that, all of your changes are good even without GCC in picture. So, couple of things about this:

1. We could add those flags by default when the compiler supports it. But if this has the potential to hinder the development cycle, for example it stops experimenting with type punning, then we should have a CMake flag to enable/disable the compiler flags. Iff we chose the route of providing a CMake flag, that is when my point about developer guidance becomes relevant.
2. The CI should cover them of course, but it also means that developers should know how to reproduce the errors when they happen.

[gchatelet]

This patch has been broken down and submitted:

• D119142: [libc][NFC] moving template specialization outside class declaration
• D119143: [libc] Don't use Clang flags on other compilers
• D119145: [libc] Replace type punning with bit_cast.
• D119242: [libc] undefined reference in LibcTest.cpp.

libc/src/__support/CPP/Bit.h

+//===-- Freestanding version of bit_cast  -----------------------*- 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_SUPPORT_CPP_BIT_H
+#define LLVM_LIBC_SUPPORT_CPP_BIT_H
+
+namespace __llvm_libc {
+
+#if defined __has_builtin
+#if __has_builtin(__builtin_bit_cast)
+#define LLVM_LIBC_HAS_BUILTIN_BIT_CAST
+#endif
+#endif
+
+#if defined __has_builtin
+#if __has_builtin(__builtin_memcpy_inline)
+#define LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE
+#endif
+#endif
+
+// This function guarantees the bitcast to be optimized away by the compiler for
+// GCC >= 8 and Clang >= 6.
+template <class To, class From> constexpr To bit_cast(const From &from) {
+  static_assert(sizeof(To) == sizeof(From), "To and From must be of same size");
+#if defined(LLVM_LIBC_HAS_BUILTIN_BIT_CAST)
+  return __builtin_bit_cast(To, from);
+#else
+  To to;
+  char *dst = reinterpret_cast<char *>(&to);
+  const char* src=reinterpret_cast<const char *>(&from));
+#if defined(LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE)
+  __builtin_memcpy_inline(dst, src, SIZE);
+#else
+  for (unsigned i = 0; i < SIZE; ++i)
+    dst[i] = src[i];
+#endif // defined(LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE)
+  return to;
+#endif // defined(LLVM_LIBC_HAS_BUILTIN_BIT_CAST)
+}
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SUPPORT_CPP_BIT_H

libc/src/__support/CPP/CMakeLists.txt

 add_header_library(
   standalone_cpp
   HDRS
     Array.h
     ArrayRef.h
+    Bit.h
     Bitset.h
     Functional.h
+    Limits.h
     StringView.h
     TypeTraits.h
-    Limits.h
 )

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/TypeTraits.h"
 
 #include "FloatProperties.h"
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <typename T> struct MantissaWidth {
   static constexpr unsigned VALUE = FloatProperties<T>::MANTISSA_WIDTH;
 };
 
 template <typename T> struct ExponentWidth {
   static constexpr unsigned VALUE = FloatProperties<T>::EXPONENT_WIDTH;
 };
 
 // A generic class to represent single precision, double precision, and quad
 // precision IEEE 754 floating point formats.
 // On most platforms, the 'float' type corresponds to single precision floating
 // point numbers, the 'double' type corresponds to double precision floating
 // point numers, and the 'long double' type corresponds to the quad precision
 // floating numbers. On x86 platforms however, the 'long double' type maps to
 // an x87 floating point format. This format is an IEEE 754 extension format.
 // It is handled as an explicit specialization of this class.
-template <typename T> union FPBits {
+template <typename T> struct FPBits {
   static_assert(cpp::IsFloatingPointType<T>::Value,
                 "FPBits instantiated with invalid type.");
 
   // Reinterpreting bits as an integer value and interpreting the bits of an
   // integer value as a floating point value is used in tests. So, a convenient
   // type is provided for such reinterpretations.
   using FloatProp = FloatProperties<T>;
   // TODO: Change UintType name to BitsType for consistency.
void set_sign(bool signVal) {
     bits &= ~(FloatProp::SIGN_MASK);
     UIntType sign = UIntType(signVal) << (FloatProp::BIT_WIDTH - 1);
     bits |= sign;
   }
 
   bool get_sign() const {
     return ((bits & FloatProp::SIGN_MASK) >> (FloatProp::BIT_WIDTH - 1));
   }
-  T val;
 
   static_assert(sizeof(T) == sizeof(UIntType),
                 "Data type and integral representation have different sizes.");
 
   static constexpr int EXPONENT_BIAS = (1 << (ExponentWidth<T>::VALUE - 1)) - 1;
   static constexpr int MAX_EXPONENT = (1 << ExponentWidth<T>::VALUE) - 1;
 
   static constexpr UIntType MIN_SUBNORMAL = UIntType(1);
   static constexpr UIntType MAX_SUBNORMAL =
       (UIntType(1) << MantissaWidth<T>::VALUE) - 1;
   static constexpr UIntType MIN_NORMAL =
       (UIntType(1) << MantissaWidth<T>::VALUE);
   static constexpr UIntType MAX_NORMAL =
       ((UIntType(MAX_EXPONENT) - 1) << MantissaWidth<T>::VALUE) | MAX_SUBNORMAL;
 
   // We don't want accidental type promotions/conversions so we require exact
   // type match.
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<T, XType>::Value, int> = 0>
-  explicit FPBits(XType x) : val(x) {}
+  constexpr explicit FPBits(XType x)
+      : bits(__llvm_libc::bit_cast<UIntType>(x)) {}
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<XType, UIntType>::Value, int> = 0>
-  explicit FPBits(XType x) : bits(x) {}
+  constexpr explicit FPBits(XType x) : bits(x) {}
 
   FPBits() : bits(0) {}
 
-  explicit operator T() { return val; }
+  T get_val() const { return __llvm_libc::bit_cast<T>(bits); }
+
+  void set_val(T value) { bits = __llvm_libc::bit_cast<UIntType>(value); }
+
+  explicit operator T() const { return get_val(); }
 
   UIntType uintval() const { return bits; }
 
   int get_exponent() const {
     return int(get_unbiased_exponent()) - EXPONENT_BIAS;
   }
 
   bool is_zero() const {

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 "src/__support/CPP/Bit.h"
 #include "src/__support/CPP/TypeTraits.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
 template <typename T>
if (y_new >= (ONE >> 1)) {
     y_new -= ONE >> 1;
     ++out_exp;
     if (out_exp >= FPBits_t::MAX_EXPONENT) {
       return T(FPBits_t::inf());
     }
   }
 
   y_new |= static_cast<UIntType>(out_exp) << MantissaWidth<T>::VALUE;
-  return *reinterpret_cast<T *>(&y_new);
+  return __llvm_libc::bit_cast<T>(y_new);
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_HYPOT_H

libc/src/__support/FPUtil/ManipulationFunctions.h

 //===-- Floating-point manipulation functions -------------------*- 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_MANIPULATION_FUNCTIONS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_MANIPULATION_FUNCTIONS_H
 
 #include "FPBits.h"
 #include "NearestIntegerOperations.h"
 #include "NormalFloat.h"
 #include "PlatformDefs.h"
 
+#include "src/__support/CPP/Bit.h"
 #include "src/__support/CPP/TypeTraits.h"
 
 #include <limits.h>
 #include <math.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
if ((from < to) == (from > T(0.0))) {
       ++int_val;
     } else {
       --int_val;
     }
   } else {
     int_val = (to_bits.uintval() & sign_mask) + UIntType(1);
   }
 
-  return *reinterpret_cast<T *>(&int_val);
+  return __llvm_libc::bit_cast<T>(int_val);
   // TODO: Raise floating point exceptions as required by the standard.
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #ifdef SPECIAL_X86_LONG_DOUBLE
 #include "x86_64/NextAfterLongDouble.h"
 #endif // SPECIAL_X86_LONG_DOUBLE
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_MANIPULATION_FUNCTIONS_H

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

 //===-- Square root of IEEE 754 floating point 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_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"
 
 namespace __llvm_libc {
 namespace fputil {
 
if (bits.is_inf_or_nan()) {
           ++y;
         break;
       case FE_UPWARD:
         if (rb || (r != 0))
           ++y;
         break;
       }
 
-      return *reinterpret_cast<T *>(&y);
+      return __llvm_libc::bit_cast<T>(y);
     }
   }
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_GENERIC_SQRT_H

libc/src/__support/FPUtil/x86_64/LongDoubleBits.h

 //===-- Bit representation 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_X86_64_LONG_DOUBLE_BITS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_LONG_DOUBLE_BITS_H
 
+#include "src/__support/CPP/Bit.h"
 #include "src/__support/architectures.h"
 
 #if !defined(LLVM_LIBC_ARCH_X86)
 #error "Invalid include"
 #endif
 
 #include "src/__support/FPUtil/FPBits.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 template <unsigned Width> struct Padding;
 
 // i386 padding.
 template <> struct Padding<4> { static constexpr unsigned VALUE = 16; };
 
 // x86_64 padding.
 template <> struct Padding<8> { static constexpr unsigned VALUE = 48; };
 
-template <> union FPBits<long double> {
+template <> struct FPBits<long double> {
   using UIntType = __uint128_t;
 
   static constexpr int EXPONENT_BIAS = 0x3FFF;
   static constexpr int MAX_EXPONENT = 0x7FFF;
   static constexpr UIntType MIN_SUBNORMAL = UIntType(1);
   // Subnormal numbers include the implicit bit in x86 long double formats.
   static constexpr UIntType MAX_SUBNORMAL =
       (UIntType(1) << (MantissaWidth<long double>::VALUE)) - 1;
void set_sign(bool signVal) {
     UIntType sign1 = UIntType(signVal) << (FloatProp::BIT_WIDTH - 1);
     bits |= sign1;
   }
 
   bool get_sign() const {
     return ((bits & FloatProp::SIGN_MASK) >> (FloatProp::BIT_WIDTH - 1));
   }
 
-  long double val;
-
   FPBits() : bits(0) {}
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<long double, XType>::Value, int> = 0>
-  explicit FPBits(XType x) : val(x) {
+  explicit FPBits(XType x) : bits(__llvm_libc::bit_cast<UIntType>(x)) {
     // bits starts uninitialized, and setting it to a long double only
     // overwrites the first 80 bits. This clears those upper bits.
     bits = bits & ((UIntType(1) << 80) - 1);
   }
 
   template <typename XType,
             cpp::EnableIfType<cpp::IsSame<XType, UIntType>::Value, int> = 0>
   explicit FPBits(XType x) : bits(x) {}
 
-  operator long double() { return val; }
+  operator long double() { return __llvm_libc::bit_cast<long double>(bits); }
 
   UIntType uintval() {
     // We zero the padding bits as they can contain garbage.
     static constexpr UIntType MASK =
         (UIntType(1) << (sizeof(long double) * 8 -
                          Padding<sizeof(uintptr_t)>::VALUE)) -
         1;
     return bits & MASK;

libc/src/__support/FPUtil/x86_64/NextAfterLongDouble.h

 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_NEXT_AFTER_LONG_DOUBLE_H
 
 #include "src/__support/architectures.h"
 
 #if !defined(LLVM_LIBC_ARCH_X86)
 #error "Invalid include"
 #endif
 
+#include "src/__support/CPP/Bit.h"
 #include "src/__support/FPUtil/FPBits.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace fputil {
 
 static inline long double nextafter(long double from, long double to) {
if (from > to) {
         from_bits.set_unbiased_exponent(from_bits.get_unbiased_exponent() + 1);
         return from_bits;
       } else {
         ++int_val;
       }
     }
   }
 
-  return *reinterpret_cast<long double *>(&int_val);
+  return __llvm_libc::bit_cast<long double>(int_val);
   // TODO: Raise floating point exceptions as required by the standard.
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_NEXT_AFTER_LONG_DOUBLE_H

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

 
 template <> inline double sqrt<double>(double x) {
   double result;
   __asm__ __volatile__("sqrtsd %x1, %x0" : "=x"(result) : "x"(x));
   return result;
 }
 
 template <> inline long double sqrt<long double>(long double x) {
-  long double result;
-  __asm__ __volatile__("fsqrt" : "=t"(result) : "t"(x));
-  return result;
+  __asm__ __volatile__("fsqrt" : "+t"(x));
+  return x;
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_SQRT_H

libc/src/fenv/fesetexceptflag.cpp

 //===-- Implementation of fesetexceptflag 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/fenv/fesetexceptflag.h"
+#include "src/__support/CPP/Bit.h"
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/common.h"
 
 #include <fenv.h>
 
 namespace __llvm_libc {
 
+template <unsigned SIZE> struct TypeSelector {};
+template <> struct TypeSelector<2> { using type = int16_t; };
+template <> struct TypeSelector<4> { using type = int32_t; };
+
 LLVM_LIBC_FUNCTION(int, fesetexceptflag,
                    (const fexcept_t *flagp, int excepts)) {
   // Since the return type of fetestexcept is int, we ensure that fexcept_t
   // can fit in int type.
   static_assert(sizeof(int) >= sizeof(fexcept_t),
                 "fexcept_t value cannot fit in an int value.");
-  int excepts_to_set = static_cast<const int>(*flagp) & excepts;
+  using IntType = TypeSelector<sizeof(fexcept_t)>::type;
+  const int excepts_as_int = __llvm_libc::bit_cast<IntType>(*flagp);
+  const int excepts_to_set = excepts_as_int & excepts;
   fputil::clear_except(FE_ALL_EXCEPT);
   return fputil::set_except(excepts_to_set);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/log10f.cpp

if (xbits.uintval() < FPBits::MIN_NORMAL ||
     }
     if (xbits.get_sign() && !xbits.is_nan()) {
       return FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
     }
     if (xbits.is_inf_or_nan()) {
       return x;
     }
     // Normalize denormal inputs.
-    xbits.val *= 0x1.0p23f;
+    xbits.set_val(xbits.get_val() * 0x1.0p23f);
     m -= 23.0;
   }
 
   m += static_cast<double>(xbits.get_exponent());
   // Set bits to 1.m
   xbits.set_unbiased_exponent(0x7F);
   int f_index = xbits.get_mantissa() >> 16;
 
-  FPBits f(xbits.val);
+  FPBits f = xbits;
   f.bits &= ~0x0000'FFFF;
 
   double d = static_cast<float>(xbits) - static_cast<float>(f);
   d *= ONE_OVER_F[f_index];
 
   double extra_factor = fputil::fma(m, LOG10_2, LOG10_F[f_index]);
 
   double r = fputil::polyeval(d, extra_factor, 0x1.bcb7b1526e4c5p-2,
                               -0x1.bcb7b1518a5e9p-3, 0x1.287a72a6f716p-3,
                               -0x1.bcadb40b85565p-4, 0x1.5e0bc97f97e22p-4);
 
   return static_cast<float>(r);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/log2f.cpp

if (xbits.uintval() < FPBits::MIN_NORMAL ||
     }
     if (xbits.get_sign() && !xbits.is_nan()) {
       return FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
     }
     if (xbits.is_inf_or_nan()) {
       return x;
     }
     // Normalize denormal inputs.
-    xbits.val *= 0x1.0p23f;
+    xbits.set_val(xbits.get_val() * 0x1.0p23f);
     m = -23;
   }
 
   m += xbits.get_exponent();
   // Set bits to 1.m
   xbits.set_unbiased_exponent(0x7F);
   // Get the 8 highest bits, use 7 bits (excluding the implicit hidden bit) for
   // lookup tables.
   int f_index = xbits.get_mantissa() >> 16;
 
-  FPBits f(xbits.val);
+  FPBits f = xbits;
   // Clear the lowest 16 bits.
   f.bits &= ~0x0000'FFFF;
 
   double d = static_cast<float>(xbits) - static_cast<float>(f);
   d *= ONE_OVER_F[f_index];
 
   double extra_factor = static_cast<double>(m) + LOG2_F[f_index];
   double r = __llvm_libc::fputil::polyeval(
       d, extra_factor, 0x1.71547652bd4fp+0, -0x1.7154769b978c7p-1,
       0x1.ec71a99e349c8p-2, -0x1.720d90e6aac6cp-2, 0x1.5132da3583dap-2);
 
   return static_cast<float>(r);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/logf.cpp

if (xbits.uintval() < FPBits::MIN_NORMAL ||
     }
     if (xbits.get_sign() && !xbits.is_nan()) {
       return FPBits::build_nan(1 << (fputil::MantissaWidth<float>::VALUE - 1));
     }
     if (xbits.is_inf_or_nan()) {
       return x;
     }
     // Normalize denormal inputs.
-    xbits.val *= 0x1.0p23f;
+    xbits.set_val(xbits.get_val() * 0x1.0p23f);
     m = -23;
   }
 
   m += xbits.get_exponent();
   // Set bits to 1.m
   xbits.set_unbiased_exponent(0x7F);
   int f_index = xbits.get_mantissa() >> 16;
 
-  FPBits f(xbits.val);
+  FPBits f = xbits;
   f.bits &= ~0x0000'FFFF;
 
   double d = static_cast<float>(xbits) - static_cast<float>(f);
   d *= ONE_OVER_F[f_index];
 
   double extra_factor =
       fputil::fma(static_cast<double>(m), LOG_2, LOG_F[f_index]);
 
   double r = __llvm_libc::fputil::polyeval(
       d, extra_factor, 0x1.fffffffffffacp-1, -0x1.fffffffef9cb2p-2,
       0x1.5555513bc679ap-2, -0x1.fff4805ea441p-3, 0x1.930180dbde91ap-3);
 
   return static_cast<float>(r);
 }
 
 } // namespace __llvm_libc

libc/src/math/generic/math_utils.h

 //===-- Collection of utils for implementing math functions -----*- 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_MATH_MATH_UTILS_H
 #define LLVM_LIBC_SRC_MATH_MATH_UTILS_H
 
+#include "src/__support/CPP/Bit.h"
 #include "src/__support/CPP/TypeTraits.h"
 #include "src/__support/common.h"
 #include <errno.h>
 #include <math.h>
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 static inline uint32_t as_uint32_bits(float x) {
-  return *reinterpret_cast<uint32_t *>(&x);
+  return __llvm_libc::bit_cast<uint32_t>(x);
 }
 
 static inline uint64_t as_uint64_bits(double x) {
-  return *reinterpret_cast<uint64_t *>(&x);
+  return __llvm_libc::bit_cast<uint64_t>(x);
 }
 
 static inline float as_float(uint32_t x) {
-  return *reinterpret_cast<float *>(&x);
+  return __llvm_libc::bit_cast<float>(x);
 }
 
 static inline double as_double(uint64_t x) {
-  return *reinterpret_cast<double *>(&x);
+  return __llvm_libc::bit_cast<double>(x);
 }
 
 static inline uint32_t top12_bits(float x) { return as_uint32_bits(x) >> 20; }
 
 static inline uint32_t top12_bits(double x) { return as_uint64_bits(x) >> 52; }
 
 // Values to trigger underflow and overflow.
 template <typename T> struct XFlowValues;

libc/src/string/CMakeLists.txt

 # - Declares an entry point,
 # - Attach the REQUIRE_CPU_FEATURES property to the target,
 # - Add the fully qualified target to `${name}_implementations` global property for tests.
 function(add_implementation name impl_name)
   cmake_parse_arguments(
     "ADD_IMPL"
     "" # Optional arguments
     "" # Single value arguments
-    "REQUIRE;SRCS;HDRS;DEPENDS;COMPILE_OPTIONS" # Multi value arguments
+    "REQUIRE;SRCS;HDRS;DEPENDS;COMPILE_OPTIONS;MLLVM_COMPILE_OPTIONS" # Multi value arguments
     ${ARGN})
+
+  if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+    list(APPEND ADD_IMPL_MLLVM_COMPILE_OPTIONS "-combiner-global-alias-analysis")
+    # Note that '-mllvm' needs to be prefixed with 'SHELL:' to prevent CMake flag deduplication.
+    foreach(opt IN LISTS ADD_IMPL_MLLVM_COMPILE_OPTIONS)
+      list(APPEND ADD_IMPL_COMPILE_OPTIONS "SHELL:-mllvm ${opt}")
+    endforeach()
+  endif()
+
   add_entrypoint_object(${impl_name}
     NAME ${name}
     SRCS ${ADD_IMPL_SRCS}
     HDRS ${ADD_IMPL_HDRS}
     DEPENDS ${ADD_IMPL_DEPENDS}
-    COMPILE_OPTIONS ${ADD_IMPL_COMPILE_OPTIONS} "SHELL:-mllvm -combiner-global-alias-analysis"
+    COMPILE_OPTIONS ${ADD_IMPL_COMPILE_OPTIONS}
   )
   get_fq_target_name(${impl_name} fq_target_name)
   set_target_properties(${fq_target_name} PROPERTIES REQUIRE_CPU_FEATURES "${ADD_IMPL_REQUIRE}")
   set_property(GLOBAL APPEND PROPERTY "${name}_implementations" "${fq_target_name}")
 endfunction()
 
 # ------------------------------------------------------------------------------
 # bcmp
if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_memcpy(memcpy_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
   add_memcpy(memcpy_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)
   add_memcpy(memcpy_x86_64_opt_avx2   COMPILE_OPTIONS -march=haswell        REQUIRE AVX2)
   add_memcpy(memcpy_x86_64_opt_avx512 COMPILE_OPTIONS -march=skylake-avx512 REQUIRE AVX512F)
   add_memcpy(memcpy_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
   add_memcpy(memcpy)
 elseif(${LIBC_TARGET_ARCHITECTURE_IS_AARCH64})
   # Disable tail merging as it leads to lower performance.
-  # Note that '-mllvm' needs to be prefixed with 'SHELL:' to prevent CMake flag deduplication.
   add_memcpy(memcpy_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE}
-                                      COMPILE_OPTIONS "SHELL:-mllvm --tail-merge-threshold=0")
-  add_memcpy(memcpy                   COMPILE_OPTIONS "SHELL:-mllvm --tail-merge-threshold=0")
+                                      MLLVM_COMPILE_OPTIONS "-tail-merge-threshold=0")
+  add_memcpy(memcpy                   MLLVM_COMPILE_OPTIONS "-tail-merge-threshold=0")
 else()
   add_memcpy(memcpy_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
   add_memcpy(memcpy)
 endif()
 
 # ------------------------------------------------------------------------------
 # memmove
 # ------------------------------------------------------------------------------
if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_memmove(memmove_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
   add_memmove(memmove_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)
   add_memmove(memmove_x86_64_opt_avx2   COMPILE_OPTIONS -march=haswell        REQUIRE AVX2)
   add_memmove(memmove_x86_64_opt_avx512 COMPILE_OPTIONS -march=skylake-avx512 REQUIRE AVX512F)
   add_memmove(memmove_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
   add_memmove(memmove)
 elseif(${LIBC_TARGET_ARCHITECTURE_IS_AARCH64})
   # Disable tail merging as it leads to lower performance.
-  # Note that '-mllvm' needs to be prefixed with 'SHELL:' to prevent CMake flag deduplication.
   add_memmove(memmove_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE}
-                                        COMPILE_OPTIONS "SHELL:-mllvm --tail-merge-threshold=0")
-  add_memmove(memmove                   COMPILE_OPTIONS "SHELL:-mllvm --tail-merge-threshold=0")
+                                        MLLVM_COMPILE_OPTIONS "-tail-merge-threshold=0")
+  add_memmove(memmove                   MLLVM_COMPILE_OPTIONS "-tail-merge-threshold=0")
 else()
   add_memmove(memmove_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
   add_memmove(memmove)
 endif()
 
 # ------------------------------------------------------------------------------
 # memset
 # ------------------------------------------------------------------------------

 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_memset(memset_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
   add_memset(memset_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)
   add_memset(memset_x86_64_opt_avx2   COMPILE_OPTIONS -march=haswell        REQUIRE AVX2)
   add_memset(memset_x86_64_opt_avx512 COMPILE_OPTIONS -march=skylake-avx512 REQUIRE AVX512F)
   add_memset(memset_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
   add_memset(memset)
 elseif(${LIBC_TARGET_ARCHITECTURE_IS_AARCH64})
+  # Disable tail merging as it leads to lower performance.
   add_memset(memset_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE}
-                                      COMPILE_OPTIONS "SHELL:-mllvm --tail-merge-threshold=0")
-  add_memset(memset                   COMPILE_OPTIONS "SHELL:-mllvm --tail-merge-threshold=0")
+                                      MLLVM_COMPILE_OPTIONS "-tail-merge-threshold=0")
+  add_memset(memset                   MLLVM_COMPILE_OPTIONS "-tail-merge-threshold=0")
 else()
   add_memset(memset_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
   add_memset(memset)
 endif()

libc/src/string/memory_utils/elements_x86.h

 //===-- Elementary operations for x86 -------------------------------------===//
 //
 // 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_STRING_MEMORY_UTILS_ELEMENTS_X86_H
 #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_ELEMENTS_X86_H
 
+#include "src/__support/CPP/Bit.h"
 #include "src/__support/architectures.h"
 
 #if defined(LLVM_LIBC_ARCH_X86)
 
 #include <stddef.h> // size_t
 #include <stdint.h> // uint8_t, uint16_t, uint32_t, uint64_t
 
 #ifdef __SSE2__
template <typename Base> struct Vector : public Base {
   }
 };
 
 struct M128 {
   static constexpr size_t SIZE = 16;
   using T = char __attribute__((__vector_size__(SIZE)));
   static uint16_t mask(T value) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
-    return _mm_movemask_epi8(value);
+    return _mm_movemask_epi8(__llvm_libc::bit_cast<__m128i>(value));
   }
   static uint16_t not_equal_mask(T a, T b) { return mask(a != b); }
   static T load(const char *ptr) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
-    return _mm_loadu_si128(reinterpret_cast<__m128i_u const *>(ptr));
+    return __llvm_libc::bit_cast<T>(
+        _mm_loadu_si128(reinterpret_cast<__m128i_u const *>(ptr)));
   }
   static void store(char *ptr, T value) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
-    return _mm_storeu_si128(reinterpret_cast<__m128i_u *>(ptr), value);
+    return _mm_storeu_si128(reinterpret_cast<__m128i_u *>(ptr),
+                            __llvm_libc::bit_cast<__m128i>(value));
   }
   static T get_splatted_value(const char v) {
     const T splatted = {v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v};
     return splatted;
   }
 };
 
 using Vector128 = Vector<M128>; // 16 Bytes
 
 #ifdef __AVX2__
 struct M256 {
   static constexpr size_t SIZE = 32;
   using T = char __attribute__((__vector_size__(SIZE)));
   static uint32_t mask(T value) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
-    return _mm256_movemask_epi8(value);
+    return _mm256_movemask_epi8(__llvm_libc::bit_cast<__m256i>(value));
   }
   static uint32_t not_equal_mask(T a, T b) { return mask(a != b); }
   static T load(const char *ptr) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
-    return _mm256_loadu_si256(reinterpret_cast<__m256i const *>(ptr));
+    return __llvm_libc::bit_cast<T>(
+        _mm256_loadu_si256(reinterpret_cast<__m256i const *>(ptr)));
   }
   static void store(char *ptr, T value) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
-    return _mm256_storeu_si256(reinterpret_cast<__m256i *>(ptr), value);
+    return _mm256_storeu_si256(reinterpret_cast<__m256i *>(ptr),
+                               __llvm_libc::bit_cast<__m256i>(value));
   }
   static T get_splatted_value(const char v) {
     const T splatted = {v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v,
                         v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v};
     return splatted;
   }
 };
 
 using Vector256 = Vector<M256>; // 32 Bytes
 
 #if defined(__AVX512F__) and defined(__AVX512BW__)
 struct M512 {
   static constexpr size_t SIZE = 64;
   using T = char __attribute__((__vector_size__(SIZE)));
   static uint64_t not_equal_mask(T a, T b) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
-    return _mm512_cmpneq_epi8_mask(a, b);
+    return _mm512_cmpneq_epi8_mask(__llvm_libc::bit_cast<__m512i>(a),
+                                   __llvm_libc::bit_cast<__m512i>(b));
   }
   static T load(const char *ptr) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
-    return _mm512_loadu_epi8(ptr);
+    return __llvm_libc::bit_cast<T>(_mm512_loadu_epi8(ptr));
   }
   static void store(char *ptr, T value) {
     // NOLINTNEXTLINE(llvmlibc-callee-namespace)
-    return _mm512_storeu_epi8(ptr, value);
+    return _mm512_storeu_epi8(ptr, __llvm_libc::bit_cast<__m512i>(value));
   }
   static T get_splatted_value(const char v) {
     const T splatted = {v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v,
                         v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v,
                         v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v,
                         v, v, v, v, v, v, v, v, v, v, v, v, v, v, v, v};
     return splatted;
   }

libc/test/src/math/NextAfterTest.h

 //===-- Utility class to test different flavors of nextafter ----*- 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_TEST_SRC_MATH_NEXTAFTERTEST_H
 #define LLVM_LIBC_TEST_SRC_MATH_NEXTAFTERTEST_H
 
+#include "src/__support/CPP/Bit.h"
 #include "src/__support/CPP/TypeTraits.h"
 #include "src/__support/FPUtil/BasicOperations.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "utils/UnitTest/FPMatcher.h"
 #include "utils/UnitTest/Test.h"
 #include <math.h>
 
 template <typename T>
public:
   void testBoundaries(NextAfterFunc func) {
     ASSERT_FP_EQ(func(zero, neg_zero), neg_zero);
     ASSERT_FP_EQ(func(neg_zero, zero), zero);
 
     // 'from' is zero|neg_zero.
     T x = zero;
     T result = func(x, T(1));
     UIntType expected_bits = 1;
-    T expected = *reinterpret_cast<T *>(&expected_bits);
+    T expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
 
     result = func(x, T(-1));
     expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + 1;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
 
     x = neg_zero;
     result = func(x, 1);
     expected_bits = 1;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
 
     result = func(x, -1);
     expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + 1;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
 
     // 'from' is max subnormal value.
-    x = *reinterpret_cast<const T *>(&max_subnormal);
+    x = __llvm_libc::bit_cast<T>(max_subnormal);
     result = func(x, 1);
-    expected = *reinterpret_cast<const T *>(&min_normal);
+    expected = __llvm_libc::bit_cast<T>(min_normal);
     ASSERT_FP_EQ(result, expected);
 
     result = func(x, 0);
     expected_bits = max_subnormal - 1;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
 
     x = -x;
 
     result = func(x, -1);
     expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + min_normal;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
 
     result = func(x, 0);
     expected_bits =
         (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + max_subnormal - 1;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
 
     // 'from' is min subnormal value.
-    x = *reinterpret_cast<const T *>(&min_subnormal);
+    x = __llvm_libc::bit_cast<T>(min_subnormal);
     result = func(x, 1);
     expected_bits = min_subnormal + 1;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
     ASSERT_FP_EQ(func(x, 0), 0);
 
     x = -x;
     result = func(x, -1);
     expected_bits =
         (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + min_subnormal + 1;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
     ASSERT_FP_EQ(func(x, 0), T(-0.0));
 
     // 'from' is min normal.
-    x = *reinterpret_cast<const T *>(&min_normal);
+    x = __llvm_libc::bit_cast<T>(min_normal);
     result = func(x, 0);
     expected_bits = max_subnormal;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
 
     result = func(x, inf);
     expected_bits = min_normal + 1;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
 
     x = -x;
     result = func(x, 0);
     expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + max_subnormal;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
 
     result = func(x, -inf);
     expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + min_normal + 1;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
 
     // 'from' is max normal and 'to' is infinity.
-    x = *reinterpret_cast<const T *>(&max_normal);
+    x = __llvm_libc::bit_cast<T>(max_normal);
     result = func(x, inf);
     ASSERT_FP_EQ(result, inf);
 
     result = func(-x, -inf);
     ASSERT_FP_EQ(result, -inf);
 
     // 'from' is infinity.
     x = inf;
     result = func(x, 0);
     expected_bits = max_normal;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
     ASSERT_FP_EQ(func(x, inf), inf);
 
     x = neg_inf;
     result = func(x, 0);
     expected_bits = (UIntType(1) << (BIT_WIDTH_OF_TYPE - 1)) + max_normal;
-    expected = *reinterpret_cast<T *>(&expected_bits);
+    expected = __llvm_libc::bit_cast<T>(expected_bits);
     ASSERT_FP_EQ(result, expected);
     ASSERT_FP_EQ(func(x, neg_inf), neg_inf);
 
     // 'from' is a power of 2.
     x = T(32.0);
     result = func(x, 0);
     FPBits x_bits = FPBits(x);
     FPBits result_bits = FPBits(result);

libc/test/src/math/SqrtTest.h

 //===-- Utility class to test sqrt[f|l] -------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
+#include "src/__support/CPP/Bit.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
 #include "utils/UnitTest/Test.h"
 
 #include <math.h>
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
for (UIntType mant = 1; mant < HIDDEN_BIT; mant <<= 1) {
       denormal.set_mantissa(mant);
 
       test_all_rounding_modes(func, T(denormal));
     }
 
     constexpr UIntType COUNT = 1'000'001;
     constexpr UIntType STEP = HIDDEN_BIT / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
-      T x = *reinterpret_cast<T *>(&v);
+      T x = __llvm_libc::bit_cast<T>(v);
       test_all_rounding_modes(func, x);
     }
   }
 
   void test_normal_range(SqrtFunc func) {
     constexpr UIntType COUNT = 10'000'001;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
-      T x = *reinterpret_cast<T *>(&v);
+      T x = __llvm_libc::bit_cast<T>(v);
       if (isnan(x) || (x < 0)) {
         continue;
       }
       test_all_rounding_modes(func, x);
     }
   }
 
   void test_all_rounding_modes(SqrtFunc func, T x) {

libc/utils/MPFRWrapper/MPFRUtils.cpp

std::string str() const {
     cpp::StringView view(buffer);
     view = view.trim(' ');
     return std::string(view.data());
   }
 
   // These functions are useful for debugging.
   template <typename T> T as() const;
 
-  template <> float as<float>() const {
-    return mpfr_get_flt(value, mpfr_rounding);
-  }
-  template <> double as<double>() const {
-    return mpfr_get_d(value, mpfr_rounding);
-  }
-  template <> long double as<long double>() const {
-    return mpfr_get_ld(value, mpfr_rounding);
-  }
-
   void dump(const char *msg) const { mpfr_printf("%s%.128Rf\n", msg, value); }
 
   // Return the ULP (units-in-the-last-place) difference between the
   // stored MPFR and a floating point number.
   //
   // We define ULP difference as follows:
   //   If exponents of this value and the |input| are same, then:
   //     ULP(this_value, input) = abs(this_value - input) / eps(input)
mpfr_mul_2si(maxMPFR.value, maxMPFR.value,
                  -maxExponent + int(fputil::MantissaWidth<T>::VALUE),
                  MPFR_RNDN);
 
     mpfr_add(minMPFR.value, minMPFR.value, maxMPFR.value, MPFR_RNDN);
     return minMPFR.as<double>();
   }
 };
 
+template <> float MPFRNumber::as<float>() const {
+  return mpfr_get_flt(value, mpfr_rounding);
+}
+
+template <> double MPFRNumber::as<double>() const {
+  return mpfr_get_d(value, mpfr_rounding);
+}
+
+template <> long double MPFRNumber::as<long double>() const {
+  return mpfr_get_ld(value, mpfr_rounding);
+}
+
 namespace internal {
 
 template <typename InputType>
 cpp::EnableIfType<cpp::IsFloatingPointType<InputType>::Value, MPFRNumber>
 unary_operation(Operation op, InputType input, unsigned int precision,
                 RoundingMode rounding) {
   MPFRNumber mpfrInput(input, precision, rounding);
   switch (op) {

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

cc_library(
     ],
 )
 
 cc_library(
     name = "__support_standalone_cpp",
     hdrs = [
         "src/__support/CPP/Array.h",
         "src/__support/CPP/ArrayRef.h",
+        "src/__support/CPP/Bit.h",
         "src/__support/CPP/Bitset.h",
         "src/__support/CPP/Functional.h",
         "src/__support/CPP/Limits.h",
         "src/__support/CPP/StringView.h",
         "src/__support/CPP/TypeTraits.h",
     ],
     deps = [":libc_root"],
 )
cc_library(
     textual_hdrs = [
         "src/string/memory_utils/bcmp_implementations.h",
         "src/string/memory_utils/memcmp_implementations.h",
         "src/string/memory_utils/memcpy_implementations.h",
         "src/string/memory_utils/memset_implementations.h",
     ],
     deps = [
         ":__support_common",
+        ":__support_standalone_cpp",
         ":libc_root",
     ],
 )
 
 libc_function(
     name = "memchr",
     srcs = ["src/string/memchr.cpp"],
     hdrs = ["src/string/memchr.h"],