Remove visibility attributes from out-of-class method definitions in iostreams.

[eugenis]

Summary

No point in pretending that these methods are hidden - they are
actually exported from libc++.so. Extern template declarations make
them part of libc++ ABI.

This patch does not change libc++.so export list (at least on Linux).

[eugenis]

Applied the same change to <sstream>. No idea how I missed it.

[EricWF]

No changes are needed in `<string>`?

[eugenis]

<string> is an interesting case.
There are no cases of visibility attribute present on an out-of-class definition but missing on an in-class declaration, so nothing needs to be done for a switch to internal_linkage.

Setting hidden visibility on an "extern template" method is probably a bad practice. By itself, it would break everything: extern template promises that this method is available externally, and hidden visibility kinda invalidates this promise. But is libc++ it is always accompanied by another attribute which sidesteps the issue: always_inline (if inlining happends) and internal_linkage (in all cases) emit method body in the caller's translation unit.

So, nothing would break if we leave <string> unchanged. Removing the attributes would add 254 exports to libc++ and not really achieve anything. Well, it could help with the link failure on compilers that do not support internal_linkage AND not always inline always_inline - are there any like this?

[eugenis]

ping

[eugenis]

Hi,

Have you had a chance to look at this?

[EricWF]

Does the inline keyword have any effect when it's on function definitions that are externally instantiated?

[eugenis]

In D14409#306272, @EricWF wrote:

Does the inline keyword have any effect when it's on function definitions that are externally instantiated?

I could not detect any difference in behavior with or without inline keyword.
Remove it?

[EricWF]

LGTM. I built the library before this patch and then diffed the symbols after this change. No symbols have been removed or added. LGTM.

[eugenis]

In D14409#306379, @eugenis wrote:

In D14409#306272, @EricWF wrote:

Does the inline keyword have any effect when it's on function definitions that are externally instantiated?

I could not detect any difference in behavior with or without inline keyword.
Remove it?

Actually, remove the inline breaks tests, because now the method is declared hidden (in-class), so template instantiation in libc++.so produces a hidden symbol.

As an alternative, we could remove both "inline" and the in-class hidden attribute.

[eugenis]

In D14409#306531, @eugenis wrote:

In D14409#306379, @eugenis wrote:

In D14409#306272, @EricWF wrote:

Does the inline keyword have any effect when it's on function definitions that are externally instantiated?

I could not detect any difference in behavior with or without inline keyword.
Remove it?

Actually, remove the inline breaks tests, because now the method is declared hidden (in-class), so template instantiation in libc++.so produces a hidden symbol.

As an alternative, we could remove both "inline" and the in-class hidden attribute.

So, we can not remove "inline" because without it always_inline does not seem to have any effect.
We can remove always_inline from the declarations, but that would add a few more exported symbols to libc++.

I'll land this change as is, if you don't mind.

[EricWF]

In D14409#306531, @eugenis wrote:

In D14409#306379, @eugenis wrote:

In D14409#306272, @EricWF wrote:

Does the inline keyword have any effect when it's on function definitions that are externally instantiated?

I could not detect any difference in behavior with or without inline keyword.
Remove it?

Actually, remove the inline breaks tests, because now the method is declared hidden (in-class), so template instantiation in libc++.so produces a hidden symbol.

As an alternative, we could remove both "inline" and the in-class hidden attribute.

That change would be an ABI break. This change is perfect as-is.

[eugenis]

r255177
Thanks for the review!

include/istream

if (__is.good())
         }
         __ok_ = __is.good();
     }
     else
         __is.setstate(ios_base::failbit);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 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
+inline
 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
+inline
 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
+inline
 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>
#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
+inline
 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
+inline
 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
+inline
 basic_istream<_CharT, _Traits>&
 basic_istream<_CharT, _Traits>::operator>>(ios_base& (*__pf)(ios_base&))
 {
     __pf(*this);
     return *this;
 }
 
 template<class _CharT, class _Traits>
#ifndef _LIBCPP_NO_EXCEPTIONS
     {
         __is.__set_badbit_and_consider_rethrow();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     return __is;
 }
 
 template<class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_istream<char, _Traits>&
 operator>>(basic_istream<char, _Traits>& __is, unsigned char* __s)
 {
     return __is >> (char*)__s;
 }
 
 template<class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_istream<char, _Traits>&
 operator>>(basic_istream<char, _Traits>& __is, signed char* __s)
 {
     return __is >> (char*)__s;
 }
 
 template<class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>&
#ifndef _LIBCPP_NO_EXCEPTIONS
     {
         __is.__set_badbit_and_consider_rethrow();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     return __is;
 }
 
 template<class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_istream<char, _Traits>&
 operator>>(basic_istream<char, _Traits>& __is, unsigned char& __c)
 {
     return __is >> (char&)__c;
 }
 
 template<class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_istream<char, _Traits>&
 operator>>(basic_istream<char, _Traits>& __is, signed char& __c)
 {
     return __is >> (char&)__c;
 }
 
 template<class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>&
#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
+inline
 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;
 }
#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
+inline
 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>&
#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
+inline
 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>&
#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
+inline
 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>&
#ifndef _LIBCPP_NO_EXCEPTIONS
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     return __is;
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
 {
     __is >> __x;
     return __is;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     basic_iostream& operator=(basic_iostream&& __rhs);
 #endif
     void swap(basic_iostream& __rhs);
 public:
 };
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 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
+inline
 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
+inline
 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
+inline
 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>&
#ifndef _LIBCPP_NO_EXCEPTIONS
     {
         __is.__set_badbit_and_consider_rethrow();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     return __is;
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_istream<_CharT, _Traits>&
 getline(basic_istream<_CharT, _Traits>& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str)
 {
     return getline(__is, __str, __is.widen('\n'));
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_istream<_CharT, _Traits>&
 getline(basic_istream<_CharT, _Traits>&& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
 {
     return getline(__is, __str, __dlm);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_istream<_CharT, _Traits>&
 getline(basic_istream<_CharT, _Traits>&& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str)
 {
     return getline(__is, __str, __is.widen('\n'));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

include/ostream

#ifndef _LIBCPP_NO_EXCEPTIONS
         catch (...)
         {
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 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
+inline
 basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs)
 {
     this->move(__rhs);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 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
+inline
 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
+inline
 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
+inline
 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
+inline
 basic_ostream<_CharT, _Traits>&
 basic_ostream<_CharT, _Traits>::operator<<(ios_base& (*__pf)(ios_base&))
 {
     __pf(*this);
     return *this;
 }
 
 template <class _CharT, class _Traits>
#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
+inline
 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
+inline
 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
+inline
 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);
     }
     return *this;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ostream<_CharT, _Traits>&
 endl(basic_ostream<_CharT, _Traits>& __os)
 {
     __os.put(__os.widen('\n'));
     __os.flush();
     return __os;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ostream<_CharT, _Traits>&
 ends(basic_ostream<_CharT, _Traits>& __os)
 {
     __os.put(_CharT());
     return __os;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ostream<_CharT, _Traits>&
 flush(basic_ostream<_CharT, _Traits>& __os)
 {
     __os.flush();
     return __os;
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Stream, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     !is_lvalue_reference<_Stream>::value &&
     is_base_of<ios_base, _Stream>::value,
     _Stream&&
 >::type
 operator<<(_Stream&& __os, const _Tp& __x)
 {
     __os << __x;
     return _VSTD::move(__os);
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
            const basic_string<_CharT, _Traits, _Allocator>& __str)
 {
     return _VSTD::__put_character_sequence(__os, __str.data(), __str.size());
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec)
 {
     return __os << __ec.category().name() << ':' << __ec.value();
 }
 
 template<class _CharT, class _Traits, class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p)
 {
     return __os << __p.get();
 }
 
 template <class _CharT, class _Traits, size_t _Size>
 basic_ostream<_CharT, _Traits>&

include/sstream

protected:
     virtual int_type overflow (int_type __c = traits_type::eof());
     virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
                              ios_base::openmode __wch = ios_base::in | ios_base::out);
     virtual pos_type seekpos(pos_type __sp,
                              ios_base::openmode __wch = ios_base::in | ios_base::out);
 };
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(ios_base::openmode __wch)
     : __hm_(0),
       __mode_(__wch)
 {
     str(string_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(const string_type& __s,
                              ios_base::openmode __wch)
     : __hm_(0),
       __mode_(__wch)
 {
     str(__s);
 }
 
else
         __rhs.setp(nullptr, nullptr);
     __rhs.__hm_ = __lhm == -1 ? nullptr : __p + __lhm;
     locale __tl = __rhs.getloc();
     __rhs.pubimbue(this->getloc());
     this->pubimbue(__tl);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
      basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
 {
     __x.swap(__y);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
basic_stringbuf<_CharT, _Traits, _Allocator>::seekoff(off_type __off,
     {
         this->setp(this->pbase(), this->epptr());
         this->pbump(__noff);
     }
     return pos_type(__noff);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename basic_stringbuf<_CharT, _Traits, _Allocator>::pos_type
 basic_stringbuf<_CharT, _Traits, _Allocator>::seekpos(pos_type __sp,
                                                       ios_base::openmode __wch)
 {
     return seekoff(__sp, ios_base::beg, __wch);
 }
 
 // basic_istringstream
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     // 27.8.2.3 Members:
     basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
     string_type str() const;
     void str(const string_type& __s);
 };
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_istringstream<_CharT, _Traits, _Allocator>::basic_istringstream(ios_base::openmode __wch)
     : basic_istream<_CharT, _Traits>(&__sb_),
       __sb_(__wch | ios_base::in)
 {
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_istringstream<_CharT, _Traits, _Allocator>::basic_istringstream(const string_type& __s,
                                                                       ios_base::openmode __wch)
     : basic_istream<_CharT, _Traits>(&__sb_),
       __sb_(__s, __wch | ios_base::in)
 {
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_istringstream<_CharT, _Traits, _Allocator>::basic_istringstream(basic_istringstream&& __rhs)
     : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs)),
       __sb_(_VSTD::move(__rhs.__sb_))
 {
     basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_istringstream<_CharT, _Traits, _Allocator>&
 basic_istringstream<_CharT, _Traits, _Allocator>::operator=(basic_istringstream&& __rhs)
 {
     basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
     __sb_ = _VSTD::move(__rhs.__sb_);
     return *this;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 basic_istringstream<_CharT, _Traits, _Allocator>::swap(basic_istringstream& __rhs)
 {
     basic_istream<char_type, traits_type>::swap(__rhs);
     __sb_.swap(__rhs.__sb_);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
      basic_istringstream<_CharT, _Traits, _Allocator>& __y)
 {
     __x.swap(__y);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_stringbuf<_CharT, _Traits, _Allocator>*
 basic_istringstream<_CharT, _Traits, _Allocator>::rdbuf() const
 {
     return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_string<_CharT, _Traits, _Allocator>
 basic_istringstream<_CharT, _Traits, _Allocator>::str() const
 {
     return __sb_.str();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 basic_istringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
 {
     __sb_.str(__s);
 }
 
 // basic_ostringstream
 
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     // 27.8.2.3 Members:
     basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
     string_type str() const;
     void str(const string_type& __s);
 };
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ostringstream<_CharT, _Traits, _Allocator>::basic_ostringstream(ios_base::openmode __wch)
     : basic_ostream<_CharT, _Traits>(&__sb_),
       __sb_(__wch | ios_base::out)
 {
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ostringstream<_CharT, _Traits, _Allocator>::basic_ostringstream(const string_type& __s,
                                                                       ios_base::openmode __wch)
     : basic_ostream<_CharT, _Traits>(&__sb_),
       __sb_(__s, __wch | ios_base::out)
 {
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_ostringstream<_CharT, _Traits, _Allocator>::basic_ostringstream(basic_ostringstream&& __rhs)
     : basic_ostream<_CharT, _Traits>(_VSTD::move(__rhs)),
       __sb_(_VSTD::move(__rhs.__sb_))
 {
     basic_ostream<_CharT, _Traits>::set_rdbuf(&__sb_);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_ostringstream<_CharT, _Traits, _Allocator>&
 basic_ostringstream<_CharT, _Traits, _Allocator>::operator=(basic_ostringstream&& __rhs)
 {
     basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
     __sb_ = _VSTD::move(__rhs.__sb_);
     return *this;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 basic_ostringstream<_CharT, _Traits, _Allocator>::swap(basic_ostringstream& __rhs)
 {
     basic_ostream<char_type, traits_type>::swap(__rhs);
     __sb_.swap(__rhs.__sb_);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
      basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
 {
     __x.swap(__y);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_stringbuf<_CharT, _Traits, _Allocator>*
 basic_ostringstream<_CharT, _Traits, _Allocator>::rdbuf() const
 {
     return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_string<_CharT, _Traits, _Allocator>
 basic_ostringstream<_CharT, _Traits, _Allocator>::str() const
 {
     return __sb_.str();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 basic_ostringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
 {
     __sb_.str(__s);
 }
 
 // basic_stringstream
 
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     // 27.8.2.3 Members:
     basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
     string_type str() const;
     void str(const string_type& __s);
 };
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(ios_base::openmode __wch)
     : basic_iostream<_CharT, _Traits>(&__sb_),
       __sb_(__wch)
 {
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(const string_type& __s,
                                                                     ios_base::openmode __wch)
     : basic_iostream<_CharT, _Traits>(&__sb_),
       __sb_(__s, __wch)
 {
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(basic_stringstream&& __rhs)
     : basic_iostream<_CharT, _Traits>(_VSTD::move(__rhs)),
       __sb_(_VSTD::move(__rhs.__sb_))
 {
     basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_stringstream<_CharT, _Traits, _Allocator>&
 basic_stringstream<_CharT, _Traits, _Allocator>::operator=(basic_stringstream&& __rhs)
 {
     basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
     __sb_ = _VSTD::move(__rhs.__sb_);
     return *this;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 basic_stringstream<_CharT, _Traits, _Allocator>::swap(basic_stringstream& __rhs)
 {
     basic_iostream<char_type, traits_type>::swap(__rhs);
     __sb_.swap(__rhs.__sb_);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
      basic_stringstream<_CharT, _Traits, _Allocator>& __y)
 {
     __x.swap(__y);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_stringbuf<_CharT, _Traits, _Allocator>*
 basic_stringstream<_CharT, _Traits, _Allocator>::rdbuf() const
 {
     return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_string<_CharT, _Traits, _Allocator>
 basic_stringstream<_CharT, _Traits, _Allocator>::str() const
 {
     return __sb_.str();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 basic_stringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
 {
     __sb_.str(__s);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_SSTREAM

include/streambuf

 };
 
 template <class _CharT, class _Traits>
 basic_streambuf<_CharT, _Traits>::~basic_streambuf()
 {
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 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
+inline
 locale
 basic_streambuf<_CharT, _Traits>::getloc() const
 {
     return __loc_;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 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
+inline
 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
+inline
 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
+inline
 int
 basic_streambuf<_CharT, _Traits>::pubsync()
 {
     return sync();
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 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
+inline
 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
+inline
 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
+inline
 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
+inline
 streamsize
 basic_streambuf<_CharT, _Traits>::sgetn(char_type* __s, streamsize __n)
 {
     return xsgetn(__s, __n);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 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
+inline
 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
+inline
 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
+inline
 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()
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
+inline
 void
 basic_streambuf<_CharT, _Traits>::gbump(int __n)
 {
     __ninp_ += __n;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 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
+inline
 void
 basic_streambuf<_CharT, _Traits>::pbump(int __n)
 {
     __nout_ += __n;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 basic_streambuf<_CharT, _Traits>::setp(char_type* __pbeg, char_type* __pend)
 {
     __bout_ = __nout_ = __pbeg;
     __eout_ = __pend;
 }
 
 template <class _CharT, class _Traits>