[libc++] Implement exception_ptr on Windows

[EricWF]

Summary

This patch implements exception_ptr on Windows using the __ExceptionPtrFoo functions provided by MSVC.

The __ExceptionPtrFoo functions are defined inside the C++ standard library, msvcprt, which is unfortunate because it requires libc++ to link to the MSVC STL. However this doesn't seem to cause any immediate problems. However to be safe I kept all usages within the libc++ dylib so that user programs wouldn't have to link to MSVCPRT as well.

Note there are still 2 outstanding exception_ptr/nested_exception test failures.

• current_exception.pass.cpp needs to be rewritten for the Windows exception_ptr semantics which copy the exception every time.
• rethrow_if_nested.pass.cpp need investigation. It hits a stack overflow, likely from recursion.

This patch also gets most of the <future> tests passing as well.

[BillyONeal]

include/exception

192 ↗

(On Diff #98039)

I hope you realize you are doing "evil" unsupported things :). (We won't go out of our way to break this, but if it does break we won't feel bad :P )

test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp

12 ↗

(On Diff #98039)

FWIW it does not pass for our implementation either.

Note that unlike the Itanium ABI, the stack is not popped back to the catch block when handling an exception (because SEH can act like a signal handler and say EXCEPTION_CONTINUE_EXECUTION).

test/std/language.support/support.exception/propagation/current_exception.pass.cpp

10–11 ↗

(On Diff #98039)

We don't copy the exception each time the exception_ptr is copied -- exception_ptr models shared_ptr. See: "C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.10.25017\crt\src\stl\excptptr.cpp"

We do make a copy when making the initial exception_ptr.

[STL_MSFT]

include/exception

192 ↗

(On Diff #98039)

More specifically, while this will work with MSVC 2015/2017's msvcp140.dll, we've changed exception_ptr's separately compiled component in the next major binary-incompatible version of our STL.

[EricWF]

include/exception

192 ↗

(On Diff #98039)

I'm well aware I'm being a bad boy, but I need to mimic the Microsoft ABI. Obviously I expect nothing less than breakage and pain.

separately compiled component in the next major binary-incompatible version of our STL.

I'll have to cross that bridge when I come to it. Hopefully I can still make libc++ work *somehow*.
Maybe the exception_ptr internals will live outside of the STL libraries next release too :-)

test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp

12 ↗

(On Diff #98039)

Thanks for pointing that out! Otherwise I may have gone down a rabbit hole trying to figure it out.

test/std/language.support/support.exception/propagation/current_exception.pass.cpp

10–11 ↗

(On Diff #98039)

Ah thanks for the clarification. So std::current_exception() always returns a different copy.

[EricWF]

I think the medium to long term goal should be to replace the __ExceptionPtrFoo functions we use with our own implementation, so we no longer rely on these MSVC implementation details.

However it appears that we don't have access to the internal headers that we might need, such as ehdata.h

test/std/language.support/support.exception/propagation/current_exception.pass.cpp

10–11 ↗

(On Diff #98039)

exception_ptr models shared_ptr.

Oh fudge me, it not only models it but it actually uses MSVC's shared_ptr implementation. This seems so much sketchier now.

[bcraig]

test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp

12 ↗

(On Diff #98039)

Also means that MSABI doesn't need to allocate heap memory in a failure case. That always bugged me about the Itanium ABI. In "the real world", I don't know if stack overflows are any better, but at least, in theory, maximum stack usage could be calculated by a determined enough programmer.

test/std/language.support/support.exception/propagation/current_exception.pass.cpp

10–11 ↗

(On Diff #98039)

You may want to pursue your long term plan instead.

Rather than use the msvcprt functions, dig into the underlying SEH structures, find the pointer to the exception, and work from there.

Headers in the older crt source have a lot of useful information, and that may be useful enough to get things going.

The blog mentions where to fine one of those useful headers (ehdata.h):
http://workblog.pilin.name/2014/03/decoding-parameters-of-thrown-c.html
"Welcome - ehdata.h. This header appears only in VS2012 and VS2013 (see "%Program Files (x86)%\Microsoft Visual Studio 12.0\VC\crt\src\ehdata.h"):"

The other useful header is mtdll.h. I found it in my local msvc 9.0 install, but didn't find it in my msvc-14.0 install. I don't have 10.0, 11.0, or 12.0 installed locally right now to see if mtdll.h is present in any of those. mtdll.h describes the layout of _tiddata, a thread local data store for the CRT. The interesting fields there are void *_curexception; and void *_curcontext;.

[EricWF]

test/std/language.support/support.exception/propagation/current_exception.pass.cpp

10–11 ↗

(On Diff #98039)

You may want to pursue your long term plan instead.

I don't think this should block this initial progress. Libc++ has a history of linking to libstdc++ without major problems. This should be OK too, although I still don't love doing it.

[bcraig]

libstdc++ and the Visual Studio C++ runtime have very different compatibility expectations.

libstdc++ is generally bundled with the operating system. It maintains binary compatibility over very long stretches of time. In most systems, there can only be one libstdc++ loaded in a process at a time. Throwing a std::exception in one shared library and catching it in another generally works, even if the two libraries were built with different compilers. So pretty similar to libc++ on Mac. This is almost certainly not news to you.

The Visual Studio C++ runtime is not bundled with the operating system. It generally does not maintain binary compatibility over more than a major release. Having multiple versions of the Visual Studio C++ runtime loaded in the same process is pretty common. Throwing a std::exception in one DLL and catching it in another will generally won't work if the two libraries were built with different compilers.

When you code against libstdc++ internals, your code will likely last 5+ years before it breaks, and when it breaks it would likely be considered a bug. When you code against Visual Studio C++ internals, your code has a shelf life of 1-3 years, and then the code has a high probability of breaking.

I think the seh internals are more stable than the ExceptionPtr helper functions. One thing that works reasonably well is throwing an exception that doesn't derive from a CRT type in one DLL, and then catching it in another, even with different compiler versions. "catch(...)" also works reasonably well across DLL / compiler version boundaries.

Is there a particular reason to go with a shorter term solution now, rather than straight to the long term solution? Is there a deadline or a particular milestone we are trying to hit for clang-cl support? Or is there a suspicion that future changes will make a really good implementation possible, incentivizing us to do something inexpensive for now?

[EricWF]

In D32927#748119, @bcraig wrote:

libstdc++ and the Visual Studio C++ runtime have very different compatibility expectations.

I only meant to imply that linking to another standard library implementation hasn't caused major issues
in the past.

Is there a particular reason to go with a shorter term solution now, rather than straight to the long term solution? Is there a deadline or a particular milestone we are trying to hit for clang-cl support? Or is there a suspicion that future changes will make a really good implementation possible, incentivizing us to do something inexpensive for now?

My main desire is to get the test suite green so we can start detecting regressions. This patch reduces the remaining test failures by half, and although not future proof, it is correct at the moment.
Plus I would really prefer writing the more complex implementation against a set of tests that are already passing.

I also think this patch is a step in the right direction, regardless of the final implementation. The bulk of this patch is just boilerplate, setting up the correct declarations and definitions for implementing exception_ptr targeting Microsoft's ABI as opposed to Itanium.
It would be nice to commit these changes apart from the future implementation, and this seems like an OK way to do that.

@bcraig Since this patch doesn't preclude improvements in the future are you OK to move forward with it? I agree this shouldn't be exception_ptr's final form, and I plan to continue working on the suggested implementation, but I don't want to block other Windows
progress while this is ongoing (and that's what having an un-implemented exception_ptr is doing).

[bcraig]

Getting the test suite green sooner rather than later seems like a good reason to temporarily pick a 1-3 year solution rather than a 5+ year solution. Also, as you mention, this isn't all throw away work, so it's still progress.

So yeah, this is fine to go in as is. LGTM.

[EricWF]

• Remove some missed XFAILS

libcxx/trunk/include/exception

 _LIBCPP_FUNC_VIS bool uncaught_exception() _NOEXCEPT;
 _LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS int uncaught_exceptions() _NOEXCEPT;
 
 class _LIBCPP_TYPE_VIS exception_ptr;
 
 _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
 
+#ifndef _LIBCPP_ABI_MICROSOFT
+
 class _LIBCPP_TYPE_VIS exception_ptr
 {
     void* __ptr_;
 public:
     _LIBCPP_INLINE_VISIBILITY exception_ptr() _NOEXCEPT : __ptr_() {}
     _LIBCPP_INLINE_VISIBILITY exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}
+
     exception_ptr(const exception_ptr&) _NOEXCEPT;
     exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
     ~exception_ptr() _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_EXPLICIT
-        operator bool() const _NOEXCEPT {return __ptr_ != nullptr;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT
+    {return __ptr_ != nullptr;}
 
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
         {return __x.__ptr_ == __y.__ptr_;}
+
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
         {return !(__x == __y);}
 
     friend _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
     friend _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
 };
 
catch (...)
         return current_exception();
     }
 #else
     ((void)__e);
     _VSTD::abort();
 #endif
 }
 
+#else // _LIBCPP_ABI_MICROSOFT
+
+class _LIBCPP_TYPE_VIS exception_ptr
+{
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+#endif
+    void* __ptr1_;
+    void* __ptr2_;
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+public:
+    exception_ptr() _NOEXCEPT;
+    exception_ptr(nullptr_t) _NOEXCEPT;
+    exception_ptr(const exception_ptr& __other) _NOEXCEPT;
+    exception_ptr& operator=(const exception_ptr& __other) _NOEXCEPT;
+    exception_ptr& operator=(nullptr_t) _NOEXCEPT;
+    ~exception_ptr() _NOEXCEPT;
+    _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT;
+};
+
+_LIBCPP_FUNC_VIS
+bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT;
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
+    {return !(__x == __y);}
+
+_LIBCPP_FUNC_VIS void swap(exception_ptr&, exception_ptr&) _NOEXCEPT;
+
+_LIBCPP_FUNC_VIS exception_ptr __copy_exception_ptr(void *__except, const void* __ptr);
+_LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
+_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr p);
+
+// This is a built-in template function which automagically extracts the required
+// information.
+template <class _E> void *__GetExceptionInfo(_E);
+
+template<class _Ep>
+exception_ptr
+make_exception_ptr(_Ep __e) _NOEXCEPT
+{
+  return __copy_exception_ptr(_VSTD::addressof(__e), __GetExceptionInfo(__e));
+}
+
+#endif // _LIBCPP_ABI_MICROSOFT
 // nested_exception
 
 class _LIBCPP_EXCEPTION_ABI nested_exception
 {
     exception_ptr __ptr_;
 public:
     nested_exception() _NOEXCEPT;
 //     nested_exception(const nested_exception&) noexcept = default;

libcxx/trunk/lib/CMakeLists.txt

else()
     set(LIB_SUFFIX "")
   endif()
   add_compile_flags(/Zl)
   add_link_flags(/nodefaultlib)
 
   add_library_flags(ucrt${LIB_SUFFIX}) # Universal C runtime
   add_library_flags(vcruntime${LIB_SUFFIX}) # C++ runtime
   add_library_flags(msvcrt${LIB_SUFFIX}) # C runtime startup files
+  add_library_flags(msvcprt${LIB_SUFFIX}) # C++ standard library. Required for exception_ptr internals.
   # Required for standards-complaint wide character formatting functions
   # (e.g. `printfw`/`scanfw`)
   add_library_flags(iso_stdio_wide_specifiers)
 endif()
 
 if (LIBCXX_OSX_REEXPORT_SYSTEM_ABI_LIBRARY)
   if (NOT DEFINED LIBCXX_LIBCPPABI_VERSION)
     set(LIBCXX_LIBCPPABI_VERSION "2") # Default value

libcxx/trunk/src/exception.cpp

#if defined(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI) || \
   (defined(__APPLE__) && !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY))
   #include <cxxabi.h>
   using namespace __cxxabiv1;
   #define HAVE_DEPENDENT_EH_ABI 1
 #endif
 
 #if defined(_LIBCPP_ABI_MICROSOFT)
 #include "support/runtime/exception_msvc.ipp"
-#include "support/runtime/exception_pointer_unimplemented.ipp"
+#include "support/runtime/exception_pointer_msvc.ipp"
 #elif defined(_LIBCPPABI_VERSION)
 #include "support/runtime/exception_libcxxabi.ipp"
 #include "support/runtime/exception_pointer_cxxabi.ipp"
 #elif defined(LIBCXXRT)
 #include "support/runtime/exception_libcxxrt.ipp"
 #include "support/runtime/exception_pointer_cxxabi.ipp"
 #elif defined(__GLIBCXX__)
 #include "support/runtime/exception_glibcxx.ipp"
 #include "support/runtime/exception_pointer_glibcxx.ipp"
 #else
 #include "support/runtime/exception_fallback.ipp"
 #include "support/runtime/exception_pointer_unimplemented.ipp"
 #endif

libcxx/trunk/src/support/runtime/exception_pointer_msvc.ipp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCreate(_Out_ void*);
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrDestroy(_Inout_ void*);
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopy(_Out_ void*,
+                                                              _In_ const void*);
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
+__ExceptionPtrAssign(_Inout_ void*, _In_ const void*);
+_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL
+__ExceptionPtrCompare(_In_ const void*, _In_ const void*);
+_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL
+__ExceptionPtrToBool(_In_ const void*);
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrSwap(_Inout_ void*,
+                                                              _Inout_ void*);
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
+__ExceptionPtrCurrentException(_Out_ void*);
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
+__ExceptionPtrRethrow(_In_ const void*);
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
+__ExceptionPtrCopyException(_Inout_ void*, _In_ const void*, _In_ const void*);
+
+namespace std {
+
+exception_ptr::exception_ptr() _NOEXCEPT { __ExceptionPtrCreate(this); }
+exception_ptr::exception_ptr(nullptr_t) _NOEXCEPT { __ExceptionPtrCreate(this); }
+
+exception_ptr::exception_ptr(const exception_ptr& __other) _NOEXCEPT {
+  __ExceptionPtrCopy(this, &__other);
+}
+exception_ptr& exception_ptr::operator=(const exception_ptr& __other) _NOEXCEPT {
+  __ExceptionPtrAssign(this, &__other);
+  return *this;
+}
+
+exception_ptr& exception_ptr::operator=(nullptr_t) _NOEXCEPT {
+  exception_ptr dummy;
+  __ExceptionPtrAssign(this, &dummy);
+  return *this;
+}
+
+exception_ptr::~exception_ptr() _NOEXCEPT { __ExceptionPtrDestroy(this); }
+
+exception_ptr::operator bool() const _NOEXCEPT {
+  return __ExceptionPtrToBool(this);
+}
+
+bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT {
+  return __ExceptionPtrCompare(&__x, &__y);
+}
+
+
+void swap(exception_ptr& lhs, exception_ptr& rhs) _NOEXCEPT {
+  __ExceptionPtrSwap(&rhs, &lhs);
+}
+
+exception_ptr __copy_exception_ptr(void* __except, const void* __ptr) {
+  exception_ptr __ret = nullptr;
+  if (__ptr)
+    __ExceptionPtrCopyException(&__ret, __except, __ptr);
+  return __ret;
+}
+
+exception_ptr current_exception() _NOEXCEPT {
+  exception_ptr __ret;
+  __ExceptionPtrCurrentException(&__ret);
+  return __ret;
+}
+
+_LIBCPP_NORETURN
+void rethrow_exception(exception_ptr p) { __ExceptionPtrRethrow(&p); }
+
+nested_exception::nested_exception() _NOEXCEPT : __ptr_(current_exception()) {}
+
+nested_exception::~nested_exception() _NOEXCEPT {}
+
+_LIBCPP_NORETURN
+void nested_exception::rethrow_nested() const {
+  if (__ptr_ == nullptr)
+    terminate();
+  rethrow_exception(__ptr_);
+}
+
+} // namespace std

libcxx/trunk/test/libcxx/thread/futures/futures.promise/set_exception.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
-//
-
-// This test depends on std::exception_ptr which has not yet been implemented.
-// XFAIL: LIBCXX-WINDOWS-FIXME
 
 // UNSUPPORTED: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
 
 // class promise<R>

libcxx/trunk/test/libcxx/thread/futures/futures.promise/set_exception_at_thread_exit.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
-// This test depends on std::exception_ptr which has not yet been implemented.
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // UNSUPPORTED: libcpp-no-exceptions
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
 
 // <future>
 
 // class promise<R>
 

libcxx/trunk/test/std/language.support/support.exception/except.nested/assign.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
-// exception_ptr has not been implemented on Windows
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <exception>
 
 // class nested_exception;
 
 // nested_exception& operator=(const nested_exception&) throw() = default;
 
 #include <exception>
 #include <cassert>

libcxx/trunk/test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
-// exception_ptr has not been implemented on Windows
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <exception>
 
 // class nested_exception;
 
 // nested_exception(const nested_exception&) throw() = default;
 
 #include <exception>
 #include <cassert>

libcxx/trunk/test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
-// exception_ptr has not been implemented on Windows
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <exception>
 
 // class nested_exception;
 
 // nested_exception() throw();
 
 #include <exception>
 #include <cassert>

libcxx/trunk/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
-// exception_ptr has not been implemented on Windows
+// UNSUPPORTED: libcpp-no-exceptions
+
+// This test fails due to a stack overflow
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
-// UNSUPPORTED: libcpp-no-exceptions
 // <exception>
 
 // class nested_exception;
 
 // template <class E> void rethrow_if_nested(const E& e);
 
 #include <exception>
 #include <cstdlib>

libcxx/trunk/test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
-// exception_ptr has not been implemented on Windows
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // UNSUPPORTED: libcpp-no-exceptions
 // <exception>
 
 // class nested_exception;
 
 // void rethrow_nested [[noreturn]] () const;
 
 #include <exception>

libcxx/trunk/test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
-// exception_ptr has not been implemented on Windows
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // UNSUPPORTED: libcpp-no-exceptions
 // <exception>
 
 // class nested_exception;
 
 // template<class T> void throw_with_nested [[noreturn]] (T&& t);
 
 #include <exception>

libcxx/trunk/test/std/language.support/support.exception/propagation/current_exception.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
-// exception_ptr has not been implemented on Windows
+// This test needs to be rewritten for the Windows exception_ptr semantics
+// which copy the exception each time the exception_ptr is copied.
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
 // UNSUPPORTED: libcpp-no-exceptions
 // <exception>
 
 // exception_ptr current_exception();
 
 #include <exception>

libcxx/trunk/test/std/language.support/support.exception/propagation/exception_ptr.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
-// exception_ptr has not been implemented on Windows
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <exception>
 
 // typedef unspecified exception_ptr;
 
 // exception_ptr shall satisfy the requirements of NullablePointer.
 
 #include <exception>
 #include <cassert>

libcxx/trunk/test/std/language.support/support.exception/propagation/make_exception_ptr.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
-// exception_ptr has not been implemented on Windows
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // UNSUPPORTED: libcpp-no-exceptions
 // <exception>
 
 // template<class E> exception_ptr make_exception_ptr(E e);
 
 #include <exception>
 #include <cassert>
 
int main()
         std::exception_ptr p = std::make_exception_ptr(A(5));
         try
         {
             std::rethrow_exception(p);
             assert(false);
         }
         catch (const A& a)
         {
+#ifndef _LIBCPP_ABI_MICROSOFT
             assert(A::constructed == 1);
+#else
+            // On Windows exception_ptr copies the exception
+            assert(A::constructed == 2);
+#endif
             assert(p != nullptr);
             p = nullptr;
             assert(p == nullptr);
             assert(a.data_ == 5);
             assert(A::constructed == 1);
         }
         assert(A::constructed == 0);
     }
+    assert(A::constructed == 0);
 }

libcxx/trunk/test/std/language.support/support.exception/propagation/rethrow_exception.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
-// exception_ptr has not been implemented on Windows
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // UNSUPPORTED: libcpp-no-exceptions
 // <exception>
 
 // void rethrow_exception [[noreturn]] (exception_ptr p);
 
 #include <exception>
 #include <cassert>
 
int main()
         }
         try
         {
             std::rethrow_exception(p);
             assert(false);
         }
         catch (const A& a)
         {
+#ifndef _LIBCPP_ABI_MICROSOFT
             assert(A::constructed == 1);
+#else
+            // On Windows the exception_ptr copies the exception
+            assert(A::constructed == 2);
+#endif
             assert(p != nullptr);
             p = nullptr;
             assert(p == nullptr);
             assert(a.data_ == 3);
             assert(A::constructed == 1);
         }
         assert(A::constructed == 0);
     }
+    assert(A::constructed == 0);
 }