From b13edf6e907b32d0b8da09dfe08fa271638eca3c Mon Sep 17 00:00:00 2001 From: Mark de Wever Date: Sat, 29 May 2021 09:50:26 +0200 Subject: [PATCH] Revert "[libc++] NFC: Move unwrap_iter to its own header" This reverts commit 9968896cd62a62b11ac61085534dd598c4bd3c60. This commit seems to cause the build failures of main. --- libcxx/include/CMakeLists.txt | 1 - libcxx/include/__algorithm/unwrap_iter.h | 89 -------------------------------- libcxx/include/algorithm | 60 ++++++++++++++++++++- 3 files changed, 59 insertions(+), 91 deletions(-) delete mode 100644 libcxx/include/__algorithm/unwrap_iter.h diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt index a38aaee2..e5ae54b 100644 --- a/libcxx/include/CMakeLists.txt +++ b/libcxx/include/CMakeLists.txt @@ -1,5 +1,4 @@ set(files - __algorithm/unwrap_iter.h __availability __bit_reference __bits diff --git a/libcxx/include/__algorithm/unwrap_iter.h b/libcxx/include/__algorithm/unwrap_iter.h deleted file mode 100644 index 70dc22e..0000000 --- a/libcxx/include/__algorithm/unwrap_iter.h +++ /dev/null @@ -1,89 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP___ALGORITHM_UNWRAP_ITER_H -#define _LIBCPP___ALGORITHM_UNWRAP_ITER_H - -#include <__config> -#include <__iterator/iterator_traits.h> // __is_cpp17_contiguous_iterator -#include <__memory/pointer_traits.h> // __to_address -#include - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_PUSH_MACROS -#include <__undef_macros> - -_LIBCPP_BEGIN_NAMESPACE_STD - -// __unwrap_iter, __rewrap_iter - -// The job of __unwrap_iter is to lower contiguous iterators (such as -// vector::iterator) into pointers, to reduce the number of template -// instantiations and to enable pointer-based optimizations e.g. in std::copy. -// For iterators that are not contiguous, it must be a no-op. -// In debug mode, we don't do this. -// -// __unwrap_iter is non-constexpr for user-defined iterators whose -// `to_address` and/or `operator->` is non-constexpr. This is okay; but we -// try to avoid doing __unwrap_iter in constant-evaluated contexts anyway. -// -// Some algorithms (e.g. std::copy, but not std::sort) need to convert an -// "unwrapped" result back into a contiguous iterator. Since contiguous iterators -// are random-access, we can do this portably using iterator arithmetic; this -// is the job of __rewrap_iter. - -template ::value> -struct __unwrap_iter_impl { - static _LIBCPP_CONSTEXPR _Iter - __apply(_Iter __i) _NOEXCEPT { - return __i; - } -}; - -#if _LIBCPP_DEBUG_LEVEL < 2 - -template -struct __unwrap_iter_impl<_Iter, true> { - static _LIBCPP_CONSTEXPR decltype(_VSTD::__to_address(declval<_Iter>())) - __apply(_Iter __i) _NOEXCEPT { - return _VSTD::__to_address(__i); - } -}; - -#endif // _LIBCPP_DEBUG_LEVEL < 2 - -template > -inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR -decltype(_Impl::__apply(_VSTD::declval<_Iter>())) -__unwrap_iter(_Iter __i) _NOEXCEPT -{ - return _Impl::__apply(__i); -} - -template -_OrigIter __rewrap_iter(_OrigIter, _OrigIter __result) -{ - return __result; -} - -template -_OrigIter __rewrap_iter(_OrigIter __first, _UnwrappedIter __result) -{ - // Precondition: __result is reachable from __first - // Precondition: _OrigIter is a contiguous iterator - return __first + (__result - _VSTD::__unwrap_iter(__first)); -} - -_LIBCPP_END_NAMESPACE_STD - -_LIBCPP_POP_MACROS - -#endif // _LIBCPP___ALGORITHM_UNWRAP_ITER_H diff --git a/libcxx/include/algorithm b/libcxx/include/algorithm index dbe7d5d..65655d7 100644 --- a/libcxx/include/algorithm +++ b/libcxx/include/algorithm @@ -645,7 +645,6 @@ template */ -#include <__algorithm/unwrap_iter.h> #include <__config> #include #include @@ -1640,6 +1639,65 @@ search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const __value_, __equal_to<__v, _Tp>()); } +// __unwrap_iter, __rewrap_iter + +// The job of __unwrap_iter is to lower contiguous iterators (such as +// vector::iterator) into pointers, to reduce the number of template +// instantiations and to enable pointer-based optimizations e.g. in std::copy. +// For iterators that are not contiguous, it must be a no-op. +// In debug mode, we don't do this. +// +// __unwrap_iter is non-constexpr for user-defined iterators whose +// `to_address` and/or `operator->` is non-constexpr. This is okay; but we +// try to avoid doing __unwrap_iter in constant-evaluated contexts anyway. +// +// Some algorithms (e.g. std::copy, but not std::sort) need to convert an +// "unwrapped" result back into a contiguous iterator. Since contiguous iterators +// are random-access, we can do this portably using iterator arithmetic; this +// is the job of __rewrap_iter. + +template ::value> +struct __unwrap_iter_impl { + static _LIBCPP_CONSTEXPR _Iter + __apply(_Iter __i) _NOEXCEPT { + return __i; + } +}; + +#if _LIBCPP_DEBUG_LEVEL < 2 + +template +struct __unwrap_iter_impl<_Iter, true> { + static _LIBCPP_CONSTEXPR decltype(_VSTD::__to_address(declval<_Iter>())) + __apply(_Iter __i) _NOEXCEPT { + return _VSTD::__to_address(__i); + } +}; + +#endif // _LIBCPP_DEBUG_LEVEL < 2 + +template > +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR +decltype(_Impl::__apply(declval<_Iter>())) +__unwrap_iter(_Iter __i) _NOEXCEPT +{ + return _Impl::__apply(__i); +} + +template +_OrigIter __rewrap_iter(_OrigIter, _OrigIter __result) +{ + return __result; +} + +template +_OrigIter __rewrap_iter(_OrigIter __first, _UnwrappedIter __result) +{ + // Precondition: __result is reachable from __first + // Precondition: _OrigIter is a contiguous iterator + return __first + (__result - _VSTD::__unwrap_iter(__first)); +} + // copy template -- 2.7.4