Index: include/algorithm
===================================================================
--- include/algorithm
+++ include/algorithm
@@ -1753,130 +1753,186 @@
 }
 
 // copy
+
 template <class _Iter>
-inline _LIBCPP_INLINE_VISIBILITY
-_Iter
-__unwrap_iter(_Iter __i)
-{
-    return __i;
-}
+struct __is_move_iterator : false_type {};
 
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_trivially_copy_assignable<_Tp>::value,
-    _Tp*
->::type
-__unwrap_iter(move_iterator<_Tp*> __i)
-{
-    return __i.base();
-}
+template <class _Iter>
+struct __is_move_iterator<move_iterator<_Iter>> : true_type {};
 
-#if _LIBCPP_DEBUG_LEVEL < 2
+template <class _Iter>
+struct __is_wrapped_iterator : false_type {};
 
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_trivially_copy_assignable<_Tp>::value,
-    _Tp*
->::type
-__unwrap_iter(__wrap_iter<_Tp*> __i)
-{
-    return __i.base();
-}
+template <class _Iter>
+struct __is_wrapped_iterator<__wrap_iter<_Iter>> : true_type {};
 
-#else
+template <class _Iter>
+struct __is_reverse_iterator : false_type {};
 
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_trivially_copy_assignable<_Tp>::value,
-    __wrap_iter<_Tp*>
->::type
-__unwrap_iter(__wrap_iter<_Tp*> __i)
-{
-    return __i;
-}
+template <class _Iter>
+struct __is_reverse_iterator<reverse_iterator<_Iter>> : true_type {};
 
-#endif  // _LIBCPP_DEBUG_LEVEL < 2
+template <bool __condition /* = false*/>
+struct __unwrap_iter_impl
+{
+    template <class _Iter>
+    inline _LIBCPP_INLINE_VISIBILITY
+    _Iter operator()(_Iter __i) const
+    {
+        _LIBCPP_DEBUG_ASSERT(false, "Internal error. This function should never be called.");
+        return __i;
+    }
+};
 
-template <class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
-_OutputIterator
-__copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
+template <>
+struct __unwrap_iter_impl</*condition =*/true>
 {
-    for (; __first != __last; ++__first, (void) ++__result)
-        *__result = *__first;
-    return __result;
-}
+    template <class _Iter>
+    inline _LIBCPP_INLINE_VISIBILITY
+    auto operator()(_Iter __i) const -> decltype(__i.base())
+    {
+        return __i.base();
+    }
+};
 
-template <class _Tp, class _Up>
+template <bool __condition, class _Iter>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
-    _Up*
->::type
-__copy(_Tp* __first, _Tp* __last, _Up* __result)
+auto __unwrap_iter(_Iter __i) -> decltype(__unwrap_iter_impl<__condition>()(__i))
 {
-    const size_t __n = static_cast<size_t>(__last - __first);
-    if (__n > 0)
-        _VSTD::memmove(__result, __first, __n * sizeof(_Up));
-    return __result + __n;
+    return __unwrap_iter_impl<__condition>()(__i);
 }
 
-template <class _InputIterator, class _OutputIterator>
+template <bool __is_backward,
+          class _CopyTraits,  // customizable for testing.
+          class _InputIterator,
+          class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
-copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
-{
-    return _VSTD::__copy(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
+__do_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
+    typedef typename iterator_traits<_InputIterator>::value_type _Tp;
+    typedef typename iterator_traits<_OutputIterator>::value_type _Up;
+
+    _LIBCPP_CONSTEXPR const bool __is_trivial_copy = std::is_trivially_copy_assignable<_Up>::value &&
+                                                     std::is_same<typename std::remove_const<_Tp>::type, _Up>::value;
+
+    if (__is_trivial_copy && is_pointer<_InputIterator>::value && is_pointer<_OutputIterator>::value)
+        return _OutputIterator(_CopyTraits::template __memmove<__is_backward>(__first, __last, __result));
+
+    {
+        _LIBCPP_CONSTEXPR const bool __condition = __is_wrapped_iterator<_OutputIterator>::value && !_CopyTraits::__is_debug;
+
+        if (__condition)
+            return _OutputIterator(__do_copy<__is_backward, _CopyTraits>(__first, __last, __unwrap_iter<__condition>(__result)));
+    }
+
+    {
+        _LIBCPP_CONSTEXPR const bool __condition =
+            (__is_trivial_copy && __is_move_iterator<_InputIterator>::value) ||
+            (__is_wrapped_iterator<_InputIterator>::value && !_CopyTraits::__is_debug);
+
+        if (__condition)
+            return _OutputIterator(
+                __do_copy<__is_backward, _CopyTraits>(__unwrap_iter<__condition>(__first),
+                                                      __unwrap_iter<__condition>(__last),
+                                                      __result));
+    }
+
+    {
+        _LIBCPP_CONSTEXPR const bool __condition =
+           __is_reverse_iterator<_InputIterator>::value && __is_reverse_iterator<_OutputIterator>::value;
+        _LIBCPP_CONSTEXPR const bool __new_is_backward = __condition ? !__is_backward : __is_backward;
+        if (__condition)
+            return _OutputIterator(
+                __do_copy<__new_is_backward, _CopyTraits>(__unwrap_iter<__condition>(__last),
+                                                          __unwrap_iter<__condition>(__first),
+                                                          __unwrap_iter<__condition>(__result)));
+    }
+
+    return _CopyTraits::template __loop<__is_backward>(__first, __last, __result);
 }
 
-// copy_backward
+template <bool __is_backward /* = false */>
+struct __loop_copy_impl
+{
+    template <class _InputIterator, class _OutputIterator>
+    inline _LIBCPP_INLINE_VISIBILITY
+    _OutputIterator
+    operator()(_InputIterator __first, _InputIterator __last, _OutputIterator __result) const
+    {
+        for (; __first != __last; ++__first, (void)++__result)
+            *__result = *__first;
+        return __result;
+    }
+};
 
-template <class _BidirectionalIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
-_OutputIterator
-__copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
+template <>
+struct __loop_copy_impl</*__is_backward =*/ true>
 {
-    while (__first != __last)
-        *--__result = *--__last;
-    return __result;
-}
+    template <class _InputIterator, class _OutputIterator>
+    inline _LIBCPP_INLINE_VISIBILITY
+    _OutputIterator
+    operator()(_InputIterator __first, _InputIterator __last, _OutputIterator __result) const
+    {
+        while (__first != __last)
+            *--__result = *--__last;
+        return __result;
+    }
+};
 
-template <class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
-    _Up*
->::type
-__copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
+struct __copy_traits
 {
-    const size_t __n = static_cast<size_t>(__last - __first);
-    if (__n > 0)
+#if _LIBCPP_DEBUG_LEVEL < 2
+    static _LIBCPP_CONSTEXPR const bool __is_debug = false;
+#else
+    static _LIBCPP_CONSTEXPR const bool __is_debug = true;
+#endif
+
+    template <bool __is_backward, class _InputIterator, class _OutputIterator>
+    inline _LIBCPP_INLINE_VISIBILITY static
+    _OutputIterator
+    __memmove(_InputIterator, _InputIterator, _OutputIterator __result)
     {
-        __result -= __n;
-        _VSTD::memmove(__result, __first, __n * sizeof(_Up));
+        _LIBCPP_DEBUG_ASSERT(false, "Internal error. This function should never be called.");
+        return __result;
     }
-    return __result;
+
+    template <bool __is_backward, class _Tp, class _Up>
+    inline _LIBCPP_INLINE_VISIBILITY static
+    _Up*
+     __memmove(_Tp* __first, _Tp* __last, _Up* __result)
+    {
+        const size_t __n = static_cast<size_t>(__last - __first);
+        if (__n)
+            _VSTD::memmove(__is_backward ? __result - __n : __result, __first, __n * sizeof(_Up));
+        return __is_backward ? __result - __n : __result + __n;
+    }
+
+    template <bool __is_backward, class _InputIterator, class _OutputIterator>
+    inline _LIBCPP_INLINE_VISIBILITY static
+    _OutputIterator
+     __loop(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
+    {
+        return __loop_copy_impl<__is_backward>()(__first, __last, __result);
+    }
+};
+
+template <class _InputIterator, class _OutputIterator>
+inline _LIBCPP_INLINE_VISIBILITY
+_OutputIterator
+copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
+{
+    return _VSTD::__do_copy</*__is_backward*/false, __copy_traits>(__first, __last, __result);
 }
 
+// copy_backward
+
 template <class _BidirectionalIterator1, class _BidirectionalIterator2>
 inline _LIBCPP_INLINE_VISIBILITY
 _BidirectionalIterator2
 copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
               _BidirectionalIterator2 __result)
 {
-    return _VSTD::__copy_backward(__unwrap_iter(__first),
-                                  __unwrap_iter(__last),
-                                  __unwrap_iter(__result));
+    return _VSTD::__do_copy</*__is_backward*/true, __copy_traits>(__first, __last, __result);
 }
 
 // copy_if
@@ -1945,75 +2001,20 @@
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
-__move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
-{
-    for (; __first != __last; ++__first, (void) ++__result)
-        *__result = _VSTD::move(*__first);
-    return __result;
-}
-
-template <class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
-    _Up*
->::type
-__move(_Tp* __first, _Tp* __last, _Up* __result)
-{
-    const size_t __n = static_cast<size_t>(__last - __first);
-    if (__n > 0)
-        _VSTD::memmove(__result, __first, __n * sizeof(_Up));
-    return __result + __n;
-}
-
-template <class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
-_OutputIterator
 move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
-    return _VSTD::__move(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
+    return _VSTD::copy(_VSTD::make_move_iterator(__first), _VSTD::make_move_iterator(__last), __result);
 }
 
 // move_backward
 
-template <class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
-_OutputIterator
-__move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
-{
-    while (__first != __last)
-        *--__result = _VSTD::move(*--__last);
-    return __result;
-}
-
-template <class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
-    _Up*
->::type
-__move_backward(_Tp* __first, _Tp* __last, _Up* __result)
-{
-    const size_t __n = static_cast<size_t>(__last - __first);
-    if (__n > 0)
-    {
-        __result -= __n;
-        _VSTD::memmove(__result, __first, __n * sizeof(_Up));
-    }
-    return __result;
-}
-
 template <class _BidirectionalIterator1, class _BidirectionalIterator2>
 inline _LIBCPP_INLINE_VISIBILITY
 _BidirectionalIterator2
 move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
               _BidirectionalIterator2 __result)
 {
-    return _VSTD::__move_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
+    return _VSTD::copy_backward(_VSTD::make_move_iterator(__first), _VSTD::make_move_iterator(__last), __result);
 }
 
 // iter_swap
Index: include/iterator
===================================================================
--- include/iterator
+++ include/iterator
@@ -80,7 +80,7 @@
 
 template <class BidirectionalIterator>  // constexpr in C++17
   constexpr BidirectionalIterator prev(BidirectionalIterator x,
-    typename iterator_traits<BidirectionalIterator>::difference_type n = 1);    
+    typename iterator_traits<BidirectionalIterator>::difference_type n = 1);
 
 template <class Iterator>
 class reverse_iterator
@@ -147,7 +147,7 @@
 
 template <class Iterator>
 constexpr reverse_iterator<Iterator>
-operator+(typename reverse_iterator<Iterator>::difference_type n, 
+operator+(typename reverse_iterator<Iterator>::difference_type n,
           const reverse_iterator<Iterator>& x);   // constexpr in C++17
 
 template <class Iterator>
@@ -227,7 +227,7 @@
     typedef typename iterator_traits<Iterator>::value_type        value_type;
     typedef typename iterator_traits<Iterator>::iterator_category iterator_category;
     typedef value_type&&                                          reference;
- 
+
     constexpr move_iterator();  // all the constexprs are in C++17
     constexpr explicit move_iterator(Iterator i);
     template <class U>
@@ -241,10 +241,10 @@
     constexpr move_iterator operator++(int);
     constexpr move_iterator& operator--();
     constexpr move_iterator operator--(int);
-    constexpr move_iterator operator+(difference_type n) const; 
-    constexpr move_iterator& operator+=(difference_type n); 
-    constexpr move_iterator operator-(difference_type n) const; 
-    constexpr move_iterator& operator-=(difference_type n); 
+    constexpr move_iterator operator+(difference_type n) const;
+    constexpr move_iterator& operator+=(difference_type n);
+    constexpr move_iterator operator-(difference_type n) const;
+    constexpr move_iterator& operator-=(difference_type n);
     constexpr unspecified operator[](difference_type n) const;
 private:
     Iterator current; // exposition only
@@ -281,7 +281,7 @@
 
 template <class Iterator>
 constexpr move_iterator<Iterator> operator+(   // constexpr in C++17
-            typename move_iterator<Iterator>::difference_type n, 
+            typename move_iterator<Iterator>::difference_type n,
             const move_iterator<Iterator>& x);
 
 template <class Iterator>   // constexpr in C++17
@@ -522,8 +522,8 @@
 
 template <class _Tp>
 struct __is_exactly_input_iterator
-    : public integral_constant<bool, 
-         __has_iterator_category_convertible_to<_Tp, input_iterator_tag>::value && 
+    : public integral_constant<bool,
+         __has_iterator_category_convertible_to<_Tp, input_iterator_tag>::value &&
         !__has_iterator_category_convertible_to<_Tp, forward_iterator_tag>::value> {};
 
 template<class _Category, class _Tp, class _Distance = ptrdiff_t,
@@ -606,7 +606,7 @@
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 typename enable_if
 <
-    __is_input_iterator<_InputIter>::value, 
+    __is_input_iterator<_InputIter>::value,
     _InputIter
 >::type
 next(_InputIter __x,
@@ -620,7 +620,7 @@
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 typename enable_if
 <
-    __is_bidirectional_iterator<_BidirectionalIter>::value, 
+    __is_bidirectional_iterator<_BidirectionalIter>::value,
     _BidirectionalIter
 >::type
 prev(_BidirectionalIter __x,
@@ -1093,7 +1093,7 @@
       _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
       move_iterator(const move_iterator<_Up>& __u) : __i(__u.base()) {}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _Iter base() const {return __i;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference operator*() const { return static_cast<reference>(*__i); }
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     pointer  operator->() const { return __i;}
@@ -1460,30 +1460,9 @@
     __wrap_iter<_Iter1>
     operator+(typename __wrap_iter<_Iter1>::difference_type, __wrap_iter<_Iter1>) _NOEXCEPT_DEBUG;
 
-    template <class _Ip, class _Op> friend _Op copy(_Ip, _Ip, _Op);
-    template <class _B1, class _B2> friend _B2 copy_backward(_B1, _B1, _B2);
-    template <class _Ip, class _Op> friend _Op move(_Ip, _Ip, _Op);
-    template <class _B1, class _B2> friend _B2 move_backward(_B1, _B1, _B2);
 
-#if _LIBCPP_DEBUG_LEVEL < 2
-    template <class _Tp>
-    friend
-    typename enable_if
-    <
-        is_trivially_copy_assignable<_Tp>::value,
-        _Tp*
-    >::type
-    __unwrap_iter(__wrap_iter<_Tp*>);
-#else
-  template <class _Tp>
-  inline _LIBCPP_INLINE_VISIBILITY
-  typename enable_if
-  <
-      is_trivially_copy_assignable<_Tp>::value,
-      __wrap_iter<_Tp*>
-  >::type
-  __unwrap_iter(__wrap_iter<_Tp*> __i);
-#endif
+    template <bool __is_backward, class _CopyTraits, class _Ip, class _Op> friend _Op __do_copy(_Ip, _Ip, _Op);
+    template <bool __condition> friend struct  __unwrap_iter_impl;
 };
 
 template <class _Iter1, class _Iter2>
@@ -1610,7 +1589,7 @@
 template <class _Iter>
 struct __libcpp_is_trivial_iterator
     : public _LIBCPP_BOOL_CONSTANT(is_pointer<_Iter>::value) {};
-    
+
 template <class _Iter>
 struct __libcpp_is_trivial_iterator<move_iterator<_Iter> >
     : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value) {};