[libc++] Replace some _LIBCPP_HIDDEN with _LIBCPP_HIDE_FROM_ABI

[daltenty]

Summary

These "implementation detail" function templates were already
hidden and have no specializations in the dylib, so they seem like they can safely
use _LIBCPP_HIDE_FROM_ABI instead and have the abi tags applied as well.

Seems some of these got over looked (e.g. D129823) in various places, and they
won't be flagged by the new checks added in D129968, as they were
already hidden.

[ldionne]

I'm not sure why the libc++ review group wasn't added on this revision automatically.

I'm fine with this, but it won't work for __gcd since we still use always_inline on GCC to approximate __exclude_from_explicit_instantitation__. We could technically not use that attribute at all since this isn't a member function, but I don't think this is worth the inconsistency.

[ldionne]

LGTM with green CI.

[daltenty]

Remove __gcd from the patch, as the always_inline we use in the macro for gcc causes problems in this recursive case.

[ldionne]

LGTM with passing CI!

libcxx/include/__algorithm/sort.h

if (__c(*__x4, *__x3)) {
         }
       }
     }
   }
   return __r;
 }
 
 template <class _AlgPolicy, class _Compare, class _ForwardIterator>
-_LIBCPP_HIDDEN unsigned __sort5_wrap_policy(
+_LIBCPP_HIDE_FROM_ABI unsigned __sort5_wrap_policy(
     _ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3, _ForwardIterator __x4, _ForwardIterator __x5,
     _Compare __c) {
   using _WrappedComp = typename _WrapAlgPolicy<_AlgPolicy, _Compare>::type;
   _WrappedComp __wrapped_comp(__c);
   return std::__sort5<_WrappedComp>(
       std::move(__x1), std::move(__x2), std::move(__x3), std::move(__x4), std::move(__x5), __wrapped_comp);
 }
 

libcxx/include/__iterator/ostreambuf_iterator.h

_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator=(_CharT __c)
         }
     _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator*()     {return *this;}
     _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++()    {return *this;}
     _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++(int) {return *this;}
     _LIBCPP_INLINE_VISIBILITY bool failed() const _NOEXCEPT {return __sbuf_ == nullptr;}
 
     template <class _Ch, class _Tr>
     friend
-    _LIBCPP_HIDDEN
+    _LIBCPP_HIDE_FROM_ABI
     ostreambuf_iterator<_Ch, _Tr>
     __pad_and_output(ostreambuf_iterator<_Ch, _Tr> __s,
                      const _Ch* __ob, const _Ch* __op, const _Ch* __oe,
                      ios_base& __iob, _Ch __fl);
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_OSTREAMBUF_ITERATOR_H

libcxx/include/locale

 //  one keyword matches, an iterator to the first matching keyword is returned.
 //  If on exit __b == __e, eofbit is set in __err.  If __case_sensitive is false,
 //  __ct is used to force to lower case before comparing characters.
 //  Examples:
 //  Keywords:  "a", "abb"
 //  If the input is "a", the first keyword matches and eofbit is set.
 //  If the input is "abc", no match is found and "ab" are consumed.
 template <class _InputIterator, class _ForwardIterator, class _Ctype>
-_LIBCPP_HIDDEN
+_LIBCPP_HIDE_FROM_ABI
 _ForwardIterator
 __scan_keyword(_InputIterator& __b, _InputIterator __e,
                _ForwardIterator __kb, _ForwardIterator __ke,
                const _Ctype& __ct, ios_base::iostate& __err,
                bool __case_sensitive = true)
 {
     typedef typename iterator_traits<_InputIterator>::value_type _CharT;
     size_t __nkw = static_cast<size_t>(_VSTD::distance(__kb, __ke));
virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
                              ios_base::iostate& __err, void*& __v) const;
 };
 
 template <class _CharT, class _InputIterator>
 locale::id
 num_get<_CharT, _InputIterator>::id;
 
 template <class _Tp>
-_LIBCPP_HIDDEN _Tp
+_LIBCPP_HIDE_FROM_ABI _Tp
 __num_get_signed_integral(const char* __a, const char* __a_end,
                           ios_base::iostate& __err, int __base)
 {
     if (__a != __a_end)
     {
         __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
         errno = 0;
         char *__p2;
if (__a != __a_end)
         }
         return static_cast<_Tp>(__ll);
     }
     __err = ios_base::failbit;
     return 0;
 }
 
 template <class _Tp>
-_LIBCPP_HIDDEN _Tp
+_LIBCPP_HIDE_FROM_ABI _Tp
 __num_get_unsigned_integral(const char* __a, const char* __a_end,
                             ios_base::iostate& __err, int __base)
 {
     if (__a != __a_end)
     {
         const bool __negate = *__a == '-';
         if (__negate && ++__a == __a_end) {
           __err = ios_base::failbit;

 
 template <>
 inline _LIBCPP_INLINE_VISIBILITY
 long double __do_strtod<long double>(const char* __a, char** __p2) {
     return strtold_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
 }
 
 template <class _Tp>
-_LIBCPP_HIDDEN
+_LIBCPP_HIDE_FROM_ABI
 _Tp
 __num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err)
 {
     if (__a != __a_end)
     {
         __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
         errno = 0;
         char *__p2;
_OutputIterator __do_put_floating_point(iter_type __s, ios_base& __iob,
                                             char const* __len) const;
 };
 
 template <class _CharT, class _OutputIterator>
 locale::id
 num_put<_CharT, _OutputIterator>::id;
 
 template <class _CharT, class _OutputIterator>
-_LIBCPP_HIDDEN
+_LIBCPP_HIDE_FROM_ABI
 _OutputIterator
 __pad_and_output(_OutputIterator __s,
                  const _CharT* __ob, const _CharT* __op, const _CharT* __oe,
                  ios_base& __iob, _CharT __fl)
 {
     streamsize __sz = __oe - __ob;
     streamsize __ns = __iob.width();
     if (__ns > __sz)
         __ns -= __sz;
     else
         __ns = 0;
     for (;__ob < __op; ++__ob, ++__s)
         *__s = *__ob;
     for (; __ns; --__ns, ++__s)
         *__s = __fl;
     for (; __ob < __oe; ++__ob, ++__s)
         *__s = *__ob;
     __iob.width(0);
     return __s;
 }
 
 template <class _CharT, class _Traits>
-_LIBCPP_HIDDEN
+_LIBCPP_HIDE_FROM_ABI
 ostreambuf_iterator<_CharT, _Traits>
 __pad_and_output(ostreambuf_iterator<_CharT, _Traits> __s,
                  const _CharT* __ob, const _CharT* __op, const _CharT* __oe,
                  ios_base& __iob, _CharT __fl)
 {
     if (__s.__sbuf_ == nullptr)
         return __s;
     streamsize __sz = __oe - __ob;

 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<wchar_t>;
 #endif
 
 template <class _CharT, class _InputIterator>
-_LIBCPP_HIDDEN
+_LIBCPP_HIDE_FROM_ABI
 int
 __get_up_to_n_digits(_InputIterator& __b, _InputIterator __e,
                      ios_base::iostate& __err, const ctype<_CharT>& __ct, int __n)
 {
     // Precondition:  __n >= 1
     if (__b == __e)
     {
         __err |= ios_base::eofbit | ios_base::failbit;

 
 template <class _CharT, class _InputIterator>
 locale::id
 money_get<_CharT, _InputIterator>::id;
 
 _LIBCPP_FUNC_VIS void __do_nothing(void*);
 
 template <class _Tp>
-_LIBCPP_HIDDEN
+_LIBCPP_HIDE_FROM_ABI
 void
 __double_or_nothing(unique_ptr<_Tp, void(*)(void*)>& __b, _Tp*& __n, _Tp*& __e)
 {
     bool __owns = __b.get_deleter() != __do_nothing;
     size_t __cur_cap = static_cast<size_t>(__e-__b.get()) * sizeof(_Tp);
     size_t __new_cap = __cur_cap < numeric_limits<size_t>::max() / 2 ?
                        2 * __cur_cap : numeric_limits<size_t>::max();
     if (__new_cap == 0)