codekingpro/portable-devtools
114k
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-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCUDACXX___BIT_REFERENCE11#define _LIBCUDACXX___BIT_REFERENCE12 13#include <__config>14#include <bit>15#include <algorithm>16 17#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)18# pragma GCC system_header19#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)20# pragma clang system_header21#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)22# pragma system_header23#endif // no system header24 25_LIBCUDACXX_PUSH_MACROS26#include <__undef_macros>27 28 29_LIBCUDACXX_BEGIN_NAMESPACE_STD30 31template <class _Cp, bool _IsConst, typename _Cp::__storage_type = 0> class __bit_iterator;32template <class _Cp> class __bit_const_reference;33 34template <class _Tp>35struct __has_storage_type36{37 static const bool value = false;38};39 40template <class _Cp, bool = __has_storage_type<_Cp>::value>41class __bit_reference42{43 typedef typename _Cp::__storage_type __storage_type;44 typedef typename _Cp::__storage_pointer __storage_pointer;45 46 __storage_pointer __seg_;47 __storage_type __mask_;48 49 friend typename _Cp::__self;50 51 friend class __bit_const_reference<_Cp>;52 friend class __bit_iterator<_Cp, false>;53public:54 _LIBCUDACXX_INLINE_VISIBILITY55 __bit_reference(const __bit_reference&) = default;56 57 _LIBCUDACXX_INLINE_VISIBILITY operator bool() const noexcept58 {return static_cast<bool>(*__seg_ & __mask_);}59 _LIBCUDACXX_INLINE_VISIBILITY bool operator ~() const noexcept60 {return !static_cast<bool>(*this);}61 62 _LIBCUDACXX_INLINE_VISIBILITY63 __bit_reference& operator=(bool __x) noexcept64 {65 if (__x)66 *__seg_ |= __mask_;67 else68 *__seg_ &= ~__mask_;69 return *this;70 }71 72 _LIBCUDACXX_INLINE_VISIBILITY73 __bit_reference& operator=(const __bit_reference& __x) noexcept74 {return operator=(static_cast<bool>(__x));}75 76 _LIBCUDACXX_INLINE_VISIBILITY void flip() noexcept {*__seg_ ^= __mask_;}77 _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator<_Cp, false> operator&() const noexcept78 {return __bit_iterator<_Cp, false>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}79private:80 _LIBCUDACXX_INLINE_VISIBILITY81 __bit_reference(__storage_pointer __s, __storage_type __m) noexcept82 : __seg_(__s), __mask_(__m) {}83};84 85template <class _Cp>86class __bit_reference<_Cp, false>87{88};89 90template <class _Cp>91inline _LIBCUDACXX_INLINE_VISIBILITY92void93swap(__bit_reference<_Cp> __x, __bit_reference<_Cp> __y) noexcept94{95 bool __t = __x;96 __x = __y;97 __y = __t;98}99 100template <class _Cp, class _Dp>101inline _LIBCUDACXX_INLINE_VISIBILITY102void103swap(__bit_reference<_Cp> __x, __bit_reference<_Dp> __y) noexcept104{105 bool __t = __x;106 __x = __y;107 __y = __t;108}109 110template <class _Cp>111inline _LIBCUDACXX_INLINE_VISIBILITY112void113swap(__bit_reference<_Cp> __x, bool& __y) noexcept114{115 bool __t = __x;116 __x = __y;117 __y = __t;118}119 120template <class _Cp>121inline _LIBCUDACXX_INLINE_VISIBILITY122void123swap(bool& __x, __bit_reference<_Cp> __y) noexcept124{125 bool __t = __x;126 __x = __y;127 __y = __t;128}129 130template <class _Cp>131class __bit_const_reference132{133 typedef typename _Cp::__storage_type __storage_type;134 typedef typename _Cp::__const_storage_pointer __storage_pointer;135 136 __storage_pointer __seg_;137 __storage_type __mask_;138 139 friend typename _Cp::__self;140 friend class __bit_iterator<_Cp, true>;141public:142 _LIBCUDACXX_INLINE_VISIBILITY143 __bit_const_reference(const __bit_const_reference&) = default;144 145 _LIBCUDACXX_INLINE_VISIBILITY146 __bit_const_reference(const __bit_reference<_Cp>& __x) noexcept147 : __seg_(__x.__seg_), __mask_(__x.__mask_) {}148 149 _LIBCUDACXX_INLINE_VISIBILITY constexpr operator bool() const noexcept150 {return static_cast<bool>(*__seg_ & __mask_);}151 152 _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator<_Cp, true> operator&() const noexcept153 {return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}154private:155 _LIBCUDACXX_INLINE_VISIBILITY156 constexpr157 __bit_const_reference(__storage_pointer __s, __storage_type __m) noexcept158 : __seg_(__s), __mask_(__m) {}159 160 __bit_const_reference& operator=(const __bit_const_reference&) = delete;161};162 163// find164 165template <class _Cp, bool _IsConst>166__bit_iterator<_Cp, _IsConst>167__find_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)168{169 typedef __bit_iterator<_Cp, _IsConst> _It;170 typedef typename _It::__storage_type __storage_type;171 static const int __bits_per_word = _It::__bits_per_word;172 // do first partial word173 if (__first.__ctz_ != 0)174 {175 __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);176 __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);177 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));178 __storage_type __b = *__first.__seg_ & __m;179 if (__b)180 return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));181 if (__n == __dn)182 return __first + __n;183 __n -= __dn;184 ++__first.__seg_;185 }186 // do middle whole words187 for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)188 if (*__first.__seg_)189 return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(*__first.__seg_)));190 // do last partial word191 if (__n > 0)192 {193 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);194 __storage_type __b = *__first.__seg_ & __m;195 if (__b)196 return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));197 }198 return _It(__first.__seg_, static_cast<unsigned>(__n));199}200 201template <class _Cp, bool _IsConst>202__bit_iterator<_Cp, _IsConst>203__find_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)204{205 typedef __bit_iterator<_Cp, _IsConst> _It;206 typedef typename _It::__storage_type __storage_type;207 const int __bits_per_word = _It::__bits_per_word;208 // do first partial word209 if (__first.__ctz_ != 0)210 {211 __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);212 __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);213 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));214 __storage_type __b = ~*__first.__seg_ & __m;215 if (__b)216 return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));217 if (__n == __dn)218 return __first + __n;219 __n -= __dn;220 ++__first.__seg_;221 }222 // do middle whole words223 for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)224 {225 __storage_type __b = ~*__first.__seg_;226 if (__b)227 return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));228 }229 // do last partial word230 if (__n > 0)231 {232 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);233 __storage_type __b = ~*__first.__seg_ & __m;234 if (__b)235 return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));236 }237 return _It(__first.__seg_, static_cast<unsigned>(__n));238}239 240template <class _Cp, bool _IsConst, class _Tp>241inline _LIBCUDACXX_INLINE_VISIBILITY242__bit_iterator<_Cp, _IsConst>243find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)244{245 if (static_cast<bool>(__value_))246 return __find_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));247 return __find_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));248}249 250// count251 252template <class _Cp, bool _IsConst>253typename __bit_iterator<_Cp, _IsConst>::difference_type254__count_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)255{256 typedef __bit_iterator<_Cp, _IsConst> _It;257 typedef typename _It::__storage_type __storage_type;258 typedef typename _It::difference_type difference_type;259 const int __bits_per_word = _It::__bits_per_word;260 difference_type __r = 0;261 // do first partial word262 if (__first.__ctz_ != 0)263 {264 __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);265 __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);266 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));267 __r = _CUDA_VSTD::__libcpp_popcount(*__first.__seg_ & __m);268 __n -= __dn;269 ++__first.__seg_;270 }271 // do middle whole words272 for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)273 __r += _CUDA_VSTD::__libcpp_popcount(*__first.__seg_);274 // do last partial word275 if (__n > 0)276 {277 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);278 __r += _CUDA_VSTD::__libcpp_popcount(*__first.__seg_ & __m);279 }280 return __r;281}282 283template <class _Cp, bool _IsConst>284typename __bit_iterator<_Cp, _IsConst>::difference_type285__count_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)286{287 typedef __bit_iterator<_Cp, _IsConst> _It;288 typedef typename _It::__storage_type __storage_type;289 typedef typename _It::difference_type difference_type;290 const int __bits_per_word = _It::__bits_per_word;291 difference_type __r = 0;292 // do first partial word293 if (__first.__ctz_ != 0)294 {295 __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);296 __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);297 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));298 __r = _CUDA_VSTD::__libcpp_popcount(~*__first.__seg_ & __m);299 __n -= __dn;300 ++__first.__seg_;301 }302 // do middle whole words303 for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)304 __r += _CUDA_VSTD::__libcpp_popcount(~*__first.__seg_);305 // do last partial word306 if (__n > 0)307 {308 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);309 __r += _CUDA_VSTD::__libcpp_popcount(~*__first.__seg_ & __m);310 }311 return __r;312}313 314template <class _Cp, bool _IsConst, class _Tp>315inline _LIBCUDACXX_INLINE_VISIBILITY316typename __bit_iterator<_Cp, _IsConst>::difference_type317count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)318{319 if (static_cast<bool>(__value_))320 return __count_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));321 return __count_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));322}323 324// fill_n325 326template <class _Cp>327void328__fill_n_false(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)329{330 typedef __bit_iterator<_Cp, false> _It;331 typedef typename _It::__storage_type __storage_type;332 const int __bits_per_word = _It::__bits_per_word;333 // do first partial word334 if (__first.__ctz_ != 0)335 {336 __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);337 __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);338 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));339 *__first.__seg_ &= ~__m;340 __n -= __dn;341 ++__first.__seg_;342 }343 // do middle whole words344 __storage_type __nw = __n / __bits_per_word;345 _CUDA_VSTD::memset(_CUDA_VSTD::__to_raw_pointer(__first.__seg_), 0, __nw * sizeof(__storage_type));346 __n -= __nw * __bits_per_word;347 // do last partial word348 if (__n > 0)349 {350 __first.__seg_ += __nw;351 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);352 *__first.__seg_ &= ~__m;353 }354}355 356template <class _Cp>357void358__fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)359{360 typedef __bit_iterator<_Cp, false> _It;361 typedef typename _It::__storage_type __storage_type;362 const int __bits_per_word = _It::__bits_per_word;363 // do first partial word364 if (__first.__ctz_ != 0)365 {366 __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);367 __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);368 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));369 *__first.__seg_ |= __m;370 __n -= __dn;371 ++__first.__seg_;372 }373 // do middle whole words374 __storage_type __nw = __n / __bits_per_word;375 _CUDA_VSTD::memset(_CUDA_VSTD::__to_raw_pointer(__first.__seg_), -1, __nw * sizeof(__storage_type));376 __n -= __nw * __bits_per_word;377 // do last partial word378 if (__n > 0)379 {380 __first.__seg_ += __nw;381 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);382 *__first.__seg_ |= __m;383 }384}385 386template <class _Cp>387inline _LIBCUDACXX_INLINE_VISIBILITY388void389fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value_)390{391 if (__n > 0)392 {393 if (__value_)394 __fill_n_true(__first, __n);395 else396 __fill_n_false(__first, __n);397 }398}399 400// fill401 402template <class _Cp>403inline _LIBCUDACXX_INLINE_VISIBILITY404void405fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value_)406{407 _CUDA_VSTD::fill_n(__first, static_cast<typename _Cp::size_type>(__last - __first), __value_);408}409 410// copy411 412template <class _Cp, bool _IsConst>413__bit_iterator<_Cp, false>414__copy_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,415 __bit_iterator<_Cp, false> __result)416{417 typedef __bit_iterator<_Cp, _IsConst> _In;418 typedef typename _In::difference_type difference_type;419 typedef typename _In::__storage_type __storage_type;420 const int __bits_per_word = _In::__bits_per_word;421 difference_type __n = __last - __first;422 if (__n > 0)423 {424 // do first word425 if (__first.__ctz_ != 0)426 {427 unsigned __clz = __bits_per_word - __first.__ctz_;428 difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz), __n);429 __n -= __dn;430 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));431 __storage_type __b = *__first.__seg_ & __m;432 *__result.__seg_ &= ~__m;433 *__result.__seg_ |= __b;434 __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;435 __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);436 ++__first.__seg_;437 // __first.__ctz_ = 0;438 }439 // __first.__ctz_ == 0;440 // do middle words441 __storage_type __nw = __n / __bits_per_word;442 _CUDA_VSTD::memmove(_CUDA_VSTD::__to_raw_pointer(__result.__seg_),443 _CUDA_VSTD::__to_raw_pointer(__first.__seg_),444 __nw * sizeof(__storage_type));445 __n -= __nw * __bits_per_word;446 __result.__seg_ += __nw;447 // do last word448 if (__n > 0)449 {450 __first.__seg_ += __nw;451 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);452 __storage_type __b = *__first.__seg_ & __m;453 *__result.__seg_ &= ~__m;454 *__result.__seg_ |= __b;455 __result.__ctz_ = static_cast<unsigned>(__n);456 }457 }458 return __result;459}460 461template <class _Cp, bool _IsConst>462__bit_iterator<_Cp, false>463__copy_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,464 __bit_iterator<_Cp, false> __result)465{466 typedef __bit_iterator<_Cp, _IsConst> _In;467 typedef typename _In::difference_type difference_type;468 typedef typename _In::__storage_type __storage_type;469 static const int __bits_per_word = _In::__bits_per_word;470 difference_type __n = __last - __first;471 if (__n > 0)472 {473 // do first word474 if (__first.__ctz_ != 0)475 {476 unsigned __clz_f = __bits_per_word - __first.__ctz_;477 difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz_f), __n);478 __n -= __dn;479 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));480 __storage_type __b = *__first.__seg_ & __m;481 unsigned __clz_r = __bits_per_word - __result.__ctz_;482 __storage_type __ddn = _CUDA_VSTD::min<__storage_type>(__dn, __clz_r);483 __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));484 *__result.__seg_ &= ~__m;485 if (__result.__ctz_ > __first.__ctz_)486 *__result.__seg_ |= __b << (__result.__ctz_ - __first.__ctz_);487 else488 *__result.__seg_ |= __b >> (__first.__ctz_ - __result.__ctz_);489 __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;490 __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_) % __bits_per_word);491 __dn -= __ddn;492 if (__dn > 0)493 {494 __m = ~__storage_type(0) >> (__bits_per_word - __dn);495 *__result.__seg_ &= ~__m;496 *__result.__seg_ |= __b >> (__first.__ctz_ + __ddn);497 __result.__ctz_ = static_cast<unsigned>(__dn);498 }499 ++__first.__seg_;500 // __first.__ctz_ = 0;501 }502 // __first.__ctz_ == 0;503 // do middle words504 unsigned __clz_r = __bits_per_word - __result.__ctz_;505 __storage_type __m = ~__storage_type(0) << __result.__ctz_;506 for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_)507 {508 __storage_type __b = *__first.__seg_;509 *__result.__seg_ &= ~__m;510 *__result.__seg_ |= __b << __result.__ctz_;511 ++__result.__seg_;512 *__result.__seg_ &= __m;513 *__result.__seg_ |= __b >> __clz_r;514 }515 // do last word516 if (__n > 0)517 {518 __m = ~__storage_type(0) >> (__bits_per_word - __n);519 __storage_type __b = *__first.__seg_ & __m;520 __storage_type __dn = _CUDA_VSTD::min(__n, static_cast<difference_type>(__clz_r));521 __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));522 *__result.__seg_ &= ~__m;523 *__result.__seg_ |= __b << __result.__ctz_;524 __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;525 __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);526 __n -= __dn;527 if (__n > 0)528 {529 __m = ~__storage_type(0) >> (__bits_per_word - __n);530 *__result.__seg_ &= ~__m;531 *__result.__seg_ |= __b >> __dn;532 __result.__ctz_ = static_cast<unsigned>(__n);533 }534 }535 }536 return __result;537}538 539template <class _Cp, bool _IsConst>540inline _LIBCUDACXX_INLINE_VISIBILITY541__bit_iterator<_Cp, false>542copy(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)543{544 if (__first.__ctz_ == __result.__ctz_)545 return __copy_aligned(__first, __last, __result);546 return __copy_unaligned(__first, __last, __result);547}548 549// copy_backward550 551template <class _Cp, bool _IsConst>552__bit_iterator<_Cp, false>553__copy_backward_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,554 __bit_iterator<_Cp, false> __result)555{556 typedef __bit_iterator<_Cp, _IsConst> _In;557 typedef typename _In::difference_type difference_type;558 typedef typename _In::__storage_type __storage_type;559 const int __bits_per_word = _In::__bits_per_word;560 difference_type __n = __last - __first;561 if (__n > 0)562 {563 // do first word564 if (__last.__ctz_ != 0)565 {566 difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);567 __n -= __dn;568 unsigned __clz = __bits_per_word - __last.__ctz_;569 __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz);570 __storage_type __b = *__last.__seg_ & __m;571 *__result.__seg_ &= ~__m;572 *__result.__seg_ |= __b;573 __result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) +574 __result.__ctz_) % __bits_per_word);575 // __last.__ctz_ = 0576 }577 // __last.__ctz_ == 0 || __n == 0578 // __result.__ctz_ == 0 || __n == 0579 // do middle words580 __storage_type __nw = __n / __bits_per_word;581 __result.__seg_ -= __nw;582 __last.__seg_ -= __nw;583 _CUDA_VSTD::memmove(_CUDA_VSTD::__to_raw_pointer(__result.__seg_),584 _CUDA_VSTD::__to_raw_pointer(__last.__seg_),585 __nw * sizeof(__storage_type));586 __n -= __nw * __bits_per_word;587 // do last word588 if (__n > 0)589 {590 __storage_type __m = ~__storage_type(0) << (__bits_per_word - __n);591 __storage_type __b = *--__last.__seg_ & __m;592 *--__result.__seg_ &= ~__m;593 *__result.__seg_ |= __b;594 __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));595 }596 }597 return __result;598}599 600template <class _Cp, bool _IsConst>601__bit_iterator<_Cp, false>602__copy_backward_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,603 __bit_iterator<_Cp, false> __result)604{605 typedef __bit_iterator<_Cp, _IsConst> _In;606 typedef typename _In::difference_type difference_type;607 typedef typename _In::__storage_type __storage_type;608 const int __bits_per_word = _In::__bits_per_word;609 difference_type __n = __last - __first;610 if (__n > 0)611 {612 // do first word613 if (__last.__ctz_ != 0)614 {615 difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);616 __n -= __dn;617 unsigned __clz_l = __bits_per_word - __last.__ctz_;618 __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_l);619 __storage_type __b = *__last.__seg_ & __m;620 unsigned __clz_r = __bits_per_word - __result.__ctz_;621 __storage_type __ddn = _CUDA_VSTD::min(__dn, static_cast<difference_type>(__result.__ctz_));622 if (__ddn > 0)623 {624 __m = (~__storage_type(0) << (__result.__ctz_ - __ddn)) & (~__storage_type(0) >> __clz_r);625 *__result.__seg_ &= ~__m;626 if (__result.__ctz_ > __last.__ctz_)627 *__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_);628 else629 *__result.__seg_ |= __b >> (__last.__ctz_ - __result.__ctz_);630 __result.__ctz_ = static_cast<unsigned>(((-__ddn & (__bits_per_word - 1)) +631 __result.__ctz_) % __bits_per_word);632 __dn -= __ddn;633 }634 if (__dn > 0)635 {636 // __result.__ctz_ == 0637 --__result.__seg_;638 __result.__ctz_ = static_cast<unsigned>(-__dn & (__bits_per_word - 1));639 __m = ~__storage_type(0) << __result.__ctz_;640 *__result.__seg_ &= ~__m;641 __last.__ctz_ -= __dn + __ddn;642 *__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_);643 }644 // __last.__ctz_ = 0645 }646 // __last.__ctz_ == 0 || __n == 0647 // __result.__ctz_ != 0 || __n == 0648 // do middle words649 unsigned __clz_r = __bits_per_word - __result.__ctz_;650 __storage_type __m = ~__storage_type(0) >> __clz_r;651 for (; __n >= __bits_per_word; __n -= __bits_per_word)652 {653 __storage_type __b = *--__last.__seg_;654 *__result.__seg_ &= ~__m;655 *__result.__seg_ |= __b >> __clz_r;656 *--__result.__seg_ &= __m;657 *__result.__seg_ |= __b << __result.__ctz_;658 }659 // do last word660 if (__n > 0)661 {662 __m = ~__storage_type(0) << (__bits_per_word - __n);663 __storage_type __b = *--__last.__seg_ & __m;664 __clz_r = __bits_per_word - __result.__ctz_;665 __storage_type __dn = _CUDA_VSTD::min(__n, static_cast<difference_type>(__result.__ctz_));666 __m = (~__storage_type(0) << (__result.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_r);667 *__result.__seg_ &= ~__m;668 *__result.__seg_ |= __b >> (__bits_per_word - __result.__ctz_);669 __result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) +670 __result.__ctz_) % __bits_per_word);671 __n -= __dn;672 if (__n > 0)673 {674 // __result.__ctz_ == 0675 --__result.__seg_;676 __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));677 __m = ~__storage_type(0) << __result.__ctz_;678 *__result.__seg_ &= ~__m;679 *__result.__seg_ |= __b << (__result.__ctz_ - (__bits_per_word - __n - __dn));680 }681 }682 }683 return __result;684}685 686template <class _Cp, bool _IsConst>687inline _LIBCUDACXX_INLINE_VISIBILITY688__bit_iterator<_Cp, false>689copy_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)690{691 if (__last.__ctz_ == __result.__ctz_)692 return __copy_backward_aligned(__first, __last, __result);693 return __copy_backward_unaligned(__first, __last, __result);694}695 696// move697 698template <class _Cp, bool _IsConst>699inline _LIBCUDACXX_INLINE_VISIBILITY700__bit_iterator<_Cp, false>701move(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)702{703 return _CUDA_VSTD::copy(__first, __last, __result);704}705 706// move_backward707 708template <class _Cp, bool _IsConst>709inline _LIBCUDACXX_INLINE_VISIBILITY710__bit_iterator<_Cp, false>711move_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)712{713 return _CUDA_VSTD::copy_backward(__first, __last, __result);714}715 716// swap_ranges717 718template <class __C1, class __C2>719__bit_iterator<__C2, false>720__swap_ranges_aligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,721 __bit_iterator<__C2, false> __result)722{723 typedef __bit_iterator<__C1, false> _I1;724 typedef typename _I1::difference_type difference_type;725 typedef typename _I1::__storage_type __storage_type;726 const int __bits_per_word = _I1::__bits_per_word;727 difference_type __n = __last - __first;728 if (__n > 0)729 {730 // do first word731 if (__first.__ctz_ != 0)732 {733 unsigned __clz = __bits_per_word - __first.__ctz_;734 difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz), __n);735 __n -= __dn;736 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));737 __storage_type __b1 = *__first.__seg_ & __m;738 *__first.__seg_ &= ~__m;739 __storage_type __b2 = *__result.__seg_ & __m;740 *__result.__seg_ &= ~__m;741 *__result.__seg_ |= __b1;742 *__first.__seg_ |= __b2;743 __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;744 __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);745 ++__first.__seg_;746 // __first.__ctz_ = 0;747 }748 // __first.__ctz_ == 0;749 // do middle words750 for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_, ++__result.__seg_)751 swap(*__first.__seg_, *__result.__seg_);752 // do last word753 if (__n > 0)754 {755 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);756 __storage_type __b1 = *__first.__seg_ & __m;757 *__first.__seg_ &= ~__m;758 __storage_type __b2 = *__result.__seg_ & __m;759 *__result.__seg_ &= ~__m;760 *__result.__seg_ |= __b1;761 *__first.__seg_ |= __b2;762 __result.__ctz_ = static_cast<unsigned>(__n);763 }764 }765 return __result;766}767 768template <class __C1, class __C2>769__bit_iterator<__C2, false>770__swap_ranges_unaligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,771 __bit_iterator<__C2, false> __result)772{773 typedef __bit_iterator<__C1, false> _I1;774 typedef typename _I1::difference_type difference_type;775 typedef typename _I1::__storage_type __storage_type;776 const int __bits_per_word = _I1::__bits_per_word;777 difference_type __n = __last - __first;778 if (__n > 0)779 {780 // do first word781 if (__first.__ctz_ != 0)782 {783 unsigned __clz_f = __bits_per_word - __first.__ctz_;784 difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz_f), __n);785 __n -= __dn;786 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));787 __storage_type __b1 = *__first.__seg_ & __m;788 *__first.__seg_ &= ~__m;789 unsigned __clz_r = __bits_per_word - __result.__ctz_;790 __storage_type __ddn = _CUDA_VSTD::min<__storage_type>(__dn, __clz_r);791 __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));792 __storage_type __b2 = *__result.__seg_ & __m;793 *__result.__seg_ &= ~__m;794 if (__result.__ctz_ > __first.__ctz_)795 {796 unsigned __s = __result.__ctz_ - __first.__ctz_;797 *__result.__seg_ |= __b1 << __s;798 *__first.__seg_ |= __b2 >> __s;799 }800 else801 {802 unsigned __s = __first.__ctz_ - __result.__ctz_;803 *__result.__seg_ |= __b1 >> __s;804 *__first.__seg_ |= __b2 << __s;805 }806 __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;807 __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_) % __bits_per_word);808 __dn -= __ddn;809 if (__dn > 0)810 {811 __m = ~__storage_type(0) >> (__bits_per_word - __dn);812 __b2 = *__result.__seg_ & __m;813 *__result.__seg_ &= ~__m;814 unsigned __s = __first.__ctz_ + __ddn;815 *__result.__seg_ |= __b1 >> __s;816 *__first.__seg_ |= __b2 << __s;817 __result.__ctz_ = static_cast<unsigned>(__dn);818 }819 ++__first.__seg_;820 // __first.__ctz_ = 0;821 }822 // __first.__ctz_ == 0;823 // do middle words824 __storage_type __m = ~__storage_type(0) << __result.__ctz_;825 unsigned __clz_r = __bits_per_word - __result.__ctz_;826 for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_)827 {828 __storage_type __b1 = *__first.__seg_;829 __storage_type __b2 = *__result.__seg_ & __m;830 *__result.__seg_ &= ~__m;831 *__result.__seg_ |= __b1 << __result.__ctz_;832 *__first.__seg_ = __b2 >> __result.__ctz_;833 ++__result.__seg_;834 __b2 = *__result.__seg_ & ~__m;835 *__result.__seg_ &= __m;836 *__result.__seg_ |= __b1 >> __clz_r;837 *__first.__seg_ |= __b2 << __clz_r;838 }839 // do last word840 if (__n > 0)841 {842 __m = ~__storage_type(0) >> (__bits_per_word - __n);843 __storage_type __b1 = *__first.__seg_ & __m;844 *__first.__seg_ &= ~__m;845 __storage_type __dn = _CUDA_VSTD::min<__storage_type>(__n, __clz_r);846 __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));847 __storage_type __b2 = *__result.__seg_ & __m;848 *__result.__seg_ &= ~__m;849 *__result.__seg_ |= __b1 << __result.__ctz_;850 *__first.__seg_ |= __b2 >> __result.__ctz_;851 __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;852 __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);853 __n -= __dn;854 if (__n > 0)855 {856 __m = ~__storage_type(0) >> (__bits_per_word - __n);857 __b2 = *__result.__seg_ & __m;858 *__result.__seg_ &= ~__m;859 *__result.__seg_ |= __b1 >> __dn;860 *__first.__seg_ |= __b2 << __dn;861 __result.__ctz_ = static_cast<unsigned>(__n);862 }863 }864 }865 return __result;866}867 868template <class __C1, class __C2>869inline _LIBCUDACXX_INLINE_VISIBILITY870__bit_iterator<__C2, false>871swap_ranges(__bit_iterator<__C1, false> __first1, __bit_iterator<__C1, false> __last1,872 __bit_iterator<__C2, false> __first2)873{874 if (__first1.__ctz_ == __first2.__ctz_)875 return __swap_ranges_aligned(__first1, __last1, __first2);876 return __swap_ranges_unaligned(__first1, __last1, __first2);877}878 879// rotate880 881template <class _Cp>882struct __bit_array883{884 typedef typename _Cp::difference_type difference_type;885 typedef typename _Cp::__storage_type __storage_type;886 typedef typename _Cp::__storage_pointer __storage_pointer;887 typedef typename _Cp::iterator iterator;888 static const unsigned __bits_per_word = _Cp::__bits_per_word;889 static const unsigned _Np = 4;890 891 difference_type __size_;892 __storage_type __word_[_Np];893 894 _LIBCUDACXX_INLINE_VISIBILITY static difference_type capacity()895 {return static_cast<difference_type>(_Np * __bits_per_word);}896 _LIBCUDACXX_INLINE_VISIBILITY explicit __bit_array(difference_type __s) : __size_(__s) {}897 _LIBCUDACXX_INLINE_VISIBILITY iterator begin()898 {899 return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]), 0);900 }901 _LIBCUDACXX_INLINE_VISIBILITY iterator end()902 {903 return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]) + __size_ / __bits_per_word,904 static_cast<unsigned>(__size_ % __bits_per_word));905 }906};907 908template <class _Cp>909__bit_iterator<_Cp, false>910rotate(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __middle, __bit_iterator<_Cp, false> __last)911{912 typedef __bit_iterator<_Cp, false> _I1;913 typedef typename _I1::difference_type difference_type;914 difference_type __d1 = __middle - __first;915 difference_type __d2 = __last - __middle;916 _I1 __r = __first + __d2;917 while (__d1 != 0 && __d2 != 0)918 {919 if (__d1 <= __d2)920 {921 if (__d1 <= __bit_array<_Cp>::capacity())922 {923 __bit_array<_Cp> __b(__d1);924 _CUDA_VSTD::copy(__first, __middle, __b.begin());925 _CUDA_VSTD::copy(__b.begin(), __b.end(), _CUDA_VSTD::copy(__middle, __last, __first));926 break;927 }928 else929 {930 __bit_iterator<_Cp, false> __mp = _CUDA_VSTD::swap_ranges(__first, __middle, __middle);931 __first = __middle;932 __middle = __mp;933 __d2 -= __d1;934 }935 }936 else937 {938 if (__d2 <= __bit_array<_Cp>::capacity())939 {940 __bit_array<_Cp> __b(__d2);941 _CUDA_VSTD::copy(__middle, __last, __b.begin());942 _CUDA_VSTD::copy_backward(__b.begin(), __b.end(), _CUDA_VSTD::copy_backward(__first, __middle, __last));943 break;944 }945 else946 {947 __bit_iterator<_Cp, false> __mp = __first + __d2;948 _CUDA_VSTD::swap_ranges(__first, __mp, __middle);949 __first = __mp;950 __d1 -= __d2;951 }952 }953 }954 return __r;955}956 957// equal958 959template <class _Cp, bool _IC1, bool _IC2>960bool961__equal_unaligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,962 __bit_iterator<_Cp, _IC2> __first2)963{964 typedef __bit_iterator<_Cp, _IC1> _It;965 typedef typename _It::difference_type difference_type;966 typedef typename _It::__storage_type __storage_type;967 static const int __bits_per_word = _It::__bits_per_word;968 difference_type __n = __last1 - __first1;969 if (__n > 0)970 {971 // do first word972 if (__first1.__ctz_ != 0)973 {974 unsigned __clz_f = __bits_per_word - __first1.__ctz_;975 difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz_f), __n);976 __n -= __dn;977 __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));978 __storage_type __b = *__first1.__seg_ & __m;979 unsigned __clz_r = __bits_per_word - __first2.__ctz_;980 __storage_type __ddn = _CUDA_VSTD::min<__storage_type>(__dn, __clz_r);981 __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));982 if (__first2.__ctz_ > __first1.__ctz_)983 {984 if ((*__first2.__seg_ & __m) != (__b << (__first2.__ctz_ - __first1.__ctz_)))985 return false;986 }987 else988 {989 if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ - __first2.__ctz_)))990 return false;991 }992 __first2.__seg_ += (__ddn + __first2.__ctz_) / __bits_per_word;993 __first2.__ctz_ = static_cast<unsigned>((__ddn + __first2.__ctz_) % __bits_per_word);994 __dn -= __ddn;995 if (__dn > 0)996 {997 __m = ~__storage_type(0) >> (__bits_per_word - __dn);998 if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ + __ddn)))999 return false;1000 __first2.__ctz_ = static_cast<unsigned>(__dn);1001 }1002 ++__first1.__seg_;1003 // __first1.__ctz_ = 0;1004 }1005 // __first1.__ctz_ == 0;1006 // do middle words1007 unsigned __clz_r = __bits_per_word - __first2.__ctz_;1008 __storage_type __m = ~__storage_type(0) << __first2.__ctz_;1009 for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_)1010 {1011 __storage_type __b = *__first1.__seg_;1012 if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))1013 return false;1014 ++__first2.__seg_;1015 if ((*__first2.__seg_ & ~__m) != (__b >> __clz_r))1016 return false;1017 }1018 // do last word1019 if (__n > 0)1020 {1021 __m = ~__storage_type(0) >> (__bits_per_word - __n);1022 __storage_type __b = *__first1.__seg_ & __m;1023 __storage_type __dn = _CUDA_VSTD::min(__n, static_cast<difference_type>(__clz_r));1024 __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));1025 if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))1026 return false;1027 __first2.__seg_ += (__dn + __first2.__ctz_) / __bits_per_word;1028 __first2.__ctz_ = static_cast<unsigned>((__dn + __first2.__ctz_) % __bits_per_word);1029 __n -= __dn;1030 if (__n > 0)1031 {1032 __m = ~__storage_type(0) >> (__bits_per_word - __n);1033 if ((*__first2.__seg_ & __m) != (__b >> __dn))1034 return false;1035 }1036 }1037 }1038 return true;1039}1040 1041template <class _Cp, bool _IC1, bool _IC2>1042bool1043__equal_aligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,1044 __bit_iterator<_Cp, _IC2> __first2)1045{1046 typedef __bit_iterator<_Cp, _IC1> _It;1047 typedef typename _It::difference_type difference_type;1048 typedef typename _It::__storage_type __storage_type;1049 static const int __bits_per_word = _It::__bits_per_word;1050 difference_type __n = __last1 - __first1;1051 if (__n > 0)1052 {1053 // do first word1054 if (__first1.__ctz_ != 0)1055 {1056 unsigned __clz = __bits_per_word - __first1.__ctz_;1057 difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz), __n);1058 __n -= __dn;1059 __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz - __dn));1060 if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))1061 return false;1062 ++__first2.__seg_;1063 ++__first1.__seg_;1064 // __first1.__ctz_ = 0;1065 // __first2.__ctz_ = 0;1066 }1067 // __first1.__ctz_ == 0;1068 // __first2.__ctz_ == 0;1069 // do middle words1070 for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_, ++__first2.__seg_)1071 if (*__first2.__seg_ != *__first1.__seg_)1072 return false;1073 // do last word1074 if (__n > 0)1075 {1076 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);1077 if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))1078 return false;1079 }1080 }1081 return true;1082}1083 1084template <class _Cp, bool _IC1, bool _IC2>1085inline _LIBCUDACXX_INLINE_VISIBILITY1086bool1087equal(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __bit_iterator<_Cp, _IC2> __first2)1088{1089 if (__first1.__ctz_ == __first2.__ctz_)1090 return __equal_aligned(__first1, __last1, __first2);1091 return __equal_unaligned(__first1, __last1, __first2);1092}1093 1094template <class _Cp, bool _IsConst,1095 typename _Cp::__storage_type>1096class __bit_iterator1097{1098public:1099 typedef typename _Cp::difference_type difference_type;1100 typedef bool value_type;1101 typedef __bit_iterator pointer;1102 typedef typename conditional<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >::type reference;1103 typedef random_access_iterator_tag iterator_category;1104 1105private:1106 typedef typename _Cp::__storage_type __storage_type;1107 typedef typename conditional<_IsConst, typename _Cp::__const_storage_pointer,1108 typename _Cp::__storage_pointer>::type __storage_pointer;1109 static const unsigned __bits_per_word = _Cp::__bits_per_word;1110 1111 __storage_pointer __seg_;1112 unsigned __ctz_;1113 1114public:1115 _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator() noexcept1116#if _LIBCUDACXX_STD_VER > 111117 : __seg_(nullptr), __ctz_(0)1118#endif1119 {}1120 // avoid re-declaring a copy constructor for the non-const version.1121 using __type_for_copy_to_const =1122 _If<_IsConst, __bit_iterator<_Cp, false>, struct __private_nat>;1123 1124 _LIBCUDACXX_INLINE_VISIBILITY1125 __bit_iterator(const __type_for_copy_to_const& __it) noexcept1126 : __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}1127 1128 _LIBCUDACXX_INLINE_VISIBILITY reference operator*() const noexcept1129 {return reference(__seg_, __storage_type(1) << __ctz_);}1130 1131 _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator& operator++()1132 {1133 if (__ctz_ != __bits_per_word-1)1134 ++__ctz_;1135 else1136 {1137 __ctz_ = 0;1138 ++__seg_;1139 }1140 return *this;1141 }1142 1143 _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator operator++(int)1144 {1145 __bit_iterator __tmp = *this;1146 ++(*this);1147 return __tmp;1148 }1149 1150 _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator& operator--()1151 {1152 if (__ctz_ != 0)1153 --__ctz_;1154 else1155 {1156 __ctz_ = __bits_per_word - 1;1157 --__seg_;1158 }1159 return *this;1160 }1161 1162 _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator operator--(int)1163 {1164 __bit_iterator __tmp = *this;1165 --(*this);1166 return __tmp;1167 }1168 1169 _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator& operator+=(difference_type __n)1170 {1171 if (__n >= 0)1172 __seg_ += (__n + __ctz_) / __bits_per_word;1173 else1174 __seg_ += static_cast<difference_type>(__n - __bits_per_word + __ctz_ + 1)1175 / static_cast<difference_type>(__bits_per_word);1176 __n &= (__bits_per_word - 1);1177 __ctz_ = static_cast<unsigned>((__n + __ctz_) % __bits_per_word);1178 return *this;1179 }1180 1181 _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator& operator-=(difference_type __n)1182 {1183 return *this += -__n;1184 }1185 1186 _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator operator+(difference_type __n) const1187 {1188 __bit_iterator __t(*this);1189 __t += __n;1190 return __t;1191 }1192 1193 _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator operator-(difference_type __n) const1194 {1195 __bit_iterator __t(*this);1196 __t -= __n;1197 return __t;1198 }1199 1200 _LIBCUDACXX_INLINE_VISIBILITY