Index: /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.members/real_imag.pass.cpp
===================================================================
--- /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.members/real_imag.pass.cpp	(revision 187354)
+++ /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.members/real_imag.pass.cpp	(working copy)
@@ -17,6 +17,23 @@
 
 template <class T>
 void
+test_constexpr()
+{
+#if _LIBCPP_STD_VER > 11
+    constexpr std::complex<T> c1;
+    static_assert(c1.real() == 0, "");
+    static_assert(c1.imag() == 0, "");
+    constexpr std::complex<T> c2(3);
+    static_assert(c2.real() == 3, "");
+    static_assert(c2.imag() == 0, "");
+    constexpr std::complex<T> c3(3, 4);
+    static_assert(c3.real() == 3, "");
+    static_assert(c3.imag() == 4, "");
+#endif
+}
+
+template <class T>
+void
 test()
 {
     std::complex<T> c;
@@ -34,6 +51,8 @@
     c.imag(-5.5);
     assert(c.real() == -4.5);
     assert(c.imag() == -5.5);
+
+    test_constexpr<T> ();
 }
 
 int main()
@@ -41,4 +60,5 @@
     test<float>();
     test<double>();
     test<long double>();
+    test_constexpr<int> ();
 }
Index: /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp
===================================================================
--- /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp	(revision 187354)
+++ /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/scalar_equals_complex.pass.cpp	(working copy)
@@ -18,9 +18,30 @@
 
 template <class T>
 void
-test(const T& lhs, const std::complex<T>& rhs, bool x)
+test_constexpr()
 {
-    assert((lhs == rhs) == x);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr T lhs(-2.5);
+    constexpr std::complex<T> rhs(1.5,  2.5);
+    static_assert(!(lhs == rhs), "");
+    }
+    {
+    constexpr T lhs(-2.5);
+    constexpr std::complex<T> rhs(1.5,  0);
+    static_assert(!(lhs == rhs), "");
+    }
+    {
+    constexpr T lhs(1.5);
+    constexpr std::complex<T> rhs(1.5, 2.5);
+    static_assert(!(lhs == rhs), "");
+    }
+    {
+    constexpr T lhs(1.5);
+    constexpr std::complex<T> rhs(1.5, 0);
+    static_assert(lhs == rhs, "");
+    }
+#endif
 }
 
 template <class T>
@@ -30,23 +51,25 @@
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  2.5);
-    test(lhs, rhs, false);
+    assert(!(lhs == rhs));
     }
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  0);
-    test(lhs, rhs, false);
+    assert(!(lhs == rhs));
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 2.5);
-    test(lhs, rhs, false);
+    assert(!(lhs == rhs));
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 0);
-    test(lhs, rhs, true);
+    assert(lhs == rhs);
     }
+
+    test_constexpr<T> ();
 }
 
 int main()
@@ -54,4 +77,5 @@
     test<float>();
     test<double>();
     test<long double>();
+//     test_constexpr<int>();
 }
Index: /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp
===================================================================
--- /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp	(revision 187354)
+++ /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/complex_equals_scalar.pass.cpp	(working copy)
@@ -18,9 +18,30 @@
 
 template <class T>
 void
-test(const std::complex<T>& lhs, const T& rhs, bool x)
+test_constexpr()
 {
-    assert((lhs == rhs) == x);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr std::complex<T> lhs(1.5, 2.5);
+    constexpr T rhs(-2.5);
+    static_assert(!(lhs == rhs), "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 0);
+    constexpr T rhs(-2.5);
+    static_assert(!(lhs == rhs), "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 2.5);
+    constexpr T rhs(1.5);
+    static_assert(!(lhs == rhs), "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 0);
+    constexpr T rhs(1.5);
+    static_assert( (lhs == rhs), "");
+    }
+#endif
 }
 
 template <class T>
@@ -30,28 +51,31 @@
     {
     std::complex<T> lhs(1.5,  2.5);
     T rhs(-2.5);
-    test(lhs, rhs, false);
+    assert(!(lhs == rhs));
     }
     {
-    std::complex<T> lhs(1.5,  0);
+    std::complex<T> lhs(1.5, 0);
     T rhs(-2.5);
-    test(lhs, rhs, false);
+    assert(!(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     T rhs(1.5);
-    test(lhs, rhs, false);
+    assert(!(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 0);
     T rhs(1.5);
-    test(lhs, rhs, true);
+    assert( (lhs == rhs));
     }
-}
 
+    test_constexpr<T> ();
+    }
+
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
+//     test_constexpr<int> ();
 }
Index: /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp
===================================================================
--- /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp	(revision 187354)
+++ /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/complex_equals_complex.pass.cpp	(working copy)
@@ -18,9 +18,20 @@
 
 template <class T>
 void
-test(const std::complex<T>& lhs, const std::complex<T>& rhs, bool x)
+test_constexpr()
 {
-    assert((lhs == rhs) == x);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr std::complex<T> lhs(1.5,  2.5);
+    constexpr std::complex<T> rhs(1.5, -2.5);
+    static_assert( !(lhs == rhs), "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 2.5);
+    constexpr std::complex<T> rhs(1.5, 2.5);
+    static_assert(lhs == rhs, "");
+    }
+#endif
 }
 
 template <class T>
@@ -30,13 +41,14 @@
     {
     std::complex<T> lhs(1.5,  2.5);
     std::complex<T> rhs(1.5, -2.5);
-    test(lhs, rhs, false);
+    assert( !(lhs == rhs));
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     std::complex<T> rhs(1.5, 2.5);
-    test(lhs, rhs, true);
+    assert(lhs == rhs);
     }
+    test_constexpr<T> ();
 }
 
 int main()
@@ -44,4 +56,5 @@
     test<float>();
     test<double>();
     test<long double>();
+//    test_constexpr<int> ();
 }
Index: /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp
===================================================================
--- /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp	(revision 187354)
+++ /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/scalar_not_equals_complex.pass.cpp	(working copy)
@@ -18,9 +18,30 @@
 
 template <class T>
 void
-test(const T& lhs, const std::complex<T>& rhs, bool x)
+test_constexpr()
 {
-    assert((lhs != rhs) == x);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr T lhs(-2.5);
+    constexpr std::complex<T> rhs(1.5,  2.5);
+    static_assert (lhs != rhs, "");
+    }
+    {
+    constexpr T lhs(-2.5);
+    constexpr std::complex<T> rhs(1.5,  0);
+    static_assert (lhs != rhs, "");
+    }
+    {
+    constexpr T lhs(1.5);
+    constexpr std::complex<T> rhs(1.5, 2.5);
+    static_assert (lhs != rhs, "");
+    }
+    {
+    constexpr T lhs(1.5);
+    constexpr std::complex<T> rhs(1.5, 0);
+    static_assert (!(lhs != rhs), "");
+    }
+#endif
 }
 
 template <class T>
@@ -30,28 +51,31 @@
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  2.5);
-    test(lhs, rhs, true);
+    assert (lhs != rhs);
     }
     {
     T lhs(-2.5);
     std::complex<T> rhs(1.5,  0);
-    test(lhs, rhs, true);
+    assert (lhs != rhs);
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 2.5);
-    test(lhs, rhs, true);
+    assert (lhs != rhs);
     }
     {
     T lhs(1.5);
     std::complex<T> rhs(1.5, 0);
-    test(lhs, rhs, false);
+    assert (!(lhs != rhs));
     }
-}
 
+    test_constexpr<T> ();
+    }
+
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
+//     test_constexpr<int>();
 }
Index: /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp
===================================================================
--- /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp	(revision 187354)
+++ /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/complex_not_equals_scalar.pass.cpp	(working copy)
@@ -18,9 +18,30 @@
 
 template <class T>
 void
-test(const std::complex<T>& lhs, const T& rhs, bool x)
+test_constexpr()
 {
-    assert((lhs != rhs) == x);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr std::complex<T> lhs(1.5,  2.5);
+    constexpr T rhs(-2.5);
+    static_assert(lhs != rhs, "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5,  0);
+    constexpr T rhs(-2.5);
+    static_assert(lhs != rhs, "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 2.5);
+    constexpr T rhs(1.5);
+    static_assert(lhs != rhs, "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 0);
+    constexpr T rhs(1.5);
+    static_assert( !(lhs != rhs), "");
+    }
+#endif
 }
 
 template <class T>
@@ -30,23 +51,25 @@
     {
     std::complex<T> lhs(1.5,  2.5);
     T rhs(-2.5);
-    test(lhs, rhs, true);
+    assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5,  0);
     T rhs(-2.5);
-    test(lhs, rhs, true);
+    assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     T rhs(1.5);
-    test(lhs, rhs, true);
+    assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5, 0);
     T rhs(1.5);
-    test(lhs, rhs, false);
+    assert( !(lhs != rhs));
     }
+
+    test_constexpr<T> ();
 }
 
 int main()
@@ -54,4 +77,5 @@
     test<float>();
     test<double>();
     test<long double>();
-}
+//     test_constexpr<int> ();
+    }
Index: /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp
===================================================================
--- /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp	(revision 187354)
+++ /Users/mclow/Projects/LLVM/libcxx/test/numerics/complex.number/complex.ops/complex_not_equals_complex.pass.cpp	(working copy)
@@ -18,11 +18,23 @@
 
 template <class T>
 void
-test(const std::complex<T>& lhs, const std::complex<T>& rhs, bool x)
+test_constexpr()
 {
-    assert((lhs != rhs) == x);
+#if _LIBCPP_STD_VER > 11
+    {
+    constexpr std::complex<T> lhs(1.5,  2.5);
+    constexpr std::complex<T> rhs(1.5, -2.5);
+    static_assert(lhs != rhs, "");
+    }
+    {
+    constexpr std::complex<T> lhs(1.5, 2.5);
+    constexpr std::complex<T> rhs(1.5, 2.5);
+    static_assert(!(lhs != rhs), "" );
+    }
+#endif
 }
 
+
 template <class T>
 void
 test()
@@ -30,18 +42,21 @@
     {
     std::complex<T> lhs(1.5,  2.5);
     std::complex<T> rhs(1.5, -2.5);
-    test(lhs, rhs, true);
+    assert(lhs != rhs);
     }
     {
     std::complex<T> lhs(1.5, 2.5);
     std::complex<T> rhs(1.5, 2.5);
-    test(lhs, rhs, false);
+    assert(!(lhs != rhs));
     }
-}
 
+	test_constexpr<T> ();
+	}
+
 int main()
 {
     test<float>();
     test<double>();
     test<long double>();
+//   test_constexpr<int> ();
 }
Index: /Users/mclow/Projects/LLVM/libcxx/include/complex
===================================================================
--- /Users/mclow/Projects/LLVM/libcxx/include/complex	(revision 187354)
+++ /Users/mclow/Projects/LLVM/libcxx/include/complex	(working copy)
@@ -23,12 +23,12 @@
 public:
     typedef T value_type;
 
-    complex(const T& re = T(), const T& im = T());
-    complex(const complex&);
-    template<class X> complex(const complex<X>&);
+    complex(const T& re = T(), const T& im = T()); // constexpr in C++14
+    complex(const complex&);  // constexpr in C++14
+    template<class X> complex(const complex<X>&);  // constexpr in C++14
 
-    T real() const;
-    T imag() const;
+    T real() const; // constexpr in C++14
+    T imag() const; // constexpr in C++14
 
     void real(T);
     void imag(T);
@@ -149,12 +149,12 @@
 template<class T> complex<T> operator/(const T&, const complex<T>&);
 template<class T> complex<T> operator+(const complex<T>&);
 template<class T> complex<T> operator-(const complex<T>&);
-template<class T> bool operator==(const complex<T>&, const complex<T>&);
-template<class T> bool operator==(const complex<T>&, const T&);
-template<class T> bool operator==(const T&, const complex<T>&);
-template<class T> bool operator!=(const complex<T>&, const complex<T>&);
-template<class T> bool operator!=(const complex<T>&, const T&);
-template<class T> bool operator!=(const T&, const complex<T>&);
+template<class T> bool operator==(const complex<T>&, const complex<T>&); // constexpr in C++14
+template<class T> bool operator==(const complex<T>&, const T&); // constexpr in C++14
+template<class T> bool operator==(const T&, const complex<T>&); // constexpr in C++14
+template<class T> bool operator!=(const complex<T>&, const complex<T>&); // constexpr in C++14
+template<class T> bool operator!=(const complex<T>&, const T&); // constexpr in C++14
+template<class T> bool operator!=(const T&, const complex<T>&); // constexpr in C++14
 
 template<class T, class charT, class traits>
   basic_istream<charT, traits>&
@@ -269,15 +269,15 @@
     value_type __re_;
     value_type __im_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     complex(const value_type& __re = value_type(), const value_type& __im = value_type())
         : __re_(__re), __im_(__im) {}
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY
+    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     complex(const complex<_Xp>& __c)
         : __re_(__c.real()), __im_(__c.imag()) {}
 
-    _LIBCPP_INLINE_VISIBILITY value_type real() const {return __re_;}
-    _LIBCPP_INLINE_VISIBILITY value_type imag() const {return __im_;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 value_type real() const {return __re_;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 value_type imag() const {return __im_;}
 
     _LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
     _LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
@@ -740,7 +740,7 @@
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
 {
@@ -748,7 +748,7 @@
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator==(const complex<_Tp>& __x, const _Tp& __y)
 {
@@ -756,7 +756,7 @@
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator==(const _Tp& __x, const complex<_Tp>& __y)
 {
@@ -764,7 +764,7 @@
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
 {
@@ -772,7 +772,7 @@
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator!=(const complex<_Tp>& __x, const _Tp& __y)
 {
@@ -780,7 +780,7 @@
 }
 
 template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator!=(const _Tp& __x, const complex<_Tp>& __y)
 {