Cleanup: move all visibility attributes to the first declaration.

[eugenis]

Summary

This change moves visibility attributes from out-of-class method definitions to in-class declaration.
This is needed for a switch to attribute((internal_linkage)) (see http://reviews.llvm.org/D13925) which can only appear on the first declaration.

This change does not touch istream/ostream/streambuf, which are handled separately in http://reviews.llvm.org/D14409.

[EricWF]

Thank you so much! I was procrastination taking this on.

[EricWF]

Is this a mechanical change, or do you remove/add some attributes in this patch?

[eugenis]

This is a mechanical change, and AFAIR I checked that no bits of libc++.so are affected.

The same mechanical change in streambuf/istream/ostream (the stuff that's parts of extern templates) breaks libc++ because of https://llvm.org/bugs/show_bug.cgi?id=25427, that's why it's not included here.

I'll verify that this is not a functional change one more time.

[EricWF]

It's not just libc++.so that could have it's ABI affected by adding/removing these. It's any shared library build against libc++. However if we are just moving the attribute to the proper place that should truly NFC modolo https://llvm.org/bugs/show_bug.cgi?id=25427.

LGTM and feel free to commit any similar cleanup without review. I'll have to think a little harder about the extern template issues before working through those.

[eugenis]

Yes. I'm just using libc++.so as a (incomplete) test that this is actually NFC. It did catch the extern template issue.

[eugenis]

Confirmed and landed as r252385.
Thanks for the quick response!

include/__hash_table

const __node_allocator& __node_alloc() const _NOEXCEPT
         {return __p1_.second();}
 
 public:
     typedef __hash_iterator<__node_pointer>                   iterator;
     typedef __hash_const_iterator<__node_pointer>             const_iterator;
     typedef __hash_local_iterator<__node_pointer>             local_iterator;
     typedef __hash_const_local_iterator<__node_pointer>       const_local_iterator;
 
+    _LIBCPP_INLINE_VISIBILITY
     __hash_table()
         _NOEXCEPT_(
             is_nothrow_default_constructible<__bucket_list>::value &&
             is_nothrow_default_constructible<__first_node>::value &&
             is_nothrow_default_constructible<__node_allocator>::value &&
             is_nothrow_default_constructible<hasher>::value &&
             is_nothrow_default_constructible<key_equal>::value);
+    _LIBCPP_INLINE_VISIBILITY
     __hash_table(const hasher& __hf, const key_equal& __eql);
     __hash_table(const hasher& __hf, const key_equal& __eql,
                  const allocator_type& __a);
     explicit __hash_table(const allocator_type& __a);
     __hash_table(const __hash_table& __u);
     __hash_table(const __hash_table& __u, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     __hash_table(__hash_table&& __u)
         _NOEXCEPT_(
             is_nothrow_move_constructible<__bucket_list>::value &&
             is_nothrow_move_constructible<__first_node>::value &&
             is_nothrow_move_constructible<__node_allocator>::value &&
             is_nothrow_move_constructible<hasher>::value &&
             is_nothrow_move_constructible<key_equal>::value);
     __hash_table(__hash_table&& __u, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~__hash_table();
 
     __hash_table& operator=(const __hash_table& __u);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     __hash_table& operator=(__hash_table&& __u)
         _NOEXCEPT_(
             __node_traits::propagate_on_container_move_assignment::value &&
             is_nothrow_move_assignable<__node_allocator>::value &&
             is_nothrow_move_assignable<hasher>::value &&
             is_nothrow_move_assignable<key_equal>::value);
 #endif
     template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY void reserve(size_type __n)
         {rehash(static_cast<size_type>(ceil(__n / max_load_factor())));}
 
     _LIBCPP_INLINE_VISIBILITY
     size_type bucket_count() const _NOEXCEPT
     {
         return __bucket_list_.get_deleter().size();
     }
 
+    _LIBCPP_INLINE_VISIBILITY
     iterator       begin() _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     iterator       end() _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     const_iterator begin() const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     const_iterator end() const _NOEXCEPT;
 
     template <class _Key>
         _LIBCPP_INLINE_VISIBILITY
         size_type bucket(const _Key& __k) const
         {
             _LIBCPP_ASSERT(bucket_count() > 0,
                 "unordered container::bucket(key) called when bucket_count() == 0");
#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     iterator erase(const_iterator __first, const_iterator __last);
     template <class _Key>
         size_type __erase_unique(const _Key& __k);
     template <class _Key>
         size_type __erase_multi(const _Key& __k);
     __node_holder remove(const_iterator __p) _NOEXCEPT;
 
     template <class _Key>
+        _LIBCPP_INLINE_VISIBILITY
         size_type __count_unique(const _Key& __k) const;
     template <class _Key>
         size_type __count_multi(const _Key& __k) const;
 
     template <class _Key>
         pair<iterator, iterator>
         __equal_range_unique(const _Key& __k);
     template <class _Key>
#endif
     void __deallocate(__node_pointer __np) _NOEXCEPT;
     __node_pointer __detach() _NOEXCEPT;
 
     template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_map;
     template <class, class, class, class, class> friend class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
 };
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table()
     _NOEXCEPT_(
         is_nothrow_default_constructible<__bucket_list>::value &&
         is_nothrow_default_constructible<__first_node>::value &&
         is_nothrow_default_constructible<hasher>::value &&
         is_nothrow_default_constructible<key_equal>::value)
     : __p2_(0),
       __p3_(1.0f)
 {
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf,
                                                        const key_equal& __eql)
     : __bucket_list_(nullptr, __bucket_list_deleter()),
       __p1_(),
       __p2_(0, __hf),
       __p3_(1.0f, __eql)
 {
 }
#endif  // _LIBCPP_NO_EXCEPTIONS
                     __construct_node(_VSTD::move(__u.remove(__i++)->__value_));
             __node_insert_multi(__h.get());
             __h.release();
         }
     }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __hash_table<_Tp, _Hash, _Equal, _Alloc>&
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(__hash_table&& __u)
     _NOEXCEPT_(
         __node_traits::propagate_on_container_move_assignment::value &&
         is_nothrow_move_assignable<__node_allocator>::value &&
         is_nothrow_move_assignable<hasher>::value &&
         is_nothrow_move_assignable<key_equal>::value)
 {

 #endif  // _LIBCPP_NO_EXCEPTIONS
         __deallocate(__cache);
     }
     for (; __first != __last; ++__first)
         __insert_multi(*__first);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() _NOEXCEPT
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     return iterator(__p1_.first().__next_, this);
 #else
     return iterator(__p1_.first().__next_);
 #endif
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::end() _NOEXCEPT
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     return iterator(nullptr, this);
 #else
     return iterator(nullptr);
 #endif
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() const _NOEXCEPT
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     return const_iterator(__p1_.first().__next_, this);
 #else
     return const_iterator(__p1_.first().__next_);
 #endif
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::end() const _NOEXCEPT
 {
 #if _LIBCPP_DEBUG_LEVEL >= 2
     return const_iterator(nullptr, this);
 #else
     return const_iterator(nullptr);
 #endif
#if _LIBCPP_DEBUG_LEVEL >= 2
     }
     __get_db()->unlock();
 #endif
     return __node_holder(__cn, _Dp(__node_alloc(), true));
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Key>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__count_unique(const _Key& __k) const
 {
     return static_cast<size_type>(find(__k) != end());
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Key>

include/__mutex_base

public:
 
     template <class _Rep, class _Period>
         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,
                  const chrono::duration<_Rep, _Period>& __d,
                  _Predicate __pred);
 
     typedef pthread_cond_t* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__cv_;}
 
 private:
if (_Max - __d > __s_now)
         __do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__d));
     else
         __do_timed_wait(__lk, __sys_tpi::max());
     return steady_clock::now() - __c_now < __d ? cv_status::no_timeout :
                                                  cv_status::timeout;
 }
 
 template <class _Rep, class _Period, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 condition_variable::wait_for(unique_lock<mutex>& __lk,
                              const chrono::duration<_Rep, _Period>& __d,
                              _Predicate __pred)
 {
     return wait_until(__lk, chrono::steady_clock::now() + __d,
                       _VSTD::move(__pred));
 }
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP___MUTEX_BASE

include/__split_buffer

public:
     typedef typename add_lvalue_reference<allocator_type>::type __alloc_ref;
     typedef typename add_lvalue_reference<allocator_type>::type __alloc_const_ref;
 
     _LIBCPP_INLINE_VISIBILITY __alloc_rr&           __alloc() _NOEXCEPT         {return __end_cap_.second();}
     _LIBCPP_INLINE_VISIBILITY const __alloc_rr&     __alloc() const _NOEXCEPT   {return __end_cap_.second();}
     _LIBCPP_INLINE_VISIBILITY pointer&              __end_cap() _NOEXCEPT       {return __end_cap_.first();}
     _LIBCPP_INLINE_VISIBILITY const pointer&        __end_cap() const _NOEXCEPT {return __end_cap_.first();}
 
+    _LIBCPP_INLINE_VISIBILITY
     __split_buffer()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
+    _LIBCPP_INLINE_VISIBILITY
     explicit __split_buffer(__alloc_rr& __a);
+    _LIBCPP_INLINE_VISIBILITY
     explicit __split_buffer(const __alloc_rr& __a);
     __split_buffer(size_type __cap, size_type __start, __alloc_rr& __a);
     ~__split_buffer();
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     __split_buffer(__split_buffer&& __c)
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
     __split_buffer(__split_buffer&& __c, const __alloc_rr& __a);
template <class _ForwardIterator>
         <
             __is_forward_iterator<_ForwardIterator>::value,
             void
         >::type
         __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
 
     _LIBCPP_INLINE_VISIBILITY void __destruct_at_begin(pointer __new_begin)
         {__destruct_at_begin(__new_begin, is_trivially_destructible<value_type>());}
+        _LIBCPP_INLINE_VISIBILITY
         void __destruct_at_begin(pointer __new_begin, false_type);
+        _LIBCPP_INLINE_VISIBILITY
         void __destruct_at_begin(pointer __new_begin, true_type);
 
     _LIBCPP_INLINE_VISIBILITY
     void __destruct_at_end(pointer __new_last) _NOEXCEPT
         {__destruct_at_end(__new_last, false_type());}
     _LIBCPP_INLINE_VISIBILITY
         void __destruct_at_end(pointer __new_last, false_type) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
__split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
     for (; __first != __last; ++__first)
     {
         __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first);
         ++this->__end_;
     }
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_type)
 {
     while (__begin_ != __new_begin)
         __alloc_traits::destroy(__alloc(), __to_raw_pointer(__begin_++));
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, true_type)
 {
     __begin_ = __new_begin;
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
__split_buffer<_Tp, _Allocator>::__split_buffer(size_type __cap, size_type __start, __alloc_rr& __a)
     : __end_cap_(nullptr, __a)
 {
     __first_ = __cap != 0 ? __alloc_traits::allocate(__alloc(), __cap) : nullptr;
     __begin_ = __end_ = __first_ + __start;
     __end_cap() = __first_ + __cap;
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __split_buffer<_Tp, _Allocator>::__split_buffer()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr)
 {
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __split_buffer<_Tp, _Allocator>::__split_buffer(__alloc_rr& __a)
     : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a)
 {
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __split_buffer<_Tp, _Allocator>::__split_buffer(const __alloc_rr& __a)
     : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a)
 {
 }
 
 template <class _Tp, class _Allocator>
 __split_buffer<_Tp, _Allocator>::~__split_buffer()
 {

include/bitset

protected:
 
     __storage_type __first_[_N_words];
 
     typedef __bit_reference<__bitset>                  reference;
     typedef __bit_const_reference<__bitset>            const_reference;
     typedef __bit_iterator<__bitset, false>            iterator;
     typedef __bit_iterator<__bitset, true>             const_iterator;
 
+    _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long __v) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos) _NOEXCEPT
         {return reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __make_ref(size_t __pos) const _NOEXCEPT
         {return const_reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
     _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
         {return iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
     _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const _NOEXCEPT
         {return const_iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
 
+    _LIBCPP_INLINE_VISIBILITY
     void operator&=(const __bitset& __v) _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     void operator|=(const __bitset& __v) _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     void operator^=(const __bitset& __v) _NOEXCEPT;
 
     void flip() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY unsigned long to_ulong() const
         {return to_ulong(integral_constant<bool, _Size < sizeof(unsigned long) * CHAR_BIT>());}
     _LIBCPP_INLINE_VISIBILITY unsigned long long to_ullong() const
         {return to_ullong(integral_constant<bool, _Size < sizeof(unsigned long long) * CHAR_BIT>());}
 
     bool all() const _NOEXCEPT;
     bool any() const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     size_t __hash_code() const _NOEXCEPT;
 private:
 #ifdef _LIBCPP_HAS_NO_CONSTEXPR
     void __init(unsigned long long __v, false_type) _NOEXCEPT;
     void __init(unsigned long long __v, true_type) _NOEXCEPT;
 #endif  // _LIBCPP_HAS_NO_CONSTEXPR
     unsigned long to_ulong(false_type) const;
+    _LIBCPP_INLINE_VISIBILITY
     unsigned long to_ulong(true_type) const;
     unsigned long long to_ullong(false_type) const;
+    _LIBCPP_INLINE_VISIBILITY
     unsigned long long to_ullong(true_type) const;
+    _LIBCPP_INLINE_VISIBILITY
     unsigned long long to_ullong(true_type, false_type) const;
     unsigned long long to_ullong(true_type, true_type) const;
 };
 
 template <size_t _N_words, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 __bitset<_N_words, _Size>::__bitset() _NOEXCEPT
 #ifndef _LIBCPP_HAS_NO_CONSTEXPR
     : __first_{0}
 #endif
 {
 #ifdef _LIBCPP_HAS_NO_CONSTEXPR
     _VSTD::fill_n(__first_, _N_words, __storage_type(0));

 {
     __first_[0] = __v;
     _VSTD::fill(__first_ + 1, __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0));
 }
 
 #endif  // _LIBCPP_HAS_NO_CONSTEXPR
 
 template <size_t _N_words, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 __bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
 #ifndef _LIBCPP_HAS_NO_CONSTEXPR
 #if __SIZEOF_SIZE_T__ == 8
     : __first_{__v}
 #elif __SIZEOF_SIZE_T__ == 4
     : __first_{__v, __v >> __bits_per_word}
 #else
 #error This constructor has not been ported to this platform
 #endif
 #endif
 {
 #ifdef _LIBCPP_HAS_NO_CONSTEXPR
     __init(__v, integral_constant<bool, sizeof(unsigned long long) == sizeof(__storage_type)>());
 #endif
 }
 
 template <size_t _N_words, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 __bitset<_N_words, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
 {
     for (size_type __i = 0; __i < _N_words; ++__i)
         __first_[__i] &= __v.__first_[__i];
 }
 
 template <size_t _N_words, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 __bitset<_N_words, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
 {
     for (size_type __i = 0; __i < _N_words; ++__i)
         __first_[__i] |= __v.__first_[__i];
 }
 
 template <size_t _N_words, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 __bitset<_N_words, _Size>::operator^=(const __bitset& __v) _NOEXCEPT
 {
     for (size_type __i = 0; __i < _N_words; ++__i)
         __first_[__i] ^= __v.__first_[__i];
 }
 
 template <size_t _N_words, size_t _Size>
#ifndef _LIBCPP_NO_EXCEPTIONS
         throw overflow_error("bitset to_ulong overflow error");
 #else
         assert(!"bitset to_ulong overflow error");
 #endif
     return __first_[0];
 }
 
 template <size_t _N_words, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unsigned long
 __bitset<_N_words, _Size>::to_ulong(true_type) const
 {
     return __first_[0];
 }
 
 template <size_t _N_words, size_t _Size>
 unsigned long long
 __bitset<_N_words, _Size>::to_ullong(false_type) const
 {
     const_iterator __e = __make_iter(_Size);
     const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true);
     if (__i != __e)
 #ifndef _LIBCPP_NO_EXCEPTIONS
         throw overflow_error("bitset to_ullong overflow error");
 #else
         assert(!"bitset to_ullong overflow error");
 #endif
     return to_ullong(true_type());
 }
 
 template <size_t _N_words, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unsigned long long
 __bitset<_N_words, _Size>::to_ullong(true_type) const
 {
     return to_ullong(true_type(), integral_constant<bool, sizeof(__storage_type) < sizeof(unsigned long long)>());
 }
 
 template <size_t _N_words, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unsigned long long
 __bitset<_N_words, _Size>::to_ullong(true_type, false_type) const
 {
     return __first_[0];
 }
 
 template <size_t _N_words, size_t _Size>
 unsigned long long
if (__n > 0)
         __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
         if (*__p & __m)
             return true;
     }
     return false;
 }
 
 template <size_t _N_words, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 size_t
 __bitset<_N_words, _Size>::__hash_code() const _NOEXCEPT
 {
     size_t __h = 0;
     for (size_type __i = 0; __i < _N_words; ++__i)
         __h ^= __first_[__i];
     return __h;
 }
protected:
 
     __storage_type __first_;
 
     typedef __bit_reference<__bitset>                  reference;
     typedef __bit_const_reference<__bitset>            const_reference;
     typedef __bit_iterator<__bitset, false>            iterator;
     typedef __bit_iterator<__bitset, true>             const_iterator;
 
+    _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long __v) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos) _NOEXCEPT
         {return reference(&__first_, __storage_type(1) << __pos);}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __make_ref(size_t __pos) const _NOEXCEPT
         {return const_reference(&__first_, __storage_type(1) << __pos);}
     _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
         {return iterator(&__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
     _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const _NOEXCEPT
         {return const_iterator(&__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
 
+    _LIBCPP_INLINE_VISIBILITY
     void operator&=(const __bitset& __v) _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     void operator|=(const __bitset& __v) _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     void operator^=(const __bitset& __v) _NOEXCEPT;
 
+    _LIBCPP_INLINE_VISIBILITY
     void flip() _NOEXCEPT;
 
+    _LIBCPP_INLINE_VISIBILITY
     unsigned long to_ulong() const;
+    _LIBCPP_INLINE_VISIBILITY
     unsigned long long to_ullong() const;
 
+    _LIBCPP_INLINE_VISIBILITY
     bool all() const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     bool any() const _NOEXCEPT;
 
+    _LIBCPP_INLINE_VISIBILITY
     size_t __hash_code() const _NOEXCEPT;
 };
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 __bitset<1, _Size>::__bitset() _NOEXCEPT
     : __first_(0)
 {
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 __bitset<1, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
     : __first_(static_cast<__storage_type>(__v))
 {
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 __bitset<1, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
 {
     __first_ &= __v.__first_;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 __bitset<1, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
 {
     __first_ |= __v.__first_;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 __bitset<1, _Size>::operator^=(const __bitset& __v) _NOEXCEPT
 {
     __first_ ^= __v.__first_;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 __bitset<1, _Size>::flip() _NOEXCEPT
 {
     __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
     __first_ = ~__first_;
     __first_ &= __m;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unsigned long
 __bitset<1, _Size>::to_ulong() const
 {
     return __first_;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unsigned long long
 __bitset<1, _Size>::to_ullong() const
 {
     return __first_;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 __bitset<1, _Size>::all() const _NOEXCEPT
 {
     __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
     return !(~__first_ & __m);
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 __bitset<1, _Size>::any() const _NOEXCEPT
 {
     __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
     return __first_ & __m;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 size_t
 __bitset<1, _Size>::__hash_code() const _NOEXCEPT
 {
     return __first_;
 }
 
 template <>
 class __bitset<0, 0>
protected:
     friend class __bit_iterator<__bitset, true>;
     friend struct __bit_array<__bitset>;
 
     typedef __bit_reference<__bitset>                  reference;
     typedef __bit_const_reference<__bitset>            const_reference;
     typedef __bit_iterator<__bitset, false>            iterator;
     typedef __bit_iterator<__bitset, true>             const_iterator;
 
+    _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t) _NOEXCEPT
         {return reference(0, 1);}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __make_ref(size_t) const _NOEXCEPT
         {return const_reference(0, 1);}
     _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t) _NOEXCEPT
         {return iterator(0, 0);}
protected:
     _LIBCPP_INLINE_VISIBILITY unsigned long long to_ullong() const {return 0;}
 
     _LIBCPP_INLINE_VISIBILITY bool all() const _NOEXCEPT {return true;}
     _LIBCPP_INLINE_VISIBILITY bool any() const _NOEXCEPT {return false;}
 
     _LIBCPP_INLINE_VISIBILITY size_t __hash_code() const _NOEXCEPT {return 0;}
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 __bitset<0, 0>::__bitset() _NOEXCEPT
 {
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 __bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT
 {
 }
 
 template <size_t _Size> class _LIBCPP_TYPE_VIS_ONLY bitset;
 template <size_t _Size> struct _LIBCPP_TYPE_VIS_ONLY hash<bitset<_Size> >;
 
public:
     template<class _CharT, class _Traits, class _Allocator>
         explicit bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
                         typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos = 0,
                         typename basic_string<_CharT,_Traits,_Allocator>::size_type __n =
                                 (basic_string<_CharT,_Traits,_Allocator>::npos),
                         _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));
 
     // 23.3.5.2 bitset operations:
+    _LIBCPP_INLINE_VISIBILITY
     bitset& operator&=(const bitset& __rhs) _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     bitset& operator|=(const bitset& __rhs) _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     bitset& operator^=(const bitset& __rhs) _NOEXCEPT;
     bitset& operator<<=(size_t __pos) _NOEXCEPT;
     bitset& operator>>=(size_t __pos) _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     bitset& set() _NOEXCEPT;
     bitset& set(size_t __pos, bool __val = true);
+    _LIBCPP_INLINE_VISIBILITY
     bitset& reset() _NOEXCEPT;
     bitset& reset(size_t __pos);
+    _LIBCPP_INLINE_VISIBILITY
     bitset  operator~() const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     bitset& flip() _NOEXCEPT;
     bitset& flip(size_t __pos);
 
     // element access:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
                               const_reference operator[](size_t __p) const {return base::__make_ref(__p);}
     _LIBCPP_INLINE_VISIBILITY       reference operator[](size_t __p)       {return base::__make_ref(__p);}
+    _LIBCPP_INLINE_VISIBILITY
     unsigned long to_ulong() const;
+    _LIBCPP_INLINE_VISIBILITY
     unsigned long long to_ullong() const;
     template <class _CharT, class _Traits, class _Allocator>
         basic_string<_CharT, _Traits, _Allocator> to_string(_CharT __zero = _CharT('0'),
                                                             _CharT __one = _CharT('1')) const;
     template <class _CharT, class _Traits>
+        _LIBCPP_INLINE_VISIBILITY
         basic_string<_CharT, _Traits, allocator<_CharT> > to_string(_CharT __zero = _CharT('0'),
                                                                     _CharT __one = _CharT('1')) const;
     template <class _CharT>
+        _LIBCPP_INLINE_VISIBILITY
         basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> > to_string(_CharT __zero = _CharT('0'),
                                                                                 _CharT __one = _CharT('1')) const;
+    _LIBCPP_INLINE_VISIBILITY
     basic_string<char, char_traits<char>, allocator<char> > to_string(char __zero = '0',
                                                                       char __one = '1') const;
+    _LIBCPP_INLINE_VISIBILITY
     size_t count() const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR size_t size() const _NOEXCEPT {return _Size;}
+    _LIBCPP_INLINE_VISIBILITY
     bool operator==(const bitset& __rhs) const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const bitset& __rhs) const _NOEXCEPT;
     bool test(size_t __pos) const;
+    _LIBCPP_INLINE_VISIBILITY
     bool all() const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     bool any() const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY bool none() const _NOEXCEPT {return !any();}
+    _LIBCPP_INLINE_VISIBILITY
     bitset operator<<(size_t __pos) const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     bitset operator>>(size_t __pos) const _NOEXCEPT;
 
 private:
 
     _LIBCPP_INLINE_VISIBILITY
     size_t __hash_code() const _NOEXCEPT {return base::__hash_code();}
 
     friend struct hash<bitset>;
for (; __i < _Mp; ++__i)
             (*this)[__i] = false;
         else
             (*this)[__i] = true;
     }
     _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bitset<_Size>&
 bitset<_Size>::operator&=(const bitset& __rhs) _NOEXCEPT
 {
     base::operator&=(__rhs);
     return *this;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bitset<_Size>&
 bitset<_Size>::operator|=(const bitset& __rhs) _NOEXCEPT
 {
     base::operator|=(__rhs);
     return *this;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bitset<_Size>&
 bitset<_Size>::operator^=(const bitset& __rhs) _NOEXCEPT
 {
     base::operator^=(__rhs);
     return *this;
 }
 
 template <size_t _Size>

 {
     __pos = _VSTD::min(__pos, _Size);
     _VSTD::copy(base::__make_iter(__pos), base::__make_iter(_Size), base::__make_iter(0));
     _VSTD::fill_n(base::__make_iter(_Size - __pos), __pos, false);
     return *this;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bitset<_Size>&
 bitset<_Size>::set() _NOEXCEPT
 {
     _VSTD::fill_n(base::__make_iter(0), _Size, true);
     return *this;
 }
 
 template <size_t _Size>
 bitset<_Size>&
 bitset<_Size>::set(size_t __pos, bool __val)
 {
     if (__pos >= _Size)
 #ifndef _LIBCPP_NO_EXCEPTIONS
         throw out_of_range("bitset set argument out of range");
 #else
         assert(!"bitset set argument out of range");
 #endif
     (*this)[__pos] = __val;
     return *this;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bitset<_Size>&
 bitset<_Size>::reset() _NOEXCEPT
 {
     _VSTD::fill_n(base::__make_iter(0), _Size, false);
     return *this;
 }
 
 template <size_t _Size>
 bitset<_Size>&
 bitset<_Size>::reset(size_t __pos)
 {
     if (__pos >= _Size)
 #ifndef _LIBCPP_NO_EXCEPTIONS
         throw out_of_range("bitset reset argument out of range");
 #else
         assert(!"bitset reset argument out of range");
 #endif
     (*this)[__pos] = false;
     return *this;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bitset<_Size>
 bitset<_Size>::operator~() const _NOEXCEPT
 {
     bitset __x(*this);
     __x.flip();
     return __x;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bitset<_Size>&
 bitset<_Size>::flip() _NOEXCEPT
 {
     base::flip();
     return *this;
 }
 
 template <size_t _Size>
 bitset<_Size>&
 bitset<_Size>::flip(size_t __pos)
 {
     if (__pos >= _Size)
 #ifndef _LIBCPP_NO_EXCEPTIONS
         throw out_of_range("bitset flip argument out of range");
 #else
         assert(!"bitset flip argument out of range");
 #endif
     reference r = base::__make_ref(__pos);
     r = ~r;
     return *this;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unsigned long
 bitset<_Size>::to_ulong() const
 {
     return base::to_ulong();
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 unsigned long long
 bitset<_Size>::to_ullong() const
 {
     return base::to_ullong();
 }
 
 template <size_t _Size>
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
 bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
 {
     basic_string<_CharT, _Traits, _Allocator> __r(_Size, __zero);
     for (size_t __i = 0; __i < _Size; ++__i)
     {
         if ((*this)[__i])
             __r[_Size - 1 - __i] = __one;
     }
     return __r;
 }
 
 template <size_t _Size>
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_string<_CharT, _Traits, allocator<_CharT> >
 bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
 {
     return to_string<_CharT, _Traits, allocator<_CharT> >(__zero, __one);
 }
 
 template <size_t _Size>
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
 bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
 {
     return to_string<_CharT, char_traits<_CharT>, allocator<_CharT> >(__zero, __one);
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 basic_string<char, char_traits<char>, allocator<char> >
 bitset<_Size>::to_string(char __zero, char __one) const
 {
     return to_string<char, char_traits<char>, allocator<char> >(__zero, __one);
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 size_t
 bitset<_Size>::count() const _NOEXCEPT
 {
     return static_cast<size_t>(_VSTD::count(base::__make_iter(0), base::__make_iter(_Size), true));
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 bitset<_Size>::operator==(const bitset& __rhs) const _NOEXCEPT
 {
     return _VSTD::equal(base::__make_iter(0), base::__make_iter(_Size), __rhs.__make_iter(0));
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 bitset<_Size>::operator!=(const bitset& __rhs) const _NOEXCEPT
 {
     return !(*this == __rhs);
 }
 
 template <size_t _Size>
 bool
 bitset<_Size>::test(size_t __pos) const
 {
     if (__pos >= _Size)
 #ifndef _LIBCPP_NO_EXCEPTIONS
         throw out_of_range("bitset test argument out of range");
 #else
         assert(!"bitset test argument out of range");
 #endif
     return (*this)[__pos];
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 bitset<_Size>::all() const _NOEXCEPT
 {
     return base::all();
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 bitset<_Size>::any() const _NOEXCEPT
 {
     return base::any();
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bitset<_Size>
 bitset<_Size>::operator<<(size_t __pos) const _NOEXCEPT
 {
     bitset __r = *this;
     __r <<= __pos;
     return __r;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bitset<_Size>
 bitset<_Size>::operator>>(size_t __pos) const _NOEXCEPT
 {
     bitset __r = *this;
     __r >>= __pos;
     return __r;
 }
 

include/condition_variable

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TYPE_VIS condition_variable_any
 {
     condition_variable __cv_;
     shared_ptr<mutex>  __mut_;
 public:
+    _LIBCPP_INLINE_VISIBILITY
     condition_variable_any();
 
+    _LIBCPP_INLINE_VISIBILITY
     void notify_one() _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     void notify_all() _NOEXCEPT;
 
     template <class _Lock>
         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>
         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,
                    const chrono::time_point<_Clock, _Duration>& __t,
                    _Predicate __pred);
 
     template <class _Lock, class _Rep, class _Period>
         cv_status
+        _LIBCPP_INLINE_VISIBILITY
         wait_for(_Lock& __lock,
                  const chrono::duration<_Rep, _Period>& __d);
 
     template <class _Lock, class _Rep, class _Period, class _Predicate>
         bool
+        _LIBCPP_INLINE_VISIBILITY
         wait_for(_Lock& __lock,
                  const chrono::duration<_Rep, _Period>& __d,
                  _Predicate __pred);
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 condition_variable_any::condition_variable_any()
     : __mut_(make_shared<mutex>()) {}
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 condition_variable_any::notify_one() _NOEXCEPT
 {
     {lock_guard<mutex> __lx(*__mut_);}
     __cv_.notify_one();
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 condition_variable_any::notify_all() _NOEXCEPT
 {
     {lock_guard<mutex> __lx(*__mut_);}
     __cv_.notify_all();
 }
 
 struct __lock_external
condition_variable_any::wait(_Lock& __lock)
     unique_lock<mutex> __lk(*__mut);
     __lock.unlock();
     unique_ptr<_Lock, __lock_external> __lxx(&__lock);
     lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock);
     __cv_.wait(__lk);
 }  // __mut_.unlock(), __lock.lock()
 
 template <class _Lock, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 condition_variable_any::wait(_Lock& __lock, _Predicate __pred)
 {
     while (!__pred())
         wait(__lock);
 }
 
 template <class _Lock, class _Clock, class _Duration>
 cv_status
 condition_variable_any::wait_until(_Lock& __lock,
                                    const chrono::time_point<_Clock, _Duration>& __t)
 {
     shared_ptr<mutex> __mut = __mut_;
     unique_lock<mutex> __lk(*__mut);
     __lock.unlock();
     unique_ptr<_Lock, __lock_external> __lxx(&__lock);
     lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock);
     return __cv_.wait_until(__lk, __t);
 }  // __mut_.unlock(), __lock.lock()
 
 template <class _Lock, class _Clock, class _Duration, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 condition_variable_any::wait_until(_Lock& __lock,
                                    const chrono::time_point<_Clock, _Duration>& __t,
                                    _Predicate __pred)
 {
     while (!__pred())
         if (wait_until(__lock, __t) == cv_status::timeout)
             return __pred();
     return true;
 }
 
 template <class _Lock, class _Rep, class _Period>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 cv_status
 condition_variable_any::wait_for(_Lock& __lock,
                                  const chrono::duration<_Rep, _Period>& __d)
 {
     return wait_until(__lock, chrono::steady_clock::now() + __d);
 }
 
 template <class _Lock, class _Rep, class _Period, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bool
 condition_variable_any::wait_for(_Lock& __lock,
                                  const chrono::duration<_Rep, _Period>& __d,
                                  _Predicate __pred)
 {
     return wait_until(__lock, chrono::steady_clock::now() + __d,
                       _VSTD::move(__pred));
 }

include/deque

protected:
 
     _LIBCPP_INLINE_VISIBILITY size_type&            size()          {return __size_.first();}
     _LIBCPP_INLINE_VISIBILITY
     const size_type& size() const _NOEXCEPT {return __size_.first();}
     _LIBCPP_INLINE_VISIBILITY allocator_type&       __alloc()       {return __size_.second();}
     _LIBCPP_INLINE_VISIBILITY
     const allocator_type& __alloc() const _NOEXCEPT {return __size_.second();}
 
+    _LIBCPP_INLINE_VISIBILITY
     __deque_base()
         _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
+    _LIBCPP_INLINE_VISIBILITY
     explicit __deque_base(const allocator_type& __a);
 public:
     ~__deque_base();
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     __deque_base(__deque_base&& __c)
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);

 __deque_base<_Tp, _Allocator>::end() const _NOEXCEPT
 {
     size_type __p = size() + __start_;
     __map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __p / __block_size);
     return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __deque_base<_Tp, _Allocator>::__deque_base()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
     : __start_(0), __size_(0) {}
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __deque_base<_Tp, _Allocator>::__deque_base(const allocator_type& __a)
     : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {}
 
 template <class _Tp, class _Allocator>
 __deque_base<_Tp, _Allocator>::~__deque_base()
 {
     clear();
     typename __map::iterator __i = __map_.begin();
#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
     deque& operator=(const deque& __c);
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     _LIBCPP_INLINE_VISIBILITY
     deque& operator=(initializer_list<value_type> __il) {assign(__il); return *this;}
 #endif   // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     deque(deque&& __c) _NOEXCEPT_(is_nothrow_move_constructible<__base>::value);
+    _LIBCPP_INLINE_VISIBILITY
     deque(deque&& __c, const allocator_type& __a);
+    _LIBCPP_INLINE_VISIBILITY
     deque& operator=(deque&& __c)
         _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
                    is_nothrow_move_assignable<allocator_type>::value);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     template <class _InputIter>
         void assign(_InputIter __f, _InputIter __l,
                     typename enable_if<__is_input_iterator<_InputIter>::value &&
                                       !__is_random_access_iterator<_InputIter>::value>::type* = 0);
     template <class _RAIter>
         void assign(_RAIter __f, _RAIter __l,
                     typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);
     void assign(size_type __n, const value_type& __v);
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     _LIBCPP_INLINE_VISIBILITY
     void assign(initializer_list<value_type> __il) {assign(__il.begin(), __il.end());}
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
+    _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const _NOEXCEPT;
 
     // iterators:
 
     _LIBCPP_INLINE_VISIBILITY
     iterator       begin() _NOEXCEPT       {return __base::begin();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator begin() const _NOEXCEPT {return __base::begin();}
size_type max_size() const _NOEXCEPT
         {return __alloc_traits::max_size(__base::__alloc());}
     void resize(size_type __n);
     void resize(size_type __n, const value_type& __v);
     void shrink_to_fit() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return __base::size() == 0;}
 
     // element access:
+    _LIBCPP_INLINE_VISIBILITY
     reference operator[](size_type __i);
+    _LIBCPP_INLINE_VISIBILITY
     const_reference operator[](size_type __i) const;
+    _LIBCPP_INLINE_VISIBILITY
     reference at(size_type __i);
+    _LIBCPP_INLINE_VISIBILITY
     const_reference at(size_type __i) const;
+    _LIBCPP_INLINE_VISIBILITY
     reference front();
+    _LIBCPP_INLINE_VISIBILITY
     const_reference front() const;
+    _LIBCPP_INLINE_VISIBILITY
     reference back();
+    _LIBCPP_INLINE_VISIBILITY
     const_reference back() const;
 
     // 23.2.2.3 modifiers:
     void push_front(const value_type& __v);
     void push_back(const value_type& __v);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class... _Args> void emplace_front(_Args&&... __args);
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     iterator insert(const_iterator __p, initializer_list<value_type> __il)
         {return insert(__p, __il.begin(), __il.end());}
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     void pop_front();
     void pop_back();
     iterator erase(const_iterator __p);
     iterator erase(const_iterator __f, const_iterator __l);
 
+    _LIBCPP_INLINE_VISIBILITY
     void swap(deque& __c)
 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT;
 #else
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                    __is_nothrow_swappable<allocator_type>::value);
 #endif
+    _LIBCPP_INLINE_VISIBILITY
     void clear() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     bool __invariants() const {return __base::__invariants();}
 private:
     typedef typename __base::__map_const_pointer __map_const_pointer;
 
     _LIBCPP_INLINE_VISIBILITY
if (this != &__c)
         assign(__c.begin(), __c.end());
     }
     return *this;
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 deque<_Tp, _Allocator>::deque(deque&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
     : __base(_VSTD::move(__c))
 {
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 deque<_Tp, _Allocator>::deque(deque&& __c, const allocator_type& __a)
     : __base(_VSTD::move(__c), __a)
 {
     if (__a != __c.__alloc())
     {
         typedef move_iterator<iterator> _Ip;
         assign(_Ip(__c.begin()), _Ip(__c.end()));
     }
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 deque<_Tp, _Allocator>&
 deque<_Tp, _Allocator>::operator=(deque&& __c)
         _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
                    is_nothrow_move_assignable<allocator_type>::value)
 {
     __move_assign(__c, integral_constant<bool,
           __alloc_traits::propagate_on_container_move_assignment::value>());
     return *this;
if (__n > __base::size())
         __n -= __base::size();
         __append(__n, __v);
     }
     else
         __erase_to_end(_VSTD::fill_n(__base::begin(), __n, __v));
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _Allocator
 deque<_Tp, _Allocator>::get_allocator() const _NOEXCEPT
 {
     return __base::__alloc();
 }
 
 template <class _Tp, class _Allocator>
 void
else
             __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
             __base::__map_.pop_back();
         }
     }
     __base::__map_.shrink_to_fit();
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename deque<_Tp, _Allocator>::reference
 deque<_Tp, _Allocator>::operator[](size_type __i)
 {
     size_type __p = __base::__start_ + __i;
     return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename deque<_Tp, _Allocator>::const_reference
 deque<_Tp, _Allocator>::operator[](size_type __i) const
 {
     size_type __p = __base::__start_ + __i;
     return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename deque<_Tp, _Allocator>::reference
 deque<_Tp, _Allocator>::at(size_type __i)
 {
     if (__i >= __base::size())
         __base::__throw_out_of_range();
     size_type __p = __base::__start_ + __i;
     return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename deque<_Tp, _Allocator>::const_reference
 deque<_Tp, _Allocator>::at(size_type __i) const
 {
     if (__i >= __base::size())
         __base::__throw_out_of_range();
     size_type __p = __base::__start_ + __i;
     return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename deque<_Tp, _Allocator>::reference
 deque<_Tp, _Allocator>::front()
 {
     return *(*(__base::__map_.begin() + __base::__start_ / __base::__block_size)
                                       + __base::__start_ % __base::__block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename deque<_Tp, _Allocator>::const_reference
 deque<_Tp, _Allocator>::front() const
 {
     return *(*(__base::__map_.begin() + __base::__start_ / __base::__block_size)
                                       + __base::__start_ % __base::__block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename deque<_Tp, _Allocator>::reference
 deque<_Tp, _Allocator>::back()
 {
     size_type __p = __base::size() + __base::__start_ - 1;
     return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename deque<_Tp, _Allocator>::const_reference
 deque<_Tp, _Allocator>::back() const
 {
     size_type __p = __base::size() + __base::__start_ - 1;
     return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
 }
 
 template <class _Tp, class _Allocator>
if (__n > 0)
         {
             __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
             __base::__map_.pop_back();
         }
     }
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 deque<_Tp, _Allocator>::swap(deque& __c)
 #if _LIBCPP_STD_VER >= 14
         _NOEXCEPT
 #else
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || 
                     __is_nothrow_swappable<allocator_type>::value)
 #endif
 {
     __base::swap(__c);
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 deque<_Tp, _Allocator>::clear() _NOEXCEPT
 {
     __base::clear();
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY

include/future

public:
     void set_exception(exception_ptr __p);
     void set_exception_at_thread_exit(exception_ptr __p);
 
     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>
         future_status
         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const;
 
     virtual void __execute();
 };
 
 template <class _Clock, class _Duration>
 future_status
 __assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 {
     unique_lock<mutex> __lk(__mut_);
     if (__state_ & deferred)
         return future_status::deferred;
     while (!(__state_ & ready) && _Clock::now() < __abs_time)
         __cv_.wait_until(__lk, __abs_time);
     if (__state_ & ready)
         return future_status::ready;
     return future_status::timeout;
 }
 
 template <class _Rep, class _Period>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 future_status
 __assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 {
     return wait_until(chrono::steady_clock::now() + __rel_time);
 }
 
 template <class _Rp>
 class __assoc_state
class __deferred_assoc_state
     : public __assoc_state<_Rp>
 {
     typedef __assoc_state<_Rp> base;
 
     _Fp __func_;
 
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     explicit __deferred_assoc_state(_Fp&& __f);
 #endif
 
     virtual void __execute();
 };
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Rp, class _Fp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f)
     : __func_(_VSTD::forward<_Fp>(__f))
 {
     this->__set_deferred();
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
class __deferred_assoc_state<void, _Fp>
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
 
     _Fp __func_;
 
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     explicit __deferred_assoc_state(_Fp&& __f);
 #endif
 
     virtual void __execute();
 };
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Fp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f)
     : __func_(_VSTD::forward<_Fp>(__f))
 {
     this->__set_deferred();
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 

 {
     typedef __assoc_state<_Rp> base;
 
     _Fp __func_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     explicit __async_assoc_state(_Fp&& __f);
 #endif
 
     virtual void __execute();
 };
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Rp, class _Fp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f)
     : __func_(_VSTD::forward<_Fp>(__f))
 {
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Rp, class _Fp>

 {
     typedef __assoc_sub_state base;
 
     _Fp __func_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     explicit __async_assoc_state(_Fp&& __f);
 #endif
 
     virtual void __execute();
 };
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Fp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f)
     : __func_(_VSTD::forward<_Fp>(__f))
 {
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Fp>
future& operator=(future&& __rhs) _NOEXCEPT
         }
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 private:
     future(const future&);
     future& operator=(const future&);
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~future();
+    _LIBCPP_INLINE_VISIBILITY
     shared_future<_Rp> share();
 
     // retrieving the value
     _Rp get();
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
future& operator=(future&& __rhs) _NOEXCEPT
         }
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 private:
     future(const future&);
     future& operator=(const future&);
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~future();
+    _LIBCPP_INLINE_VISIBILITY
     shared_future<_Rp&> share();
 
     // retrieving the value
     _Rp& get();
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
future& operator=(future&& __rhs) _NOEXCEPT
         }
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 private:
     future(const future&);
     future& operator=(const future&);
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~future();
+    _LIBCPP_INLINE_VISIBILITY
     shared_future<void> share();
 
     // retrieving the value
     void get();
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
public:
 
     __packaged_task_function(const __packaged_task_function&) =  delete;
     __packaged_task_function& operator=(const __packaged_task_function&) =  delete;
 
     ~__packaged_task_function();
 
     void swap(__packaged_task_function&) _NOEXCEPT;
 
+    _LIBCPP_INLINE_VISIBILITY
     _Rp operator()(_ArgTypes...) const;
 };
 
 template<class _Rp, class ..._ArgTypes>
 __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) _NOEXCEPT
 {
     if (__f.__f_ == nullptr)
         __f_ = nullptr;
else if (__f.__f_ == (__base*)&__f.__buf_)
         __f.__f_ = __f_;
         __f_ = (__base*)&__buf_;
     }
     else
         _VSTD::swap(__f_, __f.__f_);
 }
 
 template<class _Rp, class ..._ArgTypes>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _Rp
 __packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
 {
     return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
 }
 
 template<class _Rp, class ..._ArgTypes>
 class _LIBCPP_TYPE_VIS_ONLY packaged_task<_Rp(_ArgTypes...)>

 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(shared_future<_Rp>& __x, shared_future<_Rp>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
 
 template <class _Rp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 shared_future<_Rp>
 future<_Rp>::share()
 {
     return shared_future<_Rp>(_VSTD::move(*this));
 }
 
 template <class _Rp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 shared_future<_Rp&>
 future<_Rp&>::share()
 {
     return shared_future<_Rp&>(_VSTD::move(*this));
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 shared_future<void>
 future<void>::share()
 {
     return shared_future<void>(_VSTD::move(*this));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 #endif  // _LIBCPP_FUTURE

include/locale

private:
     wide_string __wide_err_string_;
     _Codecvt* __cvtptr_;
     state_type __cvtstate_;
     size_t __cvtcount_;
 
     wstring_convert(const wstring_convert& __wc);
     wstring_convert& operator=(const wstring_convert& __wc);
 public:
+    _LIBCPP_ALWAYS_INLINE
     _LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(_Codecvt* __pcvt = new _Codecvt);
+    _LIBCPP_ALWAYS_INLINE
     wstring_convert(_Codecvt* __pcvt, state_type __state);
     _LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(const byte_string& __byte_err,
                     const wide_string& __wide_err = wide_string());
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_ALWAYS_INLINE
     wstring_convert(wstring_convert&& __wc);
 #endif
     ~wstring_convert();
 
     _LIBCPP_ALWAYS_INLINE
     wide_string from_bytes(char __byte)
         {return from_bytes(&__byte, &__byte+1);}
     _LIBCPP_ALWAYS_INLINE
#endif
 
     _LIBCPP_ALWAYS_INLINE
     size_t converted() const _NOEXCEPT {return __cvtcount_;}
     _LIBCPP_ALWAYS_INLINE
     state_type state() const {return __cvtstate_;}
 };
 
 template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-inline _LIBCPP_ALWAYS_INLINE
+inline
 wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
     wstring_convert(_Codecvt* __pcvt)
         : __cvtptr_(__pcvt), __cvtstate_(), __cvtcount_(0)
 {
 }
 
 template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-inline _LIBCPP_ALWAYS_INLINE
+inline
 wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
     wstring_convert(_Codecvt* __pcvt, state_type __state)
         : __cvtptr_(__pcvt), __cvtstate_(__state), __cvtcount_(0)
 {
 }
 
 template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
 wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
     wstring_convert(const byte_string& __byte_err, const wide_string& __wide_err)
         : __byte_err_string_(__byte_err), __wide_err_string_(__wide_err),
           __cvtstate_(), __cvtcount_(0)
 {
     __cvtptr_ = new _Codecvt;
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-inline _LIBCPP_ALWAYS_INLINE
+inline
 wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
     wstring_convert(wstring_convert&& __wc)
         : __byte_err_string_(_VSTD::move(__wc.__byte_err_string_)),
           __wide_err_string_(_VSTD::move(__wc.__wide_err_string_)),
           __cvtptr_(__wc.__cvtptr_),
           __cvtstate_(__wc.__cvtstate_), __cvtcount_(__wc.__cvtstate_)
 {
     __wc.__cvtptr_ = nullptr;

include/memory

 public:
     typedef _Tp element_type;
 private:
     element_type*      __ptr_;
     __shared_weak_count* __cntrl_;
 
     struct __nat {int __for_bool_;};
 public:
+    _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR shared_ptr() _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR shared_ptr(nullptr_t) _NOEXCEPT;
     template<class _Yp>
         explicit shared_ptr(_Yp* __p,
                             typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
     template<class _Yp, class _Dp>
         shared_ptr(_Yp* __p, _Dp __d,
                    typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
     template<class _Yp, class _Dp, class _Alloc>
         shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
                    typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
     template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d);
     template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a);
-    template<class _Yp> shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT;
+    template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     shared_ptr(const shared_ptr& __r) _NOEXCEPT;
     template<class _Yp>
+        _LIBCPP_INLINE_VISIBILITY
         shared_ptr(const shared_ptr<_Yp>& __r,
                    typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type = __nat())
                        _NOEXCEPT;
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     shared_ptr(shared_ptr&& __r) _NOEXCEPT;
-    template<class _Yp> shared_ptr(shared_ptr<_Yp>&& __r,
+    template<class _Yp> _LIBCPP_INLINE_VISIBILITY  shared_ptr(shared_ptr<_Yp>&& __r,
                    typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type = __nat())
                        _NOEXCEPT;
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r,
                    typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type= __nat());
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template<class _Yp>
         shared_ptr(auto_ptr<_Yp>&& __r,
template <class _Yp, class _Dp>
                        !is_array<_Yp>::value &&
                        is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
                        __nat
                    >::type = __nat());
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     ~shared_ptr();
 
+    _LIBCPP_INLINE_VISIBILITY
     shared_ptr& operator=(const shared_ptr& __r) _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             shared_ptr&
         >::type
+        _LIBCPP_INLINE_VISIBILITY
         operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT;
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     shared_ptr& operator=(shared_ptr&& __r) _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             shared_ptr<_Tp>&
         >::type
+        _LIBCPP_INLINE_VISIBILITY
         operator=(shared_ptr<_Yp>&& __r);
     template<class _Yp>
         typename enable_if
         <
             !is_array<_Yp>::value &&
             is_convertible<_Yp*, element_type*>::value,
             shared_ptr
         >::type&
+        _LIBCPP_INLINE_VISIBILITY
         operator=(auto_ptr<_Yp>&& __r);
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template<class _Yp>
         typename enable_if
         <
             !is_array<_Yp>::value &&
             is_convertible<_Yp*, element_type*>::value,
             shared_ptr&
         >::type
         operator=(auto_ptr<_Yp> __r);
 #endif
     template <class _Yp, class _Dp>
         typename enable_if
         <
             !is_array<_Yp>::value &&
             is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
             shared_ptr&
         >::type
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+        _LIBCPP_INLINE_VISIBILITY
         operator=(unique_ptr<_Yp, _Dp>&& __r);
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
         operator=(unique_ptr<_Yp, _Dp> __r);
 #endif
 
+    _LIBCPP_INLINE_VISIBILITY
     void swap(shared_ptr& __r) _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     void reset() _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             void
         >::type
+        _LIBCPP_INLINE_VISIBILITY
         reset(_Yp* __p);
     template<class _Yp, class _Dp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             void
         >::type
+        _LIBCPP_INLINE_VISIBILITY
         reset(_Yp* __p, _Dp __d);
     template<class _Yp, class _Dp, class _Alloc>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             void
         >::type
+        _LIBCPP_INLINE_VISIBILITY
         reset(_Yp* __p, _Dp __d, _Alloc __a);
 
     _LIBCPP_INLINE_VISIBILITY
     element_type* get() const _NOEXCEPT {return __ptr_;}
     _LIBCPP_INLINE_VISIBILITY
     typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPT
         {return *__ptr_;}
     _LIBCPP_INLINE_VISIBILITY
private:
     _LIBCPP_INLINE_VISIBILITY
     void __enable_weak_this(const volatile void*) _NOEXCEPT {}
 
     template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY shared_ptr;
     template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY weak_ptr;
 };
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 shared_ptr<_Tp>::shared_ptr() _NOEXCEPT
     : __ptr_(0),
       __cntrl_(0)
 {
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 shared_ptr<_Tp>::shared_ptr(nullptr_t) _NOEXCEPT
     : __ptr_(0),
       __cntrl_(0)
 {
 }
 
 template<class _Tp>
catch (...)
         __d(__p);
         throw;
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template<class _Tp>
 template<class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) _NOEXCEPT
     : __ptr_(__p),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_shared();
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_shared();
 }
 
 template<class _Tp>
 template<class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r,
                             typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type)
          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_shared();
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 shared_ptr<_Tp>::shared_ptr(shared_ptr&& __r) _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     __r.__ptr_ = 0;
     __r.__cntrl_ = 0;
 }
 
 template<class _Tp>
 template<class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r,
                             typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat>::type)
          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     __r.__ptr_ = 0;
     __r.__cntrl_ = 0;

 template<class _Tp>
 shared_ptr<_Tp>::~shared_ptr()
 {
     if (__cntrl_)
         __cntrl_->__release_shared();
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 shared_ptr<_Tp>&
 shared_ptr<_Tp>::operator=(const shared_ptr& __r) _NOEXCEPT
 {
     shared_ptr(__r).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     is_convertible<_Yp*, _Tp*>::value,
     shared_ptr<_Tp>&
 >::type
 shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT
 {
     shared_ptr(__r).swap(*this);
     return *this;
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 shared_ptr<_Tp>&
 shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPT
 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     is_convertible<_Yp*, _Tp*>::value,
     shared_ptr<_Tp>&
 >::type
 shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r)
 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     !is_array<_Yp>::value &&
     is_convertible<_Yp*, _Tp*>::value,
     shared_ptr<_Tp>
 >::type&
 shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r)
 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 template <class _Yp, class _Dp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     !is_array<_Yp>::value &&
     is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, _Tp*>::value,
     shared_ptr<_Tp>&
 >::type
 shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r)
 {

 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 shared_ptr<_Tp>::swap(shared_ptr& __r) _NOEXCEPT
 {
     _VSTD::swap(__ptr_, __r.__ptr_);
     _VSTD::swap(__cntrl_, __r.__cntrl_);
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 shared_ptr<_Tp>::reset() _NOEXCEPT
 {
     shared_ptr().swap(*this);
 }
 
 template<class _Tp>
 template<class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     is_convertible<_Yp*, _Tp*>::value,
     void
 >::type
 shared_ptr<_Tp>::reset(_Yp* __p)
 {
     shared_ptr(__p).swap(*this);
 }
 
 template<class _Tp>
 template<class _Yp, class _Dp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     is_convertible<_Yp*, _Tp*>::value,
     void
 >::type
 shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d)
 {
     shared_ptr(__p, __d).swap(*this);
 }
 
 template<class _Tp>
 template<class _Yp, class _Dp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     is_convertible<_Yp*, _Tp*>::value,
     void
 >::type
 shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a)
 {
     shared_ptr(__p, __d, __a).swap(*this);

 {
 public:
     typedef _Tp element_type;
 private:
     element_type*        __ptr_;
     __shared_weak_count* __cntrl_;
 
 public:
+    _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR weak_ptr() _NOEXCEPT;
-    template<class _Yp> weak_ptr(shared_ptr<_Yp> const& __r,
+    template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(shared_ptr<_Yp> const& __r,
                    typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
                         _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     weak_ptr(weak_ptr const& __r) _NOEXCEPT;
-    template<class _Yp> weak_ptr(weak_ptr<_Yp> const& __r,
+    template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp> const& __r,
                    typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
                          _NOEXCEPT;
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     weak_ptr(weak_ptr&& __r) _NOEXCEPT;
-    template<class _Yp> weak_ptr(weak_ptr<_Yp>&& __r,
+    template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp>&& __r,
                    typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
                          _NOEXCEPT;
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~weak_ptr();
 
+    _LIBCPP_INLINE_VISIBILITY
     weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             weak_ptr&
         >::type
+        _LIBCPP_INLINE_VISIBILITY
         operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT;
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
+    _LIBCPP_INLINE_VISIBILITY
     weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             weak_ptr&
         >::type
+        _LIBCPP_INLINE_VISIBILITY
         operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT;
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     template<class _Yp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             weak_ptr&
         >::type
+        _LIBCPP_INLINE_VISIBILITY
         operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT;
 
+    _LIBCPP_INLINE_VISIBILITY
     void swap(weak_ptr& __r) _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY
     void reset() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     long use_count() const _NOEXCEPT
         {return __cntrl_ ? __cntrl_->use_count() : 0;}
     _LIBCPP_INLINE_VISIBILITY
     bool expired() const _NOEXCEPT
         {return __cntrl_ == 0 || __cntrl_->use_count() == 0;}
     shared_ptr<_Tp> lock() const _NOEXCEPT;
     template<class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(const shared_ptr<_Up>& __r) const
         {return __cntrl_ < __r.__cntrl_;}
     template<class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(const weak_ptr<_Up>& __r) const
         {return __cntrl_ < __r.__cntrl_;}
 
     template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY weak_ptr;
     template <class _Up> friend class _LIBCPP_TYPE_VIS_ONLY shared_ptr;
 };
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _LIBCPP_CONSTEXPR
 weak_ptr<_Tp>::weak_ptr() _NOEXCEPT
     : __ptr_(0),
       __cntrl_(0)
 {
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_weak();
 }
 
 template<class _Tp>
 template<class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r,
                         typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
                          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_weak();
 }
 
 template<class _Tp>
 template<class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r,
                         typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_weak();
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     __r.__ptr_ = 0;
     __r.__cntrl_ = 0;
 }
 
 template<class _Tp>
 template<class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r,
                         typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     __r.__ptr_ = 0;
     __r.__cntrl_ = 0;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
 weak_ptr<_Tp>::~weak_ptr()
 {
     if (__cntrl_)
         __cntrl_->__release_weak();
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 weak_ptr<_Tp>&
 weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     is_convertible<_Yp*, _Tp*>::value,
     weak_ptr<_Tp>&
 >::type
 weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
     return *this;
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 weak_ptr<_Tp>&
 weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT
 {
     weak_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     is_convertible<_Yp*, _Tp*>::value,
     weak_ptr<_Tp>&
 >::type
 weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT
 {
     weak_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
 template<class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     is_convertible<_Yp*, _Tp*>::value,
     weak_ptr<_Tp>&
 >::type
 weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
     return *this;
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT
 {
     _VSTD::swap(__ptr_, __r.__ptr_);
     _VSTD::swap(__cntrl_, __r.__cntrl_);
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 weak_ptr<_Tp>::reset() _NOEXCEPT
 {
     weak_ptr().swap(*this);
 }
 
 template<class _Tp>
 template<class _Yp>

include/random

#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _CharT, class _Traits,
               class _Eng, size_t _Wp, class _UI>
     friend
     basic_istream<_CharT, _Traits>&
     operator>>(basic_istream<_CharT, _Traits>& __is,
                independent_bits_engine<_Eng, _Wp, _UI>& __x);
 
 private:
+    _LIBCPP_INLINE_VISIBILITY
     result_type __eval(false_type);
     result_type __eval(true_type);
 
     template <size_t __count>
         _LIBCPP_INLINE_VISIBILITY
         static
         typename enable_if
         <
template <size_t __count>
         <
             (__count >= _Dt),
             result_type
         >::type
         __lshift(result_type) {return result_type(0);}
 };
 
 template<class _Engine, size_t __w, class _UIntType>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _UIntType
 independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type)
 {
     return static_cast<result_type>(__e_() & __mask0);
 }
 
 template<class _Engine, size_t __w, class _UIntType>
 _UIntType
public:
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY
         result_type operator()(_URNG& __g)
         {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+    template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
 
     // property functions
     _LIBCPP_INLINE_VISIBILITY
     result_type a() const {return __p_.a();}
     _LIBCPP_INLINE_VISIBILITY
     result_type b() const {return __p_.b();}
 
     _LIBCPP_INLINE_VISIBILITY
public:
     friend _LIBCPP_INLINE_VISIBILITY
         bool operator!=(const uniform_real_distribution& __x,
                         const uniform_real_distribution& __y)
         {return !(__x == __y);}
 };
 
 template<class _RealType>
 template<class _URNG>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename uniform_real_distribution<_RealType>::result_type
 uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
     return (__p.b() - __p.a())
         * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
         + __p.a();
 }
 
public:
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY
         result_type operator()(_URNG& __g)
         {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+    template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
 
     // property functions
     _LIBCPP_INLINE_VISIBILITY
     double p() const {return __p_.p();}
 
     _LIBCPP_INLINE_VISIBILITY
     param_type param() const {return __p_;}
     _LIBCPP_INLINE_VISIBILITY
friend _LIBCPP_INLINE_VISIBILITY
         {return __x.__p_ == __y.__p_;}
     friend _LIBCPP_INLINE_VISIBILITY
         bool operator!=(const bernoulli_distribution& __x,
                         const bernoulli_distribution& __y)
         {return !(__x == __y);}
 };
 
 template<class _URNG>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 bernoulli_distribution::result_type
 bernoulli_distribution::operator()(_URNG& __g, const param_type& __p)
 {
     uniform_real_distribution<double> __gen;
     return __gen(__g) < __p.p();
 }
 
 template <class _CharT, class _Traits>
public:
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY
         result_type operator()(_URNG& __g)
         {return (*this)(__g, __p_);}
-    template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+    template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
 
     // property functions
     _LIBCPP_INLINE_VISIBILITY
     result_type a() const {return __p_.a();}
     _LIBCPP_INLINE_VISIBILITY
     result_type b() const {return __p_.b();}
 
     _LIBCPP_INLINE_VISIBILITY
public:
     friend _LIBCPP_INLINE_VISIBILITY
         bool operator!=(const cauchy_distribution& __x,
                         const cauchy_distribution& __y)
         {return !(__x == __y);}
 };
 
 template <class _RealType>
 template<class _URNG>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _RealType
 cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
     uniform_real_distribution<result_type> __gen;
     // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite
     return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g));
 }
 

include/regex

template <class _ForwardIterator>
         char_class_type
         __lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
                            bool __icase, wchar_t) const;
 
     static int __regex_traits_value(unsigned char __ch, int __radix);
     _LIBCPP_INLINE_VISIBILITY
     int __regex_traits_value(char __ch, int __radix) const
         {return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);}
+    _LIBCPP_INLINE_VISIBILITY
     int __regex_traits_value(wchar_t __ch, int __radix) const;
 };
 
 template <class _CharT>
 const typename regex_traits<_CharT>::char_class_type
 regex_traits<_CharT>::__regex_word;
 
 template <class _CharT>
if (__radix != 8)
             if ('a' <= __ch && __ch <= 'f')
                 return __ch - ('a' - 10);
         }
     }
     return -1;
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 int
 regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const
 {
     return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix);
 }
 
 template <class _CharT> class __node;
 

include/string

struct _LIBCPP_TYPE_VIS_ONLY char_traits
     static inline void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT
         {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
     static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 < __c2;}
 
     static int              compare(const char_type* __s1, const char_type* __s2, size_t __n);
+    _LIBCPP_INLINE_VISIBILITY
     static size_t           length(const char_type* __s);
+    _LIBCPP_INLINE_VISIBILITY
     static const char_type* find(const char_type* __s, size_t __n, const char_type& __a);
     static char_type*       move(char_type* __s1, const char_type* __s2, size_t __n);
+    _LIBCPP_INLINE_VISIBILITY
     static char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n);
+    _LIBCPP_INLINE_VISIBILITY
     static char_type*       assign(char_type* __s, size_t __n, char_type __a);
 
     static inline _LIBCPP_CONSTEXPR int_type  not_eof(int_type __c) _NOEXCEPT
         {return eq_int_type(__c, eof()) ? ~eof() : __c;}
     static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
         {return char_type(__c);}
     static inline _LIBCPP_CONSTEXPR int_type  to_int_type(char_type __c) _NOEXCEPT
         {return int_type(__c);}
for (; __n; --__n, ++__s1, ++__s2)
             return -1;
         if (lt(*__s2, *__s1))
             return 1;
     }
     return 0;
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 size_t
 char_traits<_CharT>::length(const char_type* __s)
 {
     size_t __len = 0;
     for (; !eq(*__s, char_type(0)); ++__s)
         ++__len;
     return __len;
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 const _CharT*
 char_traits<_CharT>::find(const char_type* __s, size_t __n, const char_type& __a)
 {
     for (; __n; --__n)
     {
         if (eq(*__s, __a))
             return __s;
         ++__s;
else if (__s2 < __s1)
         __s2 += __n;
         for (; __n; --__n)
             assign(*--__s1, *--__s2);
     }
     return __r;
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _CharT*
 char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
 {
     _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
     char_type* __r = __s1;
     for (; __n; --__n, ++__s1, ++__s2)
         assign(*__s1, *__s2);
     return __r;
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _CharT*
 char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)
 {
     char_type* __r = __s;
     for (; __n; --__n, ++__s)
         assign(*__s, __a);
     return __r;
 }
struct _LIBCPP_TYPE_VIS_ONLY char_traits<char16_t>
 
     static inline void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT
         {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
     static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 < __c2;}
 
+    _LIBCPP_INLINE_VISIBILITY
     static int              compare(const char_type* __s1, const char_type* __s2, size_t __n);
+    _LIBCPP_INLINE_VISIBILITY
     static size_t           length(const char_type* __s);
+    _LIBCPP_INLINE_VISIBILITY
     static const char_type* find(const char_type* __s, size_t __n, const char_type& __a);
+    _LIBCPP_INLINE_VISIBILITY
     static char_type*       move(char_type* __s1, const char_type* __s2, size_t __n);
+    _LIBCPP_INLINE_VISIBILITY
     static char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n);
+    _LIBCPP_INLINE_VISIBILITY
     static char_type*       assign(char_type* __s, size_t __n, char_type __a);
 
     static inline _LIBCPP_CONSTEXPR int_type  not_eof(int_type __c) _NOEXCEPT
         {return eq_int_type(__c, eof()) ? ~eof() : __c;}
     static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
         {return char_type(__c);}
     static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
         {return int_type(__c);}
     static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
     static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
         {return int_type(0xFFFF);}
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 int
 char_traits<char16_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n)
 {
     for (; __n; --__n, ++__s1, ++__s2)
     {
         if (lt(*__s1, *__s2))
             return -1;
         if (lt(*__s2, *__s1))
             return 1;
     }
     return 0;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 size_t
 char_traits<char16_t>::length(const char_type* __s)
 {
     size_t __len = 0;
     for (; !eq(*__s, char_type(0)); ++__s)
         ++__len;
     return __len;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 const char16_t*
 char_traits<char16_t>::find(const char_type* __s, size_t __n, const char_type& __a)
 {
     for (; __n; --__n)
     {
         if (eq(*__s, __a))
             return __s;
         ++__s;
     }
     return 0;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 char16_t*
 char_traits<char16_t>::move(char_type* __s1, const char_type* __s2, size_t __n)
 {
     char_type* __r = __s1;
     if (__s1 < __s2)
     {
         for (; __n; --__n, ++__s1, ++__s2)
             assign(*__s1, *__s2);
     }
     else if (__s2 < __s1)
     {
         __s1 += __n;
         __s2 += __n;
         for (; __n; --__n)
             assign(*--__s1, *--__s2);
     }
     return __r;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 char16_t*
 char_traits<char16_t>::copy(char_type* __s1, const char_type* __s2, size_t __n)
 {
     _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
     char_type* __r = __s1;
     for (; __n; --__n, ++__s1, ++__s2)
         assign(*__s1, *__s2);
     return __r;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 char16_t*
 char_traits<char16_t>::assign(char_type* __s, size_t __n, char_type __a)
 {
     char_type* __r = __s;
     for (; __n; --__n, ++__s)
         assign(*__s, __a);
     return __r;
 }
struct _LIBCPP_TYPE_VIS_ONLY char_traits<char32_t>
 
     static inline void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT
         {__c1 = __c2;}
     static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
     static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
         {return __c1 < __c2;}
 
+    _LIBCPP_INLINE_VISIBILITY
     static int              compare(const char_type* __s1, const char_type* __s2, size_t __n);
+    _LIBCPP_INLINE_VISIBILITY
     static size_t           length(const char_type* __s);
+    _LIBCPP_INLINE_VISIBILITY
     static const char_type* find(const char_type* __s, size_t __n, const char_type& __a);
+    _LIBCPP_INLINE_VISIBILITY
     static char_type*       move(char_type* __s1, const char_type* __s2, size_t __n);
+    _LIBCPP_INLINE_VISIBILITY
     static char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n);
+    _LIBCPP_INLINE_VISIBILITY
     static char_type*       assign(char_type* __s, size_t __n, char_type __a);
 
     static inline _LIBCPP_CONSTEXPR int_type  not_eof(int_type __c) _NOEXCEPT
         {return eq_int_type(__c, eof()) ? ~eof() : __c;}
     static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
         {return char_type(__c);}
     static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
         {return int_type(__c);}
     static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
         {return __c1 == __c2;}
     static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
         {return int_type(0xFFFFFFFF);}
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 int
 char_traits<char32_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n)
 {
     for (; __n; --__n, ++__s1, ++__s2)
     {
         if (lt(*__s1, *__s2))
             return -1;
         if (lt(*__s2, *__s1))
             return 1;
     }
     return 0;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 size_t
 char_traits<char32_t>::length(const char_type* __s)
 {
     size_t __len = 0;
     for (; !eq(*__s, char_type(0)); ++__s)
         ++__len;
     return __len;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 const char32_t*
 char_traits<char32_t>::find(const char_type* __s, size_t __n, const char_type& __a)
 {
     for (; __n; --__n)
     {
         if (eq(*__s, __a))
             return __s;
         ++__s;
     }
     return 0;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 char32_t*
 char_traits<char32_t>::move(char_type* __s1, const char_type* __s2, size_t __n)
 {
     char_type* __r = __s1;
     if (__s1 < __s2)
     {
         for (; __n; --__n, ++__s1, ++__s2)
             assign(*__s1, *__s2);
     }
     else if (__s2 < __s1)
     {
         __s1 += __n;
         __s2 += __n;
         for (; __n; --__n)
             assign(*--__s1, *--__s2);
     }
     return __r;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 char32_t*
 char_traits<char32_t>::copy(char_type* __s1, const char_type* __s2, size_t __n)
 {
     _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
     char_type* __r = __s1;
     for (; __n; --__n, ++__s1, ++__s2)
         assign(*__s1, *__s2);
     return __r;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 char32_t*
 char_traits<char32_t>::assign(char_type* __s, size_t __n, char_type __a)
 {
     char_type* __r = __s;
     for (; __n; --__n, ++__s)
         assign(*__s, __a);
     return __r;
 }

include/thread

 #else  // _LIBCPP_HAS_NO_VARIADICS
     template <class _Fp> explicit thread(_Fp __f);
 #endif
     ~thread();
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {__t.__t_ = 0;}
+    _LIBCPP_INLINE_VISIBILITY
     thread& operator=(thread&& __t) _NOEXCEPT;
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}
 
     _LIBCPP_INLINE_VISIBILITY
     bool joinable() const _NOEXCEPT {return __t_ != 0;}
thread::thread(_Fp __f)
     else
         __throw_system_error(__ec, "thread constructor failed");
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 thread&
 thread::operator=(thread&& __t) _NOEXCEPT
 {
     if (__t_ != 0)
         terminate();
     __t_ = __t.__t_;
     __t.__t_ = 0;
     return *this;

include/valarray

 private:
     value_type* __begin_;
     value_type* __end_;
 
 public:
     // construct/destroy:
     _LIBCPP_INLINE_VISIBILITY
     valarray() : __begin_(0), __end_(0) {}
+    _LIBCPP_INLINE_VISIBILITY
     explicit valarray(size_t __n);
+    _LIBCPP_INLINE_VISIBILITY
     valarray(const value_type& __x, size_t __n);
     valarray(const value_type* __p, size_t __n);
     valarray(const valarray& __v);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     valarray(valarray&& __v) _NOEXCEPT;
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     valarray(initializer_list<value_type> __il);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     valarray(const slice_array<value_type>& __sa);
     valarray(const gslice_array<value_type>& __ga);
     valarray(const mask_array<value_type>& __ma);
     valarray(const indirect_array<value_type>& __ia);
+    _LIBCPP_INLINE_VISIBILITY
     ~valarray();
 
     // assignment:
     valarray& operator=(const valarray& __v);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator=(valarray&& __v) _NOEXCEPT;
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator=(initializer_list<value_type>);
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator=(const value_type& __x);
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator=(const slice_array<value_type>& __sa);
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator=(const gslice_array<value_type>& __ga);
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator=(const mask_array<value_type>& __ma);
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator=(const indirect_array<value_type>& __ia);
     template <class _ValExpr>
+        _LIBCPP_INLINE_VISIBILITY
         valarray& operator=(const __val_expr<_ValExpr>& __v);
 
     // element access:
     _LIBCPP_INLINE_VISIBILITY
     const value_type& operator[](size_t __i) const {return __begin_[__i];}
 
     _LIBCPP_INLINE_VISIBILITY
     value_type&       operator[](size_t __i)       {return __begin_[__i];}
 
     // subset operations:
+    _LIBCPP_INLINE_VISIBILITY
     __val_expr<__slice_expr<const valarray&> >    operator[](slice __s) const;
+    _LIBCPP_INLINE_VISIBILITY
     slice_array<value_type>                       operator[](slice __s);
+    _LIBCPP_INLINE_VISIBILITY
     __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const;
+    _LIBCPP_INLINE_VISIBILITY
     gslice_array<value_type>   operator[](const gslice& __gs);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const;
+    _LIBCPP_INLINE_VISIBILITY
     gslice_array<value_type>                      operator[](gslice&& __gs);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     __val_expr<__mask_expr<const valarray&> >     operator[](const valarray<bool>& __vb) const;
+    _LIBCPP_INLINE_VISIBILITY
     mask_array<value_type>                        operator[](const valarray<bool>& __vb);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     __val_expr<__mask_expr<const valarray&> >     operator[](valarray<bool>&& __vb) const;
+    _LIBCPP_INLINE_VISIBILITY
     mask_array<value_type>                        operator[](valarray<bool>&& __vb);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const;
+    _LIBCPP_INLINE_VISIBILITY
     indirect_array<value_type>                    operator[](const valarray<size_t>& __vs);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const;
+    _LIBCPP_INLINE_VISIBILITY
     indirect_array<value_type>                    operator[](valarray<size_t>&& __vs);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     // unary operators:
     valarray       operator+() const;
     valarray       operator-() const;
     valarray       operator~() const;
     valarray<bool> operator!() const;
 
     // computed assignment:
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator*= (const value_type& __x);
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator/= (const value_type& __x);
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator%= (const value_type& __x);
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator+= (const value_type& __x);
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator-= (const value_type& __x);
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator^= (const value_type& __x);
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator&= (const value_type& __x);
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator|= (const value_type& __x);
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator<<=(const value_type& __x);
+    _LIBCPP_INLINE_VISIBILITY
     valarray& operator>>=(const value_type& __x);
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         valarray&
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator*= (const _Expr& __v);
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         valarray&
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator/= (const _Expr& __v);
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         valarray&
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator%= (const _Expr& __v);
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         valarray&
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator+= (const _Expr& __v);
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         valarray&
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator-= (const _Expr& __v);
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         valarray&
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator^= (const _Expr& __v);
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         valarray&
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator|= (const _Expr& __v);
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         valarray&
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator&= (const _Expr& __v);
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         valarray&
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator<<= (const _Expr& __v);
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         valarray&
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator>>= (const _Expr& __v);
 
     // member functions:
+    _LIBCPP_INLINE_VISIBILITY
     void swap(valarray& __v) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return static_cast<size_t>(__end_ - __begin_);}
 
+    _LIBCPP_INLINE_VISIBILITY
     value_type sum() const;
+    _LIBCPP_INLINE_VISIBILITY
     value_type min() const;
+    _LIBCPP_INLINE_VISIBILITY
     value_type max() const;
 
     valarray shift (int __i) const;
     valarray cshift(int __i) const;
     valarray apply(value_type __f(value_type)) const;
     valarray apply(value_type __f(const value_type&)) const;
     void     resize(size_t __n, value_type __x = value_type());
 

 
 public:
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator*=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator/=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator%=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator+=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator-=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator^=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator&=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator|=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator<<=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     const slice_array& operator=(const slice_array& __sa) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     slice_array(const slice& __sl, const valarray<value_type>& __v)
         : __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())),
           __size_(__sl.size()),
           __stride_(__sl.stride())
         {}
 
     template <class> friend class valarray;
     template <class> friend class sliceExpr;
 };
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 const slice_array<_Tp>&
 slice_array<_Tp>::operator=(const slice_array& __sa) const
 {
     value_type* __t = __vp_;
     const value_type* __s = __sa.__vp_;
     for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_)
         *__t = *__s;
     return *this;
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 slice_array<_Tp>::operator=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t = __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 slice_array<_Tp>::operator*=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t *= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 slice_array<_Tp>::operator/=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t /= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 slice_array<_Tp>::operator%=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t %= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 slice_array<_Tp>::operator+=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t += __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 slice_array<_Tp>::operator-=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t -= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 slice_array<_Tp>::operator^=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t ^= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 slice_array<_Tp>::operator&=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t &= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 slice_array<_Tp>::operator|=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t |= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 slice_array<_Tp>::operator<<=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t <<= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 slice_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t >>= __v[__i];
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 slice_array<_Tp>::operator=(const value_type& __x) const
 {
     value_type* __t = __vp_;
     for (size_t __n = __size_; __n; --__n, __t += __stride_)
         *__t = __x;
 }
 

 
 public:
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator*=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator/=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator%=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator+=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator-=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator^=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator&=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator|=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator<<=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     const gslice_array& operator=(const gslice_array& __ga) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
 
 //  gslice_array(const gslice_array&)            = default;
 //  gslice_array(gslice_array&&)                 = default;
 //  gslice_array& operator=(const gslice_array&) = default;
 //  gslice_array& operator=(gslice_array&&)      = default;
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
     gslice_array(const gslice& __gs, const valarray<value_type>& __v)
         : __vp_(const_cast<value_type*>(__v.__begin_)),
           __1d_(__gs.__1d_)
         {}
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    _LIBCPP_INLINE_VISIBILITY
     gslice_array(gslice&& __gs, const valarray<value_type>& __v)
         : __vp_(const_cast<value_type*>(__v.__begin_)),
           __1d_(move(__gs.__1d_))
         {}
-
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     template <class> friend class valarray;
 };
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 gslice_array<_Tp>::operator=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] = __v[__j];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 gslice_array<_Tp>::operator*=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] *= __v[__j];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 gslice_array<_Tp>::operator/=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] /= __v[__j];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 gslice_array<_Tp>::operator%=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] %= __v[__j];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 gslice_array<_Tp>::operator+=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] += __v[__j];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 gslice_array<_Tp>::operator-=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] -= __v[__j];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 gslice_array<_Tp>::operator^=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] ^= __v[__j];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 gslice_array<_Tp>::operator&=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] &= __v[__j];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 gslice_array<_Tp>::operator|=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] |= __v[__j];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 gslice_array<_Tp>::operator<<=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] <<= __v[__j];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 gslice_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] >>= __v[__j];
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 const gslice_array<_Tp>&
 gslice_array<_Tp>::operator=(const gslice_array& __ga) const
 {
     typedef const size_t* _Ip;
     const value_type* __s = __ga.__vp_;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_;
             __i != __e; ++__i, ++__j)
         __vp_[*__i] = __s[*__j];
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 gslice_array<_Tp>::operator=(const value_type& __x) const
 {
     typedef const size_t* _Ip;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
         __vp_[*__i] = __x;
 }
 

 
 public:
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator*=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator/=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator%=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator+=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator-=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator^=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator&=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator|=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator<<=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     const mask_array& operator=(const mask_array& __ma) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
 
 //  mask_array(const mask_array&)            = default;
 //  mask_array(mask_array&&)                 = default;
 //  mask_array& operator=(const mask_array&) = default;
 //  mask_array& operator=(mask_array&&)      = default;
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v)
         : __vp_(const_cast<value_type*>(__v.__begin_)),
           __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true)))
           {
               size_t __j = 0;
               for (size_t __i = 0; __i < __vb.size(); ++__i)
                   if (__vb[__i])
                       __1d_[__j++] = __i;
           }
 
     template <class> friend class valarray;
 };
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 mask_array<_Tp>::operator=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] = __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 mask_array<_Tp>::operator*=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] *= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 mask_array<_Tp>::operator/=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] /= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 mask_array<_Tp>::operator%=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] %= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 mask_array<_Tp>::operator+=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] += __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 mask_array<_Tp>::operator-=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] -= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 mask_array<_Tp>::operator^=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] ^= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 mask_array<_Tp>::operator&=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] &= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 mask_array<_Tp>::operator|=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] |= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 mask_array<_Tp>::operator<<=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] <<= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 mask_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] >>= __v[__i];
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 const mask_array<_Tp>&
 mask_array<_Tp>::operator=(const mask_array& __ma) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]];
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 mask_array<_Tp>::operator=(const value_type& __x) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] = __x;
 }
 

 
 public:
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator*=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator/=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator%=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator+=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator-=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator^=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator&=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator|=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator<<=(const _Expr& __v) const;
 
     template <class _Expr>
     typename enable_if
     <
         __is_val_expr<_Expr>::value,
         void
     >::type
+    _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     const indirect_array& operator=(const indirect_array& __ia) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
 
 //  indirect_array(const indirect_array&)            = default;
 //  indirect_array(indirect_array&&)                 = default;
 //  indirect_array& operator=(const indirect_array&) = default;
 //  indirect_array& operator=(indirect_array&&)      = default;
 
 private:

 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     template <class> friend class valarray;
 };
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 indirect_array<_Tp>::operator=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] = __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 indirect_array<_Tp>::operator*=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] *= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 indirect_array<_Tp>::operator/=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] /= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 indirect_array<_Tp>::operator%=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] %= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 indirect_array<_Tp>::operator+=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] += __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 indirect_array<_Tp>::operator-=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] -= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 indirect_array<_Tp>::operator^=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] ^= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 indirect_array<_Tp>::operator&=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] &= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 indirect_array<_Tp>::operator|=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] |= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 indirect_array<_Tp>::operator<<=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] <<= __v[__i];
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     void
 >::type
 indirect_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] >>= __v[__i];
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 const indirect_array<_Tp>&
 indirect_array<_Tp>::operator=(const indirect_array& __ia) const
 {
     typedef const size_t* _Ip;
     const value_type* __s = __ia.__vp_;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_;
             __i != __e; ++__i, ++__j)
         __vp_[*__i] = __s[*__j];
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 indirect_array<_Tp>::operator=(const value_type& __x) const
 {
     typedef const size_t* _Ip;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
         __vp_[*__i] = __x;
 }
 
if (__n)
             ::new (__r.__end_) result_type(__expr_[__i]);
     }
     return __r;
 }
 
 // valarray
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>::valarray(size_t __n)
     : __begin_(0),
       __end_(0)
 {
     resize(__n);
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>::valarray(const value_type& __x, size_t __n)
     : __begin_(0),
       __end_(0)
 {
     resize(__n, __x);
 }
 
 template <class _Tp>
#ifndef _LIBCPP_NO_EXCEPTIONS
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT
     : __begin_(__v.__begin_),
       __end_(__v.__end_)
 {
     __v.__begin_ = __v.__end_ = nullptr;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_NO_EXCEPTIONS
             resize(0);
             throw;
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>::~valarray()
 {
     resize(0);
 }
 
 template <class _Tp>
 valarray<_Tp>&
 valarray<_Tp>::operator=(const valarray& __v)
 {
     if (this != &__v)
     {
         if (size() != __v.size())
             resize(__v.size());
         _VSTD::copy(__v.__begin_, __v.__end_, __begin_);
     }
     return *this;
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT
 {
     resize(0);
     __begin_ = __v.__begin_;
     __end_ = __v.__end_;
     __v.__begin_ = nullptr;
     __v.__end_ = nullptr;
     return *this;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(initializer_list<value_type> __il)
 {
     if (size() != __il.size())
         resize(__il.size());
     _VSTD::copy(__il.begin(), __il.end(), __begin_);
     return *this;
 }
 
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(const value_type& __x)
 {
     _VSTD::fill(__begin_, __end_, __x);
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(const slice_array<value_type>& __sa)
 {
     value_type* __t = __begin_;
     const value_type* __s = __sa.__vp_;
     for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t)
         *__t = *__s;
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(const gslice_array<value_type>& __ga)
 {
     typedef const size_t* _Ip;
     value_type* __t = __begin_;
     const value_type* __s = __ga.__vp_;
     for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_;
                     __i != __e; ++__i, ++__t)
         *__t = __s[*__i];
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(const mask_array<value_type>& __ma)
 {
     typedef const size_t* _Ip;
     value_type* __t = __begin_;
     const value_type* __s = __ma.__vp_;
     for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_;
                     __i != __e; ++__i, ++__t)
         *__t = __s[*__i];
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(const indirect_array<value_type>& __ia)
 {
     typedef const size_t* _Ip;
     value_type* __t = __begin_;
     const value_type* __s = __ia.__vp_;
     for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_;
                     __i != __e; ++__i, ++__t)
         *__t = __s[*__i];
     return *this;
 }
 
 template <class _Tp>
 template <class _ValExpr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v)
 {
     size_t __n = __v.size();
     if (size() != __n)
         resize(__n);
     value_type* __t = __begin_;
     for (size_t __i = 0; __i != __n; ++__t, ++__i)
         *__t = result_type(__v[__i]);
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __val_expr<__slice_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](slice __s) const
 {
     return __val_expr<__slice_expr<const valarray&> >(__slice_expr<const valarray&>(__s, *this));
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 slice_array<_Tp>
 valarray<_Tp>::operator[](slice __s)
 {
     return slice_array<value_type>(__s, *this);
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __val_expr<__indirect_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](const gslice& __gs) const
 {
     return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__gs.__1d_, *this));
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 gslice_array<_Tp>
 valarray<_Tp>::operator[](const gslice& __gs)
 {
     return gslice_array<value_type>(__gs, *this);
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __val_expr<__indirect_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](gslice&& __gs) const
 {
     return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__gs.__1d_), *this));
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 gslice_array<_Tp>
 valarray<_Tp>::operator[](gslice&& __gs)
 {
     return gslice_array<value_type>(move(__gs), *this);
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __val_expr<__mask_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](const valarray<bool>& __vb) const
 {
     return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(__vb, *this));
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 mask_array<_Tp>
 valarray<_Tp>::operator[](const valarray<bool>& __vb)
 {
     return mask_array<value_type>(__vb, *this);
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __val_expr<__mask_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](valarray<bool>&& __vb) const
 {
     return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(move(__vb), *this));
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 mask_array<_Tp>
 valarray<_Tp>::operator[](valarray<bool>&& __vb)
 {
     return mask_array<value_type>(move(__vb), *this);
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __val_expr<__indirect_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](const valarray<size_t>& __vs) const
 {
     return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__vs, *this));
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 indirect_array<_Tp>
 valarray<_Tp>::operator[](const valarray<size_t>& __vs)
 {
     return indirect_array<value_type>(__vs, *this);
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 __val_expr<__indirect_expr<const valarray<_Tp>&> >
 valarray<_Tp>::operator[](valarray<size_t>&& __vs) const
 {
     return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__vs), *this));
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 indirect_array<_Tp>
 valarray<_Tp>::operator[](valarray<size_t>&& __vs)
 {
     return indirect_array<value_type>(move(__vs), *this);
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
if (__n)
                 static_cast<bool*>(_VSTD::__allocate(__n * sizeof(bool)));
         for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
             ::new (__r.__end_) bool(!*__p);
     }
     return __r;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator*=(const value_type& __x)
 {
     for (value_type* __p = __begin_; __p != __end_; ++__p)
         *__p *= __x;
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator/=(const value_type& __x)
 {
     for (value_type* __p = __begin_; __p != __end_; ++__p)
         *__p /= __x;
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator%=(const value_type& __x)
 {
     for (value_type* __p = __begin_; __p != __end_; ++__p)
         *__p %= __x;
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator+=(const value_type& __x)
 {
     for (value_type* __p = __begin_; __p != __end_; ++__p)
         *__p += __x;
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator-=(const value_type& __x)
 {
     for (value_type* __p = __begin_; __p != __end_; ++__p)
         *__p -= __x;
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator^=(const value_type& __x)
 {
     for (value_type* __p = __begin_; __p != __end_; ++__p)
         *__p ^= __x;
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator&=(const value_type& __x)
 {
     for (value_type* __p = __begin_; __p != __end_; ++__p)
         *__p &= __x;
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator|=(const value_type& __x)
 {
     for (value_type* __p = __begin_; __p != __end_; ++__p)
         *__p |= __x;
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator<<=(const value_type& __x)
 {
     for (value_type* __p = __begin_; __p != __end_; ++__p)
         *__p <<= __x;
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 valarray<_Tp>&
 valarray<_Tp>::operator>>=(const value_type& __x)
 {
     for (value_type* __p = __begin_; __p != __end_; ++__p)
         *__p >>= __x;
     return *this;
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     valarray<_Tp>&
 >::type
 valarray<_Tp>::operator*=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t *= __v[__i];
     return *this;
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     valarray<_Tp>&
 >::type
 valarray<_Tp>::operator/=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t /= __v[__i];
     return *this;
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     valarray<_Tp>&
 >::type
 valarray<_Tp>::operator%=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t %= __v[__i];
     return *this;
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     valarray<_Tp>&
 >::type
 valarray<_Tp>::operator+=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t += __v[__i];
     return *this;
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     valarray<_Tp>&
 >::type
 valarray<_Tp>::operator-=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t -= __v[__i];
     return *this;
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     valarray<_Tp>&
 >::type
 valarray<_Tp>::operator^=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t ^= __v[__i];
     return *this;
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     valarray<_Tp>&
 >::type
 valarray<_Tp>::operator|=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t |= __v[__i];
     return *this;
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     valarray<_Tp>&
 >::type
 valarray<_Tp>::operator&=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t &= __v[__i];
     return *this;
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     valarray<_Tp>&
 >::type
 valarray<_Tp>::operator<<=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t <<= __v[__i];
     return *this;
 }
 
 template <class _Tp>
 template <class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 typename enable_if
 <
     __is_val_expr<_Expr>::value,
     valarray<_Tp>&
 >::type
 valarray<_Tp>::operator>>=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t >>= __v[__i];
     return *this;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 valarray<_Tp>::swap(valarray& __v) _NOEXCEPT
 {
     _VSTD::swap(__begin_, __v.__begin_);
     _VSTD::swap(__end_, __v.__end_);
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _Tp
 valarray<_Tp>::sum() const
 {
     if (__begin_ == __end_)
         return value_type();
     const value_type* __p = __begin_;
     _Tp __r = *__p;
     for (++__p; __p != __end_; ++__p)
         __r += *__p;
     return __r;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _Tp
 valarray<_Tp>::min() const
 {
     if (__begin_ == __end_)
         return value_type();
     return *_VSTD::min_element(__begin_, __end_);
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 _Tp
 valarray<_Tp>::max() const
 {
     if (__begin_ == __end_)
         return value_type();
     return *_VSTD::max_element(__begin_, __end_);
 }
 

include/vector

#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
     const value_type* data() const _NOEXCEPT
         {return _VSTD::__to_raw_pointer(this->__begin_);}
 
     _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY void push_back(value_type&& __x);
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class... _Args>
+        _LIBCPP_INLINE_VISIBILITY
         void emplace_back(_Args&&... __args);
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     void pop_back();
 
     iterator insert(const_iterator __position, const_reference __x);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     iterator insert(const_iterator __position, value_type&& __x);
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class... _Args>
         iterator emplace(const_iterator __position, _Args&&... __args);

 #endif  // _LIBCPP_DEBUG_LEVEL >= 2
 
 private:
     _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
     void allocate(size_type __n);
     void deallocate() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY size_type __recommend(size_type __new_size) const;
     void __construct_at_end(size_type __n);
+    _LIBCPP_INLINE_VISIBILITY
     void __construct_at_end(size_type __n, const_reference __x);
     template <class _ForwardIterator>
         typename enable_if
         <
             __is_forward_iterator<_ForwardIterator>::value,
             void
         >::type
         __construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n);

 
 //  Copy constructs __n objects starting at __end_ from __x
 //  throws if construction throws
 //  Precondition:  __n > 0
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == old size() + __n
 //  Postcondition:  [i] == __x for all i in [size() - __n, __n)
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
 {
     allocator_type& __a = this->__alloc();
     do
     {
         __RAII_IncreaseAnnotator __annotator(*this);
         __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), __x);

 //    __v.emplace_back(_VSTD::forward<_Args>(__args)...);
     __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(__v.__end_), _VSTD::forward<_Args>(__args)...);
     __v.__end_++;
     __swap_out_circular_buffer(__v);
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 vector<_Tp, _Allocator>::emplace_back(_Args&&... __args)
 {
     if (this->__end_ < this->__end_cap())
     {
         __RAII_IncreaseAnnotator __annotator(*this);
         __alloc_traits::construct(this->__alloc(),
                                   _VSTD::__to_raw_pointer(this->__end_),
                                   _VSTD::forward<_Args>(__args)...);
         __annotator.__done();
         ++this->__end_;
     }
     else
         __emplace_back_slow_path(_VSTD::forward<_Args>(__args)...);
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline
 void
 vector<_Tp, _Allocator>::pop_back()
 {
     _LIBCPP_ASSERT(!empty(), "vector::pop_back called for empty vector");
     this->__destruct_at_end(this->__end_ - 1);
 }
 
 template <class _Tp, class _Allocator>