Index: include/algorithm
===================================================================
--- include/algorithm	(revision 201571)
+++ include/algorithm	(working copy)
@@ -528,19 +528,19 @@
 
 template <class T>
     const T&
-    min(const T& a, const T& b);
+    min(const T& a, const T& b);  // constexpr in C++14
 
 template <class T, class Compare>
     const T&
-    min(const T& a, const T& b, Compare comp);
+    min(const T& a, const T& b, Compare comp);  // constexpr in C++14
 
 template<class T>
     T
-    min(initializer_list<T> t);
+    min(initializer_list<T> t);  // constexpr in C++14
 
 template<class T, class Compare>
     T
-    min(initializer_list<T> t, Compare comp);
+    min(initializer_list<T> t, Compare comp);  // constexpr in C++14
 
 template <class ForwardIterator>
     ForwardIterator
@@ -552,19 +552,19 @@
 
 template <class T>
     const T&
-    max(const T& a, const T& b);
+    max(const T& a, const T& b); // constexpr in C++14
 
 template <class T, class Compare>
     const T&
-    max(const T& a, const T& b, Compare comp);
+    max(const T& a, const T& b, Compare comp);  // constexpr in C++14
 
 template<class T>
     T
-    max(initializer_list<T> t);
+    max(initializer_list<T> t);  // constexpr in C++14
 
 template<class T, class Compare>
     T
-    max(initializer_list<T> t, Compare comp);
+    max(initializer_list<T> t, Compare comp);  // constexpr in C++14
 
 template<class ForwardIterator>
     pair<ForwardIterator, ForwardIterator>
@@ -576,19 +576,19 @@
 
 template<class T>
     pair<const T&, const T&>
-    minmax(const T& a, const T& b);
+    minmax(const T& a, const T& b);  // constexpr in C++14
 
 template<class T, class Compare>
     pair<const T&, const T&>
-    minmax(const T& a, const T& b, Compare comp);
+    minmax(const T& a, const T& b, Compare comp);  // constexpr in C++14
 
 template<class T>
     pair<T, T>
-    minmax(initializer_list<T> t);
+    minmax(initializer_list<T> t);  // constexpr in C++14
 
 template<class T, class Compare>
     pair<T, T>
-    minmax(initializer_list<T> t, Compare comp);
+    minmax(initializer_list<T> t, Compare comp);  // constexpr in C++14
 
 template <class InputIterator1, class InputIterator2>
     bool
@@ -643,6 +643,9 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+// I'd like to replace these with _VSTD::equal_to<void>, but can't because:
+//   * That only works with C++14 and later, and
+//   * We haven't included <functional> here.
 template <class _T1, class _T2 = _T1>
 struct __equal_to
 {
@@ -655,46 +658,59 @@
 template <class _T1>
 struct __equal_to<_T1, _T1>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
 };
 
 template <class _T1>
 struct __equal_to<const _T1, _T1>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
 };
 
 template <class _T1>
 struct __equal_to<_T1, const _T1>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    bool operator() (const _T1& __x, const _T1& __y) const {return __x == __y;}
 };
 
 template <class _T1, class _T2 = _T1>
 struct __less
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;}
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;}
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T2& __y) const {return __x < __y;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 
+    bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
+
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;}
+
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;}
+
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()
+    (const _T2& __x, const _T2& __y) const {return __x < __y;}
 };
 
 template <class _T1>
 struct __less<_T1, _T1>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
 };
 
 template <class _T1>
 struct __less<const _T1, _T1>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
 };
 
 template <class _T1>
 struct __less<_T1, const _T1>
 {
-    _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
 };
 
 template <class _Predicate>
@@ -2505,9 +2521,9 @@
 // min_element
 
 template <class _ForwardIterator, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _ForwardIterator
-min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
+__min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
 {
     if (__first != __last)
     {
@@ -2519,19 +2535,27 @@
     return __first;
 }
 
+template <class _ForwardIterator, class _Compare>
+inline _LIBCPP_INLINE_VISIBILITY
+_ForwardIterator
+min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
+{
+    return __min_element(__first, __last, __comp);
+}
+
 template <class _ForwardIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 min_element(_ForwardIterator __first, _ForwardIterator __last)
 {
-    return _VSTD::min_element(__first, __last,
+    return __min_element(__first, __last,
               __less<typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
 // min
 
 template <class _Tp, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 const _Tp&
 min(const _Tp& __a, const _Tp& __b, _Compare __comp)
 {
@@ -2539,7 +2563,7 @@
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 const _Tp&
 min(const _Tp& __a, const _Tp& __b)
 {
@@ -2549,19 +2573,19 @@
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template<class _Tp, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp
 min(initializer_list<_Tp> __t, _Compare __comp)
 {
-    return *_VSTD::min_element(__t.begin(), __t.end(), __comp);
+    return *__min_element(__t.begin(), __t.end(), __comp);
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp
 min(initializer_list<_Tp> __t)
 {
-    return *_VSTD::min_element(__t.begin(), __t.end());
+    return *__min_element(__t.begin(), __t.end(), __less<_Tp>());
 }
 
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
@@ -2569,9 +2593,9 @@
 // max_element
 
 template <class _ForwardIterator, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _ForwardIterator
-max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
+__max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
 {
     if (__first != __last)
     {
@@ -2583,19 +2607,28 @@
     return __first;
 }
 
+
+template <class _ForwardIterator, class _Compare>
+inline _LIBCPP_INLINE_VISIBILITY
+_ForwardIterator
+max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
+{
+    return __max_element(__first, __last, __comp);
+}
+
 template <class _ForwardIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 max_element(_ForwardIterator __first, _ForwardIterator __last)
 {
-    return _VSTD::max_element(__first, __last,
+    return __max_element(__first, __last,
               __less<typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
 // max
 
 template <class _Tp, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 const _Tp&
 max(const _Tp& __a, const _Tp& __b, _Compare __comp)
 {
@@ -2603,7 +2636,7 @@
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 const _Tp&
 max(const _Tp& __a, const _Tp& __b)
 {
@@ -2613,19 +2646,19 @@
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template<class _Tp, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp
 max(initializer_list<_Tp> __t, _Compare __comp)
 {
-    return *_VSTD::max_element(__t.begin(), __t.end(), __comp);
+    return *__max_element(__t.begin(), __t.end(), __comp);
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 _Tp
 max(initializer_list<_Tp> __t)
 {
-    return *_VSTD::max_element(__t.begin(), __t.end());
+    return *__max_element(__t.begin(), __t.end(), __less<_Tp>());
 }
 
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
@@ -2684,13 +2717,14 @@
 std::pair<_ForwardIterator, _ForwardIterator>
 minmax_element(_ForwardIterator __first, _ForwardIterator __last)
 {
-    return _VSTD::minmax_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
+    return _VSTD::minmax_element(__first, __last,
+              __less<typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
 // minmax
 
 template<class _Tp, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 pair<const _Tp&, const _Tp&>
 minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
 {
@@ -2699,7 +2733,7 @@
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 pair<const _Tp&, const _Tp&>
 minmax(const _Tp& __a, const _Tp& __b)
 {
@@ -2709,22 +2743,22 @@
 #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY // _LIBCPP_CONSTEXPR_AFTER_CXX11
 pair<_Tp, _Tp>
 minmax(initializer_list<_Tp> __t)
 {
     pair<const _Tp*, const _Tp*> __p =
-                                   _VSTD::minmax_element(__t.begin(), __t.end());
+                   _VSTD::minmax_element(__t.begin(), __t.end(), __less<_Tp>());
     return pair<_Tp, _Tp>(*__p.first, *__p.second);
 }
 
 template<class _Tp, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY // _LIBCPP_CONSTEXPR_AFTER_CXX11
 pair<_Tp, _Tp>
 minmax(initializer_list<_Tp> __t, _Compare __comp)
 {
     pair<const _Tp*, const _Tp*> __p =
-                           _VSTD::minmax_element(__t.begin(), __t.end(), __comp);
+                          _VSTD::minmax_element(__t.begin(), __t.end(), __comp);
     return pair<_Tp, _Tp>(*__p.first, *__p.second);
 }
 
Index: test/algorithms/alg.sorting/alg.min.max/max.pass.cpp
===================================================================
--- test/algorithms/alg.sorting/alg.min.max/max.pass.cpp	(revision 201571)
+++ test/algorithms/alg.sorting/alg.min.max/max.pass.cpp	(working copy)
@@ -43,4 +43,12 @@
     test(x, y, x);
     test(y, x, x);
     }
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr int x = 1;
+    constexpr int y = 0;
+    static_assert ( std::max (x, y) == x, "" );
+    static_assert ( std::max (y, x) == x, "" );
+    }
+#endif
 }
Index: test/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
===================================================================
--- test/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp	(revision 201571)
+++ test/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp	(working copy)
@@ -45,4 +45,12 @@
     test(x, y, std::greater<int>(), y);
     test(y, x, std::greater<int>(), y);
     }
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr int x = 1;
+    constexpr int y = 0;
+    static_assert ( std::max (x, y, std::greater<int>()) == y, "" );
+    static_assert ( std::max (y, x, std::greater<int>()) == y, "" );
+    }
+#endif
 }
Index: test/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp
===================================================================
--- test/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp	(revision 201571)
+++ test/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp	(working copy)
@@ -31,5 +31,15 @@
     assert(i == 3);
     i = std::max({1, 3, 2});
     assert(i == 3);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr int i = std::max({1, 3, 2});
+    static_assert(i == 3, "");
+    constexpr int j = std::max({2, 1, 3});
+    static_assert(j == 3, "");
+    constexpr int k = std::max({3, 2, 1});
+    static_assert(k == 3, "");
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
Index: test/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp
===================================================================
--- test/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp	(revision 201571)
+++ test/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp	(working copy)
@@ -32,5 +32,15 @@
     assert(i == 1);
     i = std::max({1, 3, 2}, std::greater<int>());
     assert(i == 1);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr int i = std::max({1, 3, 2}, std::greater<int>());
+    static_assert(i == 1, "");
+    constexpr int j = std::max({2, 1, 3}, std::greater<int>());
+    static_assert(j == 1, "");
+    constexpr int k = std::max({3, 2, 1}, std::greater<int>());
+    static_assert(k == 1, "");
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
Index: test/algorithms/alg.sorting/alg.min.max/min.pass.cpp
===================================================================
--- test/algorithms/alg.sorting/alg.min.max/min.pass.cpp	(revision 201571)
+++ test/algorithms/alg.sorting/alg.min.max/min.pass.cpp	(working copy)
@@ -43,4 +43,12 @@
     test(x, y, y);
     test(y, x, y);
     }
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr int x = 1;
+    constexpr int y = 0;
+    static_assert ( std::min (x, y) == y, "" );
+    static_assert ( std::min (y, x) == y, "" );
+    }
+#endif
 }
Index: test/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
===================================================================
--- test/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp	(revision 201571)
+++ test/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp	(working copy)
@@ -45,4 +45,12 @@
     test(x, y, std::greater<int>(), x);
     test(y, x, std::greater<int>(), x);
     }
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr int x = 1;
+    constexpr int y = 0;
+    static_assert ( std::min (x, y, std::greater<int>()) == x, "" );
+    static_assert ( std::min (y, x, std::greater<int>()) == x, "" );
+    }
+#endif
 }
Index: test/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp
===================================================================
--- test/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp	(revision 201571)
+++ test/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp	(working copy)
@@ -31,5 +31,15 @@
     assert(i == 1);
     i = std::min({1, 3, 2});
     assert(i == 1);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr int i = std::min({1, 3, 2});
+    static_assert(i == 1, "");
+    constexpr int j = std::min({2, 1, 3});
+    static_assert(j == 1, "");
+    constexpr int k = std::min({3, 2, 1});
+    static_assert(k == 1, "");
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
Index: test/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp
===================================================================
--- test/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp	(revision 201571)
+++ test/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp	(working copy)
@@ -32,5 +32,15 @@
     assert(i == 3);
     i = std::min({1, 3, 2}, std::greater<int>());
     assert(i == 3);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr int i = std::min({1, 3, 2}, std::greater<int>());
+    static_assert(i == 3, "");
+    constexpr int j = std::min({2, 1, 3}, std::greater<int>());
+    static_assert(j == 3, "");
+    constexpr int k = std::min({3, 2, 1}, std::greater<int>());
+    static_assert(k == 3, "");
+    }
+#endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
Index: test/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp
===================================================================
--- test/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp	(revision 201571)
+++ test/algorithms/alg.sorting/alg.min.max/minmax.pass.cpp	(working copy)
@@ -1,6 +1,6 @@
 //===----------------------------------------------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
+//					   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.
@@ -10,8 +10,8 @@
 // <algorithm>
 
 // template<LessThanComparable T>
-//   pair<const T&, const T&>
-//   minmax(const T& a, const T& b);
+//	 pair<const T&, const T&>
+//	 minmax(const T& a, const T& b);
 
 #include <algorithm>
 #include <cassert>
@@ -20,29 +20,43 @@
 void
 test(const T& a, const T& b, const T& x, const T& y)
 {
-    std::pair<const T&, const T&> p = std::minmax(a, b);
-    assert(&p.first == &x);
-    assert(&p.second == &y);
+	std::pair<const T&, const T&> p = std::minmax(a, b);
+	assert(&p.first == &x);
+	assert(&p.second == &y);
 }
 
 int main()
 {
-    {
-    int x = 0;
-    int y = 0;
-    test(x, y, x, y);
-    test(y, x, y, x);
-    }
-    {
-    int x = 0;
-    int y = 1;
-    test(x, y, x, y);
-    test(y, x, x, y);
-    }
-    {
-    int x = 1;
-    int y = 0;
-    test(x, y, y, x);
-    test(y, x, y, x);
-    }
+	{
+	int x = 0;
+	int y = 0;
+	test(x, y, x, y);
+	test(y, x, y, x);
+	}
+	{
+	int x = 0;
+	int y = 1;
+	test(x, y, x, y);
+	test(y, x, x, y);
+	}
+	{
+	int x = 1;
+	int y = 0;
+	test(x, y, y, x);
+	test(y, x, y, x);
+	}
+#if _LIBCPP_STD_VER > 11
+	{
+//	Note that you can't take a reference to a local var, since 
+//	it's address is not a compile-time constant.
+	constexpr static int x = 1;
+	constexpr static int y = 0;
+	constexpr auto p1 = std::minmax (x, y);
+	static_assert ( p1.first  == y, "" );
+	static_assert ( p1.second == x, "" );
+	constexpr auto p2 = std::minmax (y, x);
+	static_assert ( p2.first  == y, "" );
+	static_assert ( p2.second == x, "" );
+	}
+#endif
 }
Index: test/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
===================================================================
--- test/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp	(revision 201571)
+++ test/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp	(working copy)
@@ -27,6 +27,7 @@
     assert(&p.second == &y);
 }
 
+
 int main()
 {
     {
@@ -47,4 +48,18 @@
     test(x, y, std::greater<int>(), x, y);
     test(y, x, std::greater<int>(), x, y);
     }
+#if _LIBCPP_STD_VER > 11
+    {
+//	Note that you can't take a reference to a local var, since 
+//	it's address is not a compile-time constant.
+    constexpr static int x = 1;
+    constexpr static int y = 0;
+    constexpr auto p1 = std::minmax (x, y, std::greater<>());
+    static_assert ( p1.first  == x, "" );
+    static_assert ( p1.second == y, "" );
+    constexpr auto p2 = std::minmax (y, x, std::greater<>());
+    static_assert ( p2.first  == x, "" );
+    static_assert ( p2.second == y, "" );
+    }
+#endif
 }
Index: test/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp
===================================================================
--- test/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp	(revision 201571)
+++ test/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp	(working copy)
@@ -25,5 +25,23 @@
     assert((std::minmax({2, 3, 1}) == std::pair<int, int>(1, 3)));
     assert((std::minmax({3, 1, 2}) == std::pair<int, int>(1, 3)));
     assert((std::minmax({3, 2, 1}) == std::pair<int, int>(1, 3)));
+// #if _LIBCPP_STD_VER > 11
+//     {
+//     constexpr static std::initializer_list<int> il1 {1, 2, 3};
+//     constexpr static std::initializer_list<int> il2 {2, 3, 1};
+//     constexpr static std::initializer_list<int> il3 {3, 1, 2};
+//     constexpr std::pair<const int&, const int&> p1 = std::minmax(il1);
+//     static_assert ( p1.first  == 1, "" );
+//     static_assert ( p1.second == 3, "" );
+// 
+//     constexpr std::pair<const int&, const int&> p2 = std::minmax(il2);
+//     static_assert ( p2.first  == 1, "" );
+//     static_assert ( p2.second == 3, "" );
+//     
+//     constexpr std::pair<const int&, const int&> p3 = std::minmax(il3);
+//     static_assert ( p3.first  == 1, "" );
+//     static_assert ( p3.second == 3, "" );
+//     }
+// #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }
Index: test/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
===================================================================
--- test/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp	(revision 201571)
+++ test/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp	(working copy)
@@ -26,5 +26,23 @@
     assert((std::minmax({2, 3, 1}, std::greater<int>()) == std::pair<int, int>(3, 1)));
     assert((std::minmax({3, 1, 2}, std::greater<int>()) == std::pair<int, int>(3, 1)));
     assert((std::minmax({3, 2, 1}, std::greater<int>()) == std::pair<int, int>(3, 1)));
+// #if _LIBCPP_STD_VER > 11
+//     {
+//     constexpr static std::initializer_list<int> il1 {1, 2, 3};
+//     constexpr static std::initializer_list<int> il2 {2, 3, 1};
+//     constexpr static std::initializer_list<int> il3 {3, 1, 2};
+//     constexpr std::pair<const int&, const int&> p1 = std::minmax(il1, std::greater<>());
+//     static_assert ( p1.first  == 3, "" );
+//     static_assert ( p1.second == 1, "" );
+// 
+//     constexpr std::pair<const int&, const int&> p2 = std::minmax(il2, std::greater<>());
+//     static_assert ( p2.first  == 3, "" );
+//     static_assert ( p2.second == 1, "" );
+//     
+//     constexpr std::pair<const int&, const int&> p3 = std::minmax(il3, std::greater<>());
+//     static_assert ( p3.first  == 3, "" );
+//     static_assert ( p3.second == 1, "" );
+//     }
+// #endif
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 }