1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP___BIT_REFERENCE
11#define _LIBCPP___BIT_REFERENCE
12
13#include <__algorithm/comp.h>
14#include <__algorithm/copy.h>
15#include <__algorithm/copy_backward.h>
16#include <__algorithm/copy_n.h>
17#include <__algorithm/equal.h>
18#include <__algorithm/fill_n.h>
19#include <__algorithm/in_out_result.h>
20#include <__algorithm/min.h>
21#include <__algorithm/rotate.h>
22#include <__algorithm/specialized_algorithms.h>
23#include <__assert>
24#include <__bit/countr.h>
25#include <__compare/ordering.h>
26#include <__config>
27#include <__cstddef/ptrdiff_t.h>
28#include <__cstddef/size_t.h>
29#include <__functional/identity.h>
30#include <__fwd/bit_reference.h>
31#include <__iterator/iterator_traits.h>
32#include <__memory/construct_at.h>
33#include <__memory/pointer_traits.h>
34#include <__type_traits/conditional.h>
35#include <__type_traits/desugars_to.h>
36#include <__type_traits/enable_if.h>
37#include <__type_traits/is_constant_evaluated.h>
38#include <__type_traits/is_unsigned.h>
39#include <__type_traits/void_t.h>
40#include <__utility/pair.h>
41#include <__utility/swap.h>
42#include <climits>
43
44#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
45# pragma GCC system_header
46#endif
47
48_LIBCPP_PUSH_MACROS
49#include <__undef_macros>
50
51_LIBCPP_BEGIN_NAMESPACE_STD
52
53template <class _Cp>
54class __bit_const_reference;
55
56template <class _Tp>
57struct __has_storage_type {
58 static const bool value = false;
59};
60
61template <class, class>
62struct __size_difference_type_traits {
63 using difference_type = ptrdiff_t;
64 using size_type = size_t;
65};
66
67template <class _Cp>
68struct __size_difference_type_traits<_Cp, __void_t<typename _Cp::difference_type, typename _Cp::size_type> > {
69 using difference_type = typename _Cp::difference_type;
70 using size_type = typename _Cp::size_type;
71};
72
73// The `__x_mask` functions are designed to work exclusively with any unsigned `_StorageType`s, including small
74// integral types such as unsigned char/short, `uint8_t`, and `uint16_t`. To prevent undefined behavior or
75// ambiguities due to integral promotions for the small integral types, all intermediate bitwise operations are
76// explicitly cast back to the unsigned `_StorageType`.
77
78// Creates a mask of type `_StorageType` with a specified number of leading zeros (__clz) and sets all remaining
79// bits to one.
80template <class _StorageType>
81_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _StorageType __trailing_mask(unsigned __clz) {
82 static_assert(is_unsigned<_StorageType>::value, "__trailing_mask only works with unsigned types");
83 return static_cast<_StorageType>(~static_cast<_StorageType>(0)) >> __clz;
84}
85
86// Creates a mask of type `_StorageType` with a specified number of trailing zeros (__ctz) and sets all remaining
87// bits to one.
88template <class _StorageType>
89_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _StorageType __leading_mask(unsigned __ctz) {
90 static_assert(is_unsigned<_StorageType>::value, "__leading_mask only works with unsigned types");
91 return static_cast<_StorageType>(~static_cast<_StorageType>(0)) << __ctz;
92}
93
94// Creates a mask of type `_StorageType` with a specified number of leading zeros (__clz), a specified number of
95// trailing zeros (__ctz), and sets all bits in between to one.
96template <class _StorageType>
97_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _StorageType __middle_mask(unsigned __clz, unsigned __ctz) {
98 static_assert(is_unsigned<_StorageType>::value, "__middle_mask only works with unsigned types");
99 return std::__leading_mask<_StorageType>(__ctz) & std::__trailing_mask<_StorageType>(__clz);
100}
101
102// This function is designed to operate correctly even for smaller integral types like `uint8_t`, `uint16_t`,
103// or `unsigned short`.
104// See https://github.com/llvm/llvm-project/pull/122410.
105template <class _StoragePointer>
106_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
107__fill_masked_range(_StoragePointer __word, unsigned __clz, unsigned __ctz, bool __fill_val) {
108 static_assert(is_unsigned<typename pointer_traits<_StoragePointer>::element_type>::value,
109 "__fill_masked_range must be called with unsigned type");
110 using _StorageType = typename pointer_traits<_StoragePointer>::element_type;
111 _LIBCPP_ASSERT_VALID_INPUT_RANGE(
112 __ctz + __clz < sizeof(_StorageType) * CHAR_BIT, "__fill_masked_range called with invalid range");
113 _StorageType __m = std::__middle_mask<_StorageType>(__clz, __ctz);
114 if (__fill_val)
115 *__word |= __m;
116 else
117 *__word &= ~__m;
118}
119
120template <class _Cp, bool = __has_storage_type<_Cp>::value>
121class __bit_reference {
122 using __storage_type _LIBCPP_NODEBUG = typename _Cp::__storage_type;
123 using __storage_pointer _LIBCPP_NODEBUG = typename _Cp::__storage_pointer;
124
125 __storage_pointer __seg_;
126 __storage_type __mask_;
127
128 friend typename _Cp::__self;
129
130 friend class __bit_const_reference<_Cp>;
131 friend class __bit_iterator<_Cp, false>;
132
133public:
134 using __container _LIBCPP_NODEBUG = typename _Cp::__self;
135
136 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_reference(const __bit_reference&) = default;
137
138 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 operator bool() const _NOEXCEPT {
139 return static_cast<bool>(*__seg_ & __mask_);
140 }
141 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool operator~() const _NOEXCEPT {
142 return !static_cast<bool>(*this);
143 }
144
145 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_reference& operator=(bool __x) _NOEXCEPT {
146 if (__x)
147 *__seg_ |= __mask_;
148 else
149 *__seg_ &= ~__mask_;
150 return *this;
151 }
152
153#if _LIBCPP_STD_VER >= 23
154 _LIBCPP_HIDE_FROM_ABI constexpr const __bit_reference& operator=(bool __x) const noexcept {
155 if (__x)
156 *__seg_ |= __mask_;
157 else
158 *__seg_ &= ~__mask_;
159 return *this;
160 }
161#endif
162
163 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT {
164 return operator=(static_cast<bool>(__x));
165 }
166
167 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void flip() _NOEXCEPT { *__seg_ ^= __mask_; }
168
169private:
170 _LIBCPP_HIDE_FROM_ABI
171 _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit __bit_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
172 : __seg_(__s),
173 __mask_(__m) {}
174};
175
176template <class _Cp>
177class __bit_reference<_Cp, false> {};
178
179template <class _Cp>
180inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
181swap(__bit_reference<_Cp> __x, __bit_reference<_Cp> __y) _NOEXCEPT {
182 bool __t = __x;
183 __x = __y;
184 __y = __t;
185}
186
187template <class _Cp, class _Dp>
188inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
189swap(__bit_reference<_Cp> __x, __bit_reference<_Dp> __y) _NOEXCEPT {
190 bool __t = __x;
191 __x = __y;
192 __y = __t;
193}
194
195template <class _Cp>
196inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(__bit_reference<_Cp> __x, bool& __y) _NOEXCEPT {
197 bool __t = __x;
198 __x = __y;
199 __y = __t;
200}
201
202template <class _Cp>
203inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(bool& __x, __bit_reference<_Cp> __y) _NOEXCEPT {
204 bool __t = __x;
205 __x = __y;
206 __y = __t;
207}
208
209template <class _Cp>
210class __bit_const_reference {
211 using __storage_type _LIBCPP_NODEBUG = typename _Cp::__storage_type;
212 using __storage_pointer _LIBCPP_NODEBUG = typename _Cp::__const_storage_pointer;
213
214 __storage_pointer __seg_;
215 __storage_type __mask_;
216
217 friend typename _Cp::__self;
218 friend class __bit_iterator<_Cp, true>;
219
220public:
221 using __container _LIBCPP_NODEBUG = typename _Cp::__self;
222
223 _LIBCPP_HIDE_FROM_ABI __bit_const_reference(const __bit_const_reference&) = default;
224 __bit_const_reference& operator=(const __bit_const_reference&) = delete;
225
226 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_const_reference(const __bit_reference<_Cp>& __x) _NOEXCEPT
227 : __seg_(__x.__seg_),
228 __mask_(__x.__mask_) {}
229
230 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR operator bool() const _NOEXCEPT {
231 return static_cast<bool>(*__seg_ & __mask_);
232 }
233
234 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cp, true> operator&() const _NOEXCEPT {
235 return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(std::__countr_zero(__mask_)));
236 }
237
238private:
239 _LIBCPP_HIDE_FROM_ABI
240 _LIBCPP_CONSTEXPR explicit __bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
241 : __seg_(__s),
242 __mask_(__m) {}
243};
244
245template <class _Cp>
246struct __bit_array {
247 using difference_type _LIBCPP_NODEBUG = typename __size_difference_type_traits<_Cp>::difference_type;
248 using __storage_type _LIBCPP_NODEBUG = typename _Cp::__storage_type;
249 using __storage_pointer _LIBCPP_NODEBUG = typename _Cp::__storage_pointer;
250 using iterator _LIBCPP_NODEBUG = typename _Cp::iterator;
251
252 static const unsigned __bits_per_word = _Cp::__bits_per_word;
253 static const unsigned _Np = 4;
254
255 difference_type __size_;
256 __storage_type __word_[_Np];
257
258 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static difference_type capacity() {
259 return static_cast<difference_type>(_Np * __bits_per_word);
260 }
261 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit __bit_array(difference_type __s) : __size_(__s) {
262 if (__libcpp_is_constant_evaluated()) {
263 for (size_t __i = 0; __i != __bit_array<_Cp>::_Np; ++__i)
264 std::__construct_at(__word_ + __i, 0);
265 }
266 }
267 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator begin() {
268 return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]), 0);
269 }
270 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator end() {
271 return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]) + __size_ / __bits_per_word,
272 static_cast<unsigned>(__size_ % __bits_per_word));
273 }
274};
275
276template <class _Cp, bool _IsConst, typename _Cp::__storage_type>
277class __bit_iterator {
278public:
279 using difference_type = typename __size_difference_type_traits<_Cp>::difference_type;
280 using value_type = bool;
281 using pointer = __bit_iterator;
282#ifndef _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
283 using reference = __conditional_t<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >;
284#else
285 using reference = __conditional_t<_IsConst, bool, __bit_reference<_Cp> >;
286#endif
287 using iterator_category = random_access_iterator_tag;
288
289private:
290 using __storage_type _LIBCPP_NODEBUG = typename _Cp::__storage_type;
291 using __storage_pointer _LIBCPP_NODEBUG =
292 __conditional_t<_IsConst, typename _Cp::__const_storage_pointer, typename _Cp::__storage_pointer>;
293
294 static const unsigned __bits_per_word = _Cp::__bits_per_word;
295
296 __storage_pointer __seg_;
297 unsigned __ctz_;
298
299public:
300 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator() _NOEXCEPT
301#if _LIBCPP_STD_VER >= 14
302 : __seg_(nullptr),
303 __ctz_(0)
304#endif
305 {
306 }
307
308#ifdef _LIBCPP_ABI_TRIVIALLY_COPYABLE_BIT_ITERATOR
309 template <bool _IsConstDep = _IsConst, __enable_if_t<_IsConstDep, int> = 0>
310 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT
311 : __seg_(__it.__seg_),
312 __ctz_(__it.__ctz_) {}
313
314 _LIBCPP_HIDE_FROM_ABI __bit_iterator(const __bit_iterator&) = default;
315 _LIBCPP_HIDE_FROM_ABI __bit_iterator& operator=(const __bit_iterator&) = default;
316#else
317 // When _IsConst=false, this is the copy constructor.
318 // It is non-trivial. Making it trivial would break ABI.
319 // When _IsConst=true, this is a converting constructor;
320 // the copy and move constructors are implicitly generated
321 // and trivial.
322 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT
323 : __seg_(__it.__seg_),
324 __ctz_(__it.__ctz_) {}
325
326 // When _IsConst=false, we have a user-provided copy constructor,
327 // so we must also provide a copy assignment operator because
328 // the implicit generation of a defaulted one is deprecated.
329 // When _IsConst=true, the assignment operators are
330 // implicitly generated and trivial.
331 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator&
332 operator=(const _If<_IsConst, struct __private_nat, __bit_iterator>& __it) {
333 __seg_ = __it.__seg_;
334 __ctz_ = __it.__ctz_;
335 return *this;
336 }
337#endif
338
339 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference operator*() const _NOEXCEPT {
340 _LIBCPP_ASSERT_INTERNAL(__ctz_ < __bits_per_word, "Dereferencing an invalid __bit_iterator.");
341 return __conditional_t<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >(
342 __seg_, __storage_type(1) << __ctz_);
343 }
344
345 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator& operator++() {
346 if (__ctz_ != __bits_per_word - 1)
347 ++__ctz_;
348 else {
349 __ctz_ = 0;
350 ++__seg_;
351 }
352 return *this;
353 }
354
355 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator operator++(int) {
356 __bit_iterator __tmp = *this;
357 ++(*this);
358 return __tmp;
359 }
360
361 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator& operator--() {
362 if (__ctz_ != 0)
363 --__ctz_;
364 else {
365 __ctz_ = __bits_per_word - 1;
366 --__seg_;
367 }
368 return *this;
369 }
370
371 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator operator--(int) {
372 __bit_iterator __tmp = *this;
373 --(*this);
374 return __tmp;
375 }
376
377 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator& operator+=(difference_type __n) {
378 if (__n >= 0)
379 __seg_ += (__n + __ctz_) / __bits_per_word;
380 else
381 __seg_ += static_cast<difference_type>(__n - __bits_per_word + __ctz_ + 1) /
382 static_cast<difference_type>(__bits_per_word);
383 __n &= (__bits_per_word - 1);
384 __ctz_ = static_cast<unsigned>((__n + __ctz_) % __bits_per_word);
385 return *this;
386 }
387
388 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator& operator-=(difference_type __n) {
389 return *this += -__n;
390 }
391
392 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator
393 operator+(difference_type __n) const {
394 __bit_iterator __t(*this);
395 __t += __n;
396 return __t;
397 }
398
399 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator
400 operator-(difference_type __n) const {
401 __bit_iterator __t(*this);
402 __t -= __n;
403 return __t;
404 }
405
406 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator
407 operator+(difference_type __n, const __bit_iterator& __it) {
408 return __it + __n;
409 }
410
411 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend difference_type
412 operator-(const __bit_iterator& __x, const __bit_iterator& __y) {
413 return (__x.__seg_ - __y.__seg_) * __bits_per_word + __x.__ctz_ - __y.__ctz_;
414 }
415
416 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference
417 operator[](difference_type __n) const {
418 return *(*this + __n);
419 }
420
421 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
422 operator==(const __bit_iterator& __x, const __bit_iterator& __y) {
423 return __x.__seg_ == __y.__seg_ && __x.__ctz_ == __y.__ctz_;
424 }
425
426#if _LIBCPP_STD_VER <= 17
427 _LIBCPP_HIDE_FROM_ABI
428 _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool operator!=(const __bit_iterator& __x, const __bit_iterator& __y) {
429 return !(__x == __y);
430 }
431
432 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
433 operator<(const __bit_iterator& __x, const __bit_iterator& __y) {
434 return __x.__seg_ < __y.__seg_ || (__x.__seg_ == __y.__seg_ && __x.__ctz_ < __y.__ctz_);
435 }
436
437 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
438 operator>(const __bit_iterator& __x, const __bit_iterator& __y) {
439 return __y < __x;
440 }
441
442 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
443 operator<=(const __bit_iterator& __x, const __bit_iterator& __y) {
444 return !(__y < __x);
445 }
446
447 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
448 operator>=(const __bit_iterator& __x, const __bit_iterator& __y) {
449 return !(__x < __y);
450 }
451#else // _LIBCPP_STD_VER <= 17
452 _LIBCPP_HIDE_FROM_ABI constexpr friend strong_ordering
453 operator<=>(const __bit_iterator& __x, const __bit_iterator& __y) {
454 if (__x.__seg_ < __y.__seg_)
455 return strong_ordering::less;
456
457 if (__x.__seg_ == __y.__seg_)
458 return __x.__ctz_ <=> __y.__ctz_;
459
460 return strong_ordering::greater;
461 }
462#endif // _LIBCPP_STD_VER <= 17
463
464private:
465 _LIBCPP_HIDE_FROM_ABI
466 _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit __bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT
467 : __seg_(__s),
468 __ctz_(__ctz) {
469 _LIBCPP_ASSERT_INTERNAL(
470 __ctz_ < __bits_per_word, "__bit_iterator initialized with an invalid number of trailing zeros.");
471 }
472
473 friend typename _Cp::__self;
474
475 friend class __bit_reference<_Cp>;
476 friend class __bit_const_reference<_Cp>;
477 friend class __bit_iterator<_Cp, true>;
478 template <class _Dp>
479 friend struct __bit_array;
480
481 template <class _Dp, bool _IC>
482 _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false> __copy_backward_aligned(
483 __bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
484 template <class _Dp, bool _IC>
485 _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false> __copy_backward_unaligned(
486 __bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
487 template <class _AlgPolicy>
488 friend struct __copy_backward_impl;
489 template <class, class _Dp>
490 _LIBCPP_CONSTEXPR_SINCE_CXX20 friend pair<__bit_iterator<_Dp, false>, __bit_iterator<_Dp, false> >
491 __rotate(__bit_iterator<_Dp, false>, __bit_iterator<_Dp, false>, __bit_iterator<_Dp, false>);
492 template <class _Dp, bool _IsConst1, bool _IsConst2>
493 _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
494 __equal_aligned(__bit_iterator<_Dp, _IsConst1>, __bit_iterator<_Dp, _IsConst1>, __bit_iterator<_Dp, _IsConst2>);
495 template <class _Dp, bool _IsConst1, bool _IsConst2>
496 _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
497 __equal_unaligned(__bit_iterator<_Dp, _IsConst1>, __bit_iterator<_Dp, _IsConst1>, __bit_iterator<_Dp, _IsConst2>);
498 template <class _Dp,
499 bool _IsConst1,
500 bool _IsConst2,
501 class _BinaryPredicate,
502 class _Proj1,
503 class _Proj2,
504 __enable_if_t<__is_identity<_Proj1>::value && __is_identity<_Proj2>::value &&
505 __desugars_to_v<__equal_tag, _BinaryPredicate, bool, bool>,
506 int> >
507 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool __equal_iter_impl(
508 __bit_iterator<_Dp, _IsConst1>,
509 __bit_iterator<_Dp, _IsConst1>,
510 __bit_iterator<_Dp, _IsConst2>,
511 _BinaryPredicate,
512 _Proj1&,
513 _Proj2&);
514 template <bool,
515 class _Dp,
516 bool _IsConst1,
517 bool _IsConst2,
518 class _Pred,
519 class _Proj1,
520 class _Proj2,
521 __enable_if_t<__desugars_to_v<__equal_tag, _Pred, bool, bool> && __is_identity<_Proj1>::value &&
522 __is_identity<_Proj2>::value,
523 int> >
524 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool __equal_impl(
525 __bit_iterator<_Dp, _IsConst1> __first1,
526 __bit_iterator<_Dp, _IsConst1> __last1,
527 __bit_iterator<_Dp, _IsConst2> __first2,
528 __bit_iterator<_Dp, _IsConst2>,
529 _Pred&,
530 _Proj1&,
531 _Proj2&);
532 template <bool _ToFind, class _Dp, bool _IC>
533 _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, _IC>
534 __find_bool(__bit_iterator<_Dp, _IC>, typename __size_difference_type_traits<_Dp>::size_type);
535 template <bool _ToCount, class _Dp, bool _IC>
536 friend typename __bit_iterator<_Dp, _IC>::difference_type _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
537 __count_bool(__bit_iterator<_Dp, _IC>, typename __size_difference_type_traits<_Dp>::size_type);
538
539 template <class, class...>
540 friend struct __specialized_algorithm;
541};
542
543template <class _Cp>
544struct __specialized_algorithm<_Algorithm::__fill_n, __single_iterator<__bit_iterator<_Cp, false> > > {
545 static const bool __has_algorithm = true;
546
547 template <bool _FillVal>
548 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static void
549 __impl(__bit_iterator<_Cp, false> __first, typename __size_difference_type_traits<_Cp>::size_type __n) {
550 using _It = __bit_iterator<_Cp, false>;
551 using __storage_type = typename _It::__storage_type;
552
553 const int __bits_per_word = _It::__bits_per_word;
554 // do first partial word
555 if (__first.__ctz_ != 0) {
556 __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
557 __storage_type __dn = std::min(__clz_f, __n);
558 std::__fill_masked_range(std::__to_address(__first.__seg_), __clz_f - __dn, __first.__ctz_, _FillVal);
559 __n -= __dn;
560 ++__first.__seg_;
561 }
562 // do middle whole words
563 __storage_type __nw = __n / __bits_per_word;
564 std::__fill_n(std::__to_address(__first.__seg_), __nw, _FillVal ? static_cast<__storage_type>(-1) : 0);
565 __n -= __nw * __bits_per_word;
566 // do last partial word
567 if (__n > 0) {
568 __first.__seg_ += __nw;
569 std::__fill_masked_range(std::__to_address(__first.__seg_), __bits_per_word - __n, 0u, _FillVal);
570 }
571 }
572
573 template <class _Size, class _Tp>
574 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static __bit_iterator<_Cp, false>
575 operator()(__bit_iterator<_Cp, false> __first, _Size __n, const _Tp& __value) {
576 if (__n <= 0)
577 return __first;
578
579 if (__value)
580 __impl<true>(__first, __n);
581 else
582 __impl<false>(__first, __n);
583 return __first + __n;
584 }
585};
586
587template <class _Cp, bool _IsConst>
588struct __specialized_algorithm<_Algorithm::__copy,
589 __iterator_pair<__bit_iterator<_Cp, _IsConst>, __bit_iterator<_Cp, _IsConst> >,
590 __single_iterator<__bit_iterator<_Cp, false> > > {
591 static const bool __has_algorithm = true;
592
593 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static __bit_iterator<_Cp, false>
594 __aligned_impl(__bit_iterator<_Cp, _IsConst> __first,
595 __bit_iterator<_Cp, _IsConst> __last,
596 __bit_iterator<_Cp, false> __result) {
597 using _In = __bit_iterator<_Cp, _IsConst>;
598 using difference_type = typename _In::difference_type;
599 using __storage_type = typename _In::__storage_type;
600
601 const int __bits_per_word = _In::__bits_per_word;
602 difference_type __n = __last - __first;
603 if (__n > 0) {
604 // do first word
605 if (__first.__ctz_ != 0) {
606 unsigned __clz = __bits_per_word - __first.__ctz_;
607 difference_type __dn = std::min(static_cast<difference_type>(__clz), __n);
608 __n -= __dn;
609 __storage_type __m = std::__middle_mask<__storage_type>(__clz - __dn, __first.__ctz_);
610 __storage_type __b = *__first.__seg_ & __m;
611 *__result.__seg_ &= ~__m;
612 *__result.__seg_ |= __b;
613 __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
614 __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
615 ++__first.__seg_;
616 // __first.__ctz_ = 0;
617 }
618 // __first.__ctz_ == 0;
619 // do middle words
620 __storage_type __nw = __n / __bits_per_word;
621 std::copy(std::__to_address(__first.__seg_),
622 std::__to_address(__first.__seg_ + __nw),
623 std::__to_address(__result.__seg_));
624 __n -= __nw * __bits_per_word;
625 __result.__seg_ += __nw;
626 // do last word
627 if (__n > 0) {
628 __first.__seg_ += __nw;
629 __storage_type __m = std::__trailing_mask<__storage_type>(__bits_per_word - __n);
630 __storage_type __b = *__first.__seg_ & __m;
631 *__result.__seg_ &= ~__m;
632 *__result.__seg_ |= __b;
633 __result.__ctz_ = static_cast<unsigned>(__n);
634 }
635 }
636 return __result;
637 }
638
639 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static __bit_iterator<_Cp, false>
640 __unaligned_impl(__bit_iterator<_Cp, _IsConst> __first,
641 __bit_iterator<_Cp, _IsConst> __last,
642 __bit_iterator<_Cp, false> __result) {
643 using _In = __bit_iterator<_Cp, _IsConst>;
644 using difference_type = typename _In::difference_type;
645 using __storage_type = typename _In::__storage_type;
646
647 const int __bits_per_word = _In::__bits_per_word;
648 difference_type __n = __last - __first;
649 if (__n > 0) {
650 // do first word
651 if (__first.__ctz_ != 0) {
652 unsigned __clz_f = __bits_per_word - __first.__ctz_;
653 difference_type __dn = std::min(static_cast<difference_type>(__clz_f), __n);
654 __n -= __dn;
655 __storage_type __m = std::__middle_mask<__storage_type>(__clz_f - __dn, __first.__ctz_);
656 __storage_type __b = *__first.__seg_ & __m;
657 unsigned __clz_r = __bits_per_word - __result.__ctz_;
658 __storage_type __ddn = std::min<__storage_type>(__dn, __clz_r);
659 __m = std::__middle_mask<__storage_type>(__clz_r - __ddn, __result.__ctz_);
660 *__result.__seg_ &= ~__m;
661 if (__result.__ctz_ > __first.__ctz_)
662 *__result.__seg_ |= __b << (__result.__ctz_ - __first.__ctz_);
663 else
664 *__result.__seg_ |= __b >> (__first.__ctz_ - __result.__ctz_);
665 __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
666 __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_) % __bits_per_word);
667 __dn -= __ddn;
668 if (__dn > 0) {
669 __m = std::__trailing_mask<__storage_type>(__bits_per_word - __dn);
670 *__result.__seg_ &= ~__m;
671 *__result.__seg_ |= __b >> (__first.__ctz_ + __ddn);
672 __result.__ctz_ = static_cast<unsigned>(__dn);
673 }
674 ++__first.__seg_;
675 // __first.__ctz_ = 0;
676 }
677 // __first.__ctz_ == 0;
678 // do middle words
679 unsigned __clz_r = __bits_per_word - __result.__ctz_;
680 __storage_type __m = std::__leading_mask<__storage_type>(__result.__ctz_);
681 for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_) {
682 __storage_type __b = *__first.__seg_;
683 *__result.__seg_ &= ~__m;
684 *__result.__seg_ |= __b << __result.__ctz_;
685 ++__result.__seg_;
686 *__result.__seg_ &= __m;
687 *__result.__seg_ |= __b >> __clz_r;
688 }
689 // do last word
690 if (__n > 0) {
691 __m = std::__trailing_mask<__storage_type>(__bits_per_word - __n);
692 __storage_type __b = *__first.__seg_ & __m;
693 __storage_type __dn = std::min(__n, static_cast<difference_type>(__clz_r));
694 __m = std::__middle_mask<__storage_type>(__clz_r - __dn, __result.__ctz_);
695 *__result.__seg_ &= ~__m;
696 *__result.__seg_ |= __b << __result.__ctz_;
697 __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
698 __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
699 __n -= __dn;
700 if (__n > 0) {
701 __m = std::__trailing_mask<__storage_type>(__bits_per_word - __n);
702 *__result.__seg_ &= ~__m;
703 *__result.__seg_ |= __b >> __dn;
704 __result.__ctz_ = static_cast<unsigned>(__n);
705 }
706 }
707 }
708 return __result;
709 }
710
711 _LIBCPP_HIDE_FROM_ABI
712 _LIBCPP_CONSTEXPR_SINCE_CXX20 static __in_out_result<__bit_iterator<_Cp, _IsConst>, __bit_iterator<_Cp, false> >
713 operator()(__bit_iterator<_Cp, _IsConst> __first,
714 __bit_iterator<_Cp, _IsConst> __last,
715 __bit_iterator<_Cp, false> __result) {
716 if (__first.__ctz_ == __result.__ctz_)
717 return {__last, __aligned_impl(__first, __last, __result)};
718 return {__last, __unaligned_impl(__first, __last, __result)};
719 }
720};
721
722template <class _Cl, class _Cr>
723struct __specialized_algorithm<_Algorithm::__swap_ranges,
724 __iterator_pair<__bit_iterator<_Cl, false>, __bit_iterator<_Cl, false> >,
725 __single_iterator<__bit_iterator<_Cr, false> > > {
726 static const bool __has_algorithm = true;
727
728 _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cr, false> __aligned_impl(
729 __bit_iterator<_Cl, false> __first, __bit_iterator<_Cl, false> __last, __bit_iterator<_Cr, false> __result) {
730 using _I1 = __bit_iterator<_Cl, false>;
731 using difference_type = typename _I1::difference_type;
732 using __storage_type = typename _I1::__storage_type;
733
734 const int __bits_per_word = _I1::__bits_per_word;
735 difference_type __n = __last - __first;
736 if (__n > 0) {
737 // do first word
738 if (__first.__ctz_ != 0) {
739 unsigned __clz = __bits_per_word - __first.__ctz_;
740 difference_type __dn = std::min(static_cast<difference_type>(__clz), __n);
741 __n -= __dn;
742 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
743 __storage_type __b1 = *__first.__seg_ & __m;
744 *__first.__seg_ &= ~__m;
745 __storage_type __b2 = *__result.__seg_ & __m;
746 *__result.__seg_ &= ~__m;
747 *__result.__seg_ |= __b1;
748 *__first.__seg_ |= __b2;
749 __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
750 __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
751 ++__first.__seg_;
752 // __first.__ctz_ = 0;
753 }
754 // __first.__ctz_ == 0;
755 // do middle words
756 for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_, ++__result.__seg_)
757 swap(*__first.__seg_, *__result.__seg_);
758 // do last word
759 if (__n > 0) {
760 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
761 __storage_type __b1 = *__first.__seg_ & __m;
762 *__first.__seg_ &= ~__m;
763 __storage_type __b2 = *__result.__seg_ & __m;
764 *__result.__seg_ &= ~__m;
765 *__result.__seg_ |= __b1;
766 *__first.__seg_ |= __b2;
767 __result.__ctz_ = static_cast<unsigned>(__n);
768 }
769 }
770 return __result;
771 }
772
773 _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cr, false> __unaligned_impl(
774 __bit_iterator<_Cl, false> __first, __bit_iterator<_Cl, false> __last, __bit_iterator<_Cr, false> __result) {
775 using _I1 = __bit_iterator<_Cl, false>;
776 using difference_type = typename _I1::difference_type;
777 using __storage_type = typename _I1::__storage_type;
778
779 const int __bits_per_word = _I1::__bits_per_word;
780 difference_type __n = __last - __first;
781 if (__n > 0) {
782 // do first word
783 if (__first.__ctz_ != 0) {
784 unsigned __clz_f = __bits_per_word - __first.__ctz_;
785 difference_type __dn = std::min(static_cast<difference_type>(__clz_f), __n);
786 __n -= __dn;
787 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
788 __storage_type __b1 = *__first.__seg_ & __m;
789 *__first.__seg_ &= ~__m;
790 unsigned __clz_r = __bits_per_word - __result.__ctz_;
791 __storage_type __ddn = std::min<__storage_type>(__dn, __clz_r);
792 __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
793 __storage_type __b2 = *__result.__seg_ & __m;
794 *__result.__seg_ &= ~__m;
795 if (__result.__ctz_ > __first.__ctz_) {
796 unsigned __s = __result.__ctz_ - __first.__ctz_;
797 *__result.__seg_ |= __b1 << __s;
798 *__first.__seg_ |= __b2 >> __s;
799 } else {
800 unsigned __s = __first.__ctz_ - __result.__ctz_;
801 *__result.__seg_ |= __b1 >> __s;
802 *__first.__seg_ |= __b2 << __s;
803 }
804 __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
805 __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_) % __bits_per_word);
806 __dn -= __ddn;
807 if (__dn > 0) {
808 __m = ~__storage_type(0) >> (__bits_per_word - __dn);
809 __b2 = *__result.__seg_ & __m;
810 *__result.__seg_ &= ~__m;
811 unsigned __s = __first.__ctz_ + __ddn;
812 *__result.__seg_ |= __b1 >> __s;
813 *__first.__seg_ |= __b2 << __s;
814 __result.__ctz_ = static_cast<unsigned>(__dn);
815 }
816 ++__first.__seg_;
817 // __first.__ctz_ = 0;
818 }
819 // __first.__ctz_ == 0;
820 // do middle words
821 __storage_type __m = ~__storage_type(0) << __result.__ctz_;
822 unsigned __clz_r = __bits_per_word - __result.__ctz_;
823 for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_) {
824 __storage_type __b1 = *__first.__seg_;
825 __storage_type __b2 = *__result.__seg_ & __m;
826 *__result.__seg_ &= ~__m;
827 *__result.__seg_ |= __b1 << __result.__ctz_;
828 *__first.__seg_ = __b2 >> __result.__ctz_;
829 ++__result.__seg_;
830 __b2 = *__result.__seg_ & ~__m;
831 *__result.__seg_ &= __m;
832 *__result.__seg_ |= __b1 >> __clz_r;
833 *__first.__seg_ |= __b2 << __clz_r;
834 }
835 // do last word
836 if (__n > 0) {
837 __m = ~__storage_type(0) >> (__bits_per_word - __n);
838 __storage_type __b1 = *__first.__seg_ & __m;
839 *__first.__seg_ &= ~__m;
840 __storage_type __dn = std::min<__storage_type>(__n, __clz_r);
841 __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
842 __storage_type __b2 = *__result.__seg_ & __m;
843 *__result.__seg_ &= ~__m;
844 *__result.__seg_ |= __b1 << __result.__ctz_;
845 *__first.__seg_ |= __b2 >> __result.__ctz_;
846 __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
847 __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
848 __n -= __dn;
849 if (__n > 0) {
850 __m = ~__storage_type(0) >> (__bits_per_word - __n);
851 __b2 = *__result.__seg_ & __m;
852 *__result.__seg_ &= ~__m;
853 *__result.__seg_ |= __b1 >> __dn;
854 *__first.__seg_ |= __b2 << __dn;
855 __result.__ctz_ = static_cast<unsigned>(__n);
856 }
857 }
858 }
859 return __result;
860 }
861
862 _LIBCPP_HIDE_FROM_ABI static
863 _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<__bit_iterator<_Cl, false>, __bit_iterator<_Cr, false> >
864 operator()(__bit_iterator<_Cl, false> __first1,
865 __bit_iterator<_Cl, false> __last1,
866 __bit_iterator<_Cr, false> __first2) {
867 if (__first1.__ctz_ == __first2.__ctz_)
868 return std::make_pair(__last1, __aligned_impl(first: __first1, last: __last1, result: __first2));
869 return std::make_pair(__last1, __unaligned_impl(first: __first1, last: __last1, result: __first2));
870 }
871};
872
873_LIBCPP_END_NAMESPACE_STD
874
875_LIBCPP_POP_MACROS
876
877#endif // _LIBCPP___BIT_REFERENCE
878