Vendor import of libc++ trunk r307894:vendor/libc++/libc++-trunk-r307894

https://llvm.org/svn/llvm-project/libcxx/trunk@307894

32 files changed, 855 insertions, 427 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5b5971036b88..1f8b24d17e24 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -352,6 +352,13 @@ else()
 endif()
 file(MAKE_DIRECTORY "${LIBCXX_BINARY_INCLUDE_DIR}")
 
+set(LIBCXX_INSTALL_PREFIX "" CACHE STRING
+    "Define libc++ destination prefix.")
+
+if (NOT LIBCXX_INSTALL_PREFIX MATCHES "^$|.*/")
+  message(FATAL_ERROR "LIBCXX_INSTALL_PREFIX has to end with \"/\".")
+endif()
+
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LIBCXX_LIBRARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LIBCXX_LIBRARY_DIR})
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LIBCXX_LIBRARY_DIR})
diff --git a/cmake/Modules/HandleLibCXXABI.cmake b/cmake/Modules/HandleLibCXXABI.cmake
index b404e36c1480..b1f6bee8f945 100644
--- a/cmake/Modules/HandleLibCXXABI.cmake
+++ b/cmake/Modules/HandleLibCXXABI.cmake
@@ -55,7 +55,7 @@ macro(setup_abi_lib abidefines abilib abifiles abidirs)
           )
         if (LIBCXX_INSTALL_HEADERS)
           install(FILES "${LIBCXX_BINARY_INCLUDE_DIR}/${fpath}"
-            DESTINATION include/c++/v1/${dstdir}
+            DESTINATION ${LIBCXX_INSTALL_PREFIX}include/c++/v1/${dstdir}
             COMPONENT libcxx
             PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
             )
diff --git a/docs/BuildingLibcxx.rst b/docs/BuildingLibcxx.rst
index c7b5e96422f0..81a7c2341473 100644
--- a/docs/BuildingLibcxx.rst
+++ b/docs/BuildingLibcxx.rst
@@ -216,6 +216,11 @@ libc++ specific options
   Extra suffix to append to the directory where libraries are to be installed.
   This option overrides `LLVM_LIBDIR_SUFFIX`.
 
+.. option:: LIBCXX_INSTALL_PREFIX:STRING
+
+  **Default**: ``""``
+
+  Define libc++ destination prefix.
 
 .. _libc++experimental options:
 
diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index 1c6790ab4652..5a1b2ccdc426 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -20,7 +20,7 @@ endif()
 
 if (LIBCXX_INSTALL_HEADERS)
   install(DIRECTORY .
-    DESTINATION include/c++/v1
+    DESTINATION ${LIBCXX_INSTALL_PREFIX}include/c++/v1
     COMPONENT cxx-headers
     FILES_MATCHING
     ${LIBCXX_HEADER_PATTERN}
@@ -44,7 +44,7 @@ if (LIBCXX_INSTALL_HEADERS)
     set(generated_config_deps generate_config_header)
     # Install the generated header as __config.
     install(FILES ${LIBCXX_BINARY_DIR}/__generated_config
-      DESTINATION include/c++/v1
+      DESTINATION ${LIBCXX_INSTALL_PREFIX}include/c++/v1
       PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
       RENAME __config
       COMPONENT cxx-headers)
diff --git a/include/cmath b/include/cmath
index b41f247af59c..917928a1f42f 100644
--- a/include/cmath
+++ b/include/cmath
@@ -549,7 +549,7 @@ hypot(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT
 template <class _A1>
 _LIBCPP_ALWAYS_INLINE
 _LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
-__libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT
+__libcpp_isnan_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_isnan)
     return __builtin_isnan(__lcpp_x);
@@ -561,7 +561,7 @@ __libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT
 template <class _A1>
 _LIBCPP_ALWAYS_INLINE
 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
-__libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT
+__libcpp_isnan_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 {
     return isnan(__lcpp_x);
 }
@@ -569,7 +569,7 @@ __libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT
 template <class _A1>
 _LIBCPP_ALWAYS_INLINE
 _LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
-__libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT
+__libcpp_isinf_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_isinf)
     return __builtin_isinf(__lcpp_x);
@@ -581,7 +581,7 @@ __libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT
 template <class _A1>
 _LIBCPP_ALWAYS_INLINE
 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
-__libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT
+__libcpp_isinf_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 {
     return isinf(__lcpp_x);
 }
@@ -589,7 +589,7 @@ __libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT
 template <class _A1>
 _LIBCPP_ALWAYS_INLINE
 _LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
-__libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT
+__libcpp_isfinite_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_isfinite)
     return __builtin_isfinite(__lcpp_x);
@@ -601,7 +601,7 @@ __libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT
 template <class _A1>
 _LIBCPP_ALWAYS_INLINE
 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
-__libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT
+__libcpp_isfinite_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 {
     return isfinite(__lcpp_x);
 }
diff --git a/include/complex b/include/complex
index d41971b3b4db..41a47cfba47c 100644
--- a/include/complex
+++ b/include/complex
@@ -599,39 +599,39 @@ operator*(const complex<_Tp>& __z, const complex<_Tp>& __w)
     _Tp __bc = __b * __c;
     _Tp __x = __ac - __bd;
     _Tp __y = __ad + __bc;
-    if (__libcpp_isnan(__x) && __libcpp_isnan(__y))
+    if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
     {
         bool __recalc = false;
-        if (__libcpp_isinf(__a) || __libcpp_isinf(__b))
+        if (__libcpp_isinf_or_builtin(__a) || __libcpp_isinf_or_builtin(__b))
         {
-            __a = copysign(__libcpp_isinf(__a) ? _Tp(1) : _Tp(0), __a);
-            __b = copysign(__libcpp_isinf(__b) ? _Tp(1) : _Tp(0), __b);
-            if (__libcpp_isnan(__c))
+            __a = copysign(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
+            __b = copysign(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
+            if (__libcpp_isnan_or_builtin(__c))
                 __c = copysign(_Tp(0), __c);
-            if (__libcpp_isnan(__d))
+            if (__libcpp_isnan_or_builtin(__d))
                 __d = copysign(_Tp(0), __d);
             __recalc = true;
         }
-        if (__libcpp_isinf(__c) || __libcpp_isinf(__d))
+        if (__libcpp_isinf_or_builtin(__c) || __libcpp_isinf_or_builtin(__d))
         {
-            __c = copysign(__libcpp_isinf(__c) ? _Tp(1) : _Tp(0), __c);
-            __d = copysign(__libcpp_isinf(__d) ? _Tp(1) : _Tp(0), __d);
-            if (__libcpp_isnan(__a))
+            __c = copysign(__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
+            __d = copysign(__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
+            if (__libcpp_isnan_or_builtin(__a))
                 __a = copysign(_Tp(0), __a);
-            if (__libcpp_isnan(__b))
+            if (__libcpp_isnan_or_builtin(__b))
                 __b = copysign(_Tp(0), __b);
             __recalc = true;
         }
-        if (!__recalc && (__libcpp_isinf(__ac) || __libcpp_isinf(__bd) ||
-                          __libcpp_isinf(__ad) || __libcpp_isinf(__bc)))
+        if (!__recalc && (__libcpp_isinf_or_builtin(__ac) || __libcpp_isinf_or_builtin(__bd) ||
+                          __libcpp_isinf_or_builtin(__ad) || __libcpp_isinf_or_builtin(__bc)))
         {
-            if (__libcpp_isnan(__a))
+            if (__libcpp_isnan_or_builtin(__a))
                 __a = copysign(_Tp(0), __a);
-            if (__libcpp_isnan(__b))
+            if (__libcpp_isnan_or_builtin(__b))
                 __b = copysign(_Tp(0), __b);
-            if (__libcpp_isnan(__c))
+            if (__libcpp_isnan_or_builtin(__c))
                 __c = copysign(_Tp(0), __c);
-            if (__libcpp_isnan(__d))
+            if (__libcpp_isnan_or_builtin(__d))
                 __d = copysign(_Tp(0), __d);
             __recalc = true;
         }
@@ -674,7 +674,7 @@ operator/(const complex<_Tp>& __z, const complex<_Tp>& __w)
     _Tp __c = __w.real();
     _Tp __d = __w.imag();
     _Tp __logbw = logb(fmax(fabs(__c), fabs(__d)));
-    if (__libcpp_isfinite(__logbw))
+    if (__libcpp_isfinite_or_builtin(__logbw))
     {
         __ilogbw = static_cast<int>(__logbw);
         __c = scalbn(__c, -__ilogbw);
@@ -683,24 +683,24 @@ operator/(const complex<_Tp>& __z, const complex<_Tp>& __w)
     _Tp __denom = __c * __c + __d * __d;
     _Tp __x = scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
     _Tp __y = scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
-    if (__libcpp_isnan(__x) && __libcpp_isnan(__y))
+    if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
     {
-        if ((__denom == _Tp(0)) && (!__libcpp_isnan(__a) || !__libcpp_isnan(__b)))
+        if ((__denom == _Tp(0)) && (!__libcpp_isnan_or_builtin(__a) || !__libcpp_isnan_or_builtin(__b)))
         {
             __x = copysign(_Tp(INFINITY), __c) * __a;
             __y = copysign(_Tp(INFINITY), __c) * __b;
         }
-        else if ((__libcpp_isinf(__a) || __libcpp_isinf(__b)) && __libcpp_isfinite(__c) && __libcpp_isfinite(__d))
+        else if ((__libcpp_isinf_or_builtin(__a) || __libcpp_isinf_or_builtin(__b)) && __libcpp_isfinite_or_builtin(__c) && __libcpp_isfinite_or_builtin(__d))
         {
-            __a = copysign(__libcpp_isinf(__a) ? _Tp(1) : _Tp(0), __a);
-            __b = copysign(__libcpp_isinf(__b) ? _Tp(1) : _Tp(0), __b);
+            __a = copysign(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
+            __b = copysign(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
             __x = _Tp(INFINITY) * (__a * __c + __b * __d);
             __y = _Tp(INFINITY) * (__b * __c - __a * __d);
         }
-        else if (__libcpp_isinf(__logbw) && __logbw > _Tp(0) && __libcpp_isfinite(__a) && __libcpp_isfinite(__b))
+        else if (__libcpp_isinf_or_builtin(__logbw) && __logbw > _Tp(0) && __libcpp_isfinite_or_builtin(__a) && __libcpp_isfinite_or_builtin(__b))
         {
-            __c = copysign(__libcpp_isinf(__c) ? _Tp(1) : _Tp(0), __c);
-            __d = copysign(__libcpp_isinf(__d) ? _Tp(1) : _Tp(0), __d);
+            __c = copysign(__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
+            __d = copysign(__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
             __x = _Tp(0) * (__a * __c + __b * __d);
             __y = _Tp(0) * (__b * __c - __a * __d);
         }
@@ -910,9 +910,9 @@ inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 norm(const complex<_Tp>& __c)
 {
-    if (__libcpp_isinf(__c.real()))
+    if (__libcpp_isinf_or_builtin(__c.real()))
         return abs(__c.real());
-    if (__libcpp_isinf(__c.imag()))
+    if (__libcpp_isinf_or_builtin(__c.imag()))
         return abs(__c.imag());
     return __c.real() * __c.real() + __c.imag() * __c.imag();
 }
@@ -955,7 +955,7 @@ complex<_Tp>
 proj(const complex<_Tp>& __c)
 {
     std::complex<_Tp> __r = __c;
-    if (__libcpp_isinf(__c.real()) || __libcpp_isinf(__c.imag()))
+    if (__libcpp_isinf_or_builtin(__c.real()) || __libcpp_isinf_or_builtin(__c.imag()))
         __r = complex<_Tp>(INFINITY, copysign(_Tp(0), __c.imag()));
     return __r;
 }
@@ -969,7 +969,7 @@ typename enable_if
 >::type
 proj(_Tp __re)
 {
-    if (__libcpp_isinf(__re))
+    if (__libcpp_isinf_or_builtin(__re))
         __re = abs(__re);
     return complex<_Tp>(__re);
 }
@@ -993,25 +993,25 @@ template<class _Tp>
 complex<_Tp>
 polar(const _Tp& __rho, const _Tp& __theta = _Tp(0))
 {
-    if (__libcpp_isnan(__rho) || signbit(__rho))
+    if (__libcpp_isnan_or_builtin(__rho) || signbit(__rho))
         return complex<_Tp>(_Tp(NAN), _Tp(NAN));
-    if (__libcpp_isnan(__theta))
+    if (__libcpp_isnan_or_builtin(__theta))
     {
-        if (__libcpp_isinf(__rho))
+        if (__libcpp_isinf_or_builtin(__rho))
             return complex<_Tp>(__rho, __theta);
         return complex<_Tp>(__theta, __theta);
     }
-    if (__libcpp_isinf(__theta))
+    if (__libcpp_isinf_or_builtin(__theta))
     {
-        if (__libcpp_isinf(__rho))
+        if (__libcpp_isinf_or_builtin(__rho))
             return complex<_Tp>(__rho, _Tp(NAN));
         return complex<_Tp>(_Tp(NAN), _Tp(NAN));
     }
     _Tp __x = __rho * cos(__theta);
-    if (__libcpp_isnan(__x))
+    if (__libcpp_isnan_or_builtin(__x))
         __x = 0;
     _Tp __y = __rho * sin(__theta);
-    if (__libcpp_isnan(__y))
+    if (__libcpp_isnan_or_builtin(__y))
         __y = 0;
     return complex<_Tp>(__x, __y);
 }
@@ -1042,13 +1042,13 @@ template<class _Tp>
 complex<_Tp>
 sqrt(const complex<_Tp>& __x)
 {
-    if (__libcpp_isinf(__x.imag()))
+    if (__libcpp_isinf_or_builtin(__x.imag()))
         return complex<_Tp>(_Tp(INFINITY), __x.imag());
-    if (__libcpp_isinf(__x.real()))
+    if (__libcpp_isinf_or_builtin(__x.real()))
     {
         if (__x.real() > _Tp(0))
-            return complex<_Tp>(__x.real(), __libcpp_isnan(__x.imag()) ? __x.imag() : copysign(_Tp(0), __x.imag()));
-        return complex<_Tp>(__libcpp_isnan(__x.imag()) ? __x.imag() : _Tp(0), copysign(__x.real(), __x.imag()));
+            return complex<_Tp>(__x.real(), __libcpp_isnan_or_builtin(__x.imag()) ? __x.imag() : copysign(_Tp(0), __x.imag()));
+        return complex<_Tp>(__libcpp_isnan_or_builtin(__x.imag()) ? __x.imag() : _Tp(0), copysign(__x.real(), __x.imag()));
     }
     return polar(sqrt(abs(__x)), arg(__x) / _Tp(2));
 }
@@ -1060,21 +1060,21 @@ complex<_Tp>
 exp(const complex<_Tp>& __x)
 {
     _Tp __i = __x.imag();
-    if (__libcpp_isinf(__x.real()))
+    if (__libcpp_isinf_or_builtin(__x.real()))
     {
         if (__x.real() < _Tp(0))
         {
-            if (!__libcpp_isfinite(__i))
+            if (!__libcpp_isfinite_or_builtin(__i))
                 __i = _Tp(1);
         }
-        else if (__i == 0 || !__libcpp_isfinite(__i))
+        else if (__i == 0 || !__libcpp_isfinite_or_builtin(__i))
         {
-            if (__libcpp_isinf(__i))
+            if (__libcpp_isinf_or_builtin(__i))
                 __i = _Tp(NAN);
             return complex<_Tp>(__x.real(), __i);
         }
     }
-    else if (__libcpp_isnan(__x.real()) && __x.imag() == 0)
+    else if (__libcpp_isnan_or_builtin(__x.real()) && __x.imag() == 0)
         return __x;
     _Tp __e = exp(__x.real());
     return complex<_Tp>(__e * cos(__i), __e * sin(__i));
@@ -1132,23 +1132,23 @@ complex<_Tp>
 asinh(const complex<_Tp>& __x)
 {
     const _Tp __pi(atan2(+0., -0.));
-    if (__libcpp_isinf(__x.real()))
+    if (__libcpp_isinf_or_builtin(__x.real()))
     {
-        if (__libcpp_isnan(__x.imag()))
+        if (__libcpp_isnan_or_builtin(__x.imag()))
             return __x;
-        if (__libcpp_isinf(__x.imag()))
+        if (__libcpp_isinf_or_builtin(__x.imag()))
             return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
         return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
     }
-    if (__libcpp_isnan(__x.real()))
+    if (__libcpp_isnan_or_builtin(__x.real()))
     {
-        if (__libcpp_isinf(__x.imag()))
+        if (__libcpp_isinf_or_builtin(__x.imag()))
             return complex<_Tp>(__x.imag(), __x.real());
         if (__x.imag() == 0)
             return __x;
         return complex<_Tp>(__x.real(), __x.real());
     }
-    if (__libcpp_isinf(__x.imag()))
+    if (__libcpp_isinf_or_builtin(__x.imag()))
         return complex<_Tp>(copysign(__x.imag(), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
     complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) + _Tp(1)));
     return complex<_Tp>(copysign(__z.real(), __x.real()), copysign(__z.imag(), __x.imag()));
@@ -1161,11 +1161,11 @@ complex<_Tp>
 acosh(const complex<_Tp>& __x)
 {
     const _Tp __pi(atan2(+0., -0.));
-    if (__libcpp_isinf(__x.real()))
+    if (__libcpp_isinf_or_builtin(__x.real()))
     {
-        if (__libcpp_isnan(__x.imag()))
+        if (__libcpp_isnan_or_builtin(__x.imag()))
             return complex<_Tp>(abs(__x.real()), __x.imag());
-        if (__libcpp_isinf(__x.imag()))
+        if (__libcpp_isinf_or_builtin(__x.imag()))
         {
             if (__x.real() > 0)
                 return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
@@ -1176,13 +1176,13 @@ acosh(const complex<_Tp>& __x)
             return complex<_Tp>(-__x.real(), copysign(__pi, __x.imag()));
         return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
     }
-    if (__libcpp_isnan(__x.real()))
+    if (__libcpp_isnan_or_builtin(__x.real()))
     {
-        if (__libcpp_isinf(__x.imag()))
+        if (__libcpp_isinf_or_builtin(__x.imag()))
             return complex<_Tp>(abs(__x.imag()), __x.real());
         return complex<_Tp>(__x.real(), __x.real());
     }
-    if (__libcpp_isinf(__x.imag()))
+    if (__libcpp_isinf_or_builtin(__x.imag()))
         return complex<_Tp>(abs(__x.imag()), copysign(__pi/_Tp(2), __x.imag()));
     complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) - _Tp(1)));
     return complex<_Tp>(copysign(__z.real(), _Tp(0)), copysign(__z.imag(), __x.imag()));
@@ -1195,21 +1195,21 @@ complex<_Tp>
 atanh(const complex<_Tp>& __x)
 {
     const _Tp __pi(atan2(+0., -0.));
-    if (__libcpp_isinf(__x.imag()))
+    if (__libcpp_isinf_or_builtin(__x.imag()))
     {
         return complex<_Tp>(copysign(_Tp(0), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
     }
-    if (__libcpp_isnan(__x.imag()))
+    if (__libcpp_isnan_or_builtin(__x.imag()))
     {
-        if (__libcpp_isinf(__x.real()) || __x.real() == 0)
+        if (__libcpp_isinf_or_builtin(__x.real()) || __x.real() == 0)
             return complex<_Tp>(copysign(_Tp(0), __x.real()), __x.imag());
         return complex<_Tp>(__x.imag(), __x.imag());
     }
-    if (__libcpp_isnan(__x.real()))
+    if (__libcpp_isnan_or_builtin(__x.real()))
     {
         return complex<_Tp>(__x.real(), __x.real());
     }
-    if (__libcpp_isinf(__x.real()))
+    if (__libcpp_isinf_or_builtin(__x.real()))
     {
         return complex<_Tp>(copysign(_Tp(0), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
     }
@@ -1227,11 +1227,11 @@ template<class _Tp>
 complex<_Tp>
 sinh(const complex<_Tp>& __x)
 {
-    if (__libcpp_isinf(__x.real()) && !__libcpp_isfinite(__x.imag()))
+    if (__libcpp_isinf_or_builtin(__x.real()) && !__libcpp_isfinite_or_builtin(__x.imag()))
         return complex<_Tp>(__x.real(), _Tp(NAN));
-    if (__x.real() == 0 && !__libcpp_isfinite(__x.imag()))
+    if (__x.real() == 0 && !__libcpp_isfinite_or_builtin(__x.imag()))
         return complex<_Tp>(__x.real(), _Tp(NAN));
-    if (__x.imag() == 0 && !__libcpp_isfinite(__x.real()))
+    if (__x.imag() == 0 && !__libcpp_isfinite_or_builtin(__x.real()))
         return __x;
     return complex<_Tp>(sinh(__x.real()) * cos(__x.imag()), cosh(__x.real()) * sin(__x.imag()));
 }
@@ -1242,13 +1242,13 @@ template<class _Tp>
 complex<_Tp>
 cosh(const complex<_Tp>& __x)
 {
-    if (__libcpp_isinf(__x.real()) && !__libcpp_isfinite(__x.imag()))
+    if (__libcpp_isinf_or_builtin(__x.real()) && !__libcpp_isfinite_or_builtin(__x.imag()))
         return complex<_Tp>(abs(__x.real()), _Tp(NAN));
-    if (__x.real() == 0 && !__libcpp_isfinite(__x.imag()))
+    if (__x.real() == 0 && !__libcpp_isfinite_or_builtin(__x.imag()))
         return complex<_Tp>(_Tp(NAN), __x.real());
     if (__x.real() == 0 && __x.imag() == 0)
         return complex<_Tp>(_Tp(1), __x.imag());
-    if (__x.imag() == 0 && !__libcpp_isfinite(__x.real()))
+    if (__x.imag() == 0 && !__libcpp_isfinite_or_builtin(__x.real()))
         return complex<_Tp>(abs(__x.real()), __x.imag());
     return complex<_Tp>(cosh(__x.real()) * cos(__x.imag()), sinh(__x.real()) * sin(__x.imag()));
 }
@@ -1259,19 +1259,19 @@ template<class _Tp>
 complex<_Tp>
 tanh(const complex<_Tp>& __x)
 {
-    if (__libcpp_isinf(__x.real()))
+    if (__libcpp_isinf_or_builtin(__x.real()))
     {
-        if (!__libcpp_isfinite(__x.imag()))
+        if (!__libcpp_isfinite_or_builtin(__x.imag()))
             return complex<_Tp>(_Tp(1), _Tp(0));
         return complex<_Tp>(_Tp(1), copysign(_Tp(0), sin(_Tp(2) * __x.imag())));
     }
-    if (__libcpp_isnan(__x.real()) && __x.imag() == 0)
+    if (__libcpp_isnan_or_builtin(__x.real()) && __x.imag() == 0)
         return __x;
     _Tp __2r(_Tp(2) * __x.real());
     _Tp __2i(_Tp(2) * __x.imag());
     _Tp __d(cosh(__2r) + cos(__2i));
     _Tp __2rsh(sinh(__2r));
-    if (__libcpp_isinf(__2rsh) && __libcpp_isinf(__d))
+    if (__libcpp_isinf_or_builtin(__2rsh) && __libcpp_isinf_or_builtin(__d))
         return complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1),
                             __2i > _Tp(0) ? _Tp(0) : _Tp(-0.));
     return  complex<_Tp>(__2rsh/__d, sin(__2i)/__d);
@@ -1294,11 +1294,11 @@ complex<_Tp>
 acos(const complex<_Tp>& __x)
 {
     const _Tp __pi(atan2(+0., -0.));
-    if (__libcpp_isinf(__x.real()))
+    if (__libcpp_isinf_or_builtin(__x.real()))
     {
-        if (__libcpp_isnan(__x.imag()))
+        if (__libcpp_isnan_or_builtin(__x.imag()))
             return complex<_Tp>(__x.imag(), __x.real());
-        if (__libcpp_isinf(__x.imag()))
+        if (__libcpp_isinf_or_builtin(__x.imag()))
         {
             if (__x.real() < _Tp(0))
                 return complex<_Tp>(_Tp(0.75) * __pi, -__x.imag());
@@ -1308,13 +1308,13 @@ acos(const complex<_Tp>& __x)
             return complex<_Tp>(__pi, signbit(__x.imag()) ? -__x.real() : __x.real());
         return complex<_Tp>(_Tp(0), signbit(__x.imag()) ? __x.real() : -__x.real());
     }
-    if (__libcpp_isnan(__x.real()))
+    if (__libcpp_isnan_or_builtin(__x.real()))
     {
-        if (__libcpp_isinf(__x.imag()))
+        if (__libcpp_isinf_or_builtin(__x.imag()))
             return complex<_Tp>(__x.real(), -__x.imag());
         return complex<_Tp>(__x.real(), __x.real());
     }
-    if (__libcpp_isinf(__x.imag()))
+    if (__libcpp_isinf_or_builtin(__x.imag()))
         return complex<_Tp>(__pi/_Tp(2), -__x.imag());
     if (__x.real() == 0 && (__x.imag() == 0 || isnan(__x.imag())))
         return complex<_Tp>(__pi/_Tp(2), -__x.imag());
diff --git a/include/optional b/include/optional
index c0fd0e7bc49f..1fb953bab743 100644
--- a/include/optional
+++ b/include/optional
@@ -439,46 +439,122 @@ struct __optional_storage_base<_Tp, true>
     }
 };
 
-template <class _Tp, bool = is_trivially_copyable<_Tp>::value>
-struct __optional_storage;
-
-template <class _Tp>
-struct __optional_storage<_Tp, true> : __optional_storage_base<_Tp>
+template <class _Tp, bool = is_trivially_copy_constructible<_Tp>::value>
+struct __optional_copy_base : __optional_storage_base<_Tp>
 {
     using __optional_storage_base<_Tp>::__optional_storage_base;
 };
 
 template <class _Tp>
-struct __optional_storage<_Tp, false> : __optional_storage_base<_Tp>
+struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp>
 {
-    using value_type = _Tp;
     using __optional_storage_base<_Tp>::__optional_storage_base;
 
     _LIBCPP_INLINE_VISIBILITY
-    __optional_storage() = default;
+    __optional_copy_base() = default;
 
     _LIBCPP_INLINE_VISIBILITY
-    __optional_storage(const __optional_storage& __opt)
+    __optional_copy_base(const __optional_copy_base& __opt)
     {
         this->__construct_from(__opt);
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    __optional_storage(__optional_storage&& __opt)
+    __optional_copy_base(__optional_copy_base&&) = default;
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_copy_base& operator=(const __optional_copy_base&) = default;
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_copy_base& operator=(__optional_copy_base&&) = default;
+};
+
+template <class _Tp, bool = is_trivially_move_constructible<_Tp>::value>
+struct __optional_move_base : __optional_copy_base<_Tp>
+{
+    using __optional_copy_base<_Tp>::__optional_copy_base;
+};
+
+template <class _Tp>
+struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp>
+{
+    using value_type = _Tp;
+    using __optional_copy_base<_Tp>::__optional_copy_base;
+
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_move_base() = default;
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_move_base(const __optional_move_base&) = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_move_base(__optional_move_base&& __opt)
         noexcept(is_nothrow_move_constructible_v<value_type>)
     {
         this->__construct_from(_VSTD::move(__opt));
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    __optional_storage& operator=(const __optional_storage& __opt)
+    __optional_move_base& operator=(const __optional_move_base&) = default;
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_move_base& operator=(__optional_move_base&&) = default;
+};
+
+template <class _Tp, bool =
+    is_trivially_destructible<_Tp>::value &&
+    is_trivially_copy_constructible<_Tp>::value &&
+    is_trivially_copy_assignable<_Tp>::value>
+struct __optional_copy_assign_base : __optional_move_base<_Tp>
+{
+    using __optional_move_base<_Tp>::__optional_move_base;
+};
+
+template <class _Tp>
+struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp>
+{
+    using __optional_move_base<_Tp>::__optional_move_base;
+
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_copy_assign_base() = default;
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_copy_assign_base(const __optional_copy_assign_base&) = default;
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_copy_assign_base(__optional_copy_assign_base&&) = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt)
     {
         this->__assign_from(__opt);
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    __optional_storage& operator=(__optional_storage&& __opt)
+    __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default;
+};
+
+template <class _Tp, bool =
+    is_trivially_destructible<_Tp>::value &&
+    is_trivially_move_constructible<_Tp>::value &&
+    is_trivially_move_assignable<_Tp>::value>
+struct __optional_move_assign_base : __optional_copy_assign_base<_Tp>
+{
+    using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
+};
+
+template <class _Tp>
+struct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp>
+{
+    using value_type = _Tp;
+    using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
+
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_move_assign_base() = default;
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_move_assign_base(const __optional_move_assign_base& __opt) = default;
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_move_assign_base(__optional_move_assign_base&&) = default;
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    __optional_move_assign_base& operator=(__optional_move_assign_base&& __opt)
         noexcept(is_nothrow_move_assignable_v<value_type> &&
                  is_nothrow_move_constructible_v<value_type>)
     {
@@ -501,11 +577,11 @@ using __optional_sfinae_assign_base_t = __sfinae_assign_base<
 
 template <class _Tp>
 class optional
-    : private __optional_storage<_Tp>
+    : private __optional_move_assign_base<_Tp>
     , private __optional_sfinae_ctor_base_t<_Tp>
     , private __optional_sfinae_assign_base_t<_Tp>
 {
-    using __base = __optional_storage<_Tp>;
+    using __base = __optional_move_assign_base<_Tp>;
 public:
     using value_type = _Tp;
 
diff --git a/include/regex b/include/regex
index 443c2e303465..77ca648109b2 100644
--- a/include/regex
+++ b/include/regex
@@ -6142,7 +6142,7 @@ regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
 {
     __flags_ |= regex_constants::__no_update_pos;
     _BidirectionalIterator __start = __match_[0].second;
-    if (__match_.empty())
+    if (__match_[0].first == __match_[0].second)
     {
         if (__start == __end_)
         {
diff --git a/include/string b/include/string
index d1a3a1f8e6cc..010a4c7816ea 100644
--- a/include/string
+++ b/include/string
@@ -676,11 +676,11 @@ private:
     };
 
 #if _LIBCPP_BIG_ENDIAN
-    enum {__short_mask = 0x01};
-    enum {__long_mask  = 0x1ul};
+    static const size_type __short_mask = 0x01;
+    static const size_type __long_mask  = 0x1ul;
 #else  // _LIBCPP_BIG_ENDIAN
-    enum {__short_mask = 0x80};
-    enum {__long_mask  = ~(size_type(~0) >> 1)};
+    static const size_type __short_mask = 0x80;
+    static const size_type __long_mask  = ~(size_type(~0) >> 1);
 #endif  // _LIBCPP_BIG_ENDIAN
 
     enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
@@ -706,11 +706,11 @@ private:
     };
 
 #if _LIBCPP_BIG_ENDIAN
-    enum {__short_mask = 0x80};
-    enum {__long_mask  = ~(size_type(~0) >> 1)};
+    static const size_type __short_mask = 0x80;
+    static const size_type __long_mask  = ~(size_type(~0) >> 1);
 #else  // _LIBCPP_BIG_ENDIAN
-    enum {__short_mask = 0x01};
-    enum {__long_mask  = 0x1ul};
+    static const size_type __short_mask = 0x01;
+    static const size_type __long_mask  = 0x1ul;
 #endif  // _LIBCPP_BIG_ENDIAN
 
     enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index f04ef82a83d6..9fc0d1394336 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -355,8 +355,8 @@ if (LIBCXX_INSTALL_LIBRARY)
     set(experimental_lib cxx_experimental)
   endif()
   install(TARGETS ${LIBCXX_TARGETS} ${experimental_lib}
-    LIBRARY DESTINATION lib${LIBCXX_LIBDIR_SUFFIX} COMPONENT cxx
-    ARCHIVE DESTINATION lib${LIBCXX_LIBDIR_SUFFIX} COMPONENT cxx
+    LIBRARY DESTINATION ${LIBCXX_INSTALL_PREFIX}lib${LIBCXX_LIBDIR_SUFFIX} COMPONENT cxx
+    ARCHIVE DESTINATION ${LIBCXX_INSTALL_PREFIX}lib${LIBCXX_LIBDIR_SUFFIX} COMPONENT cxx
     )
   # NOTE: This install command must go after the cxx install command otherwise
   # it will not be executed after the library symlinks are installed.
@@ -364,7 +364,7 @@ if (LIBCXX_INSTALL_LIBRARY)
     # Replace the libc++ filename with $<TARGET_LINKER_FILE:cxx>
     # after we required CMake 3.0.
     install(FILES "${LIBCXX_LIBRARY_DIR}/libc++${CMAKE_SHARED_LIBRARY_SUFFIX}"
-      DESTINATION lib${LIBCXX_LIBDIR_SUFFIX}
+      DESTINATION ${LIBCXX_INSTALL_PREFIX}lib${LIBCXX_LIBDIR_SUFFIX}
       COMPONENT libcxx)
   endif()
 endif()
diff --git a/src/experimental/filesystem/filesystem_time_helper.h b/src/experimental/filesystem/filesystem_time_helper.h
new file mode 100644
index 000000000000..a60fdef5f0d9
--- /dev/null
+++ b/src/experimental/filesystem/filesystem_time_helper.h
@@ -0,0 +1,173 @@
+//===----------------------------------------------------------------------===////
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===////
+
+#ifndef FILESYSTEM_TIME_HELPER_H
+#define FILESYSTEM_TIME_HELPER_H
+
+#include "experimental/__config"
+#include "chrono"
+#include "cstdlib"
+#include "climits"
+
+#include <unistd.h>
+#include <sys/stat.h>
+#if !defined(UTIME_OMIT)
+#include <sys/time.h> // for ::utimes as used in __last_write_time
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+namespace time_detail { namespace {
+
+using namespace chrono;
+
+template <class FileTimeT,
+          bool IsFloat = is_floating_point<typename FileTimeT::rep>::value>
+struct fs_time_util_base {
+  static constexpr auto max_seconds =
+      duration_cast<seconds>(FileTimeT::duration::max()).count();
+
+  static constexpr auto max_nsec =
+      duration_cast<nanoseconds>(FileTimeT::duration::max() -
+                                 seconds(max_seconds))
+          .count();
+
+  static constexpr auto min_seconds =
+      duration_cast<seconds>(FileTimeT::duration::min()).count();
+
+  static constexpr auto min_nsec_timespec =
+      duration_cast<nanoseconds>(
+          (FileTimeT::duration::min() - seconds(min_seconds)) + seconds(1))
+          .count();
+
+  // Static assert that these values properly round trip.
+  static_assert((seconds(min_seconds) +
+                 duration_cast<microseconds>(nanoseconds(min_nsec_timespec))) -
+                        duration_cast<microseconds>(seconds(1)) ==
+                    FileTimeT::duration::min(),
+                "");
+};
+
+template <class FileTimeT>
+struct fs_time_util_base<FileTimeT, true> {
+  static const long long max_seconds;
+  static const long long max_nsec;
+  static const long long min_seconds;
+  static const long long min_nsec_timespec;
+};
+
+template <class FileTimeT>
+const long long fs_time_util_base<FileTimeT, true>::max_seconds =
+    duration_cast<seconds>(FileTimeT::duration::max()).count();
+
+template <class FileTimeT>
+const long long fs_time_util_base<FileTimeT, true>::max_nsec =
+    duration_cast<nanoseconds>(FileTimeT::duration::max() -
+                               seconds(max_seconds))
+        .count();
+
+template <class FileTimeT>
+const long long fs_time_util_base<FileTimeT, true>::min_seconds =
+    duration_cast<seconds>(FileTimeT::duration::min()).count();
+
+template <class FileTimeT>
+const long long fs_time_util_base<FileTimeT, true>::min_nsec_timespec =
+    duration_cast<nanoseconds>((FileTimeT::duration::min() -
+                                seconds(min_seconds)) +
+                               seconds(1))
+        .count();
+
+template <class FileTimeT, class TimeT, class TimeSpecT>
+struct fs_time_util : fs_time_util_base<FileTimeT> {
+  using Base = fs_time_util_base<FileTimeT>;
+  using Base::max_nsec;
+  using Base::max_seconds;
+  using Base::min_nsec_timespec;
+  using Base::min_seconds;
+
+public:
+  template <class CType, class ChronoType>
+  static bool checked_set(CType* out, ChronoType time) {
+    using Lim = numeric_limits<CType>;
+    if (time > Lim::max() || time < Lim::min())
+      return false;
+    *out = static_cast<CType>(time);
+    return true;
+  }
+
+  static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool is_representable(TimeSpecT tm) {
+    if (tm.tv_sec >= 0) {
+      return (tm.tv_sec < max_seconds) ||
+             (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
+    } else if (tm.tv_sec == (min_seconds - 1)) {
+      return tm.tv_nsec >= min_nsec_timespec;
+    } else {
+      return (tm.tv_sec >= min_seconds);
+    }
+  }
+
+  static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool is_representable(FileTimeT tm) {
+    auto secs = duration_cast<seconds>(tm.time_since_epoch());
+    auto nsecs = duration_cast<nanoseconds>(tm.time_since_epoch() - secs);
+    if (nsecs.count() < 0) {
+      secs = secs + seconds(1);
+      nsecs = nsecs + seconds(1);
+    }
+    using TLim = numeric_limits<TimeT>;
+    if (secs.count() >= 0)
+      return secs.count() <= TLim::max();
+    return secs.count() >= TLim::min();
+  }
+
+  static _LIBCPP_CONSTEXPR_AFTER_CXX11 FileTimeT
+  convert_timespec(TimeSpecT tm) {
+    auto adj_msec = duration_cast<microseconds>(nanoseconds(tm.tv_nsec));
+    if (tm.tv_sec >= 0) {
+      auto Dur = seconds(tm.tv_sec) + microseconds(adj_msec);
+      return FileTimeT(Dur);
+    } else if (duration_cast<microseconds>(nanoseconds(tm.tv_nsec)).count() ==
+               0) {
+      return FileTimeT(seconds(tm.tv_sec));
+    } else { // tm.tv_sec < 0
+      auto adj_subsec =
+          duration_cast<microseconds>(seconds(1) - nanoseconds(tm.tv_nsec));
+      auto Dur = seconds(tm.tv_sec + 1) - adj_subsec;
+      return FileTimeT(Dur);
+    }
+  }
+
+  template <class SubSecDurT, class SubSecT>
+  static bool set_times_checked(TimeT* sec_out, SubSecT* subsec_out,
+                                FileTimeT tp) {
+    using namespace chrono;
+    auto dur = tp.time_since_epoch();
+    auto sec_dur = duration_cast<seconds>(dur);
+    auto subsec_dur = duration_cast<SubSecDurT>(dur - sec_dur);
+    // The tv_nsec and tv_usec fields must not be negative so adjust accordingly
+    if (subsec_dur.count() < 0) {
+      if (sec_dur.count() > min_seconds) {
+        sec_dur -= seconds(1);
+        subsec_dur += seconds(1);
+      } else {
+        subsec_dur = SubSecDurT::zero();
+      }
+    }
+    return checked_set(sec_out, sec_dur.count()) &&
+           checked_set(subsec_out, subsec_dur.count());
+  }
+};
+
+} // end namespace
+} // end namespace time_detail
+
+using time_detail::fs_time_util;
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+#endif // FILESYSTEM_TIME_HELPER_H
diff --git a/src/experimental/filesystem/operations.cpp b/src/experimental/filesystem/operations.cpp
index e9bc0eb6e30e..641a3c53636d 100644
--- a/src/experimental/filesystem/operations.cpp
+++ b/src/experimental/filesystem/operations.cpp
@@ -15,6 +15,8 @@
 #include "cstdlib"
 #include "climits"
 
+#include "filesystem_time_helper.h"
+
 #include <unistd.h>
 #include <sys/stat.h>
 #include <sys/statvfs.h>
@@ -426,17 +428,20 @@ void __current_path(const path& p, std::error_code *ec) {
 
 bool __equivalent(const path& p1, const path& p2, std::error_code *ec)
 {
+    auto make_unsupported_error = [&]() {
+      set_or_throw(make_error_code(errc::not_supported), ec,
+                     "equivalent", p1, p2);
+      return false;
+    };
     std::error_code ec1, ec2;
     struct ::stat st1 = {};
     struct ::stat st2 = {};
     auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
+    if (!exists(s1))
+      return make_unsupported_error();
     auto s2 = detail::posix_stat(p2.native(), st2, &ec2);
-
-    if ((!exists(s1) && !exists(s2)) || (is_other(s1) && is_other(s2))) {
-        set_or_throw(make_error_code(errc::not_supported), ec,
-                     "equivalent", p1, p2);
-        return false;
-    }
+    if (!exists(s2))
+      return make_unsupported_error();
     if (ec) ec->clear();
     return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
 }
@@ -502,17 +507,6 @@ bool __fs_is_empty(const path& p, std::error_code *ec)
 
 namespace detail { namespace {
 
-using namespace std::chrono;
-
-template <class CType, class ChronoType>
-bool checked_set(CType* out, ChronoType time) {
-    using Lim = numeric_limits<CType>;
-    if (time > Lim::max() || time < Lim::min())
-        return false;
-    *out = static_cast<CType>(time);
-    return true;
-}
-
 using TimeSpec = struct timespec;
 using StatT =  struct stat;
 
@@ -525,137 +519,10 @@ __attribute__((unused)) // Suppress warning
 TimeSpec extract_atime(StatT const& st) { return st.st_atim; }
 #endif
 
-constexpr auto max_seconds = duration_cast<seconds>(
-    file_time_type::duration::max()).count();
-
-constexpr auto max_nsec = duration_cast<nanoseconds>(
-    file_time_type::duration::max() - seconds(max_seconds)).count();
-
-constexpr auto min_seconds = duration_cast<seconds>(
-    file_time_type::duration::min()).count();
-
-constexpr auto min_nsec_timespec = duration_cast<nanoseconds>(
-    (file_time_type::duration::min() - seconds(min_seconds)) + seconds(1)).count();
-
-// Static assert that these values properly round trip.
-static_assert((seconds(min_seconds) + duration_cast<microseconds>(nanoseconds(min_nsec_timespec)))
-                  - duration_cast<microseconds>(seconds(1))
-                  == file_time_type::duration::min(), "");
-
-constexpr auto max_time_t = numeric_limits<time_t>::max();
-constexpr auto min_time_t = numeric_limits<time_t>::min();
-
-#if !defined(__LP64__) && defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wtautological-constant-out-of-range-compare"
-#endif
-
-_LIBCPP_CONSTEXPR_AFTER_CXX11
-bool is_representable(TimeSpec const& tm) {
-  if (tm.tv_sec >= 0) {
-    return (tm.tv_sec < max_seconds) ||
-        (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
-  } else if (tm.tv_sec == (min_seconds - 1)) {
-     return tm.tv_nsec >= min_nsec_timespec;
-  } else {
-    return (tm.tv_sec >= min_seconds);
-  }
-}
-#ifndef _LIBCPP_HAS_NO_CXX14_CONSTEXPR
-#if defined(__LP64__)
-static_assert(is_representable({max_seconds, max_nsec}), "");
-static_assert(!is_representable({max_seconds + 1, 0}), "");
-static_assert(!is_representable({max_seconds, max_nsec + 1}), "");
-static_assert(!is_representable({max_time_t, 0}), "");
-static_assert(is_representable({min_seconds, 0}), "");
-static_assert(is_representable({min_seconds - 1, min_nsec_timespec}), "");
-static_assert(is_representable({min_seconds - 1, min_nsec_timespec + 1}), "");
-static_assert(!is_representable({min_seconds - 1, min_nsec_timespec - 1}), "");
-static_assert(!is_representable({min_time_t, 999999999}), "");
-#else
-static_assert(is_representable({max_time_t, 999999999}), "");
-static_assert(is_representable({max_time_t, 1000000000}), "");
-static_assert(is_representable({min_time_t, 0}), "");
-#endif
-#endif
-
-_LIBCPP_CONSTEXPR_AFTER_CXX11
-bool is_representable(file_time_type const& tm) {
-  auto secs = duration_cast<seconds>(tm.time_since_epoch());
-  auto nsecs = duration_cast<nanoseconds>(tm.time_since_epoch() - secs);
-  if (nsecs.count() < 0) {
-    secs = secs +  seconds(1);
-    nsecs = nsecs + seconds(1);
-  }
-  using TLim = numeric_limits<time_t>;
-  if (secs.count() >= 0)
-    return secs.count() <= TLim::max();
-  return secs.count() >= TLim::min();
-}
-#ifndef _LIBCPP_HAS_NO_CXX14_CONSTEXPR
-#if defined(__LP64__)
-static_assert(is_representable(file_time_type::max()), "");
-static_assert(is_representable(file_time_type::min()), "");
-#else
-static_assert(!is_representable(file_time_type::max()), "");
-static_assert(!is_representable(file_time_type::min()), "");
-static_assert(is_representable(file_time_type(seconds(max_time_t))), "");
-static_assert(is_representable(file_time_type(seconds(min_time_t))), "");
-#endif
-#endif
-
-_LIBCPP_CONSTEXPR_AFTER_CXX11
-file_time_type convert_timespec(TimeSpec const& tm) {
-  auto adj_msec = duration_cast<microseconds>(nanoseconds(tm.tv_nsec));
-  if (tm.tv_sec >= 0) {
-    auto Dur = seconds(tm.tv_sec) + microseconds(adj_msec);
-    return file_time_type(Dur);
-  } else if (duration_cast<microseconds>(nanoseconds(tm.tv_nsec)).count() == 0) {
-    return file_time_type(seconds(tm.tv_sec));
-  } else { // tm.tv_sec < 0
-    auto adj_subsec = duration_cast<microseconds>(seconds(1) - nanoseconds(tm.tv_nsec));
-    auto Dur = seconds(tm.tv_sec + 1) - adj_subsec;
-    return file_time_type(Dur);
-  }
-}
-#ifndef _LIBCPP_HAS_NO_CXX14_CONSTEXPR
-#if defined(__LP64__)
-static_assert(convert_timespec({max_seconds, max_nsec}) == file_time_type::max(), "");
-static_assert(convert_timespec({max_seconds, max_nsec - 1}) < file_time_type::max(), "");
-static_assert(convert_timespec({max_seconds - 1, 999999999}) < file_time_type::max(), "");
-static_assert(convert_timespec({min_seconds - 1, min_nsec_timespec}) == file_time_type::min(), "");
-static_assert(convert_timespec({min_seconds - 1, min_nsec_timespec + 1}) > file_time_type::min(), "");
-static_assert(convert_timespec({min_seconds , 0}) > file_time_type::min(), "");
-#else
-// FIXME add tests for 32 bit builds
-#endif
-#endif
-
-#if !defined(__LP64__) && defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-template <class SubSecDurT, class SubSecT>
-bool set_times_checked(time_t* sec_out, SubSecT* subsec_out, file_time_type tp) {
-    using namespace chrono;
-    auto dur = tp.time_since_epoch();
-    auto sec_dur = duration_cast<seconds>(dur);
-    auto subsec_dur = duration_cast<SubSecDurT>(dur - sec_dur);
-    // The tv_nsec and tv_usec fields must not be negative so adjust accordingly
-    if (subsec_dur.count() < 0) {
-        if (sec_dur.count() > min_seconds) {
-            sec_dur -= seconds(1);
-            subsec_dur += seconds(1);
-        } else {
-            subsec_dur = SubSecDurT::zero();
-        }
-    }
-    return checked_set(sec_out, sec_dur.count())
-        && checked_set(subsec_out, subsec_dur.count());
-}
-
 }} // end namespace detail
 
+using FSTime = fs_time_util<file_time_type, time_t, struct timespec>;
+
 file_time_type __last_write_time(const path& p, std::error_code *ec)
 {
     using namespace ::std::chrono;
@@ -668,12 +535,12 @@ file_time_type __last_write_time(const path& p, std::error_code *ec)
     }
     if (ec) ec->clear();
     auto ts = detail::extract_mtime(st);
-    if (!detail::is_representable(ts)) {
+    if (!FSTime::is_representable(ts)) {
         set_or_throw(error_code(EOVERFLOW, generic_category()), ec,
                      "last_write_time", p);
         return file_time_type::min();
     }
-    return detail::convert_timespec(ts);
+    return FSTime::convert_timespec(ts);
 }
 
 void __last_write_time(const path& p, file_time_type new_time,
@@ -698,7 +565,7 @@ void __last_write_time(const path& p, file_time_type new_time,
     struct ::timeval tbuf[2];
     tbuf[0].tv_sec = atime.tv_sec;
     tbuf[0].tv_usec = duration_cast<microseconds>(nanoseconds(atime.tv_nsec)).count();
-    const bool overflowed = !detail::set_times_checked<microseconds>(
+    const bool overflowed = !FSTime::set_times_checked<microseconds>(
         &tbuf[1].tv_sec, &tbuf[1].tv_usec, new_time);
 
     if (overflowed) {
@@ -714,7 +581,7 @@ void __last_write_time(const path& p, file_time_type new_time,
     tbuf[0].tv_sec = 0;
     tbuf[0].tv_nsec = UTIME_OMIT;
 
-    const bool overflowed = !detail::set_times_checked<nanoseconds>(
+    const bool overflowed = !FSTime::set_times_checked<nanoseconds>(
         &tbuf[1].tv_sec, &tbuf[1].tv_nsec, new_time);
     if (overflowed) {
         set_or_throw(make_error_code(errc::invalid_argument),
diff --git a/include/__refstring b/src/include/refstring.h
index 7f417a03c491..f0d5b4456da5 100644
--- a/include/__refstring
+++ b/src/include/refstring.h
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _LIBCPP___REFSTRING
-#define _LIBCPP___REFSTRING
+#ifndef _LIBCPP_REFSTRING_H
+#define _LIBCPP_REFSTRING_H
 
 #include <__config>
 #include <stdexcept>
@@ -124,4 +124,4 @@ bool __libcpp_refstring::__uses_refcount() const {
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif //_LIBCPP___REFSTRING
+#endif //_LIBCPP_REFSTRING_H
diff --git a/src/stdexcept.cpp b/src/stdexcept.cpp
index 3f333309dd8f..5e06e521e404 100644
--- a/src/stdexcept.cpp
+++ b/src/stdexcept.cpp
@@ -11,7 +11,7 @@
 #include "new"
 #include "string"
 #include "system_error"
-#include "__refstring"
+#include "include/refstring.h"
 
 /* For _LIBCPPABI_VERSION */
 #if !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) && \
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 6f2eac0546fc..7b8a8322a11f 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -85,3 +85,36 @@ if (LIBCXX_GENERATE_COVERAGE)
   set(extract_dirs "${LIBCXX_SOURCE_DIR}/include;${LIBCXX_SOURCE_DIR}/src")
   setup_lcov_test_target_coverage("cxx" "${output_dir}" "${capture_dirs}" "${extract_dirs}")
 endif()
+
+
+if (LIBCXX_CONFIGURE_IDE)
+  # Create dummy targets for each of the tests in the test suite, this allows
+  # IDE's such as CLion to correctly highlight the tests because it knows
+  # roughly what include paths/compile flags/macro definitions are needed.
+  include_directories(support)
+  file(GLOB_RECURSE LIBCXX_TESTS ${CMAKE_CURRENT_SOURCE_DIR}/*.pass.cpp)
+  file(GLOB LIBCXX_TEST_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/support/*)
+  file(GLOB_RECURSE LIBCXX_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../include/*)
+  add_executable(libcxx_test_objects EXCLUDE_FROM_ALL
+          ${LIBCXX_TESTS} ${LIBCXX_TEST_HEADERS} ${LIBCXX_HEADERS})
+  add_dependencies(libcxx_test_objects cxx)
+
+  set(STATIC_ROOT ${LIBCXX_SOURCE_DIR}/test/std/experimental/filesystem/Inputs/static_test_env)
+  add_definitions(-DLIBCXX_FILESYSTEM_STATIC_TEST_ROOT="${STATIC_ROOT}")
+
+  set(DYNAMIC_ROOT ${LIBCXX_BINARY_DIR}/test/filesystem/Output/dynamic_env)
+  add_definitions(-DLIBCXX_FILESYSTEM_DYNAMIC_TEST_ROOT="${DYNAMIC_ROOT}")
+
+  set(DYNAMIC_HELPER "python ${LIBCXX_SOURCE_DIR}/test/support/filesystem_dynamic_test_helper.py ")
+  add_definitions(-DLIBCXX_FILESYSTEM_DYNAMIC_TEST_HELPER="${DYNAMIC_HELPER}")
+
+  split_list(LIBCXX_COMPILE_FLAGS)
+  split_list(LIBCXX_LINK_FLAGS)
+
+  set_target_properties(libcxx_test_objects
+          PROPERTIES
+            COMPILE_FLAGS "${LIBCXX_COMPILE_FLAGS}"
+            LINK_FLAGS "${LIBCXX_LINK_FLAGS}"
+            EXCLUDE_FROM_ALL ON
+  )
+endif()
diff --git a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default_throws_bad_alloc.pass.cpp b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default_throws_bad_alloc.pass.cpp
index 9c6cad8ee2d3..4009841355f9 100644
--- a/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default_throws_bad_alloc.pass.cpp
+++ b/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default_throws_bad_alloc.pass.cpp
@@ -16,7 +16,7 @@
 // UNSUPPORTED: c++98, c++03, c++11
 
 // The sanitizers replace new/delete with versions that do not throw bad_alloc.
-// UNSUPPORTED: sanitizer-new-delete, ubsan
+// UNSUPPORTED: sanitizer-new-delete
 
 
 #include <experimental/dynarray>
diff --git a/test/libcxx/experimental/filesystem/convert_file_time.sh.cpp b/test/libcxx/experimental/filesystem/convert_file_time.sh.cpp
new file mode 100644
index 000000000000..972d51813961
--- /dev/null
+++ b/test/libcxx/experimental/filesystem/convert_file_time.sh.cpp
@@ -0,0 +1,200 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <experimental/filesystem>
+
+// typedef TrivialClock file_time_type;
+
+// RUN: %build -I%libcxx_src_root/src/experimental/filesystem
+// RUN: %run
+
+#include <experimental/filesystem>
+#include <chrono>
+#include <type_traits>
+#include <limits>
+#include <cstddef>
+#include <cassert>
+
+#include "filesystem_time_helper.h"
+
+using namespace std::chrono;
+namespace fs = std::experimental::filesystem;
+using fs::file_time_type;
+using fs::fs_time_util;
+
+enum TestKind { TK_64Bit, TK_32Bit, TK_FloatingPoint };
+
+template <class FileTimeT, class TimeT, class TimeSpec>
+constexpr TestKind getTestKind() {
+  if (sizeof(TimeT) == 8 && !std::is_floating_point<TimeT>::value)
+    return TK_64Bit;
+  else if (sizeof(TimeT) == 4 && !std::is_floating_point<TimeT>::value)
+    return TK_32Bit;
+  else if (std::is_floating_point<TimeT>::value)
+    return TK_FloatingPoint;
+  else
+    assert(false && "test kind not supported");
+}
+
+template <class FileTimeT, class TimeT, class TimeSpecT,
+          class Base = fs_time_util<FileTimeT, TimeT, TimeSpecT>,
+          TestKind = getTestKind<FileTimeT, TimeT, TimeSpecT>()>
+struct check_is_representable;
+
+template <class FileTimeT, class TimeT, class TimeSpecT, class Base>
+struct check_is_representable<FileTimeT, TimeT, TimeSpecT, Base, TK_64Bit>
+    : public Base {
+
+  using Base::convert_timespec;
+  using Base::is_representable;
+  using Base::max_nsec;
+  using Base::max_seconds;
+  using Base::min_nsec_timespec;
+  using Base::min_seconds;
+
+  static constexpr auto max_time_t = std::numeric_limits<TimeT>::max();
+  static constexpr auto min_time_t = std::numeric_limits<TimeT>::min();
+
+  static constexpr bool test_timespec() {
+    static_assert(is_representable(TimeSpecT{max_seconds, max_nsec}), "");
+    static_assert(!is_representable(TimeSpecT{max_seconds + 1, 0}), "");
+    static_assert(!is_representable(TimeSpecT{max_seconds, max_nsec + 1}), "");
+    static_assert(!is_representable(TimeSpecT{max_time_t, 0}), "");
+    static_assert(is_representable(TimeSpecT{min_seconds, 0}), "");
+    static_assert(
+        is_representable(TimeSpecT{min_seconds - 1, min_nsec_timespec}), "");
+    static_assert(
+        is_representable(TimeSpecT{min_seconds - 1, min_nsec_timespec + 1}),
+        "");
+    static_assert(
+        !is_representable(TimeSpecT{min_seconds - 1, min_nsec_timespec - 1}),
+        "");
+    static_assert(!is_representable(TimeSpecT{min_time_t, 999999999}), "");
+    return true;
+  }
+
+  static constexpr bool test_file_time_type() {
+    static_assert(Base::is_representable(FileTimeT::max()), "");
+    static_assert(Base::is_representable(FileTimeT::min()), "");
+    return true;
+  }
+
+  static constexpr bool test_convert_timespec() {
+    static_assert(convert_timespec(TimeSpecT{max_seconds, max_nsec}) ==
+                      FileTimeT::max(),
+                  "");
+    static_assert(convert_timespec(TimeSpecT{max_seconds, max_nsec - 1}) <
+                      FileTimeT::max(),
+                  "");
+    static_assert(convert_timespec(TimeSpecT{max_seconds - 1, 999999999}) <
+                      FileTimeT::max(),
+                  "");
+    static_assert(convert_timespec(TimeSpecT{
+                      min_seconds - 1, min_nsec_timespec}) == FileTimeT::min(),
+                  "");
+    static_assert(
+        convert_timespec(TimeSpecT{min_seconds - 1, min_nsec_timespec + 1}) >
+            FileTimeT::min(),
+        "");
+    static_assert(
+        convert_timespec(TimeSpecT{min_seconds, 0}) > FileTimeT::min(), "");
+    return true;
+  }
+
+  static bool test() {
+    static_assert(test_timespec(), "");
+    static_assert(test_file_time_type(), "");
+    static_assert(test_convert_timespec(), "");
+    return true;
+  }
+};
+
+template <class FileTimeT, class TimeT, class TimeSpecT, class Base>
+struct check_is_representable<FileTimeT, TimeT, TimeSpecT, Base, TK_32Bit>
+    : public Base {
+  static constexpr auto max_time_t = std::numeric_limits<TimeT>::max();
+  static constexpr auto min_time_t = std::numeric_limits<TimeT>::min();
+
+  using Base::convert_timespec;
+  using Base::is_representable;
+  using Base::max_nsec;
+  using Base::max_seconds;
+  using Base::min_nsec_timespec;
+  using Base::min_seconds;
+
+  static constexpr bool test_timespec() {
+    static_assert(is_representable(TimeSpecT{max_time_t, 999999999}), "");
+    static_assert(is_representable(TimeSpecT{max_time_t, 1000000000}), "");
+    static_assert(is_representable(TimeSpecT{min_time_t, 0}), "");
+    return true;
+  }
+
+  static constexpr bool test_file_time_type() {
+    static_assert(!is_representable(FileTimeT::max()), "");
+    static_assert(!is_representable(FileTimeT::min()), "");
+    static_assert(is_representable(FileTimeT(seconds(max_time_t))), "");
+    static_assert(is_representable(FileTimeT(seconds(min_time_t))), "");
+    return true;
+  }
+
+  static constexpr bool test_convert_timespec() {
+    // FIXME add tests for 32 bit builds
+    return true;
+  }
+
+  static bool test() {
+    static_assert(test_timespec(), "");
+    static_assert(test_file_time_type(), "");
+    static_assert(test_convert_timespec(), "");
+    return true;
+  }
+};
+
+template <class FileTimeT, class TimeT, class TimeSpec, class Base>
+struct check_is_representable<FileTimeT, TimeT, TimeSpec, Base,
+                              TK_FloatingPoint> : public Base {
+
+  static bool test() { return true; }
+};
+
+template <class TimeT, class NSecT = long>
+struct TestTimeSpec {
+  TimeT tv_sec;
+  NSecT tv_nsec;
+};
+
+template <class Dur>
+struct TestClock {
+  typedef Dur duration;
+  typedef typename duration::rep rep;
+  typedef typename duration::period period;
+  typedef std::chrono::time_point<TestClock> time_point;
+  static constexpr const bool is_steady = false;
+
+  static time_point now() noexcept { return {}; }
+};
+
+template <class IntType, class Dur = duration<IntType, std::micro> >
+using TestFileTimeT = time_point<TestClock<Dur> >;
+
+int main() {
+  assert((
+      check_is_representable<file_time_type, time_t, struct timespec>::test()));
+  assert((check_is_representable<TestFileTimeT<int64_t>, int64_t,
+                                 TestTimeSpec<int64_t, long> >::test()));
+  assert((check_is_representable<TestFileTimeT<long long>, int32_t,
+                                 TestTimeSpec<int32_t, int32_t> >::test()));
+
+  // Test that insane platforms like ppc64 linux, which use long double as time_t,
+  // at least compile.
+  assert((check_is_representable<TestFileTimeT<long double>, double,
+                                 TestTimeSpec<long double, long> >::test()));
+}
diff --git a/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp b/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
index 9123be1f0990..a58c389cd7ac 100644
--- a/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
+++ b/test/libcxx/numerics/c.math/constexpr-fns.pass.cpp
@@ -23,9 +23,9 @@
 
 #include <cmath>
 
-static_assert(std::__libcpp_isnan(0.) == false, "");
-static_assert(std::__libcpp_isinf(0.0) == false, "");
-static_assert(std::__libcpp_isfinite(0.0) == true, "");
+static_assert(std::__libcpp_isnan_or_builtin(0.) == false, "");
+static_assert(std::__libcpp_isinf_or_builtin(0.0) == false, "");
+static_assert(std::__libcpp_isfinite_or_builtin(0.0) == true, "");
 
 int main()
 {
diff --git a/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp b/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp
new file mode 100644
index 000000000000..37aaa2acf1d9
--- /dev/null
+++ b/test/libcxx/numerics/c.math/fdelayed-template-parsing.sh.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test that cmath builds with -fdelayed-template-parsing
+
+// REQUIRES: fdelayed-template-parsing
+
+// RUN: %build -fdelayed-template-parsing
+// RUN: %run
+
+#include <cmath>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main() {
+  assert(std::isfinite(1.0));
+  assert(!std::isinf(1.0));
+  assert(!std::isnan(1.0));
+}
+
+using namespace std;
diff --git a/test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp b/test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp
deleted file mode 100644
index 9493d6bb766c..000000000000
--- a/test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-// <optional>
-
-
-#include <optional>
-#include <type_traits>
-#include <cassert>
-
-#include "archetypes.hpp"
-
-template <class T>
-struct SpecialMemberTest {
-    using O = std::optional<T>;
-
-    template <template <class> class TestMF>
-    static constexpr bool check_same() {
-        return TestMF<O>::value == TestMF<T>::value;
-    }
-
-    // Test that optional inherits the correct trivial/non-trivial members
-    static_assert(check_same<std::is_trivially_destructible>(), "");
-    static_assert(check_same<std::is_trivially_copyable>(), "");
-};
-
-template <class ...Args> static void sink(Args&&...) {}
-
-template <class ...TestTypes>
-struct DoTestsMetafunction {
-    DoTestsMetafunction() { sink(SpecialMemberTest<TestTypes>{}...); }
-};
-
-struct TrivialMoveNonTrivialCopy {
-    TrivialMoveNonTrivialCopy() = default;
-    TrivialMoveNonTrivialCopy(const TrivialMoveNonTrivialCopy&) {}
-    TrivialMoveNonTrivialCopy(TrivialMoveNonTrivialCopy&&) = default;
-    TrivialMoveNonTrivialCopy& operator=(const TrivialMoveNonTrivialCopy&) { return *this; }
-    TrivialMoveNonTrivialCopy& operator=(TrivialMoveNonTrivialCopy&&) = default;
-};
-
-struct TrivialCopyNonTrivialMove {
-    TrivialCopyNonTrivialMove() = default;
-    TrivialCopyNonTrivialMove(const TrivialCopyNonTrivialMove&) = default;
-    TrivialCopyNonTrivialMove(TrivialCopyNonTrivialMove&&) {}
-    TrivialCopyNonTrivialMove& operator=(const TrivialCopyNonTrivialMove&) = default;
-    TrivialCopyNonTrivialMove& operator=(TrivialCopyNonTrivialMove&&) { return *this; }
-};
-
-int main()
-{
-    sink(
-        ImplicitTypes::ApplyTypes<DoTestsMetafunction>{},
-        ExplicitTypes::ApplyTypes<DoTestsMetafunction>{},
-        NonLiteralTypes::ApplyTypes<DoTestsMetafunction>{},
-        NonTrivialTypes::ApplyTypes<DoTestsMetafunction>{},
-        DoTestsMetafunction<TrivialMoveNonTrivialCopy, TrivialCopyNonTrivialMove>{}
-    );
-}
diff --git a/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp b/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
index e42e9f28448a..7a4090b9c252 100644
--- a/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
+++ b/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp
@@ -25,6 +25,40 @@ template <typename T> void checkAlwaysLockFree() {
     assert(std::atomic<T>().is_lock_free());
 }
 
+// FIXME: This separate test is needed to work around llvm.org/PR31864
+// which causes ATOMIC_LLONG_LOCK_FREE to be defined as '1' in 32-bit builds
+// even though __atomic_always_lock_free returns true for the same type.
+constexpr bool NeedWorkaroundForPR31864 =
+#if defined(__clang__)
+(sizeof(void*) == 4); // Needed on 32 bit builds
+#else
+false;
+#endif
+
+template <bool Disable = NeedWorkaroundForPR31864,
+  std::enable_if_t<!Disable>* = nullptr,
+  class LLong = long long,
+  class ULLong = unsigned long long>
+void checkLongLongTypes() {
+  static_assert(std::atomic<LLong>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE));
+  static_assert(std::atomic<ULLong>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE));
+}
+
+// Used to make the calls to __atomic_always_lock_free dependent on a template
+// parameter.
+template <class T> constexpr size_t getSizeOf() { return sizeof(T); }
+
+template <bool Enable = NeedWorkaroundForPR31864,
+  std::enable_if_t<Enable>* = nullptr,
+  class LLong = long long,
+  class ULLong = unsigned long long>
+void checkLongLongTypes() {
+  constexpr bool ExpectLockFree = __atomic_always_lock_free(getSizeOf<LLong>(), 0);
+  static_assert(std::atomic<LLong>::is_always_lock_free == ExpectLockFree, "");
+  static_assert(std::atomic<ULLong>::is_always_lock_free == ExpectLockFree, "");
+  static_assert((0 != ATOMIC_LLONG_LOCK_FREE) == ExpectLockFree, "");
+}
+
 int main()
 {
 // structs and unions can't be defined in the template invocation.
@@ -94,8 +128,7 @@ int main()
     static_assert(std::atomic<unsigned int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE));
     static_assert(std::atomic<long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE));
     static_assert(std::atomic<unsigned long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE));
-    static_assert(std::atomic<long long>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE));
-    static_assert(std::atomic<unsigned long long>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE));
+    checkLongLongTypes();
     static_assert(std::atomic<void*>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE));
     static_assert(std::atomic<std::nullptr_t>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE));
 }
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp
index 621ff8305fc3..a3591e0267e6 100644
--- a/test/std/experimental/filesystem/fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp
@@ -26,63 +26,87 @@ using namespace std::experimental::filesystem;
 
 TEST_SUITE(equivalent_test_suite)
 
-TEST_CASE(signature_test)
-{
-    const path p; ((void)p);
-    std::error_code ec; ((void)ec);
-    ASSERT_NOEXCEPT(equivalent(p, p, ec));
-    ASSERT_NOT_NOEXCEPT(equivalent(p, p));
+TEST_CASE(signature_test) {
+  const path p;
+  ((void)p);
+  std::error_code ec;
+  ((void)ec);
+  ASSERT_NOEXCEPT(equivalent(p, p, ec));
+  ASSERT_NOT_NOEXCEPT(equivalent(p, p));
 }
 
-TEST_CASE(equivalent_test)
-{
-    struct TestCase {
-        path lhs;
-        path rhs;
-        bool expect;
-    };
-    const TestCase testCases[] = {
-        {StaticEnv::Dir, StaticEnv::Dir, true},
-        {StaticEnv::File, StaticEnv::Dir, false},
-        {StaticEnv::Dir, StaticEnv::SymlinkToDir, true},
-        {StaticEnv::Dir, StaticEnv::SymlinkToFile, false},
-        {StaticEnv::File, StaticEnv::File, true},
-        {StaticEnv::File, StaticEnv::SymlinkToFile, true},
-    };
-    for (auto& TC : testCases) {
-        std::error_code ec;
-        TEST_CHECK(equivalent(TC.lhs, TC.rhs, ec) == TC.expect);
-        TEST_CHECK(!ec);
-    }
+TEST_CASE(equivalent_test) {
+  struct TestCase {
+    path lhs;
+    path rhs;
+    bool expect;
+  };
+  const TestCase testCases[] = {
+      {StaticEnv::Dir, StaticEnv::Dir, true},
+      {StaticEnv::File, StaticEnv::Dir, false},
+      {StaticEnv::Dir, StaticEnv::SymlinkToDir, true},
+      {StaticEnv::Dir, StaticEnv::SymlinkToFile, false},
+      {StaticEnv::File, StaticEnv::File, true},
+      {StaticEnv::File, StaticEnv::SymlinkToFile, true},
+  };
+  for (auto& TC : testCases) {
+    std::error_code ec;
+    TEST_CHECK(equivalent(TC.lhs, TC.rhs, ec) == TC.expect);
+    TEST_CHECK(!ec);
+  }
 }
 
-TEST_CASE(equivalent_reports_double_dne)
-{
-    const path E = StaticEnv::File;
-    const path DNE = StaticEnv::DNE;
-    { // Test that no exception is thrown if one of the paths exists
-        TEST_CHECK(equivalent(E, DNE) == false);
-        TEST_CHECK(equivalent(DNE, E) == false);
-    }
-    { // Test that an exception is thrown if both paths do not exist.
-        TEST_CHECK_THROW(filesystem_error, equivalent(DNE, DNE));
-    }
-    {
-        std::error_code ec;
-        TEST_CHECK(equivalent(DNE, DNE, ec) == false);
-        TEST_CHECK(ec);
-    }
+TEST_CASE(equivalent_reports_error_if_input_dne) {
+  const path E = StaticEnv::File;
+  const path DNE = StaticEnv::DNE;
+  { // Test that an error is reported when either of the paths don't exist
+    std::error_code ec = GetTestEC();
+    TEST_CHECK(equivalent(E, DNE, ec) == false);
+    TEST_CHECK(ec);
+    TEST_CHECK(ec != GetTestEC());
+  }
+  {
+    std::error_code ec = GetTestEC();
+    TEST_CHECK(equivalent(DNE, E, ec) == false);
+    TEST_CHECK(ec);
+    TEST_CHECK(ec != GetTestEC());
+  }
+  {
+    TEST_CHECK_THROW(filesystem_error, equivalent(DNE, E));
+    TEST_CHECK_THROW(filesystem_error, equivalent(E, DNE));
+  }
+  { // Test that an exception is thrown if both paths do not exist.
+    TEST_CHECK_THROW(filesystem_error, equivalent(DNE, DNE));
+  }
+  {
+    std::error_code ec = GetTestEC();
+    TEST_CHECK(equivalent(DNE, DNE, ec) == false);
+    TEST_CHECK(ec);
+    TEST_CHECK(ec != GetTestEC());
+  }
 }
 
-TEST_CASE(equivalent_is_other_succeeds)
-{
-    scoped_test_env env;
-    path const file = env.create_file("file", 42);
-    const path hl1 = env.create_hardlink(file, "hl1");
-    const path hl2 = env.create_hardlink(file, "hl2");
-    TEST_CHECK(equivalent(file, hl1));
-    TEST_CHECK(equivalent(file, hl2));
-    TEST_CHECK(equivalent(hl1, hl2));
+TEST_CASE(equivalent_hardlink_succeeds) {
+  scoped_test_env env;
+  path const file = env.create_file("file", 42);
+  const path hl1 = env.create_hardlink(file, "hl1");
+  const path hl2 = env.create_hardlink(file, "hl2");
+  TEST_CHECK(equivalent(file, hl1));
+  TEST_CHECK(equivalent(file, hl2));
+  TEST_CHECK(equivalent(hl1, hl2));
+}
+
+TEST_CASE(equivalent_is_other_succeeds) {
+  scoped_test_env env;
+  path const file = env.create_file("file", 42);
+  const path fifo1 = env.create_fifo("fifo1");
+  const path fifo2 = env.create_fifo("fifo2");
+  // Required to test behavior for inputs where is_other(p) is true.
+  TEST_REQUIRE(is_other(fifo1));
+  TEST_CHECK(!equivalent(file, fifo1));
+  TEST_CHECK(!equivalent(fifo2, file));
+  TEST_CHECK(!equivalent(fifo1, fifo2));
+  TEST_CHECK(equivalent(fifo1, fifo1));
 }
 
 TEST_SUITE_END()
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
index f3b57f6bc9da..5e3ad4d910e7 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
@@ -95,4 +95,22 @@ int main()
         assert((*i2).position() == 0);
         assert((*i2).str() == "555-1234");
     }
+    { // http://llvm.org/PR33681
+        std::regex rex(".*");
+        const char foo[] = "foo";
+    //  The -1 is because we don't want the implicit null from the array.
+        std::cregex_iterator i(std::begin(foo), std::end(foo) - 1, rex);
+        std::cregex_iterator e;
+        assert(i != e);
+        assert((*i).size() == 1);
+        assert((*i).str() == "foo");
+
+        ++i;
+        assert(i != e);
+        assert((*i).size() == 1);
+        assert((*i).str() == "");
+
+        ++i;
+        assert(i == e);
+    }
 }
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
index 984dcdc80b32..212a12084e79 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor2.fail.cpp
@@ -30,5 +30,5 @@ typedef volatile std::packaged_task<A(int, char)> VPT;
 int main()
 {
     PT p { std::allocator_arg_t{}, test_allocator<A>{}, VPT {}}; // expected-error {{no matching constructor for initialization of 'PT' (aka 'packaged_task<A (int, char)>')}}
-    // expected-note@future:* 1 {{candidate template ignored: disabled by 'enable_if'}}
+    // expected-note-re@future:* 1 {{candidate template ignored: {{(disabled by 'enable_if')|(requirement '.*' was not satisfied)}}}}
 }
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
index 253515e3db3c..f2cf9f2d4187 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp
@@ -29,11 +29,12 @@ struct A
 
 int main()
 {
+    globalMemCounter.reset();
     std::allocator<A> a;
     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(A_constructed == 0);
     globalMemCounter.last_new_size = 0;
-    A* ap = a.allocate(3);
+    A* volatile ap = a.allocate(3);
     assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(globalMemCounter.checkLastNewSizeEq(3 * sizeof(int)));
     assert(A_constructed == 0);
@@ -42,7 +43,7 @@ int main()
     assert(A_constructed == 0);
 
     globalMemCounter.last_new_size = 0;
-    A* ap2 = a.allocate(3, (const void*)5);
+    A* volatile ap2 = a.allocate(3, (const void*)5);
     assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(globalMemCounter.checkLastNewSizeEq(3 * sizeof(int)));
     assert(A_constructed == 0);
diff --git a/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
index 3ba261b52464..ed8b433da693 100644
--- a/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
@@ -147,27 +147,27 @@ int main()
     }
     {
         struct ThrowsMove {
-          ThrowsMove() noexcept {}
-          ThrowsMove(ThrowsMove const&) noexcept {}
-          ThrowsMove(ThrowsMove &&) noexcept(false) {}
-          ThrowsMove& operator=(ThrowsMove const&) noexcept { return *this; }
-          ThrowsMove& operator=(ThrowsMove &&) noexcept { return *this; }
+            ThrowsMove() noexcept {}
+            ThrowsMove(ThrowsMove const&) noexcept {}
+            ThrowsMove(ThrowsMove &&) noexcept(false) {}
+            ThrowsMove& operator=(ThrowsMove const&) noexcept { return *this; }
+            ThrowsMove& operator=(ThrowsMove &&) noexcept { return *this; }
         };
         static_assert(!std::is_nothrow_move_assignable<optional<ThrowsMove>>::value, "");
         struct ThrowsMoveAssign {
-          ThrowsMoveAssign() noexcept {}
-          ThrowsMoveAssign(ThrowsMoveAssign const&) noexcept {}
-          ThrowsMoveAssign(ThrowsMoveAssign &&) noexcept {}
-          ThrowsMoveAssign& operator=(ThrowsMoveAssign const&) noexcept { return *this; }
-          ThrowsMoveAssign& operator=(ThrowsMoveAssign &&) noexcept(false) { return *this; }
+            ThrowsMoveAssign() noexcept {}
+            ThrowsMoveAssign(ThrowsMoveAssign const&) noexcept {}
+            ThrowsMoveAssign(ThrowsMoveAssign &&) noexcept {}
+            ThrowsMoveAssign& operator=(ThrowsMoveAssign const&) noexcept { return *this; }
+            ThrowsMoveAssign& operator=(ThrowsMoveAssign &&) noexcept(false) { return *this; }
         };
         static_assert(!std::is_nothrow_move_assignable<optional<ThrowsMoveAssign>>::value, "");
         struct NoThrowMove {
-          NoThrowMove() noexcept(false) {}
-          NoThrowMove(NoThrowMove const&) noexcept(false) {}
-          NoThrowMove(NoThrowMove &&) noexcept {}
-          NoThrowMove& operator=(NoThrowMove const&) noexcept { return *this; }
-          NoThrowMove& operator=(NoThrowMove&&) noexcept { return *this; }
+            NoThrowMove() noexcept(false) {}
+            NoThrowMove(NoThrowMove const&) noexcept(false) {}
+            NoThrowMove(NoThrowMove &&) noexcept {}
+            NoThrowMove& operator=(NoThrowMove const&) noexcept { return *this; }
+            NoThrowMove& operator=(NoThrowMove&&) noexcept { return *this; }
         };
         static_assert(std::is_nothrow_move_assignable<optional<NoThrowMove>>::value, "");
     }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
index 6b4283a2854b..0f1fabd0cebb 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
@@ -45,10 +45,10 @@ constexpr bool constexpr_test(InitArgs&&... args)
 void test_throwing_ctor() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     struct Z {
-      Z() : count(0) {}
-      Z(Z const& o) : count(o.count + 1)
-      { if (count == 2) throw 6; }
-      int count;
+        Z() : count(0) {}
+        Z(Z const& o) : count(o.count + 1)
+        { if (count == 2) throw 6; }
+        int count;
     };
     const Z z;
     const optional<Z> rhs(z);
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
index 55c2156300fb..e73f3747c435 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
@@ -55,10 +55,10 @@ constexpr bool constexpr_test(InitArgs&&... args)
 void test_throwing_ctor() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     struct Z {
-      Z() : count(0) {}
-      Z(Z&& o) : count(o.count + 1)
-      { if (count == 2) throw 6; }
-      int count;
+        Z() : count(0) {}
+        Z(Z&& o) : count(o.count + 1)
+        { if (count == 2) throw 6; }
+        int count;
     };
     Z z;
     optional<Z> rhs(std::move(z));
diff --git a/test/std/utilities/optional/optional.object/special_member_gen.pass.cpp b/test/std/utilities/optional/optional.object/special_member_gen.pass.cpp
index fdd0f154f0e5..0b9b6e717c3a 100644
--- a/test/std/utilities/optional/optional.object/special_member_gen.pass.cpp
+++ b/test/std/utilities/optional/optional.object/special_member_gen.pass.cpp
@@ -33,10 +33,38 @@ struct SpecialMemberTest {
         "optional<T> is copy assignable if and only if T is both copy "
         "constructible and copy assignable.");
     static_assert(std::is_move_assignable_v<O> ==
-        ((std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T>) ||
-         (std::is_move_constructible_v<T> && std::is_move_assignable_v<T>)),
-        "optional<T> is move assignable if and only if T is both move assignable and "
-        "move constructible, or both copy constructible and copy assignable.");
+        ((std::is_move_constructible_v<T> && std::is_move_assignable_v<T>) ||
+         (std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T>)),
+        "optional<T> is move assignable if and only if T is both move constructible and "
+        "move assignable, or both copy constructible and copy assignable.");
+
+    // The following tests are for not-yet-standardized behavior (P0602):
+    static_assert(std::is_trivially_destructible_v<O> ==
+        std::is_trivially_destructible_v<T>,
+        "optional<T> is trivially destructible if and only if T is.");
+    static_assert(std::is_trivially_copy_constructible_v<O> ==
+        std::is_trivially_copy_constructible_v<T>,
+        "optional<T> is trivially copy constructible if and only if T is.");
+    static_assert(std::is_trivially_move_constructible_v<O> ==
+        std::is_trivially_move_constructible_v<T> ||
+        (!std::is_move_constructible_v<T> && std::is_trivially_copy_constructible_v<T>),
+        "optional<T> is trivially move constructible if T is trivially move constructible, "
+        "or if T is trivially copy constructible and is not move constructible.");
+    static_assert(std::is_trivially_copy_assignable_v<O> ==
+        (std::is_trivially_destructible_v<T> &&
+         std::is_trivially_copy_constructible_v<T> &&
+         std::is_trivially_copy_assignable_v<T>),
+        "optional<T> is trivially copy assignable if and only if T is trivially destructible, "
+        "trivially copy constructible, and trivially copy assignable.");
+    static_assert(std::is_trivially_move_assignable_v<O> ==
+        (std::is_trivially_destructible_v<T> &&
+         ((std::is_trivially_move_constructible_v<T> && std::is_trivially_move_assignable_v<T>) ||
+          ((!std::is_move_constructible_v<T> || !std::is_move_assignable_v<T>) &&
+           std::is_trivially_copy_constructible_v<T> && std::is_trivially_copy_assignable_v<T>))),
+        "optional<T> is trivially move assignable if T is trivially destructible, and either "
+        "(1) trivially move constructible and trivially move assignable, or "
+        "(2) not move constructible or not move assignable, and "
+        "trivially copy constructible and trivially copy assignable.");
 };
 
 template <class ...Args> static void sink(Args&&...) {}
diff --git a/utils/libcxx/test/config.py b/utils/libcxx/test/config.py
index 96b3df55ede7..2ee41924fe13 100644
--- a/utils/libcxx/test/config.py
+++ b/utils/libcxx/test/config.py
@@ -440,6 +440,9 @@ class Configuration(object):
             # C++17 aligned allocation.
             self.config.available_features.add('no-aligned-allocation')
 
+        if self.cxx.hasCompileFlag('-fdelayed-template-parsing'):
+            self.config.available_features.add('fdelayed-template-parsing')
+
         if self.get_lit_bool('has_libatomic', False):
             self.config.available_features.add('libatomic')
 
@@ -888,6 +891,7 @@ class Configuration(object):
         self.cxx.addWarningFlagIfSupported('-Wno-c++11-extensions')
         self.cxx.addWarningFlagIfSupported('-Wno-user-defined-literals')
         self.cxx.addWarningFlagIfSupported('-Wno-noexcept-type')
+        self.cxx.addWarningFlagIfSupported('-Wno-aligned-allocation-unavailable')
         # These warnings should be enabled in order to support the MSVC
         # team using the test suite; They enable the warnings below and
         # expect the test suite to be clean.
@@ -1015,6 +1019,7 @@ class Configuration(object):
         cxx_path = pipes.quote(self.cxx.path)
         # Configure compiler substitutions
         sub.append(('%cxx', cxx_path))
+        sub.append(('%libcxx_src_root', self.libcxx_src_root))
         # Configure flags substitutions
         flags_str = ' '.join([pipes.quote(f) for f in self.cxx.flags])
         compile_flags_str = ' '.join([pipes.quote(f) for f in self.cxx.compile_flags])
diff --git a/utils/libcxx/test/target_info.py b/utils/libcxx/test/target_info.py
index b3bbc0088542..e6fde900cf70 100644
--- a/utils/libcxx/test/target_info.py
+++ b/utils/libcxx/test/target_info.py
@@ -169,10 +169,6 @@ class DarwinLocalTI(DefaultTargetInfo):
         # should be available in libc++ directly.
         return False
 
-    def add_sanitizer_features(self, sanitizer_type, features):
-        if sanitizer_type == 'Undefined':
-            features.add('sanitizer-new-delete')
-
 
 class FreeBSDLocalTI(DefaultTargetInfo):
     def __init__(self, full_config):
diff --git a/www/upcoming_meeting.html b/www/upcoming_meeting.html
index c7bd83fb39ca..f1a99fdef2d8 100644
--- a/www/upcoming_meeting.html
+++ b/www/upcoming_meeting.html
@@ -64,7 +64,7 @@
 	<tr><td><a href="http://wg21.link/LWG2597">2597</a></td><td>std::log misspecified for complex numbers</td><td>Toronto</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2783">2783</a></td><td>stack::emplace() and queue::emplace() should return decltype(auto)</td><td>Toronto</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2932">2932</a></td><td>Constraints on parallel algorithm implementations are underspecified</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2937">2937</a></td><td>Is equivalent("existing_thing", "not_existing_thing") an error?</td><td>Toronto</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2937">2937</a></td><td>Is equivalent("existing_thing", "not_existing_thing") an error?</td><td>Toronto</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2940">2940</a></td><td>result_of specification also needs a little cleanup</td><td>Toronto</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2942">2942</a></td><td>LWG 2873's resolution missed weak_ptr::owner_before</td><td>Toronto</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2954">2954</a></td><td>Specialization of the convenience variable templates should be prohibited</td><td>Toronto</td><td></td></tr>
@@ -84,7 +84,7 @@
 <li>2597 - I think we do this already; probably needs tests</li>
 <li>2783 - should be easy to change; needs tests</li>
 <li>2932 - We're not doing the parallel algorithms yet.</li>
-<li>2937 - file system; Eric?</li>
+<li>2937 - Implemented with tests. The PR LGTM (Eric)</li>
 <li>2940 - We haven't implemented result_of yet, but I don't think that this will require any changes.</li>
 <li>2942 - all of our owner_before overloads are already noexcept; just need to update the tests.</li>
 <li>2954 - I don't think there's anything to do here.</li>