[libc++] Implement P1272R4 (std::byteswap)

[philnik]

Summary

Implement P1274R4

[lebedev.ri]

byte!=bit, you want __builtin_bswap*()

[philnik]

Doing a byteswap now instead of a bitswap - I already wondered why it was called byteswap :D

[Mordante]

Thanks for working on this! In general looks good, but I've several minor issue.

libcxx/include/__bit/byteswap.h

26

We conditionally support __uint128_t. This type won't work with the current implementation. I would prefer to support that type, or constrain function where sizeof(_Tp) <= 8. The availability is guarded by _LIBCPP_HAS_NO_INT128.

Note that GCC already has a __builtin_bswap128, so maybe it's interesting to also add this to clang. I wouldn't mind looking into that myself if you don't want to.

libcxx/test/std/numerics/bit/byteswap.pass.cpp

25

I would suggest to use '0x0123456789ABCDEF`. That way all nibbles are tested properly.

25

We need to either test __int128_t / __uint128_t here if you want to support it. If you don't want to support it we need a separate validate test that rejects this type.

25

I really would like see tests for all integral types. https://en.cppreference.com/w/cpp/types/is_integral, for example bool and the character types aren't tested now.

35

Since the function requires to be noexcept please add an test using ASSERT_NOEXCEPT to validate it's really noexcept.

38

Needed to make sure it works properly on freestanding implementations.

[• Quuxplusone]

LGTM % comments (most of which echo @Mordante's comments) — thanks! Requesting changes so that I'll see it again.

libcxx/include/__bit/byteswap.h

26

IMO:

• Definitely add _LIBCPP_UNREACHABLE(); at the end of this function.
• If both Clang and GCC support __builtin_bswap128 then we should just do that for case 16.
• Otherwise, we should case 16: return _Tp(byteswap(uint64_t(__val))) | (_Tp(byteswap(uint64_t(__val >> 64))) << 64); // TODO: __builtin_bswap128 when Clang supports it.

39

Since you've used std::integral on line 24, you need to guard with #if _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_CONCEPTS). Also, please mark the #endif:

#endif // _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_CONCEPTS)

43

libcxx/include/bit

58

This line is misindented.

libcxx/test/std/numerics/bit/byteswap.pass.cpp

18

Please also

ASSERT_SAME_TYPE(decltype(std::byteswap(in)), decltype(in));
ASSERT_NOEXCEPT(std::byteswap(in));

25

+1 for testing all integral types, including char and bool.
Also, please add a simple neg test. I recommend:

template<class T>
concept has_byteswap = requires (T t) { std::byteswap(t); };

static_assert(!has_byteswap<void*>);
static_assert(!has_byteswap<float>);
static_assert(!has_byteswap<char[2]>);
static_assert(!has_byteswap<std::byte>);

[Mordante]

libcxx/test/std/numerics/bit/byteswap.pass.cpp

25

Regardless whether or not to test the 128-bit failures, I think it would be good to add a test to make sure non-integral types aren't accepted.

[philnik]

Updated tests and supporting int128_t/uint128_t now

libcxx/include/__bit/byteswap.h

26

Right now I'll just do the two 8 byte swaps. I think I will try to add __builtin_bswap128 in a few days, but it can't be used right now anyways if I understand correctly. Would libc++15 be the earliest revision where this could be changed, assuming clang14 gets __builtin_bswap128?

[• Quuxplusone]

libcxx/include/__bit/byteswap.h

26

Would libc++15 be the earliest revision where this could be changed, assuming clang14 gets __builtin_bswap128?

You could make it conditional immediately (#if __has_builtin(__builtin_bswap128) — and in fact perhaps that should be part of this PR!), but yeah, my understanding of the new-as-of-last-year policy is that libc++14 needs to work with both Clang14 and Clang13; libc++15 needs to work with both Clang15 and Clang14; etc.

libcxx/test/std/numerics/bit/byteswap.pass.cpp

47–48

I'd feel better if the test case weren't constructed such that "nybble-swap each byte" was an acceptable implementation. :)
How about making the input (0x0123456789ABCDEF, 0x13579BDF02468ACE)?

FWIW, I also find the templated make_128bit_int quite verbose. I see that you're making it a template so that you don't have to hide it under an ifdef; but still, how about just this, right above the return true?

#ifndef _LIBCPP_HAS_NO_INT128
  auto before = __uint128_t(0x0123456789ABCDEF) << 64 | 0x13579BDF02468ACE;
  auto after = __uint128_t(0xCE8A4602DF9B5713) << 64 | 0xEFCDAB8967452301);
  test_num<__uint128_t>(before, after);
  test_num<__int128_t>(__int128_t(before), __int128_t(after));
#endif

74

Please add similar tests for short, int, long, long long and their unsigned counterparts.
(These can repeat the input data for int{16,32,64}_t AFAIC. We just want to make sure that we have covered whichever of long and long long is not int64_t.)

libcxx/test/support/test_macros.h

207–209 ↗

(On Diff #388011)

I bet this is overkill. Are we worried that some non-libc++ vendor might fail to define byteswap for __int128_t?

If we're messing with test macros related to 128-bit support, we might want to revisit libcxx/test/libcxx/input.output/filesystems/convert_file_time.pass.cpp too, I'm not sure.

[Mordante]

LGTM after the open comments have been addressed.

libcxx/include/__bit/byteswap.h

26

I also wanted to suggest to add #if __has_builtin(__builtin_bswap128) so I think it would be great to make that part of this PR. GCC already supports it so that means the code path will have test coverage. After it's available in Clang it will use it out-of-the-box. The #else branch can just use the fallback you currently use. That way we're compatible with implementations that don't have __builtin_bswap128.

26

I still think it would be good to constrain the template on the maximum supported sizeof(_Tp). I prefer a compile-time error over run-time bug or error.

libcxx/test/support/test_macros.h

207–209 ↗

(On Diff #388011)

+1. Currently we have 121 occurrences of _LIBCPP_HAS_NO_INT128 in our test directory.

[• Quuxplusone]

libcxx/include/__bit/byteswap.h

26

Constraints are evil because they cause it to just quietly drop out of overload resolution. I don't think WG21 knows what it's doing these days by adding constraints on everything. At first it seems neato that using std::byteswap; byteswap(N::Widget()) will quietly choose ADL N::byteswap instead of being ambiguous — but really, are we encouraging people to call byteswap by ADL? I don't think so.
I think it'd be fine to add a static_assert, though, like

static_assert(sizeof(_Tp) == 1 || sizeof(_Tp) == 2 || sizeof(_Tp) == 4 || sizeof(_Tp) == 8 || sizeof(_Tp) == 16);

Could even refactor this function to use a ladder of if constexpr ... else if constexpr ... and then put static_assert(sizeof(_Tp) == 0, "byteswap is unimplemented for integral types of this size"); in the final else branch.

37

Nit: This indentation is bizarre. I expect clang-format is to blame. #ifndef with no space, plz. :)

[philnik]

Updated test

[philnik]

Added static_assert

[Mordante]

Some small nits, but I'd like to see the CI green before accepting.

libcxx/include/__bit/byteswap.h

26

Fair point, I've no objection to static_asserts either, just as long as we make sure we don't accept invalid code.

29

Or something similar to make sure we don't except 128 bit values when not supported.

37

@Quuxplusone That clang-format rule changed in D109835.

libcxx/test/std/numerics/bit/byteswap.pass.cpp

62

I think this name is misleading. I would suggest a name like test_implementation_defined_size.

[philnik]

Added explicit casts and conditionally allowing __int128_t now

[philnik]

Replaced erroneous _LIBCPP_HAS_NO_CONCEPTS with _LIBCPP_HAS_NO_IN128

[jloser]

libcxx/include/__bit/byteswap.h

26

I'd also prefer the if constexpr chain with a static_assert in the false case as Arthur mentioned.

[Mordante]

LGTM, there are still some open comments and CI issues to address. I'll approve the patch so @Quuxplusone can give the libc++ approval once these are addressed.

[philnik]

• Use if constexpr() now

[• Quuxplusone]

LGTM mod comments. One (int->unsigned int) is functional; the others are just style improvements.

libcxx/include/__bit/byteswap.h

50

Style nit: Personally, I'd add { } around each if's body, and around the else, and cuddle the else. This gives the same number of source lines, but makes it much easier to add or remove lines without major surgery.

if constexpr (X) {
} else if constexpr (Y) {
} else {
}

(That said, libc++ style is generally to omit braces on single-line ifs... but that's usually because it saves a line to omit the braces. Here, it doesn't save you anything, and you've got a mix of bodies-that-need-braces and bodies-that-don't, so "consistency" comes into play too.)
Anyway, not a blocker AFAIC.

libcxx/test/std/numerics/bit/byteswap.pass.cpp

96–103

Seems like it would be simpler to use the same approach for all of these types, wouldn't it?
And get_test_data and get_expected could be moved into a single function std::pair<T, T> get_test_data() so that you wouldn't have to keep lines in sync that were separated by ~15 LOC.

99

s/int/unsigned int/ IIUC.

[philnik]

Updated test and added braces

[• Quuxplusone]

#include <utility>, wait for green CI, and ship it! :)

[philnik]

• added <utility> to test

[philnik]

Rebased

[philnik]

Rebased again

[philnik]

Moved endif and corrected comment

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_to_address``                          ``201711L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_to_array``                            ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_unwrap_ref``                          ``201811L``
     ------------------------------------------------- -----------------
     **C++ 2b**
     -------------------------------------------------------------------
+    ``__cpp_lib_byteswap``                            ``202110L``
+    ------------------------------------------------- -----------------
     ``__cpp_lib_is_scoped_enum``                      ``202011L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_stacktrace``                          *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_stdatomic_h``                         *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_string_contains``                     ``202011L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_to_underlying``                       ``202102L``
     ================================================= =================
 

libcxx/docs/Status/Cxx2bPapers.csv

 "`P2136R3 <https://wg21.link/P2136R3>`__","LWG","invoke_r","June 2021","",""
 "`P2166R1 <https://wg21.link/P2166R1>`__","LWG","A Proposal to Prohibit std::basic_string and std::basic_string_view construction from nullptr","June 2021","|Complete|","13.0"
 "","","","","",""
 "`P0288R9 <https://wg21.link/P0288R9>`__","LWG","``any_invocable``","October 2021","",""
 "`P0798R8 <https://wg21.link/P0798R8>`__","LWG","Monadic operations for ``std::optional``","October 2021","",""
 "`P0849R8 <https://wg21.link/P0849R8>`__","LWG","``auto(x)``: ``DECAY_COPY`` in the language","October 2021","",""
 "`P1072R10 <https://wg21.link/P1072R10>`__","LWG","``basic_string::resize_and_overwrite``","October 2021","",""
 "`P1147R1 <https://wg21.link/P1147R1>`__","LWG","Printing ``volatile`` Pointers","October 2021","|Complete|","14.0"
-"`P1272R4 <https://wg21.link/P1272R4>`__","LWG","Byteswapping for fun&&nuf","October 2021","",""
+"`P1272R4 <https://wg21.link/P1272R4>`__","LWG","Byteswapping for fun&&nuf","October 2021","|Complete|","14.0"
 "`P1675R2 <https://wg21.link/P1675R2>`__","LWG","``rethrow_exception`` must be allowed to copy","October 2021","",""
 "`P2077R3 <https://wg21.link/P2077R3>`__","LWG","Heterogeneous erasure overloads for associative containers","October 2021","",""
 "`P2251R1 <https://wg21.link/P2251R1>`__","LWG","Require ``span`` & ``basic_string_view`` to be Trivially Copyable","October 2021","|Complete|","14.0"
 "`P2301R1 <https://wg21.link/P2301R1>`__","LWG","Add a ``pmr`` alias for ``std::stacktrace``","October 2021","",""
 "`P2321R2 <https://wg21.link/P2321R2>`__","LWG","``zip``","October 2021","",""
 "`P2340R1 <https://wg21.link/P2340R1>`__","LWG","Clarifying the status of the 'C headers'","October 2021","",""
 "`P2393R1 <https://wg21.link/P2393R1>`__","LWG","Cleaning up ``integer``-class types","October 2021","",""
 "`P2401R0 <https://wg21.link/P2401R0>`__","LWG","Add a conditional ``noexcept`` specification to ``std::exchange``","October 2021","|Complete|","14.0"
 "","","","","",""

libcxx/include/CMakeLists.txt

set(files
   __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
+  __bit/byteswap.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.h

libcxx/include/__bit/byteswap.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_BYTESWAP_H
+#define _LIBCPP___BIT_BYTESWAP_H
+
+#include <__concepts/arithmetic.h>
+#include <__config>
+#include <cstdint>
+#include <cstdlib>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+template <integral _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp byteswap(_Tp __val) noexcept {
+
+  if constexpr (sizeof(_Tp) == 1) {
+    return __val;
+  } else if constexpr (sizeof(_Tp) == 2) {
+    return __builtin_bswap16(__val);
+  } else if constexpr (sizeof(_Tp) == 4) {
+    return __builtin_bswap32(__val);
+  } else if constexpr (sizeof(_Tp) == 8) {
+    return __builtin_bswap64(__val);
+#ifndef _LIBCPP_HAS_NO_INT128
+  } else if constexpr (sizeof(_Tp) == 16) {
+#if __has_builtin(__builtin_bswap128)
+    return __builtin_bswap128(__val);
+#else
+    return static_cast<_Tp>(byteswap(static_cast<uint64_t>(__val))) << 64 |
+           static_cast<_Tp>(byteswap(static_cast<uint64_t>(__val >> 64)));
+#endif // __has_builtin(__builtin_bswap128)
+#endif // _LIBCPP_HAS_NO_INT128
+  } else {
+    static_assert(sizeof(_Tp) == 0, "byteswap is unimplemented for integral types of this size");
+  }
+}
+
+#endif // _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___BIT_BYTESWAP_H

libcxx/include/bit

 // -*- 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
 #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.byteswap], byteswap
+  template<class T>
+    constexpr T byteswap(T value) noexcept;      // C++23
+
   // [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
   template <class T>
namespace std {
   template<class T>
     constexpr int popcount(T x) noexcept;     // C++20
 
   // [bit.endian], endian
   enum class endian {
     little = see below,        // C++20
     big = see below,           // C++20
     native = see below         // C++20
   };
 
 } // namespace std
 
 */
 
 #include <__bit/bit_cast.h>
+#include <__bit/byteswap.h>
 #include <__bits> // __libcpp_clz
 #include <__config>
 #include <__debug>
 #include <limits>
 #include <type_traits>
 #include <version>
 
 #if defined(__IBMCPP__)

libcxx/include/module.modulemap

module barrier {
     export *
   }
   module bit {
     header "bit"
     export *
 
     module __bit {
       module bit_cast { private header "__bit/bit_cast.h" }
+      module byteswap { private header "__bit/byteswap.h" }
     }
   }
   module bitset {
     header "bitset"
     export string
     export iosfwd
     export *
   }

libcxx/include/version

 __cpp_lib_barrier                                       201907L <barrier>
 __cpp_lib_bind_front                                    201907L <functional>
 __cpp_lib_bit_cast                                      201806L <bit>
 __cpp_lib_bitops                                        201907L <bit>
 __cpp_lib_bool_constant                                 201505L <type_traits>
 __cpp_lib_bounded_array_traits                          201902L <type_traits>
 __cpp_lib_boyer_moore_searcher                          201603L <functional>
 __cpp_lib_byte                                          201603L <cstddef>
+__cpp_lib_byteswap                                      202110L <bit>
 __cpp_lib_char8_t                                       201811L <atomic> <filesystem> <istream>
                                                                 <limits> <locale> <ostream>
                                                                 <string> <string_view>
 __cpp_lib_chrono                                        201611L <chrono>
 __cpp_lib_chrono_udls                                   201304L <chrono>
 __cpp_lib_clamp                                         201603L <algorithm>
 __cpp_lib_complex_udls                                  201309L <complex>
 __cpp_lib_concepts                                      202002L <concepts>

 // # define __cpp_lib_syncbuf                              201803L
 // # define __cpp_lib_three_way_comparison                 201907L
 # define __cpp_lib_to_address                           201711L
 # define __cpp_lib_to_array                             201907L
 # define __cpp_lib_unwrap_ref                           201811L
 #endif
 
 #if _LIBCPP_STD_VER > 20
+# define __cpp_lib_byteswap                             202110L
 # define __cpp_lib_is_scoped_enum                       202011L
 // # define __cpp_lib_stacktrace                           202011L
 // # define __cpp_lib_stdatomic_h                          202011L
 # define __cpp_lib_string_contains                      202011L
 # define __cpp_lib_to_underlying                        202102L
 #endif
 
 // clang-format on
 
 #endif // _LIBCPP_VERSIONH

libcxx/test/libcxx/diagnostics/detail.headers/bit/byteswap.module.verify.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
+//
+//===----------------------------------------------------------------------===//
+
+// 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/byteswap.h'}}
+#include <__bit/byteswap.h>

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

 
 // <bit>
 
 // Test the feature test macros defined by <bit>
 
 /*  Constant              Value
     __cpp_lib_bit_cast    201806L [C++20]
     __cpp_lib_bitops      201907L [C++20]
+    __cpp_lib_byteswap    202110L [C++2b]
     __cpp_lib_endian      201907L [C++20]
     __cpp_lib_int_pow2    202002L [C++20]
 */
 
 #include <bit>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_bit_cast
 #   error "__cpp_lib_bit_cast should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_bitops
 #   error "__cpp_lib_bitops should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_byteswap
+#   error "__cpp_lib_byteswap should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_endian
 #   error "__cpp_lib_endian should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_int_pow2
 #   error "__cpp_lib_int_pow2 should not be defined before c++20"
 # endif
 
 #elif TEST_STD_VER == 14
 
 # ifdef __cpp_lib_bit_cast
 #   error "__cpp_lib_bit_cast should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_bitops
 #   error "__cpp_lib_bitops should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_byteswap
+#   error "__cpp_lib_byteswap should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_endian
 #   error "__cpp_lib_endian should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_int_pow2
 #   error "__cpp_lib_int_pow2 should not be defined before c++20"
 # endif
 
 #elif TEST_STD_VER == 17
 
 # ifdef __cpp_lib_bit_cast
 #   error "__cpp_lib_bit_cast should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_bitops
 #   error "__cpp_lib_bitops should not be defined before c++20"
 # endif
 
+# ifdef __cpp_lib_byteswap
+#   error "__cpp_lib_byteswap should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_endian
 #   error "__cpp_lib_endian should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_int_pow2
 #   error "__cpp_lib_int_pow2 should not be defined before c++20"
 # endif
 

 #     error "__cpp_lib_bitops should have the value 201907L in c++20"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_bitops
 #     error "__cpp_lib_bitops should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
+# ifdef __cpp_lib_byteswap
+#   error "__cpp_lib_byteswap should not be defined before c++2b"
+# endif
+
 # ifndef __cpp_lib_endian
 #   error "__cpp_lib_endian should be defined in c++20"
 # endif
 # if __cpp_lib_endian != 201907L
 #   error "__cpp_lib_endian should have the value 201907L in c++20"
 # endif
 
 # ifndef __cpp_lib_int_pow2

 #     error "__cpp_lib_bitops should have the value 201907L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_bitops
 #     error "__cpp_lib_bitops should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
+# ifndef __cpp_lib_byteswap
+#   error "__cpp_lib_byteswap should be defined in c++2b"
+# endif
+# if __cpp_lib_byteswap != 202110L
+#   error "__cpp_lib_byteswap should have the value 202110L in c++2b"
+# endif
+
 # ifndef __cpp_lib_endian
 #   error "__cpp_lib_endian should be defined in c++2b"
 # endif
 # if __cpp_lib_endian != 201907L
 #   error "__cpp_lib_endian should have the value 201907L in c++2b"
 # endif
 
 # ifndef __cpp_lib_int_pow2

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

/*  Constant                                       Value
     __cpp_lib_barrier                              201907L [C++20]
     __cpp_lib_bind_front                           201907L [C++20]
     __cpp_lib_bit_cast                             201806L [C++20]
     __cpp_lib_bitops                               201907L [C++20]
     __cpp_lib_bool_constant                        201505L [C++17]
     __cpp_lib_bounded_array_traits                 201902L [C++20]
     __cpp_lib_boyer_moore_searcher                 201603L [C++17]
     __cpp_lib_byte                                 201603L [C++17]
+    __cpp_lib_byteswap                             202110L [C++2b]
     __cpp_lib_char8_t                              201811L [C++20]
     __cpp_lib_chrono                               201611L [C++17]
     __cpp_lib_chrono_udls                          201304L [C++14]
     __cpp_lib_clamp                                201603L [C++17]
     __cpp_lib_complex_udls                         201309L [C++14]
     __cpp_lib_concepts                             202002L [C++20]
     __cpp_lib_constexpr_algorithms                 201806L [C++20]
     __cpp_lib_constexpr_complex                    201711L [C++20]

 # ifdef __cpp_lib_boyer_moore_searcher
 #   error "__cpp_lib_boyer_moore_searcher should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_byte
 #   error "__cpp_lib_byte should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_byteswap
+#   error "__cpp_lib_byteswap should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_chrono
 #   error "__cpp_lib_chrono should not be defined before c++17"
 # endif
 

 # ifdef __cpp_lib_boyer_moore_searcher
 #   error "__cpp_lib_boyer_moore_searcher should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_byte
 #   error "__cpp_lib_byte should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_byteswap
+#   error "__cpp_lib_byteswap should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_chrono
 #   error "__cpp_lib_chrono should not be defined before c++17"
 # endif
 

 
 # ifndef __cpp_lib_byte
 #   error "__cpp_lib_byte should be defined in c++17"
 # endif
 # if __cpp_lib_byte != 201603L
 #   error "__cpp_lib_byte should have the value 201603L in c++17"
 # endif
 
+# ifdef __cpp_lib_byteswap
+#   error "__cpp_lib_byteswap should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++20"
 # endif
 
 # ifndef __cpp_lib_chrono
 #   error "__cpp_lib_chrono should be defined in c++17"
 # endif
 # if __cpp_lib_chrono != 201611L

 
 # ifndef __cpp_lib_byte
 #   error "__cpp_lib_byte should be defined in c++20"
 # endif
 # if __cpp_lib_byte != 201603L
 #   error "__cpp_lib_byte should have the value 201603L in c++20"
 # endif
 
+# ifdef __cpp_lib_byteswap
+#   error "__cpp_lib_byteswap should not be defined before c++2b"
+# endif
+
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++20"
 #   endif
 #   if __cpp_lib_char8_t != 201811L
 #     error "__cpp_lib_char8_t should have the value 201811L in c++20"
 #   endif
 # else

 
 # ifndef __cpp_lib_byte
 #   error "__cpp_lib_byte should be defined in c++2b"
 # endif
 # if __cpp_lib_byte != 201603L
 #   error "__cpp_lib_byte should have the value 201603L in c++2b"
 # endif
 
+# ifndef __cpp_lib_byteswap
+#   error "__cpp_lib_byteswap should be defined in c++2b"
+# endif
+# if __cpp_lib_byteswap != 202110L
+#   error "__cpp_lib_byteswap should have the value 202110L in c++2b"
+# endif
+
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++2b"
 #   endif
 #   if __cpp_lib_char8_t != 201811L
 #     error "__cpp_lib_char8_t should have the value 201811L in c++2b"
 #   endif
 # else

libcxx/test/std/numerics/bit/byteswap.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, c++20
+
+#include <bit>
+#include <cassert>
+#include <cstdint>
+#include <utility>
+
+#include "test_macros.h"
+
+template <class T>
+concept has_byteswap = requires(T t) {
+  std::byteswap(t);
+};
+
+static_assert(!has_byteswap<void*>);
+static_assert(!has_byteswap<float>);
+static_assert(!has_byteswap<char[2]>);
+static_assert(!has_byteswap<std::byte>);
+
+template <class T>
+constexpr void test_num(T in, T expected) {
+  assert(std::byteswap(in) == expected);
+  ASSERT_SAME_TYPE(decltype(std::byteswap(in)), decltype(in));
+  ASSERT_NOEXCEPT(std::byteswap(in));
+}
+
+template <class T>
+constexpr std::pair<T, T> get_test_data() {
+  switch (sizeof(T)) {
+  case 2:
+    return {static_cast<T>(0x1234), static_cast<T>(0x3412)};
+  case 4:
+    return {static_cast<T>(0x60AF8503), static_cast<T>(0x0385AF60)};
+  case 8:
+    return {static_cast<T>(0xABCDFE9477936406), static_cast<T>(0x0664937794FECDAB)};
+  }
+  assert(false);
+}
+
+template <class T>
+constexpr void test_implementation_defined_size() {
+  const auto [in, expected] = get_test_data<T>();
+  test_num<T>(in, expected);
+}
+
+constexpr bool test() {
+  test_num<uint8_t>(0xAB, 0xAB);
+  test_num<uint16_t>(0xCDEF, 0xEFCD);
+  test_num<uint32_t>(0x01234567, 0x67452301);
+  test_num<uint64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
+
+  test_num<int8_t>(0xAB, 0xAB);
+  test_num<int16_t>(0xCDEF, 0xEFCD);
+  test_num<int32_t>(0x01234567, 0x67452301);
+  test_num<int64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
+
+#ifndef _LIBCPP_HAS_NO_INT128
+  const auto in = static_cast<__uint128_t>(0x0123456789ABCDEF) << 64 | 0x13579BDF02468ACE;
+  const auto expected = static_cast<__uint128_t>(0xCE8A4602DF9B5713) << 64 | 0xEFCDAB8967452301;
+  test_num<__uint128_t>(in, expected);
+  test_num<__int128_t>(in, expected);
+#endif
+
+  test_num<bool>(true, true);
+  test_num<bool>(false, false);
+  test_num<char>(0xCD, 0xCD);
+  test_num<unsigned char>(0xEF, 0xEF);
+  test_num<signed char>(0x45, 0x45);
+  test_num<char8_t>(0xAB, 0xAB);
+  test_num<char16_t>(0xABCD, 0xCDAB);
+  test_num<char32_t>(0xABCDEF01, 0x01EFCDAB);
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test_implementation_defined_size<wchar_t>();
+#endif
+
+  test_implementation_defined_size<short>();
+  test_implementation_defined_size<unsigned short>();
+  test_implementation_defined_size<int>();
+  test_implementation_defined_size<unsigned int>();
+  test_implementation_defined_size<long>();
+  test_implementation_defined_size<unsigned long>();
+  test_implementation_defined_size<long long>();
+  test_implementation_defined_size<unsigned long long>();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "values": { "c++17": 201603 },
     "headers": ["functional"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_byte",
     "values": { "c++17": 201603 },
     "headers": ["cstddef"],
   }, {
+    "name": "__cpp_lib_byteswap",
+    "values": { "c++2b": 202110 },
+    "headers": ["bit"],
+  }, {
     "name": "__cpp_lib_char8_t",
     "values": { "c++20": 201811 },
     "headers": ["atomic", "filesystem", "istream", "limits", "locale", "ostream", "string", "string_view"],
     "test_suite_guard": "defined(__cpp_char8_t)",
     "libcxx_guard": "!defined(_LIBCPP_HAS_NO_CHAR8_T)",
   }, {
     "name": "__cpp_lib_chrono",
     "values": { "c++17": 201611 },