[libc] Replace type punning with bit_cast

[gchatelet]

Summary

Although type punning is defined for union in C, it is UB in C++.
This patch introduces a bit_cast function to convert between types in a safe way.

This is necessary to get llvm-libc compile with GCC.
This patch is extracted from D119002.

[lntue]

libc/src/__support/CPP/Bit.h

35

Extra space around =, and extra closing parenthesis to be removed.

37–39

Is SIZE defined anywhere?

[sivachandra]

libc/src/fenv/fesetexceptflag.cpp

28

I am still confused. Previously, we de-referenced (*flagp) before static-casting it. So, there is no type-punning involved (assuming fexcept_t is of integral type), no? Can you share the error you are seeing?

[gchatelet]

• Address comments

libc/src/__support/CPP/Bit.h

35

Duh!? What happened here...

37–39

Bad copy/paste, thx for noticing.

libc/src/fenv/fesetexceptflag.cpp

28

Oh I see, there is no type punning here indeed. I got confused by using bit_cast that expects both type to have exact same size.

That said this is still implementation defined because of integer conversion from unsigned to signed.

This currently works for GCC and Clang but the standard does not enforce this behavior before c++20.

[gchatelet]

• Remove leftover

[gchatelet]

squash commits and rebase

[gchatelet]

FYI I also had the following constness warning

/redacted/git/llvm-project/libc/src/fenv/fesetexceptflag.cpp: In function ‘int __llvm_libc::__fesetexceptflag_impl__(const fexcept_t*, int)’:
/redacted/git/llvm-project/libc/src/fenv/fesetexceptflag.cpp:23:24: warning: type qualifiers ignored on cast result type [-Wignored-qualifiers]
   23 |   int excepts_to_set = static_cast<const int>(*flagp) & excepts;
      |                        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[gchatelet]

• Add missing change

[sivachandra]

I am not an expert, but normally the word "illegal" in code/commit logs is not preferred as it can imply non-technical errors. So, may be replace it with "incorrect".

[gchatelet]

rebase and change commit message

[gchatelet]

In D119145#3305009, @sivachandra wrote:

I am not an expert, but normally the word "illegal" in code/commit logs is not preferred as it can imply non-technical errors. So, may be replace it with "incorrect".

Thx, I reworded it.

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/memory_utils/CMakeLists.txt

 add_header_library(
   memory_utils
   HDRS
     utils.h
     elements.h
     bcmp_implementations.h
     memcmp_implementations.h
     memcpy_implementations.h
     memset_implementations.h
+  DEPS
+    standalone_cpp
 )
 
 add_header_library(
   memcpy_implementation
   HDRS
     memcpy_implementations.h
   DEPS
     .memory_utils

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) {

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"],