Tagging 15

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/tags/libcpp-15@125667 91177308-0d34-0410-b5e6-96231b3b80d8
Change install name to libc++.1.dylib
2011-02-16 17:23:15 +00:00 · 2011-02-16 00:40:06 +00:00 · 2011-02-14 19:12:38 +00:00 · 2011-02-14 18:06:10 +00:00 · 2011-02-10 21:34:42 +00:00 · 2011-02-10 17:46:03 +00:00
53 changed files with 717 additions and 486 deletions
--- a/CREDITS.TXT
+++ b/CREDITS.TXT
@@ -12,4 +12,7 @@ N: Howard Hinnant
 E: hhinnant@apple.com
 D: Architect and primary author of libc++

-
+N: Marshall Clow
+E: marshall@idio.com
+E: mclow@qualcomm.com
+D: Minor patches and bug fixes.
--- a/include/__config
+++ b/include/__config
@@ -148,22 +148,15 @@ typedef __char32_t char32_t;
 #define _LIBCPP_HAS_NO_TRAILING_RETURN
 #endif

-#if __has_feature(cxx_inline_namespaces)
+// Inline namespaces are available in Clang regardless of C++ dialect.
 #define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {inline namespace _LIBCPP_NAMESPACE {
 #define _LIBCPP_END_NAMESPACE_STD  } }
 #define _STD std::_LIBCPP_NAMESPACE

 namespace std {
-inline namespace _LIBCPP_NAMESPACE {
+  inline namespace _LIBCPP_NAMESPACE {
+  }
 }
-using namespace _LIBCPP_NAMESPACE;
-}
-
-#else  // __has_feature(cxx_inline_namespaces)
-#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {
-#define _LIBCPP_END_NAMESPACE_STD }
-#define _STD std
-#endif  // __has_feature(cxx_inline_namespaces)

 #if !(__has_feature(cxx_constexpr))
 #define _LIBCPP_HAS_NO_CONSTEXPR
--- a/include/__hash_table
+++ b/include/__hash_table
@@ -85,7 +85,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY
        reference operator*() const {return __node_->__value_;}
    _LIBCPP_INLINE_VISIBILITY
-        pointer operator->() const {return addressof(__node_->__value_);}
+        pointer operator->() const {return _STD::addressof(__node_->__value_);}

    _LIBCPP_INLINE_VISIBILITY
    __hash_iterator& operator++()
@@ -163,7 +163,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY
        reference operator*() const {return __node_->__value_;}
    _LIBCPP_INLINE_VISIBILITY
-        pointer operator->() const {return addressof(__node_->__value_);}
+        pointer operator->() const {return _STD::addressof(__node_->__value_);}

    _LIBCPP_INLINE_VISIBILITY
    __hash_const_iterator& operator++()
@@ -433,7 +433,7 @@ public:
    void operator()(pointer __p)
    {
        if (__value_constructed)
-            __alloc_traits::destroy(__na_, addressof(__p->__value_));
+            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_));
        if (__p)
            __alloc_traits::deallocate(__na_, __p, 1);
    }
@@ -798,7 +798,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u)
    if (size() > 0)
    {
        __bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
-            static_cast<__node_pointer>(addressof(__p1_.first()));
+            static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
        __u.__p1_.first().__next_ = nullptr;
        __u.size() = 0;
    }
@@ -822,7 +822,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
            __p1_.first().__next_ = __u.__p1_.first().__next_;
            __u.__p1_.first().__next_ = nullptr;
            __bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
-                static_cast<__node_pointer>(addressof(__p1_.first()));
+                static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
            size() = __u.size();
            __u.size() = 0;
        }
@@ -875,7 +875,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate(__node_pointer __np)
    while (__np != nullptr)
    {
        __node_pointer __next = __np->__next_;
-        __node_traits::destroy(__na, addressof(__np->__value_));
+        __node_traits::destroy(__na, _STD::addressof(__np->__value_));
        __node_traits::deallocate(__na, __np, 1);
        __np = __next;
    }
@@ -914,7 +914,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
    if (size() > 0)
    {
        __bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
-            static_cast<__node_pointer>(addressof(__p1_.first()));
+            static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
        __u.__p1_.first().__next_ = nullptr;
        __u.size() = 0;
    }
@@ -1131,7 +1131,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __
        __node_pointer __pn = __bucket_list_[__chash];
        if (__pn == nullptr)
        {
-            __pn = static_cast<__node_pointer>(addressof(__p1_.first()));
+            __pn = static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
            __nd->__next_ = __pn->__next_;
            __pn->__next_ = __nd;
            // fix up __bucket_list_
@@ -1169,7 +1169,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(__node_pointer __c
    __node_pointer __pn = __bucket_list_[__chash];
    if (__pn == nullptr)
    {
-        __pn = static_cast<__node_pointer>(addressof(__p1_.first()));
+        __pn = static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
        __cp->__next_ = __pn->__next_;
        __pn->__next_ = __cp;
        // fix up __bucket_list_
@@ -1275,7 +1275,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(const value_type& __x)
        __node_pointer __pn = __bucket_list_[__chash];
        if (__pn == nullptr)
        {
-            __pn = static_cast<__node_pointer>(addressof(__p1_.first()));
+            __pn = static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
            __h->__next_ = __pn->__next_;
            __pn->__next_ = __h.get();
            // fix up __bucket_list_
@@ -1433,7 +1433,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__rehash(size_type __nbc)
    {
        for (size_type __i = 0; __i < __nbc; ++__i)
            __bucket_list_[__i] = nullptr;
-        __node_pointer __pp(static_cast<__node_pointer>(addressof(__p1_.first())));
+        __node_pointer __pp(static_cast<__node_pointer>(_STD::addressof(__p1_.first())));
        __node_pointer __cp = __pp->__next_;
        if (__cp != nullptr)
        {
@@ -1533,7 +1533,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&& ...__args)
 {
    __node_allocator& __na = __node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_), _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_Args>(__args)...);
    __h.get_deleter().__value_constructed = true;
    __h->__hash_ = hash_function()(__h->__value_);
    __h->__next_ = nullptr;
@@ -1549,7 +1549,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(value_type&& __v,
 {
    __node_allocator& __na = __node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_), _STD::move(__v));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::move(__v));
    __h.get_deleter().__value_constructed = true;
    __h->__hash_ = __hash;
    __h->__next_ = nullptr;
@@ -1564,7 +1564,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const value_type& __v
 {
    __node_allocator& __na = __node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_), __v);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
    __h.get_deleter().__value_constructed = true;
    __h->__hash_ = hash_function()(__h->__value_);
    __h->__next_ = nullptr;
@@ -1580,7 +1580,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const value_type& __v
 {
    __node_allocator& __na = __node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_), __v);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
    __h.get_deleter().__value_constructed = true;
    __h->__hash_ = __hash;
    __h->__next_ = nullptr;
@@ -1658,7 +1658,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p)
    // Fix up __bucket_list_
        // if __pn is not in same bucket (before begin is not in same bucket) &&
        //    if __cn->__next_ is not in same bucket (nullptr is not in same bucket)
-    if (__pn == addressof(__p1_.first()) || __pn->__hash_ % __bc != __chash)
+    if (__pn == _STD::addressof(__p1_.first()) || __pn->__hash_ % __bc != __chash)
    {
        if (__cn->__next_ == nullptr || __cn->__next_->__hash_ % __bc != __chash)
            __bucket_list_[__chash] = nullptr;
@@ -1791,10 +1791,10 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::swap(__hash_table& __u)
    __p3_.swap(__u.__p3_);
    if (size() > 0)
        __bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
-            static_cast<__node_pointer>(addressof(__p1_.first()));
+            static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
    if (__u.size() > 0)
        __u.__bucket_list_[__u.__p1_.first().__next_->__hash_ % __u.bucket_count()] =
-            static_cast<__node_pointer>(addressof(__u.__p1_.first()));
+            static_cast<__node_pointer>(_STD::addressof(__u.__p1_.first()));
 }

 template <class _Tp, class _Hash, class _Equal, class _Alloc>
--- a/include/__split_buffer
+++ b/include/__split_buffer
@@ -98,11 +98,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY void pop_back() {__destruct_at_end(__end_-1);}

    void __construct_at_end(size_type __n);
-        void __construct_at_end(size_type __n, false_type);
-        void __construct_at_end(size_type __n, true_type);
    void __construct_at_end(size_type __n, const_reference __x);
-        void __construct_at_end(size_type __n, const_reference __x, false_type);
-        void __construct_at_end(size_type __n, const_reference __x, true_type);
    template <class _InputIter>
        typename enable_if
        <
@@ -192,16 +188,8 @@ __split_buffer<_Tp, _Allocator>::__invariants() const
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == size() + __n
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
 void
 __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
-{
-    __construct_at_end(__n, __is_zero_default_constructible<value_type>());
-}
-
-template <class _Tp, class _Allocator>
-void
-__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, false_type)
 {
    __alloc_rr& __a = this->__alloc();
    do
@@ -212,15 +200,6 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, false_type)
    } while (__n > 0);
 }

-template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
-void
-__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, true_type)
-{
-    _STD::memset(this->__end_, 0, __n*sizeof(value_type));
-    this->__end_ += __n;
-}
-
 //  Copy constructs __n objects starting at __end_ from __x
 //  throws if construction throws
 //  Precondition:  __n > 0
@@ -228,17 +207,8 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, true_type)
 //  Postcondition:  size() == old size() + __n
 //  Postcondition:  [i] == __x for all i in [size() - __n, __n)
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
 void
 __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
-{
-    __construct_at_end(__n, __x, integral_constant<bool, is_trivially_copy_constructible<value_type>::value &&
-                                                         is_trivially_copy_assignable<value_type>::value>());
-}
-
-template <class _Tp, class _Allocator>
-void
-__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x, false_type)
 {
    __alloc_rr& __a = this->__alloc();
    do
@@ -249,15 +219,6 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_referen
    } while (__n > 0);
 }

-template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
-void
-__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x, true_type)
-{
-    _STD::fill_n(this->__end_, __n, __x);
-    this->__end_ += __n;
-}
-
 template <class _Tp, class _Allocator>
 template <class _InputIter>
 typename enable_if
--- a/include/__std_stream
+++ b/include/__std_stream
@@ -97,7 +97,7 @@ typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::__getchar(bool __consume)
 {
    char __extbuf[__limit];
-    int __nread = max(1, __encoding_);
+    int __nread = _STD::max(1, __encoding_);
    for (int __i = 0; __i < __nread; ++__i)
    {
        char __c = getc(__file_);
--- a/include/__tree
+++ b/include/__tree
@@ -523,7 +523,7 @@ public:
    void operator()(pointer __p)
    {
        if (__value_constructed)
-            __alloc_traits::destroy(__na_, addressof(__p->__value_));
+            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_));
        if (__p)
            __alloc_traits::deallocate(__na_, __p, 1);
    }
@@ -1373,7 +1373,7 @@ __tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd)
        destroy(static_cast<__node_pointer>(__nd->__left_));
        destroy(static_cast<__node_pointer>(__nd->__right_));
        __node_allocator& __na = __node_alloc();
-        __node_traits::destroy(__na, addressof(__nd->__value_));
+        __node_traits::destroy(__na, _STD::addressof(__nd->__value_));
        __node_traits::deallocate(__na, __nd, 1);
    }
 }
@@ -1655,7 +1655,7 @@ __tree<_Tp, _Compare, _Allocator>::__construct_node(_Args&& ...__args)
 {
    __node_allocator& __na = __node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_), _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_Args>(__args)...);
    __h.get_deleter().__value_constructed = true;
    return __h;
 }
@@ -1791,7 +1791,7 @@ __tree<_Tp, _Compare, _Allocator>::__construct_node(const value_type& __v)
 {
    __node_allocator& __na = __node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_), __v);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
    __h.get_deleter().__value_constructed = true;
    return _STD::move(__h);
 }
@@ -1919,7 +1919,7 @@ __tree<_Tp, _Compare, _Allocator>::erase(const_iterator __p)
        __begin_node() = __r.__ptr_;
    --size();
    __node_allocator& __na = __node_alloc();
-    __node_traits::destroy(__na, const_cast<value_type*>(addressof(*__p)));
+    __node_traits::destroy(__na, const_cast<value_type*>(_STD::addressof(*__p)));
    __tree_remove(__end_node()->__left_,
                  static_cast<__node_base_pointer>(__np));
    __node_traits::deallocate(__na, __np, 1);
--- a/include/__tuple
+++ b/include/__tuple
@@ -72,20 +72,20 @@ template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {
 template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {};
 template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp> {};

-template <class... _Tp> struct __tuple_like<tuple<_Tp...>> : true_type {};
+template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
 template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
 template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};

 template <size_t _Ip, class ..._Tp>
-typename tuple_element<_Ip, tuple<_Tp...>>::type&
+typename tuple_element<_Ip, tuple<_Tp...> >::type&
 get(tuple<_Tp...>&);

 template <size_t _Ip, class ..._Tp>
-const typename tuple_element<_Ip, tuple<_Tp...>>::type&
+const typename tuple_element<_Ip, tuple<_Tp...> >::type&
 get(const tuple<_Tp...>&);

 template <size_t _Ip, class ..._Tp>
-typename tuple_element<_Ip, tuple<_Tp...>>::type&&
+typename tuple_element<_Ip, tuple<_Tp...> >::type&&
 get(tuple<_Tp...>&&);

 template <size_t _Ip, class _T1, class _T2>
@@ -143,7 +143,7 @@ struct __make_tuple_indices
 template <class ..._Tp> struct __tuple_types {};

 template <size_t _Ip>
-class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<>>
+class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<> >
 {
 public:
    static_assert(_Ip == 0, "tuple_element index out of range");
@@ -151,26 +151,26 @@ public:
 };

 template <class _Hp, class ..._Tp>
-class _LIBCPP_VISIBLE tuple_element<0, __tuple_types<_Hp, _Tp...>>
+class _LIBCPP_VISIBLE tuple_element<0, __tuple_types<_Hp, _Tp...> >
 {
 public:
    typedef _Hp type;
 };

 template <size_t _Ip, class _Hp, class ..._Tp>
-class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<_Hp, _Tp...>>
+class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<_Hp, _Tp...> >
 {
 public:
-    typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...>>::type type;
+    typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...> >::type type;
 };

 template <class ..._Tp>
-class _LIBCPP_VISIBLE tuple_size<__tuple_types<_Tp...>>
+class _LIBCPP_VISIBLE tuple_size<__tuple_types<_Tp...> >
    : public integral_constant<size_t, sizeof...(_Tp)>
 {
 };

-template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...>> : true_type {};
+template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {};

 // __make_tuple_types

@@ -212,13 +212,13 @@ template <bool, class _Tp, class _Up>
 struct __tuple_convertible_imp : public false_type {};

 template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
-struct __tuple_convertible_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...>>
+struct __tuple_convertible_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
    : public integral_constant<bool,
                               is_convertible<_Tp0, _Up0>::value &&
-                               __tuple_convertible_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...>>::value> {};
+                               __tuple_convertible_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};

 template <>
-struct __tuple_convertible_imp<true, __tuple_types<>, __tuple_types<>>
+struct __tuple_convertible_imp<true, __tuple_types<>, __tuple_types<> >
    : public true_type {};

 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
@@ -239,13 +239,13 @@ template <bool, class _Tp, class _Up>
 struct __tuple_assignable_imp : public false_type {};

 template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
-struct __tuple_assignable_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...>>
+struct __tuple_assignable_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
    : public integral_constant<bool,
                               is_assignable<_Up0&, _Tp0>::value &&
-                               __tuple_assignable_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...>>::value> {};
+                               __tuple_assignable_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};

 template <>
-struct __tuple_assignable_imp<true, __tuple_types<>, __tuple_types<>>
+struct __tuple_assignable_imp<true, __tuple_types<>, __tuple_types<> >
    : public true_type {};

 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
--- a/include/algorithm
+++ b/include/algorithm
@@ -1573,7 +1573,7 @@ typename enable_if
 >::type
 copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
 {
-    return copy(__first, __first + __n, __result);
+    return _STD::copy(__first, __first + __n, __result);
 }

 // move
--- a/include/deque
+++ b/include/deque
@@ -603,7 +603,7 @@ copy_backward(_RAIter __f,
    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
    while (__f != __l)
    {
-        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = prev(__r);
+        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _STD::prev(__r);
        pointer __rb = *__rp.__m_iter_;
        pointer __re = __rp.__ptr_ + 1;
        difference_type __bs = __re - __rb;
@@ -776,7 +776,7 @@ move_backward(_RAIter __f,
    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
    while (__f != __l)
    {
-        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = prev(__r);
+        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _STD::prev(__r);
        pointer __rb = *__rp.__m_iter_;
        pointer __re = __rp.__ptr_ + 1;
        difference_type __bs = __re - __rb;
@@ -1116,7 +1116,7 @@ __deque_base<_Tp, _Allocator>::clear()
 {
    allocator_type& __a = __alloc();
    for (iterator __i = begin(), __e = end(); __i != __e; ++__i)
-        __alloc_traits::destroy(__a, addressof(*__i));
+        __alloc_traits::destroy(__a, _STD::addressof(*__i));
    size() = 0;
    while (__map_.size() > 2)
    {
@@ -1675,7 +1675,7 @@ deque<_Tp, _Allocator>::push_back(const value_type& __v)
    if (__back_spare() == 0)
        __add_back_capacity();
    // __back_spare() >= 1
-    __alloc_traits::construct(__a, addressof(*__base::end()), __v);
+    __alloc_traits::construct(__a, _STD::addressof(*__base::end()), __v);
    ++__base::size();
 }

@@ -1689,7 +1689,7 @@ deque<_Tp, _Allocator>::push_back(value_type&& __v)
    if (__back_spare() == 0)
        __add_back_capacity();
    // __back_spare() >= 1
-    __alloc_traits::construct(__a, addressof(*__base::end()), _STD::move(__v));
+    __alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::move(__v));
    ++__base::size();
 }

@@ -1704,7 +1704,7 @@ deque<_Tp, _Allocator>::emplace_back(_Args&&... __args)
    if (__back_spare() == 0)
        __add_back_capacity();
    // __back_spare() >= 1
-    __alloc_traits::construct(__a, addressof(*__base::end()), _STD::forward<_Args>(__args)...);
+    __alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::forward<_Args>(__args)...);
    ++__base::size();
 }

@@ -1719,7 +1719,7 @@ deque<_Tp, _Allocator>::push_front(const value_type& __v)
    if (__front_spare() == 0)
        __add_front_capacity();
    // __front_spare() >= 1
-    __alloc_traits::construct(__a, addressof(*--__base::begin()), __v);
+    __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), __v);
    --__base::__start_;
    ++__base::size();
 }
@@ -1734,7 +1734,7 @@ deque<_Tp, _Allocator>::push_front(value_type&& __v)
    if (__front_spare() == 0)
        __add_front_capacity();
    // __front_spare() >= 1
-    __alloc_traits::construct(__a, addressof(*--__base::begin()), _STD::move(__v));
+    __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::move(__v));
    --__base::__start_;
    ++__base::size();
 }
@@ -1750,7 +1750,7 @@ deque<_Tp, _Allocator>::emplace_front(_Args&&... __args)
    if (__front_spare() == 0)
        __add_front_capacity();
    // __front_spare() >= 1
-    __alloc_traits::construct(__a, addressof(*--__base::begin()), _STD::forward<_Args>(__args)...);
+    __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::forward<_Args>(__args)...);
    --__base::__start_;
    ++__base::size();
 }
@@ -1772,7 +1772,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
        // __front_spare() >= 1
        if (__pos == 0)
        {
-            __alloc_traits::construct(__a, addressof(*--__base::begin()), __v);
+            __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), __v);
            --__base::__start_;
            ++__base::size();
        }
@@ -1780,10 +1780,10 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
        {
            const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
            iterator __b = __base::begin();
-            iterator __bm1 = prev(__b);
+            iterator __bm1 = _STD::prev(__b);
            if (__vt == pointer_traits<const_pointer>::pointer_to(*__b))
                __vt = pointer_traits<const_pointer>::pointer_to(*__bm1);
-            __alloc_traits::construct(__a, addressof(*__bm1), _STD::move(*__b));
+            __alloc_traits::construct(__a, _STD::addressof(*__bm1), _STD::move(*__b));
            --__base::__start_;
            ++__base::size();
            if (__pos > 1)
@@ -1799,17 +1799,17 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
        size_type __de = __base::size() - __pos;
        if (__de == 0)
        {
-            __alloc_traits::construct(__a, addressof(*__base::end()), __v);
+            __alloc_traits::construct(__a, _STD::addressof(*__base::end()), __v);
            ++__base::size();
        }
        else
        {
            const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
            iterator __e = __base::end();
-            iterator __em1 = prev(__e);
+            iterator __em1 = _STD::prev(__e);
            if (__vt == pointer_traits<const_pointer>::pointer_to(*__em1))
                __vt = pointer_traits<const_pointer>::pointer_to(*__e);
-            __alloc_traits::construct(__a, addressof(*__e), _STD::move(*__em1));
+            __alloc_traits::construct(__a, _STD::addressof(*__e), _STD::move(*__em1));
            ++__base::size();
            if (__de > 1)
                __e = __move_backward_and_check(__e - __de, __em1, __e, __vt);
@@ -1835,15 +1835,15 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
        // __front_spare() >= 1
        if (__pos == 0)
        {
-            __alloc_traits::construct(__a, addressof(*--__base::begin()), _STD::move(__v));
+            __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::move(__v));
            --__base::__start_;
            ++__base::size();
        }
        else
        {
            iterator __b = __base::begin();
-            iterator __bm1 = prev(__b);
-            __alloc_traits::construct(__a, addressof(*__bm1), _STD::move(*__b));
+            iterator __bm1 = _STD::prev(__b);
+            __alloc_traits::construct(__a, _STD::addressof(*__bm1), _STD::move(*__b));
            --__base::__start_;
            ++__base::size();
            if (__pos > 1)
@@ -1859,14 +1859,14 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
        size_type __de = __base::size() - __pos;
        if (__de == 0)
        {
-            __alloc_traits::construct(__a, addressof(*__base::end()), _STD::move(__v));
+            __alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::move(__v));
            ++__base::size();
        }
        else
        {
            iterator __e = __base::end();
-            iterator __em1 = prev(__e);
-            __alloc_traits::construct(__a, addressof(*__e), _STD::move(*__em1));
+            iterator __em1 = _STD::prev(__e);
+            __alloc_traits::construct(__a, _STD::addressof(*__e), _STD::move(*__em1));
            ++__base::size();
            if (__de > 1)
                __e = _STD::move_backward(__e - __de, __em1, __e);
@@ -1893,15 +1893,15 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
        // __front_spare() >= 1
        if (__pos == 0)
        {
-            __alloc_traits::construct(__a, addressof(*--__base::begin()), _STD::forward<_Args>(__args)...);
+            __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::forward<_Args>(__args)...);
            --__base::__start_;
            ++__base::size();
        }
        else
        {
            iterator __b = __base::begin();
-            iterator __bm1 = prev(__b);
-            __alloc_traits::construct(__a, addressof(*__bm1), _STD::move(*__b));
+            iterator __bm1 = _STD::prev(__b);
+            __alloc_traits::construct(__a, _STD::addressof(*__bm1), _STD::move(*__b));
            --__base::__start_;
            ++__base::size();
            if (__pos > 1)
@@ -1917,14 +1917,14 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
        size_type __de = __base::size() - __pos;
        if (__de == 0)
        {
-            __alloc_traits::construct(__a, addressof(*__base::end()), _STD::forward<_Args>(__args)...);
+            __alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::forward<_Args>(__args)...);
            ++__base::size();
        }
        else
        {
            iterator __e = __base::end();
-            iterator __em1 = prev(__e);
-            __alloc_traits::construct(__a, addressof(*__e), _STD::move(*__em1));
+            iterator __em1 = _STD::prev(__e);
+            __alloc_traits::construct(__a, _STD::addressof(*__e), _STD::move(*__em1));
            ++__base::size();
            if (__de > 1)
                __e = _STD::move_backward(__e - __de, __em1, __e);
@@ -1955,7 +1955,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_ty
        if (__n > __pos)
        {
            for (size_type __m = __n - __pos; __m; --__m, --__base::__start_, ++__base::size())
-                __alloc_traits::construct(__a, addressof(*--__i), __v);
+                __alloc_traits::construct(__a, _STD::addressof(*--__i), __v);
            __n = __pos;
        }
        if (__n > 0)
@@ -1981,7 +1981,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_ty
        if (__n > __de)
        {
            for (size_type __m = __n - __de; __m; --__m, ++__i, ++__base::size())
-                __alloc_traits::construct(__a, addressof(*__i), __v);
+                __alloc_traits::construct(__a, _STD::addressof(*__i), __v);
            __n = __de;
        }
        if (__n > 0)
@@ -2033,7 +2033,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
        {
            __m = __pos < __n / 2 ? _STD::prev(__l, __pos) : _STD::next(__f, __n - __pos);
            for (_BiIter __j = __m; __j != __f; --__base::__start_, ++__base::size())
-                __alloc_traits::construct(__a, addressof(*--__i), *--__j);
+                __alloc_traits::construct(__a, _STD::addressof(*--__i), *--__j);
            __n = __pos;
        }
        if (__n > 0)
@@ -2041,7 +2041,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
            iterator __obn = __old_begin + __n;
            for (iterator __j = __obn; __j != __old_begin;)
            {
-                __alloc_traits::construct(__a, addressof(*--__i), _STD::move(*--__j));
+                __alloc_traits::construct(__a, _STD::addressof(*--__i), _STD::move(*--__j));
                --__base::__start_;
                ++__base::size();
            }
@@ -2065,14 +2065,14 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
        {
            __m = __de < __n / 2 ? _STD::next(__f, __de) : _STD::prev(__l, __n - __de);
            for (_BiIter __j = __m; __j != __l; ++__i, ++__j, ++__base::size())
-                __alloc_traits::construct(__a, addressof(*__i), *__j);
+                __alloc_traits::construct(__a, _STD::addressof(*__i), *__j);
            __n = __de;
        }
        if (__n > 0)
        {
            iterator __oen = __old_end - __n;
            for (iterator __j = __oen; __j != __old_end; ++__i, ++__j, ++__base::size())
-                __alloc_traits::construct(__a, addressof(*__i), _STD::move(*__j));
+                __alloc_traits::construct(__a, _STD::addressof(*__i), _STD::move(*__j));
            if (__n < __de)
                __old_end = _STD::move_backward(__old_end - __de, __oen, __old_end);
            _STD::copy_backward(__f, __m, __old_end);
@@ -2105,7 +2105,7 @@ deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
        __add_back_capacity(__n - __back_capacity);
    // __n <= __back_capacity
    for (iterator __i = __base::end(); __f != __l; ++__i, ++__f, ++__base::size())
-        __alloc_traits::construct(__a, addressof(*__i), *__f);
+        __alloc_traits::construct(__a, _STD::addressof(*__i), *__f);
 }

 template <class _Tp, class _Allocator>
@@ -2118,7 +2118,7 @@ deque<_Tp, _Allocator>::__append(size_type __n)
        __add_back_capacity(__n - __back_capacity);
    // __n <= __back_capacity
    for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())
-        __alloc_traits::construct(__a, addressof(*__i));
+        __alloc_traits::construct(__a, _STD::addressof(*__i));
 }

 template <class _Tp, class _Allocator>
@@ -2131,7 +2131,7 @@ deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v)
        __add_back_capacity(__n - __back_capacity);
    // __n <= __back_capacity
    for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())
-        __alloc_traits::construct(__a, addressof(*__i), __v);
+        __alloc_traits::construct(__a, _STD::addressof(*__i), __v);
 }

 // Create front capacity for one block of elements.
@@ -2209,7 +2209,7 @@ deque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
    size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
    // Number of unused blocks at back:
    size_type __back_capacity = __back_spare() / __base::__block_size;
-    __back_capacity = min(__back_capacity, __nb);  // don't take more than you need
+    __back_capacity = _STD::min(__back_capacity, __nb);  // don't take more than you need
    __nb -= __back_capacity;  // number of blocks need to allocate
    // If __nb == 0, then we have sufficient capacity.
    if (__nb == 0)
@@ -2354,7 +2354,7 @@ deque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
    size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
    // Number of unused blocks at front:
    size_type __front_capacity = __front_spare() / __base::__block_size;
-    __front_capacity = min(__front_capacity, __nb);  // don't take more than you need
+    __front_capacity = _STD::min(__front_capacity, __nb);  // don't take more than you need
    __nb -= __front_capacity;  // number of blocks need to allocate
    // If __nb == 0, then we have sufficient capacity.
    if (__nb == 0)
@@ -2536,7 +2536,7 @@ deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l,
    allocator_type& __a = __base::__alloc();
    // as if
    //   for (; __f != __l; ++__r, ++__f, ++__base::size())
-    //       __alloc_traits::construct(__a, addressof(*__r), _STD::move(*__f));
+    //       __alloc_traits::construct(__a, _STD::addressof(*__r), _STD::move(*__f));
    difference_type __n = __l - __f;
    while (__n > 0)
    {
@@ -2551,7 +2551,7 @@ deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l,
        if (__fb <= __vt && __vt < __fe)
            __vt = (const_iterator(__f.__m_iter_, __vt) += __r - __f).__ptr_;
        for (; __fb != __fe; ++__fb, ++__r, ++__base::size())
-            __alloc_traits::construct(__a, addressof(*__r), _STD::move(*__fb));
+            __alloc_traits::construct(__a, _STD::addressof(*__r), _STD::move(*__fb));
        __n -= __bs;
        __f += __bs;
    }
@@ -2568,7 +2568,7 @@ deque<_Tp, _Allocator>::__move_construct_backward_and_check(iterator __f, iterat
    // as if
    //   for (iterator __j = __l; __j != __f;)
    //   {
-    //       __alloc_traitsconstruct(__a, addressof(*--__r), _STD::move(*--__j));
+    //       __alloc_traitsconstruct(__a, _STD::addressof(*--__r), _STD::move(*--__j));
    //       --__base::__start_;
    //       ++__base::size();
    //   }
@@ -2588,7 +2588,7 @@ deque<_Tp, _Allocator>::__move_construct_backward_and_check(iterator __f, iterat
            __vt = (const_iterator(__l.__m_iter_, __vt) -= __l - __r + 1).__ptr_;
        while (__le != __lb)
        {
-            __alloc_traits::construct(__a, addressof(*--__r), _STD::move(*--__le));
+            __alloc_traits::construct(__a, _STD::addressof(*--__r), _STD::move(*--__le));
            --__base::__start_;
            ++__base::size();
        }
@@ -2608,8 +2608,8 @@ deque<_Tp, _Allocator>::erase(const_iterator __f)
    allocator_type& __a = __base::__alloc();
    if (__pos < (__base::size() - 1) / 2)
    {   // erase from front
-        _STD::move_backward(__b, __p, next(__p));
-        __alloc_traits::destroy(__a, addressof(*__b));
+        _STD::move_backward(__b, __p, _STD::next(__p));
+        __alloc_traits::destroy(__a, _STD::addressof(*__b));
        --__base::size();
        ++__base::__start_;
        if (__front_spare() >= 2 * __base::__block_size)
@@ -2622,7 +2622,7 @@ deque<_Tp, _Allocator>::erase(const_iterator __f)
    else
    {   // erase from back
        iterator __i = _STD::move(next(__p), __base::end(), __p);
-        __alloc_traits::destroy(__a, addressof(*__i));
+        __alloc_traits::destroy(__a, _STD::addressof(*__i));
        --__base::size();
        if (__back_spare() >= 2 * __base::__block_size)
        {
@@ -2648,7 +2648,7 @@ deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
        {   // erase from front
            iterator __i = _STD::move_backward(__b, __p, __p + __n);
            for (; __b != __i; ++__b)
-                __alloc_traits::destroy(__a, addressof(*__b));
+                __alloc_traits::destroy(__a, _STD::addressof(*__b));
            __base::size() -= __n;
            __base::__start_ += __n;
            while (__front_spare() >= 2 * __base::__block_size)
@@ -2662,7 +2662,7 @@ deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
        {   // erase from back
            iterator __i = _STD::move(__p + __n, __base::end(), __p);
            for (iterator __e = __base::end(); __i != __e; ++__i)
-                __alloc_traits::destroy(__a, addressof(*__i));
+                __alloc_traits::destroy(__a, _STD::addressof(*__i));
            __base::size() -= __n;
            while (__back_spare() >= 2 * __base::__block_size)
            {
@@ -2686,7 +2686,7 @@ deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f)
        iterator __b = __base::begin();
        difference_type __pos = __f - __b;
        for (iterator __p = __b + __pos; __p != __e; ++__p)
-            __alloc_traits::destroy(__a, addressof(*__p));
+            __alloc_traits::destroy(__a, _STD::addressof(*__p));
        __base::size() -= __n;
        while (__back_spare() >= 2 * __base::__block_size)
        {
--- a/include/ext/hash_map
+++ b/include/ext/hash_map
@@ -341,9 +341,9 @@ public:
    void operator()(pointer __p)
    {
        if (__second_constructed)
-            __alloc_traits::destroy(__na_, addressof(__p->__value_.second));
+            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
        if (__first_constructed)
-            __alloc_traits::destroy(__na_, addressof(__p->__value_.first));
+            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
        if (__p)
            __alloc_traits::deallocate(__na_, __p, 1);
    }
@@ -666,9 +666,9 @@ hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type& __k)
 {
    __node_allocator& __na = __table_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_.first), __k);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, addressof(__h->__value_.second));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
    __h.get_deleter().__second_constructed = true;
    return _STD::move(__h);
 }
--- a/include/forward_list
+++ b/include/forward_list
@@ -106,15 +106,21 @@ public:
    void resize(size_type n, const value_type& v);
    void clear();

+    void splice_after(const_iterator p, forward_list& x);
    void splice_after(const_iterator p, forward_list&& x);
+    void splice_after(const_iterator p, forward_list& x, const_iterator i);
    void splice_after(const_iterator p, forward_list&& x, const_iterator i);
+    void splice_after(const_iterator p, forward_list& x,
+                      const_iterator first, const_iterator last);
    void splice_after(const_iterator p, forward_list&& x,
                      const_iterator first, const_iterator last);
    void remove(const value_type& v);
    template <class Predicate> void remove_if(Predicate pred);
    void unique();
    template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);
+    void merge(forward_list& x);
    void merge(forward_list&& x);
+    template <class Compare> void merge(forward_list& x, Compare comp);
    template <class Compare> void merge(forward_list&& x, Compare comp);
    void sort();
    template <class Compare> void sort(Compare comp);
@@ -486,7 +492,7 @@ __forward_list_base<_Tp, _Alloc>::clear()
    for (__node_pointer __p = __before_begin()->__next_; __p != nullptr;)
    {
        __node_pointer __next = __p->__next_;
-        __node_traits::destroy(__a, addressof(__p->__value_));
+        __node_traits::destroy(__a, _STD::addressof(__p->__value_));
        __node_traits::deallocate(__a, __p, 1);
        __p = __next;
    }
@@ -632,16 +638,18 @@ public:
    void clear() {base::clear();}

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
    void splice_after(const_iterator __p, forward_list&& __x);
+    _LIBCPP_INLINE_VISIBILITY
    void splice_after(const_iterator __p, forward_list&& __x, const_iterator __i);
+    _LIBCPP_INLINE_VISIBILITY
    void splice_after(const_iterator __p, forward_list&& __x,
                      const_iterator __f, const_iterator __l);
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    void splice_after(const_iterator __p, forward_list& __x);
    void splice_after(const_iterator __p, forward_list& __x, const_iterator __i);
    void splice_after(const_iterator __p, forward_list& __x,
                      const_iterator __f, const_iterator __l);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    void remove(const value_type& __v);
    template <class _Predicate> void remove_if(_Predicate __pred);
    _LIBCPP_INLINE_VISIBILITY
@@ -649,13 +657,15 @@ public:
    template <class _BinaryPredicate> void unique(_BinaryPredicate __binary_pred);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
-    void merge(forward_list&& __x) {merge(_STD::move(__x), __less<value_type>());}
-    template <class _Compare> void merge(forward_list&& __x, _Compare __comp);
-#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    void merge(forward_list&& __x) {merge(__x, __less<value_type>());}
+    template <class _Compare>
+        _LIBCPP_INLINE_VISIBILITY
+        void merge(forward_list&& __x, _Compare __comp)
+        {merge(__x, _STD::move(__comp));}
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    void merge(forward_list& __x) {merge(__x, __less<value_type>());}
    template <class _Compare> void merge(forward_list& __x, _Compare __comp);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    void sort() {sort(__less<value_type>());}
    template <class _Compare> void sort(_Compare __comp);
@@ -702,7 +712,7 @@ forward_list<_Tp, _Alloc>::forward_list(size_type __n)
                                                             __p = __p->__next_)
        {
            __h.reset(__node_traits::allocate(__a, 1));
-            __node_traits::construct(__a, addressof(__h->__value_));
+            __node_traits::construct(__a, _STD::addressof(__h->__value_));
            __h->__next_ = nullptr;
            __p->__next_ = __h.release();
        }
@@ -861,7 +871,7 @@ typename enable_if
 forward_list<_Tp, _Alloc>::assign(_InputIterator __f, _InputIterator __l)
 {
    iterator __i = before_begin();
-    iterator __j = next(__i);
+    iterator __j = _STD::next(__i);
    iterator __e = end();
    for (; __j != __e && __f != __l; ++__i, ++__j, ++__f)
        *__j = *__f;
@@ -876,7 +886,7 @@ void
 forward_list<_Tp, _Alloc>::assign(size_type __n, const value_type& __v)
 {
    iterator __i = before_begin();
-    iterator __j = next(__i);
+    iterator __j = _STD::next(__i);
    iterator __e = end();
    for (; __j != __e && __n > 0; --__n, ++__i, ++__j)
        *__j = __v;
@@ -905,7 +915,7 @@ forward_list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
    __node_allocator& __a = base::__alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, addressof(__h->__value_),
+    __node_traits::construct(__a, _STD::addressof(__h->__value_),
                                  _STD::forward<_Args>(__args)...);
    __h->__next_ = base::__before_begin()->__next_;
    base::__before_begin()->__next_ = __h.release();
@@ -920,7 +930,7 @@ forward_list<_Tp, _Alloc>::push_front(value_type&& __v)
    __node_allocator& __a = base::__alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, addressof(__h->__value_), _STD::move(__v));
+    __node_traits::construct(__a, _STD::addressof(__h->__value_), _STD::move(__v));
    __h->__next_ = base::__before_begin()->__next_;
    base::__before_begin()->__next_ = __h.release();
 }
@@ -934,7 +944,7 @@ forward_list<_Tp, _Alloc>::push_front(const value_type& __v)
    __node_allocator& __a = base::__alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, addressof(__h->__value_), __v);
+    __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
    __h->__next_ = base::__before_begin()->__next_;
    base::__before_begin()->__next_ = __h.release();
 }
@@ -946,7 +956,7 @@ forward_list<_Tp, _Alloc>::pop_front()
    __node_allocator& __a = base::__alloc();
    __node_pointer __p = base::__before_begin()->__next_;
    base::__before_begin()->__next_ = __p->__next_;
-    __node_traits::destroy(__a, addressof(__p->__value_));
+    __node_traits::destroy(__a, _STD::addressof(__p->__value_));
    __node_traits::deallocate(__a, __p, 1);
 }

@@ -962,7 +972,7 @@ forward_list<_Tp, _Alloc>::emplace_after(const_iterator __p, _Args&&... __args)
    __node_allocator& __a = base::__alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, addressof(__h->__value_),
+    __node_traits::construct(__a, _STD::addressof(__h->__value_),
                                  _STD::forward<_Args>(__args)...);
    __h->__next_ = __r->__next_;
    __r->__next_ = __h.release();
@@ -979,7 +989,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, value_type&& __v)
    __node_allocator& __a = base::__alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, addressof(__h->__value_), _STD::move(__v));
+    __node_traits::construct(__a, _STD::addressof(__h->__value_), _STD::move(__v));
    __h->__next_ = __r->__next_;
    __r->__next_ = __h.release();
    return iterator(__r->__next_);
@@ -995,7 +1005,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, const value_type& __
    __node_allocator& __a = base::__alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, addressof(__h->__value_), __v);
+    __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
    __h->__next_ = __r->__next_;
    __r->__next_ = __h.release();
    return iterator(__r->__next_);
@@ -1012,7 +1022,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
        __node_allocator& __a = base::__alloc();
        typedef __allocator_destructor<__node_allocator> _D;
        unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-        __node_traits::construct(__a, addressof(__h->__value_), __v);
+        __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
        __node_pointer __first = __h.release();
        __node_pointer __last = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1022,7 +1032,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
            for (--__n; __n != 0; --__n, __last = __last->__next_)
            {
                __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, addressof(__h->__value_), __v);
+                __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
                __last->__next_ = __h.release();
            }
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1032,7 +1042,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
            while (__first != nullptr)
            {
                __node_pointer __next = __first->__next_;
-                __node_traits::destroy(__a, addressof(__first->__value_));
+                __node_traits::destroy(__a, _STD::addressof(__first->__value_));
                __node_traits::deallocate(__a, __first, 1);
                __first = __next;
            }
@@ -1062,7 +1072,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
        __node_allocator& __a = base::__alloc();
        typedef __allocator_destructor<__node_allocator> _D;
        unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-        __node_traits::construct(__a, addressof(__h->__value_), *__f);
+        __node_traits::construct(__a, _STD::addressof(__h->__value_), *__f);
        __node_pointer __first = __h.release();
        __node_pointer __last = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1072,7 +1082,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
            for (++__f; __f != __l; ++__f, __last = __last->__next_)
            {
                __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, addressof(__h->__value_), *__f);
+                __node_traits::construct(__a, _STD::addressof(__h->__value_), *__f);
                __last->__next_ = __h.release();
            }
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1082,7 +1092,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
            while (__first != nullptr)
            {
                __node_pointer __next = __first->__next_;
-                __node_traits::destroy(__a, addressof(__first->__value_));
+                __node_traits::destroy(__a, _STD::addressof(__first->__value_));
                __node_traits::deallocate(__a, __first, 1);
                __first = __next;
            }
@@ -1104,7 +1114,7 @@ forward_list<_Tp, _Alloc>::erase_after(const_iterator __f)
    __node_pointer __n = __p->__next_;
    __p->__next_ = __n->__next_;
    __node_allocator& __a = base::__alloc();
-    __node_traits::destroy(__a, addressof(__n->__value_));
+    __node_traits::destroy(__a, _STD::addressof(__n->__value_));
    __node_traits::deallocate(__a, __n, 1);
    return iterator(__p->__next_);
 }
@@ -1125,7 +1135,7 @@ forward_list<_Tp, _Alloc>::erase_after(const_iterator __f, const_iterator __l)
            do
            {
                __p = __n->__next_;
-                __node_traits::destroy(__a, addressof(__n->__value_));
+                __node_traits::destroy(__a, _STD::addressof(__n->__value_));
                __node_traits::deallocate(__a, __n, 1);
                __n = __p;
            } while (__n != __e);
@@ -1158,7 +1168,7 @@ forward_list<_Tp, _Alloc>::resize(size_type __n)
                                                         __ptr = __ptr->__next_)
            {
                __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, addressof(__h->__value_));
+                __node_traits::construct(__a, _STD::addressof(__h->__value_));
                __h->__next_ = nullptr;
                __ptr->__next_ = __h.release();
            }
@@ -1190,7 +1200,7 @@ forward_list<_Tp, _Alloc>::resize(size_type __n, const value_type& __v)
                                                         __ptr = __ptr->__next_)
            {
                __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, addressof(__h->__value_), __v);
+                __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
                __h->__next_ = nullptr;
                __ptr->__next_ = __h.release();
            }
@@ -1201,11 +1211,7 @@ forward_list<_Tp, _Alloc>::resize(size_type __n, const value_type& __v)
 template <class _Tp, class _Alloc>
 void
 forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-                                        forward_list&& __x)
-#else
                                        forward_list& __x)
-#endif
 {
    if (!__x.empty())
    {
@@ -1226,14 +1232,10 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
 template <class _Tp, class _Alloc>
 void
 forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-                                        forward_list&& __x,
-#else
                                        forward_list& __x,
-#endif
                                        const_iterator __i)
 {
-    const_iterator __lm1 = next(__i);
+    const_iterator __lm1 = _STD::next(__i);
    if (__p != __i && __p != __lm1)
    {
        const_cast<__node_pointer>(__i.__ptr_)->__next_ =
@@ -1248,11 +1250,7 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
 template <class _Tp, class _Alloc>
 void
 forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-                                        forward_list&& __x,
-#else
                                        forward_list& __x,
-#endif
                                        const_iterator __f, const_iterator __l)
 {
    if (__f != __l && __p != __f)
@@ -1272,6 +1270,39 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
    }
 }

+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
+template <class _Tp, class _Alloc>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
+                                        forward_list&& __x)
+{
+    splice_after(__p, __x);
+}
+
+template <class _Tp, class _Alloc>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
+                                        forward_list&& __x,
+                                        const_iterator __i)
+{
+    splice_after(__p, __x, __i);
+}
+
+template <class _Tp, class _Alloc>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
+                                        forward_list&& __x,
+                                        const_iterator __f, const_iterator __l)
+{
+    splice_after(__p, __x, __f, __l);
+}
+
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
 template <class _Tp, class _Alloc>
 void
 forward_list<_Tp, _Alloc>::remove(const value_type& __v)
@@ -1281,7 +1312,7 @@ forward_list<_Tp, _Alloc>::remove(const value_type& __v)
    {
        if (__i.__ptr_->__next_->__value_ == __v)
        {
-            iterator __j = next(__i, 2);
+            iterator __j = _STD::next(__i, 2);
            for (; __j != __e && *__j == __v; ++__j)
                ;
            erase_after(__i, __j);
@@ -1304,7 +1335,7 @@ forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)
    {
        if (__pred(__i.__ptr_->__next_->__value_))
        {
-            iterator __j = next(__i, 2);
+            iterator __j = _STD::next(__i, 2);
            for (; __j != __e && __pred(*__j); ++__j)
                ;
            erase_after(__i, __j);
@@ -1324,7 +1355,7 @@ forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
 {
    for (iterator __i = begin(), __e = end(); __i != __e;)
    {
-        iterator __j = next(__i);
+        iterator __j = _STD::next(__i);
        for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
            ;
        if (__i.__ptr_->__next_ != __j.__ptr_)
@@ -1336,11 +1367,7 @@ forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
 template <class _Tp, class _Alloc>
 template <class _Compare>
 void
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-forward_list<_Tp, _Alloc>::merge(forward_list&& __x, _Compare __comp)
-#else
 forward_list<_Tp, _Alloc>::merge(forward_list& __x, _Compare __comp)
-#endif
 {
    if (this != &__x)
    {
@@ -1429,7 +1456,7 @@ forward_list<_Tp, _Alloc>::__sort(__node_pointer __f1, difference_type __sz,
    }
    difference_type __sz1 = __sz / 2;
    difference_type __sz2 = __sz - __sz1;
-    __node_pointer __t = next(iterator(__f1), __sz1 - 1).__ptr_;
+    __node_pointer __t = _STD::next(iterator(__f1), __sz1 - 1).__ptr_;
    __node_pointer __f2 = __t->__next_;
    __t->__next_ = nullptr;
    return __merge(__sort(__f1, __sz1, __comp),
--- a/include/fstream
+++ b/include/fstream
@@ -579,7 +579,7 @@ basic_filebuf<_CharT, _Traits>::underflow()
                this->setg(this->eback(),
                           this->eback() + __unget_sz,
                           this->eback() + __unget_sz + __nmemb);
-                __c = *this->gptr();
+                __c = traits_type::to_int_type(*this->gptr());
            }
        }
        else
@@ -587,7 +587,7 @@ basic_filebuf<_CharT, _Traits>::underflow()
            memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
            __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
            __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
-            size_t __nmemb = min(static_cast<size_t>(this->egptr() - this->eback() - __unget_sz),
+            size_t __nmemb = _STD::min(static_cast<size_t>(this->egptr() - this->eback() - __unget_sz),
                                 static_cast<size_t>(__extbufend_ - __extbufnext_));
            codecvt_base::result __r;
            state_type __svs = __st_;
@@ -602,18 +602,18 @@ basic_filebuf<_CharT, _Traits>::underflow()
                if (__r == codecvt_base::noconv)
                {
                    this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, (char_type*)__extbufend_);
-                    __c = *this->gptr();
+                    __c = traits_type::to_int_type(*this->gptr());
                }
                else if (__inext != this->eback() + __unget_sz)
                {
                    this->setg(this->eback(), this->eback() + __unget_sz, __inext);
-                    __c = *this->gptr();
+                    __c = traits_type::to_int_type(*this->gptr());
                }
            }
        }
    }
    else
-        __c = *this->gptr();
+        __c = traits_type::to_int_type(*this->gptr());
    if (this->eback() == &__1buf)
        this->setg(0, 0, 0);
    return __c;
--- a/include/functional
+++ b/include/functional
@@ -1559,10 +1559,7 @@ typename enable_if
 __mu(_Ti&, _Uj& __uj)
 {
    const size_t _Indx = is_placeholder<_Ti>::value - 1;
-    // compiler bug workaround
-    typename tuple_element<_Indx, _Uj>::type __t = get<_Indx>(__uj);
-    return __t;
-//    return _STD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
+    return _STD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
 }

 template <class _Ti, class _Uj>
--- a/include/iosfwd
+++ b/include/iosfwd
@@ -92,6 +92,8 @@ typedef fpos<char_traits<wchar_t>::state_type> wstreampos;

 _LIBCPP_BEGIN_NAMESPACE_STD

+class ios_base;
+
 template<class _CharT>  struct _LIBCPP_VISIBLE char_traits;
 template<class _Tp>     class _LIBCPP_VISIBLE allocator;

--- a/include/istream
+++ b/include/istream
@@ -1265,7 +1265,7 @@ basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
            case 0:
                break;
            default:
-                __c = min(__c, __n);
+                __c = _STD::min(__c, __n);
                for (streamsize __k = 0; __k < __c; ++__k, ++__s, ++__i)
                    *__s = *__i;
            }
--- a/include/iterator
+++ b/include/iterator
@@ -488,7 +488,7 @@ next(_ForwardIter __x,
     typename iterator_traits<_ForwardIter>::difference_type __n = 1,
     typename enable_if<__is_forward_iterator<_ForwardIter>::value>::type* = 0)
 {
-    advance(__x, __n);
+    _STD::advance(__x, __n);
    return __x;
 }

@@ -499,7 +499,7 @@ prev(_BidiretionalIter __x,
     typename iterator_traits<_BidiretionalIter>::difference_type __n = 1,
     typename enable_if<__is_bidirectional_iterator<_BidiretionalIter>::value>::type* = 0)
 {
-    advance(__x, -__n);
+    _STD::advance(__x, -__n);
    return __x;
 }

@@ -902,8 +902,13 @@ public:
    template <class _Up> _LIBCPP_INLINE_VISIBILITY move_iterator(const move_iterator<_Up>& __u)
        : __i(__u.base()) {}
    _LIBCPP_INLINE_VISIBILITY _Iter base() const {return __i;}
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return *__i;}
-    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const {return &(operator*());}
+    _LIBCPP_INLINE_VISIBILITY reference operator*() const {
+      return static_cast<reference>(*__i);
+    }
+    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const {
+      typename iterator_traits<iterator_type>::reference __ref = *__i;
+      return &__ref;
+    }
    _LIBCPP_INLINE_VISIBILITY move_iterator& operator++() {++__i; return *this;}
    _LIBCPP_INLINE_VISIBILITY move_iterator  operator++(int)
        {move_iterator __tmp(*this); ++__i; return __tmp;}
@@ -919,7 +924,9 @@ public:
    _LIBCPP_INLINE_VISIBILITY move_iterator& operator-=(difference_type __n)
        {__i -= __n; return *this;}
    _LIBCPP_INLINE_VISIBILITY reference         operator[](difference_type __n) const
-        {return __i[__n];}
+    {
+      return static_cast<reference>(__i[__n]);
+    }
 };

 template <class _Iter1, class _Iter2>
--- a/include/list
+++ b/include/list
@@ -236,6 +236,8 @@ public:
                                             pointer;
    typedef typename pointer_traits<pointer>::difference_type difference_type;

+    _LIBCPP_INLINE_VISIBILITY
+    __list_iterator() {}
    _LIBCPP_INLINE_VISIBILITY
    reference operator*() const {return __ptr_->__value_;}
    _LIBCPP_INLINE_VISIBILITY
@@ -289,6 +291,8 @@ public:
                                             pointer;
    typedef typename pointer_traits<pointer>::difference_type difference_type;

+    _LIBCPP_INLINE_VISIBILITY
+    __list_const_iterator() {}
    _LIBCPP_INLINE_VISIBILITY
    __list_const_iterator(__list_iterator<_Tp, _VoidPtr> __p) : __ptr_(__p.__ptr_) {}

@@ -469,8 +473,8 @@ __list_imp<_Tp, _Alloc>::clear()
        {
            __node& __n = *__f.__ptr_;
            ++__f;
-            __node_alloc_traits::destroy(__na, addressof(__n.__value_));
-            __node_alloc_traits::deallocate(__na, addressof(__n), 1);
+            __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
+            __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
        }
    }
 }
@@ -710,8 +714,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::__iterator(size_type __n)
 {
-    return __n <= base::__sz() / 2 ? next(begin(), __n)
-                                   : prev(end(), base::__sz() - __n);
+    return __n <= base::__sz() / 2 ? _STD::next(begin(), __n)
+                                   : _STD::prev(end(), base::__sz() - __n);
 }

 template <class _Tp, class _Alloc>
@@ -911,7 +915,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, const value_type& __x)
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
    __hold->__prev_ = 0;
-    __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
+    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
    __link_nodes(const_cast<__node&>(*__p.__ptr_), *__hold, *__hold);
    ++base::__sz();
    return iterator(__hold.release());
@@ -929,7 +933,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
        typedef __allocator_destructor<__node_allocator> _D;
        unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
        __hold->__prev_ = 0;
-        __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
+        __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
        ++__ds;
        __r = iterator(__hold.get());
        __hold.release();
@@ -941,7 +945,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
            for (--__n; __n != 0; --__n, ++__e, ++__ds)
            {
                __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
+                __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
                __e.__ptr_->__next_ = __hold.get();
                __hold->__prev_ = __e.__ptr_;
                __hold.release();
@@ -952,7 +956,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
        {
            while (true)
            {
-                __node_alloc_traits::destroy(__na, addressof(*__e));
+                __node_alloc_traits::destroy(__na, _STD::addressof(*__e));
                __node_pointer __prev = __e.__ptr_->__prev_;
                __node_alloc_traits::deallocate(__na, __e.__ptr_, 1);
                if (__prev == 0)
@@ -982,7 +986,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
        typedef __allocator_destructor<__node_allocator> _D;
        unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
        __hold->__prev_ = 0;
-        __node_alloc_traits::construct(__na, addressof(__hold->__value_), *__f);
+        __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), *__f);
        ++__ds;
        __r = iterator(__hold.get());
        __hold.release();
@@ -994,7 +998,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
            for (++__f; __f != __l; ++__f, ++__e, ++__ds)
            {
                __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, addressof(__hold->__value_), *__f);
+                __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), *__f);
                __e.__ptr_->__next_ = __hold.get();
                __hold->__prev_ = __e.__ptr_;
                __hold.release();
@@ -1005,7 +1009,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
        {
            while (true)
            {
-                __node_alloc_traits::destroy(__na, addressof(*__e));
+                __node_alloc_traits::destroy(__na, _STD::addressof(*__e));
                __node_pointer __prev = __e.__ptr_->__prev_;
                __node_alloc_traits::deallocate(__na, __e.__ptr_, 1);
                if (__prev == 0)
@@ -1028,7 +1032,7 @@ list<_Tp, _Alloc>::push_front(const value_type& __x)
    __node_allocator& __na = base::__node_alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
+    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
    __link_nodes(*base::__end_.__next_, *__hold, *__hold);
    ++base::__sz();
    __hold.release();
@@ -1041,7 +1045,7 @@ list<_Tp, _Alloc>::push_back(const value_type& __x)
    __node_allocator& __na = base::__node_alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
+    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
    __link_nodes(static_cast<__node&>(base::__end_), *__hold, *__hold);
    ++base::__sz();
    __hold.release();
@@ -1056,7 +1060,7 @@ list<_Tp, _Alloc>::push_front(value_type&& __x)
    __node_allocator& __na = base::__node_alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, addressof(__hold->__value_), _STD::move(__x));
+    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::move(__x));
    __link_nodes(*base::__end_.__next_, *__hold, *__hold);
    ++base::__sz();
    __hold.release();
@@ -1069,7 +1073,7 @@ list<_Tp, _Alloc>::push_back(value_type&& __x)
    __node_allocator& __na = base::__node_alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, addressof(__hold->__value_), _STD::move(__x));
+    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::move(__x));
    __link_nodes(static_cast<__node&>(base::__end_), *__hold, *__hold);
    ++base::__sz();
    __hold.release();
@@ -1085,7 +1089,7 @@ list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
    __node_allocator& __na = base::__node_alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
+    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
    __link_nodes(*base::__end_.__next_, *__hold, *__hold);
    ++base::__sz();
    __hold.release();
@@ -1099,7 +1103,7 @@ list<_Tp, _Alloc>::emplace_back(_Args&&... __args)
    __node_allocator& __na = base::__node_alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
+    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
    __link_nodes(static_cast<__node&>(base::__end_), *__hold, *__hold);
    ++base::__sz();
    __hold.release();
@@ -1114,7 +1118,7 @@ list<_Tp, _Alloc>::emplace(const_iterator __p, _Args&&... __args)
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
    __hold->__prev_ = 0;
-    __node_alloc_traits::construct(__na, addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
+    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
    __link_nodes(const_cast<__node&>(*__p.__ptr_), *__hold, *__hold);
    ++base::__sz();
    return iterator(__hold.release());
@@ -1130,7 +1134,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, value_type&& __x)
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
    __hold->__prev_ = 0;
-    __node_alloc_traits::construct(__na, addressof(__hold->__value_), _STD::move(__x));
+    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::move(__x));
    __link_nodes(const_cast<__node&>(*__p.__ptr_), *__hold, *__hold);
    ++base::__sz();
    return iterator(__hold.release());
@@ -1146,8 +1150,8 @@ list<_Tp, _Alloc>::pop_front()
    __node& __n = *base::__end_.__next_;
    base::__unlink_nodes(__n, __n);
    --base::__sz();
-    __node_alloc_traits::destroy(__na, addressof(__n.__value_));
-    __node_alloc_traits::deallocate(__na, addressof(__n), 1);
+    __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
+    __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
 }

 template <class _Tp, class _Alloc>
@@ -1158,8 +1162,8 @@ list<_Tp, _Alloc>::pop_back()
    __node& __n = *base::__end_.__prev_;
    base::__unlink_nodes(__n, __n);
    --base::__sz();
-    __node_alloc_traits::destroy(__na, addressof(__n.__value_));
-    __node_alloc_traits::deallocate(__na, addressof(__n), 1);
+    __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
+    __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
 }

 template <class _Tp, class _Alloc>
@@ -1171,8 +1175,8 @@ list<_Tp, _Alloc>::erase(const_iterator __p)
    __node_pointer __r = __n.__next_;
    base::__unlink_nodes(__n, __n);
    --base::__sz();
-    __node_alloc_traits::destroy(__na, addressof(__n.__value_));
-    __node_alloc_traits::deallocate(__na, addressof(__n), 1);
+    __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
+    __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
    return iterator(__r);
 }

@@ -1189,8 +1193,8 @@ list<_Tp, _Alloc>::erase(const_iterator __f, const_iterator __l)
            __node& __n = const_cast<__node&>(*__f.__ptr_);
            ++__f;
            --base::__sz();
-            __node_alloc_traits::destroy(__na, addressof(__n.__value_));
-            __node_alloc_traits::deallocate(__na, addressof(__n), 1);
+            __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
+            __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
        }
    }
    return iterator(const_cast<__node_pointer>(__l.__ptr_));
@@ -1210,7 +1214,7 @@ list<_Tp, _Alloc>::resize(size_type __n)
        typedef __allocator_destructor<__node_allocator> _D;
        unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
        __hold->__prev_ = 0;
-        __node_alloc_traits::construct(__na, addressof(__hold->__value_));
+        __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_));
        ++__ds;
        iterator __r = iterator(__hold.release());
        iterator __e = __r;
@@ -1221,7 +1225,7 @@ list<_Tp, _Alloc>::resize(size_type __n)
            for (--__n; __n != 0; --__n, ++__e, ++__ds)
            {
                __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, addressof(__hold->__value_));
+                __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_));
                __e.__ptr_->__next_ = __hold.get();
                __hold->__prev_ = __e.__ptr_;
                __hold.release();
@@ -1232,7 +1236,7 @@ list<_Tp, _Alloc>::resize(size_type __n)
        {
            while (true)
            {
-                __node_alloc_traits::destroy(__na, addressof(*__e));
+                __node_alloc_traits::destroy(__na, _STD::addressof(*__e));
                __node_pointer __prev = __e.__ptr_->__prev_;
                __node_alloc_traits::deallocate(__na, __e.__ptr_, 1);
                if (__prev == 0)
@@ -1261,7 +1265,7 @@ list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
        typedef __allocator_destructor<__node_allocator> _D;
        unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
        __hold->__prev_ = 0;
-        __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
+        __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
        ++__ds;
        iterator __r = iterator(__hold.release());
        iterator __e = __r;
@@ -1272,7 +1276,7 @@ list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
            for (--__n; __n != 0; --__n, ++__e, ++__ds)
            {
                __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
+                __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
                __e.__ptr_->__next_ = __hold.get();
                __hold->__prev_ = __e.__ptr_;
                __hold.release();
@@ -1283,7 +1287,7 @@ list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
        {
            while (true)
            {
-                __node_alloc_traits::destroy(__na, addressof(*__e));
+                __node_alloc_traits::destroy(__na, _STD::addressof(*__e));
                __node_pointer __prev = __e.__ptr_->__prev_;
                __node_alloc_traits::deallocate(__na, __e.__ptr_, 1);
                if (__prev == 0)
@@ -1317,7 +1321,7 @@ template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __i)
 {
-    if (__p != __i && __p != next(__i))
+    if (__p != __i && __p != _STD::next(__i))
    {
        __node& __f = const_cast<__node&>(*__i.__ptr_);
        base::__unlink_nodes(__f, __f);
@@ -1355,7 +1359,7 @@ list<_Tp, _Alloc>::remove(const value_type& __x)
    {
        if (*__i == __x)
        {
-            iterator __j = next(__i);
+            iterator __j = _STD::next(__i);
            for (; __j != __e && *__j == __x; ++__j)
                ;
            __i = erase(__i, __j);
@@ -1374,7 +1378,7 @@ list<_Tp, _Alloc>::remove_if(_Pred __pred)
    {
        if (__pred(*__i))
        {
-            iterator __j = next(__i);
+            iterator __j = _STD::next(__i);
            for (; __j != __e && __pred(*__j); ++__j)
                ;
            __i = erase(__i, __j);
@@ -1399,7 +1403,7 @@ list<_Tp, _Alloc>::unique(_BinaryPred __binary_pred)
 {
    for (iterator __i = begin(), __e = end(); __i != __e;)
    {
-        iterator __j = next(__i);
+        iterator __j = _STD::next(__i);
        for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
            ;
        if (++__i != __j)
@@ -1431,7 +1435,7 @@ list<_Tp, _Alloc>::merge(list& __c, _Comp __comp)
            if (__comp(*__f2, *__f1))
            {
                size_type __ds = 1;
-                iterator __m2 = next(__f2);
+                iterator __m2 = _STD::next(__f2);
                for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2, ++__ds)
                    ;
                base::__sz() += __ds;
@@ -1440,7 +1444,7 @@ list<_Tp, _Alloc>::merge(list& __c, _Comp __comp)
                __node& __l = *__m2.__ptr_->__prev_;
                __f2 = __m2;
                base::__unlink_nodes(__f, __l);
-                __m2 = next(__f1);
+                __m2 = _STD::next(__f1);
                __link_nodes(*__f1.__ptr_, __f, __l);
                __f1 = __m2;
            }
@@ -1489,12 +1493,12 @@ list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __
        return __f1;
    }
    size_type __n2 = __n / 2;
-    iterator __e1 = next(__f1, __n2);
+    iterator __e1 = _STD::next(__f1, __n2);
    iterator  __r = __f1 = __sort(__f1, __e1, __n2, __comp);
    iterator __f2 = __e1 = __sort(__e1, __e2, __n - __n2, __comp);
    if (__comp(*__f2, *__f1))
    {
-        iterator __m2 = next(__f2);
+        iterator __m2 = _STD::next(__f2);
        for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2)
            ;
        __node& __f = *__f2.__ptr_;
@@ -1502,7 +1506,7 @@ list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __
        __r = __f2;
        __e1 = __f2 = __m2;
        base::__unlink_nodes(__f, __l);
-        __m2 = next(__f1);
+        __m2 = _STD::next(__f1);
        __link_nodes(*__f1.__ptr_, __f, __l);
        __f1 = __m2;
    }
@@ -1512,7 +1516,7 @@ list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __
    {
        if (__comp(*__f2, *__f1))
        {
-            iterator __m2 = next(__f2);
+            iterator __m2 = _STD::next(__f2);
            for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2)
                ;
            __node& __f = *__f2.__ptr_;
@@ -1521,7 +1525,7 @@ list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __
                __e1 = __m2;
            __f2 = __m2;
            base::__unlink_nodes(__f, __l);
-            __m2 = next(__f1);
+            __m2 = _STD::next(__f1);
            __link_nodes(*__f1.__ptr_, __f, __l);
            __f1 = __m2;
        }
--- a/include/locale
+++ b/include/locale
@@ -2580,7 +2580,7 @@ time_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
    char_type* __nb = __nar;
    char_type* __ne = __nb + 100;
    __do_put(__nb, __ne, __tm, __fmt, __mod);
-    return copy(__nb, __ne, __s);
+    return _STD::copy(__nb, __ne, __s);
 }

 extern template class time_put<char>;
@@ -3248,7 +3248,7 @@ __money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __m
            break;
        case money_base::symbol:
            if (!__sym.empty() && (__flags & ios_base::showbase))
-                __me = copy(__sym.begin(), __sym.end(), __me);
+                __me = _STD::copy(__sym.begin(), __sym.end(), __me);
            break;
        case money_base::value:
            {
@@ -3307,7 +3307,7 @@ __money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __m
    }
    // print rest of sign, if any
    if (__sn.size() > 1)
-        __me = copy(__sn.begin()+1, __sn.end(), __me);
+        __me = _STD::copy(__sn.begin()+1, __sn.end(), __me);
    // set alignment
    if ((__flags & ios_base::adjustfield) == ios_base::left)
        __mi = __me;
@@ -3967,7 +3967,7 @@ wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow()
            memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
            __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
            __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
-            streamsize __nmemb = min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
+            streamsize __nmemb = _STD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
                                 static_cast<streamsize>(__extbufend_ - __extbufnext_));
            codecvt_base::result __r;
            state_type __svs = __st_;
--- a/include/map
+++ b/include/map
@@ -350,7 +350,7 @@ template <class _Key, class _Tp, class _Compare, bool = is_empty<_Compare>::valu
 class __map_value_compare
    : private _Compare
 {
-    typedef pair<_Key, _Tp> _P;
+    typedef pair<typename std::remove_const<_Key>::type, _Tp> _P;
    typedef pair<const _Key, _Tp> _CP;
 public:
    _LIBCPP_INLINE_VISIBILITY
@@ -393,7 +393,7 @@ class __map_value_compare<_Key, _Tp, _Compare, false>
 {
    _Compare comp;

-    typedef pair<_Key, _Tp> _P;
+    typedef pair<typename std::remove_const<_Key>::type, _Tp> _P;
    typedef pair<const _Key, _Tp> _CP;

 public:
@@ -475,9 +475,9 @@ public:
    void operator()(pointer __p)
    {
        if (__second_constructed)
-            __alloc_traits::destroy(__na_, addressof(__p->__value_.second));
+            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
        if (__first_constructed)
-            __alloc_traits::destroy(__na_, addressof(__p->__value_.first));
+            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
        if (__p)
            __alloc_traits::deallocate(__na_, __p, 1);
    }
@@ -1042,7 +1042,7 @@ map<_Key, _Tp, _Compare, _Allocator>::__find_equal_key(const_iterator __hint,
    else if (__tree_.value_comp().key_comp()(__hint->first, __k))  // check after
    {
        // *__hint < __k
-        const_iterator __next = next(__hint);
+        const_iterator __next = _STD::next(__hint);
        if (__next == end() || __tree_.value_comp().key_comp()(__k, __next->first))
        {
            // *__hint < __k < *next(__hint)
@@ -1131,9 +1131,9 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node()
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_.first));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.first));
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, addressof(__h->__value_.second));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
    __h.get_deleter().__second_constructed = true;
    return __h;
 }
@@ -1146,7 +1146,7 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_), _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
    __h.get_deleter().__second_constructed = true;
    return __h;
@@ -1162,9 +1162,9 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _Args&& ...__
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_.first), _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, addressof(__h->__value_.second), _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.second), _STD::forward<_Args>(__args)...);
    __h.get_deleter().__second_constructed = true;
    return __h;
 }
@@ -1179,9 +1179,9 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node(const key_type& __k)
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_.first), __k);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, addressof(__h->__value_.second));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
    __h.get_deleter().__second_constructed = true;
    return _STD::move(__h);
 }
@@ -1685,9 +1685,9 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node()
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_.first));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.first));
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, addressof(__h->__value_.second));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
    __h.get_deleter().__second_constructed = true;
    return __h;
 }
@@ -1701,7 +1701,7 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_), _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
    __h.get_deleter().__second_constructed = true;
    return __h;
@@ -1718,9 +1718,9 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _Args&&
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_.first), _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, addressof(__h->__value_.second), _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.second), _STD::forward<_Args>(__args)...);
    __h.get_deleter().__second_constructed = true;
    return __h;
 }
--- a/include/memory
+++ b/include/memory
@@ -1487,7 +1487,7 @@ struct _LIBCPP_VISIBLE uses_allocator
 {
 };

-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+#ifndef _LIBCPP_HAS_NO_VARIADICS

 // uses-allocator construction

@@ -1505,7 +1505,7 @@ struct __uses_alloc_ctor
    : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
    {};

-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
+#endif  // _LIBCPP_HAS_NO_VARIADICS

 // allocator

@@ -1525,8 +1525,8 @@ public:

    _LIBCPP_INLINE_VISIBILITY allocator() throw() {}
    template <class _Up> _LIBCPP_INLINE_VISIBILITY allocator(const allocator<_Up>&) throw() {}
-    _LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const             {return addressof(__x);}
-    _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const {return addressof(__x);}
+    _LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const             {return _STD::addressof(__x);}
+    _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const {return _STD::addressof(__x);}
    _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
        {return static_cast<pointer>(::operator new(__n * sizeof(_Tp)));}
    _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) {::operator delete((void*)__p);}
--- a/include/mutex
+++ b/include/mutex
@@ -364,9 +364,9 @@ lock(_L0& __l0, _L1& __l1)

 #ifndef _LIBCPP_HAS_NO_VARIADICS

-template <class _L0, class _L1, class ..._L2>
+template <class _L0, class _L1, class _L2, class ..._L3>
 void
-__lock_first(int __i, _L0& __l0, _L1& __l1, _L2& ...__l2)
+__lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
 {
    while (true)
    {
@@ -375,7 +375,7 @@ __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& ...__l2)
        case 0:
            {
                unique_lock<_L0> __u0(__l0);
-                __i = try_lock(__l1, __l2...);
+                __i = try_lock(__l1, __l2, __l3...);
                if (__i == -1)
                {
                    __u0.release();
@@ -388,32 +388,32 @@ __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& ...__l2)
        case 1:
            {
                unique_lock<_L1> __u1(__l1);
-                __i = try_lock(__l2..., __l0);
+                __i = try_lock(__l2, __l3..., __l0);
                if (__i == -1)
                {
                    __u1.release();
                    return;
                }
            }
-            if (__i == sizeof...(_L2))
+            if (__i == sizeof...(_L3) + 1)
                __i = 0;
            else
                __i += 2;
            sched_yield();
            break;
        default:
-            __lock_first(__i - 2, __l2..., __l0, __l1);
+            __lock_first(__i - 2, __l2, __l3..., __l0, __l1);
            return;
        }
    }
 }

-template <class _L0, class _L1, class ..._L2>
+template <class _L0, class _L1, class _L2, class ..._L3>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-lock(_L0& __l0, _L1& __l1, _L2& ...__l2)
+lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
 {
-    __lock_first(0, __l0, __l1, __l2...);
+    __lock_first(0, __l0, __l1, __l2, __l3...);
 }

 #endif  // _LIBCPP_HAS_NO_VARIADICS
--- a/include/regex
+++ b/include/regex
@@ -2228,7 +2228,7 @@ __bracket_expression<_CharT, _Traits>::__exec(__state& __s) const
        ++__consumed;
        if (__might_have_digraph_)
        {
-            const _CharT* __next = next(__s.__current_);
+            const _CharT* __next = _STD::next(__s.__current_);
            if (__next != __s.__last_)
            {
                pair<_CharT, _CharT> __ch2(*__s.__current_, *__next);
@@ -2919,7 +2919,7 @@ basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first,
            __first = __parse_RE_expression(__first, __last);
            if (__first != __last)
            {
-                _ForwardIterator __temp = next(__first);
+                _ForwardIterator __temp = _STD::next(__first);
                if (__temp == __last && *__first == '$')
                {
                    __push_r_anchor();
@@ -3148,7 +3148,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && *__temp == '(')
@@ -3166,7 +3166,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && *__temp == ')')
@@ -3184,7 +3184,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && *__temp == '{')
@@ -3202,7 +3202,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && *__temp == '}')
@@ -3220,7 +3220,7 @@ basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && '1' <= *__temp && *__temp <= '9')
@@ -3241,7 +3241,7 @@ basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp == __last && *__first == '$')
            return __first;
        // Not called inside a bracket
@@ -3299,7 +3299,7 @@ basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\')
@@ -3330,7 +3330,7 @@ basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\')
@@ -3640,7 +3640,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
 {
    if (__first != __last && *__first != ']')
    {
-        _ForwardIterator __temp = next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        basic_string<_CharT> __start_range;
        if (__temp != __last && *__first == '[')
        {
@@ -3669,7 +3669,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
        }
        if (__first != __last && *__first != ']')
        {
-            __temp = next(__first);
+            __temp = _STD::next(__first);
            if (__temp != __last && *__first == '-' && *__temp != ']')
            {
                // parse a range
@@ -3891,7 +3891,7 @@ basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first
 #endif  // _LIBCPP_NO_EXCEPTIONS
        }
    }
-    __first = next(__temp, 2);
+    __first = _STD::next(__temp, 2);
    return __first;
 }

@@ -3920,7 +3920,7 @@ basic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first,
        throw regex_error(regex_constants::error_brack);
 #endif  // _LIBCPP_NO_EXCEPTIONS
    __ml->__add_class(__class_type);
-    __first = next(__temp, 2);
+    __first = _STD::next(__temp, 2);
    return __first;
 }

@@ -3953,7 +3953,7 @@ basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
        throw regex_error(regex_constants::error_collate);
 #endif  // _LIBCPP_NO_EXCEPTIONS
    }
-    __first = next(__temp, 2);
+    __first = _STD::next(__temp, 2);
    return __first;
 }

@@ -5220,18 +5220,18 @@ public:
        __matches_.resize(__m.size());
        for (size_type __i = 0; __i < __matches_.size(); ++__i)
        {
-            __matches_[__i].first = next(__f, _STD::distance(__mf, __m[__i].first));
-            __matches_[__i].second = next(__f, _STD::distance(__mf, __m[__i].second));
+            __matches_[__i].first = _STD::next(__f, _STD::distance(__mf, __m[__i].first));
+            __matches_[__i].second = _STD::next(__f, _STD::distance(__mf, __m[__i].second));
            __matches_[__i].matched = __m[__i].matched;
        }
        __unmatched_.first   = __l;
        __unmatched_.second  = __l;
        __unmatched_.matched = false;
-        __prefix_.first = next(__f, _STD::distance(__mf, __m.prefix().first));
-        __prefix_.second = next(__f, _STD::distance(__mf, __m.prefix().second));
+        __prefix_.first = _STD::next(__f, _STD::distance(__mf, __m.prefix().first));
+        __prefix_.second = _STD::next(__f, _STD::distance(__mf, __m.prefix().second));
        __prefix_.matched = __m.prefix().matched;
-        __suffix_.first = next(__f, _STD::distance(__mf, __m.suffix().first));
-        __suffix_.second = next(__f, _STD::distance(__mf, __m.suffix().second));
+        __suffix_.first = _STD::next(__f, _STD::distance(__mf, __m.suffix().first));
+        __suffix_.second = _STD::next(__f, _STD::distance(__mf, __m.suffix().second));
        __suffix_.matched = __m.suffix().matched;
        if (!__no_update_pos)
            __position_start_ = __prefix_.first;
--- a/include/sstream
+++ b/include/sstream
@@ -451,7 +451,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c)
            }
 #endif  // _LIBCPP_NO_EXCEPTIONS
        }
-        __hm_ = max(this->pptr() + 1, __hm_);
+        __hm_ = _STD::max(this->pptr() + 1, __hm_);
        if (__mode_ & ios_base::in)
        {
            char_type* __p = const_cast<char_type*>(__str_.data());
--- a/include/string
+++ b/include/string
@@ -1033,7 +1033,9 @@ public:
    basic_string(const basic_string& __str);
    basic_string(const basic_string& __str, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
    basic_string(basic_string&& __str);
+    _LIBCPP_INLINE_VISIBILITY
    basic_string(basic_string&& __str, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY basic_string(const_pointer __s);
@@ -3641,10 +3643,6 @@ swap(basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Tra
    __lhs.swap(__rhs);
 }

-template<class _CharT, class _Traits, class _Allocator>
-struct __is_zero_default_constructible<basic_string<_CharT, _Traits, _Allocator> >
-    : public integral_constant<bool, __is_zero_default_constructible<_Allocator>::value> {};
-
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS

 typedef basic_string<char16_t> u16string;
--- a/include/tuple
+++ b/include/tuple
@@ -120,7 +120,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // tuple_size

 template <class ..._Tp>
-class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...>>
+class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...> >
    : public integral_constant<size_t, sizeof...(_Tp)>
 {
 };
@@ -128,10 +128,10 @@ class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...>>
 // tuple_element

 template <size_t _Ip, class ..._Tp>
-class _LIBCPP_VISIBLE tuple_element<_Ip, tuple<_Tp...>>
+class _LIBCPP_VISIBLE tuple_element<_Ip, tuple<_Tp...> >
 {
 public:
-    typedef typename tuple_element<_Ip, __tuple_types<_Tp...>>::type type;
+    typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
 };

 // __tuple_leaf
@@ -373,7 +373,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
    template <class _Tuple,
              class = typename enable_if
                      <
-                         __tuple_convertible<_Tuple, tuple<_Tp...>>::value
+                         __tuple_convertible<_Tuple, tuple<_Tp...> >::value
                      >::type
             >
        _LIBCPP_INLINE_VISIBILITY
@@ -385,7 +385,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
    template <class _Alloc, class _Tuple,
              class = typename enable_if
                      <
-                         __tuple_convertible<_Tuple, tuple<_Tp...>>::value
+                         __tuple_convertible<_Tuple, tuple<_Tp...> >::value
                      >::type
             >
        _LIBCPP_INLINE_VISIBILITY
@@ -400,7 +400,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
        _LIBCPP_INLINE_VISIBILITY
        typename enable_if
        <
-            __tuple_assignable<_Tuple, tuple<_Tp...>>::value,
+            __tuple_assignable<_Tuple, tuple<_Tp...> >::value,
            __tuple_impl&
        >::type
        operator=(_Tuple&& __t)
@@ -425,11 +425,11 @@ class _LIBCPP_VISIBLE tuple
    base base_;

    template <size_t _Jp, class ..._Up> friend
-        typename tuple_element<_Jp, tuple<_Up...>>::type& get(tuple<_Up...>&);
+        typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&);
    template <size_t _Jp, class ..._Up> friend
-        const typename tuple_element<_Jp, tuple<_Up...>>::type& get(const tuple<_Up...>&);
+        const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&);
    template <size_t _Jp, class ..._Up> friend
-        typename tuple_element<_Jp, tuple<_Up...>>::type&& get(tuple<_Up...>&&);
+        typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&);
 public:

    _LIBCPP_INLINE_VISIBILITY
@@ -567,29 +567,30 @@ swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u) {__t.swap(__u);}

 template <size_t _Ip, class ..._Tp>
 inline _LIBCPP_INLINE_VISIBILITY
-typename tuple_element<_Ip, tuple<_Tp...>>::type&
+typename tuple_element<_Ip, tuple<_Tp...> >::type&
 get(tuple<_Tp...>& __t)
 {
-    typedef typename tuple_element<_Ip, tuple<_Tp...>>::type type;
+    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
    return static_cast<__tuple_leaf<_Ip, type>&>(__t.base_).get();
 }

 template <size_t _Ip, class ..._Tp>
 inline _LIBCPP_INLINE_VISIBILITY
-const typename tuple_element<_Ip, tuple<_Tp...>>::type&
+const typename tuple_element<_Ip, tuple<_Tp...> >::type&
 get(const tuple<_Tp...>& __t)
 {
-    typedef typename tuple_element<_Ip, tuple<_Tp...>>::type type;
+    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
    return static_cast<const __tuple_leaf<_Ip, type>&>(__t.base_).get();
 }

 template <size_t _Ip, class ..._Tp>
 inline _LIBCPP_INLINE_VISIBILITY
-typename tuple_element<_Ip, tuple<_Tp...>>::type&&
+typename tuple_element<_Ip, tuple<_Tp...> >::type&&
 get(tuple<_Tp...>&& __t)
 {
-    typedef typename tuple_element<_Ip, tuple<_Tp...>>::type type;
-    return static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get();
+    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
+    return static_cast<type&&>(
+             static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get());
 }

 // tie
@@ -626,7 +627,7 @@ struct ___make_tuple_return
 };

 template <class _Tp>
-struct ___make_tuple_return<reference_wrapper<_Tp>>
+struct ___make_tuple_return<reference_wrapper<_Tp> >
 {
    typedef _Tp& type;
 };
@@ -751,7 +752,7 @@ operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 template <class _Tp, class _Up> struct __tuple_cat_type;

 template <class ..._Ttypes, class ..._Utypes>
-struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...>>
+struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
 {
    typedef tuple<_Ttypes..., _Utypes...> type;
 };
@@ -841,7 +842,7 @@ template <class _Types, class _I0, class _J0>
 struct __tuple_cat;

 template <class ..._Types, size_t ..._I0, size_t ..._J0>
-struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...>>
+struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
 {
    template <class _Tuple0>
    _LIBCPP_INLINE_VISIBILITY
--- a/include/type_traits
+++ b/include/type_traits
@@ -165,10 +165,11 @@ struct _LIBCPP_VISIBLE integral_constant
    static constexpr _Tp      value = __v;
    typedef _Tp               value_type;
    typedef integral_constant type;
-#ifndef _LIBCPP_HAS_NO_CONSTEXPR
    _LIBCPP_INLINE_VISIBILITY
-    constexpr operator value_type() {return value;}
+#ifndef _LIBCPP_HAS_NO_CONSTEXPR
+    constexpr
 #endif
+         operator value_type() const {return value;}
 };

 template <class _Tp, _Tp __v>
@@ -597,6 +598,13 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_abstract : public __libcpp_abstra

 // is_convertible

+#if __has_feature(is_convertible_to)
+
+template <class _T1, class _T2> struct _LIBCPP_VISIBLE is_convertible
+    : public integral_constant<bool, __is_convertible_to(_T1, _T2)> {};
+
+#else  // __has_feature(is_convertible_to)
+
 namespace __is_convertible_imp
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -697,8 +705,18 @@ template <class _T1, class _T2> struct _LIBCPP_VISIBLE is_convertible
    static const size_t __complete_check2 = __is_convertible_check<_T2>::__v;
 };

+#endif  // __has_feature(is_convertible_to)
+
 // is_base_of

+#if __has_feature(is_base_of)
+
+template <class _Bp, class _Dp>
+struct _LIBCPP_VISIBLE is_base_of
+    : public integral_constant<bool, __is_base_of(_Bp, _Dp)> {};
+
+#else  // __has_feature(is_base_of)
+
 //  (C) Copyright Rani Sharoni 2003.
 //  Use, modification and distribution are subject to the Boost Software License,
 //  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -745,6 +763,8 @@ struct _LIBCPP_VISIBLE is_base_of
 {
 };

+#endif  // __has_feature(is_base_of)
+
 // is_empty

 template <class _Tp>
@@ -2302,9 +2322,6 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_pod

 #endif  // _LIBCPP_HAS_TYPE_TRAITS

-template <class _Tp> struct __is_zero_default_constructible
-    : public integral_constant<bool, is_scalar<_Tp>::value || is_empty<_Tp>::value> {};
-
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
--- a/include/unordered_map
+++ b/include/unordered_map
@@ -424,9 +424,9 @@ public:
    void operator()(pointer __p)
    {
        if (__second_constructed)
-            __alloc_traits::destroy(__na_, addressof(__p->__value_.second));
+            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
        if (__first_constructed)
-            __alloc_traits::destroy(__na_, addressof(__p->__value_.first));
+            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
        if (__p)
            __alloc_traits::deallocate(__na_, __p, 1);
    }
@@ -979,10 +979,10 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0,
 {
    __node_allocator& __na = __table_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_.first),
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.first),
                             _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, addressof(__h->__value_.second),
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.second),
                             _STD::forward<_Args>(__args)...);
    __h.get_deleter().__second_constructed = true;
    return __h;
@@ -999,7 +999,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0)
 {
    __node_allocator& __na = __table_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_),
+    __node_traits::construct(__na, _STD::addressof(__h->__value_),
                             _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
    __h.get_deleter().__second_constructed = true;
@@ -1032,9 +1032,9 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type&
 {
    __node_allocator& __na = __table_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_.first), __k);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, addressof(__h->__value_.second));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
    __h.get_deleter().__second_constructed = true;
    return _STD::move(__h);
 }
@@ -1560,10 +1560,10 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(
 {
    __node_allocator& __na = __table_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_.first),
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.first),
                             _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, addressof(__h->__value_.second),
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.second),
                             _STD::forward<_Args>(__args)...);
    __h.get_deleter().__second_constructed = true;
    return __h;
@@ -1580,7 +1580,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0
 {
    __node_allocator& __na = __table_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, addressof(__h->__value_),
+    __node_traits::construct(__na, _STD::addressof(__h->__value_),
                             _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
    __h.get_deleter().__second_constructed = true;
--- a/include/utility
+++ b/include/utility
@@ -271,6 +271,7 @@ private:

 #ifndef _LIBCPP_HAS_NO_VARIADICS
    template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
+        _LIBCPP_INLINE_VISIBILITY
        pair(piecewise_construct_t,
             tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
             __tuple_indices<_I1...>, __tuple_indices<_I2...>);
--- a/include/vector
+++ b/include/vector
@@ -624,14 +624,8 @@ private:
    void allocate(size_type __n);
    void deallocate();
    _LIBCPP_INLINE_VISIBILITY size_type __recommend(size_type __new_size) const;
-    _LIBCPP_INLINE_VISIBILITY void __construct_at_end(size_type __n);
-        void __construct_at_end(size_type __n, false_type);
-    _LIBCPP_INLINE_VISIBILITY void __construct_at_end(size_type __n, true_type);
-    _LIBCPP_INLINE_VISIBILITY
+    void __construct_at_end(size_type __n);
    void __construct_at_end(size_type __n, const_reference __x);
-    void __construct_at_end(size_type __n, const_reference __x, false_type);
-    _LIBCPP_INLINE_VISIBILITY
-        void __construct_at_end(size_type __n, const_reference __x, true_type);
    template <class _ForwardIterator>
        typename enable_if
        <
@@ -741,16 +735,8 @@ vector<_Tp, _Allocator>::__recommend(size_type __new_size) const
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == size() + __n
 template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
 void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n)
-{
-    __construct_at_end(__n, __is_zero_default_constructible<value_type>());
-}
-
-template <class _Tp, class _Allocator>
-void
-vector<_Tp, _Allocator>::__construct_at_end(size_type __n, false_type)
 {
    allocator_type& __a = this->__alloc();
    do
@@ -761,15 +747,6 @@ vector<_Tp, _Allocator>::__construct_at_end(size_type __n, false_type)
    } while (__n > 0);
 }

-template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
-void
-vector<_Tp, _Allocator>::__construct_at_end(size_type __n, true_type)
-{
-    _STD::memset(this->__end_, 0, __n*sizeof(value_type));
-    this->__end_ += __n;
-}
-
 //  Copy constructs __n objects starting at __end_ from __x
 //  throws if construction throws
 //  Precondition:  __n > 0
@@ -780,14 +757,6 @@ template <class _Tp, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
-{
-    __construct_at_end(__n, __x, integral_constant<bool, is_trivially_copy_constructible<value_type>::value &&
-                                                         is_trivially_copy_assignable<value_type>::value>());
-}
-
-template <class _Tp, class _Allocator>
-void
-vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x, false_type)
 {
    allocator_type& __a = this->__alloc();
    do
@@ -798,15 +767,6 @@ vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x,
    } while (__n > 0);
 }

-template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
-void
-vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x, true_type)
-{
-    _STD::fill_n(this->__end_, __n, __x);
-    this->__end_ += __n;
-}
-
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
 typename enable_if
@@ -1141,7 +1101,7 @@ vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u)
    if (__n <= capacity())
    {
        size_type __s = size();
-        _STD::fill_n(this->__begin_, min(__n, __s), __u);
+        _STD::fill_n(this->__begin_, _STD::min(__n, __s), __u);
        if (__n > __s)
            __construct_at_end(__n - __s, __u);
        else
@@ -2764,10 +2724,6 @@ struct _LIBCPP_VISIBLE hash<vector<bool, _Allocator> >
        {return __vec.__hash_code();}
 };

-template <class _Tp, class _Allocator>
-struct __is_zero_default_constructible<vector<_Tp, _Allocator> >
-    : public integral_constant<bool, __is_zero_default_constructible<_Allocator>::value> {};
-
 template <class _Tp, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 bool
--- a/lib/buildit
+++ b/lib/buildit
@@ -36,18 +36,20 @@ case $TRIPLE in
    SOEXT=dylib
 	if [ "$MACOSX_DEPLOYMENT_TARGET" == "10.6" ]
 	then
+	    EXTRA_FLAGS="-std=c++0x -U__STRICT_ANSI__"
 		LDSHARED_FLAGS="-o libc++.1.dylib \
 			-dynamiclib -nodefaultlibs -current_version 1 \
 			-compatibility_version 1 \
-			-install_name /usr/lib/libc++.dylib \
+			-install_name /usr/lib/libc++.1.dylib \
 			-Wl,-reexport_library,/usr/lib/libc++abi.dylib \
 			-Wl,-unexported_symbols_list,libc++unexp.exp  \
 			/usr/lib/libSystem.B.dylib"
 	else
+	    EXTRA_FLAGS="-std=c++0x"
 		LDSHARED_FLAGS="-o libc++.1.dylib \
 			-dynamiclib -nodefaultlibs  \
 			-current_version ${RC_ProjectSourceVersion} -compatibility_version 1 \
-			-install_name /usr/lib/libc++.dylib \
+			-install_name /usr/lib/libc++.1.dylib \
 			${SDKROOT}/usr/lib/libc++abi.dylib \
 			-lSystem  \
 			-Wl,-unexported_symbols_list,libc++unexp.exp  \
@@ -72,7 +74,7 @@ fi
 set -x

 for FILE in ../src/*.cpp; do
-	$CXX -c -g -Os $RC_CFLAGS -nostdinc++ -I../include $FILE
+	$CXX -c -g -Os $RC_CFLAGS $EXTRA_FLAGS -nostdinc++ -I../include $FILE
 done


--- a/src/ios.cpp
+++ b/src/ios.cpp
@@ -165,7 +165,7 @@ ios_base::iword(int index)
        size_t newcap;
        const size_t mx = std::numeric_limits<size_t>::max();
        if (req_size < mx/2)
-            newcap = max(2 * __iarray_cap_, req_size);
+            newcap = _STD::max(2 * __iarray_cap_, req_size);
        else
            newcap = mx;
        long* iarray = (long*)realloc(__iarray_, newcap * sizeof(long));
@@ -193,7 +193,7 @@ ios_base::pword(int index)
        size_t newcap;
        const size_t mx = std::numeric_limits<size_t>::max();
        if (req_size < mx/2)
-            newcap = max(2 * __parray_cap_, req_size);
+            newcap = _STD::max(2 * __parray_cap_, req_size);
        else
            newcap = mx;
        void** parray = (void**)realloc(__parray_, newcap * sizeof(void*));
@@ -223,7 +223,7 @@ ios_base::register_callback(event_callback fn, int index)
        size_t newcap;
        const size_t mx = std::numeric_limits<size_t>::max();
        if (req_size < mx/2)
-            newcap = max(2 * __event_cap_, req_size);
+            newcap = _STD::max(2 * __event_cap_, req_size);
        else
            newcap = mx;
        event_callback* fns = (event_callback*)realloc(__fn_, newcap * sizeof(event_callback));
--- a/src/regex.cpp
+++ b/src/regex.cpp
@@ -229,7 +229,7 @@ string
 __get_collation_name(const char* s)
 {
    const collationnames* i =
-            lower_bound(begin(collatenames), end(collatenames), s, use_strcmp());
+            _STD::lower_bound(begin(collatenames), end(collatenames), s, use_strcmp());
    string r;
    if (i != end(collatenames) && strcmp(s, i->elem_) == 0)
        r = char(i->char_);
@@ -240,7 +240,7 @@ ctype_base::mask
 __get_classname(const char* s, bool __icase)
 {
    const classnames* i =
-            lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp());
+            _STD::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp());
    ctype_base::mask r = 0;
    if (i != end(ClassNames) && strcmp(s, i->elem_) == 0)
    {
--- a/src/strstream.cpp
+++ b/src/strstream.cpp
@@ -130,6 +130,7 @@ strstreambuf::operator=(strstreambuf&& __rhs)
    __pfree_ = __rhs.__pfree_;
    __rhs.setg(nullptr, nullptr, nullptr);
    __rhs.setp(nullptr, nullptr);
+    return *this;
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -301,7 +302,7 @@ strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmod
        {
            char* newpos = eback() + newoff;
            if (pos_in)
-                setg(eback(), newpos, max(newpos, egptr()));
+                setg(eback(), newpos, _STD::max(newpos, egptr()));
            if (pos_out)
            {
                // min(pbase, newpos), newpos, epptr()
@@ -331,7 +332,7 @@ strstreambuf::seekpos(pos_type __sp, ios_base::openmode __which)
            {
                char* newpos = eback() + newoff;
                if (pos_in)
-                    setg(eback(), newpos, max(newpos, egptr()));
+                    setg(eback(), newpos, _STD::max(newpos, egptr()));
                if (pos_out)
                {
                    // min(pbase, newpos), newpos, epptr()
--- a/test/containers/associative/map/map.access/iterator.pass.cpp
+++ b/test/containers/associative/map/map.access/iterator.pass.cpp
@@ -63,7 +63,8 @@ int main()
        std::map<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
        assert(std::distance(m.begin(), m.end()) == m.size());
        assert(std::distance(m.rbegin(), m.rend()) == m.size());
-        std::map<int, double>::iterator i = m.begin();
+        std::map<int, double>::iterator i;
+        i = m.begin();
        std::map<int, double>::const_iterator k = i;
        assert(i == k);
        for (int j = 1; j <= m.size(); ++j, ++i)
@@ -108,7 +109,8 @@ int main()
        assert(std::distance(m.cbegin(), m.cend()) == m.size());
        assert(std::distance(m.rbegin(), m.rend()) == m.size());
        assert(std::distance(m.crbegin(), m.crend()) == m.size());
-        std::map<int, double>::const_iterator i = m.begin();
+        std::map<int, double>::const_iterator i;
+        i = m.begin();
        for (int j = 1; j <= m.size(); ++j, ++i)
        {
            assert(i->first == j);
--- a/test/containers/associative/multimap/iterator.pass.cpp
+++ b/test/containers/associative/multimap/iterator.pass.cpp
@@ -63,7 +63,8 @@ int main()
        std::multimap<int, double> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
        assert(std::distance(m.begin(), m.end()) == m.size());
        assert(std::distance(m.rbegin(), m.rend()) == m.size());
-        std::multimap<int, double>::iterator i = m.begin();
+        std::multimap<int, double>::iterator i;
+        i = m.begin();
        std::multimap<int, double>::const_iterator k = i;
        assert(i == k);
        for (int j = 1; j <= 8; ++j)
@@ -109,7 +110,8 @@ int main()
        assert(std::distance(m.cbegin(), m.cend()) == m.size());
        assert(std::distance(m.rbegin(), m.rend()) == m.size());
        assert(std::distance(m.crbegin(), m.crend()) == m.size());
-        std::multimap<int, double>::const_iterator i = m.begin();
+        std::multimap<int, double>::const_iterator i;
+        i = m.begin();
        for (int j = 1; j <= 8; ++j)
            for (double d = 1; d <= 2; d += .5, ++i)
            {
--- a/test/containers/associative/multiset/iterator.pass.cpp
+++ b/test/containers/associative/multiset/iterator.pass.cpp
@@ -63,7 +63,8 @@ int main()
        std::multiset<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
        assert(std::distance(m.begin(), m.end()) == m.size());
        assert(std::distance(m.rbegin(), m.rend()) == m.size());
-        std::multiset<int>::iterator i = m.begin();
+        std::multiset<int>::iterator i;
+        i = m.begin();
        std::multiset<int>::const_iterator k = i;
        assert(i == k);
        for (int j = 1; j <= 8; ++j)
@@ -104,7 +105,8 @@ int main()
        assert(std::distance(m.cbegin(), m.cend()) == m.size());
        assert(std::distance(m.rbegin(), m.rend()) == m.size());
        assert(std::distance(m.crbegin(), m.crend()) == m.size());
-        std::multiset<int, double>::const_iterator i = m.begin();
+        std::multiset<int, double>::const_iterator i;
+        i = m.begin();
        for (int j = 1; j <= 8; ++j)
            for (int k = 0; k < 3; ++k, ++i)
                assert(*i == j);
--- a/test/containers/associative/set/iterator.pass.cpp
+++ b/test/containers/associative/set/iterator.pass.cpp
@@ -63,7 +63,8 @@ int main()
        std::set<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
        assert(std::distance(m.begin(), m.end()) == m.size());
        assert(std::distance(m.rbegin(), m.rend()) == m.size());
-        std::set<int>::iterator i = m.begin();
+        std::set<int>::iterator i;
+        i = m.begin();
        std::set<int>::const_iterator k = i;
        assert(i == k);
        for (int j = 1; j <= m.size(); ++j, ++i)
@@ -103,7 +104,8 @@ int main()
        assert(std::distance(m.cbegin(), m.cend()) == m.size());
        assert(std::distance(m.rbegin(), m.rend()) == m.size());
        assert(std::distance(m.crbegin(), m.crend()) == m.size());
-        std::set<int, double>::const_iterator i = m.begin();
+        std::set<int, double>::const_iterator i;
+        i = m.begin();
        for (int j = 1; j <= m.size(); ++j, ++i)
            assert(*i == j);
    }
--- a/test/containers/sequences/array/begin.pass.cpp
+++ b/test/containers/sequences/array/begin.pass.cpp
@@ -20,7 +20,8 @@ int main()
        typedef double T;
        typedef std::array<T, 3> C;
        C c = {1, 2, 3.5};
-        C::iterator i = c.begin();
+        C::iterator i;
+        i = c.begin();
        assert(*i == 1);
        assert(&*i == c.data());
        *i = 5.5;
--- a/test/containers/sequences/deque/iterators.pass.cpp
+++ b/test/containers/sequences/deque/iterators.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <deque>
+
+// Test nested types and default template args:
+
+// template <class T, class Allocator = allocator<T> >
+// class deque;
+
+// iterator, const_iterator
+
+#include <deque>
+#include <iterator>
+#include <cassert>
+
+int main()
+{
+    typedef std::deque<int> C;
+    C c;
+    C::iterator i;
+    i = c.begin();
+    C::const_iterator j;
+    j = c.cbegin();
+    assert(i == j);
+}
--- a/test/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
+++ b/test/containers/sequences/forwardlist/forwardlist.iter/iterators.pass.cpp
@@ -67,5 +67,6 @@ int main()
        typedef int T;
        typedef std::forward_list<T> C;
        C::iterator i;
+        C::const_iterator j;
    }
 }
--- a/test/containers/sequences/list/iterators.pass.cpp
+++ b/test/containers/sequences/list/iterators.pass.cpp
@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// iterator       begin();
+// iterator       end();
+// const_iterator begin()  const;
+// const_iterator end()    const;
+// const_iterator cbegin() const;
+// const_iterator cend()   const;
+
+#include <list>
+#include <cassert>
+#include <iterator>
+
+int main()
+{
+    {
+        typedef int T;
+        typedef std::list<T> C;
+        C c;
+        C::iterator i = c.begin();
+        C::iterator j = c.end();
+        assert(std::distance(i, j) == 0);
+        assert(i == j);
+    }
+    {
+        typedef int T;
+        typedef std::list<T> C;
+        const C c;
+        C::const_iterator i = c.begin();
+        C::const_iterator j = c.end();
+        assert(std::distance(i, j) == 0);
+        assert(i == j);
+    }
+    {
+        typedef int T;
+        typedef std::list<T> C;
+        C c;
+        C::const_iterator i = c.cbegin();
+        C::const_iterator j = c.cend();
+        assert(std::distance(i, j) == 0);
+        assert(i == j);
+        assert(i == c.end());
+    }
+    {
+        typedef int T;
+        typedef std::list<T> C;
+        const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+        C c(std::begin(t), std::end(t));
+        C::iterator i = c.begin();
+        assert(*i == 0);
+        ++i;
+        assert(*i == 1);
+        *i = 10;
+        assert(*i == 10);
+        assert(std::distance(c.begin(), c.end()) == 10);
+    }
+    {
+        typedef int T;
+        typedef std::list<T> C;
+        C::iterator i;
+        C::const_iterator j;
+    }
+}
--- a/test/containers/sequences/vector.bool/iterators.pass.cpp
+++ b/test/containers/sequences/vector.bool/iterators.pass.cpp
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// iterator       begin();
+// iterator       end();
+// const_iterator begin()  const;
+// const_iterator end()    const;
+// const_iterator cbegin() const;
+// const_iterator cend()   const;
+
+#include <vector>
+#include <cassert>
+#include <iterator>
+
+int main()
+{
+    {
+        typedef bool T;
+        typedef std::vector<T> C;
+        C c;
+        C::iterator i = c.begin();
+        C::iterator j = c.end();
+        assert(std::distance(i, j) == 0);
+        assert(i == j);
+    }
+    {
+        typedef bool T;
+        typedef std::vector<T> C;
+        const C c;
+        C::const_iterator i = c.begin();
+        C::const_iterator j = c.end();
+        assert(std::distance(i, j) == 0);
+        assert(i == j);
+    }
+    {
+        typedef bool T;
+        typedef std::vector<T> C;
+        C c;
+        C::const_iterator i = c.cbegin();
+        C::const_iterator j = c.cend();
+        assert(std::distance(i, j) == 0);
+        assert(i == j);
+        assert(i == c.end());
+    }
+    {
+        typedef bool T;
+        typedef std::vector<T> C;
+        C::iterator i;
+        C::const_iterator j;
+    }
+}
--- a/test/containers/sequences/vector/iterators.pass.cpp
+++ b/test/containers/sequences/vector/iterators.pass.cpp
@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// iterator       begin();
+// iterator       end();
+// const_iterator begin()  const;
+// const_iterator end()    const;
+// const_iterator cbegin() const;
+// const_iterator cend()   const;
+
+#include <vector>
+#include <cassert>
+#include <iterator>
+
+int main()
+{
+    {
+        typedef int T;
+        typedef std::vector<T> C;
+        C c;
+        C::iterator i = c.begin();
+        C::iterator j = c.end();
+        assert(std::distance(i, j) == 0);
+        assert(i == j);
+    }
+    {
+        typedef int T;
+        typedef std::vector<T> C;
+        const C c;
+        C::const_iterator i = c.begin();
+        C::const_iterator j = c.end();
+        assert(std::distance(i, j) == 0);
+        assert(i == j);
+    }
+    {
+        typedef int T;
+        typedef std::vector<T> C;
+        C c;
+        C::const_iterator i = c.cbegin();
+        C::const_iterator j = c.cend();
+        assert(std::distance(i, j) == 0);
+        assert(i == j);
+        assert(i == c.end());
+    }
+    {
+        typedef int T;
+        typedef std::vector<T> C;
+        const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+        C c(std::begin(t), std::end(t));
+        C::iterator i = c.begin();
+        assert(*i == 0);
+        ++i;
+        assert(*i == 1);
+        *i = 10;
+        assert(*i == 10);
+        assert(std::distance(c.begin(), c.end()) == 10);
+    }
+    {
+        typedef int T;
+        typedef std::vector<T> C;
+        C::iterator i;
+        C::const_iterator j;
+    }
+}
--- a/test/containers/unord/unord.map/iterators.pass.cpp
+++ b/test/containers/unord/unord.map/iterators.pass.cpp
@@ -43,6 +43,7 @@ int main()
        assert(c.size() == 4);
        assert(std::distance(c.begin(), c.end()) == c.size());
        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        C::iterator i;
    }
    {
        typedef std::unordered_map<int, std::string> C;
@@ -61,5 +62,6 @@ int main()
        assert(c.size() == 4);
        assert(std::distance(c.begin(), c.end()) == c.size());
        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        C::const_iterator i;
    }
 }
--- a/test/containers/unord/unord.multimap/iterators.pass.cpp
+++ b/test/containers/unord/unord.multimap/iterators.pass.cpp
@@ -43,7 +43,8 @@ int main()
        assert(c.size() == 6);
        assert(std::distance(c.begin(), c.end()) == c.size());
        assert(std::distance(c.cbegin(), c.cend()) == c.size());
-        C::iterator i = c.begin();
+        C::iterator i;
+        i = c.begin();
        i->second = "ONE";
        assert(i->second == "ONE");
    }
@@ -64,5 +65,6 @@ int main()
        assert(c.size() == 6);
        assert(std::distance(c.begin(), c.end()) == c.size());
        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        C::const_iterator i;
    }
 }
--- a/test/containers/unord/unord.multiset/iterators.pass.cpp
+++ b/test/containers/unord/unord.multiset/iterators.pass.cpp
@@ -42,6 +42,7 @@ int main()
        assert(c.size() == 6);
        assert(std::distance(c.begin(), c.end()) == c.size());
        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        C::iterator i;
    }
    {
        typedef std::unordered_multiset<int> C;
@@ -60,5 +61,6 @@ int main()
        assert(c.size() == 6);
        assert(std::distance(c.begin(), c.end()) == c.size());
        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        C::const_iterator i;
    }
 }
--- a/test/containers/unord/unord.set/iterators.pass.cpp
+++ b/test/containers/unord/unord.set/iterators.pass.cpp
@@ -42,6 +42,7 @@ int main()
        assert(c.size() == 4);
        assert(std::distance(c.begin(), c.end()) == c.size());
        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        C::iterator i;
    }
    {
        typedef std::unordered_set<int> C;
@@ -60,5 +61,6 @@ int main()
        assert(c.size() == 4);
        assert(std::distance(c.begin(), c.end()) == c.size());
        assert(std::distance(c.cbegin(), c.cend()) == c.size());
+        C::const_iterator i;
    }
 }
--- a/test/lit.cfg
+++ b/test/lit.cfg
@@ -134,16 +134,21 @@ if libcxx_obj_root is not None:
 else:
  libcxx_obj_root = "/usr"

+# Configure extra compiler flags.
+compile_flags = []
+if getattr(config, 'cxx_has_stdcxx0x_flag', False):
+  compile_flags += ['-std=c++0x']
+
 # Configure extra libraries.
 libraries = []
 if sys.platform == 'darwin':
  libraries += ['-lSystem']
 if sys.platform == 'linux2':
-  libraries += ['-lgcc_eh', '-lsupc++', '-lc', '-lm', '-lgcc_s']
+  libraries += ['-lgcc_eh', '-lsupc++', '-lc', '-lm', '-lrt', '-lgcc_s']
  libraries += ['-Wl,-R', libcxx_obj_root + '/lib']

 config.test_format = LibcxxTestFormat(cxx_under_test,
-                                      cpp_flags = ['-nostdinc++'] + include_paths,
+                                      cpp_flags = ['-nostdinc++'] + compile_flags + include_paths,
                                      ld_flags = ['-nodefaultlibs'] + library_paths + ['-lc++'] + libraries)

 config.target_triple = None
--- a/test/testit
+++ b/test/testit
@@ -8,51 +8,14 @@
 # //
 # //===--------------------------------------------------------------------===//

-BACKUP="../"
-
-currentpath=`pwd`
-origpath=$currentpath
-currentdir=`basename $currentpath`
-while [ $currentdir != "test" ]; do
-	if [ $currentdir == "/" ]
-	then
-		echo "current directory must be in or under \"test\"."
-		exit 1
-	fi
-	cd ..
-	currentpath=`pwd`
-	currentdir=`basename $currentpath`
-	BACKUP="../"$BACKUP
-done
-cd $origpath
-
 if [ -z $CC ]
 then
-	CC=g++
-fi
-
-auto_header=0
-
-if [ -z $HEADER_INCLUDE ]
-then
-	HEADER_INCLUDE=$BACKUP"include"
-	let "auto_header+=1"
-fi
-
-auto_lib=0
-
-SOURCE_LIB=/usr/lib/libc++.dylib
-#SOURCE_LIB=/Users/hinnant/Development/libcpp/lib/libc++.a
-
-if [ -z $SOURCE_LIB ]
-then
-	SOURCE_LIB=$BACKUP"lib/libc++.dylib"
-	let "auto_lib+=1"
+	CC=clang++
 fi

 if [ -z "$OPTIONS" ]
 then
-	OPTIONS="-nostdinc++ -nodefaultlibs /usr/lib/libSystem.B.dylib -arch `arch`"
+	OPTIONS="-std=c++0x -stdlib=libc++"
 fi

 FAIL=0
@@ -68,7 +31,7 @@ function afunc
 	if (ls *.fail.cpp &> /dev/null)
 	then
 		for FILE in $(ls *.fail.cpp); do
-			if $CC $OPTIONS -I$HEADER_INCLUDE $SOURCE_LIB $FILE &> /dev/null
+			if $CC $OPTIONS $HEADER_INCLUDE $SOURCE_LIB $FILE &> /dev/null
 			then
 				rm ./a.out
 				echo "$FILE should not compile"
@@ -82,7 +45,7 @@ function afunc
 	if (ls *.pass.cpp &> /dev/null)
 	then
 		for FILE in $(ls *.pass.cpp); do
-			if $CC $OPTIONS -I$HEADER_INCLUDE $SOURCE_LIB $FILE
+			if $CC $OPTIONS $HEADER_INCLUDE $SOURCE_LIB $FILE
 			then
 				if ./a.out
 				then
@@ -127,27 +90,7 @@ function afunc
 		if [ -d "$FILE" ];
 		then
 			cd $FILE
-			if [ $auto_header -eq 1 ]
-			then
-				SAVE_HEADER_INCLUDE=$HEADER_INCLUDE
-				HEADER_INCLUDE="../"$HEADER_INCLUDE
-			fi
-			if [ $auto_lib -eq 1 ]
-			then
-				SAVE_SOURCE_LIB=$SOURCE_LIB
-				SOURCE_LIB="../"$SOURCE_LIB
-			fi
-
 			afunc
-
-			if [ $auto_header -eq 1 ]
-			then
-				HEADER_INCLUDE=${HEADER_INCLUDE:3}
-			fi
-			if [ $auto_lib -eq 1 ]
-			then
-				SOURCE_LIB=${SOURCE_LIB:3}
-			fi
 			cd ..
 		fi
 	done
@@ -158,7 +101,7 @@ afunc
 echo "****************************************************"
 echo "Results for `pwd`:"
 echo "using `$CC --version`"
-echo "with $OPTIONS -I$HEADER_INCLUDE $SOURCE_LIB"
+echo "with $OPTIONS $HEADER_INCLUDE $SOURCE_LIB"
 echo "----------------------------------------------------"
 echo "sections without tests   : $UNIMPLEMENTED"
 echo "sections with failures   : $IMPLEMENTED_FAIL"
--- a/test/utilities/meta/meta.rel/is_base_of.pass.cpp
+++ b/test/utilities/meta/meta.rel/is_base_of.pass.cpp
@@ -46,5 +46,4 @@ int main()
    test_is_not_base_of<B&, D&>();
    test_is_not_base_of<B[3], D[3]>();
    test_is_not_base_of<int, int>();
-    test_is_not_base_of<int, int>();
 }
--- a/test/utilities/meta/meta.rel/is_convertible.pass.cpp
+++ b/test/utilities/meta/meta.rel/is_convertible.pass.cpp
@@ -16,6 +16,10 @@
 typedef void Function();
 typedef char Array[1];

+class NonCopyable {
+  NonCopyable(NonCopyable&);
+};
+
 int main()
 {
    {
@@ -66,8 +70,7 @@ int main()

    static_assert((!std::is_convertible<Function, Function>::value), "");

-    static_assert((!std::is_convertible<Function, Function&>::value), "");
-    static_assert((!std::is_convertible<Function, Function&>::value), "");
+    static_assert(( std::is_convertible<Function, Function&>::value), "");

    static_assert(( std::is_convertible<Function, Function*>::value), "");
    static_assert(( std::is_convertible<Function, Function* const>::value), "");
@@ -94,7 +97,6 @@ int main()
    static_assert((!std::is_convertible<Function&, Function>::value), "");

    static_assert(( std::is_convertible<Function&, Function&>::value), "");
-    static_assert(( std::is_convertible<Function&, const Function&>::value), "");

    static_assert(( std::is_convertible<Function&, Function*>::value), "");
    static_assert(( std::is_convertible<Function&, Function* const>::value), "");
@@ -181,7 +183,7 @@ int main()
    static_assert((!std::is_convertible<Array, Array&>::value), "");
    static_assert(( std::is_convertible<Array, const Array&>::value), "");
    static_assert((!std::is_convertible<const Array, Array&>::value), "");
-    static_assert((!std::is_convertible<const Array, const Array&>::value), "");
+    static_assert(( std::is_convertible<const Array, const Array&>::value), "");

    static_assert((!std::is_convertible<Array, char>::value), "");
    static_assert((!std::is_convertible<Array, const char>::value), "");
@@ -366,4 +368,15 @@ int main()
    static_assert((!std::is_convertible<const char*, char*>::value), "");
    static_assert(( std::is_convertible<const char*, const char*>::value), "");
    }
+    {
+    static_assert((std::is_convertible<NonCopyable&, NonCopyable&>::value), "");
+    static_assert((std::is_convertible<NonCopyable&, const NonCopyable&>::value), "");
+    static_assert((std::is_convertible<NonCopyable&, const volatile NonCopyable&>::value), "");
+    static_assert((std::is_convertible<NonCopyable&, volatile NonCopyable&>::value), "");
+    static_assert((std::is_convertible<const NonCopyable&, const NonCopyable&>::value), "");
+    static_assert((std::is_convertible<const NonCopyable&, const volatile NonCopyable&>::value), "");
+    static_assert((std::is_convertible<volatile NonCopyable&, const volatile NonCopyable&>::value), "");
+    static_assert((std::is_convertible<const volatile NonCopyable&, const volatile NonCopyable&>::value), "");
+    static_assert((!std::is_convertible<const NonCopyable&, NonCopyable&>::value), "");
+    }
 }
--- a/test/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
+++ b/test/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp
@@ -0,0 +1,19 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// type_traits
+
+// aligned_union
+
+#include <type_traits>
+
+int main()
+{
+#error aligned_union is not implemented
+}
--- a/www/index.html
+++ b/www/index.html
@@ -121,11 +121,6 @@
      support is as well.  The only major missing piece of C++'0x support is
      <code>&lt;atomic&gt;</code>.</p>

-   <p>libc++ is currently dependent upon a separate library for the low-level
-      ABI compatibility with gcc.  As a workaround it can be linked against
-      gcc's libstdc++, or on Mac OS X
-      <a href="http://home.roadrunner.com/~hinnant/libcppabi.zip">this library</a>.</p>
-
   <p><a href="libcxx_by_chapter.pdf">Here</a> is a by-chapter breakdown of what
   is passing tests and what isn't. This chart is currently based on testing
   against g++-4.4.0 with -std=c++0x. </p>
@@ -138,8 +133,42 @@

  <ul>
  <li><code>svn co http://llvm.org/svn/llvm-project/libcxx/trunk libcxx</code></li>
-  <li><code>cd libcxx/lib</code></li>
-  <li><code>./buildit</code></li>
+  </ul>
+
+  <p>To build on Mac OS X 10.6, you need a helper library and header 
+    <a href="http://home.roadrunner.com/~hinnant/libcppabi.zip">found here</a>.
+    cp cxxabi.h to /usr/include, and cp libc++abi.dylib to /usr/lib.
+    <p>
+    
+  <p>
+     Next:
+  </p>
+  
+  <ul>
+    <li><code>cd libcxx/lib</code></li>
+    <li><code>export TRIPLE=-apple-</code></li>
+    <li><code>./buildit</code></li>
+  </ul>
+  
+  <p>
+     That should result in a libc++.1.dylib.  To install it I like to use links
+     instead of copying, but either should work:
+  </p>
+
+  <ul>
+    <li><code>cd /usr/lib</code></li>
+    <li><code>sudo ln -sf path-to-libcxx/lib/libc++.1.dylib libc++.dylib</code></li>
+    <li><code>cd /usr/include/c++</code></li>
+    <li><code>sudo ln -sf path-to-libcxx/include v1</code></li>
+  </ul>
+
+  <p>
+  To use with clang you can:
+  </p>
+
+  <ul>
+    <li><code>clang++ -stdlib=libc++ test.cpp</code></li>
+    <li><code>clang++ -std=c++0x -stdlib=libc++ test.cpp</code></li>
  </ul>

  <p>To run the libc++ test suit (recommended):</p>
Author	SHA1	Message	Date
Howard Hinnant	3887a2b3a7	Tagging 15 git-svn-id: https://llvm.org/svn/llvm-project/libcxx/tags/libcpp-15@125667 91177308-0d34-0410-b5e6-96231b3b80d8	2011-02-16 17:23:15 +00:00
Howard Hinnant	08774c5a22	Change install name to libc++.1.dylib git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@125626 91177308-0d34-0410-b5e6-96231b3b80d8	2011-02-16 00:40:06 +00:00
Howard Hinnant	6cf5d8c3aa	Chris Jefferson noted many places where function calls needed to be qualified (thanks Chris). git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@125510 91177308-0d34-0410-b5e6-96231b3b80d8	2011-02-14 19:12:38 +00:00
Howard Hinnant	c4cbb5b6b7	Update testit to default to clang git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@125498 91177308-0d34-0410-b5e6-96231b3b80d8	2011-02-14 18:06:10 +00:00
Howard Hinnant	621ee222d9	fix stupid type-o git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@125311 91177308-0d34-0410-b5e6-96231b3b80d8	2011-02-10 21:34:42 +00:00
Howard Hinnant	31b8e617b6	Installed __has_feature(is_convertible_to) and __has_feature(is_base_of) git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@125290 91177308-0d34-0410-b5e6-96231b3b80d8	2011-02-10 17:46:03 +00:00
Howard Hinnant	47a7cce01e	Missing traits::to_int_type in fstream git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124727 91177308-0d34-0410-b5e6-96231b3b80d8	2011-02-02 17:37:16 +00:00
Howard Hinnant	2529d02b5d	Qualify calls to addressof with std::. Bug 9106 git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124726 91177308-0d34-0410-b5e6-96231b3b80d8	2011-02-02 17:36:20 +00:00
Howard Hinnant	211f0ee1be	Bug 9096 - list::iterator not default constructible git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124508 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-28 23:46:28 +00:00
Howard Hinnant	80f9180729	minor corrections to test, and hook is_base_of up to clang intrinsic git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124502 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-28 20:00:37 +00:00
Douglas Gregor	9ca45e21b8	Eliminate extraneous {}; git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124456 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-27 23:36:08 +00:00
Howard Hinnant	65451f1549	Updated getting started directions. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124452 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-27 23:18:19 +00:00
Howard Hinnant	30bbc93088	updated buildit to work with recent clang updates git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124432 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-27 21:01:51 +00:00
Howard Hinnant	9a21a01946	clang found a missing return statement. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124431 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-27 21:01:11 +00:00
Howard Hinnant	99b2f7660d	Make forward_list splice_after and merge work for lvalue lists git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124430 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-27 21:00:35 +00:00
Howard Hinnant	091c5ace78	Reverted previous fix to is_convertible as it caused more problems than it fixed. But this reverted fix will only matter for non-clang compilers. Installed __is_convertible_to for clang. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124429 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-27 21:00:00 +00:00
Douglas Gregor	497ac97247	Inline namespaces are always available in Clang. Rely on that without testing via __has_feature, since __has_feature for C++0x features no longer evaluates true in C++98/03 mode. Also, eliminate the redundant using directive. Inline namespaces make their members visible in the enclosing namespace automatically. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124293 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-26 15:39:56 +00:00
Douglas Gregor	aab015a929	Teach move_iterator that rvalue references cannot bind to non-function lvalues, nor can one take the address of an xvalue, by adding appropriate static_cast's (in the first case) and a temporary (in the second case). git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124255 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-26 00:12:48 +00:00
Howard Hinnant	9f193f202f	Add always_inline to string move constructors git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124252 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-26 00:06:59 +00:00
Douglas Gregor	5ea2e37c08	Remove an (incorrect) compiler workaround in the __mu function. The workaround relied on rvalue references binding to non-function lvalues, while the original formulation (with std::forward) does the right thing. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124241 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-25 23:11:15 +00:00
Howard Hinnant	4ff9d3599c	placeholder test git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124193 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-25 16:32:04 +00:00
Howard Hinnant	56a85ca8bf	tweak for readability (no functionality change) git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124192 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-25 16:31:30 +00:00
Douglas Gregor	6c669943b3	An rvalue reference cannot bind to an lvalue, so static_cast the result of the __tuple_leaf::get() call to an rvalue reference when returning from tuple's get(). git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124190 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-25 16:14:21 +00:00
Douglas Gregor	f9e1c7e367	Eliminate the C++0x-only is_convertible testing function that accepts a cv-qualifier rvalue reference to the type, e.g., template <class _Tp> char __test(const volatile typename remove_reference<_Tp>::type&&); The use of this function signature rather than the more straightforward one used in C++98/03 mode, e.g., template <class _Tp> char __test(_Tp); is broken in two ways: 1) An rvalue reference cannot bind to lvalues, so is_convertible<X&, X&>::value would be false. This breaks two of the unique_ptr tests on Clang and GCC >= 4.5. Prior GCC's seem to have allowed rvalue references to bind to lvalues, allowing this bug to slip in. 2) By adding cv-qualifiers to the type we're converting to, we get some incorrect "true" results for, e.g., is_convertible<const X&, X&>::value. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124166 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-25 01:15:41 +00:00
Howard Hinnant	f83417b823	Chandler Carruth changed >> to > > in several places. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124120 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-24 16:07:25 +00:00
Chandler Carruth	e76496ce46	Teach the Lit configuration to actually use the cxx0x setting when constructing compile flags, and to link against the 'rt' library on Linux for clock_gettime and friends. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@124052 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-23 01:05:20 +00:00
Howard Hinnant	5f5859c45b	Add attribute to inlined member. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@123392 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-13 20:05:05 +00:00
Howard Hinnant	6fd4b669ca	Fixing an ambiguity in variadics found by clang. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@123337 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-12 22:56:59 +00:00
Howard Hinnant	ac38bae75b	fix guard git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@123269 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-11 20:02:45 +00:00
Howard Hinnant	52c4eb23e0	Two minor fixes: 1. Put integral_constant conversion to integral in even without constexpr support. 2. Add ios_base to <iosfwd>. The latter is being tracked by LWG 2026. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@123080 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-08 20:00:48 +00:00
Howard Hinnant	04240d90ef	Reverting an old optimization that conflicts with the new allocator model, and causes some test casees to compile that shouldn't. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@122830 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-04 19:53:31 +00:00
Howard Hinnant	93c382bf45	Marshall Clow's fix for Bug 8421. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@122825 91177308-0d34-0410-b5e6-96231b3b80d8	2011-01-04 19:21:05 +00:00