diff --git a/libcxx/include/string b/libcxx/include/string
index 3056a6b..92f0ed1 100644
--- a/libcxx/include/string
+++ b/libcxx/include/string
@@ -1028,33 +1028,43 @@
 public:
     static const size_type npos = -1;
 
-    basic_string();
-    explicit basic_string(const allocator_type& __a);
+    _LIBCPP_INLINE_VISIBILITY basic_string();
+    _LIBCPP_INLINE_VISIBILITY explicit basic_string(const allocator_type& __a);
     basic_string(const basic_string& __str);
     basic_string(const basic_string& __str, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     basic_string(basic_string&& __str);
     basic_string(basic_string&& __str, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    basic_string(const_pointer __s);
+    _LIBCPP_INLINE_VISIBILITY basic_string(const_pointer __s);
+    _LIBCPP_INLINE_VISIBILITY
     basic_string(const_pointer __s, const allocator_type& __a);
+    _LIBCPP_INLINE_VISIBILITY
     basic_string(const_pointer __s, size_type __n);
+    _LIBCPP_INLINE_VISIBILITY
     basic_string(const_pointer __s, size_type __n, const allocator_type& __a);
+    _LIBCPP_INLINE_VISIBILITY
     basic_string(size_type __n, value_type __c);
+    _LIBCPP_INLINE_VISIBILITY
     basic_string(size_type __n, value_type __c, const allocator_type& __a);
     basic_string(const basic_string& __str, size_type __pos, size_type __n = npos,
                  const allocator_type& __a = allocator_type());
     template<class _InputIterator>
+        _LIBCPP_INLINE_VISIBILITY
         basic_string(_InputIterator __first, _InputIterator __last);
     template<class _InputIterator>
+        _LIBCPP_INLINE_VISIBILITY
         basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a);
+    _LIBCPP_INLINE_VISIBILITY
     basic_string(initializer_list<value_type> __il);
+    _LIBCPP_INLINE_VISIBILITY
     basic_string(initializer_list<value_type> __il, const allocator_type& __a);
 
     ~basic_string();
 
     basic_string& operator=(const basic_string& __str);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_string& operator=(basic_string&& __str);
 #endif
     _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const_pointer __s)         {return assign(__s);}
@@ -1086,7 +1096,7 @@
     _LIBCPP_INLINE_VISIBILITY size_type size() const
         {return __is_long() ? __get_long_size() : __get_short_size();}
     _LIBCPP_INLINE_VISIBILITY size_type length() const {return size();}
-    size_type max_size() const;
+    _LIBCPP_INLINE_VISIBILITY size_type max_size() const;
     _LIBCPP_INLINE_VISIBILITY size_type capacity() const
         {return (__is_long() ? __get_long_cap() : __min_cap) - 1;}
 
@@ -1096,6 +1106,7 @@
     void reserve(size_type res_arg = 0);
     _LIBCPP_INLINE_VISIBILITY
     void shrink_to_fit() {reserve();}
+    _LIBCPP_INLINE_VISIBILITY
     void clear();
     _LIBCPP_INLINE_VISIBILITY bool empty() const {return size() == 0;}
 
@@ -1110,6 +1121,7 @@
     _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(value_type __c)            {push_back(__c); return *this;}
     _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(initializer_list<value_type> __il) {return append(__il);}
 
+    _LIBCPP_INLINE_VISIBILITY
     basic_string& append(const basic_string& __str);
     basic_string& append(const basic_string& __str, size_type __pos, size_type __n);
     basic_string& append(const_pointer __s, size_type __n);
@@ -1134,12 +1146,14 @@
     basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}
 
     void push_back(value_type __c);
+    _LIBCPP_INLINE_VISIBILITY
     void pop_back();
-    reference       front();
-    const_reference front() const;
-    reference       back();
-    const_reference back() 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;
 
+    _LIBCPP_INLINE_VISIBILITY
     basic_string& assign(const basic_string& __str);
     basic_string& assign(const basic_string& __str, size_type __pos, size_type __n);
     basic_string& assign(const_pointer __s, size_type __n);
@@ -1163,12 +1177,14 @@
     _LIBCPP_INLINE_VISIBILITY
     basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
 
+    _LIBCPP_INLINE_VISIBILITY
     basic_string& insert(size_type __pos1, const basic_string& __str);
     basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n);
     basic_string& insert(size_type __pos, const_pointer __s, size_type __n);
     basic_string& insert(size_type __pos, const_pointer __s);
     basic_string& insert(size_type __pos, size_type __n, value_type __c);
     iterator      insert(const_iterator __pos, value_type __c);
+    _LIBCPP_INLINE_VISIBILITY
     iterator      insert(const_iterator __pos, size_type __n, value_type __c);
     template<class _InputIterator>
         typename enable_if
@@ -1190,17 +1206,24 @@
                     {return insert(__pos, __il.begin(), __il.end());}
 
     basic_string& erase(size_type __pos = 0, size_type __n = npos);
+    _LIBCPP_INLINE_VISIBILITY
     iterator      erase(const_iterator __pos);
+    _LIBCPP_INLINE_VISIBILITY
     iterator      erase(const_iterator __first, const_iterator __last);
 
+    _LIBCPP_INLINE_VISIBILITY
     basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str);
     basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2);
     basic_string& replace(size_type __pos, size_type __n1, const_pointer __s, size_type __n2);
     basic_string& replace(size_type __pos, size_type __n1, const_pointer __s);
     basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c);
+    _LIBCPP_INLINE_VISIBILITY
     basic_string& replace(const_iterator __i1, const_iterator __i2, const basic_string& __str);
+    _LIBCPP_INLINE_VISIBILITY
     basic_string& replace(const_iterator __i1, const_iterator __i2, const_pointer __s, size_type __n);
+    _LIBCPP_INLINE_VISIBILITY
     basic_string& replace(const_iterator __i1, const_iterator __i2, const_pointer __s);
+    _LIBCPP_INLINE_VISIBILITY
     basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c);
     template<class _InputIterator>
         typename enable_if
@@ -1214,8 +1237,10 @@
         {return replace(__i1, __i2, __il.begin(), __il.end());}
 
     size_type copy(pointer __s, size_type __n, size_type __pos = 0) const;
+    _LIBCPP_INLINE_VISIBILITY
     basic_string substr(size_type __pos = 0, size_type __n = npos) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     void swap(basic_string& __str);
 
     _LIBCPP_INLINE_VISIBILITY const_pointer c_str() const {return data();}
@@ -1223,44 +1248,62 @@
 
     _LIBCPP_INLINE_VISIBILITY allocator_type get_allocator() const {return __alloc();}
 
+    _LIBCPP_INLINE_VISIBILITY
     size_type find(const basic_string& __str, size_type __pos = 0) const;
     size_type find(const_pointer __s, size_type __pos, size_type __n) const;
+    _LIBCPP_INLINE_VISIBILITY
     size_type find(const_pointer __s, size_type __pos = 0) const;
     size_type find(value_type __c, size_type __pos = 0) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     size_type rfind(const basic_string& __str, size_type __pos = npos) const;
     size_type rfind(const_pointer __s, size_type __pos, size_type __n) const;
+    _LIBCPP_INLINE_VISIBILITY
     size_type rfind(const_pointer __s, size_type __pos = npos) const;
     size_type rfind(value_type __c, size_type __pos = npos) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     size_type find_first_of(const basic_string& __str, size_type __pos = 0) const;
     size_type find_first_of(const_pointer __s, size_type __pos, size_type __n) const;
+    _LIBCPP_INLINE_VISIBILITY
     size_type find_first_of(const_pointer __s, size_type __pos = 0) const;
+    _LIBCPP_INLINE_VISIBILITY
     size_type find_first_of(value_type __c, size_type __pos = 0) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     size_type find_last_of(const basic_string& __str, size_type __pos = npos) const;
     size_type find_last_of(const_pointer __s, size_type __pos, size_type __n) const;
+    _LIBCPP_INLINE_VISIBILITY
     size_type find_last_of(const_pointer __s, size_type __pos = npos) const;
+    _LIBCPP_INLINE_VISIBILITY
     size_type find_last_of(value_type __c, size_type __pos = npos) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const;
     size_type find_first_not_of(const_pointer __s, size_type __pos, size_type __n) const;
+    _LIBCPP_INLINE_VISIBILITY
     size_type find_first_not_of(const_pointer __s, size_type __pos = 0) const;
+    _LIBCPP_INLINE_VISIBILITY
     size_type find_first_not_of(value_type __c, size_type __pos = 0) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const;
     size_type find_last_not_of(const_pointer __s, size_type __pos, size_type __n) const;
+    _LIBCPP_INLINE_VISIBILITY
     size_type find_last_not_of(const_pointer __s, size_type __pos = npos) const;
+    _LIBCPP_INLINE_VISIBILITY
     size_type find_last_not_of(value_type __c, size_type __pos = npos) const;
 
+    _LIBCPP_INLINE_VISIBILITY
     int compare(const basic_string& __str) const;
+    _LIBCPP_INLINE_VISIBILITY
     int compare(size_type __pos1, size_type __n1, const basic_string& __str) const;
     int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2) const;
     int compare(const_pointer __s) const;
     int compare(size_type __pos1, size_type __n1, const_pointer __s) const;
     int compare(size_type __pos1, size_type __n1, const_pointer __s, size_type __n2) const;
 
-    bool __invariants() const;
+    _LIBCPP_INLINE_VISIBILITY bool __invariants() const;
 private:
     _LIBCPP_INLINE_VISIBILITY allocator_type&       __alloc()       {return __r_.second();}
     _LIBCPP_INLINE_VISIBILITY const allocator_type& __alloc() const {return __r_.second();}
@@ -1338,6 +1381,7 @@
                                size_type __n_copy,  size_type __n_del,
                                size_type __n_add, const_pointer __p_new_stuff);
 
+    _LIBCPP_INLINE_VISIBILITY
     void __erase_to_end(size_type __pos);
 
     _LIBCPP_INLINE_VISIBILITY
@@ -1361,7 +1405,9 @@
         {}
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     void __move_assign(basic_string& __str, false_type);
+    _LIBCPP_INLINE_VISIBILITY
     void __move_assign(basic_string& __str, true_type);
 #endif
 
@@ -1380,8 +1426,8 @@
     static void __swap_alloc(allocator_type& __x, allocator_type& __y, false_type)
         {}
 
-    void __invalidate_all_iterators();
-    void __invalidate_iterators_past(size_type);
+    _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
+    _LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(size_type);
 
     friend basic_string operator+<>(const basic_string&, const basic_string&);
     friend basic_string operator+<>(const value_type*, const basic_string&);
@@ -1741,7 +1787,6 @@
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
 basic_string<_CharT, _Traits, _Allocator>::~basic_string()
 {
     __invalidate_all_iterators();
@@ -3204,6 +3249,7 @@
 // __invariants
 
 template<class _CharT, class _Traits, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
 bool
 basic_string<_CharT, _Traits, _Allocator>::__invariants() const
 {