[libc++][PSTL] Fix clang-tidy

[philnik]

Rebased

libcxx/include/__pstl/internal/execution_impl.h

 
 template <class _IsVector, class... _IteratorTypes>
 using __tag_type =
     typename std::conditional<__internal::__are_random_access_iterators<_IteratorTypes...>::value,
                               __parallel_tag<_IsVector>,
                               __serial_tag<_IsVector>>::type;
 
 template <class... _IteratorTypes>
-__serial_tag</*_IsVector = */ std::false_type>
+_LIBCPP_HIDE_FROM_ABI __serial_tag</*_IsVector = */ std::false_type>
 __select_backend(__pstl::execution::sequenced_policy, _IteratorTypes&&...) {
   return {};
 }
 
 template <class... _IteratorTypes>
-__serial_tag<__internal::__are_random_access_iterators<_IteratorTypes...>>
+_LIBCPP_HIDE_FROM_ABI __serial_tag<__internal::__are_random_access_iterators<_IteratorTypes...>>
 __select_backend(__pstl::execution::unsequenced_policy, _IteratorTypes&&...) {
   return {};
 }
 
 template <class... _IteratorTypes>
-__tag_type</*_IsVector = */ std::false_type, _IteratorTypes...>
+_LIBCPP_HIDE_FROM_ABI __tag_type</*_IsVector = */ std::false_type, _IteratorTypes...>
 __select_backend(__pstl::execution::parallel_policy, _IteratorTypes&&...) {
   return {};
 }
 
 template <class... _IteratorTypes>
-__tag_type<__internal::__are_random_access_iterators<_IteratorTypes...>, _IteratorTypes...>
+_LIBCPP_HIDE_FROM_ABI __tag_type<__internal::__are_random_access_iterators<_IteratorTypes...>, _IteratorTypes...>
 __select_backend(__pstl::execution::parallel_unsequenced_policy, _IteratorTypes&&...) {
   return {};
 }
 
 } // namespace __internal
 } // namespace __pstl
 
 #endif /* _PSTL_EXECUTION_IMPL_H */

libcxx/include/__pstl/internal/parallel_backend_serial.h

class __buffer
     std::allocator<_Tp> __allocator_;
     _Tp* __ptr_;
     const std::size_t __buf_size_;
     __buffer(const __buffer&) = delete;
     void
     operator=(const __buffer&) = delete;
 
   public:
+    _LIBCPP_HIDE_FROM_ABI
     __buffer(std::size_t __n) : __allocator_(), __ptr_(__allocator_.allocate(__n)), __buf_size_(__n) {}
 
-    operator bool() const { return __ptr_ != nullptr; }
-    _Tp*
+    _LIBCPP_HIDE_FROM_ABI operator bool() const { return __ptr_ != nullptr; }
+    _LIBCPP_HIDE_FROM_ABI _Tp*
     get() const
     {
         return __ptr_;
     }
-    ~__buffer() { __allocator_.deallocate(__ptr_, __buf_size_); }
+    _LIBCPP_HIDE_FROM_ABI ~__buffer() { __allocator_.deallocate(__ptr_, __buf_size_); }
 };
 
-inline void
+_LIBCPP_HIDE_FROM_ABI inline void
 __cancel_execution()
 {
 }
 
 template <class _ExecutionPolicy, class _Index, class _Fp>
-void
+_LIBCPP_HIDE_FROM_ABI void
 __parallel_for(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _Index __first, _Index __last, _Fp __f)
 {
     __f(__first, __last);
 }
 
 template <class _ExecutionPolicy, class _Value, class _Index, typename _RealBody, typename _Reduction>
-_Value
+_LIBCPP_HIDE_FROM_ABI _Value
 __parallel_reduce(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _Index __first, _Index __last,
                   const _Value& __identity, const _RealBody& __real_body, const _Reduction&)
 {
     if (__first == __last)
     {
         return __identity;
     }
     else
     {
         return __real_body(__first, __last, __identity);
     }
 }
 
 template <class _ExecutionPolicy, class _Index, class _UnaryOp, class _Tp, class _BinaryOp, class _Reduce>
-_Tp
+_LIBCPP_HIDE_FROM_ABI _Tp
 __parallel_transform_reduce(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _Index __first, _Index __last,
                             _UnaryOp, _Tp __init, _BinaryOp, _Reduce __reduce)
 {
     return __reduce(__first, __last, __init);
 }
 
 template <class _ExecutionPolicy, typename _Index, typename _Tp, typename _Rp, typename _Cp, typename _Sp, typename _Ap>
-void
+_LIBCPP_HIDE_FROM_ABI void
 __parallel_strict_scan(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _Index __n, _Tp __initial,
                        _Rp __reduce, _Cp __combine, _Sp __scan, _Ap __apex)
 {
     _Tp __sum = __initial;
     if (__n)
         __sum = __combine(__sum, __reduce(_Index(0), __n));
     __apex(__sum);
     if (__n)
         __scan(_Index(0), __n, __initial);
 }
 
 template <class _ExecutionPolicy, class _Index, class _UnaryOp, class _Tp, class _BinaryOp, class _Reduce, class _Scan>
-_Tp
+_LIBCPP_HIDE_FROM_ABI _Tp
 __parallel_transform_scan(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _Index __n, _UnaryOp,
                           _Tp __init, _BinaryOp, _Reduce, _Scan __scan)
 {
     return __scan(_Index(0), __n, __init);
 }
 
 template <class _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _LeafSort>
-void
+_LIBCPP_HIDE_FROM_ABI void
 __parallel_stable_sort(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _RandomAccessIterator __first,
                        _RandomAccessIterator __last, _Compare __comp, _LeafSort __leaf_sort, std::size_t = 0)
 {
     __leaf_sort(__first, __last, __comp);
 }
 
 template <class _ExecutionPolicy, typename _RandomAccessIterator1, typename _RandomAccessIterator2,
           typename _RandomAccessIterator3, typename _Compare, typename _LeafMerge>
-void
+_LIBCPP_HIDE_FROM_ABI void
 __parallel_merge(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _RandomAccessIterator1 __first1,
                  _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2,
                  _RandomAccessIterator3 __outit, _Compare __comp, _LeafMerge __leaf_merge)
 {
     __leaf_merge(__first1, __last1, __first2, __last2, __outit, __comp);
 }
 
 template <class _ExecutionPolicy, typename _F1, typename _F2>
-void
+_LIBCPP_HIDE_FROM_ABI void
 __parallel_invoke(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _F1&& __f1, _F2&& __f2)
 {
     std::forward<_F1>(__f1)();
     std::forward<_F2>(__f2)();
 }
 
 } // namespace __serial_backend
 } // namespace __pstl
 
 #endif /* _PSTL_PARALLEL_BACKEND_SERIAL_H */

libcxx/include/__pstl/internal/parallel_impl.h

 {
 
 //------------------------------------------------------------------------
 // parallel_find
 //-----------------------------------------------------------------------
 /** Return extremum value returned by brick f[i,j) for subranges [i,j) of [first,last)
 Each f[i,j) must return a value in [i,j). */
 template <class _BackendTag, class _ExecutionPolicy, class _Index, class _Brick, class _Compare>
-_Index
+_LIBCPP_HIDE_FROM_ABI _Index
 __parallel_find(_BackendTag __tag, _ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f,
                 _Compare __comp, bool __b_first)
 {
     typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType;
     const _DifferenceType __n = __last - __first;
     _DifferenceType __initial_dist = __b_first ? __n : -1;
     std::atomic<_DifferenceType> __extremum(__initial_dist);
     // TODO: find out what is better here: parallel_for or parallel_reduce
__parallel_find(_BackendTag __tag, _ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f,
     return __extremum != __initial_dist ? __first + __extremum : __last;
 }
 
 //------------------------------------------------------------------------
 // parallel_or
 //------------------------------------------------------------------------
 //! Return true if brick f[i,j) returns true for some subrange [i,j) of [first,last)
 template <class _BackendTag, class _ExecutionPolicy, class _Index, class _Brick>
+_LIBCPP_HIDE_FROM_ABI
 bool __parallel_or(_BackendTag __tag, _ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f) {
     std::atomic<bool> __found(false);
     __par_backend::__parallel_for(__tag, std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                   [__f, &__found](_Index __i, _Index __j)
                                   {
                                       if (!__found.load(std::memory_order_relaxed) && __f(__i, __j))
                                       {
                                           __found.store(true, std::memory_order_relaxed);

libcxx/include/__pstl/internal/unseq_backend_simd.h

 {
 namespace __unseq_backend
 {
 
 // Expect vector width up to 64 (or 512 bit)
 const std::size_t __lane_size = 64;
 
 template <class _Iterator, class _DifferenceType, class _Function>
-_Iterator
+_LIBCPP_HIDE_FROM_ABI _Iterator
 __simd_walk_1(_Iterator __first, _DifferenceType __n, _Function __f) noexcept
 {
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         __f(__first[__i]);
 
     return __first + __n;
 }
 
 template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Function>
-_Iterator2
+_LIBCPP_HIDE_FROM_ABI _Iterator2
 __simd_walk_2(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Function __f) noexcept
 {
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         __f(__first1[__i], __first2[__i]);
     return __first2 + __n;
 }
 
 template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Iterator3, class _Function>
-_Iterator3
+_LIBCPP_HIDE_FROM_ABI _Iterator3
 __simd_walk_3(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Iterator3 __first3,
               _Function __f) noexcept
 {
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         __f(__first1[__i], __first2[__i], __first3[__i]);
     return __first3 + __n;
 }
 
 // TODO: check whether __simd_first() can be used here
 template <class _Index, class _DifferenceType, class _Pred>
-bool
+_LIBCPP_HIDE_FROM_ABI bool
 __simd_or(_Index __first, _DifferenceType __n, _Pred __pred) noexcept
 {
 #if defined(_PSTL_EARLYEXIT_PRESENT)
     _DifferenceType __i;
     _PSTL_PRAGMA_VECTOR_UNALIGNED
     _PSTL_PRAGMA_SIMD_EARLYEXIT
     for (__i = 0; __i < __n; ++__i)
         if (__pred(__first[__i]))
while (__last != __first)
             __block_size = __last - __first;
         }
     }
     return false;
 #endif
 }
 
 template <class _Index, class _DifferenceType, class _Compare>
-_Index
+_LIBCPP_HIDE_FROM_ABI _Index
 __simd_first(_Index __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp) noexcept
 {
 #if defined(_PSTL_EARLYEXIT_PRESENT)
     _DifferenceType __i = __begin;
     _PSTL_PRAGMA_VECTOR_UNALIGNED // Do not generate peel loop part
         _PSTL_PRAGMA_SIMD_EARLYEXIT for (; __i < __end; ++__i)
     {
         if (__comp(__first, __i))
while (__begin != __end)
         }
         ++__begin;
     }
     return __first + __end;
 #endif //_PSTL_EARLYEXIT_PRESENT
 }
 
 template <class _Index1, class _DifferenceType, class _Index2, class _Pred>
-std::pair<_Index1, _Index2>
+_LIBCPP_HIDE_FROM_ABI std::pair<_Index1, _Index2>
 __simd_first(_Index1 __first1, _DifferenceType __n, _Index2 __first2, _Pred __pred) noexcept
 {
 #if defined(_PSTL_EARLYEXIT_PRESENT)
     _DifferenceType __i = 0;
     _PSTL_PRAGMA_VECTOR_UNALIGNED
     _PSTL_PRAGMA_SIMD_EARLYEXIT
     for (; __i < __n; ++__i)
         if (__pred(__first1[__i], __first2[__i]))
for (; __last1 != __first1; ++__first1, ++__first2)
         if (__pred(*(__first1), *(__first2)))
             return std::make_pair(__first1, __first2);
 
     return std::make_pair(__last1, __last2);
 #endif //_PSTL_EARLYEXIT_PRESENT
 }
 
 template <class _Index, class _DifferenceType, class _Pred>
-_DifferenceType
+_LIBCPP_HIDE_FROM_ABI _DifferenceType
 __simd_count(_Index __index, _DifferenceType __n, _Pred __pred) noexcept
 {
     _DifferenceType __count = 0;
     _PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         if (__pred(*(__index + __i)))
             ++__count;
 
     return __count;
 }
 
 template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _BinaryPredicate>
-_OutputIterator
+_LIBCPP_HIDE_FROM_ABI _OutputIterator
 __simd_unique_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator __result,
                    _BinaryPredicate __pred) noexcept
 {
     if (__n == 0)
         return __result;
 
     _DifferenceType __cnt = 1;
     __result[0] = __first[0];
 
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 1; __i < __n; ++__i)
     {
         _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
         if (!__pred(__first[__i], __first[__i - 1]))
         {
             __result[__cnt] = __first[__i];
             ++__cnt;
         }
     }
     return __result + __cnt;
 }
 
 template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _Assigner>
-_OutputIterator
+_LIBCPP_HIDE_FROM_ABI _OutputIterator
 __simd_assign(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _Assigner __assigner) noexcept
 {
     _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         __assigner(__first + __i, __result + __i);
     return __result + __n;
 }
 
 template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _UnaryPredicate>
-_OutputIterator
+_LIBCPP_HIDE_FROM_ABI _OutputIterator
 __simd_copy_if(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _UnaryPredicate __pred) noexcept
 {
     _DifferenceType __cnt = 0;
 
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
         _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
         if (__pred(__first[__i]))
         {
             __result[__cnt] = __first[__i];
             ++__cnt;
         }
     }
     return __result + __cnt;
 }
 
 template <class _InputIterator, class _DifferenceType, class _BinaryPredicate>
-_DifferenceType
+_LIBCPP_HIDE_FROM_ABI _DifferenceType
 __simd_calc_mask_2(_InputIterator __first, _DifferenceType __n, bool* __mask, _BinaryPredicate __pred) noexcept
 {
     _DifferenceType __count = 0;
 
     _PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
         __mask[__i] = !__pred(__first[__i], __first[__i - 1]);
         __count += __mask[__i];
     }
     return __count;
 }
 
 template <class _InputIterator, class _DifferenceType, class _UnaryPredicate>
-_DifferenceType
+_LIBCPP_HIDE_FROM_ABI _DifferenceType
 __simd_calc_mask_1(_InputIterator __first, _DifferenceType __n, bool* __mask, _UnaryPredicate __pred) noexcept
 {
     _DifferenceType __count = 0;
 
     _PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
         __mask[__i] = __pred(__first[__i]);
         __count += __mask[__i];
     }
     return __count;
 }
 
 template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _Assigner>
-void
+_LIBCPP_HIDE_FROM_ABI void
 __simd_copy_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, bool* __mask,
                     _Assigner __assigner) noexcept
 {
     _DifferenceType __cnt = 0;
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
         if (__mask[__i])
         {
             _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(__cnt : 1)
             {
                 __assigner(__first + __i, __result + __cnt);
                 ++__cnt;
             }
         }
     }
 }
 
 template <class _InputIterator, class _DifferenceType, class _OutputIterator1, class _OutputIterator2>
-void
+_LIBCPP_HIDE_FROM_ABI void
 __simd_partition_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
                          _OutputIterator2 __out_false, bool* __mask) noexcept
 {
     _DifferenceType __cnt_true = 0, __cnt_false = 0;
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
         _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(__cnt_true : 1, __cnt_false : 1)
         if (__mask[__i])
         {
             __out_true[__cnt_true] = __first[__i];
             ++__cnt_true;
         }
         else
         {
             __out_false[__cnt_false] = __first[__i];
             ++__cnt_false;
         }
     }
 }
 
 template <class _Index, class _DifferenceType, class _Tp>
-_Index
+_LIBCPP_HIDE_FROM_ABI _Index
 __simd_fill_n(_Index __first, _DifferenceType __n, const _Tp& __value) noexcept
 {
     _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         __first[__i] = __value;
     return __first + __n;
 }
 
 template <class _Index, class _DifferenceType, class _Generator>
-_Index
+_LIBCPP_HIDE_FROM_ABI _Index
 __simd_generate_n(_Index __first, _DifferenceType __size, _Generator __g) noexcept
 {
     _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __size; ++__i)
         __first[__i] = __g();
     return __first + __size;
 }
 
 template <class _Index, class _BinaryPredicate>
-_Index
+_LIBCPP_HIDE_FROM_ABI _Index
 __simd_adjacent_find(_Index __first, _Index __last, _BinaryPredicate __pred, bool __or_semantic) noexcept
 {
     if (__last - __first < 2)
         return __last;
 
     typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType;
     _DifferenceType __i = 0;
 

 }
 
 // It was created to reduce the code inside std::enable_if
 template <typename _Tp, typename _BinaryOperation>
 using is_arithmetic_plus = std::integral_constant<bool, std::is_arithmetic<_Tp>::value &&
                                                             std::is_same<_BinaryOperation, std::plus<_Tp>>::value>;
 
 template <typename _DifferenceType, typename _Tp, typename _BinaryOperation, typename _UnaryOperation>
-typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type
+_LIBCPP_HIDE_FROM_ABI typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type
 __simd_transform_reduce(_DifferenceType __n, _Tp __init, _BinaryOperation, _UnaryOperation __f) noexcept
 {
     _PSTL_PRAGMA_SIMD_REDUCTION(+ : __init)
     for (_DifferenceType __i = 0; __i < __n; ++__i)
         __init += __f(__i);
     return __init;
 }
 
 template <typename _Size, typename _Tp, typename _BinaryOperation, typename _UnaryOperation>
-typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type
+_LIBCPP_HIDE_FROM_ABI typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type
 __simd_transform_reduce(_Size __n, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __f) noexcept
 {
     const _Size __block_size = __lane_size / sizeof(_Tp);
     if (__n > 2 * __block_size && __block_size > 1)
     {
         alignas(__lane_size) char __lane_[__lane_size];
         _Tp* __lane = reinterpret_cast<_Tp*>(__lane_);
 
else
         }
     }
     return __init;
 }
 
 // Exclusive scan for "+" and arithmetic types
 template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
           class _BinaryOperation>
+_LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
 __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
             _BinaryOperation, /*Inclusive*/ std::false_type)
 {
     _PSTL_PRAGMA_SIMD_SCAN(+ : __init)
     for (_Size __i = 0; __i < __n; ++__i)
     {
         __result[__i] = __init;
         _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(__init)
         __init += __unary_op(__first[__i]);
     }
     return std::make_pair(__result + __n, __init);
 }
 
 // As soon as we cannot call __binary_op in "combiner" we create a wrapper over _Tp to encapsulate __binary_op
 template <typename _Tp, typename _BinaryOp>
 struct _Combiner
 {
     _Tp __value;
     _BinaryOp* __bin_op; // Here is a pointer to function because of default ctor
 
-    _Combiner() : __value{}, __bin_op(nullptr) {}
+    _LIBCPP_HIDE_FROM_ABI _Combiner() : __value{}, __bin_op(nullptr) {}
+    _LIBCPP_HIDE_FROM_ABI
     _Combiner(const _Tp& value, const _BinaryOp* bin_op) : __value(value), __bin_op(const_cast<_BinaryOp*>(bin_op)) {}
-    _Combiner(const _Combiner& __obj) : __value{}, __bin_op(__obj.__bin_op) {}
+    _LIBCPP_HIDE_FROM_ABI _Combiner(const _Combiner& __obj) : __value{}, __bin_op(__obj.__bin_op) {}
 
-    void
+    _LIBCPP_HIDE_FROM_ABI void
     operator()(const _Combiner& __obj)
     {
         __value = (*__bin_op)(__value, __obj.__value);
     }
 };
 
 // Exclusive scan for other binary operations and types
 template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
           class _BinaryOperation>
+_LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
 __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
             _BinaryOperation __binary_op, /*Inclusive*/ std::false_type)
 {
     typedef _Combiner<_Tp, _BinaryOperation> _CombinerType;
     _CombinerType __init_{__init, &__binary_op};
 
     _PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType)
 
     _PSTL_PRAGMA_SIMD_SCAN(__bin_op : __init_)
     for (_Size __i = 0; __i < __n; ++__i)
     {
         __result[__i] = __init_.__value;
         _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(__init_)
         _PSTL_PRAGMA_FORCEINLINE
         __init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i]));
     }
     return std::make_pair(__result + __n, __init_.__value);
 }
 
 // Inclusive scan for "+" and arithmetic types
 template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
           class _BinaryOperation>
+_LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
 __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
             _BinaryOperation, /*Inclusive*/ std::true_type)
 {
     _PSTL_PRAGMA_SIMD_SCAN(+ : __init)
     for (_Size __i = 0; __i < __n; ++__i)
     {
         __init += __unary_op(__first[__i]);
         _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(__init)
         __result[__i] = __init;
     }
     return std::make_pair(__result + __n, __init);
 }
 
 // Inclusive scan for other binary operations and types
 template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
           class _BinaryOperation>
+_LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
 __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
             _BinaryOperation __binary_op, std::true_type)
 {
     typedef _Combiner<_Tp, _BinaryOperation> _CombinerType;
     _CombinerType __init_{__init, &__binary_op};
 
     _PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType)
 
     _PSTL_PRAGMA_SIMD_SCAN(__bin_op : __init_)
     for (_Size __i = 0; __i < __n; ++__i)
     {
         _PSTL_PRAGMA_FORCEINLINE
         __init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i]));
         _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(__init_)
         __result[__i] = __init_.__value;
     }
     return std::make_pair(__result + __n, __init_.__value);
 }
 
 // [restriction] - std::iterator_traits<_ForwardIterator>::value_type should be DefaultConstructible.
 // complexity [violation] - We will have at most (__n-1 + number_of_lanes) comparisons instead of at most __n-1.
 template <typename _ForwardIterator, typename _Size, typename _Compare>
-_ForwardIterator
+_LIBCPP_HIDE_FROM_ABI _ForwardIterator
 __simd_min_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept
 {
     if (__n == 0)
     {
         return __first;
     }
 
     typedef typename std::iterator_traits<_ForwardIterator>::value_type _ValueType;
     struct _ComplexType
     {
         _ValueType __min_val;
         _Size __min_ind;
         _Compare* __min_comp;
 
-        _ComplexType() : __min_val{}, __min_ind{}, __min_comp(nullptr) {}
-        _ComplexType(const _ValueType& val, const _Compare* comp)
+        _LIBCPP_HIDE_FROM_ABI _ComplexType() : __min_val{}, __min_ind{}, __min_comp(nullptr) {}
+        _LIBCPP_HIDE_FROM_ABI _ComplexType(const _ValueType& val, const _Compare* comp)
             : __min_val(val), __min_ind(0), __min_comp(const_cast<_Compare*>(comp))
         {
         }
-        _ComplexType(const _ComplexType& __obj)
+        _LIBCPP_HIDE_FROM_ABI _ComplexType(const _ComplexType& __obj)
             : __min_val(__obj.__min_val), __min_ind(__obj.__min_ind), __min_comp(__obj.__min_comp)
         {
         }
 
         _PSTL_PRAGMA_DECLARE_SIMD
-        void
+        _LIBCPP_HIDE_FROM_ABI void
         operator()(const _ComplexType& __obj)
         {
             if (!(*__min_comp)(__min_val, __obj.__min_val) &&
                 ((*__min_comp)(__obj.__min_val, __min_val) || __obj.__min_ind - __min_ind < 0))
             {
                 __min_val = __obj.__min_val;
                 __min_ind = __obj.__min_ind;
             }
for (_Size __i = 1; __i < __n; ++__i)
         }
     }
     return __first + __init.__min_ind;
 }
 
 // [restriction] - std::iterator_traits<_ForwardIterator>::value_type should be DefaultConstructible.
 // complexity [violation] - We will have at most (2*(__n-1) + 4*number_of_lanes) comparisons instead of at most [1.5*(__n-1)].
 template <typename _ForwardIterator, typename _Size, typename _Compare>
-std::pair<_ForwardIterator, _ForwardIterator>
+_LIBCPP_HIDE_FROM_ABI std::pair<_ForwardIterator, _ForwardIterator>
 __simd_minmax_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept
 {
     if (__n == 0)
     {
         return std::make_pair(__first, __first);
     }
     typedef typename std::iterator_traits<_ForwardIterator>::value_type _ValueType;
 
     struct _ComplexType
     {
         _ValueType __min_val;
         _ValueType __max_val;
         _Size __min_ind;
         _Size __max_ind;
         _Compare* __minmax_comp;
 
-        _ComplexType() : __min_val{}, __max_val{}, __min_ind{}, __max_ind{}, __minmax_comp(nullptr) {}
-        _ComplexType(const _ValueType& min_val, const _ValueType& max_val, const _Compare* comp)
+        _LIBCPP_HIDE_FROM_ABI _ComplexType() : __min_val{}, __max_val{}, __min_ind{}, __max_ind{}, __minmax_comp(nullptr) {}
+        _LIBCPP_HIDE_FROM_ABI _ComplexType(const _ValueType& min_val, const _ValueType& max_val, const _Compare* comp)
             : __min_val(min_val), __max_val(max_val), __min_ind(0), __max_ind(0),
               __minmax_comp(const_cast<_Compare*>(comp))
         {
         }
-        _ComplexType(const _ComplexType& __obj)
+        _LIBCPP_HIDE_FROM_ABI _ComplexType(const _ComplexType& __obj)
             : __min_val(__obj.__min_val), __max_val(__obj.__max_val), __min_ind(__obj.__min_ind),
               __max_ind(__obj.__max_ind), __minmax_comp(__obj.__minmax_comp)
         {
         }
 
-        void
+        _LIBCPP_HIDE_FROM_ABI void
         operator()(const _ComplexType& __obj)
         {
             // min
             if ((*__minmax_comp)(__obj.__min_val, __min_val))
             {
                 __min_val = __obj.__min_val;
                 __min_ind = __obj.__min_ind;
             }
for (_Size __i = 1; __i < __n; ++__i)
             __init.__max_ind = __i;
         }
     }
     return std::make_pair(__first + __init.__min_ind, __first + __init.__max_ind);
 }
 
 template <class _InputIterator, class _DifferenceType, class _OutputIterator1, class _OutputIterator2,
           class _UnaryPredicate>
-std::pair<_OutputIterator1, _OutputIterator2>
+_LIBCPP_HIDE_FROM_ABI std::pair<_OutputIterator1, _OutputIterator2>
 __simd_partition_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
                       _OutputIterator2 __out_false, _UnaryPredicate __pred) noexcept
 {
     _DifferenceType __cnt_true = 0, __cnt_false = 0;
 
     _PSTL_PRAGMA_SIMD
     for (_DifferenceType __i = 0; __i < __n; ++__i)
     {
         _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(__cnt_true : 1, __cnt_false : 1)
         if (__pred(__first[__i]))
         {
             __out_true[__cnt_true] = __first[__i];
             ++__cnt_true;
         }
         else
         {
             __out_false[__cnt_false] = __first[__i];
             ++__cnt_false;
         }
     }
     return std::make_pair(__out_true + __cnt_true, __out_false + __cnt_false);
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1
+_LIBCPP_HIDE_FROM_ABI _ForwardIterator1
 __simd_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
                      _ForwardIterator2 __s_last, _BinaryPredicate __pred) noexcept
 {
     typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferencType;
 
     const _DifferencType __n1 = __last - __first;
     const _DifferencType __n2 = __s_last - __s_first;
     if (__n1 == 0 || __n2 == 0)
else
                 return __result;
             }
         }
     }
     return __last;
 }
 
 template <class _RandomAccessIterator, class _DifferenceType, class _UnaryPredicate>
-_RandomAccessIterator
+_LIBCPP_HIDE_FROM_ABI _RandomAccessIterator
 __simd_remove_if(_RandomAccessIterator __first, _DifferenceType __n, _UnaryPredicate __pred) noexcept
 {
     // find first element we need to remove
     auto __current = __unseq_backend::__simd_first(
         __first, _DifferenceType(0), __n,
         [&__pred](_RandomAccessIterator __it, _DifferenceType __i) { return __pred(__it[__i]); });
     __n -= __current - __first;
 

libcxx/include/__pstl/internal/utils.h

 #include <iterator>
 #include <new>
 #include <utility>
 
 namespace __pstl {
 namespace __internal {
 
 template <typename _Fp>
-auto __except_handler(_Fp __f) -> decltype(__f()) {
+_LIBCPP_HIDE_FROM_ABI auto __except_handler(_Fp __f) -> decltype(__f()) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
     return __f();
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   } catch (const std::bad_alloc&) {
     throw;            // re-throw bad_alloc according to the standard [algorithms.parallel.exceptions]
   } catch (...) {
     std::terminate(); // Good bye according to the standard [algorithms.parallel.exceptions]
   }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 }
 
 template <typename _Fp>
-void __invoke_if(std::true_type, _Fp __f) {
+_LIBCPP_HIDE_FROM_ABI void __invoke_if(std::true_type, _Fp __f) {
   __f();
 }
 
 template <typename _Fp>
-void __invoke_if(std::false_type, _Fp) {}
+_LIBCPP_HIDE_FROM_ABI void __invoke_if(std::false_type, _Fp) {}
 
 template <typename _Fp>
-void __invoke_if_not(std::false_type, _Fp __f) {
+_LIBCPP_HIDE_FROM_ABI void __invoke_if_not(std::false_type, _Fp __f) {
   __f();
 }
 
 template <typename _Fp>
-void __invoke_if_not(std::true_type, _Fp) {}
+_LIBCPP_HIDE_FROM_ABI void __invoke_if_not(std::true_type, _Fp) {}
 
 template <typename _F1, typename _F2>
-auto __invoke_if_else(std::true_type, _F1 __f1, _F2) -> decltype(__f1()) {
+_LIBCPP_HIDE_FROM_ABI auto __invoke_if_else(std::true_type, _F1 __f1, _F2) -> decltype(__f1()) {
   return __f1();
 }
 
 template <typename _F1, typename _F2>
-auto __invoke_if_else(std::false_type, _F1, _F2 __f2) -> decltype(__f2()) {
+_LIBCPP_HIDE_FROM_ABI auto __invoke_if_else(std::false_type, _F1, _F2 __f2) -> decltype(__f2()) {
   return __f2();
 }
 
 //! Unary operator that returns reference to its argument.
 struct __no_op {
   template <typename _Tp>
-  _Tp&& operator()(_Tp&& __a) const {
+  _LIBCPP_HIDE_FROM_ABI _Tp&& operator()(_Tp&& __a) const {
     return std::forward<_Tp>(__a);
   }
 };
 
 template <typename _Pred>
 class __reorder_pred {
   _Pred _M_pred;
 
 public:
-  explicit __reorder_pred(_Pred __pred) : _M_pred(__pred) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __reorder_pred(_Pred __pred) : _M_pred(__pred) {}
 
   template <typename _FTp, typename _STp>
-  bool operator()(_FTp&& __a, _STp&& __b) {
+  _LIBCPP_HIDE_FROM_ABI bool operator()(_FTp&& __a, _STp&& __b) {
     return _M_pred(std::forward<_STp>(__b), std::forward<_FTp>(__a));
   }
 };
 
 //! Like a polymorphic lambda for pred(...,value)
 template <typename _Tp, typename _Predicate>
 class __equal_value_by_pred {
   const _Tp& _M_value;
   _Predicate _M_pred;
 
 public:
-  __equal_value_by_pred(const _Tp& __value, _Predicate __pred) : _M_value(__value), _M_pred(__pred) {}
+  _LIBCPP_HIDE_FROM_ABI __equal_value_by_pred(const _Tp& __value, _Predicate __pred)
+      : _M_value(__value), _M_pred(__pred) {}
 
   template <typename _Arg>
-  bool operator()(_Arg&& __arg) {
+  _LIBCPP_HIDE_FROM_ABI bool operator()(_Arg&& __arg) {
     return _M_pred(std::forward<_Arg>(__arg), _M_value);
   }
 };
 
 //! Like a polymorphic lambda for ==value
 template <typename _Tp>
 class __equal_value {
   const _Tp& _M_value;
 
 public:
-  explicit __equal_value(const _Tp& __value) : _M_value(__value) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __equal_value(const _Tp& __value) : _M_value(__value) {}
 
   template <typename _Arg>
-  bool operator()(_Arg&& __arg) const {
+  _LIBCPP_HIDE_FROM_ABI bool operator()(_Arg&& __arg) const {
     return std::forward<_Arg>(__arg) == _M_value;
   }
 };
 
 //! Logical negation of ==value
 template <typename _Tp>
 class __not_equal_value {
   const _Tp& _M_value;
 
 public:
-  explicit __not_equal_value(const _Tp& __value) : _M_value(__value) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __not_equal_value(const _Tp& __value) : _M_value(__value) {}
 
   template <typename _Arg>
-  bool operator()(_Arg&& __arg) const {
+  _LIBCPP_HIDE_FROM_ABI bool operator()(_Arg&& __arg) const {
     return !(std::forward<_Arg>(__arg) == _M_value);
   }
 };
 
 template <typename _ForwardIterator, typename _Compare>
-_ForwardIterator __cmp_iterators_by_values(_ForwardIterator __a, _ForwardIterator __b, _Compare __comp) {
+_LIBCPP_HIDE_FROM_ABI _ForwardIterator
+__cmp_iterators_by_values(_ForwardIterator __a, _ForwardIterator __b, _Compare __comp) {
   if (__a < __b) { // we should return closer iterator
     return __comp(*__b, *__a) ? __b : __a;
   } else {
     return __comp(*__a, *__b) ? __a : __b;
   }
 }
 
 } // namespace __internal
 } // namespace __pstl
 
 #endif /* _PSTL_UTILS_H */

libcxx/include/execution

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace execution {
 struct __disable_user_instantiations_tag {
   explicit __disable_user_instantiations_tag() = default;
 };
 
 struct sequenced_policy {
-  constexpr explicit sequenced_policy(__disable_user_instantiations_tag) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit sequenced_policy(__disable_user_instantiations_tag) {}
   sequenced_policy(const sequenced_policy&)            = delete;
   sequenced_policy& operator=(const sequenced_policy&) = delete;
 };
 
 inline constexpr sequenced_policy seq{__disable_user_instantiations_tag{}};
 
 struct parallel_policy {
-  constexpr explicit parallel_policy(__disable_user_instantiations_tag) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit parallel_policy(__disable_user_instantiations_tag) {}
   parallel_policy(const parallel_policy&)            = delete;
   parallel_policy& operator=(const parallel_policy&) = delete;
 };
 
 inline constexpr parallel_policy par{__disable_user_instantiations_tag{}};
 
 struct parallel_unsequenced_policy {
-  constexpr explicit parallel_unsequenced_policy(__disable_user_instantiations_tag) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit parallel_unsequenced_policy(__disable_user_instantiations_tag) {}
   parallel_unsequenced_policy(const parallel_unsequenced_policy&)            = delete;
   parallel_unsequenced_policy& operator=(const parallel_unsequenced_policy&) = delete;
 };
 
 inline constexpr parallel_unsequenced_policy par_unseq{__disable_user_instantiations_tag{}};
 
 struct __unsequenced_policy {
-  constexpr explicit __unsequenced_policy(__disable_user_instantiations_tag) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __unsequenced_policy(__disable_user_instantiations_tag) {}
   __unsequenced_policy(const __unsequenced_policy&)            = delete;
   __unsequenced_policy& operator=(const __unsequenced_policy&) = delete;
 };
 
 constexpr __unsequenced_policy __unseq{__disable_user_instantiations_tag{}};
 
 #  if _LIBCPP_STD_VER >= 20
 

libcxx/test/libcxx/clang_tidy.sh.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: has-clang-tidy
 
-// FIXME: This should pass with the PSTL enabled
-// XFAIL: with-pstl
-
 // The GCC compiler flags are not always compatible with clang-tidy.
 // UNSUPPORTED: gcc
 
 // TODO: run clang-tidy with modules enabled once they are supported
 // RUN: %{clang-tidy} %s --warnings-as-errors=* -header-filter=.* --checks='-*,libcpp-*' --load=%{test-tools}/clang_tidy_checks/libcxx-tidy.plugin -- %{compile_flags} -fno-modules
 // RUN: %{clang-tidy} %s --warnings-as-errors=* -header-filter=.* --config-file=%S/../../.clang-tidy -- -Wweak-vtables %{compile_flags} -fno-modules
 
 // Prevent <ext/hash_map> from generating deprecated warnings for this test.