[libc++] Annotate template methods with visibility

[smeenai]

Summary

D25208 switches _LIBCPP_TYPE_VIS to expand to default visibility
instead of default type visibility, in order to ease building libc++
with hidden visibility. With that change made, any template methods of a
class marked _LIBCPP_TYPE_VIS will also get default visibility when
implicitly instantiated, which is not desirable for clients of libc++
headers who wish to control their visibility; a similar issue led to
PR30642. Annotate all problematic methods with an explicit visibility
specifier in order to avoid this issue.

The problematic methods were found by applying D25208 and then running
https://github.com/smeenai/bad-visibility-finder. The small methods were
marked for inlining; the larger ones marked hidden.

[smeenai]

Hidden visibility also requires extern template declarations to expand to default visibility (as opposed to just default type visibility) to be feasible. Will fix annotations there and add those to this diff.

[smeenai]

I think this actually stands well on its own. I'll do the extern template annotations in a different diff.

Also, ping :)

[EricWF]

Please put these attributes to the first declaration instead of the definition.

include/thread

392

We really should hide this using inline _LIBCPP_INLINE_VISIBILITY because it's a special C++03 symbol, so we don't even want a hidden definition omitted ideally.

[smeenai]

In D27430#632652, @EricWF wrote:

Please put these attributes to the first declaration instead of the definition.

Sounds good to me for _LIBCPP_HIDDEN, but as far as I understand, for the inline _LIBCPP_INLINE_VISIBILITY cases, at least the inline needs to be at the definition itself, otherwise it won't have any effect. For those, do you want to keep the _LIBCPP_INLINE_VISIBILITY at the declaration and the inline at the definition?

include/thread

392

Will do.

[smeenai]

In D27430#634880, @smeenai wrote:

Sounds good to me for _LIBCPP_HIDDEN, but as far as I understand, for the inline _LIBCPP_INLINE_VISIBILITY cases, at least the inline needs to be at the definition itself, otherwise it won't have any effect.

Err this might actually have just been me being stupid. Lemme confirm that first.

[smeenai]

In D27430#634882, @smeenai wrote:

In D27430#634880, @smeenai wrote:

Sounds good to me for _LIBCPP_HIDDEN, but as far as I understand, for the inline _LIBCPP_INLINE_VISIBILITY cases, at least the inline needs to be at the definition itself, otherwise it won't have any effect.

Err this might actually have just been me being stupid. Lemme confirm that first.

Yup, I'm dumb; ignore me. I'll move everything to the declarations.

[smeenai]

Folded into D25208

include/__locale

 template <class _Facet>
 inline _LIBCPP_INLINE_VISIBILITY
 locale::locale(const locale& __other, _Facet* __f)
 {
     __install_ctor(__other, __f, __f ? __f->id.__get() : 0);
 }
 
 template <class _Facet>
+inline _LIBCPP_INLINE_VISIBILITY
 locale
 locale::combine(const locale& __other) const
 {
     if (!_VSTD::has_facet<_Facet>(__other))
         __throw_runtime_error("locale::combine: locale missing facet");
 
     return locale(*this, &const_cast<_Facet&>(_VSTD::use_facet<_Facet>(__other)));
 }
protected:
     ~collate_byname();
 
     virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
                            const char_type* __lo2, const char_type* __hi2) const;
     virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const;
 };
 
 template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_INLINE_VISIBILITY
 bool
 locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
                    const basic_string<_CharT, _Traits, _Allocator>& __y) const
 {
     return _VSTD::use_facet<_VSTD::collate<_CharT> >(*this).compare(
                                        __x.data(), __x.data() + __x.size(),
                                        __y.data(), __y.data() + __y.size()) < 0;
 }

include/__mutex_base

__ceil(chrono::duration<_Rep, _Period> __d)
     _To __r = duration_cast<_To>(__d);
     if (__r < __d)
         ++__r;
     return __r;
 }
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 template <class _Predicate>
+inline _LIBCPP_INLINE_VISIBILITY
 void
 condition_variable::wait(unique_lock<mutex>& __lk, _Predicate __pred)
 {
     while (!__pred())
         wait(__lk);
 }
 
 template <class _Clock, class _Duration>
+_LIBCPP_HIDDEN
 cv_status
 condition_variable::wait_until(unique_lock<mutex>& __lk,
                                const chrono::time_point<_Clock, _Duration>& __t)
 {
     using namespace chrono;
     wait_for(__lk, __t - _Clock::now());
     return _Clock::now() < __t ? cv_status::no_timeout : cv_status::timeout;
 }
 
 template <class _Clock, class _Duration, class _Predicate>
+_LIBCPP_HIDDEN
 bool
 condition_variable::wait_until(unique_lock<mutex>& __lk,
                    const chrono::time_point<_Clock, _Duration>& __t,
                    _Predicate __pred)
 {
     while (!__pred())
     {
         if (wait_until(__lk, __t) == cv_status::timeout)
             return __pred();
     }
     return true;
 }
 
 template <class _Rep, class _Period>
+_LIBCPP_HIDDEN
 cv_status
 condition_variable::wait_for(unique_lock<mutex>& __lk,
                              const chrono::duration<_Rep, _Period>& __d)
 {
     using namespace chrono;
     if (__d <= __d.zero())
         return cv_status::timeout;
     typedef time_point<system_clock, duration<long double, nano> > __sys_tpf;

include/condition_variable

 
 struct __lock_external
 {
     template <class _Lock>
     void operator()(_Lock* __m) {__m->lock();}
 };
 
 template <class _Lock>
+_LIBCPP_HIDDEN
 void
 condition_variable_any::wait(_Lock& __lock)
 {
     shared_ptr<mutex> __mut = __mut_;
     unique_lock<mutex> __lk(*__mut);
     __lock.unlock();
     unique_ptr<_Lock, __lock_external> __lxx(&__lock);
     lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock);
     __cv_.wait(__lk);
 }  // __mut_.unlock(), __lock.lock()
 
 template <class _Lock, class _Predicate>
 inline
 void
 condition_variable_any::wait(_Lock& __lock, _Predicate __pred)
 {
     while (!__pred())
         wait(__lock);
 }
 
 template <class _Lock, class _Clock, class _Duration>
+_LIBCPP_HIDDEN
 cv_status
 condition_variable_any::wait_until(_Lock& __lock,
                                    const chrono::time_point<_Clock, _Duration>& __t)
 {
     shared_ptr<mutex> __mut = __mut_;
     unique_lock<mutex> __lk(*__mut);
     __lock.unlock();
     unique_ptr<_Lock, __lock_external> __lxx(&__lock);

include/future

public:
     template <class _Clock, class _Duration>
         future_status
         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const;
 
     virtual void __execute();
 };
 
 template <class _Clock, class _Duration>
+_LIBCPP_HIDDEN
 future_status
 __assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 {
     unique_lock<mutex> __lk(__mut_);
     if (__state_ & deferred)
         return future_status::deferred;
     while (!(__state_ & ready) && _Clock::now() < __abs_time)
         __cv_.wait_until(__lk, __abs_time);
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     void set_exception(exception_ptr __p);
 
     // setting the result with deferred notification
     void set_value_at_thread_exit();
     void set_exception_at_thread_exit(exception_ptr __p);
 };
 
 template <class _Alloc>
+_LIBCPP_HIDDEN
 promise<void>::promise(allocator_arg_t, const _Alloc& __a0)
 {
     typedef __assoc_sub_state_alloc<_Alloc> _State;
     typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
     typedef __allocator_destructor<_A2> _D2;
     _A2 __a(__a0);
     unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
     ::new(static_cast<void*>(_VSTD::addressof(*__hold.get()))) _State(__a0);

include/mutex

template <class _Rep, class _Period>
         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
             {return try_lock_until(chrono::steady_clock::now() + __d);}
     template <class _Clock, class _Duration>
         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
     void unlock() _NOEXCEPT;
 };
 
 template <class _Clock, class _Duration>
+_LIBCPP_HIDDEN
 bool
 timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 {
     using namespace chrono;
     unique_lock<mutex> __lk(__m_);
     bool no_timeout = _Clock::now() < __t;
     while (no_timeout && __locked_)
         no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout;
template <class _Rep, class _Period>
         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
             {return try_lock_until(chrono::steady_clock::now() + __d);}
     template <class _Clock, class _Duration>
         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
     void unlock() _NOEXCEPT;
 };
 
 template <class _Clock, class _Duration>
+_LIBCPP_HIDDEN
 bool
 recursive_timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 {
     using namespace chrono;
     __libcpp_thread_id __id = __libcpp_thread_get_current_id();
     unique_lock<mutex> lk(__m_);
     if (__libcpp_thread_id_equal(__id, __id_))
     {

include/thread

 {
     std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
     __thread_local_data().set_pointer(__p->__tsp_.release());
     (__p->__fn_)();
     return nullptr;
 }
 
 template <class _Fp>
+_LIBCPP_HIDDEN
 thread::thread(_Fp __f)
 {
 
     typedef __thread_invoke_pair<_Fp> _InvokePair;
     typedef std::unique_ptr<_InvokePair> _PairPtr;
     _PairPtr __pp(new _InvokePair(__f));
     int __ec = __libcpp_thread_create(&__t_, &__thread_proxy_cxx03<_InvokePair>, __pp.get());
     if (__ec == 0)