[libc++][PSTL] Remove _PSTL_HIDE_FROM_ABI_{PUSH,POP} macros

[philnik]

Rebased

[philnik]

Rebased

libcxx/include/__pstl/internal/algorithm_fwd.h

 #define _PSTL_ALGORITHM_FWD_H
 
 #include <iterator>
 #include <type_traits>
 #include <utility>
 
 #include "pstl_config.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl {
 namespace __internal {
 
 //------------------------------------------------------------------------
 // walk1 (pseudo)
 //
 // walk1 evaluates f(x) for each dereferenced value x drawn from [first,last)
 //------------------------------------------------------------------------
bool __pattern_lexicographical_compare(
     _RandomAccessIterator1,
     _RandomAccessIterator2,
     _RandomAccessIterator2,
     _Compare) noexcept;
 
 } // namespace __internal
 } // namespace __pstl
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_ALGORITHM_FWD_H */

libcxx/include/__pstl/internal/algorithm_impl.h

 #include "execution_impl.h"
 #include "memory_impl.h"
 #include "parallel_backend.h"
 #include "parallel_backend_utils.h"
 #include "parallel_impl.h"
 #include "pstl_config.h"
 #include "unseq_backend_simd.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl {
 namespace __internal {
 
 // [alg.foreach]
 // for_each_n with no policy
 
 template <class _ForwardIterator, class _Size, class _Function>
 _ForwardIterator __for_each_n_it_serial(_ForwardIterator __first, _Size __n, _Function __f) {
if (__result == __last1 && __first2 + (__result - __first1) != __last2) { // if first sequence shorter than second
       return __comp(*__result, *(__first2 + (__result - __first1)));
     }
   }
 }
 
 } // namespace __internal
 } // namespace __pstl
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_ALGORITHM_IMPL_H */

libcxx/include/__pstl/internal/execution_defs.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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 _PSTL_EXECUTION_POLICY_DEFS_H
 #define _PSTL_EXECUTION_POLICY_DEFS_H
 
 #include <type_traits>
 
 #include "pstl_config.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl {
 namespace execution {
 inline namespace v1 {
 
 // 2.4, Sequential execution policy
 class sequenced_policy {};
 
 // 2.5, Parallel execution policy

 struct __serial_tag;
 template <class _IsVector>
 struct __parallel_tag;
 
 } // namespace __internal
 
 } // namespace __pstl
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_EXECUTION_POLICY_DEFS_H */

libcxx/include/__pstl/internal/execution_impl.h

 #define _PSTL_EXECUTION_IMPL_H
 
 #include <iterator>
 #include <type_traits>
 
 #include "execution_defs.h"
 #include "pstl_config.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl {
 namespace __internal {
 
 template <typename _IteratorTag, typename... _IteratorTypes>
 using __are_iterators_of = std::conjunction<
     std::is_base_of<_IteratorTag, typename std::iterator_traits<std::decay_t<_IteratorTypes>>::iterator_category>...>;
 
 template <typename... _IteratorTypes>

 __tag_type<__internal::__are_random_access_iterators<_IteratorTypes...>, _IteratorTypes...>
 __select_backend(__pstl::execution::parallel_unsequenced_policy, _IteratorTypes&&...) {
   return {};
 }
 
 } // namespace __internal
 } // namespace __pstl
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_EXECUTION_IMPL_H */

libcxx/include/__pstl/internal/glue_algorithm_defs.h

 #define _PSTL_GLUE_ALGORITHM_DEFS_H
 
 #include <functional>
 #include <iterator>
 
 #include "execution_defs.h"
 #include "pstl_config.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace std {
 
 // [alg.find]
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
 __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
 find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
 
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(
     _ExecutionPolicy&& __exec,
     _ForwardIterator1 __first1,
     _ForwardIterator1 __last1,
     _ForwardIterator2 __first2,
     _ForwardIterator2 __last2);
 
 } // namespace std
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_GLUE_ALGORITHM_DEFS_H */

libcxx/include/__pstl/internal/glue_algorithm_impl.h

 
 #include "algorithm_fwd.h"
 #include "execution_defs.h"
 #include "numeric_fwd.h" /* count and count_if use __pattern_transform_reduce */
 #include "utils.h"
 
 #include "execution_impl.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace std {
 
 // [alg.find]
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
 __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
 find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
   auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(
     _ForwardIterator2 __first2,
     _ForwardIterator2 __last2) {
   return std::lexicographical_compare(
       std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, std::less<>());
 }
 
 } // namespace std
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_GLUE_ALGORITHM_IMPL_H */

libcxx/include/__pstl/internal/glue_memory_defs.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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 _PSTL_GLUE_MEMORY_DEFS_H
 #define _PSTL_GLUE_MEMORY_DEFS_H
 
 #include "execution_defs.h"
 #include "pstl_config.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace std {
 
 // [uninitialized.copy]
 
 template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
 __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
 uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result);
 

 uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
 __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
 uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);
 
 } //  namespace std
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_GLUE_MEMORY_DEFS_H */

libcxx/include/__pstl/internal/glue_memory_impl.h

 #include "pstl_config.h"
 
 #include "algorithm_fwd.h"
 #include "execution_defs.h"
 #include "utils.h"
 
 #include "execution_impl.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace std {
 
 // [uninitialized.copy]
 
 template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
 __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_copy(
     _ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) {
   typedef typename iterator_traits<_InputIterator>::value_type _ValueType1;
return __pstl::__internal::__invoke_if_else(
             __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __n, [](_ReferenceType __val) {
               ::new (std::addressof(__val)) _ValueType();
             });
       });
 }
 
 } // namespace std
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_GLUE_MEMORY_IMPL_H */

libcxx/include/__pstl/internal/glue_numeric_defs.h

 #ifndef _PSTL_GLUE_NUMERIC_DEFS_H
 #define _PSTL_GLUE_NUMERIC_DEFS_H
 
 #include <iterator>
 
 #include "execution_defs.h"
 #include "pstl_config.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace std {
 // [reduce]
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation>
 __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
 reduce(_ExecutionPolicy&& __exec,
        _ForwardIterator __first,
        _ForwardIterator __last,
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> adjacent_difference(
     _BinaryOperation op);
 
 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
 __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> adjacent_difference(
     _ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first);
 
 } // namespace std
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_GLUE_NUMERIC_DEFS_H */

libcxx/include/__pstl/internal/glue_numeric_impl.h

 #include <functional>
 
 #include "pstl_config.h"
 
 #include "execution_impl.h"
 #include "numeric_fwd.h"
 #include "utils.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace std {
 
 // [reduce]
 
 template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation>
 __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
 reduce(_ExecutionPolicy&& __exec,
        _ForwardIterator __first,
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> adjacent_difference(
     _ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first) {
   typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType;
   return adjacent_difference(
       std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, std::minus<_ValueType>());
 }
 
 } // namespace std
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_GLUE_NUMERIC_IMPL_H_ */

libcxx/include/__pstl/internal/memory_impl.h

 #ifndef _PSTL_MEMORY_IMPL_H
 #define _PSTL_MEMORY_IMPL_H
 
 #include <iterator>
 
 #include "pstl_config.h"
 #include "unseq_backend_simd.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl {
 namespace __internal {
 
 //------------------------------------------------------------------------
 // uninitialized_move
 //------------------------------------------------------------------------
 
 template <typename _ForwardIterator, typename _OutputIterator>
return __unseq_backend::__simd_walk_2(
       __first, __last - __first, __result, [](_ReferenceType1 __x, _ReferenceType2 __y) {
         ::new (std::addressof(__y)) __ValueType(__x);
       });
 }
 
 } // namespace __internal
 } // namespace __pstl
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_MEMORY_IMPL_H */

libcxx/include/__pstl/internal/numeric_fwd.h

 #ifndef _PSTL_NUMERIC_FWD_H
 #define _PSTL_NUMERIC_FWD_H
 
 #include <type_traits>
 #include <utility>
 
 #include "pstl_config.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl {
 namespace __internal {
 
 //------------------------------------------------------------------------
 // transform_reduce (version with two binary functions, according to draft N4659)
 //------------------------------------------------------------------------
 
 template <class _RandomAccessIterator1,
_OutputIterator __pattern_adjacent_difference(
     _RandomAccessIterator,
     _RandomAccessIterator,
     _OutputIterator,
     _BinaryOperation);
 
 } // namespace __internal
 } // namespace __pstl
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_NUMERIC_FWD_H */

libcxx/include/__pstl/internal/numeric_impl.h

 #include <numeric>
 
 #include "parallel_backend.h"
 #include "pstl_config.h"
 #include "execution_impl.h"
 #include "unseq_backend_simd.h"
 #include "algorithm_fwd.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl {
 namespace __internal {
 
 //------------------------------------------------------------------------
 // transform_reduce (version with two binary functions, according to draft N4659)
 //------------------------------------------------------------------------
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
__par_backend::__parallel_for(
             _IsVector{});
       });
   return __d_first + (__last - __first);
 }
 
 } // namespace __internal
 } // namespace __pstl
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_NUMERIC_IMPL_H */

libcxx/include/__pstl/internal/omp/util.h

 
 // Portability "#pragma" definition
 #ifdef _MSC_VER
 #    define _PSTL_PRAGMA(x) __pragma(x)
 #else
 #    define _PSTL_PRAGMA(x) _Pragma(#    x)
 #endif
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl
 {
 namespace __omp_backend
 {
 
 //------------------------------------------------------------------------
 // use to cancel execution
 //------------------------------------------------------------------------

libcxx/include/__pstl/internal/parallel_backend_serial.h

 #define _PSTL_PARALLEL_BACKEND_SERIAL_H
 
 #include <__memory/allocator.h>
 #include <__pstl/internal/execution_impl.h>
 #include <__utility/forward.h>
 
 #include "pstl_config.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl
 {
 namespace __serial_backend
 {
 
 template <typename _Tp>
 class __buffer
 {

 {
     std::forward<_F1>(__f1)();
     std::forward<_F2>(__f2)();
 }
 
 } // namespace __serial_backend
 } // namespace __pstl
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_PARALLEL_BACKEND_SERIAL_H */

libcxx/include/__pstl/internal/parallel_backend_tbb.h

 #include <tbb/task_arena.h>
 #include <tbb/tbb_allocator.h>
 #include <tbb/task.h>
 
 #if TBB_INTERFACE_VERSION < 10000
 #    error Intel(R) Threading Building Blocks 2018 is required; older versions are not supported.
 #endif
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl
 {
 namespace __tbb_backend
 {
 
 //! Raw memory buffer with automatic freeing and no exceptions.
 /** Some of our algorithms need to start with raw memory buffer,
 not an initialize array, because initialization/destruction

 {
     //TODO: a version of tbb::this_task_arena::isolate with variadic arguments pack should be added in the future
     tbb::this_task_arena::isolate([&]() { tbb::parallel_invoke(std::forward<_F1>(__f1), std::forward<_F2>(__f2)); });
 }
 
 } // namespace __tbb_backend
 } // namespace __pstl
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_PARALLEL_BACKEND_TBB_H */

libcxx/include/__pstl/internal/parallel_backend_utils.h

 #define _PSTL_PARALLEL_BACKEND_UTILS_H
 
 #include <iterator>
 #include <utility>
 #include "utils.h"
 
 #include "pstl_config.h"
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl
 {
 
 namespace __utils
 {
 
 //! Destroy sequence [xs,xe)
 struct __serial_destroy
for (; __first1 != __last1;)
         }
     }
     return __cc_range(__first2, __last2, __result);
 }
 
 } // namespace __utils
 } // namespace __pstl
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_PARALLEL_BACKEND_UTILS_H */

libcxx/include/__pstl/internal/parallel_impl.h

 
 #include "pstl_config.h"
 
 #include <__pstl/internal/parallel_backend.h>
 #include <atomic>
 // This header defines the minimum set of parallel routines required to support Parallel STL,
 // implemented on top of Intel(R) Threading Building Blocks (Intel(R) TBB) library
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl
 {
 namespace __internal
 {
 
 //------------------------------------------------------------------------
 // parallel_find
 //-----------------------------------------------------------------------
__par_backend::__parallel_for(__tag, std::forward<_ExecutionPolicy>(__exec), __first, __last,
                                       }
                                   });
     return __found;
 }
 
 } // namespace __internal
 } // namespace __pstl
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_PARALLEL_IMPL_H */

libcxx/include/__pstl/internal/pstl_config.h

 // TODO: Make this a proper configuration option
 #define _PSTL_PAR_BACKEND_SERIAL
 
 #include <__assert>
 #define _PSTL_ASSERT(pred) _LIBCPP_ASSERT(pred, "")
 
 #define _PSTL_PRAGMA(x) _Pragma(#    x)
 
-#define _PSTL_HIDE_FROM_ABI_PUSH /* nothing */
-#define _PSTL_HIDE_FROM_ABI_POP  /* nothing */
-
 // Enable SIMD for compilers that support OpenMP 4.0
 #if (defined(_OPENMP) && _OPENMP >= 201307)
 #    define _PSTL_PRAGMA_SIMD _PSTL_PRAGMA(omp simd)
 #    define _PSTL_PRAGMA_DECLARE_SIMD _PSTL_PRAGMA(omp declare simd)
 #    define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) _PSTL_PRAGMA(omp simd reduction(PRM))
 #else //no simd
 #    define _PSTL_PRAGMA_SIMD
 #    define _PSTL_PRAGMA_DECLARE_SIMD

libcxx/include/__pstl/internal/unseq_backend_simd.h

 #include <type_traits>
 
 #include "pstl_config.h"
 #include "utils.h"
 
 // This header defines the minimum set of vector routines required
 // to support parallel STL.
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl
 {
 namespace __unseq_backend
 {
 
 // Expect vector width up to 64 (or 512 bit)
 const std::size_t __lane_size = 64;
 
for (_DifferenceType __i = 1; __i < __n; ++__i)
             ++__cnt;
         }
     }
     return __current + __cnt;
 }
 } // namespace __unseq_backend
 } // namespace __pstl
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_UNSEQ_BACKEND_SIMD_H */

libcxx/include/__pstl/internal/utils.h

 #ifndef _PSTL_UTILS_H
 #define _PSTL_UTILS_H
 
 #include <__exception/terminate.h>
 #include <iterator>
 #include <new>
 #include <utility>
 
-_PSTL_HIDE_FROM_ABI_PUSH
-
 namespace __pstl {
 namespace __internal {
 
 template <typename _Fp>
 auto __except_handler(_Fp __f) -> decltype(__f()) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
_ForwardIterator __cmp_iterators_by_values(_ForwardIterator __a, _ForwardIterator __b, _Compare __comp) {
   } else {
     return __comp(*__a, *__b) ? __a : __b;
   }
 }
 
 } // namespace __internal
 } // namespace __pstl
 
-_PSTL_HIDE_FROM_ABI_POP
-
 #endif /* _PSTL_UTILS_H */