[libcxx] unexpected/terminate support for MS CRT

[K-ballo]

Summary

MS CRT provides implementation of those handler functions, defer to them.

[K-ballo]

test/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp

32

This assertion does not hold for MSVCRT, as a null handler represents the default behavior. Would it be better to make this check conditionally instead of marking the whole test as failed?

40

This does not hold for MSVCRT either. Assuming the previous assertion is skipped for it, this could be tested by setting the unexpected handler to its original value and calling unexpected().

[mclow.lists]

This looks OK to me.
Ugly, but OK.

test/depr/exception.unexpected/set.unexpected/get_unexpected.pass.cpp

32

I believe that this check is incorrect.
Section D.8.3 says of get_unexpected:
Returns: The current unexpected_handler. [ Note: This may be a null pointer value. — end note ]

40

Yes, I think that's better.

[K-ballo]

Waiting for VS2015RTM

[andrew.j.c.parker]

You will also need to change the test:

test/depr/exception.unexpected/set.unexpected/set_unexpected.pass.cpp

as it makes similar assumptions about an initial non-null handler.

src/exception.cpp

#ifdef __APPLE__
   #ifndef _LIBCPPABI_VERSION
     using namespace __cxxabiapple;
     // On Darwin, there are two STL shared libraries and a lower level ABI
     // shared library.  The globals holding the current terminate handler and
     // current unexpected handler are in the ABI library.
     #define __terminate_handler  __cxxabiapple::__cxa_terminate_handler
     #define __unexpected_handler __cxxabiapple::__cxa_unexpected_handler
   #endif  // _LIBCPPABI_VERSION
+#elif defined(_LIBCPP_MSVCRT)
+  #include <eh.h>
 #elif defined(LIBCXXRT) || __has_include(<cxxabi.h>)
   #include <cxxabi.h>
   using namespace __cxxabiv1;
   #if defined(LIBCXXRT) || defined(_LIBCPPABI_VERSION)
     #define HAVE_DEPENDENT_EH_ABI 1
   #endif
 #elif !defined(__GLIBCXX__) // __has_include(<cxxabi.h>)
   static std::terminate_handler  __terminate_handler;
   static std::unexpected_handler __unexpected_handler;
 #endif // __has_include(<cxxabi.h>)
 
 namespace std
 {
 
 #if !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__)
 
 // libcxxrt provides implementations of these functions itself.
 unexpected_handler
 set_unexpected(unexpected_handler func) _NOEXCEPT
 {
+#ifndef _LIBCPP_MSVCRT
     return __sync_lock_test_and_set(&__unexpected_handler, func);
+#else
+    return ::set_unexpected(func);
+#endif  // !_LIBCPP_MSVCRT
 }
 
 unexpected_handler
 get_unexpected() _NOEXCEPT
 {
+#ifndef _LIBCPP_MSVCRT
     return __sync_fetch_and_add(&__unexpected_handler, (unexpected_handler)0);
+#else
+    return ::_get_unexpected();
+#endif  // !_LIBCPP_MSVCRT
 }
 
 _LIBCPP_NORETURN
 void
 unexpected()
 {
+#ifndef _LIBCPP_MSVCRT
     (*get_unexpected())();
     // unexpected handler should not return
     terminate();
+#else
+    return ::unexpected();
+#endif  // !_LIBCPP_MSVCRT
 }
 
 terminate_handler
 set_terminate(terminate_handler func) _NOEXCEPT
 {
+#ifndef _LIBCPP_MSVCRT
     return __sync_lock_test_and_set(&__terminate_handler, func);
+#else
+    return ::set_terminate(func);
+#endif  // !_LIBCPP_MSVCRT
 }
 
 terminate_handler
 get_terminate() _NOEXCEPT
 {
+#ifndef _LIBCPP_MSVCRT
     return __sync_fetch_and_add(&__terminate_handler, (terminate_handler)0);
+#else
+    return ::_get_terminate();
+#endif  // !_LIBCPP_MSVCRT
 }
 
 #ifndef __EMSCRIPTEN__ // We provide this in JS
 _LIBCPP_NORETURN
 void
 terminate() _NOEXCEPT
 {
+#ifndef _LIBCPP_MSVCRT
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         (*get_terminate())();
         // handler should not return
         printf("terminate_handler unexpectedly returned\n");
         ::abort();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         // handler should not throw exception
         printf("terminate_handler unexpectedly threw an exception\n");
         ::abort();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
+#else
+    return ::terminate();
+#endif  // !_LIBCPP_MSVCRT
 }
 #endif // !__EMSCRIPTEN__
-#endif // !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION)
+#endif // !defined(LIBCXXRT) && !defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__)
 
 #if !defined(LIBCXXRT) && !defined(__GLIBCXX__) && !defined(__EMSCRIPTEN__)
 bool uncaught_exception() _NOEXCEPT
 {
 #if defined(__APPLE__) || defined(_LIBCPPABI_VERSION)
     // on Darwin, there is a helper function so __cxa_get_globals is private
     return __cxa_uncaught_exception();
-#else  // __APPLE__
+#elif defined(_LIBCPP_MSVCRT)
+    return ::__uncaught_exception();
+#else
 #   if defined(_MSC_VER) && ! defined(__clang__)
         _LIBCPP_WARNING("uncaught_exception not yet implemented")
 #   else
 #       warning uncaught_exception not yet implemented
 #   endif
     printf("uncaught_exception not yet implemented\n");
     ::abort();
 #endif  // __APPLE__
 }
 
 
 #ifndef _LIBCPPABI_VERSION
 
 exception::~exception() _NOEXCEPT
 {
 }
 
 const char* exception::what() const _NOEXCEPT
 {
   return "std::exception";
 }
 
 #endif  // _LIBCPPABI_VERSION
-#endif //LIBCXXRT
+#endif // !defined(LIBCXXRT) && !defined(__GLIBCXX__) && !defined(__EMSCRIPTEN__)
 #if !defined(_LIBCPPABI_VERSION) && !defined(__GLIBCXX__)
 
 bad_exception::~bad_exception() _NOEXCEPT
 {
 }
 
 const char* bad_exception::what() const _NOEXCEPT
 {

test/depr/exception.unexpected/set.unexpected/get_unexpected.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.
 //
 //===----------------------------------------------------------------------===//
 
+// msvcrt default unexpected handler is null
+// XFAIL: win32
+
 // test get_unexpected
 
 #include <exception>
 #include <cassert>
 #include <cstdlib>
 
 void f1() {}
 void f2() {}
 
 void f3()
 {
     std::exit(0);
 }
 
 int main()
 {
     
     std::unexpected_handler old = std::get_unexpected();
     // verify there is a previous unexpected handler
     assert(old);
     std::set_unexpected(f1);
     assert(std::get_unexpected() == f1);
     // verify f1 was replace with f2
     std::set_unexpected(f2);
     assert(std::get_unexpected() == f2);
     // verify calling original unexpected handler calls terminate
     std::set_terminate(f3);
     (*old)();
     assert(0);
 }