[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

230

We should probably mark this nodiscard.

235

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

237

#endif // !defined(_LIBCPP_HAS_NO_BUILTIN_BIT_CAST)

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

58 ↗

(On Diff #249494)

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

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

25

What's the fun stuff?

[ldionne]

Add tests

[ldionne]

Specify that the errors from __builtin_bit_cast come from <bit>

[ldionne]

libcxx/include/bit

230

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

232

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

25

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

232

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

31 ↗

(On Diff #250245)

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

31 ↗

(On Diff #250245)

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

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

30

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.

32

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

37

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.

50

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

This should now become 14.

libcxx/include/__bit/bit_cast.h

29

Would it make sense to use concepts instead of _EnableIf?

32

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

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

29

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

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_atomic_value_initialization``         ``201911L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_atomic_wait``                         ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_barrier``                             ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_bind_front``                          ``201907L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_bit_cast``                            *unimplemented*
+    ``__cpp_lib_bit_cast``                            ``201806L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_bitops``                              *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_bounded_array_traits``                ``201902L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_char8_t``                             ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_concepts``                            ``202002L``

libcxx/docs/Status/Cxx20Papers.csv

 "`P0809R0 <https://wg21.link/P0809R0>`__","LWG","Comparing Unordered Containers","Jacksonville","|Nothing To Do|",""
 "`P0858R0 <https://wg21.link/P0858R0>`__","LWG","Constexpr iterator requirements","Jacksonville","",""
 "`P0905R1 <https://wg21.link/P0905R1>`__","CWG","Symmetry for spaceship","Jacksonville","",""
 "`P0966R1 <https://wg21.link/P0966R1>`__","LWG","``string::reserve``\  Should Not Shrink","Jacksonville","|Complete| [#note-P0966]_","12.0"
 "","","","","",""
 "`P0019R8 <https://wg21.link/P0019R8>`__","LWG","Atomic Ref","Rapperswil","",""
 "`P0458R2 <https://wg21.link/P0458R2>`__","LWG","Checking for Existence of an Element in Associative Containers","Rapperswil","|Complete|","13.0"
 "`P0475R1 <https://wg21.link/P0475R1>`__","LWG","LWG 2511: guaranteed copy elision for piecewise construction","Rapperswil","|Complete|",""
-"`P0476R2 <https://wg21.link/P0476R2>`__","LWG","Bit-casting object representations","Rapperswil","",""
+"`P0476R2 <https://wg21.link/P0476R2>`__","LWG","Bit-casting object representations","Rapperswil","|Complete|","14.0"
 "`P0528R3 <https://wg21.link/P0528R3>`__","CWG","The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange","Rapperswil","",""
 "`P0542R5 <https://wg21.link/P0542R5>`__","CWG","Support for contract based programming in C++","Rapperswil","*Removed in Cologne*","n/a"
 "`P0556R3 <https://wg21.link/P0556R3>`__","LWG","Integral power-of-2 operations","Rapperswil","|Complete|","9.0"
 "`P0619R4 <https://wg21.link/P0619R4>`__","LWG","Reviewing Deprecated Facilities of C++17 for C++20","Rapperswil","|Partial| [#note-P0619]_",""
 "`P0646R1 <https://wg21.link/P0646R1>`__","LWG","Improving the Return Value of Erase-Like Algorithms","Rapperswil","|Complete|","10.0"
 "`P0722R3 <https://wg21.link/P0722R3>`__","CWG","Efficient sized delete for variable sized classes","Rapperswil","|Complete|","9.0"
 "`P0758R1 <https://wg21.link/P0758R1>`__","LWG","Implicit conversion traits and utility functions","Rapperswil","|Complete|",""
 "`P0759R1 <https://wg21.link/P0759R1>`__","LWG","fpos Requirements","Rapperswil","|Complete|","11.0"

 "`P2116 <https://wg21.link/P2116>`__","LWG","Remove tuple-like protocol support from fixed-extent span","Prague","|Complete|","11.0"
 "`P2231 <https://wg21.link/P2231>`__","LWG","Missing constexpr in std::optional and std::variant","February 2021","|In progress|","13.0"
 "`P2325 <https://wg21.link/P2325>`__","LWG","Views should not be required to be default constructible","June 2021","|In progress|",""
 "`P2210R2 <https://wg21.link/P2210R2>`__","LWG",Superior String Splitting,"June 2021","",""
 "`P2216R3 <https://wg21.link/P2216R3>`__","LWG",std::format improvements,"June 2021","",""
 "`P2281R1 <https://wg21.link/P2281R1>`__","LWG",Clarifying range adaptor objects,"June 2021","",""
 "`P2328R1 <https://wg21.link/P2328R1>`__","LWG",join_view should join all views of ranges,"June 2021","",""
 "`P2367R0 <https://wg21.link/P2367R0>`__","LWG",Remove misuses of list-initialization from Clause 24,"June 2021","",""
 No newline at end of file

libcxx/docs/UsingLibcxx.rst

 
 This section lists all extended applications of ``[[nodiscard]]`` to entities
 which no dialect declares as such (See the second form described above).
 
 * ``adjacent_find``
 * ``all_of``
 * ``any_of``
 * ``binary_search``
 * ``clamp``
 * ``count_if``
 * ``count``
 * ``equal_range``
 * ``equal``
 * ``find_end``
 * ``find_first_of``
 * ``find_if_not``
 * ``find_if``

 * ``remove_if``
 * ``remove``
 * ``search_n``
 * ``search``
 * ``unique``
 * ``upper_bound``
 * ``lock_guard``'s constructors
 * ``as_const``
+* ``bit_cast``
 * ``forward``
 * ``move``
 * ``move_if_noexcept``
 * ``identity::operator()``
 * ``to_integer``
 * ``to_underlying``

libcxx/include/CMakeLists.txt

set(files
   __algorithm/stable_sort.h
   __algorithm/swap_ranges.h
   __algorithm/transform.h
   __algorithm/unique_copy.h
   __algorithm/unique.h
   __algorithm/unwrap_iter.h
   __algorithm/upper_bound.h
   __availability
   __bit_reference
+  __bit/bit_cast.h
   __bits
   __bsd_locale_defaults.h
   __bsd_locale_fallbacks.h
   __charconv/chars_format.h
   __charconv/from_chars_result.h
   __charconv/to_chars_result.h
   __compare/common_comparison_category.h
   __compare/compare_three_way_result.h
   __compare/ordering.h

libcxx/include/__bit/bit_cast.h

+// -*- 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 _LIBCPP___BIT_BIT_CAST_H
+#define _LIBCPP___BIT_BIT_CAST_H
+
+#include <__config>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+template<class _ToType, class _FromType, class = enable_if_t<
+  sizeof(_ToType) == sizeof(_FromType) &&
+  is_trivially_copyable_v<_ToType> &&
+  is_trivially_copyable_v<_FromType>
+>>
+_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI
+constexpr _ToType bit_cast(_FromType const& __from) noexcept {
+    return __builtin_bit_cast(_ToType, __from);
+}
+
+#endif // _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___BIT_BIT_CAST_H

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 has_single_bit(T x) noexcept; // C++20
   template <class T>
     constexpr T bit_ceil(T x);                   // C++20
   template <class T>
     constexpr T bit_floor(T x) noexcept;         // C++20
enum class endian {
     big = see below,           // C++20
     native = see below         // C++20
 };
 
 } // namespace std
 
 */
 
-#include <__config>
+#include <__bit/bit_cast.h>
 #include <__bits> // __libcpp_clz
+#include <__config>
 #include <__debug>
 #include <limits>
 #include <type_traits>
 #include <version>
 
 #if defined(__IBMCPP__)
 #include "__support/ibm/support.h"
 #endif
bool __has_single_bit(_Tp __t) _NOEXCEPT
     return __t != 0 && (((__t & (__t - 1)) == 0));
 }
 
 #if _LIBCPP_STD_VER > 17
 
 template<class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr
 enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value, _Tp>
 rotl(_Tp __t, unsigned int __cnt) noexcept
 {
     return __rotl(__t, __cnt);
 }
 
 template<class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr
 enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value, _Tp>
 rotr(_Tp __t, unsigned int __cnt) noexcept
 {
     return __rotr(__t, __cnt);
 }
 
 template<class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr
 enable_if_t<__libcpp_is_unsigned_integer<_Tp>::value, int>

libcxx/include/module.modulemap

module std [system] {
   module barrier {
     requires cplusplus14
     header "barrier"
     export *
   }
   module bit {
     header "bit"
     export *
+
+    module __bit {
+      module bit_cast { private header "__bit/bit_cast.h" }
+    }
   }
   module bitset {
     header "bitset"
     export string
     export iosfwd
     export *
   }
   // No submodule for cassert. It fundamentally needs repeated, textual inclusion.

libcxx/include/version

 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)
 #   define __cpp_lib_atomic_wait                        201907L
 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)
 #   define __cpp_lib_barrier                            201907L
 # endif
 # define __cpp_lib_bind_front                           201907L
-// # define __cpp_lib_bit_cast                             201806L
+# define __cpp_lib_bit_cast                             201806L
 // # define __cpp_lib_bitops                               201907L
 # define __cpp_lib_bounded_array_traits                 201902L
 # if !defined(_LIBCPP_HAS_NO_CHAR8_T)
 #   define __cpp_lib_char8_t                            201811L
 # endif
 # define __cpp_lib_concepts                             202002L
 # define __cpp_lib_constexpr_algorithms                 201806L
 // # define __cpp_lib_constexpr_complex                    201711L

libcxx/test/libcxx/diagnostics/detail.headers/bit/bit_cast.module.verify.cpp

+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__bit/bit_cast.h'}}
+#include <__bit/bit_cast.h>

libcxx/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp

 // This test intentionally leaks memory, so it is unsupported under ASAN.
 // UNSUPPORTED: asan
 
 // All entities to which libc++ applies [[nodiscard]] as an extension should
 // be tested here and in nodiscard_extensions.fail.cpp. They should also
 // be listed in `UsingLibcxx.rst` in the documentation for the extension.
 
 #include <algorithm>
+#include <bit> // bit_cast
 #include <cstddef> // to_integer
 #include <functional> // identity
 #include <iterator>
 #include <memory>
 #include <utility> // to_underlying
 
 #include "test_macros.h"
 

 #if TEST_STD_VER >= 20
   std::identity()(lv);
   std::identity()(rv);
 #endif
 }
 
 void test_nontemplate_cast_wrappers()
 {
-#if TEST_STD_VER >= 17
+#if TEST_STD_VER > 14
   std::byte b{42};
   std::to_integer<int>(b);
 #endif
 
-#if TEST_STD_VER >= 20
-  // std::bit_cast<unsigned int>(42);
+#if TEST_STD_VER > 17
+  std::bit_cast<unsigned int>(42);
 #endif
 
 #if TEST_STD_VER > 20
   enum E { Apple, Orange } e = Apple;
   std::to_underlying(e);
 #endif
 }
 

libcxx/test/libcxx/diagnostics/nodiscard_extensions.verify.cpp

 
 // All entities to which libc++ applies [[nodiscard]] as an extension should
 // be tested here and in nodiscard_extensions.pass.cpp. They should also
 // be listed in `UsingLibcxx.rst` in the documentation for the extension.
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_NODISCARD
 
 #include <algorithm>
+#include <bit> // bit_cast
 #include <cstddef> // to_integer
 #include <functional> // identity
 #include <iterator>
 #include <memory>
 #include <utility> // to_underlying
 
 #include "test_macros.h"
 
#if TEST_STD_VER >= 20
   std::identity()(lv);
   // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::identity()(rv);
 #endif
 }
 
 void test_nontemplate_cast_wrappers()
 {
-#if TEST_STD_VER >= 17
+#if TEST_STD_VER > 14
   std::byte b{42};
   // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::to_integer<int>(b);
 #endif
 
-#if TEST_STD_VER >= 20
-  // std::bit_cast<unsigned int>(42);
+#if TEST_STD_VER > 17
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  std::bit_cast<unsigned int>(42);
 #endif
 
 #if TEST_STD_VER > 20
   enum E { Apple, Orange } e = Apple;
   // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   std::to_underlying(e);
 #endif
 }

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

 # endif
 
 # ifdef __cpp_lib_int_pow2
 #   error "__cpp_lib_int_pow2 should not be defined before c++20"
 # endif
 
 #elif TEST_STD_VER == 20
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should be defined in c++20"
-#   endif
-#   if __cpp_lib_bit_cast != 201806L
-#     error "__cpp_lib_bit_cast should have the value 201806L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should be defined in c++20"
+# endif
+# if __cpp_lib_bit_cast != 201806L
+#   error "__cpp_lib_bit_cast should have the value 201806L in c++20"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_bitops
 #     error "__cpp_lib_bitops should be defined in c++20"
 #   endif
 #   if __cpp_lib_bitops != 201907L
 #     error "__cpp_lib_bitops should have the value 201907L in c++20"
 #   endif

 #   error "__cpp_lib_int_pow2 should be defined in c++20"
 # endif
 # if __cpp_lib_int_pow2 != 202002L
 #   error "__cpp_lib_int_pow2 should have the value 202002L in c++20"
 # endif
 
 #elif TEST_STD_VER > 20
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should be defined in c++2b"
-#   endif
-#   if __cpp_lib_bit_cast != 201806L
-#     error "__cpp_lib_bit_cast should have the value 201806L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should be defined in c++2b"
+# endif
+# if __cpp_lib_bit_cast != 201806L
+#   error "__cpp_lib_bit_cast should have the value 201806L in c++2b"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_bitops
 #     error "__cpp_lib_bitops should be defined in c++2b"
 #   endif
 #   if __cpp_lib_bitops != 201907L
 #     error "__cpp_lib_bitops should have the value 201907L in c++2b"
 #   endif

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

 
 # ifndef __cpp_lib_bind_front
 #   error "__cpp_lib_bind_front should be defined in c++20"
 # endif
 # if __cpp_lib_bind_front != 201907L
 #   error "__cpp_lib_bind_front should have the value 201907L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should be defined in c++20"
-#   endif
-#   if __cpp_lib_bit_cast != 201806L
-#     error "__cpp_lib_bit_cast should have the value 201806L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should be defined in c++20"
+# endif
+# if __cpp_lib_bit_cast != 201806L
+#   error "__cpp_lib_bit_cast should have the value 201806L in c++20"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_bitops
 #     error "__cpp_lib_bitops should be defined in c++20"
 #   endif
 #   if __cpp_lib_bitops != 201907L
 #     error "__cpp_lib_bitops should have the value 201907L in c++20"
 #   endif

 
 # ifndef __cpp_lib_bind_front
 #   error "__cpp_lib_bind_front should be defined in c++2b"
 # endif
 # if __cpp_lib_bind_front != 201907L
 #   error "__cpp_lib_bind_front should have the value 201907L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should be defined in c++2b"
-#   endif
-#   if __cpp_lib_bit_cast != 201806L
-#     error "__cpp_lib_bit_cast should have the value 201806L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bit_cast
-#     error "__cpp_lib_bit_cast should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_bit_cast
+#   error "__cpp_lib_bit_cast should be defined in c++2b"
+# endif
+# if __cpp_lib_bit_cast != 201806L
+#   error "__cpp_lib_bit_cast should have the value 201806L in c++2b"
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_bitops
 #     error "__cpp_lib_bitops should be defined in c++2b"
 #   endif
 #   if __cpp_lib_bitops != 201907L
 #     error "__cpp_lib_bitops should have the value 201907L in c++2b"
 #   endif

libcxx/test/std/numerics/bit/bit.cast/bit_cast.compile.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++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// <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.
+//
+// Also check that it's ill-formed when the return type would be
+// ill-formed, even though that is not explicitly mentioned in the
+// specification (but it can be inferred from the synopsis).
+
+#include <bit>
+#include <concepts>
+
+template<class To, class From>
+concept bit_cast_is_valid = requires(From from) {
+    { std::bit_cast<To>(from) } -> std::same_as<To>;
+};
+
+// Types are not the same size
+namespace ns1 {
+    struct To { char a; };
+    struct From { char a; char b; };
+    static_assert(!bit_cast_is_valid<To, From>);
+    static_assert(!bit_cast_is_valid<From&, From>);
+}
+
+// To is not trivially copyable
+namespace ns2 {
+    struct To { char a; To(To const&); };
+    struct From { char a; };
+    static_assert(!bit_cast_is_valid<To, From>);
+}
+
+// From is not trivially copyable
+namespace ns3 {
+    struct To { char a; };
+    struct From { char a; From(From const&); };
+    static_assert(!bit_cast_is_valid<To, From>);
+}
+
+// The return type is ill-formed
+namespace ns4 {
+    struct From { char a; char b; };
+    static_assert(!bit_cast_is_valid<char[2], From>);
+    static_assert(!bit_cast_is_valid<int(), From>);
+}

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++03, c++11, c++14, c++17
+
+// <bit>
+//
+// template<class To, class From>
+//   constexpr To bit_cast(const From& from) noexcept; // C++20
+
+#include <array>
+#include <bit>
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+// std::bit_cast does not preserve padding bits, so if T has padding bits,
+// the results might not memcmp cleanly.
+template<bool HasUniqueObjectRepresentations = true, typename T>
+void test_roundtrip_through_buffer(T from) {
+    struct Buffer { char buffer[sizeof(T)]; };
+    Buffer middle = std::bit_cast<Buffer>(from);
+    T to = std::bit_cast<T>(middle);
+    Buffer middle2 = std::bit_cast<Buffer>(to);
+
+    assert((from == to) == (from == from)); // because NaN
+
+    if constexpr (HasUniqueObjectRepresentations) {
+        assert(std::memcmp(&from, &middle, sizeof(T)) == 0);
+        assert(std::memcmp(&to, &middle, sizeof(T)) == 0);
+        assert(std::memcmp(&middle, &middle2, sizeof(T)) == 0);
+    }
+}
+
+template<bool HasUniqueObjectRepresentations = true, typename T>
+void test_roundtrip_through_nested_T(T from) {
+    struct Nested { T x; };
+    static_assert(sizeof(Nested) == sizeof(T));
+
+    Nested middle = std::bit_cast<Nested>(from);
+    T to = std::bit_cast<T>(middle);
+    Nested middle2 = std::bit_cast<Nested>(to);
+
+    assert((from == to) == (from == from)); // because NaN
+
+    if constexpr (HasUniqueObjectRepresentations) {
+        assert(std::memcmp(&from, &middle, sizeof(T)) == 0);
+        assert(std::memcmp(&to, &middle, sizeof(T)) == 0);
+        assert(std::memcmp(&middle, &middle2, sizeof(T)) == 0);
+    }
+}
+
+template <typename Intermediate, bool HasUniqueObjectRepresentations = true, typename T>
+void test_roundtrip_through(T from) {
+    static_assert(sizeof(Intermediate) == sizeof(T));
+
+    Intermediate middle = std::bit_cast<Intermediate>(from);
+    T to = std::bit_cast<T>(middle);
+    Intermediate middle2 = std::bit_cast<Intermediate>(to);
+
+    assert((from == to) == (from == from)); // because NaN
+
+    if constexpr (HasUniqueObjectRepresentations) {
+        assert(std::memcmp(&from, &middle, sizeof(T)) == 0);
+        assert(std::memcmp(&to, &middle, sizeof(T)) == 0);
+        assert(std::memcmp(&middle, &middle2, sizeof(T)) == 0);
+    }
+}
+
+template <typename T>
+constexpr std::array<T, 10> generate_signed_integral_values() {
+    return {std::numeric_limits<T>::min(),
+            std::numeric_limits<T>::min() + 1,
+            static_cast<T>(-2), static_cast<T>(-1),
+            static_cast<T>(0), static_cast<T>(1),
+            static_cast<T>(2), static_cast<T>(3),
+            std::numeric_limits<T>::max() - 1,
+            std::numeric_limits<T>::max()};
+}
+
+template <typename T>
+constexpr std::array<T, 6> generate_unsigned_integral_values() {
+    return {static_cast<T>(0), static_cast<T>(1),
+            static_cast<T>(2), static_cast<T>(3),
+            std::numeric_limits<T>::max() - 1,
+            std::numeric_limits<T>::max()};
+}
+
+bool tests() {
+    for (bool b : {false, true}) {
+        test_roundtrip_through_nested_T(b);
+        test_roundtrip_through_buffer(b);
+        test_roundtrip_through<char>(b);
+    }
+
+    for (char c : {'\0', 'a', 'b', 'c', 'd'}) {
+        test_roundtrip_through_nested_T(c);
+        test_roundtrip_through_buffer(c);
+    }
+
+    // Fundamental signed integer types
+    for (signed char i : generate_signed_integral_values<signed char>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+    }
+
+    for (short i : generate_signed_integral_values<short>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+    }
+
+    for (int i : generate_signed_integral_values<int>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<float>(i);
+    }
+
+    for (long i : generate_signed_integral_values<long>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+    }
+
+    for (long long i : generate_signed_integral_values<long long>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<double>(i);
+    }
+
+    // Fundamental unsigned integer types
+    for (unsigned char i : generate_unsigned_integral_values<unsigned char>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+    }
+
+    for (unsigned short i : generate_unsigned_integral_values<unsigned short>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+    }
+
+    for (unsigned int i : generate_unsigned_integral_values<unsigned int>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<float>(i);
+    }
+
+    for (unsigned long i : generate_unsigned_integral_values<unsigned long>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+    }
+
+    for (unsigned long long i : generate_unsigned_integral_values<unsigned long long>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<double>(i);
+    }
+
+    // Fixed width signed integer types
+    for (std::int32_t i : generate_signed_integral_values<std::int32_t>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<int>(i);
+        test_roundtrip_through<std::uint32_t>(i);
+        test_roundtrip_through<float>(i);
+    }
+
+    for (std::int64_t i : generate_signed_integral_values<std::int64_t>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<long long>(i);
+        test_roundtrip_through<std::uint64_t>(i);
+        test_roundtrip_through<double>(i);
+    }
+
+    // Fixed width unsigned integer types
+    for (std::uint32_t i : generate_unsigned_integral_values<std::uint32_t>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<int>(i);
+        test_roundtrip_through<std::int32_t>(i);
+        test_roundtrip_through<float>(i);
+    }
+
+    for (std::uint64_t i : generate_unsigned_integral_values<std::uint64_t>()) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<long long>(i);
+        test_roundtrip_through<std::int64_t>(i);
+        test_roundtrip_through<double>(i);
+    }
+
+    // Floating point types
+    for (float i : {0.0f, 1.0f, -1.0f, 10.0f, -10.0f, 1e10f, 1e-10f, 1e20f, 1e-20f, 2.71828f, 3.14159f,
+                    std::nanf(""),
+                    __builtin_nanf("0x55550001"), // NaN with a payload
+                    std::numeric_limits<float>::signaling_NaN(),
+                    std::numeric_limits<float>::quiet_NaN()}) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<int>(i);
+    }
+
+    for (double i : {0.0, 1.0, -1.0, 10.0, -10.0, 1e10, 1e-10, 1e100, 1e-100,
+                     2.718281828459045,
+                     3.141592653589793238462643383279502884197169399375105820974944,
+                     std::nan(""),
+                     std::numeric_limits<double>::signaling_NaN(),
+                     std::numeric_limits<double>::quiet_NaN()}) {
+        test_roundtrip_through_nested_T(i);
+        test_roundtrip_through_buffer(i);
+        test_roundtrip_through<long long>(i);
+    }
+
+    for (long double i : {0.0l, 1.0l, -1.0l, 10.0l, -10.0l, 1e10l, 1e-10l, 1e100l, 1e-100l,
+                          2.718281828459045l,
+                          3.141592653589793238462643383279502884197169399375105820974944l,
+                          std::nanl(""),
+                          std::numeric_limits<long double>::signaling_NaN(),
+                          std::numeric_limits<long double>::quiet_NaN()}) {
+        // Note that x86's `long double` has 80 value bits and 48 padding bits.
+        test_roundtrip_through_nested_T<false>(i);
+        test_roundtrip_through_buffer<false>(i);
+
+        // On arm64 on Apple platforms, long double is just double, so we don't
+        // test against int128, but instead against double itself. Otherwise,
+        // we test against int128 if we have those types available.
+#if defined(__aarch64__) && defined(__APPLE__)
+#   define LONG_DOUBLE_IS_DOUBLE
+#endif
+
+#if defined(LONG_DOUBLE_IS_DOUBLE)
+        test_roundtrip_through<double, false>(i);
+#elif !defined(_LIBCPP_HAS_NO_INT128)
+        test_roundtrip_through<__int128_t, false>(i);
+        test_roundtrip_through<__uint128_t, false>(i);
+#endif
+    }
+
+    return true;
+}
+
+// TODO: There doesn't seem to be a way to perform non-trivial correctness
+//       tests inside constexpr.
+constexpr bool basic_constexpr_test() {
+    struct Nested { char buffer[sizeof(int)]; };
+    int from = 3;
+    Nested middle = std::bit_cast<Nested>(from);
+    int to = std::bit_cast<int>(middle);
+    assert(from == to);
+    return true;
+}
+
+int main(int, char**) {
+    tests();
+    static_assert(basic_constexpr_test());
+    return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_bind_front",
     "values": { "c++20": 201907 },
     "headers": ["functional"],
   }, {
     "name": "__cpp_lib_bit_cast",
     "values": { "c++20": 201806 },
     "headers": ["bit"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_bitops",
     "values": { "c++20": 201907 },
     "headers": ["bit"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_bool_constant",
     "values": { "c++17": 201505 },