[libc++] Make _LIBCPP_TYPE_VIS export members

[smeenai]

Summary

Most classes annotated with _LIBCPP_TYPE_VIS need to have at least some
of their members exported, otherwise we have a lot of link errors when
linking against a libc++ built with hidden visibility. This also makes
_LIBCPP_TYPE_VIS be consistent across platforms, since on Windows it
already exports members.

With this change made, any template methods of a class marked
_LIBCPP_TYPE_VIS will also get default visibility when instantiatied,
which is not desirable for clients of libc++ headers who wish to control
their visibility; this is the same issue as PR30642. Annotate all
problematic methods with an explicit visibility specifier to avoid this.

The problematic methods were found by running bad-visibility-finder [1]
against the libc++ headers after making the _LIBCPP_TYPE_VIS change. The
small methods were marked for inlining; the larger ones hidden.

[1] https://github.com/smeenai/bad-visibility-finder

[EricWF]

Why do you want to build libc++.so with hidden visibility? What's wrong with the existing way we build libc++.so?

[smeenai]

In D25208#564930, @EricWF wrote:

Why do you want to build libc++.so with hidden visibility? What's wrong with the existing way we build libc++.so?

There's nothing wrong with the existing way, per se. I personally prefer hidden visibility semantics because I come from a Windows background and hidden visibility matches up well with DLL semantics, but the first section of https://gcc.gnu.org/wiki/Visibility covers the advantages of hidden visibility pretty well.

[smeenai]

Ping.

The way I see it, this doesn't change anything for people not building with hidden visibility (which should be most people, including the buildbots), but it does make _LIBCPP_TYPE_VIS more useful (and consistent with the existing Windows behavior) for people building (or attempting to build) with hidden visibility.

[smeenai]

Ping :)

[smeenai]

Ping.

I used @EricWF's ABI list verification work to confirm that this diff doesn't change the ABI of libc++ on both Darwin and Linux, so it should be completely safe.

Building with hidden visibility on top of this patch gives the following ABI removals: P7937. I'll be going through this list over the next few days to figure out if the omissions are actually correct or if they're indicative of missing source export annotations. D26823 resulted from this effort.

[smeenai]

I should clarify that the ABI omissions are for Linux.

[smeenai]

Rebasing

[smeenai]

D27430 should unblock this.

[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 then roll that macro change into this diff.

[smeenai]

Actually, I think this can stand on its own. I'll do the extern template fixes in another diff.

Also, ping :)

[smeenai]

Not gonna submit this till D27430 has been submitted (will address comments on that one after holidays).

[EricWF]

Yeah, that sounds good. I want to do more investigation into this as well.

[EricWF]

Actually I probably shouldn't have approved this due to http://llvm.org/PR30642. I forgot about that when I last reviewed this.

[smeenai]

In D25208#647743, @EricWF wrote:

Actually I probably shouldn't have approved this due to http://llvm.org/PR30642. I forgot about that when I last reviewed this.

Yup. I wrote https://github.com/smeenai/bad-visibility-finder to find all problematic instances, and D27430 fixes all the issues caused by this diff (I haven't gotten around to addressing the comments on that yet).

[smeenai]

Folding D27430 and addressing comments from that diff.

[smeenai]

Ping.

[smeenai]

Rebase and ping

[smeenai]

Rebase atop D29157 and switch to _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS

[smeenai]

Rebase

libcxx/trunk/docs/DesignDocs/VisibilityMacros.rst

 
 **_LIBCPP_INLINE_VISIBILITY**
   Mark a function as hidden and force inlining whenever possible.
 
 **_LIBCPP_ALWAYS_INLINE**
   A synonym for `_LIBCPP_INLINE_VISIBILITY`
 
 **_LIBCPP_TYPE_VIS**
+  Mark a type's typeinfo, vtable and members as having default visibility.
+  This attribute cannot be used on class templates.
+
+**_LIBCPP_TEMPLATE_VIS**
   Mark a type's typeinfo and vtable as having default visibility.
-  `_LIBCPP_TYPE_VIS`. This macro has no effect on the visibility of the
-  type's member functions. This attribute cannot be used on class templates.
+  This macro has no effect on the visibility of the type's member functions.
 
   **GCC Behavior**: GCC does not support Clang's `type_visibility(...)`
   attribute. With GCC the `visibility(...)` attribute is used and member
   functions are affected.
 
-**_LIBCPP_TEMPLATE_VIS**
-  The same as `_LIBCPP_TYPE_VIS` except that it may be applied to class
-  templates.
-
   **Windows Behavior**: DLLs do not support dllimport/export on class templates.
   The macro has an empty definition on this platform.
 
 
 **_LIBCPP_ENUM_VIS**
   Mark the typeinfo of an enum as having default visibility. This attribute
   should be applied to all enum declarations.
 

libcxx/trunk/include/__config

 #define _LIBCPP_FUNC_VIS __attribute__ ((__visibility__("default")))
 #else
 #define _LIBCPP_FUNC_VIS
 #endif
 #endif
 
 #ifndef _LIBCPP_TYPE_VIS
 #  if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
-#    if __has_attribute(__type_visibility__)
-#      define _LIBCPP_TYPE_VIS __attribute__ ((__type_visibility__("default")))
-#    else
-#      define _LIBCPP_TYPE_VIS __attribute__ ((__visibility__("default")))
-#    endif
+#    define _LIBCPP_TYPE_VIS __attribute__ ((__visibility__("default")))
 #  else
 #    define _LIBCPP_TYPE_VIS
 #  endif
 #endif
 
 #ifndef _LIBCPP_TEMPLATE_VIS
-# define _LIBCPP_TEMPLATE_VIS _LIBCPP_TYPE_VIS
+#  if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
+#    if __has_attribute(__type_visibility__)
+#      define _LIBCPP_TEMPLATE_VIS __attribute__ ((__type_visibility__("default")))
+#    else
+#      define _LIBCPP_TEMPLATE_VIS __attribute__ ((__visibility__("default")))
+#    endif
+#  else
+#    define _LIBCPP_TEMPLATE_VIS
+#  endif
 #endif
 
 #ifndef _LIBCPP_FUNC_VIS_ONLY
 # define _LIBCPP_FUNC_VIS_ONLY _LIBCPP_FUNC_VIS
 #endif
 
 #ifndef _LIBCPP_EXTERN_VIS
 # define _LIBCPP_EXTERN_VIS

libcxx/trunk/include/__locale

public:
     template <class _Facet>
         _LIBCPP_INLINE_VISIBILITY locale(const locale&, _Facet*);
     locale(const locale&, const locale&, category);
 
     ~locale();
 
     const locale& operator=(const locale&)  _NOEXCEPT;
 
-    template <class _Facet> locale combine(const locale&) const;
+    template <class _Facet>
+      _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+      locale combine(const locale&) const;
 
     // locale operations:
     string name() const;
     bool operator==(const locale&) const;
     bool operator!=(const locale& __y) const {return !(*this == __y);}
     template <class _CharT, class _Traits, class _Allocator>
+      _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
       bool operator()(const basic_string<_CharT, _Traits, _Allocator>&,
                       const basic_string<_CharT, _Traits, _Allocator>&) const;
 
     // global locale objects:
     static locale global(const locale&);
     static const locale& classic();
 
 private:

libcxx/trunk/include/__mutex_base

private:
     condition_variable& operator=(const condition_variable&); // = delete;
 
 public:
     void notify_one() _NOEXCEPT;
     void notify_all() _NOEXCEPT;
 
     void wait(unique_lock<mutex>& __lk) _NOEXCEPT;
     template <class _Predicate>
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         void wait(unique_lock<mutex>& __lk, _Predicate __pred);
 
     template <class _Clock, class _Duration>
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         cv_status
         wait_until(unique_lock<mutex>& __lk,
                    const chrono::time_point<_Clock, _Duration>& __t);
 
     template <class _Clock, class _Duration, class _Predicate>
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         bool
         wait_until(unique_lock<mutex>& __lk,
                    const chrono::time_point<_Clock, _Duration>& __t,
                    _Predicate __pred);
 
     template <class _Rep, class _Period>
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         cv_status
         wait_for(unique_lock<mutex>& __lk,
                  const chrono::duration<_Rep, _Period>& __d);
 
     template <class _Rep, class _Period, class _Predicate>
         bool
         _LIBCPP_INLINE_VISIBILITY
         wait_for(unique_lock<mutex>& __lk,

libcxx/trunk/include/condition_variable

public:
     condition_variable_any();
 
     _LIBCPP_INLINE_VISIBILITY
     void notify_one() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     void notify_all() _NOEXCEPT;
 
     template <class _Lock>
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         void wait(_Lock& __lock);
     template <class _Lock, class _Predicate>
         _LIBCPP_INLINE_VISIBILITY
         void wait(_Lock& __lock, _Predicate __pred);
 
     template <class _Lock, class _Clock, class _Duration>
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         cv_status
         wait_until(_Lock& __lock,
                    const chrono::time_point<_Clock, _Duration>& __t);
 
     template <class _Lock, class _Clock, class _Duration, class _Predicate>
         bool
         _LIBCPP_INLINE_VISIBILITY
         wait_until(_Lock& __lock,

libcxx/trunk/include/future

public:
     void copy();
 
     void wait();
     template <class _Rep, class _Period>
         future_status
         _LIBCPP_INLINE_VISIBILITY
         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const;
     template <class _Clock, class _Duration>
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         future_status
         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const;
 
     virtual void __execute();
 };
 
 template <class _Clock, class _Duration>
 future_status
class _LIBCPP_TYPE_VIS promise<void>
     _LIBCPP_INLINE_VISIBILITY
     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
 
     template <class> friend class packaged_task;
 
 public:
     promise();
     template <class _Allocator>
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         promise(allocator_arg_t, const _Allocator& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     promise(promise&& __rhs) _NOEXCEPT
         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
     promise(const promise& __rhs) = delete;
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 private:

libcxx/trunk/include/mutex

 public:
     void lock();
     bool try_lock() _NOEXCEPT;
     template <class _Rep, class _Period>
         _LIBCPP_INLINE_VISIBILITY
         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
             {return try_lock_until(chrono::steady_clock::now() + __d);}
     template <class _Clock, class _Duration>
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
     void unlock() _NOEXCEPT;
 };
 
 template <class _Clock, class _Duration>
 bool
 timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 {

 public:
     void lock();
     bool try_lock() _NOEXCEPT;
     template <class _Rep, class _Period>
         _LIBCPP_INLINE_VISIBILITY
         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
             {return try_lock_until(chrono::steady_clock::now() + __d);}
     template <class _Clock, class _Duration>
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
     void unlock() _NOEXCEPT;
 };
 
 template <class _Clock, class _Duration>
 bool
 recursive_timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 {

libcxx/trunk/include/shared_mutex

public:
     template <class _Rep, class _Period>
         _LIBCPP_INLINE_VISIBILITY
         bool
         try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time)
         {
             return try_lock_until(chrono::steady_clock::now() + __rel_time);
         }
     template <class _Clock, class _Duration>
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         bool
         try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
     void unlock();
 
     // Shared ownership
     void lock_shared();
     bool try_lock_shared();
     template <class _Rep, class _Period>
         _LIBCPP_INLINE_VISIBILITY
         bool
         try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rel_time)
         {
             return try_lock_shared_until(chrono::steady_clock::now() + __rel_time);
         }
     template <class _Clock, class _Duration>
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         bool
         try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
     void unlock_shared();
 };
 
 template <class _Clock, class _Duration>
 bool
 shared_timed_mutex::try_lock_until(

libcxx/trunk/include/thread

public:
     thread() _NOEXCEPT : __t_(_LIBCPP_NULL_THREAD) {}
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class _Fp, class ..._Args,
               class = typename enable_if
               <
                    !is_same<typename decay<_Fp>::type, thread>::value
               >::type
              >
+        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         explicit thread(_Fp&& __f, _Args&&... __args);
 #else  // _LIBCPP_HAS_NO_VARIADICS
-    template <class _Fp> explicit thread(_Fp __f);
+    template <class _Fp>
+    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+    explicit thread(_Fp __f);
 #endif
     ~thread();
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {__t.__t_ = _LIBCPP_NULL_THREAD;}
     _LIBCPP_INLINE_VISIBILITY
     thread& operator=(thread&& __t) _NOEXCEPT;