Index: libcxx/include/algorithm
===================================================================
--- libcxx/include/algorithm
+++ libcxx/include/algorithm
@@ -1631,7 +1631,7 @@
 
 // copy
 template <class _Iter>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 _Iter
 __unwrap_iter(_Iter __i)
 {
@@ -1639,7 +1639,7 @@
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     is_trivially_copy_assignable<_Tp>::value,
@@ -1653,7 +1653,7 @@
 #if _LIBCPP_DEBUG_LEVEL < 2
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     is_trivially_copy_assignable<_Tp>::value,
@@ -1665,7 +1665,7 @@
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     is_trivially_copy_assignable<_Tp>::value,
@@ -1679,7 +1679,7 @@
 #else
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     is_trivially_copy_assignable<_Tp>::value,
@@ -1832,17 +1832,25 @@
 // move
 
 template <class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 _OutputIterator
-__move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
+__move_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
     for (; __first != __last; ++__first, (void) ++__result)
         *__result = _VSTD::move(*__first);
     return __result;
 }
 
+template <class _InputIterator, class _OutputIterator>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+_OutputIterator
+__move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
+{
+    return __move_constexpr(__first, __last, __result);
+}
+
 template <class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
@@ -1851,6 +1859,13 @@
 >::type
 __move(_Tp* __first, _Tp* __last, _Up* __result)
 {
+#ifdef is_constant_evaluated
+    if (is_constant_evaluated())
+        return __move_constexpr(__first, __last, __result);
+#else // we must assume we are in a constexpr
+    return __move_constexpr(__first, __last, __result);
+#endif // is_constant_evaluated
+
     const size_t __n = static_cast<size_t>(__last - __first);
     if (__n > 0)
         _VSTD::memmove(__result, __first, __n * sizeof(_Up));
@@ -1858,7 +1873,7 @@
 }
 
 template <class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
 move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
@@ -1868,17 +1883,25 @@
 // move_backward
 
 template <class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 _OutputIterator
-__move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
+__move_backward_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
     while (__first != __last)
         *--__result = _VSTD::move(*--__last);
     return __result;
 }
 
+template <class _InputIterator, class _OutputIterator>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+_OutputIterator
+__move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
+{
+    return __move_backward_constexpr(__first, __last, __result);
+}
+
 template <class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     is_same<typename remove_const<_Tp>::type, _Up>::value &&
@@ -1887,6 +1910,13 @@
 >::type
 __move_backward(_Tp* __first, _Tp* __last, _Up* __result)
 {
+#ifdef is_constant_evaluated
+    if (is_constant_evaluated())
+        return __move_backward_constexpr(__first, __last, __result);
+#else // we must assume we are in a constexpr
+    return __move_backward_constexpr(__first, __last, __result);
+#endif // is_constant_evaluated
+
     const size_t __n = static_cast<size_t>(__last - __first);
     if (__n > 0)
     {
@@ -1897,7 +1927,7 @@
 }
 
 template <class _BidirectionalIterator1, class _BidirectionalIterator2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _BidirectionalIterator2
 move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
               _BidirectionalIterator2 __result)
@@ -2305,7 +2335,7 @@
 // rotate
 
 template <class _ForwardIterator>
-_ForwardIterator
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
 __rotate_left(_ForwardIterator __first, _ForwardIterator __last)
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
@@ -2316,7 +2346,7 @@
 }
 
 template <class _BidirectionalIterator>
-_BidirectionalIterator
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _BidirectionalIterator
 __rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last)
 {
     typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
@@ -2328,7 +2358,7 @@
 }
 
 template <class _ForwardIterator>
-_ForwardIterator
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
 __rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
 {
     _ForwardIterator __i = __middle;
@@ -2364,7 +2394,7 @@
 
 template<typename _Integral>
 inline _LIBCPP_INLINE_VISIBILITY
-_Integral
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _Integral
 __algo_gcd(_Integral __x, _Integral __y)
 {
     do
@@ -2377,7 +2407,7 @@
 }
 
 template<typename _RandomAccessIterator>
-_RandomAccessIterator
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator
 __rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
 {
     typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
@@ -2413,7 +2443,7 @@
 
 template <class _ForwardIterator>
 inline _LIBCPP_INLINE_VISIBILITY
-_ForwardIterator
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
 __rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
          _VSTD::forward_iterator_tag)
 {
@@ -2428,7 +2458,7 @@
 
 template <class _BidirectionalIterator>
 inline _LIBCPP_INLINE_VISIBILITY
-_BidirectionalIterator
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _BidirectionalIterator
 __rotate(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
          _VSTD::bidirectional_iterator_tag)
 {
@@ -2445,7 +2475,7 @@
 
 template <class _RandomAccessIterator>
 inline _LIBCPP_INLINE_VISIBILITY
-_RandomAccessIterator
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator
 __rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
          _VSTD::random_access_iterator_tag)
 {
@@ -2463,7 +2493,7 @@
 
 template <class _ForwardIterator>
 inline _LIBCPP_INLINE_VISIBILITY
-_ForwardIterator
+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
 rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
 {
     if (__first == __middle)
Index: libcxx/include/iterator
===================================================================
--- libcxx/include/iterator
+++ libcxx/include/iterator
@@ -1304,15 +1304,26 @@
 __wrap_iter<_Iter>
 operator+(typename __wrap_iter<_Iter>::difference_type, __wrap_iter<_Iter>) _NOEXCEPT;
 
-template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY copy(_Ip, _Ip, _Op);
-template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY copy_backward(_B1, _B1, _B2);
-template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY move(_Ip, _Ip, _Op);
-template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY move_backward(_B1, _B1, _B2);
+template <class _Ip, class _Op>
+_Op _LIBCPP_INLINE_VISIBILITY
+copy(_Ip, _Ip, _Op);
+
+template <class _B1, class _B2>
+_B2 _LIBCPP_INLINE_VISIBILITY
+copy_backward(_B1, _B1, _B2);
+
+template <class _Ip, class _Op>
+_Op _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+move(_Ip, _Ip, _Op);
+
+template <class _B1, class _B2>
+_B2 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+move_backward(_B1, _B1, _B2);
 
 #if _LIBCPP_DEBUG_LEVEL < 2
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     is_trivially_copy_assignable<_Tp>::value,
@@ -1323,7 +1334,7 @@
 #else
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename enable_if
 <
     is_trivially_copy_assignable<_Tp>::value,
@@ -1522,7 +1533,7 @@
 
 #if _LIBCPP_DEBUG_LEVEL < 2
     template <class _Tp>
-    _LIBCPP_CONSTEXPR_IF_NODEBUG friend
+    _LIBCPP_CONSTEXPR friend
     typename enable_if
     <
         is_trivially_copy_assignable<_Tp>::value,
@@ -1531,7 +1542,7 @@
     __unwrap_iter(__wrap_iter<_Tp*>);
 #else
   template <class _Tp>
-  inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
+  inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
   typename enable_if
   <
       is_trivially_copy_assignable<_Tp>::value,
Index: libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
===================================================================
--- libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
+++ libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
@@ -21,11 +21,11 @@
 #include "test_iterators.h"
 
 template <class InIter, class OutIter>
-void
+_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
 test()
 {
     const unsigned N = 1000;
-    int ia[N];
+    int ia[N] = {};
     for (unsigned i = 0; i < N; ++i)
         ia[i] = i;
     int ib[N] = {0};
@@ -34,6 +34,8 @@
     assert(base(r) == ib+N);
     for (unsigned i = 0; i < N; ++i)
         assert(ia[i] == ib[i]);
+
+    return true;
 }
 
 #if TEST_STD_VER >= 11
@@ -128,5 +130,37 @@
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
 
+#if TEST_STD_VER > 17
+    static_assert(test<input_iterator<const int*>, input_iterator<int*> >());
+    static_assert(test<input_iterator<const int*>, forward_iterator<int*> >());
+    static_assert(test<input_iterator<const int*>, bidirectional_iterator<int*> >());
+    static_assert(test<input_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<input_iterator<const int*>, int*>());
+
+    static_assert(test<forward_iterator<const int*>, input_iterator<int*> >());
+    static_assert(test<forward_iterator<const int*>, forward_iterator<int*> >());
+    static_assert(test<forward_iterator<const int*>, bidirectional_iterator<int*> >());
+    static_assert(test<forward_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<forward_iterator<const int*>, int*>());
+
+    static_assert(test<bidirectional_iterator<const int*>, input_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<const int*>, forward_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<const int*>, int*>());
+
+    static_assert(test<random_access_iterator<const int*>, input_iterator<int*> >());
+    static_assert(test<random_access_iterator<const int*>, forward_iterator<int*> >());
+    static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<int*> >());
+    static_assert(test<random_access_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<random_access_iterator<const int*>, int*>());
+
+    static_assert(test<const int*, input_iterator<int*> >());
+    static_assert(test<const int*, forward_iterator<int*> >());
+    static_assert(test<const int*, bidirectional_iterator<int*> >());
+    static_assert(test<const int*, random_access_iterator<int*> >());
+    static_assert(test<const int*, int*>());
+#endif  // TEST_STD_VER > 17
+
   return 0;
 }
Index: libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
===================================================================
--- libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
+++ libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
@@ -21,11 +21,11 @@
 #include "test_iterators.h"
 
 template <class InIter, class OutIter>
-void
+_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
 test()
 {
     const unsigned N = 1000;
-    int ia[N];
+    int ia[N] = {};
     for (unsigned i = 0; i < N; ++i)
         ia[i] = i;
     int ib[N] = {0};
@@ -34,6 +34,8 @@
     assert(base(r) == ib);
     for (unsigned i = 0; i < N; ++i)
         assert(ia[i] == ib[i]);
+
+    return true;
 }
 
 #if TEST_STD_VER >= 11
@@ -82,5 +84,19 @@
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
 
+#if TEST_STD_VER > 17
+    static_assert(test<bidirectional_iterator<const int*>, bidirectional_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<const int*>, int*>());
+
+    static_assert(test<random_access_iterator<const int*>, bidirectional_iterator<int*> >());
+    static_assert(test<random_access_iterator<const int*>, random_access_iterator<int*> >());
+    static_assert(test<random_access_iterator<const int*>, int*>());
+
+    static_assert(test<const int*, bidirectional_iterator<int*> >());
+    static_assert(test<const int*, random_access_iterator<int*> >());
+    static_assert(test<const int*, int*>());
+#endif  // TEST_STD_VER > 17
+
   return 0;
 }
Index: libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
===================================================================
--- libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
+++ libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_iterators.h"
 
 template <class Iter>
-void
+_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
 test()
 {
     int ia[] = {0};
@@ -209,6 +209,8 @@
     assert(ig[3] == 0);
     assert(ig[4] == 1);
     assert(ig[5] == 2);
+
+    return true;
 }
 
 #if TEST_STD_VER >= 11
@@ -419,6 +421,7 @@
 
 #endif  // TEST_STD_VER >= 11
 
+
 int main(int, char**)
 {
     test<forward_iterator<int*> >();
@@ -435,5 +438,12 @@
 
 #endif
 
+#if TEST_STD_VER > 17
+    static_assert(test<forward_iterator<int*> >());
+    static_assert(test<bidirectional_iterator<int*> >());
+    static_assert(test<random_access_iterator<int*> >());
+    static_assert(test<int*>());
+#endif  // TEST_STD_VER > 17
+
   return 0;
 }