[libc++] Add _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY to support GCC ABI compatibility

[EricWF]

Summary

GCC and Clang handle visibility attributes on the out-of-line definition of externally instantiated templates differently. For example in the reproducer below Clang will emit both 'foo' and 'bar' with default visibility while GCC only emits a non-hidden 'foo'.

// RUN: g++ -std=c++11 -shared -O3 test.cpp && sym_extract.py a.out
// RUN: clang++ -std=c++11 -shared -O3 test.cpp && sym_extract.py a.out
#define INLINE_VISIBILITY __attribute__((visibility("hidden"), always_inline))

template <class T>
struct Foo {
  void foo();
  void bar();
};

template <class T>
void Foo<T>::foo() {}

template <class T>
inline INLINE_VISIBILITY
void Foo<T>::bar() {}

template struct Foo<int>;

This difference creates ABI incompatibilities between Clang and GCC built dylibs. Specifically GCC built dylibs lack definitions for various member functions of basic_string, basic_istream, basic_ostream, basic_iostream, and basic_streambuf (All of these types are externally instantiated).

Surprisingly these missing symbols don't cause many problems because the functions are marked always_inline therefore the dylib definition is rarely needed. However when an out-of-line definition is required then GCC built dylibs will fail to link. For example GCC built dylibs cannot build Clang.

This patch works around this issue by adding _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY which is used to mark externally instantiated member functions as always inline. When building the library _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY sets the symbol's visibility to "default" instead of "hidden", otherwise it acts exactly the same as _LIBCPP_INLINE_VISIBILITY.

After applying this patch GCC dylibs now contain:

• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7sungetcEv
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5gbumpEi
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7sungetcEv
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9sputbackcEc
• _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EE
• _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_9basic_iosIwS2_EES6_E
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setpEPcS4_
• _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6snextcEv
• _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4swapERS3_
• _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4swapERS3_
• _ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm
• _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_8ios_baseES5_E
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pubsetbufEPcl
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekoffExNS_8ios_base7seekdirEj
• _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_9basic_iosIwS2_EES6_E
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5pbumpEi
• _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpENS_4fposI11__mbstate_tEE
• _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPcl
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetcEv
• _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EE
• _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_8ios_baseES5_E
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8in_availEv
• _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_8ios_baseES5_E
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6sbumpcEv
• _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_9basic_iosIcS2_EES6_E
• _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERc
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6snextcEv
• _ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEmw
• _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwl
• _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5tellpEv
• _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERw
• _ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7pubsyncEv
• _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPcl
• _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE
• _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_9basic_iosIcS2_EES6_E
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7pubsyncEv
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputcEc
• _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpExNS_8ios_base7seekdirE
• _ZNKSt3__115basic_streambufIcNS_11char_traitsIcEEE6getlocEv
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5gbumpEi
• _ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEE4swapERS3_
• _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpENS_4fposI11__mbstate_tEE
• _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5tellpEv
• _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRS3_S4_E
• _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwl
• _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE
• _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRS3_S4_E
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setgEPcS4_S4_
• _ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwmm
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setgEPwS4_S4_
• _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8pubimbueERKNS_6localeE
• _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE4swapERS3_
• _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekposENS_4fposI11__mbstate_tEEj
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5pbumpEi
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetcEv
• _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE4swapERS3_
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekposENS_4fposI11__mbstate_tEEj
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputnEPKcl
• _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpExNS_8ios_base7seekdirE
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetnEPwl
• _ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_8ios_baseES5_E
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setpEPwS4_
• _ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetnEPcl
• _ZNKSt3__115basic_streambufIwNS_11char_traitsIwEEE6getlocEv
• _ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8pubimbueERKNS_6localeE
• _ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8in_availEv
• _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE
• _ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcmm
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6sbumpcEv
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekoffExNS_8ios_base7seekdirEj
• _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE
• _ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRS3_S4_E
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9sputbackcEw
• _ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwm
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputnEPKwl
• _ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRS3_S4_E
• _ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pubsetbufEPwl
• _ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputcEw

This patch has no effect on Clang based builds.

[EricWF]

I should mention that before this patch a GCC compiled dylib had 62 additional symbols and was missing 105 symbols. Now there are only 20 missing symbols and 62 additional.

[EricWF]

• Update the patch based on r281673.
• Add doc for _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
• Move all uses of _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY to the first declaration in order to support __attribute__((internal_linkage)). I took the liberty of moving many of the definitions in-line to reduce duplication.

[EricWF]

Accepting to commit. Post commit review is very welcome (but nobody likes looking at visibility patches).

CMakeLists.txt

 endif()
 
 # On all systems the system c++ standard library headers need to be excluded.
 # MSVC only has -X, which disables all default includes; including the crt.
 # Thus, we do nothing and hope we don't accidentally include any of the C++
 # headers
 add_compile_flags_if_supported(-nostdinc++)
 
+add_definitions(-D_LIBCPP_BUILDING_LIBRARY)
+
 # Warning flags ===============================================================
 add_definitions(-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 add_compile_flags_if_supported(
     -Wall -Wextra -W -Wwrite-strings
     -Wno-unused-parameter -Wno-long-long
     -Werror=return-type)
 if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
     add_compile_flags_if_supported(

docs/DesignDocs/VisibilityMacros.rst

**_LIBCPP_EXTERN_TEMPLATE_TYPE_VIS**
   specified on the primary template and to export the member functions produced
   by the explicit instantiation in the dylib.
 
   **GCC Behavior**: GCC ignores visibility attributes applied the type in
   extern template declarations and applying an attribute results in a warning.
   However since `_LIBCPP_TYPE_VIS_ONLY` is the same as `_LIBCPP_TYPE_VIS` the
   visibility is already correct. The macro has an empty definition with GCC.
 
+**_LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY**
+  Mark a member function of a class template as hidden and inline except when
+  building the libc++ library where it marks the symbol as being exported by
+  the library.
+
+  This macro is used to maintain ABI compatibility for symbols that have been
+  historically exported by the libc++ library but are now marked inline. It
+  should only be applied to member functions of class templates that are
+  externally instantiated.
+
 **_LIBCPP_EXCEPTION_ABI**
   Mark the member functions, typeinfo, and vtable of the type as being exported
   by the libc++ library. This macro must be applied to all *exception types*.
   Exception types must be defined directly in namespace `std` and not the
   versioning namespace.
 
 Links
 =====
 
 * `[cfe-dev] Visibility in libc++ - 1 <http://lists.llvm.org/pipermail/cfe-dev/2013-July/030610.html>`_
 * `[cfe-dev] Visibility in libc++ - 2 <http://lists.llvm.org/pipermail/cfe-dev/2013-August/031195.html>`_
 * `[libcxx] Visibility fixes for Windows <http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20130805/085461.html>`_

include/__config

 #define _LIBCPP_EXCEPTION_ABI       _LIBCPP_DLL_VIS
 #define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_DLL_VIS
 #define _LIBCPP_HIDDEN
 #define _LIBCPP_TYPE_VIS_ONLY
 #define _LIBCPP_FUNC_VIS_ONLY
 #define _LIBCPP_ENUM_VIS
 #define _LIBCPP_INLINE_VISIBILITY __forceinline
 #define _LIBCPP_ALWAYS_INLINE     __forceinline
+#define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY __forceinline
 #endif // _WIN32
 
 #ifndef _LIBCPP_HIDDEN
 #define _LIBCPP_HIDDEN __attribute__ ((__visibility__("hidden")))
 #endif
 
 #ifndef _LIBCPP_FUNC_VIS
 #define _LIBCPP_FUNC_VIS __attribute__ ((__visibility__("default")))

 #ifndef _LIBCPP_INLINE_VISIBILITY
 #define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__visibility__("hidden"), __always_inline__))
 #endif
 
 #ifndef _LIBCPP_ALWAYS_INLINE
 #define _LIBCPP_ALWAYS_INLINE  __attribute__ ((__visibility__("hidden"), __always_inline__))
 #endif
 
+#ifndef _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+# ifdef _LIBCPP_BUILDING_LIBRARY
+#   define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY __attribute__((__visibility__("default"), __always_inline__))
+# else
+#   define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
+# endif
+#endif
+
 #ifndef _LIBCPP_PREFERRED_OVERLOAD
 #  if __has_attribute(__enable_if__)
 #    define _LIBCPP_PREFERRED_OVERLOAD __attribute__ ((__enable_if__(true, "")))
 #  endif
 #endif
 
 #ifndef _LIBCPP_HAS_NO_NOEXCEPT
 #  define _NOEXCEPT noexcept

include/istream

public:
     // types (inherited from basic_ios (27.5.4)):
     typedef _CharT                         char_type;
     typedef _Traits                        traits_type;
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     // 27.7.1.1.1 Constructor/destructor:
-    explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb);
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb) : __gc_(0)
+    { this->init(__sb); }
     virtual ~basic_istream();
 protected:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+    inline _LIBCPP_INLINE_VISIBILITY
     basic_istream(basic_istream&& __rhs);
 #endif
     // 27.7.1.1.2 Assign/swap:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+    inline _LIBCPP_INLINE_VISIBILITY
     basic_istream& operator=(basic_istream&& __rhs);
 #endif
-    void swap(basic_istream& __rhs);
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    void swap(basic_istream& __rhs) {
+      _VSTD::swap(__gc_, __rhs.__gc_);
+      basic_ios<char_type, traits_type>::swap(__rhs);
+    }
 
 #if _LIBCPP_STD_VER > 11
 #ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
     basic_istream           (const basic_istream& __rhs) = delete;
     basic_istream& operator=(const basic_istream& __rhs) = delete;
 #else
     basic_istream           (const basic_istream& __rhs); // not defined
     basic_istream& operator=(const basic_istream& __rhs); // not defined
 #endif
 #endif
 public:
 
     // 27.7.1.1.3 Prefix/suffix:
     class _LIBCPP_TYPE_VIS_ONLY sentry;
 
     // 27.7.1.2 Formatted input:
-    basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&));
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&))
+    { return __pf(*this); }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     basic_istream& operator>>(basic_ios<char_type, traits_type>&
-                              (*__pf)(basic_ios<char_type, traits_type>&));
-    basic_istream& operator>>(ios_base& (*__pf)(ios_base&));
+                              (*__pf)(basic_ios<char_type, traits_type>&))
+    { __pf(*this); return *this; }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    basic_istream& operator>>(ios_base& (*__pf)(ios_base&))
+    { __pf(*this); return *this; }
+
     basic_istream& operator>>(basic_streambuf<char_type, traits_type>* __sb);
     basic_istream& operator>>(bool& __n);
     basic_istream& operator>>(short& __n);
     basic_istream& operator>>(unsigned short& __n);
     basic_istream& operator>>(int& __n);
     basic_istream& operator>>(unsigned int& __n);
     basic_istream& operator>>(long& __n);
     basic_istream& operator>>(unsigned long& __n);
     basic_istream& operator>>(long long& __n);
     basic_istream& operator>>(unsigned long long& __n);
     basic_istream& operator>>(float& __f);
     basic_istream& operator>>(double& __f);
     basic_istream& operator>>(long double& __f);
     basic_istream& operator>>(void*& __p);
 
     // 27.7.1.3 Unformatted input:
     _LIBCPP_INLINE_VISIBILITY
     streamsize gcount() const {return __gc_;}
     int_type get();
-    basic_istream& get(char_type& __c);
-    basic_istream& get(char_type* __s, streamsize __n);
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    basic_istream& get(char_type& __c) {
+      int_type __ch = get();
+      if (__ch != traits_type::eof())
+        __c = traits_type::to_char_type(__ch);
+      return *this;
+    }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    basic_istream& get(char_type* __s, streamsize __n)
+    { return get(__s, __n, this->widen('\n')); }
+
     basic_istream& get(char_type* __s, streamsize __n, char_type __dlm);
-    basic_istream& get(basic_streambuf<char_type, traits_type>& __sb);
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    basic_istream& get(basic_streambuf<char_type, traits_type>& __sb)
+    { return get(__sb, this->widen('\n')); }
+
     basic_istream& get(basic_streambuf<char_type, traits_type>& __sb, char_type __dlm);
 
-    basic_istream& getline(char_type* __s, streamsize __n);
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    basic_istream& getline(char_type* __s, streamsize __n)
+    { return getline(__s, __n, this->widen('\n')); }
+
     basic_istream& getline(char_type* __s, streamsize __n, char_type __dlm);
 
     basic_istream& ignore(streamsize __n = 1, int_type __dlm = traits_type::eof());
     int_type peek();
     basic_istream& read (char_type* __s, streamsize __n);
     streamsize readsome(char_type* __s, streamsize __n);
 
     basic_istream& putback(char_type __c);
if (__is.good())
                 __is.setstate(ios_base::failbit | ios_base::eofbit);
         }
         __ok_ = __is.good();
     }
     else
         __is.setstate(ios_base::failbit);
 }
 
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>::basic_istream(basic_streambuf<char_type, traits_type>* __sb)
-    : __gc_(0)
-{
-    this->init(__sb);
-}
-
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
 basic_istream<_CharT, _Traits>::basic_istream(basic_istream&& __rhs)
     : __gc_(__rhs.__gc_)
 {
     __rhs.__gc_ = 0;
     this->move(__rhs);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
 basic_istream<_CharT, _Traits>&
 basic_istream<_CharT, _Traits>::operator=(basic_istream&& __rhs)
 {
     swap(__rhs);
     return *this;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>::~basic_istream()
 {
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-basic_istream<_CharT, _Traits>::swap(basic_istream& __rhs)
-{
-    _VSTD::swap(__gc_, __rhs.__gc_);
-    basic_ios<char_type, traits_type>::swap(__rhs);
-}
-
-template <class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>&
 basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
#ifndef _LIBCPP_NO_EXCEPTIONS
     catch (...)
     {
         this->__set_badbit_and_consider_rethrow();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     return *this;
 }
 
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(basic_istream& (*__pf)(basic_istream&))
-{
-    return __pf(*this);
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(basic_ios<char_type, traits_type>&
-                                           (*__pf)(basic_ios<char_type, traits_type>&))
-{
-    __pf(*this);
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(ios_base& (*__pf)(ios_base&))
-{
-    __pf(*this);
-    return *this;
-}
-
-template<class _CharT, class _Traits>
+template<class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
#ifndef _LIBCPP_NO_EXCEPTIONS
     {
         this->__set_badbit_and_consider_rethrow();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     return __r;
 }
 
 template<class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::get(char_type& __c)
-{
-    int_type __ch = get();
-    if (__ch != traits_type::eof())
-        __c = traits_type::to_char_type(__ch);
-    return *this;
-}
-
-template<class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>&
 basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __dlm)
 {
     __gc_ = 0;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
#ifndef _LIBCPP_NO_EXCEPTIONS
     {
         this->__set_badbit_and_consider_rethrow();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     return *this;
 }
 
 template<class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n)
-{
-    return get(__s, __n, this->widen('\n'));
-}
-
-template<class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>&
 basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __sb,
                                     char_type __dlm)
 {
     __gc_ = 0;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
#ifndef _LIBCPP_NO_EXCEPTIONS
     {
         this->__set_badbit_and_consider_rethrow();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     return *this;
 }
 
 template<class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __sb)
-{
-    return get(__sb, this->widen('\n'));
-}
-
-template<class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>&
 basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_type __dlm)
 {
     __gc_ = 0;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
#ifndef _LIBCPP_NO_EXCEPTIONS
     {
         this->__set_badbit_and_consider_rethrow();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     return *this;
 }
 
 template<class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n)
-{
-    return getline(__s, __n, this->widen('\n'));
-}
-
-template<class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>&
 basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm)
 {
     __gc_ = 0;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
public:
     // types:
     typedef _CharT                         char_type;
     typedef _Traits                        traits_type;
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     // constructor/destructor
-    explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb);
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb)
+      : basic_istream<_CharT, _Traits>(__sb)
+    {}
+
     virtual ~basic_iostream();
 protected:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+    inline _LIBCPP_INLINE_VISIBILITY
     basic_iostream(basic_iostream&& __rhs);
 #endif
 
     // assign/swap
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+    inline _LIBCPP_INLINE_VISIBILITY
     basic_iostream& operator=(basic_iostream&& __rhs);
 #endif
-    void swap(basic_iostream& __rhs);
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    void swap(basic_iostream& __rhs)
+    { basic_istream<char_type, traits_type>::swap(__rhs); }
 public:
 };
 
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_iostream<_CharT, _Traits>::basic_iostream(basic_streambuf<char_type, traits_type>* __sb)
-    : basic_istream<_CharT, _Traits>(__sb)
-{
-}
-
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
 basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs)
     : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs))
 {
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
 basic_iostream<_CharT, _Traits>&
 basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs)
 {
     swap(__rhs);
     return *this;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
 basic_iostream<_CharT, _Traits>::~basic_iostream()
 {
 }
 
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-basic_iostream<_CharT, _Traits>::swap(basic_iostream& __rhs)
-{
-    basic_istream<char_type, traits_type>::swap(__rhs);
-}
-
 template<class _CharT, class _Traits, class _Allocator>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
            basic_string<_CharT, _Traits, _Allocator>& __str)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {

include/ostream

public:
     // types (inherited from basic_ios (27.5.4)):
     typedef _CharT                         char_type;
     typedef _Traits                        traits_type;
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     // 27.7.2.2 Constructor/destructor:
-    explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb);
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb)
+    { this->init(__sb); }
     virtual ~basic_ostream();
 protected:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+    inline _LIBCPP_INLINE_VISIBILITY
     basic_ostream(basic_ostream&& __rhs);
 #endif
 
     // 27.7.2.3 Assign/swap
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
+    inline _LIBCPP_INLINE_VISIBILITY
     basic_ostream& operator=(basic_ostream&& __rhs);
 #endif
-    void swap(basic_ostream& __rhs);
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    void swap(basic_ostream& __rhs)
+    { basic_ios<char_type, traits_type>::swap(__rhs); }
 
 #ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
     basic_ostream           (const basic_ostream& __rhs) = delete;
     basic_ostream& operator=(const basic_ostream& __rhs) = delete;
 #else
     basic_ostream           (const basic_ostream& __rhs); // not defined
     basic_ostream& operator=(const basic_ostream& __rhs); // not defined
 #endif
 public:
 
     // 27.7.2.4 Prefix/suffix:
     class _LIBCPP_TYPE_VIS_ONLY sentry;
 
     // 27.7.2.6 Formatted output:
-    basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&));
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&))
+    { return __pf(*this); }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     basic_ostream& operator<<(basic_ios<char_type, traits_type>&
-                              (*__pf)(basic_ios<char_type,traits_type>&));
-    basic_ostream& operator<<(ios_base& (*__pf)(ios_base&));
+                              (*__pf)(basic_ios<char_type,traits_type>&))
+    { __pf(*this); return *this; }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    basic_ostream& operator<<(ios_base& (*__pf)(ios_base&))
+    { __pf(*this); return *this; }
+
     basic_ostream& operator<<(bool __n);
     basic_ostream& operator<<(short __n);
     basic_ostream& operator<<(unsigned short __n);
     basic_ostream& operator<<(int __n);
     basic_ostream& operator<<(unsigned int __n);
     basic_ostream& operator<<(long __n);
     basic_ostream& operator<<(unsigned long __n);
     basic_ostream& operator<<(long long __n);
     basic_ostream& operator<<(unsigned long long __n);
     basic_ostream& operator<<(float __f);
     basic_ostream& operator<<(double __f);
     basic_ostream& operator<<(long double __f);
     basic_ostream& operator<<(const void* __p);
     basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);
 
     // 27.7.2.7 Unformatted output:
     basic_ostream& put(char_type __c);
     basic_ostream& write(const char_type* __s, streamsize __n);
     basic_ostream& flush();
 
     // 27.7.2.5 seeks:
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     pos_type tellp();
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     basic_ostream& seekp(pos_type __pos);
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);
 
 protected:
     _LIBCPP_ALWAYS_INLINE
     basic_ostream() {}  // extension, intentially does not initialize
 };
 
 template <class _CharT, class _Traits>
#ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>::basic_ostream(basic_streambuf<char_type, traits_type>* __sb)
-{
-    this->init(__sb);
-}
-
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs)
 {
     this->move(__rhs);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>&
 basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs)
 {
     swap(__rhs);
     return *this;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>::~basic_ostream()
 {
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-basic_ostream<_CharT, _Traits>::swap(basic_ostream& __rhs)
-{
-    basic_ios<char_type, traits_type>::swap(__rhs);
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(basic_ostream& (*__pf)(basic_ostream&))
-{
-    return __pf(*this);
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(basic_ios<char_type, traits_type>&
-                                           (*__pf)(basic_ios<char_type,traits_type>&))
-{
-    __pf(*this);
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(ios_base& (*__pf)(ios_base&))
-{
-    __pf(*this);
-    return *this;
-}
-
-template <class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>&
 basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         sentry __s(*this);
#ifndef _LIBCPP_NO_EXCEPTIONS
     {
         this->__set_badbit_and_consider_rethrow();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     return *this;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
 typename basic_ostream<_CharT, _Traits>::pos_type
 basic_ostream<_CharT, _Traits>::tellp()
 {
     if (this->fail())
         return pos_type(-1);
     return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>&
 basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
 {
     sentry __s(*this);
     if (!this->fail())
     {
         if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1))
             this->setstate(ios_base::failbit);
     }
     return *this;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>&
 basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir)
 {
     sentry __s(*this);
     if (!this->fail())
     {
         if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1))
             this->setstate(ios_base::failbit);

include/streambuf

public:
     typedef _Traits                        traits_type;
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     virtual ~basic_streambuf();
 
     // 27.6.2.2.1 locales:
-    locale pubimbue(const locale& __loc);
-    locale getloc() const;
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    locale pubimbue(const locale& __loc) {
+        imbue(__loc);
+        locale __r = __loc_;
+        __loc_ = __loc;
+        return __r;
+    }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    locale getloc() const { return __loc_; }
 
     // 27.6.2.2.2 buffer and positioning:
-    basic_streambuf* pubsetbuf(char_type* __s, streamsize __n);
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    basic_streambuf* pubsetbuf(char_type* __s, streamsize __n)
+    { return setbuf(__s, __n); }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     pos_type pubseekoff(off_type __off, ios_base::seekdir __way,
-                        ios_base::openmode __which = ios_base::in | ios_base::out);
+                        ios_base::openmode __which = ios_base::in | ios_base::out)
+    { return seekoff(__off, __way, __which); }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     pos_type pubseekpos(pos_type __sp,
-                        ios_base::openmode __which = ios_base::in | ios_base::out);
-    int pubsync();
+                        ios_base::openmode __which = ios_base::in | ios_base::out)
+    { return seekpos(__sp, __which); }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    int pubsync() { return sync(); }
 
     // Get and put areas:
     // 27.6.2.2.3 Get area:
-    streamsize in_avail();
-    int_type snextc();
-    int_type sbumpc();
-    int_type sgetc();
-    streamsize sgetn(char_type* __s, streamsize __n);
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    streamsize in_avail() {
+        if (__ninp_ < __einp_)
+            return static_cast<streamsize>(__einp_ - __ninp_);
+        return showmanyc();
+    }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    int_type snextc() {
+        if (sbumpc() == traits_type::eof())
+            return traits_type::eof();
+        return sgetc();
+    }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    int_type sbumpc() {
+        if (__ninp_ == __einp_)
+            return uflow();
+        return traits_type::to_int_type(*__ninp_++);
+    }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    int_type sgetc() {
+        if (__ninp_ == __einp_)
+            return underflow();
+        return traits_type::to_int_type(*__ninp_);
+    }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    streamsize sgetn(char_type* __s, streamsize __n)
+    { return xsgetn(__s, __n); }
 
     // 27.6.2.2.4 Putback:
-    int_type sputbackc(char_type __c);
-    int_type sungetc();
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    int_type sputbackc(char_type __c) {
+        if (__binp_ == __ninp_ || !traits_type::eq(__c, __ninp_[-1]))
+            return pbackfail(traits_type::to_int_type(__c));
+        return traits_type::to_int_type(*--__ninp_);
+    }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    int_type sungetc() {
+        if (__binp_ == __ninp_)
+          return pbackfail();
+        return traits_type::to_int_type(*--__ninp_);
+    }
 
     // 27.6.2.2.5 Put area:
-    int_type sputc(char_type __c);
-    streamsize sputn(const char_type* __s, streamsize __n);
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    int_type sputc(char_type __c) {
+        if (__nout_ == __eout_)
+            return overflow(traits_type::to_int_type(__c));
+        *__nout_++ = __c;
+        return traits_type::to_int_type(__c);
+    }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    streamsize sputn(const char_type* __s, streamsize __n)
+    { return xsputn(__s, __n); }
 
 protected:
     basic_streambuf();
     basic_streambuf(const basic_streambuf& __rhs);
     basic_streambuf& operator=(const basic_streambuf& __rhs);
     void swap(basic_streambuf& __rhs);
 
     // 27.6.2.3.2 Get area:
     _LIBCPP_ALWAYS_INLINE char_type* eback() const {return __binp_;}
     _LIBCPP_ALWAYS_INLINE char_type* gptr()  const {return __ninp_;}
     _LIBCPP_ALWAYS_INLINE char_type* egptr() const {return __einp_;}
-    void gbump(int __n);
-    void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend);
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    void gbump(int __n) { __ninp_ += __n; }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) {
+        __binp_ = __gbeg;
+        __ninp_ = __gnext;
+        __einp_ = __gend;
+    }
 
     // 27.6.2.3.3 Put area:
     _LIBCPP_ALWAYS_INLINE char_type* pbase() const {return __bout_;}
     _LIBCPP_ALWAYS_INLINE char_type* pptr()  const {return __nout_;}
     _LIBCPP_ALWAYS_INLINE char_type* epptr() const {return __eout_;}
-    void pbump(int __n);
-    void setp(char_type* __pbeg, char_type* __pend);
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    void pbump(int __n) { __nout_ += __n; }
+
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
+    void setp(char_type* __pbeg, char_type* __pend) {
+        __bout_ = __nout_ = __pbeg;
+        __eout_ = __pend;
+    }
 
     // 27.6.2.4 virtual functions:
     // 27.6.2.4.1 Locales:
     virtual void imbue(const locale& __loc);
 
     // 27.6.2.4.2 Buffer management and positioning:
     virtual basic_streambuf* setbuf(char_type* __s, streamsize __n);
     virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,

 };
 
 template <class _CharT, class _Traits>
 basic_streambuf<_CharT, _Traits>::~basic_streambuf()
 {
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-locale
-basic_streambuf<_CharT, _Traits>::pubimbue(const locale& __loc)
-{
-    imbue(__loc);
-    locale __r = __loc_;
-    __loc_ = __loc;
-    return __r;
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-locale
-basic_streambuf<_CharT, _Traits>::getloc() const
-{
-    return __loc_;
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_streambuf<_CharT, _Traits>*
-basic_streambuf<_CharT, _Traits>::pubsetbuf(char_type* __s, streamsize __n)
-{
-    return setbuf(__s, __n);
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-typename basic_streambuf<_CharT, _Traits>::pos_type
-basic_streambuf<_CharT, _Traits>::pubseekoff(off_type __off,
-                                             ios_base::seekdir __way,
-                                             ios_base::openmode __which)
-{
-    return seekoff(__off, __way, __which);
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-typename basic_streambuf<_CharT, _Traits>::pos_type
-basic_streambuf<_CharT, _Traits>::pubseekpos(pos_type __sp,
-                                             ios_base::openmode __which)
-{
-    return seekpos(__sp, __which);
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-int
-basic_streambuf<_CharT, _Traits>::pubsync()
-{
-    return sync();
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-streamsize
-basic_streambuf<_CharT, _Traits>::in_avail()
-{
-    if (__ninp_ < __einp_)
-        return static_cast<streamsize>(__einp_ - __ninp_);
-    return showmanyc();
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-typename basic_streambuf<_CharT, _Traits>::int_type
-basic_streambuf<_CharT, _Traits>::snextc()
-{
-    if (sbumpc() == traits_type::eof())
-        return traits_type::eof();
-    return sgetc();
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-typename basic_streambuf<_CharT, _Traits>::int_type
-basic_streambuf<_CharT, _Traits>::sbumpc()
-{
-    if (__ninp_ == __einp_)
-        return uflow();
-    return traits_type::to_int_type(*__ninp_++);
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-typename basic_streambuf<_CharT, _Traits>::int_type
-basic_streambuf<_CharT, _Traits>::sgetc()
-{
-    if (__ninp_ == __einp_)
-        return underflow();
-    return traits_type::to_int_type(*__ninp_);
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-streamsize
-basic_streambuf<_CharT, _Traits>::sgetn(char_type* __s, streamsize __n)
-{
-    return xsgetn(__s, __n);
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-typename basic_streambuf<_CharT, _Traits>::int_type
-basic_streambuf<_CharT, _Traits>::sputbackc(char_type __c)
-{
-    if (__binp_ == __ninp_ || !traits_type::eq(__c, __ninp_[-1]))
-        return pbackfail(traits_type::to_int_type(__c));
-    return traits_type::to_int_type(*--__ninp_);
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-typename basic_streambuf<_CharT, _Traits>::int_type
-basic_streambuf<_CharT, _Traits>::sungetc()
-{
-    if (__binp_ == __ninp_)
-        return pbackfail();
-    return traits_type::to_int_type(*--__ninp_);
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-typename basic_streambuf<_CharT, _Traits>::int_type
-basic_streambuf<_CharT, _Traits>::sputc(char_type __c)
-{
-    if (__nout_ == __eout_)
-        return overflow(traits_type::to_int_type(__c));
-    *__nout_++ = __c;
-    return traits_type::to_int_type(__c);
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-streamsize
-basic_streambuf<_CharT, _Traits>::sputn(const char_type* __s, streamsize __n)
-{
-    return xsputn(__s, __n);
-}
-
-template <class _CharT, class _Traits>
 basic_streambuf<_CharT, _Traits>::basic_streambuf()
     : __binp_(0),
       __ninp_(0),
       __einp_(0),
       __bout_(0),
       __nout_(0),
       __eout_(0)
 {
basic_streambuf<_CharT, _Traits>::swap(basic_streambuf& __sb)
     _VSTD::swap(__ninp_, __sb.__ninp_);
     _VSTD::swap(__einp_, __sb.__einp_);
     _VSTD::swap(__bout_, __sb.__bout_);
     _VSTD::swap(__nout_, __sb.__nout_);
     _VSTD::swap(__eout_, __sb.__eout_);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-basic_streambuf<_CharT, _Traits>::gbump(int __n)
-{
-    __ninp_ += __n;
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-basic_streambuf<_CharT, _Traits>::setg(char_type* __gbeg, char_type* __gnext,
-                                                          char_type* __gend)
-{
-    __binp_ = __gbeg;
-    __ninp_ = __gnext;
-    __einp_ = __gend;
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-basic_streambuf<_CharT, _Traits>::pbump(int __n)
-{
-    __nout_ += __n;
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-basic_streambuf<_CharT, _Traits>::setp(char_type* __pbeg, char_type* __pend)
-{
-    __bout_ = __nout_ = __pbeg;
-    __eout_ = __pend;
-}
-
-template <class _CharT, class _Traits>
 void
 basic_streambuf<_CharT, _Traits>::imbue(const locale&)
 {
 }
 
 template <class _CharT, class _Traits>
 basic_streambuf<_CharT, _Traits>*
 basic_streambuf<_CharT, _Traits>::setbuf(char_type*, streamsize)

include/string

             {return (__s + (__a-1)) & ~(__a-1);}
     enum {__alignment = 16};
     static _LIBCPP_INLINE_VISIBILITY
     size_type __recommend(size_type __s) _NOEXCEPT
         {return (__s < __min_cap ? static_cast<size_type>(__min_cap) :
                  __align_it<sizeof(value_type) < __alignment ?
                             __alignment/sizeof(value_type) : 1 > (__s+1)) - 1;}
 
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     void __init(const value_type* __s, size_type __sz, size_type __reserve);
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     void __init(const value_type* __s, size_type __sz);
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     void __init(size_type __n, value_type __c);
 
     template <class _InputIterator>
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     typename enable_if
     <
         __is_exactly_input_iterator<_InputIterator>::value,
         void
     >::type
     __init(_InputIterator __first, _InputIterator __last);
 
     template <class _ForwardIterator>
+    inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     typename enable_if
     <
         __is_forward_iterator<_ForwardIterator>::value,
         void
     >::type
     __init(_ForwardIterator __first, _ForwardIterator __last);
 
     void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,

 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
     __zero();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz, size_type __reserve)
+void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s,
+                                                       size_type __sz,
+                                                       size_type __reserve)
 {
     if (__reserve > max_size())
         this->__throw_length_error();
     pointer __p;
     if (__reserve < __min_cap)
     {
         __set_short_size(__sz);
         __p = __get_short_pointer();
     }
     else
     {
         size_type __cap = __recommend(__reserve);
         __p = __alloc_traits::allocate(__alloc(), __cap+1);
         __set_long_pointer(__p);
         __set_long_cap(__cap+1);
         __set_long_size(__sz);
     }
     traits_type::copy(_VSTD::__to_raw_pointer(__p), __s, __sz);
     traits_type::assign(__p[__sz], value_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz)
 {
     if (__sz > max_size())
         this->__throw_length_error();
     pointer __p;
     if (__sz < __min_cap)
     {

     if (__is_long())
         __get_db()->swap(this, &__str);
 #endif
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
 {
     if (__n > max_size())
         this->__throw_length_error();
     pointer __p;
     if (__n < __min_cap)
     {

     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
 #endif
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _InputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     __is_exactly_input_iterator<_InputIterator>::value,
     void
 >::type
 basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
 {
     __zero();

             __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
         throw;
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _ForwardIterator>
-inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     __is_forward_iterator<_ForwardIterator>::value,
     void
 >::type
 basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
 {
     size_type __sz = static_cast<size_type>(_VSTD::distance(__first, __last));

utils/sym_check/sym_diff.py

 def main():
     parser = ArgumentParser(
         description='Extract a list of symbols from a shared library.')
     parser.add_argument(
         '--names-only', dest='names_only',
         help='Only print symbol names',
         action='store_true', default=False)
     parser.add_argument(
+        '--removed-only', dest='removed_only',
+        help='Only print removed symbols',
+        action='store_true', default=False)
+    parser.add_argument(
         '-o', '--output', dest='output',
         help='The output file. stdout is used if not given',
         type=str, action='store', default=None)
     parser.add_argument(
         '--demangle', dest='demangle', action='store_true', default=False)
     parser.add_argument(
         'old_syms', metavar='old-syms', type=str,
         help='The file containing the old symbol list or a library')
     parser.add_argument(
         'new_syms', metavar='new-syms', type=str,
         help='The file containing the new symbol list or a library')
     args = parser.parse_args()
 
     old_syms_list = util.extract_or_load(args.old_syms)
     new_syms_list = util.extract_or_load(args.new_syms)
 
     added, removed, changed = diff.diff(old_syms_list, new_syms_list)
+    if args.removed_only:
+        added = {}
     report, is_break = diff.report_diff(added, removed, changed,
                                         names_only=args.names_only,
                                         demangle=args.demangle)
     if args.output is None:
         print(report)
     else:
         with open(args.output, 'w') as f:
             f.write(report + '\n')
     sys.exit(is_break)
 
 
 if __name__ == '__main__':
     main()