[libcxx] Implement P1956 rename low-level bit functions

[Mordante]

Summary

Implements P1956: On the names of low-level bit manipulation functions.

Users may use older versions of libc++ or other standard libraries with the old names. In order to keep compatibility the old functions are kept, but marked as deprecated.

The patch also adds a new config macro _LIBCPP_DEPRECATED_MSG. Do you prefer a this is a separate patch?

[ldionne]

I would be tempted to rename the functions and just remove the old ones. It's not clear to me we're making anyone a flower by keeping the old ones but marking them as deprecated. I think we might just be introducing complexity and a migration burden for a non-existent problem.

The reason why I think the problem might be non-existent is that:

1. Those are not the most widely used functions
2. The old names never made it into any published C++ Standard, so we'd effectively be non-conforming by providing (deprecated) functions that don't exist in the standard
3. Many people compile with -Werror, so the difference between a deprecation warning and the name not being there is immaterial.

Can you please add a release note to libcxx/docs/ReleaseNotes.rst?

I'll launch a build at Apple to see whether removing the names causes issues. @EricWF Can you please do the same at Google?

Edit: for my own ref rdar://71236792

[ldionne]

Requesting changes so it shows up properly in the queue.

[Mordante]

Thanks for the review.

I kept the old names to aid people transition to the new names since I don't know how many people relay on the old names. (I don't expect too many.) If the test at Apple and Google shows no or little breakage I think it would be good to remove the old names.

I've updated the release notes and will post an updated patch after we've determined the fate of the old name.

[ldionne]

In D90551#2386348, @Mordante wrote:

Thanks for the review.

I kept the old names to aid people transition to the new names since I don't know how many people relay on the old names. (I don't expect too many.) If the test at Apple and Google shows no or little breakage I think it would be good to remove the old names.

Removing the old names causes no breakage internally. Let's go with that, and we can always come back and add the old names back as a temporary measure if we notice breakage -- but it's not clear to me that's going to happen.

[Mordante]

Addresses the review comments:

• Adds the change to the release notes.
• Remove instead of deprecate the old functions.

[ldionne]

I don't understand why no CI is being triggered. That's weird. @goncharov do you know?

This LGTM if CI passes. Can you please hold off until we've figured out what's wrong?

[Mordante]

Thanks for the review.

@goncharov I use the Phabricator's web-interface instead of arc to create and update revisions. Can that be the issue?

[Mordante]

Rebase to trigger the bildkite.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_destroying_delete``                   ``201806L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_endian``                              ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_erase_if``                            ``202002L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_generic_unordered_lookup``            *unimplemented*
     ------------------------------------------------- -----------------
+    ``__cpp_lib_int_pow2``                            ``202002L``
+    ------------------------------------------------- -----------------
     ``__cpp_lib_interpolate``                         ``201902L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_is_constant_evaluated``               ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_list_remove_return_type``             ``201806L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_math_constants``                      ``201907L``
     ------------------------------------------------- -----------------

libcxx/include/__config

 
 // Deprecation macros.
 //
 // Deprecations warnings are always enabled, except when users explicitly opt-out
 // by defining _LIBCPP_DISABLE_DEPRECATION_WARNINGS.
 #if !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS)
 #  if __has_attribute(deprecated)
 #    define _LIBCPP_DEPRECATED __attribute__ ((deprecated))
+#    define _LIBCPP_DEPRECATED_MSG(_MSG) __attribute__ ((deprecated))
 #  elif _LIBCPP_STD_VER > 11
 #    define _LIBCPP_DEPRECATED [[deprecated]]
+#    define _LIBCPP_DEPRECATED_MSG(_MSG) [[deprecated(_MSG)]]
 #  else
 #    define _LIBCPP_DEPRECATED
+#    define _LIBCPP_DEPRECATED_MSG(_MSG)
 #  endif
 #else
 #  define _LIBCPP_DEPRECATED
+#  define _LIBCPP_DEPRECATED_MSG(_MSG)
 #endif
 
 #if !defined(_LIBCPP_CXX03_LANG)
 #  define _LIBCPP_DEPRECATED_IN_CXX11 _LIBCPP_DEPRECATED
 #else
 #  define _LIBCPP_DEPRECATED_IN_CXX11
 #endif
 

libcxx/include/bit

 
 /*
     bit synopsis
 
 namespace std {
 
   // [bit.pow.two], integral powers of 2
   template <class T>
-    constexpr bool ispow2(T x) noexcept; // C++20
+    constexpr bool has_single_bit(T x) noexcept; // C++20
   template <class T>
-    constexpr T ceil2(T x);              // C++20
+    constexpr T bit_ceil(T x);                   // C++20
   template <class T>
-    constexpr T floor2(T x) noexcept;    // C++20
+    constexpr T bit_floor(T x) noexcept;         // C++20
   template <class T>
-    constexpr T log2p1(T x) noexcept;    // C++20
+    constexpr T bit_width(T x) noexcept;         // C++20
 
   // [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
 
   // [bit.count], counting

 unsigned __bit_log2(_Tp __t) _NOEXCEPT
 {
     static_assert(__bitop_unsigned_integer<_Tp>::value, "__bit_log2 requires unsigned");
     return std::numeric_limits<_Tp>::digits - 1 - __countl_zero(__t);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-bool __ispow2(_Tp __t) _NOEXCEPT
+bool __has_single_bit(_Tp __t) _NOEXCEPT
 {
-    static_assert(__bitop_unsigned_integer<_Tp>::value, "__ispow2 requires unsigned");
+    static_assert(__bitop_unsigned_integer<_Tp>::value, "__has_single_bit requires unsigned");
     return __t != 0 && (((__t & (__t - 1)) == 0));
 }
 
 
 #if _LIBCPP_STD_VER > 17
 
 template<class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr

 }
 
 
 template<class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr
 enable_if_t<__bitop_unsigned_integer<_Tp>::value, int>
 countr_zero(_Tp __t) noexcept
 {
-  return __countr_zero(__t);
+    return __countr_zero(__t);
 }
 
 
 template<class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr
 enable_if_t<__bitop_unsigned_integer<_Tp>::value, int>
 countr_one(_Tp __t) noexcept
 {
     return __countr_one(__t);
 }
 
 
 template<class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr
 enable_if_t<__bitop_unsigned_integer<_Tp>::value, int>
 popcount(_Tp __t) noexcept
 {
     return __popcount(__t);
 }
 
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr
 enable_if_t<__bitop_unsigned_integer<_Tp>::value, bool>
+has_single_bit(_Tp __t) noexcept
+{
+    return __has_single_bit(__t);
+}
+
+template <class _Tp>
+_LIBCPP_DEPRECATED_MSG("Use std::has_single_bit")
+_LIBCPP_INLINE_VISIBILITY constexpr
+enable_if_t<__bitop_unsigned_integer<_Tp>::value, bool>
 ispow2(_Tp __t) noexcept
 {
-    return __ispow2(__t);
+    return _VSTD::has_single_bit(__t);
 }
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY constexpr
 enable_if_t<__bitop_unsigned_integer<_Tp>::value, _Tp>
-floor2(_Tp __t) noexcept
+bit_floor(_Tp __t) noexcept
 {
     return __t == 0 ? 0 : _Tp{1} << __bit_log2(__t);
 }
 
 template <class _Tp>
+_LIBCPP_DEPRECATED_MSG("Use std::bit_floor")
 _LIBCPP_INLINE_VISIBILITY constexpr
 enable_if_t<__bitop_unsigned_integer<_Tp>::value, _Tp>
-ceil2(_Tp __t) noexcept
+floor2(_Tp __t) noexcept
+{
+    return _VSTD::bit_floor(__t);
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY constexpr
+enable_if_t<__bitop_unsigned_integer<_Tp>::value, _Tp>
+bit_ceil(_Tp __t) noexcept
 {
     if (__t < 2) return 1;
     const unsigned __n = numeric_limits<_Tp>::digits - countl_zero((_Tp)(__t - 1u));
-    _LIBCPP_DEBUG_ASSERT(__libcpp_is_constant_evaluated() || __n != numeric_limits<_Tp>::digits, "Bad input to ceil2");
+    _LIBCPP_DEBUG_ASSERT(__libcpp_is_constant_evaluated() || __n != numeric_limits<_Tp>::digits, "Bad input to bit_ceil");
 
     if constexpr (sizeof(_Tp) >= sizeof(unsigned))
         return _Tp{1} << __n;
     else
     {
         const unsigned __extra = numeric_limits<unsigned>::digits  - numeric_limits<_Tp>::digits;
         const unsigned __retVal = 1u << (__n + __extra);
         return (_Tp) (__retVal >> __extra);
     }
 }
 
 template <class _Tp>
+_LIBCPP_DEPRECATED_MSG("Use std::bit_ceil")
 _LIBCPP_INLINE_VISIBILITY constexpr
 enable_if_t<__bitop_unsigned_integer<_Tp>::value, _Tp>
-log2p1(_Tp __t) noexcept
+ceil2(_Tp __t) noexcept
+{
+    return _VSTD::bit_ceil(__t);
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY constexpr
+enable_if_t<__bitop_unsigned_integer<_Tp>::value, _Tp>
+bit_width(_Tp __t) noexcept
 {
     return __t == 0 ? 0 : __bit_log2(__t) + 1;
 }
 
+template <class _Tp>
+_LIBCPP_DEPRECATED_MSG("Use std::bit_width")
+_LIBCPP_INLINE_VISIBILITY constexpr
+enable_if_t<__bitop_unsigned_integer<_Tp>::value, _Tp>
+log2p1(_Tp __t) noexcept
+{
+    return _VSTD::bit_width(__t);
+}
 
 enum class endian
 {
     little = 0xDEAD,
     big    = 0xFACE,
 #if defined(_LIBCPP_LITTLE_ENDIAN)
     native = little
 #elif defined(_LIBCPP_BIG_ENDIAN)

libcxx/include/version

 __cpp_lib_filesystem                                    201703L <filesystem>
 __cpp_lib_gcd_lcm                                       201606L <numeric>
 __cpp_lib_generic_associative_lookup                    201304L <map> <set>
 __cpp_lib_generic_unordered_lookup                      201811L <unordered_map> <unordered_set>
 __cpp_lib_hardware_interference_size                    201703L <new>
 __cpp_lib_has_unique_object_representations             201606L <type_traits>
 __cpp_lib_hypot                                         201603L <cmath>
 __cpp_lib_incomplete_container_elements                 201505L <forward_list> <list> <vector>
+__cpp_lib_int_pow2                                      202002L <bit>
 __cpp_lib_integer_sequence                              201304L <utility>
 __cpp_lib_integral_constant_callable                    201304L <type_traits>
 __cpp_lib_interpolate                                   201902L <numeric>
 __cpp_lib_invoke                                        201411L <functional>
 __cpp_lib_is_aggregate                                  201703L <type_traits>
 __cpp_lib_is_constant_evaluated                         201811L <type_traits>
 __cpp_lib_is_final                                      201402L <type_traits>
 __cpp_lib_is_invocable                                  201703L <type_traits>

 // # define __cpp_lib_constexpr_swap_algorithms            201806L
 # define __cpp_lib_constexpr_utility                    201811L
 # 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                             202002L
 // # define __cpp_lib_generic_unordered_lookup             201811L
+# define __cpp_lib_int_pow2                             202002L
 # 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
 # if defined(__cpp_concepts) && __cpp_concepts >= 201811L
 #   define __cpp_lib_math_constants                     201907L
 # endif
 // # define __cpp_lib_ranges                               201811L
 # define __cpp_lib_span                                 202002L
 // # define __cpp_lib_three_way_comparison                 201711L
 # define __cpp_lib_to_array                             201907L
 #endif
 
 #endif // _LIBCPP_VERSIONH

libcxx/test/libcxx/numerics/bit.ops.pass.cpp

//  These are all constexpr in C++14 and later
     static_assert( std::__rotr(v, 4) == 0x70000123, "");
     static_assert( std::__countl_one(v)  == 0, "");
     static_assert( std::__countr_one(v)  == 3, "");
     static_assert( std::__countl_zero(v) == 19, "");
     static_assert( std::__countr_zero(v) == 0, "");
 
     static_assert( std::__libcpp_popcount(v) == 7, "");
     static_assert( std::__bit_log2(v) == 12, "");
-    static_assert(!std::__ispow2(v), "");
+    static_assert(!std::__has_single_bit(v), "");
     }
 #endif
 
     {
     const unsigned v = 0x12345678;
 
     ASSERT_SAME_TYPE(unsigned, decltype(std::__rotl(v, 3)));
     ASSERT_SAME_TYPE(unsigned, decltype(std::__rotr(v, 3)));
 
     ASSERT_SAME_TYPE(int, decltype(std::__countl_one(v)));
     ASSERT_SAME_TYPE(int, decltype(std::__countr_one(v)));
     ASSERT_SAME_TYPE(int, decltype(std::__countl_zero(v)));
     ASSERT_SAME_TYPE(int, decltype(std::__countr_zero(v)));
 
     ASSERT_SAME_TYPE(int,      decltype(std::__libcpp_popcount(v)));
     ASSERT_SAME_TYPE(unsigned, decltype(std::__bit_log2(v)));
-    ASSERT_SAME_TYPE(bool,     decltype(std::__ispow2(v)));
+    ASSERT_SAME_TYPE(bool,     decltype(std::__has_single_bit(v)));
 
 
     assert( std::__rotl(v, 3) == 0x91a2b3c0U);
     assert( std::__rotr(v, 3) == 0x02468acfU);
 
     assert( std::__countl_one(v)  == 0);
     assert( std::__countr_one(v)  == 0);
     assert( std::__countl_zero(v) == 3);
     assert( std::__countr_zero(v) == 3);
 
     assert( std::__libcpp_popcount(v) == 13);
     assert( std::__bit_log2(v) == 28);
-    assert(!std::__ispow2(v));
+    assert(!std::__has_single_bit(v));
     }
 
     return 0;
 }

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++2a]
     __cpp_lib_endian      201907L [C++2a]
+    __cpp_lib_int_pow2    202002L [C++2a]
 */
 
 #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++2a"
 # endif
 
 # ifdef __cpp_lib_endian
 #   error "__cpp_lib_endian should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_int_pow2
+#   error "__cpp_lib_int_pow2 should not be defined before c++2a"
+# endif
+
 #elif TEST_STD_VER == 14
 
 # ifdef __cpp_lib_bit_cast
 #   error "__cpp_lib_bit_cast should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_endian
 #   error "__cpp_lib_endian should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_int_pow2
+#   error "__cpp_lib_int_pow2 should not be defined before c++2a"
+# endif
+
 #elif TEST_STD_VER == 17
 
 # ifdef __cpp_lib_bit_cast
 #   error "__cpp_lib_bit_cast should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_endian
 #   error "__cpp_lib_endian should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_int_pow2
+#   error "__cpp_lib_int_pow2 should not be defined before c++2a"
+# endif
+
 #elif TEST_STD_VER > 17
 
 # if !defined(_LIBCPP_VERSION)
 #   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
 #   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_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
 
+# ifndef __cpp_lib_int_pow2
+#   error "__cpp_lib_int_pow2 should be defined in c++2a"
+# endif
+# if __cpp_lib_int_pow2 != 202002L
+#   error "__cpp_lib_int_pow2 should have the value 202002L 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

/*  Constant                                       Value
     __cpp_lib_filesystem                           201703L [C++17]
     __cpp_lib_gcd_lcm                              201606L [C++17]
     __cpp_lib_generic_associative_lookup           201304L [C++14]
     __cpp_lib_generic_unordered_lookup             201811L [C++2a]
     __cpp_lib_hardware_interference_size           201703L [C++17]
     __cpp_lib_has_unique_object_representations    201606L [C++17]
     __cpp_lib_hypot                                201603L [C++17]
     __cpp_lib_incomplete_container_elements        201505L [C++17]
+    __cpp_lib_int_pow2                             202002L [C++2a]
     __cpp_lib_integer_sequence                     201304L [C++14]
     __cpp_lib_integral_constant_callable           201304L [C++14]
     __cpp_lib_interpolate                          201902L [C++2a]
     __cpp_lib_invoke                               201411L [C++17]
     __cpp_lib_is_aggregate                         201703L [C++17]
     __cpp_lib_is_constant_evaluated                201811L [C++2a]
     __cpp_lib_is_final                             201402L [C++14]
     __cpp_lib_is_invocable                         201703L [C++17]

 # ifdef __cpp_lib_hypot
 #   error "__cpp_lib_hypot should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_incomplete_container_elements
 #   error "__cpp_lib_incomplete_container_elements should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_int_pow2
+#   error "__cpp_lib_int_pow2 should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should not be defined before c++14"
 # endif
 
 # ifdef __cpp_lib_integral_constant_callable
 #   error "__cpp_lib_integral_constant_callable should not be defined before c++14"
 # endif
 

 # ifdef __cpp_lib_hypot
 #   error "__cpp_lib_hypot should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_incomplete_container_elements
 #   error "__cpp_lib_incomplete_container_elements should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_int_pow2
+#   error "__cpp_lib_int_pow2 should not be defined before c++2a"
+# endif
+
 # ifndef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should be defined in c++14"
 # endif
 # if __cpp_lib_integer_sequence != 201304L
 #   error "__cpp_lib_integer_sequence should have the value 201304L in c++14"
 # endif
 
 # ifndef __cpp_lib_integral_constant_callable

 
 # ifndef __cpp_lib_incomplete_container_elements
 #   error "__cpp_lib_incomplete_container_elements should be defined in c++17"
 # endif
 # if __cpp_lib_incomplete_container_elements != 201505L
 #   error "__cpp_lib_incomplete_container_elements should have the value 201505L in c++17"
 # endif
 
+# ifdef __cpp_lib_int_pow2
+#   error "__cpp_lib_int_pow2 should not be defined before c++2a"
+# endif
+
 # ifndef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should be defined in c++17"
 # endif
 # if __cpp_lib_integer_sequence != 201304L
 #   error "__cpp_lib_integer_sequence should have the value 201304L in c++17"
 # endif
 
 # ifndef __cpp_lib_integral_constant_callable

 
 # ifndef __cpp_lib_incomplete_container_elements
 #   error "__cpp_lib_incomplete_container_elements should be defined in c++2a"
 # endif
 # if __cpp_lib_incomplete_container_elements != 201505L
 #   error "__cpp_lib_incomplete_container_elements should have the value 201505L in c++2a"
 # endif
 
+# ifndef __cpp_lib_int_pow2
+#   error "__cpp_lib_int_pow2 should be defined in c++2a"
+# endif
+# if __cpp_lib_int_pow2 != 202002L
+#   error "__cpp_lib_int_pow2 should have the value 202002L in c++2a"
+# endif
+
 # ifndef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should be defined in c++2a"
 # endif
 # if __cpp_lib_integer_sequence != 201304L
 #   error "__cpp_lib_integer_sequence should have the value 201304L in c++2a"
 # endif
 
 # ifndef __cpp_lib_integral_constant_callable

libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // template <class T>
-//   constexpr T ceil2(T x) noexcept;
+//   constexpr T bit_ceil(T x) noexcept;
 
 // Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
 #include <cstdint>
 #include <limits>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };
 
 template <typename T>
 constexpr bool toobig()
 {
-  return 0 == std::ceil2(std::numeric_limits<T>::max());
+  return 0 == std::bit_ceil(std::numeric_limits<T>::max());
 }
 
 int main(int, char**)
 {
 //  Make sure we generate a compile-time error for UB
   static_assert(toobig<unsigned char>(),      ""); // expected-error {{static_assert expression is not an integral constant expression}}
   static_assert(toobig<unsigned short>(),     ""); // expected-error {{static_assert expression is not an integral constant expression}}
   static_assert(toobig<unsigned>(),           ""); // expected-error {{static_assert expression is not an integral constant expression}}

libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // template <class T>
-//   constexpr T ceil2(T x) noexcept;
+//   constexpr T bit_ceil(T x) noexcept;
 
-// Returns: The minimal value y such that ispow2(y) is true and y >= x;
+// Returns: The minimal value y such that has_single_bit(y) is true and y >= x;
 //    if y is not representable as a value of type T, the result is an unspecified value.
 // Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
 #include <cstdint>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };
 
 template <typename T>
 constexpr bool constexpr_test()
 {
-    return std::ceil2(T(0)) == T(1)
-       &&  std::ceil2(T(1)) == T(1)
-       &&  std::ceil2(T(2)) == T(2)
-       &&  std::ceil2(T(3)) == T(4)
-       &&  std::ceil2(T(4)) == T(4)
-       &&  std::ceil2(T(5)) == T(8)
-       &&  std::ceil2(T(6)) == T(8)
-       &&  std::ceil2(T(7)) == T(8)
-       &&  std::ceil2(T(8)) == T(8)
-       &&  std::ceil2(T(9)) == T(16)
+    return std::bit_ceil(T(0)) == T(1)
+       &&  std::bit_ceil(T(1)) == T(1)
+       &&  std::bit_ceil(T(2)) == T(2)
+       &&  std::bit_ceil(T(3)) == T(4)
+       &&  std::bit_ceil(T(4)) == T(4)
+       &&  std::bit_ceil(T(5)) == T(8)
+       &&  std::bit_ceil(T(6)) == T(8)
+       &&  std::bit_ceil(T(7)) == T(8)
+       &&  std::bit_ceil(T(8)) == T(8)
+       &&  std::bit_ceil(T(9)) == T(16)
        ;
 }
 
 
 template <typename T>
 void runtime_test()
 {
-    ASSERT_SAME_TYPE(T, decltype(std::ceil2(T(0))));
-    LIBCPP_ASSERT_NOEXCEPT(      std::ceil2(T(0)));
+    ASSERT_SAME_TYPE(T, decltype(std::bit_ceil(T(0))));
+    LIBCPP_ASSERT_NOEXCEPT(      std::bit_ceil(T(0)));
 
-    assert( std::ceil2(T(60)) == T( 64));
-    assert( std::ceil2(T(61)) == T( 64));
-    assert( std::ceil2(T(62)) == T( 64));
-    assert( std::ceil2(T(63)) == T( 64));
-    assert( std::ceil2(T(64)) == T( 64));
-    assert( std::ceil2(T(65)) == T(128));
-    assert( std::ceil2(T(66)) == T(128));
-    assert( std::ceil2(T(67)) == T(128));
-    assert( std::ceil2(T(68)) == T(128));
-    assert( std::ceil2(T(69)) == T(128));
+    assert( std::bit_ceil(T(60)) == T( 64));
+    assert( std::bit_ceil(T(61)) == T( 64));
+    assert( std::bit_ceil(T(62)) == T( 64));
+    assert( std::bit_ceil(T(63)) == T( 64));
+    assert( std::bit_ceil(T(64)) == T( 64));
+    assert( std::bit_ceil(T(65)) == T(128));
+    assert( std::bit_ceil(T(66)) == T(128));
+    assert( std::bit_ceil(T(67)) == T(128));
+    assert( std::bit_ceil(T(68)) == T(128));
+    assert( std::bit_ceil(T(69)) == T(128));
 }
 
 int main(int, char**)
 {
 
     {
-    auto lambda = [](auto x) -> decltype(std::ceil2(x)) {};
+    auto lambda = [](auto x) -> decltype(std::bit_ceil(x)) {};
     using L = decltype(lambda);
 
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
     static_assert( std::is_invocable_v<L, unsigned long long>, "");
 
     static_assert( std::is_invocable_v<L, uint8_t>, "");

libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // template <class T>
-//   constexpr T floor2(T x) noexcept;
+//   constexpr T bit_floor(T x) noexcept;
 
-// Returns: If x == 0, 0; otherwise the maximal value y such that floor2(y) is true and y <= x.
+// Returns: If x == 0, 0; otherwise the maximal value y such that bit_floor(y) is true and y <= x.
 // Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
 #include <cstdint>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };
 
 template <typename T>
 constexpr bool constexpr_test()
 {
-  return std::floor2(T(0)) == T(0)
-     &&  std::floor2(T(1)) == T(1)
-     &&  std::floor2(T(2)) == T(2)
-     &&  std::floor2(T(3)) == T(2)
-     &&  std::floor2(T(4)) == T(4)
-     &&  std::floor2(T(5)) == T(4)
-     &&  std::floor2(T(6)) == T(4)
-     &&  std::floor2(T(7)) == T(4)
-     &&  std::floor2(T(8)) == T(8)
-     &&  std::floor2(T(9)) == T(8)
+  return std::bit_floor(T(0)) == T(0)
+     &&  std::bit_floor(T(1)) == T(1)
+     &&  std::bit_floor(T(2)) == T(2)
+     &&  std::bit_floor(T(3)) == T(2)
+     &&  std::bit_floor(T(4)) == T(4)
+     &&  std::bit_floor(T(5)) == T(4)
+     &&  std::bit_floor(T(6)) == T(4)
+     &&  std::bit_floor(T(7)) == T(4)
+     &&  std::bit_floor(T(8)) == T(8)
+     &&  std::bit_floor(T(9)) == T(8)
      ;
 }
 
 
 template <typename T>
 void runtime_test()
 {
-  ASSERT_SAME_TYPE(T, decltype(std::floor2(T(0))));
-  ASSERT_NOEXCEPT(             std::floor2(T(0)));
+  ASSERT_SAME_TYPE(T, decltype(std::bit_floor(T(0))));
+  ASSERT_NOEXCEPT(             std::bit_floor(T(0)));
 
-  assert( std::floor2(T(121)) == T(64));
-  assert( std::floor2(T(122)) == T(64));
-  assert( std::floor2(T(123)) == T(64));
-  assert( std::floor2(T(124)) == T(64));
-  assert( std::floor2(T(125)) == T(64));
-  assert( std::floor2(T(126)) == T(64));
-  assert( std::floor2(T(127)) == T(64));
-  assert( std::floor2(T(128)) == T(128));
-  assert( std::floor2(T(129)) == T(128));
-  assert( std::floor2(T(130)) == T(128));
+  assert( std::bit_floor(T(121)) == T(64));
+  assert( std::bit_floor(T(122)) == T(64));
+  assert( std::bit_floor(T(123)) == T(64));
+  assert( std::bit_floor(T(124)) == T(64));
+  assert( std::bit_floor(T(125)) == T(64));
+  assert( std::bit_floor(T(126)) == T(64));
+  assert( std::bit_floor(T(127)) == T(64));
+  assert( std::bit_floor(T(128)) == T(128));
+  assert( std::bit_floor(T(129)) == T(128));
+  assert( std::bit_floor(T(130)) == T(128));
 }
 
 int main(int, char**)
 {
 
     {
-    auto lambda = [](auto x) -> decltype(std::floor2(x)) {};
+    auto lambda = [](auto x) -> decltype(std::bit_floor(x)) {};
     using L = decltype(lambda);
 
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
     static_assert( std::is_invocable_v<L, unsigned long long>, "");
 
     static_assert( std::is_invocable_v<L, uint8_t>, "");
#endif
   runtime_test<uintptr_t>();
 
 #ifndef _LIBCPP_HAS_NO_INT128
   runtime_test<__uint128_t>();
 
   {
   __uint128_t val = 128;
   val <<= 32;
-  assert( std::floor2(val-1) == val/2);
-  assert( std::floor2(val)   == val);
-  assert( std::floor2(val+1) == val);
+  assert( std::bit_floor(val-1) == val/2);
+  assert( std::bit_floor(val)   == val);
+  assert( std::bit_floor(val+1) == val);
   val <<= 2;
-  assert( std::floor2(val-1) == val/2);
-  assert( std::floor2(val)   == val);
-  assert( std::floor2(val+1) == val);
+  assert( std::bit_floor(val-1) == val/2);
+  assert( std::bit_floor(val)   == val);
+  assert( std::bit_floor(val+1) == val);
   val <<= 3;
-  assert( std::floor2(val-1) == val/2);
-  assert( std::floor2(val)   == val);
-  assert( std::floor2(val+1) == val);
+  assert( std::bit_floor(val-1) == val/2);
+  assert( std::bit_floor(val)   == val);
+  assert( std::bit_floor(val+1) == val);
   }
 #endif
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // template <class T>
-//   constexpr T log2p1(T x) noexcept;
+//   constexpr T bit_width(T x) noexcept;
 
 // If x == 0, 0; otherwise one plus the base-2 logarithm of x, with any fractional part discarded.
 
 // Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };
 
 template <typename T>
 constexpr bool constexpr_test()
 {
-  return std::log2p1(T(0)) == T(0)
-     &&  std::log2p1(T(1)) == T(1)
-     &&  std::log2p1(T(2)) == T(2)
-     &&  std::log2p1(T(3)) == T(2)
-     &&  std::log2p1(T(4)) == T(3)
-     &&  std::log2p1(T(5)) == T(3)
-     &&  std::log2p1(T(6)) == T(3)
-     &&  std::log2p1(T(7)) == T(3)
-     &&  std::log2p1(T(8)) == T(4)
-     &&  std::log2p1(T(9)) == T(4)
+  return std::bit_width(T(0)) == T(0)
+     &&  std::bit_width(T(1)) == T(1)
+     &&  std::bit_width(T(2)) == T(2)
+     &&  std::bit_width(T(3)) == T(2)
+     &&  std::bit_width(T(4)) == T(3)
+     &&  std::bit_width(T(5)) == T(3)
+     &&  std::bit_width(T(6)) == T(3)
+     &&  std::bit_width(T(7)) == T(3)
+     &&  std::bit_width(T(8)) == T(4)
+     &&  std::bit_width(T(9)) == T(4)
      ;
 }
 
 
 template <typename T>
 void runtime_test()
 {
-  ASSERT_SAME_TYPE(T, decltype(std::log2p1(T(0))));
-  ASSERT_NOEXCEPT(             std::log2p1(T(0)));
+  ASSERT_SAME_TYPE(T, decltype(std::bit_width(T(0))));
+  ASSERT_NOEXCEPT(             std::bit_width(T(0)));
 
-  assert( std::log2p1(T(0)) == T(0));
-  assert( std::log2p1(T(1)) == T(1));
-  assert( std::log2p1(T(2)) == T(2));
-  assert( std::log2p1(T(3)) == T(2));
-  assert( std::log2p1(T(4)) == T(3));
-  assert( std::log2p1(T(5)) == T(3));
-  assert( std::log2p1(T(6)) == T(3));
-  assert( std::log2p1(T(7)) == T(3));
-  assert( std::log2p1(T(8)) == T(4));
-  assert( std::log2p1(T(9)) == T(4));
-
-
-  assert( std::log2p1(T(121)) == T(7));
-  assert( std::log2p1(T(122)) == T(7));
-  assert( std::log2p1(T(123)) == T(7));
-  assert( std::log2p1(T(124)) == T(7));
-  assert( std::log2p1(T(125)) == T(7));
-  assert( std::log2p1(T(126)) == T(7));
-  assert( std::log2p1(T(127)) == T(7));
-  assert( std::log2p1(T(128)) == T(8));
-  assert( std::log2p1(T(129)) == T(8));
-  assert( std::log2p1(T(130)) == T(8));
+  assert( std::bit_width(T(0)) == T(0));
+  assert( std::bit_width(T(1)) == T(1));
+  assert( std::bit_width(T(2)) == T(2));
+  assert( std::bit_width(T(3)) == T(2));
+  assert( std::bit_width(T(4)) == T(3));
+  assert( std::bit_width(T(5)) == T(3));
+  assert( std::bit_width(T(6)) == T(3));
+  assert( std::bit_width(T(7)) == T(3));
+  assert( std::bit_width(T(8)) == T(4));
+  assert( std::bit_width(T(9)) == T(4));
+
+
+  assert( std::bit_width(T(121)) == T(7));
+  assert( std::bit_width(T(122)) == T(7));
+  assert( std::bit_width(T(123)) == T(7));
+  assert( std::bit_width(T(124)) == T(7));
+  assert( std::bit_width(T(125)) == T(7));
+  assert( std::bit_width(T(126)) == T(7));
+  assert( std::bit_width(T(127)) == T(7));
+  assert( std::bit_width(T(128)) == T(8));
+  assert( std::bit_width(T(129)) == T(8));
+  assert( std::bit_width(T(130)) == T(8));
 }
 
 int main(int, char**)
 {
 
     {
-    auto lambda = [](auto x) -> decltype(std::log2p1(x)) {};
+    auto lambda = [](auto x) -> decltype(std::bit_width(x)) {};
     using L = decltype(lambda);
 
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
     static_assert( std::is_invocable_v<L, unsigned long long>, "");
 
     static_assert( std::is_invocable_v<L, uint8_t>, "");
#endif
   runtime_test<uintptr_t>();
 
 #ifndef _LIBCPP_HAS_NO_INT128
   runtime_test<__uint128_t>();
 
   {
   __uint128_t val = 128;
   val <<= 32;
-  assert( std::log2p1(val-1) == 39);
-  assert( std::log2p1(val)   == 40);
-  assert( std::log2p1(val+1) == 40);
+  assert( std::bit_width(val-1) == 39);
+  assert( std::bit_width(val)   == 40);
+  assert( std::bit_width(val+1) == 40);
   val <<= 2;
-  assert( std::log2p1(val-1) == 41);
-  assert( std::log2p1(val)   == 42);
-  assert( std::log2p1(val+1) == 42);
+  assert( std::bit_width(val-1) == 41);
+  assert( std::bit_width(val)   == 42);
+  assert( std::bit_width(val+1) == 42);
   val <<= 3;
-  assert( std::log2p1(val-1) == 44);
-  assert( std::log2p1(val)   == 45);
-  assert( std::log2p1(val+1) == 45);
+  assert( std::bit_width(val-1) == 44);
+  assert( std::bit_width(val)   == 45);
+  assert( std::bit_width(val+1) == 45);
   }
 #endif
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // template <class T>
-//   constexpr bool ispow2(T x) noexcept;
+//   constexpr bool has_single_bit(T x) noexcept;
 
 // Remarks: This function shall not participate in overload resolution unless
 //  T is an unsigned integer type
 
 #include <bit>
 #include <cstdint>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 class A{};
 enum       E1 : unsigned char { rEd };
 enum class E2 : unsigned char { red };
 
 template <typename T>
 constexpr bool constexpr_test()
 {
-  return  std::ispow2(T(1))
-     &&   std::ispow2(T(2))
-     &&  !std::ispow2(T(3))
-     &&   std::ispow2(T(4))
-     &&  !std::ispow2(T(5))
-     &&  !std::ispow2(T(6))
-     &&  !std::ispow2(T(7))
-     &&   std::ispow2(T(8))
-     &&  !std::ispow2(T(9))
+  return  std::has_single_bit(T(1))
+     &&   std::has_single_bit(T(2))
+     &&  !std::has_single_bit(T(3))
+     &&   std::has_single_bit(T(4))
+     &&  !std::has_single_bit(T(5))
+     &&  !std::has_single_bit(T(6))
+     &&  !std::has_single_bit(T(7))
+     &&   std::has_single_bit(T(8))
+     &&  !std::has_single_bit(T(9))
      ;
 }
 
 
 template <typename T>
 void runtime_test()
 {
-  ASSERT_SAME_TYPE(bool, decltype(std::ispow2(T(0))));
-  ASSERT_NOEXCEPT(                std::ispow2(T(0)));
+  ASSERT_SAME_TYPE(bool, decltype(std::has_single_bit(T(0))));
+  ASSERT_NOEXCEPT(                std::has_single_bit(T(0)));
 
-  assert(!std::ispow2(T(121)));
-  assert(!std::ispow2(T(122)));
-  assert(!std::ispow2(T(123)));
-  assert(!std::ispow2(T(124)));
-  assert(!std::ispow2(T(125)));
-  assert(!std::ispow2(T(126)));
-  assert(!std::ispow2(T(127)));
-  assert( std::ispow2(T(128)));
-  assert(!std::ispow2(T(129)));
-  assert(!std::ispow2(T(130)));
+  assert(!std::has_single_bit(T(121)));
+  assert(!std::has_single_bit(T(122)));
+  assert(!std::has_single_bit(T(123)));
+  assert(!std::has_single_bit(T(124)));
+  assert(!std::has_single_bit(T(125)));
+  assert(!std::has_single_bit(T(126)));
+  assert(!std::has_single_bit(T(127)));
+  assert( std::has_single_bit(T(128)));
+  assert(!std::has_single_bit(T(129)));
+  assert(!std::has_single_bit(T(130)));
 }
 
 int main(int, char**)
 {
 
     {
-    auto lambda = [](auto x) -> decltype(std::ispow2(x)) {};
+    auto lambda = [](auto x) -> decltype(std::has_single_bit(x)) {};
     using L = decltype(lambda);
 
     static_assert( std::is_invocable_v<L, unsigned char>, "");
     static_assert( std::is_invocable_v<L, unsigned int>, "");
     static_assert( std::is_invocable_v<L, unsigned long>, "");
     static_assert( std::is_invocable_v<L, unsigned long long>, "");
 
     static_assert( std::is_invocable_v<L, uint8_t>, "");
#endif
   runtime_test<uintptr_t>();
 
 #ifndef _LIBCPP_HAS_NO_INT128
   runtime_test<__uint128_t>();
 
   {
   __uint128_t val = 128;
   val <<= 32;
-  assert(!std::ispow2(val-1));
-  assert( std::ispow2(val));
-  assert(!std::ispow2(val+1));
+  assert(!std::has_single_bit(val-1));
+  assert( std::has_single_bit(val));
+  assert(!std::has_single_bit(val+1));
   val <<= 2;
-  assert(!std::ispow2(val-1));
-  assert( std::ispow2(val));
-  assert(!std::ispow2(val+1));
+  assert(!std::has_single_bit(val-1));
+  assert( std::has_single_bit(val));
+  assert(!std::has_single_bit(val+1));
   val <<= 3;
-  assert(!std::ispow2(val-1));
-  assert( std::ispow2(val));
-  assert(!std::ispow2(val+1));
+  assert(!std::has_single_bit(val-1));
+  assert( std::has_single_bit(val));
+  assert(!std::has_single_bit(val+1));
   }
 #endif
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/p1956_backwards_compatibility.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// P1956 Renamed several functions in the bit header. The old names are kept but
+// deprecated. This tests whether the compatibility layer works properly.
+
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
+#include <bit>
+#include <cstdint>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+constexpr bool constexpr_test() {
+  return std::has_single_bit(T(1)) == std::ispow2(T(1)) &&
+         std::has_single_bit(T(2)) == std::ispow2(T(2)) &&
+         std::has_single_bit(T(3)) == std::ispow2(T(3)) &&
+         std::has_single_bit(T(4)) == std::ispow2(T(4)) &&
+         std::has_single_bit(T(5)) == std::ispow2(T(5)) &&
+         std::has_single_bit(T(6)) == std::ispow2(T(6)) &&
+         std::has_single_bit(T(7)) == std::ispow2(T(7)) &&
+         std::has_single_bit(T(8)) == std::ispow2(T(8)) &&
+         std::has_single_bit(T(9)) == std::ispow2(T(9)) &&
+
+         std::bit_ceil(T(0)) == std::ceil2(T(0)) &&
+         std::bit_ceil(T(1)) == std::ceil2(T(1)) &&
+         std::bit_ceil(T(2)) == std::ceil2(T(2)) &&
+         std::bit_ceil(T(3)) == std::ceil2(T(3)) &&
+         std::bit_ceil(T(4)) == std::ceil2(T(4)) &&
+         std::bit_ceil(T(5)) == std::ceil2(T(5)) &&
+         std::bit_ceil(T(6)) == std::ceil2(T(6)) &&
+         std::bit_ceil(T(7)) == std::ceil2(T(7)) &&
+         std::bit_ceil(T(8)) == std::ceil2(T(8)) &&
+         std::bit_ceil(T(9)) == std::ceil2(T(9)) &&
+
+         std::bit_floor(T(0)) == std::floor2(T(0)) &&
+         std::bit_floor(T(1)) == std::floor2(T(1)) &&
+         std::bit_floor(T(2)) == std::floor2(T(2)) &&
+         std::bit_floor(T(3)) == std::floor2(T(3)) &&
+         std::bit_floor(T(4)) == std::floor2(T(4)) &&
+         std::bit_floor(T(5)) == std::floor2(T(5)) &&
+         std::bit_floor(T(6)) == std::floor2(T(6)) &&
+         std::bit_floor(T(7)) == std::floor2(T(7)) &&
+         std::bit_floor(T(8)) == std::floor2(T(8)) &&
+         std::bit_floor(T(9)) == std::floor2(T(9)) &&
+
+         std::bit_width(T(0)) == std::log2p1(T(0)) &&
+         std::bit_width(T(1)) == std::log2p1(T(1)) &&
+         std::bit_width(T(2)) == std::log2p1(T(2)) &&
+         std::bit_width(T(3)) == std::log2p1(T(3)) &&
+         std::bit_width(T(4)) == std::log2p1(T(4)) &&
+         std::bit_width(T(5)) == std::log2p1(T(5)) &&
+         std::bit_width(T(6)) == std::log2p1(T(6)) &&
+         std::bit_width(T(7)) == std::log2p1(T(7)) &&
+         std::bit_width(T(8)) == std::log2p1(T(8)) &&
+         std::bit_width(T(9)) == std::log2p1(T(9));
+}
+
+template <typename T>
+void runtime_test() {
+  assert(std::has_single_bit(T(121)) == std::ispow2(T(121)));
+  assert(std::has_single_bit(T(122)) == std::ispow2(T(122)));
+  assert(std::has_single_bit(T(123)) == std::ispow2(T(123)));
+  assert(std::has_single_bit(T(124)) == std::ispow2(T(124)));
+  assert(std::has_single_bit(T(125)) == std::ispow2(T(125)));
+  assert(std::has_single_bit(T(126)) == std::ispow2(T(126)));
+  assert(std::has_single_bit(T(127)) == std::ispow2(T(127)));
+  assert(std::has_single_bit(T(128)) == std::ispow2(T(128)));
+  assert(std::has_single_bit(T(129)) == std::ispow2(T(129)));
+  assert(std::has_single_bit(T(130)) == std::ispow2(T(130)));
+
+  assert(std::bit_ceil(T(60)) == std::ceil2(T(60)));
+  assert(std::bit_ceil(T(61)) == std::ceil2(T(61)));
+  assert(std::bit_ceil(T(62)) == std::ceil2(T(62)));
+  assert(std::bit_ceil(T(63)) == std::ceil2(T(63)));
+  assert(std::bit_ceil(T(64)) == std::ceil2(T(64)));
+  assert(std::bit_ceil(T(65)) == std::ceil2(T(65)));
+  assert(std::bit_ceil(T(66)) == std::ceil2(T(66)));
+  assert(std::bit_ceil(T(67)) == std::ceil2(T(67)));
+  assert(std::bit_ceil(T(68)) == std::ceil2(T(68)));
+  assert(std::bit_ceil(T(69)) == std::ceil2(T(69)));
+
+  assert(std::bit_floor(T(121)) == std::bit_floor(T(121)));
+  assert(std::bit_floor(T(122)) == std::bit_floor(T(122)));
+  assert(std::bit_floor(T(123)) == std::bit_floor(T(123)));
+  assert(std::bit_floor(T(124)) == std::bit_floor(T(124)));
+  assert(std::bit_floor(T(125)) == std::bit_floor(T(125)));
+  assert(std::bit_floor(T(126)) == std::bit_floor(T(126)));
+  assert(std::bit_floor(T(127)) == std::bit_floor(T(127)));
+  assert(std::bit_floor(T(128)) == std::bit_floor(T(128)));
+  assert(std::bit_floor(T(129)) == std::bit_floor(T(129)));
+  assert(std::bit_floor(T(130)) == std::bit_floor(T(130)));
+
+  assert(std::bit_width(T(121)) == std::log2p1(T(121)));
+  assert(std::bit_width(T(122)) == std::log2p1(T(122)));
+  assert(std::bit_width(T(123)) == std::log2p1(T(123)));
+  assert(std::bit_width(T(124)) == std::log2p1(T(124)));
+  assert(std::bit_width(T(125)) == std::log2p1(T(125)));
+  assert(std::bit_width(T(126)) == std::log2p1(T(126)));
+  assert(std::bit_width(T(127)) == std::log2p1(T(127)));
+  assert(std::bit_width(T(128)) == std::log2p1(T(128)));
+  assert(std::bit_width(T(129)) == std::log2p1(T(129)));
+  assert(std::bit_width(T(130)) == std::log2p1(T(130)));
+}
+
+int main(int, char**) {
+
+  static_assert(constexpr_test<unsigned char>(), "");
+  static_assert(constexpr_test<unsigned short>(), "");
+  static_assert(constexpr_test<unsigned>(), "");
+  static_assert(constexpr_test<unsigned long>(), "");
+  static_assert(constexpr_test<unsigned long long>(), "");
+
+  static_assert(constexpr_test<uint8_t>(), "");
+  static_assert(constexpr_test<uint16_t>(), "");
+  static_assert(constexpr_test<uint32_t>(), "");
+  static_assert(constexpr_test<uint64_t>(), "");
+  static_assert(constexpr_test<size_t>(), "");
+  static_assert(constexpr_test<uintmax_t>(), "");
+  static_assert(constexpr_test<uintptr_t>(), "");
+
+#ifndef _LIBCPP_HAS_NO_INT128
+  static_assert(constexpr_test<__uint128_t>(), "");
+#endif
+
+  runtime_test<unsigned char>();
+  runtime_test<unsigned>();
+  runtime_test<unsigned short>();
+  runtime_test<unsigned long>();
+  runtime_test<unsigned long long>();
+
+  runtime_test<uint8_t>();
+  runtime_test<uint16_t>();
+  runtime_test<uint32_t>();
+  runtime_test<uint64_t>();
+  runtime_test<size_t>();
+  runtime_test<uintmax_t>();
+  runtime_test<uintptr_t>();
+
+#ifndef _LIBCPP_HAS_NO_INT128
+  runtime_test<__uint128_t>();
+
+  {
+    __uint128_t val = 128;
+    val <<= 32;
+    assert(!std::has_single_bit(val - 1));
+    assert(std::has_single_bit(val));
+    assert(!std::has_single_bit(val + 1));
+    val <<= 2;
+    assert(!std::has_single_bit(val - 1));
+    assert(std::has_single_bit(val));
+    assert(!std::has_single_bit(val + 1));
+    val <<= 3;
+    assert(!std::has_single_bit(val - 1));
+    assert(std::has_single_bit(val));
+    assert(!std::has_single_bit(val + 1));
+  }
+#endif
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = sorted([ add_version_header(x) for x in [
    }, {
     "name": "__cpp_lib_atomic_ref",
     "values": { "c++2a": int(201806) },
     "headers": ["atomic"],
     "unimplemented": True,
     "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
    }, {
+    "name": "__cpp_lib_int_pow2",
+    "values": { "c++2a": int(202002) },
+    "headers": ["bit"],
+   }, {
     "name": "__cpp_lib_interpolate",
     "values": { "c++2a": int(201902) },
     "headers": ["numeric"],
    }, {
     "name": "__cpp_lib_endian",
     "values": { "c++2a": int(201907) },
     "headers": ["bit"],
    }, {

libcxx/www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/P1115">P1115</a></td><td>LWG</td><td>Improving the Return Value of Erase-Like Algorithms II: Free erase/erase if</td><td>Prague</td><td>Complete</td><td>11.0</td></tr>
   <tr><td><a href="https://wg21.link/P1243">P1243</a></td><td>LWG</td><td>Rangify New Algorithms</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1460">P1460</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 20 - Utilities library</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1739">P1739</a></td><td>LWG</td><td>Avoid template bloat for safe_ranges in combination with "subrange-y" view adaptors</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1831">P1831</a></td><td>LWG</td><td>Deprecating volatile: library</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1868">P1868</a></td><td>LWG</td><td>width: clarifying units of width and precision in std::format</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1908">P1908</a></td><td>CWG</td><td>Reserving Attribute Namespaces for Future Use</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1937">P1937</a></td><td>CWG</td><td>Fixing inconsistencies between constexpr and consteval functions</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1956">P1956</a></td><td>LWG</td><td>On the names of low-level bit manipulation functions</td><td>Prague</td><td><i> </i></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P1956">P1956</a></td><td>LWG</td><td>On the names of low-level bit manipulation functions</td><td>Prague</td><td>Complete</td><td>12.0</td></tr>
   <tr><td><a href="https://wg21.link/P1957">P1957</a></td><td>CWG</td><td>Converting from T* to bool should be considered narrowing (re: US 212)</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1963">P1963</a></td><td>LWG</td><td>Fixing US 313</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1964">P1964</a></td><td>LWG</td><td>Wording for boolean-testable</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1970">P1970</a></td><td>LWG</td><td>Consistency for size() functions: Add ranges::ssize</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1973">P1973</a></td><td>LWG</td><td>Rename "_default_init" Functions, Rev1</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1976">P1976</a></td><td>LWG</td><td>Fixed-size span construction from dynamic range</td><td>Prague</td><td>Complete</td><td>11.0</td></tr>
   <tr><td><a href="https://wg21.link/P1981">P1981</a></td><td>LWG</td><td>Rename leap to leap_second</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1982">P1982</a></td><td>LWG</td><td>Rename link to time_zone_link</td><td>Prague</td><td><i> </i></td><td></td></tr>