[libc++] Implement C++20's P0476r2: std::bit_cast

[EricWF]

LGTM other than the lack of tests.

We should also figure out what GCC's plan is here, so we can implement a GCC version in future.

libcxx/include/bit

366

We should probably mark this nodiscard.

371

Gosh. __builtin_bit_cast is a weird builtin -- taking a type as the first parameter.

373

#endif // !defined(_LIBCPP_HAS_NO_BUILTIN_BIT_CAST)

libcxx/test/std/numerics/bit/bit.cast/bit_cast.fail.cpp

58

Are these errors emitted inside <bit>? If so, we should specify that here.

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

24

What's the fun stuff?

[ldionne]

Add tests

[ldionne]

Specify that the errors from __builtin_bit_cast come from <bit>

[ldionne]

libcxx/include/bit

366

Marked it with _LIBCPP_NODISCARD_EXT, which we use for nodiscard-as-an-extension.

368

Question: the spec has these as Constraints: -- I think it means these should be used to SFINAE out, not hard-error -- right?

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

24

Writing the tests.

154

@erik.pilkington Any idea why those don't work inside constexpr?

158

@jfb Can you think of other interesting values to test?

197

@erik.pilkington All the tests for long double are failing (at runtime) -- any idea why? Did you implement support for long double in __builtin_bit_cast?

[erik.pilkington]

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

154

Its hitting the isInt() check here: https://github.com/llvm/llvm-project/blob/master/clang/lib/AST/ExprConstant.cpp#L11102. Seems like constexpr __builtin_memcmp was only implemented for integers.

197

Eek, it looks like this is asserting at compile time too. Let me take a closer look.

[jfb]

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

165

Signaling NaN, and NaNs with payloads.
Infinities.
Denormals.

Check this out: https://babbage.cs.qc.cuny.edu/IEEE-754/index.xhtml

195

Some of these won't work on all platforms. You'll need to selectively disable some for platforms that don't have IEEE-754 with the expected sizes.

[erik.pilkington]

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

197

I put a patch up to fix this here: https://reviews.llvm.org/D76323

[tambre]

libcxx/include/bit

368

Correct.

From [structure.specifications] 3.1:

Constraints: the conditions for the function’s participation in overload resolution.

[zoecarver]

This approach may be frowned upon because std::bit_cast is implemented with __builtin_bit_cast but, I think you could actually use __builtin_bit_cast to write the comparison function you want for the tests:

template<class T> struct Buff { char buff[sizeof(T)]; };

template<class T>
constexpr bool cmp(const T &a, const T &b) {
    auto c1 = __builtin_bit_cast(Buff<T>, a);
    auto c2 = __builtin_bit_cast(Buff<T>, b);
    for (unsigned i = 0; i < sizeof(T); ++i) {
        if (c1.buff[i] != c2.buff[i])
            return false;
    }
    return true;
}

libcxx/test/std/numerics/bit/bit.cast/bit_cast.fail.cpp

32

Maybe a deleted copy constructor?

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

44

So, in non-constexpr, the only thing you're testing here is that you can cast a pointer to its current type?

[ldionne]

Rebase onto main and update tests + implementation.

The tests are still not passing, and I have to verify whether it's a Clang
bug or whether the tests are wrong.

libcxx/test/std/numerics/bit/bit.cast/bit_cast.fail.cpp

32

I think that's covered by the test for a type that isn't trivially copyable. If a type is not copyable, then it is not trivially copyable.

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

44

I don't understand. In constexpr mode, the only thing being tested is that the roundtrip from T back to T (through std::bit_cast) works as expected. I'm only unable to test the intermediate results (the char arrays).

However, as of rebasing this patch, it appears that none of it works anymore. So I don't have a way to test bit_cast inside constexpr.

195

I'll see what CI complains about!

[zoecarver]

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

44

This comment was referring to the old patch where there was an is_constant_evaluated condition in the test_buffer_roundtrip function.

209

I assume this means you're against using __builtin_bit_cast to test std::bit_cast? Fair enough.

[ldionne]

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

209

Yes, because std::bit_cast is implemented as a single call to __builtin_bit_cast. I feel like what we're actually testing here is in fact __builtin_bit_cast directly, not just std::bit_cast.

[curdeius]

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

154

Nit: you should probably use long long instead of long so that this test doesn't break on LLP64 data model (Windows). You might use uint64_t as well.

[curdeius]

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

50

Not sure if this adds much value, but can't you additionally test assert(from == middle.x);?
Similarly for middle2.

[zoecarver]

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

209

Fair enough. Ideally, Clang's tests would be sufficient, but I see where you're coming from. I think that makes sense.

Would it make it better if the call to __builtin_bit_cast always casted it to a char array and compared the bytes? That would basically be re-implementing memcmp. If we can verify that the cast to char array always works, then we can use that to test other things, maybe.

[zoecarver]

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

209

Here's a Godbolt. I think the issue is just when you try to compare different pointer types with __builtin_memcmp. I guess the earlier approach where you turned off certain asserts in constexpr mode actually makes sense.

https://godbolt.org/z/ozKn8W

[• Quuxplusone]

Re [[nodiscard]]: hooray!
D99895 provides a Test Ready to Eat for the nodiscardness of bit_cast; once it's landed, you should be able to just rebase, uncomment that test, and add bit_cast to the appropriate list in UsingLibcxx.rst.

[ldionne]

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

50

Since I'm already testing memcmp, I feel like adding an equality test is not super useful. If the bytes are the same, they have to compare equal.

[ldionne]

Rebase onto main. Tests are still going to fail because Clang's __builtin_bit_cast still seems to have issues (I'll try to investigate those in the next week).

[• Quuxplusone]

LGTM % comments, FWIW.

libcxx/include/CMakeLists.txt

96–98 ↗

(On Diff #361296)

Nit: / < _ < a according to ASCII.
But note that we get this wrong for __functional_base vs. __functional/... below. So if you take this nit, maybe fix both places; and/or maybe wonder are we historically sorting by something other than ASCIIbetically?

libcxx/include/__bit/bit_cast.h

29 ↗

(On Diff #361296)

Please _LIBCPP_NODISCARD_EXT, and uncomment the existing test in libcxx/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp which was added by D99895.

Please also add bit_cast to the list in libcxx/docs/UsingLibcxx.rst.

Please also git grep bit_cast libcxx/ and see if there are any more things waiting to be uncommented by this patch.

31 ↗

(On Diff #361296)

Surely this should be guarded by __has_builtin(__builtin_bit_cast). Or is the rationale that we don't need to guard it, because we have no fallback implementation, and so "you get a weird compiler error" is already the best-case outcome on compilers that don't support it? Notice that because _ToType is a type, not a value, you'll get a parse error very eagerly as soon as <bit> is included; it's not merely that you'll get an error when you try to call bit_cast.

It looks like the builtin is supported on Clang 9+ and GCC 11+; it's unsupported on Clang 8- and GCC 10-.

libcxx/test/std/numerics/bit/bit.cast/bit_cast.compile.pass.cpp

36 ↗

(On Diff #361296)

Consider adding things like

static_assert(!bit_cast_is_valid<char[2], From>);  // makes bit_cast's return type invalid
static_assert(!bit_cast_is_valid<int(), From>);  // duh, but might as well check
static_assert(bit_cast_is_valid<From, From>);  // OK, right?
static_assert(!bit_cast_is_valid<From&, From>);  // Not OK???

I'm not sure about the last one. Obviously real production code should use reinterpret_cast, not bit_cast, for such an operation; but I don't know if bit_cast is supposed to accept it or not.

49 ↗

(On Diff #361296)

From() { } is superfluous, right? Remove.
Consider removing the function bodies, too.

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

95

Here you're missing signed char, and below you're missing unsigned char. Also all the charN_t types, not that I'm asking for those.

110

I'm sure there must be supported platforms where long and double are different sizes. (If Linux isn't one, then Windows is probably one; and vice versa.)
...ah, I see, this line simply belongs on line 114 (under long long) instead. Ditto line 132 should be moved to 137.

[Mordante]

libcxx/docs/Status/Cxx20Papers.csv

32 ↗

(On Diff #361296)

This should now become 14.

libcxx/include/__bit/bit_cast.h

28 ↗

(On Diff #361296)

Would it make sense to use concepts instead of _EnableIf?

31 ↗

(On Diff #361296)

AFAIK all supported platforms, including MSVC now support __builtin_bit_cast.

[• Quuxplusone]

@ldionne, is anything in particular blocking this?

[ldionne]

Fix the tests (thanks Arthur)!

libcxx/include/CMakeLists.txt

96–98 ↗

(On Diff #361296)

This is weird indeed, but I'm using VS Code's line sorting functionality. Will leave as-is since otherwise we'll just re-order stuff all the time because we use different sorts.

libcxx/include/__bit/bit_cast.h

28 ↗

(On Diff #361296)

We generally use enable_if for Constraints: in the Standard, so I think I'd stick with that unless there is a benefit in using concepts here.

[• Quuxplusone]

LGTM, just some nitpicky irrelevancies. :) If you're happy with the (lack of) constexpr tests, I say ship it already.

libcxx/docs/UsingLibcxx.rst

305 ↗

(On Diff #371445)

I put this down between as_const and forward, which is a-z among the whatever-paper-that-was casting operators, instead of up here with the STL algorithms. bit_cast is not an STL algorithm.

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

39

I'd checked from,middle and middle,to, in which case transitivity gets us from,to.
(This is just straight comparison of arrays of bytes, so no evil type can trick us here; transitivity definitely applies.)

40

By definition, sizeof(Buffer) equals sizeof(T), or else bit_cast would not compile... right?
I preferred to consistently use T throughout (and below instead of Nested), but I guess it doesn't matter.

254

I guess I meant to try to constexpr-ify tests() but never succeeded. The problems were (I think) with std::nanl and std::memcmp. I think it would be fine to ship this with only the basic_constexpr_test; although you might also try putting the memcmps under if (!std::is_constant_evaluated()) and splitting out the floating-point nan tests into a non-constexpr special test.

[jfb]

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

254

nan will be constexpr if you do bool my_is_nan(double value) { return value != value; }.

[ldionne]

Address review comments and try fixing tests on ARM64

[ldionne]

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

254

As Arthur says, the issue here is really to get a NaN value in constexpr context, which I don't know how to do. The other issue, which is more fundamental, is that we can't use std::memcmp in a constexpr context. And we can't use __builtin_memcmp, because although it *is* constexpr, it can't be used to compare different types, and we can't reinterpret_cast in a constexpr context.

[• Quuxplusone]

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

254

Somewhat circular, but you can define a constexpr-evaluable memcmp in terms of bit_cast. :)
https://godbolt.org/z/49dhW4jzz
The only trick is that it can't take void*, void*, size_t; it must take T*, T*, because even bit_cast doesn't let you cast void* back to SomeOtherType* in a constexpr context.

From my perspective, the lack of memcmp isn't so fundamental, because we can just if out those tests when it's constexpr time. The more awkward programming problem is lines 220-225, where we need to generate an array with a couple different NaNs if it's non-constexpr, but somehow omit generating those array elements when it's constexpr time.
See my solution at D107036 (search for the phrase "specifically positive or negative NAN").

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_void_t``                              ``201411L``      
     ------------------------------------------------- -----------------
     **C++ 2a**                                                         
     -------------------------------------------------------------------
     ``__cpp_lib_atomic_ref``                          *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_bind_front``                          *unimplemented*  
     ------------------------------------------------- -----------------
-    ``__cpp_lib_bit_cast``                            *unimplemented*  
+    ``__cpp_lib_bit_cast``                            ``201806L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_char8_t``                             ``201811L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_concepts``                            *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_misc``                      *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_swap_algorithms``           *unimplemented*  

libcxx/include/__config

 #if !__has_builtin(__builtin_addressof) && _GNUC_VER < 700
 #define _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
 #endif
 
 #if !__has_builtin(__builtin_is_constant_evaluated) && _GNUC_VER < 900
 #define _LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED
 #endif
 
+#if !__has_builtin(__builtin_bit_cast)
+#  define _LIBCPP_HAS_NO_BUILTIN_BIT_CAST
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
 #  if defined(_LIBCPP_MSVCRT) || defined(_NEWLIB_VERSION)
 #    define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS
 #  endif
 #endif
 
 #if __has_attribute(diagnose_if) && !defined(_LIBCPP_DISABLE_ADDITIONAL_DIAGNOSTICS)
 #  define _LIBCPP_DIAGNOSE_WARNING(...) \

libcxx/include/bit

 // -*- C++ -*-
 //===------------------------------ bit ----------------------------------===//
 //
 // 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 _LIBCPP_BIT
 #define _LIBCPP_BIT
 
 /*
     bit synopsis
 
 namespace std {
+    // [bit.cast], bit_cast
+    template<class To, class From>
+      constexpr To bit_cast(const From& from) noexcept; // C++20
 
+  // [bit.pow.two], integral powers of 2
   template <class T>
     constexpr bool ispow2(T x) noexcept; // C++20
   template <class T>
     constexpr T ceil2(T x);              // C++20
   template <class T>
     constexpr T floor2(T x) noexcept;    // C++20
   template <class T>
     constexpr T log2p1(T x) noexcept;    // C++20
 
-  // 23.20.2, rotating
+  // [bit.rotate], rotating
   template<class T>
     constexpr T rotl(T x, unsigned int s) noexcept; // C++20
   template<class T>
     constexpr T rotr(T x, unsigned int s) noexcept; // C++20
 
-  // 23.20.3, counting
+  // [bit.count], counting
   template<class T>
     constexpr int countl_zero(T x) noexcept;  // C++20
   template<class T>
     constexpr int countl_one(T x) noexcept;   // C++20
   template<class T>
     constexpr int countr_zero(T x) noexcept;  // C++20
   template<class T>
     constexpr int countr_one(T x) noexcept;   // C++20
   template<class T>
     constexpr int popcount(T x) noexcept;     // C++20
 
-  // 20.15.9, endian
+  // [bit.endian], endian
   enum class endian {
     little = see below,        // C++20
     big = see below,           // C++20
     native = see below         // C++20
 };
 
 } // namespace std
 
unsigned __bit_log2(_Tp __t) _NOEXCEPT
     return std::numeric_limits<_Tp>::digits - 1 - __countl_zero(__t);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 bool __ispow2(_Tp __t) _NOEXCEPT
 {
     static_assert(__bitop_unsigned_integer<_Tp>::value, "__ispow2 requires unsigned");
-  return __t != 0 && (((__t & (__t - 1)) == 0));
+    return __t != 0 && (((__t & (__t - 1)) == 0));
 }
 
 
 #if _LIBCPP_STD_VER > 17
 
+#if !defined(_LIBCPP_HAS_NO_BUILTIN_BIT_CAST)
+template<class _ToType, class _FromType>
+_LIBCPP_INLINE_VISIBILITY
+constexpr _ToType bit_cast(_FromType const& __from) noexcept
+{
+    static_assert(sizeof(_ToType) == sizeof(_FromType));
+    static_assert(is_trivially_copyable_v<_ToType>);
+    static_assert(is_trivially_copyable_v<_FromType>);
+    return __builtin_bit_cast(_ToType, __from);
+}
+#endif
+
 template<class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr
 enable_if_t<__bitop_unsigned_integer<_Tp>::value, _Tp>
 rotl(_Tp __t, unsigned int __cnt) noexcept
 {
     return __rotl(__t, __cnt);
 }
 

libcxx/include/version

 # define __cpp_lib_void_t                               201411L
 #endif
 
 #if _LIBCPP_STD_VER > 17
 # if !defined(_LIBCPP_HAS_NO_THREADS)
 // #   define __cpp_lib_atomic_ref                         201806L
 # endif
 // # define __cpp_lib_bind_front                           201811L
-// # define __cpp_lib_bit_cast                             201806L
+# if !defined(_LIBCPP_HAS_NO_BUILTIN_BIT_CAST)
+#   define __cpp_lib_bit_cast                           201806L
+# endif
 # if !defined(_LIBCPP_NO_HAS_CHAR8_T)
 #   define __cpp_lib_char8_t                            201811L
 # endif
 // # define __cpp_lib_concepts                             201806L
 // # define __cpp_lib_constexpr_misc                       201811L
 // # define __cpp_lib_constexpr_swap_algorithms            201806L
 # if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
 #   define __cpp_lib_destroying_delete                  201806L
 # endif
 # define __cpp_lib_endian                               201907L
 # define __cpp_lib_erase_if                             201811L
 // # define __cpp_lib_generic_unordered_lookup             201811L
 # define __cpp_lib_interpolate                          201902L
 # if !defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)
 #   define __cpp_lib_is_constant_evaluated              201811L
 # endif
 // # define __cpp_lib_list_remove_return_type              201806L
 // # define __cpp_lib_ranges                               201811L
-# define __cpp_lib_to_array                                201907L
 // # define __cpp_lib_three_way_comparison                 201711L
+# define __cpp_lib_to_array                             201907L
 #endif
 
 #endif // _LIBCPP_VERSIONH

libcxx/test/std/language.support/support.limits/support.limits.general/bit.version.pass.cpp

 # endif
 
 # ifdef __cpp_lib_endian
 #   error "__cpp_lib_endian should not be defined before c++2a"
 # endif
 
 #elif TEST_STD_VER > 17
 
-# if !defined(_LIBCPP_VERSION)
+# if TEST_HAS_BUILTIN(__builtin_bit_cast)
 #   ifndef __cpp_lib_bit_cast
 #     error "__cpp_lib_bit_cast should be defined in c++2a"
 #   endif
 #   if __cpp_lib_bit_cast != 201806L
 #     error "__cpp_lib_bit_cast should have the value 201806L in c++2a"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_bit_cast should not be defined when TEST_HAS_BUILTIN(__builtin_bit_cast) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_endian
 #   error "__cpp_lib_endian should be defined in c++2a"
 # endif
 # if __cpp_lib_endian != 201907L
 #   error "__cpp_lib_endian should have the value 201907L in c++2a"
 # endif
 
 #endif // TEST_STD_VER > 17
 
 int main(int, char**) { return 0; }

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

 #     error "__cpp_lib_bind_front should have the value 201811L in c++2a"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_bind_front
 #     error "__cpp_lib_bind_front should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
+# if TEST_HAS_BUILTIN(__builtin_bit_cast)
 #   ifndef __cpp_lib_bit_cast
 #     error "__cpp_lib_bit_cast should be defined in c++2a"
 #   endif
 #   if __cpp_lib_bit_cast != 201806L
 #     error "__cpp_lib_bit_cast should have the value 201806L in c++2a"
 #   endif
-# else // _LIBCPP_VERSION
+# else
 #   ifdef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
+#     error "__cpp_lib_bit_cast should not be defined when TEST_HAS_BUILTIN(__builtin_bit_cast) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_bool_constant
 #   error "__cpp_lib_bool_constant should be defined in c++2a"
 # endif
 # if __cpp_lib_bool_constant != 201505L
 #   error "__cpp_lib_bool_constant should have the value 201505L in c++2a"

libcxx/test/std/numerics/bit/bit.cast/bit_cast.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// REQUIRES: verify-support
+
+// <bit>
+//
+// template<class To, class From>
+//   constexpr To bit_cast(const From& from) noexcept; // C++20
+
+// This test makes sure that std::bit_cast fails when any of the following
+// constraints are violated:
+//
+//      (1.1) sizeof(To) == sizeof(From) is true;
+//      (1.2) is_trivially_copyable_v<To> is true;
+//      (1.3) is_trivially_copyable_v<From> is true.
+
+#include <bit>
+#include <cassert>
+#include <cstdint>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    // Not the same size
+    {
+        struct To { char a; };
+        struct From { char a; char b; };
+        From from;
+        (void)std::bit_cast<To>(from); // expected-error@bit:* {{static_assert failed due to requirement 'sizeof(To) == sizeof(From)'}}
+    }
+
+    // To is not trivially copyable
+    {
+        struct To { char a; To(To const& x) : a(x.a) { } };
+        struct From { char a; };
+        From from;
+        (void)std::bit_cast<To>(from); // expected-error@bit:* {{static_assert failed due to requirement 'is_trivially_copyable_v<To>'}}
+    }
+
+    // From is not trivially copyable
+    {
+        struct To { char a; };
+        struct From { char a; From() { } From(From const& x) : a(x.a) { } };
+        From from;
+        (void)std::bit_cast<To>(from); // expected-error@bit:* {{static_assert failed due to requirement 'is_trivially_copyable_v<From>'}}
+    }
+
+    // Disregard the error messages given by __builtin_bit_cast, if any.
+    // __builtin_bit_cast is an implementation detail of libc++.
+    // expected-error@* 0-3 {{__builtin_bit_cast}}
+
+    return 0;
+}

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <bit>
+//
+// template<class To, class From>
+//   constexpr To bit_cast(const From& from) noexcept; // C++20
+
+#include <bit>
+#include <cassert>
+#include <cstdint>
+
+#include "test_macros.h"
+
+constexpr bool tests() {
+    // TODO fun stuff
+    return true;
+}
+
+static_assert(tests());
+
+int main(int, char**)
+{
+    tests();
+    return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = sorted([ add_version_header(x) for x in [
    "headers": ["algorithm", "functional", "iterator", "memory", "ranges"],
    "unimplemented": True,
    },
   {"name": "__cpp_lib_bit_cast",
    "values": {
      "c++2a": int(201806),
    },
    "headers": ["bit"],
-   "unimplemented": True,
+   "depends": "TEST_HAS_BUILTIN(__builtin_bit_cast)",
+   "internal_depends": "!defined(_LIBCPP_HAS_NO_BUILTIN_BIT_CAST)",
    },
   {"name": "__cpp_lib_atomic_ref",
    "values": {
      "c++2a": int(201806),
    },
    "headers": ["atomic"],
    "unimplemented": True,
    "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",

libcxx/www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/P0858R0">P0858R0</a></td><td>LWG</td><td>Constexpr iterator requirements</td><td>Jacksonville</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0905R1">P0905R1</a></td><td>CWG</td><td>Symmetry for spaceship</td><td>Jacksonville</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0966R1">P0966R1</a></td><td>LWG</td><td><tt>string::reserve</tt> Should Not Shrink</td><td>Jacksonville</td><td>Complete</td><td>8.0</td></tr>
 
     <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0019R8">P0019R8</a></td><td>LWG</td><td>Atomic Ref</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0458R2">P0458R2</a></td><td>LWG</td><td>Checking for Existence of an Element in Associative Containers</td><td>Rapperswil</td><td>Complete</td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0475R1">P0475R1</a></td><td>LWG</td><td>LWG 2511: guaranteed copy elision for piecewise construction</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0476R2">P0476R2</a></td><td>LWG</td><td>Bit-casting object representations</td><td>Rapperswil</td><td></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P0476R2">P0476R2</a></td><td>LWG</td><td>Bit-casting object representations</td><td>Rapperswil</td><td>Complete</td><td>10.0</td></tr>
   <tr><td><a href="https://wg21.link/P0528R3">P0528R3</a></td><td>CWG</td><td>The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0542R5">P0542R5</a></td><td>CWG</td><td>Support for contract based programming in C++</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0556R3">P0556R3</a></td><td>LWG</td><td>Integral power-of-2 operations</td><td>Rapperswil</td><td>Complete</td><td>9.0</td></tr>
   <tr><td><a href="https://wg21.link/P0619R4">P0619R4</a></td><td>LWG</td><td>Reviewing Deprecated Facilities of C++17 for C++20</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0646R1">P0646R1</a></td><td>LWG</td><td>Improving the Return Value of Erase-Like Algorithms</td><td>Rapperswil</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0722R3">P0722R3</a></td><td>CWG</td><td>Efficient sized delete for variable sized classes</td><td>Rapperswil</td><td>Complete</td><td>9.0</td></tr>
   <tr><td><a href="https://wg21.link/P0758R1">P0758R1</a></td><td>LWG</td><td>Implicit conversion traits and utility functions</td><td>Rapperswil</td><td>Complete</td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0759R1">P0759R1</a></td><td>LWG</td><td>fpos Requirements</td><td>Rapperswil</td><td></td><td></td></tr>