Refactor

Author: winner245

libcxx/include/__algorithm/find.h

@@ -106,7 +106,7 @@ __find_bool(__bit_iterator<_Cp, _IsConst> __first, typename __size_difference_ty
   if (__first.__ctz_ != 0) {
     __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
     __storage_type __dn    = std::min(__clz_f, __n);
-    __storage_type __m     = std::__middle_mask<__storage_type>(__first.__ctz_, __clz_f - __dn);
+    __storage_type __m     = std::__middle_mask<__storage_type>(__clz_f - __dn, __first.__ctz_);
     __storage_type __b     = std::__invert_if<!_ToFind>(*__first.__seg_) & __m;
     if (__b)
       return _It(__first.__seg_, static_cast<unsigned>(std::__countr_zero(__b)));

libcxx/include/__bit/countr.h

@@ -40,73 +40,63 @@ _LIBCPP_BEGIN_NAMESPACE_STD
   return __builtin_ctzll(__x);
 }
 
-#if _LIBCPP_STD_VER >= 17
-// Implementation using constexpr if for C++ standards >= 17
+#ifndef _LIBCPP_CXX03_LANG
+// constexpr implementation for C++11 and later
 
-// Precondition: __t != 0 (This is guaranteed by the caller __countr_zero, which handles __t == 0 as a special case)
-template <class _Tp, __enable_if_t<is_unsigned<_Tp>::value, int> = 0>
-[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 int __countr_zero_impl(_Tp __t) _NOEXCEPT {
+// Precondition: __t != 0 (the caller __countr_zero handles __t == 0 as a special case)
+template <class _Tp>
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr int __countr_zero_impl(_Tp __t) _NOEXCEPT {
+  static_assert(is_unsigned<_Tp>::value, "__countr_zero_impl only works with unsigned types");
   if constexpr (sizeof(_Tp) <= sizeof(unsigned int)) {
     return std::__libcpp_ctz(static_cast<unsigned int>(__t));
   } else if constexpr (sizeof(_Tp) <= sizeof(unsigned long)) {
     return std::__libcpp_ctz(static_cast<unsigned long>(__t));
   } else if constexpr (sizeof(_Tp) <= sizeof(unsigned long long)) {
     return std::__libcpp_ctz(static_cast<unsigned long long>(__t));
   } else {
+#  if _LIBCPP_STD_VER == 11
+    // A recursive constexpr implementation for C++11
+    unsigned long long __ull       = static_cast<unsigned long long>(__t);
+    const unsigned int __ulldigits = numeric_limits<unsigned long long>::digits;
+    return __ull == 0ull ? __ulldigits + std::__countr_zero_impl<_Tp>(__t >> __ulldigits) : std::__libcpp_ctz(__ull);
+#  else
     int __ret                      = 0;
     const unsigned int __ulldigits = numeric_limits<unsigned long long>::digits;
     while (static_cast<unsigned long long>(__t) == 0uLL) {
       __ret += __ulldigits;
       __t >>= __ulldigits;
     }
     return __ret + std::__libcpp_ctz(static_cast<unsigned long long>(__t));
+#  endif
   }
 }
 
 #else
-// Equivalent SFINAE-based implementation for older C++ standards < 17
+// implementation for C++03
 
-// Precondition: __t != 0 (This is guaranteed by the caller __countr_zero, which handles __t == 0 as a special case)
 template < class _Tp, __enable_if_t<is_unsigned<_Tp>::value && sizeof(_Tp) <= sizeof(unsigned int), int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __countr_zero_impl(_Tp __t) _NOEXCEPT {
+_LIBCPP_HIDE_FROM_ABI int __countr_zero_impl(_Tp __t) {
   return std::__libcpp_ctz(static_cast<unsigned int>(__t));
 }
 
-// Precondition: __t != 0 (This is guaranteed by the caller __countr_zero)
 template < class _Tp,
            __enable_if_t<is_unsigned<_Tp>::value && (sizeof(_Tp) > sizeof(unsigned int)) &&
                              sizeof(_Tp) <= sizeof(unsigned long),
                          int> = 0 >
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __countr_zero_impl(_Tp __t) _NOEXCEPT {
+_LIBCPP_HIDE_FROM_ABI int __countr_zero_impl(_Tp __t) {
   return std::__libcpp_ctz(static_cast<unsigned long>(__t));
 }
 
-// Precondition: __t != 0 (This is guaranteed by the caller __countr_zero)
 template < class _Tp,
            __enable_if_t<is_unsigned<_Tp>::value && (sizeof(_Tp) > sizeof(unsigned long)) &&
                              sizeof(_Tp) <= sizeof(unsigned long long),
                          int> = 0 >
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __countr_zero_impl(_Tp __t) _NOEXCEPT {
+_LIBCPP_HIDE_FROM_ABI int __countr_zero_impl(_Tp __t) {
   return std::__libcpp_ctz(static_cast<unsigned long long>(__t));
 }
 
-#  if _LIBCPP_STD_VER == 11
-
-// Recursive constexpr implementation for C++11 due to limited constexpr support
-// Precondition: __t != 0 (This is guaranteed by the caller __countr_zero)
-template < class _Tp, __enable_if_t<is_unsigned<_Tp>::value && (sizeof(_Tp) > sizeof(unsigned long long)), int> = 0 >
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __countr_zero_impl(_Tp __t) _NOEXCEPT {
-  unsigned long long __ull       = static_cast<unsigned long long>(__t);
-  const unsigned int __ulldigits = numeric_limits<unsigned long long>::digits;
-  return __ull == 0ull ? __ulldigits + std::__countr_zero_impl<_Tp>(__t >> __ulldigits) : std::__libcpp_ctz(__ull);
-}
-
-#  else
-
-// Loop-based constexpr implementation for C++14 (and non-constexpr for C++03, 98)
-// Precondition: __t != 0 (This is guaranteed by the caller __countr_zero)
 template < class _Tp, __enable_if_t<is_unsigned<_Tp>::value && (sizeof(_Tp) > sizeof(unsigned long long)), int> = 0 >
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int __countr_zero_impl(_Tp __t) _NOEXCEPT {
+_LIBCPP_HIDE_FROM_ABI int __countr_zero_impl(_Tp __t) {
   int __ret                      = 0;
   const unsigned int __ulldigits = numeric_limits<unsigned long long>::digits;
   while (static_cast<unsigned long long>(__t) == 0uLL) {
@@ -116,16 +106,15 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int __countr_zero_impl(_Tp _
   return __ret + std::__libcpp_ctz(static_cast<unsigned long long>(__t));
 }
 
-#  endif // _LIBCPP_STD_VER == 11
-
-#endif // _LIBCPP_STD_VER >= 17
+#endif // _LIBCPP_CXX03_LANG
 
-template <class _Tp, __enable_if_t<is_unsigned<_Tp>::value, int> = 0>
+template <class _Tp>
 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __countr_zero(_Tp __t) _NOEXCEPT {
+  static_assert(is_unsigned<_Tp>::value, "__countr_zero only works with unsigned types");
 #if __has_builtin(__builtin_ctzg)
   return __builtin_ctzg(__t, numeric_limits<_Tp>::digits);
 #else
-  return __t != 0 ? __countr_zero_impl(__t) : numeric_limits<_Tp>::digits;
+  return __t != 0 ? std::__countr_zero_impl(__t) : numeric_limits<_Tp>::digits;
 #endif
 }
 

libcxx/include/__bit_reference

@@ -16,6 +16,7 @@
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__bit/countr.h>
+#include <__bit/invert_if.h>
 #include <__compare/ordering.h>
 #include <__config>
 #include <__cstddef/ptrdiff_t.h>
@@ -62,6 +63,20 @@ struct __size_difference_type_traits<_Cp, __void_t<typename _Cp::difference_type
   using size_type       = typename _Cp::size_type;
 };
 
+template <class _StorageType>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _StorageType __trailing_mask(unsigned __clz) {
+  static_assert(is_unsigned<_StorageType>::value, "__trailing_mask only works with unsigned types");
+  return static_cast<_StorageType>(static_cast<_StorageType>(~static_cast<_StorageType>(0)) >> __clz);
+}
+
+template <class _StorageType>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _StorageType __middle_mask(unsigned __clz, unsigned __ctz) {
+  static_assert(is_unsigned<_StorageType>::value, "__middle_mask only works with unsigned types");
+  return static_cast<_StorageType>(
+      static_cast<_StorageType>(static_cast<_StorageType>(~static_cast<_StorageType>(0)) << __ctz) &
+      std::__trailing_mask<_StorageType>(__clz));
+}
+
 // This function is designed to operate correctly even for smaller integral types like `uint8_t`, `uint16_t`,
 // or `unsigned short`. Casting back to _StorageType is crucial to prevent undefined behavior that can arise
 // from integral promotions.

libcxx/include/__fwd/bit_reference.h

@@ -10,9 +10,6 @@
 #define _LIBCPP___FWD_BIT_REFERENCE_H
 
 #include <__config>
-#include <__memory/pointer_traits.h>
-#include <__type_traits/enable_if.h>
-#include <__type_traits/is_unsigned.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -30,6 +27,12 @@ template <class _StoragePointer>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
 __fill_masked_range(_StoragePointer __word, unsigned __ctz, unsigned __clz, bool __fill_val);
 
+template <class _StorageType>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _StorageType __trailing_mask(unsigned __clz);
+
+template <class _StorageType>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _StorageType __middle_mask(unsigned __clz, unsigned __ctz);
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FWD_BIT_REFERENCE_H

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp

@@ -208,7 +208,7 @@ struct TestIntegerPromotions {
   }
 };
 
-TEST_CONSTEXPR_CXX20 void test_bititer_with_custom_sized_types() {
+TEST_CONSTEXPR_CXX20 void test_bit_iterator_with_custom_sized_types() {
   {
     using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
     std::vector<bool, Alloc> in(100, false, Alloc(1));
@@ -217,7 +217,7 @@ TEST_CONSTEXPR_CXX20 void test_bititer_with_custom_sized_types() {
   }
   {
     using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
-    std::vector<bool, Alloc> in(200, false, Alloc(1));
+    std::vector<bool, Alloc> in(199, false, Alloc(1));
     in[in.size() - 2] = true;
     assert(std::find(in.begin(), in.end(), true) == in.end() - 2);
   }
@@ -229,7 +229,7 @@ TEST_CONSTEXPR_CXX20 void test_bititer_with_custom_sized_types() {
   }
   {
     using Alloc = sized_allocator<bool, std::uint64_t, std::int64_t>;
-    std::vector<bool, Alloc> in(200, false, Alloc(1));
+    std::vector<bool, Alloc> in(257, false, Alloc(1));
     in[in.size() - 2] = true;
     assert(std::find(in.begin(), in.end(), true) == in.end() - 2);
   }
@@ -255,7 +255,7 @@ TEST_CONSTEXPR_CXX20 bool test() {
 #endif
 
   types::for_each(types::integral_types(), TestIntegerPromotions());
-  test_bititer_with_custom_sized_types();
+  test_bit_iterator_with_custom_sized_types();
 
   return true;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

@@ -121,7 +121,7 @@ class TriviallyComparable {
   bool operator==(const TriviallyComparable&) const = default;
 };
 
-constexpr void test_bititer_with_custom_sized_types() {
+constexpr void test_bit_iterator_with_custom_sized_types() {
   {
     using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
     std::vector<bool, Alloc> in(100, false, Alloc(1));
@@ -130,7 +130,7 @@ constexpr void test_bititer_with_custom_sized_types() {
   }
   {
     using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
-    std::vector<bool, Alloc> in(200, false, Alloc(1));
+    std::vector<bool, Alloc> in(199, false, Alloc(1));
     in[in.size() - 2] = true;
     assert(std::ranges::find(in, true) == in.end() - 2);
   }
@@ -142,7 +142,7 @@ constexpr void test_bititer_with_custom_sized_types() {
   }
   {
     using Alloc = sized_allocator<bool, std::uint64_t, std::int64_t>;
-    std::vector<bool, Alloc> in(200, false, Alloc(1));
+    std::vector<bool, Alloc> in(257, false, Alloc(1));
     in[in.size() - 2] = true;
     assert(std::ranges::find(in, true) == in.end() - 2);
   }
@@ -229,7 +229,7 @@ constexpr bool test() {
     }
   }
 
-  test_bititer_with_custom_sized_types();
+  test_bit_iterator_with_custom_sized_types();
 
   return true;
 }